more AB sync

9 files changed, 141 insertions, 57 deletions

diff --git a/kabc/addressee.cpp b/kabc/addressee.cpp
index 3a2dc5f..fda62f1 100644
--- a/kabc/addressee.cpp
+++ b/kabc/addressee.cpp
@@ -1,1143 +1,1156 @@
 /*** Warning! This file has been generated by the script makeaddressee ***/
 /*
     This file is part of libkabc.
     Copyright (c) 2001 Cornelius Schumacher <schumacher@kde.org>
 
     This library is free software; you can redistribute it and/or
     modify it under the terms of the GNU Library General Public
     License as published by the Free Software Foundation; either
     version 2 of the License, or (at your option) any later version.
 
     This library is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
     Library General Public License for more details.
 
     You should have received a copy of the GNU Library General Public License
     along with this library; see the file COPYING.LIB.  If not, write to
     the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
     Boston, MA 02111-1307, USA.
 */
 
 /*
 Enhanced Version of the file for platform independent KDE tools.
 Copyright (c) 2004 Ulf Schenk
 
 $Id$
 */
 
 #include <kconfig.h>
 
 #include <ksharedptr.h>
 #include <kdebug.h>
 #include <kapplication.h>
 #include <klocale.h>
 #include <kidmanager.h>
 //US
 #include <kstandarddirs.h>
 #include <libkcal/syncdefines.h>
 
 //US #include "resource.h"
 #include "addressee.h"
 
 using namespace KABC;
 
 static bool matchBinaryPattern( int value, int pattern );
 
 struct Addressee::AddresseeData : public KShared
 {
   QString uid;
   QString name;
   QString formattedName;
   QString familyName;
   QString givenName;
   QString additionalName;
   QString prefix;
   QString suffix;
   QString nickName;
   QDateTime birthday;
   QString mailer;
   TimeZone timeZone;
   Geo geo;
   QString title;
   QString role;
   QString organization;
   QString note;
   QString productId;
   QDateTime revision;
   QString sortString;
   QString externalUID;
+  QString originalExternalUID;
   KURL url;
   Secrecy secrecy;
   Picture logo;
   Picture photo;
   Sound sound;
   Agent agent;
   QString mExternalId;
   PhoneNumber::List phoneNumbers;
   Address::List addresses;
   Key::List keys;
   QStringList emails;
   QStringList categories;
   QStringList custom;
   int mTempSyncStat;
   Resource *resource;
 
   bool empty    :1;
   bool changed  :1;
 };
 
 Addressee::Addressee()
 {
   mData = new AddresseeData;
   mData->empty = true;
   mData->changed = false;
   mData->resource = 0;
   mData->mExternalId = ":";
   mData->revision = QDateTime ( QDate( 2004,1,1));
   mData->mTempSyncStat =  SYNC_TEMPSTATE_INITIAL;
 }
 
 Addressee::~Addressee()
 {
 }
 
 Addressee::Addressee( const Addressee &a )
 {
   mData = a.mData;
 }
 
 Addressee &Addressee::operator=( const Addressee &a )
 {
   mData = a.mData;
   return (*this);
 }
 
 Addressee Addressee::copy()
 {
   Addressee a;
   *(a.mData) = *mData;
   return a;
 }
 
 void Addressee::detach()
 {
   if ( mData.count() == 1 ) return;
   *this = copy();
 }
 
 bool Addressee::operator==( const Addressee &a ) const
 {
   if ( uid() != a.uid() ) return false;
   if ( mData->name != a.mData->name ) return false;
   if ( mData->formattedName != a.mData->formattedName ) return false;
   if ( mData->familyName != a.mData->familyName ) return false;
   if ( mData->givenName != a.mData->givenName ) return false;
   if ( mData->additionalName != a.mData->additionalName ) return false;
   if ( mData->prefix != a.mData->prefix ) return false;
   if ( mData->suffix != a.mData->suffix ) return false;
   if ( mData->nickName != a.mData->nickName ) return false;
   if ( mData->birthday != a.mData->birthday ) return false;
   if ( mData->mailer != a.mData->mailer ) return false;
   if ( mData->timeZone != a.mData->timeZone ) return false;
   if ( mData->geo != a.mData->geo ) return false;
   if ( mData->title != a.mData->title ) return false;
   if ( mData->role != a.mData->role ) return false;
   if ( mData->organization != a.mData->organization ) return false;
   if ( mData->note != a.mData->note ) return false;
   if ( mData->productId != a.mData->productId ) return false;
   //if ( mData->revision != a.mData->revision ) return false;
   if ( mData->sortString != a.mData->sortString ) return false;
   if ( mData->secrecy != a.mData->secrecy ) return false;
   if ( mData->logo != a.mData->logo ) return false;
   if ( mData->photo != a.mData->photo ) return false;
   if ( mData->sound != a.mData->sound ) return false;
   if ( mData->agent != a.mData->agent ) return false;
   if ( ( mData->url.isValid() || a.mData->url.isValid() ) &&
        ( mData->url != a.mData->url ) ) return false;
   if ( mData->phoneNumbers != a.mData->phoneNumbers ) return false;
   if ( mData->addresses != a.mData->addresses ) return false;
   if ( mData->keys != a.mData->keys ) return false;
   if ( mData->emails != a.mData->emails ) return false;
   if ( mData->categories != a.mData->categories ) return false;
   if ( mData->custom != a.mData->custom ) return false;
 
   return true;
 }
 
 bool Addressee::operator!=( const Addressee &a ) const
 {
   return !( a == *this );
 }
 
 bool Addressee::isEmpty() const
 {
   return mData->empty;
 }
 ulong  Addressee::getCsum4List( const QStringList &  attList)
 {
     int max = attList.count();
     ulong cSum = 0;
     int j,k,i;
     int add;
     for ( i = 0; i < max ; ++i ) {
         QString s = attList[i];
         if ( ! s.isEmpty() ){
             j = s.length();
             for ( k = 0; k < j; ++k ) {
                 int mul = k +1;
                 add = s[k].unicode ();
                 if ( k < 16 )
                     mul = mul * mul;
                 int ii = i+1;
                 add = add * mul *ii*ii*ii;
                 cSum += add;
             }
         }
             
     }
     //QString dump = attList.join(",");
     //qDebug("csum: %d %s", cSum,dump.latin1()); 
     
     return cSum;
 
 }
 void Addressee::computeCsum(const QString &dev)
 {
     QStringList l;
     if ( !mData->name.isEmpty() ) l.append(mData->name);
     if ( !mData->formattedName.isEmpty() ) l.append(mData->formattedName  );
     if ( !mData->familyName.isEmpty()  ) l.append( mData->familyName );
     if ( !mData->givenName.isEmpty() ) l.append(mData->givenName  );
     if ( !mData->additionalName  ) l.append( mData->additionalName );
     if ( !mData->prefix.isEmpty()  ) l.append( mData->prefix );
     if ( !mData->suffix.isEmpty()  ) l.append( mData->suffix );
     if ( !mData->nickName.isEmpty()  ) l.append( mData->nickName );
     if ( mData->birthday.isValid()  ) l.append( mData->birthday.toString() );
     if ( !mData->mailer.isEmpty() ) l.append( mData->mailer );
     if ( mData->timeZone.isValid() ) l.append( mData->timeZone.asString() );
     if ( mData->geo.isValid() ) l.append( mData->geo.asString() );
     if ( !mData->title .isEmpty() ) l.append( mData->title );
     if ( !mData->role.isEmpty() ) l.append( mData->role );
     if ( !mData->organization.isEmpty() ) l.append( mData->organization ); 
     if ( !mData->note.isEmpty() ) l.append( mData->note ); 
     if ( !mData->productId.isEmpty() ) l.append(mData->productId ); 
     if ( !mData->sortString.isEmpty() ) l.append( mData->sortString ); 
     if ( mData->secrecy.isValid() ) l.append( mData->secrecy.asString()); 
     // if ( !mData->logo.isEmpty() ) l.append(  ); 
     //if ( !mData->photo.isEmpty() ) l.append(  );
     //if ( !mData->sound.isEmpty() ) l.append(  );
     //if ( !mData->agent.isEmpty() ) l.append(  ); 
     //if (  mData->url.isValid() ) l.append(  ); 
 #if 0
     if ( !mData->phoneNumbers.isEmpty() ) l.append(  ); 
     if ( !mData->addresses.isEmpty() ) l.append(  );
     //if ( !mData->keys.isEmpty() ) l.append(  );
     if ( !mData->emails.isEmpty() ) l.append(  ); 
     if ( !mData->categories .isEmpty() ) l.append(  );
     if ( !mData->custom.isEmpty() ) l.append(  );
 #endif
     KABC::PhoneNumber::List phoneNumbers;
     KABC::PhoneNumber::List::Iterator phoneIter;
 
     QStringList t;
     for ( phoneIter = mData->phoneNumbers.begin(); phoneIter != mData->phoneNumbers.end();
           ++phoneIter )
         t.append( ( *phoneIter ).number()+QString::number( ( *phoneIter ).type() ) );
     t.sort();
     uint iii;
     for ( iii = 0; iii < t.count(); ++iii)
         l.append( t[iii]  );
     t = mData->emails;
     t.sort();
     for ( iii = 0; iii < t.count(); ++iii)
         l.append( t[iii]  );
     t = mData->categories;
     t.sort();
     for ( iii = 0; iii < t.count(); ++iii)
         l.append( t[iii]  );
     t = mData->custom;
     t.sort();
     for ( iii = 0; iii < t.count(); ++iii)
         l.append( t[iii]  );
     KABC::Address::List::Iterator addressIter;
     for ( addressIter = mData->addresses.begin(); addressIter != mData->addresses.end();
           ++addressIter ) {
         t = (*addressIter).asList();
         t.sort();
         for ( iii = 0; iii < t.count(); ++iii)
             l.append( t[iii]  );
     }
     uint cs = getCsum4List(l);
     // qDebug("CSUM computed %d %s %s", cs,QString::number (cs ).latin1(), uid().latin1() );
     setCsum( dev, QString::number (cs ));
 }
 
 void Addressee::mergeContact( const Addressee& ad )
 {
 
     detach();
     if ( mData->name.isEmpty() ) mData->name = ad.mData->name;
     if ( mData->formattedName.isEmpty() ) mData->formattedName  = ad.mData->formattedName;
     if ( mData->familyName.isEmpty()  )  mData->familyName  = ad.mData->familyName;
     if ( mData->givenName.isEmpty() ) mData->givenName   = ad.mData->givenName ;
     if ( mData->additionalName )  mData->additionalName  = ad.mData->additionalName;
     if ( mData->prefix.isEmpty() )  mData->prefix  = ad.mData->prefix;
     if ( mData->suffix.isEmpty() )  mData->suffix  = ad.mData->suffix;
     if ( mData->nickName.isEmpty() )  mData->nickName  = ad.mData->nickName;
     if ( !mData->birthday.isValid() ) 
         if ( ad.mData->birthday.isValid()) 
         mData->birthday =  ad.mData->birthday;
     if ( mData->mailer.isEmpty() ) mData->mailer = ad.mData->mailer;
     if ( !mData->timeZone.isValid() ) mData->timeZone = ad.mData->timeZone;
     if ( !mData->geo.isValid() ) mData->geo = ad.mData->geo;
     if ( mData->title .isEmpty() ) mData->title = ad.mData->title  ;
     if ( mData->role.isEmpty() ) mData->role = ad.mData->role ;
     if ( mData->organization.isEmpty() ) mData->organization = ad.mData->organization ; 
     if ( mData->note.isEmpty() ) mData->note = ad.mData->note ; 
     if ( mData->productId.isEmpty() ) mData->productId  = ad.mData->productId; 
     if ( mData->sortString.isEmpty() )  mData->sortString  = ad.mData->sortString; 
     if ( !mData->secrecy.isValid() ) mData->secrecy = ad.mData->secrecy;
     if ( ( !mData->url.isValid() && ad.mData->url.isValid() ) ) mData->url = ad.mData->url ;
 
     // pending:
     // merging phonenumbers 
     // merging addresses
     // merging emails;
     // merging categories;
     // merging custom;
     // merging keys
 }
 
 void Addressee::removeID(const QString &prof)
 {
     detach();
     mData->mExternalId = KIdManager::removeId ( mData->mExternalId, prof);
     
 }
 void Addressee::setID( const QString & prof , const QString & id )
 {
     detach();
     mData->mExternalId = KIdManager::setId ( mData->mExternalId, prof, id );
     //qDebug("setID2 %s %s %s",mData->mExternalId.latin1(), prof.latin1(), id.latin1() );
 }
 void Addressee::setTempSyncStat( int id )
 {
     if ( mData->mTempSyncStat == id ) return;
     detach();
     mData->mTempSyncStat = id;
 }
 int Addressee::tempSyncStat() const
 {
     return mData->mTempSyncStat;
 }
 
 QString Addressee::getID( const QString &  prof)
 {
     return KIdManager::getId ( mData->mExternalId, prof ); 
 }
 
 void Addressee::setCsum( const QString & prof , const QString & id )
 {
     detach();
     //qDebug("setcsum1 %s %s %s",mData->mExternalId.latin1(), prof.latin1(), id.latin1() );
     mData->mExternalId = KIdManager::setCsum ( mData->mExternalId, prof, id );
     //qDebug("setcsum2 %s ",mData->mExternalId.latin1() );
 }
 
 QString Addressee::getCsum( const QString &  prof)
 {
     return KIdManager::getCsum ( mData->mExternalId, prof ); 
 }
 
 void Addressee::setIDStr( const QString & s )
 { 
     detach();
     mData->mExternalId = s;
 }
 
 QString Addressee::IDStr() const
 {
     return mData->mExternalId;
 }
 
 void Addressee::setExternalUID( const QString &id )
 {
   if ( id == mData->externalUID ) return;
   detach();
   mData->empty = false;
   mData->externalUID = id;
 }
 
 QString Addressee::externalUID() const
 {
   return mData->externalUID;
 }
+void Addressee::setOriginalExternalUID( const QString &id )
+{
+  if ( id == mData->originalExternalUID ) return;
+  detach();
+  mData->empty = false;
+  mData->originalExternalUID = id;
+}
+
+QString Addressee::originalExternalUID() const
+{
+  return mData->originalExternalUID;
+}
 
 void Addressee::setUid( const QString &id )
 {
   if ( id == mData->uid ) return;
   detach();
   mData->empty = false;
   mData->uid = id;
 }
 
 QString Addressee::uid() const
 {
   if ( mData->uid.isEmpty() )
     mData->uid = KApplication::randomString( 10 );
 
   return mData->uid;
 }
 
 QString Addressee::uidLabel()
 {
   return i18n("Unique Identifier");
 }
 
 void Addressee::setName( const QString &name )
 {
   if ( name == mData->name ) return;
   detach();
   mData->empty = false;
   mData->name = name;
 }
 
 QString Addressee::name() const
 {
   return mData->name;
 }
 
 QString Addressee::nameLabel()
 {
   return i18n("Name");
 }
 
 
 void Addressee::setFormattedName( const QString &formattedName )
 {
   if ( formattedName == mData->formattedName ) return;
   detach();
   mData->empty = false;
   mData->formattedName = formattedName;
 }
 
 QString Addressee::formattedName() const
 {
   return mData->formattedName;
 }
 
 QString Addressee::formattedNameLabel()
 {
   return i18n("Formatted Name");
 }
 
 
 void Addressee::setFamilyName( const QString &familyName )
 {
   if ( familyName == mData->familyName ) return;
   detach();
   mData->empty = false;
   mData->familyName = familyName;
 }
 
 QString Addressee::familyName() const
 {
   return mData->familyName;
 }
 
 QString Addressee::familyNameLabel()
 {
   return i18n("Family Name");
 }
 
 
 void Addressee::setGivenName( const QString &givenName )
 {
   if ( givenName == mData->givenName ) return;
   detach();
   mData->empty = false;
   mData->givenName = givenName;
 }
 
 QString Addressee::givenName() const
 {
   return mData->givenName;
 }
 
 QString Addressee::givenNameLabel()
 {
   return i18n("Given Name");
 }
 
 
 void Addressee::setAdditionalName( const QString &additionalName )
 {
   if ( additionalName == mData->additionalName ) return;
   detach();
   mData->empty = false;
   mData->additionalName = additionalName;
 }
 
 QString Addressee::additionalName() const
 {
   return mData->additionalName;
 }
 
 QString Addressee::additionalNameLabel()
 {
   return i18n("Additional Names");
 }
 
 
 void Addressee::setPrefix( const QString &prefix )
 {
   if ( prefix == mData->prefix ) return;
   detach();
   mData->empty = false;
   mData->prefix = prefix;
 }
 
 QString Addressee::prefix() const
 {
   return mData->prefix;
 }
 
 QString Addressee::prefixLabel()
 {
   return i18n("Honorific Prefixes");
 }
 
 
 void Addressee::setSuffix( const QString &suffix )
 {
   if ( suffix == mData->suffix ) return;
   detach();
   mData->empty = false;
   mData->suffix = suffix;
 }
 
 QString Addressee::suffix() const
 {
   return mData->suffix;
 }
 
 QString Addressee::suffixLabel()
 {
   return i18n("Honorific Suffixes");
 }
 
 
 void Addressee::setNickName( const QString &nickName )
 {
   if ( nickName == mData->nickName ) return;
   detach();
   mData->empty = false;
   mData->nickName = nickName;
 }
 
 QString Addressee::nickName() const
 {
   return mData->nickName;
 }
 
 QString Addressee::nickNameLabel()
 {
   return i18n("Nick Name");
 }
 
 
 void Addressee::setBirthday( const QDateTime &birthday )
 {
   if ( birthday == mData->birthday ) return;
   detach();
   mData->empty = false;
   mData->birthday = birthday;
 }
 
 QDateTime Addressee::birthday() const
 {
   return mData->birthday;
 }
 
 QString Addressee::birthdayLabel()
 {
   return i18n("Birthday");
 }
 
 
 QString Addressee::homeAddressStreetLabel()
 {
   return i18n("Home Address Street");
 }
 
 
 QString Addressee::homeAddressLocalityLabel()
 {
   return i18n("Home Address Locality");
 }
 
 
 QString Addressee::homeAddressRegionLabel()
 {
   return i18n("Home Address Region");
 }
 
 
 QString Addressee::homeAddressPostalCodeLabel()
 {
   return i18n("Home Address Postal Code");
 }
 
 
 QString Addressee::homeAddressCountryLabel()
 {
   return i18n("Home Address Country");
 }
 
 
 QString Addressee::homeAddressLabelLabel()
 {
   return i18n("Home Address Label");
 }
 
 
 QString Addressee::businessAddressStreetLabel()
 {
   return i18n("Business Address Street");
 }
 
 
 QString Addressee::businessAddressLocalityLabel()
 {
   return i18n("Business Address Locality");
 }
 
 
 QString Addressee::businessAddressRegionLabel()
 {
   return i18n("Business Address Region");
 }
 
 
 QString Addressee::businessAddressPostalCodeLabel()
 {
   return i18n("Business Address Postal Code");
 }
 
 
 QString Addressee::businessAddressCountryLabel()
 {
   return i18n("Business Address Country");
 }
 
 
 QString Addressee::businessAddressLabelLabel()
 {
   return i18n("Business Address Label");
 }
 
 
 QString Addressee::homePhoneLabel()
 {
   return i18n("Home Phone");
 }
 
 
 QString Addressee::businessPhoneLabel()
 {
   return i18n("Business Phone");
 }
 
 
 QString Addressee::mobilePhoneLabel()
 {
   return i18n("Mobile Phone");
 }
 
 
 QString Addressee::homeFaxLabel()
 {
   return i18n("Home Fax");
 }
 
 
 QString Addressee::businessFaxLabel()
 {
   return i18n("Business Fax");
 }
 
 
 QString Addressee::carPhoneLabel()
 {
   return i18n("Car Phone");
 }
 
 
 QString Addressee::isdnLabel()
 {
   return i18n("ISDN");
 }
 
 
 QString Addressee::pagerLabel()
 {
   return i18n("Pager");
 }
 
 QString Addressee::sipLabel()
 {
   return i18n("SIP");
 }
 
 QString Addressee::emailLabel()
 {
   return i18n("Email Address");
 }
 
 
 void Addressee::setMailer( const QString &mailer )
 {
   if ( mailer == mData->mailer ) return;
   detach();
   mData->empty = false;
   mData->mailer = mailer;
 }
 
 QString Addressee::mailer() const
 {
   return mData->mailer;
 }
 
 QString Addressee::mailerLabel()
 {
   return i18n("Mail Client");
 }
 
 
 void Addressee::setTimeZone( const TimeZone &timeZone )
 {
   if ( timeZone == mData->timeZone ) return;
   detach();
   mData->empty = false;
   mData->timeZone = timeZone;
 }
 
 TimeZone Addressee::timeZone() const
 {
   return mData->timeZone;
 }
 
 QString Addressee::timeZoneLabel()
 {
   return i18n("Time Zone");
 }
 
 
 void Addressee::setGeo( const Geo &geo )
 {
   if ( geo == mData->geo ) return;
   detach();
   mData->empty = false;
   mData->geo = geo;
 }
 
 Geo Addressee::geo() const
 {
   return mData->geo;
 }
 
 QString Addressee::geoLabel()
 {
   return i18n("Geographic Position");
 }
 
 
 void Addressee::setTitle( const QString &title )
 {
   if ( title == mData->title ) return;
   detach();
   mData->empty = false;
   mData->title = title;
 }
 
 QString Addressee::title() const
 {
   return mData->title;
 }
 
 QString Addressee::titleLabel()
 {
   return i18n("Title");
 }
 
 
 void Addressee::setRole( const QString &role )
 {
   if ( role == mData->role ) return;
   detach();
   mData->empty = false;
   mData->role = role;
 }
 
 QString Addressee::role() const
 {
   return mData->role;
 }
 
 QString Addressee::roleLabel()
 {
   return i18n("Role");
 }
 
 
 void Addressee::setOrganization( const QString &organization )
 {
   if ( organization == mData->organization ) return;
   detach();
   mData->empty = false;
   mData->organization = organization;
 }
 
 QString Addressee::organization() const
 {
   return mData->organization;
 }
 
 QString Addressee::organizationLabel()
 {
   return i18n("Organization");
 }
 
 
 void Addressee::setNote( const QString &note )
 {
   if ( note == mData->note ) return;
   detach();
   mData->empty = false;
   mData->note = note;
 }
 
 QString Addressee::note() const
 {
   return mData->note;
 }
 
 QString Addressee::noteLabel()
 {
   return i18n("Note");
 }
 
 
 void Addressee::setProductId( const QString &productId )
 {
   if ( productId == mData->productId ) return;
   detach();
   mData->empty = false;
   mData->productId = productId;
 }
 
 QString Addressee::productId() const
 {
   return mData->productId;
 }
 
 QString Addressee::productIdLabel()
 {
   return i18n("Product Identifier");
 }
 
 
 void Addressee::setRevision( const QDateTime &revision )
 {
   if ( revision == mData->revision ) return;
   detach();
   mData->empty = false;
   mData->revision = revision;
 }
 
 QDateTime Addressee::revision() const
 {
   return mData->revision;
 }
 
 QString Addressee::revisionLabel()
 {
   return i18n("Revision Date");
 }
 
 
 void Addressee::setSortString( const QString &sortString )
 {
   if ( sortString == mData->sortString ) return;
   detach();
   mData->empty = false;
   mData->sortString = sortString;
 }
 
 QString Addressee::sortString() const
 {
   return mData->sortString;
 }
 
 QString Addressee::sortStringLabel()
 {
   return i18n("Sort String");
 }
 
 
 void Addressee::setUrl( const KURL &url )
 {
   if ( url == mData->url ) return;
   detach();
   mData->empty = false;
   mData->url = url;
 }
 
 KURL Addressee::url() const
 {
   return mData->url;
 }
 
 QString Addressee::urlLabel()
 {
   return i18n("URL");
 }
 
 
 void Addressee::setSecrecy( const Secrecy &secrecy )
 {
   if ( secrecy == mData->secrecy ) return;
   detach();
   mData->empty = false;
   mData->secrecy = secrecy;
 }
 
 Secrecy Addressee::secrecy() const
 {
   return mData->secrecy;
 }
 
 QString Addressee::secrecyLabel()
 {
   return i18n("Security Class");
 }
 
 
 void Addressee::setLogo( const Picture &logo )
 {
   if ( logo == mData->logo ) return;
   detach();
   mData->empty = false;
   mData->logo = logo;
 }
 
 Picture Addressee::logo() const
 {
   return mData->logo;
 }
 
 QString Addressee::logoLabel()
 {
   return i18n("Logo");
 }
 
 
 void Addressee::setPhoto( const Picture &photo )
 {
   if ( photo == mData->photo ) return;
   detach();
   mData->empty = false;
   mData->photo = photo;
 }
 
 Picture Addressee::photo() const
 {
   return mData->photo;
 }
 
 QString Addressee::photoLabel()
 {
   return i18n("Photo");
 }
 
 
 void Addressee::setSound( const Sound &sound )
 {
   if ( sound == mData->sound ) return;
   detach();
   mData->empty = false;
   mData->sound = sound;
 }
 
 Sound Addressee::sound() const
 {
   return mData->sound;
 }
 
 QString Addressee::soundLabel()
 {
   return i18n("Sound");
 }
 
 
 void Addressee::setAgent( const Agent &agent )
 {
   if ( agent == mData->agent ) return;
   detach();
   mData->empty = false;
   mData->agent = agent;
 }
 
 Agent Addressee::agent() const
 {
   return mData->agent;
 }
 
 QString Addressee::agentLabel()
 {
   return i18n("Agent");
 }
 
 
 
 void Addressee::setNameFromString( const QString &str )
 {
   setFormattedName( str );
   setName( str );
 
   static bool first = true;
   static QStringList titles;
   static QStringList suffixes;
   static QStringList prefixes;
 
   if ( first ) {
       first = false;
       titles += i18n( "Dr." );
       titles += i18n( "Miss" );
       titles += i18n( "Mr." );
       titles += i18n( "Mrs." );
       titles += i18n( "Ms." );
       titles += i18n( "Prof." );
 
       suffixes += i18n( "I" );
       suffixes += i18n( "II" );
       suffixes += i18n( "III" );
       suffixes += i18n( "Jr." );
       suffixes += i18n( "Sr." );
 
       prefixes += "van";
       prefixes += "von";
       prefixes += "de";
 
       KConfig config( locateLocal( "config", "kabcrc") );
       config.setGroup( "General" );
       titles += config.readListEntry( "Prefixes" );
       titles.remove( "" );
       prefixes += config.readListEntry( "Inclusions" );
       prefixes.remove( "" );
       suffixes += config.readListEntry( "Suffixes" );
       suffixes.remove( "" );
   }
 
   // clear all name parts
   setPrefix( "" );
   setGivenName( "" );
   setAdditionalName( "" );
   setFamilyName( "" );
   setSuffix( "" );
 
   if ( str.isEmpty() )
     return;
 
   int i = str.find(',');
   if( i < 0 ) {
     QStringList parts = QStringList::split( " ", str );
     int leftOffset = 0;
     int rightOffset = parts.count() - 1;
 
     QString suffix;
     while ( rightOffset >= 0 ) {
       if ( suffixes.contains( parts[ rightOffset ] ) ) {
         suffix.prepend(parts[ rightOffset ] + (suffix.isEmpty() ? "" : " "));
         rightOffset--;
       } else
         break;
     }
     setSuffix( suffix );
 
     if ( rightOffset < 0 )
       return;
 
     if ( rightOffset - 1 >= 0 && prefixes.contains( parts[ rightOffset - 1 ].lower() ) ) {
       setFamilyName( parts[ rightOffset - 1 ] + " " + parts[ rightOffset ] );
       rightOffset--;
     } else
       setFamilyName( parts[ rightOffset ] );
 
     QString prefix;
     while ( leftOffset < rightOffset ) {
       if ( titles.contains( parts[ leftOffset ] ) ) {
         prefix.append( ( prefix.isEmpty() ? "" : " ") + parts[ leftOffset ] );
         leftOffset++;
       } else
         break;
     }
     setPrefix( prefix );
 
     if ( leftOffset < rightOffset ) {
       setGivenName( parts[ leftOffset ] );
       leftOffset++;
     }
 
     QString additionalName;
     while ( leftOffset < rightOffset ) {
       additionalName.append( ( additionalName.isEmpty() ? "" : " ") + parts[ leftOffset ] );
       leftOffset++;
     }
     setAdditionalName( additionalName );
   } else {
     QString part1 = str.left( i );
     QString part2 = str.mid( i + 1 );
 
     QStringList parts = QStringList::split( " ", part1 );
     int leftOffset = 0;
     int rightOffset = parts.count() - 1;
 
     QString suffix;
     while ( rightOffset >= 0 ) {
       if ( suffixes.contains( parts[ rightOffset ] ) ) {
         suffix.prepend(parts[ rightOffset ] + (suffix.isEmpty() ? "" : " "));
         rightOffset--;
       } else
         break;
     }
     setSuffix( suffix );
 
     if ( rightOffset - 1 >= 0 && prefixes.contains( parts[ rightOffset - 1 ].lower() ) ) {
       setFamilyName( parts[ rightOffset - 1 ] + " " + parts[ rightOffset ] );
       rightOffset--;
     } else
       setFamilyName( parts[ rightOffset ] );
 
     QString prefix;
     while ( leftOffset < rightOffset ) {
       if ( titles.contains( parts[ leftOffset ] ) ) {
         prefix.append( ( prefix.isEmpty() ? "" : " ") + parts[ leftOffset ] );
         leftOffset++;
       } else
         break;
     }
 
     parts = QStringList::split( " ", part2 );
 
     leftOffset = 0;
     rightOffset = parts.count();
 
     while ( leftOffset < rightOffset ) {
       if ( titles.contains( parts[ leftOffset ] ) ) {
         prefix.append( ( prefix.isEmpty() ? "" : " ") + parts[ leftOffset ] );
         leftOffset++;
       } else
         break;
     }
diff --git a/kabc/addressee.h b/kabc/addressee.h
index 3ba7777..8baa888 100644
--- a/kabc/addressee.h
+++ b/kabc/addressee.h
@@ -1,841 +1,843 @@
 /*** Warning! This file has been generated by the script makeaddressee ***/
 /*
     This file is part of libkabc.
     Copyright (c) 2001 Cornelius Schumacher <schumacher@kde.org>
 
     This library is free software; you can redistribute it and/or
     modify it under the terms of the GNU Library General Public
     License as published by the Free Software Foundation; either
     version 2 of the License, or (at your option) any later version.
 
     This library is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
     Library General Public License for more details.
 
     You should have received a copy of the GNU Library General Public License
     along with this library; see the file COPYING.LIB.  If not, write to
     the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
     Boston, MA 02111-1307, USA.
 */
 
 /*
 Enhanced Version of the file for platform independent KDE tools.
 Copyright (c) 2004 Ulf Schenk
 
 $Id$
 */
 
 #ifndef KABC_ADDRESSEE_H
 #define KABC_ADDRESSEE_H
 
 #include <qdatetime.h>
 #include <qstring.h>
 #include <qstringlist.h>
 #include <qvaluelist.h>
 
 #include <ksharedptr.h>
 #include <kurl.h>
 
 #include "address.h"
 #include "agent.h"
 #include "geo.h"
 #include "key.h"
 #include "phonenumber.h"
 #include "picture.h"
 #include "secrecy.h"
 #include "sound.h"
 #include "timezone.h"
 
 namespace KABC {
 
 class Resource;
 
 /**
   @short address book entry
 
   This class represents an entry in the address book.
 
   The data of this class is implicitly shared. You can pass this class by value.
 
   If you need the name of a field for presenting it to the user you should use
   the functions ending in Label(). They return a translated string which can be
   used as label for the corresponding field.
 
   About the name fields:
 
   givenName() is the first name and familyName() the last name. In some
   countries the family name comes first, that's the reason for the
   naming. formattedName() is the full name with the correct formatting.
   It is used as an override, when the correct formatting can't be generated
   from the other name fields automatically.
 
   realName() returns a fully formatted name(). It uses formattedName, if set,
   otherwise it constucts the name from the name fields. As fallback, if
   nothing else is set it uses name().
 
   name() is the NAME type of RFC2426. It can be used as internal name for the
   data enty, but shouldn't be used for displaying the data to the user.
  */
 class Addressee
 {
     friend QDataStream &operator<<( QDataStream &, const Addressee & );
     friend QDataStream &operator>>( QDataStream &, Addressee & );
 
   public:
     typedef QValueList<Addressee> List;
 
     /**
       Construct an empty address book entry.
      */
     Addressee();
     ~Addressee();
 
     Addressee( const Addressee & );
     Addressee &operator=( const Addressee & );
 
     bool operator==( const Addressee & ) const;
     bool operator!=( const Addressee & ) const;
     // sync stuff
     void setTempSyncStat(int id);
     int tempSyncStat() const;
     void setIDStr( const QString & );
     QString IDStr() const;
     void setID( const QString &, const QString & );
     QString  getID( const QString & );
     void setCsum( const QString &, const QString & );
     QString getCsum( const QString & );
     void removeID(const QString &);
     void computeCsum(const QString &dev);
     ulong getCsum4List( const QStringList &  attList);
     /**
       Return, if the address book entry is empty.
      */
     bool isEmpty() const;
     void setExternalUID( const QString &id );
     QString externalUID() const;
+    void setOriginalExternalUID( const QString &id );
+    QString originalExternalUID() const;
     void mergeContact(  const Addressee& ad ); 
     /**
       Set unique identifier.
      */
     void setUid( const QString &uid );
     /**
       Return unique identifier.
      */
     QString uid() const;
     /**
       Return translated label for uid field.
      */
     static QString uidLabel();
 
     /**
       Set name.
      */
     void setName( const QString &name );
     /**
       Return name.
      */
     QString name() const;
     /**
       Return translated label for name field.
      */
     static QString nameLabel();
 
     /**
       Set formatted name.
      */
     void setFormattedName( const QString &formattedName );
     /**
       Return formatted name.
      */
     QString formattedName() const;
     /**
       Return translated label for formattedName field.
      */
     static QString formattedNameLabel();
 
     /**
       Set family name.
      */
     void setFamilyName( const QString &familyName );
     /**
       Return family name.
      */
     QString familyName() const;
     /**
       Return translated label for familyName field.
      */
     static QString familyNameLabel();
 
     /**
       Set given name.
      */
     void setGivenName( const QString &givenName );
     /**
       Return given name.
      */
     QString givenName() const;
     /**
       Return translated label for givenName field.
      */
     static QString givenNameLabel();
 
     /**
       Set additional names.
      */
     void setAdditionalName( const QString &additionalName );
     /**
       Return additional names.
      */
     QString additionalName() const;
     /**
       Return translated label for additionalName field.
      */
     static QString additionalNameLabel();
 
     /**
       Set honorific prefixes.
      */
     void setPrefix( const QString &prefix );
     /**
       Return honorific prefixes.
      */
     QString prefix() const;
     /**
       Return translated label for prefix field.
      */
     static QString prefixLabel();
 
     /**
       Set honorific suffixes.
      */
     void setSuffix( const QString &suffix );
     /**
       Return honorific suffixes.
      */
     QString suffix() const;
     /**
       Return translated label for suffix field.
      */
     static QString suffixLabel();
 
     /**
       Set nick name.
      */
     void setNickName( const QString &nickName );
     /**
       Return nick name.
      */
     QString nickName() const;
     /**
       Return translated label for nickName field.
      */
     static QString nickNameLabel();
 
     /**
       Set birthday.
      */
     void setBirthday( const QDateTime &birthday );
     /**
       Return birthday.
      */
     QDateTime birthday() const;
     /**
       Return translated label for birthday field.
      */
     static QString birthdayLabel();
 
     /**
       Return translated label for homeAddressStreet field.
      */
     static QString homeAddressStreetLabel();
 
     /**
       Return translated label for homeAddressLocality field.
      */
     static QString homeAddressLocalityLabel();
 
     /**
       Return translated label for homeAddressRegion field.
      */
     static QString homeAddressRegionLabel();
 
     /**
       Return translated label for homeAddressPostalCode field.
      */
     static QString homeAddressPostalCodeLabel();
 
     /**
       Return translated label for homeAddressCountry field.
      */
     static QString homeAddressCountryLabel();
 
     /**
       Return translated label for homeAddressLabel field.
      */
     static QString homeAddressLabelLabel();
 
     /**
       Return translated label for businessAddressStreet field.
      */
     static QString businessAddressStreetLabel();
 
     /**
       Return translated label for businessAddressLocality field.
      */
     static QString businessAddressLocalityLabel();
 
     /**
       Return translated label for businessAddressRegion field.
      */
     static QString businessAddressRegionLabel();
 
     /**
       Return translated label for businessAddressPostalCode field.
      */
     static QString businessAddressPostalCodeLabel();
 
     /**
       Return translated label for businessAddressCountry field.
      */
     static QString businessAddressCountryLabel();
 
     /**
       Return translated label for businessAddressLabel field.
      */
     static QString businessAddressLabelLabel();
 
     /**
       Return translated label for homePhone field.
      */
     static QString homePhoneLabel();
 
     /**
       Return translated label for businessPhone field.
      */
     static QString businessPhoneLabel();
 
     /**
       Return translated label for mobilePhone field.
      */
     static QString mobilePhoneLabel();
 
     /**
       Return translated label for homeFax field.
      */
     static QString homeFaxLabel();
 
     /**
       Return translated label for businessFax field.
      */
     static QString businessFaxLabel();
 
     /**
       Return translated label for carPhone field.
      */
     static QString carPhoneLabel();
 
     /**
       Return translated label for isdn field.
      */
     static QString isdnLabel();
 
     /**
       Return translated label for pager field.
      */
     static QString pagerLabel();
 
     /**
       Return translated label for sip field.
      */
     static QString sipLabel();
 
     /**
       Return translated label for email field.
      */
     static QString emailLabel();
 
     /**
       Set mail client.
      */
     void setMailer( const QString &mailer );
     /**
       Return mail client.
      */
     QString mailer() const;
     /**
       Return translated label for mailer field.
      */
     static QString mailerLabel();
 
     /**
       Set time zone.
      */
     void setTimeZone( const TimeZone &timeZone );
     /**
       Return time zone.
      */
     TimeZone timeZone() const;
     /**
       Return translated label for timeZone field.
      */
     static QString timeZoneLabel();
 
     /**
       Set geographic position.
      */
     void setGeo( const Geo &geo );
     /**
       Return geographic position.
      */
     Geo geo() const;
     /**
       Return translated label for geo field.
      */
     static QString geoLabel();
 
     /**
       Set title.
      */
     void setTitle( const QString &title );
     /**
       Return title.
      */
     QString title() const;
     /**
       Return translated label for title field.
      */
     static QString titleLabel();
 
     /**
       Set role.
      */
     void setRole( const QString &role );
     /**
       Return role.
      */
     QString role() const;
     /**
       Return translated label for role field.
      */
     static QString roleLabel();
 
     /**
       Set organization.
      */
     void setOrganization( const QString &organization );
     /**
       Return organization.
      */
     QString organization() const;
     /**
       Return translated label for organization field.
      */
     static QString organizationLabel();
 
     /**
       Set note.
      */
     void setNote( const QString &note );
     /**
       Return note.
      */
     QString note() const;
     /**
       Return translated label for note field.
      */
     static QString noteLabel();
 
     /**
       Set product identifier.
      */
     void setProductId( const QString &productId );
     /**
       Return product identifier.
      */
     QString productId() const;
     /**
       Return translated label for productId field.
      */
     static QString productIdLabel();
 
     /**
       Set revision date.
      */
     void setRevision( const QDateTime &revision );
     /**
       Return revision date.
      */
     QDateTime revision() const;
     /**
       Return translated label for revision field.
      */
     static QString revisionLabel();
 
     /**
       Set sort string.
      */
     void setSortString( const QString &sortString );
     /**
       Return sort string.
      */
     QString sortString() const;
     /**
       Return translated label for sortString field.
      */
     static QString sortStringLabel();
 
     /**
       Set URL.
      */
     void setUrl( const KURL &url );
     /**
       Return URL.
      */
     KURL url() const;
     /**
       Return translated label for url field.
      */
     static QString urlLabel();
 
     /**
       Set security class.
      */
     void setSecrecy( const Secrecy &secrecy );
     /**
       Return security class.
      */
     Secrecy secrecy() const;
     /**
       Return translated label for secrecy field.
      */
     static QString secrecyLabel();
 
     /**
       Set logo.
      */
     void setLogo( const Picture &logo );
     /**
       Return logo.
      */
     Picture logo() const;
     /**
       Return translated label for logo field.
      */
     static QString logoLabel();
 
     /**
       Set photo.
      */
     void setPhoto( const Picture &photo );
     /**
       Return photo.
      */
     Picture photo() const;
     /**
       Return translated label for photo field.
      */
     static QString photoLabel();
 
     /**
       Set sound.
      */
     void setSound( const Sound &sound );
     /**
       Return sound.
      */
     Sound sound() const;
     /**
       Return translated label for sound field.
      */
     static QString soundLabel();
 
     /**
       Set agent.
      */
     void setAgent( const Agent &agent );
     /**
       Return agent.
      */
     Agent agent() const;
     /**
       Return translated label for agent field.
      */
     static QString agentLabel();
 
     /**
       Set name fields by parsing the given string and trying to associate the
       parts of the string with according fields. This function should probably
       be a bit more clever.
      */
     void setNameFromString( const QString & );
 
     /**
       Return the name of the addressee. This is calculated from all the name
       fields.
      */
     QString realName() const;
 
     /**
       Return the name that consists of all name parts.
      */
     QString assembledName() const;
 
     /**
       Return email address including real name.
 
       @param email Email address to be used to construct the full email string.
                    If this is QString::null the preferred email address is used.
      */
     QString fullEmail( const QString &email=QString::null ) const;
 
     /**
       Insert an email address. If the email address already exists in this
       addressee it is not duplicated.
 
       @param email Email address
       @param preferred Set to true, if this is the preferred email address of
                        the addressee.
      */
     void insertEmail( const QString &email, bool preferred=false );
 
     /**
       Remove email address. If the email address doesn't exist, nothing happens.
      */
     void removeEmail( const QString &email );
 
     /**
       Return preferred email address. This is the first email address or the
       last one added with @ref insertEmail() with a set preferred parameter.
      */
     QString preferredEmail() const;
 
     /**
       Return list of all email addresses.
      */
     QStringList emails() const;
 
     /**
        Set the emails to @param.
        The first email address gets the preferred one!
        @param list The list of email addresses.
      */
     void setEmails( const QStringList& list);
 
     /**
       Insert a phone number. If a phone number with the same id already exists
       in this addressee it is not duplicated.
      */
     void insertPhoneNumber( const PhoneNumber &phoneNumber );
 
     /**
       Remove phone number. If no phone number with the given id exists for this
       addresse nothing happens.
      */
     void removePhoneNumber( const PhoneNumber &phoneNumber );
 
     /**
       Return phone number, which matches the given type.
      */
     PhoneNumber phoneNumber( int type ) const;
 
     /**
       Return list of all phone numbers.
      */
     PhoneNumber::List phoneNumbers() const;
 
     /**
       Return list of phone numbers with a special type.
      */
     PhoneNumber::List phoneNumbers( int type ) const;
 
     /**
       Return phone number with the given id.
      */
     PhoneNumber findPhoneNumber( const QString &id ) const;
 
     /**
       Insert a key. If a key with the same id already exists
       in this addressee it is not duplicated.
      */
     void insertKey( const Key &key );
 
     /**
       Remove a key. If no key with the given id exists for this
       addresse nothing happens.
      */
     void removeKey( const Key &key );
 
     /**
       Return key, which matches the given type.
       If @p type == Key::Custom you can specify a string
       that should match. If you leave the string empty, the first
       key with a custom value is returned.
      */
     Key key( int type, QString customTypeString = QString::null ) const;
 
     /**
       Return list of all keys.
      */
     Key::List keys() const;
 
     /**
        Set the list of keys
        @param keys The keys to be set.
      */
     void setKeys( const Key::List& keys);
 
     /**
       Return list of keys with a special type.
       If @p type == Key::Custom you can specify a string
       that should match. If you leave the string empty, all custom
       keys will be returned.
      */
     Key::List keys( int type, QString customTypeString = QString::null  ) const;
 
     /**
       Return key with the given id.
      */
     Key findKey( const QString &id ) const;
 
     /**
       Insert an address. If an address with the same id already exists
       in this addressee it is not duplicated.
      */
     void insertAddress( const Address &address );
 
     /**
       Remove address. If no address with the given id exists for this
       addresse nothing happens.
      */
     void removeAddress( const Address &address );
 
     /**
       Return address, which matches the given type.
      */
     Address address( int type ) const;
 
     /**
       Return list of all addresses.
      */
     Address::List addresses() const;
 
     /**
       Return list of addresses with a special type.
      */
     Address::List addresses( int type ) const;
 
     /**
       Return address with the given id.
      */
     Address findAddress( const QString &id ) const;
 
     /**
       Insert category. If the category already exists it is not duplicated.
      */
     void insertCategory( const QString & );
 
     /**
       Remove category.
      */
     void removeCategory( const QString & );
 
     /**
       Return, if addressee has the given category.
      */
     bool hasCategory( const QString & ) const;
 
     /**
       Set categories to given value.
      */
     void setCategories( const QStringList & );
 
     /**
       Return list of all set categories.
      */
     QStringList categories() const;
 
     /**
       Insert custom entry. The entry is identified by the name of the inserting
       application and a unique name. If an entry with the given app and name
       already exists its value is replaced with the new given value.
      */
     void insertCustom( const QString &app, const QString &name,
                        const QString &value );
 
     /**
       Remove custom entry.
      */
     void removeCustom( const QString &app, const QString &name );
 
     /**
       Return value of custom entry, identified by app and entry name.
      */
     QString custom( const QString &app, const QString &name ) const;
 
     /**
       Set all custom entries.
      */
     void setCustoms( const QStringList & );
 
     /**
       Return list of all custom entries.
      */
     QStringList customs() const;
 
     /**
       Parse full email address. The result is given back in fullName and email.
      */
     static void parseEmailAddress( const QString &rawEmail, QString &fullName,
                                    QString &email );
 
     /**
       Debug output.
      */
     void dump() const;
 
     /**
       Returns string representation of the addressee.
      */
     QString asString() const;
 
     /**
       Set resource where the addressee is from.
      */
     void setResource( Resource *resource );
 
     /**
       Return pointer to resource.
      */
     Resource *resource() const;
 
     /**
       Return resourcelabel.
      */
     //US
     static QString resourceLabel();
     
     /**
 	    Mark addressee as changed.
 	   */
     void setChanged( bool value );
 
   	/**
 	    Return whether the addressee is changed.
 	   */
 	  bool changed() const;
 
   private:
     Addressee copy();
     void detach();
 
     struct AddresseeData;
     mutable KSharedPtr<AddresseeData> mData;
 };
 
 QDataStream &operator<<( QDataStream &, const Addressee & );
 QDataStream &operator>>( QDataStream &, Addressee & );
 
 }
 
 #endif
diff --git a/kabc/plugins/qtopia/qtopiaE.pro b/kabc/plugins/qtopia/qtopiaE.pro
index 148da2a..c0aa960 100644
--- a/kabc/plugins/qtopia/qtopiaE.pro
+++ b/kabc/plugins/qtopia/qtopiaE.pro
@@ -1,27 +1,27 @@
 TEMPLATE	= lib
 CONFIG += qt warn_on
 
 TARGET = microkabc_qtopia
 
-INCLUDEPATH += $(KDEPIMDIR)/kabc $(KDEPIMDIR)/microkde $(KDEPIMDIR)/microkde/kdecore $(KDEPIMDIR)/microkde/kio/kfile $(KDEPIMDIR)/microkde/kio/kio $(KDEPIMDIR)/microkde/kresources $(KDEPIMDIR)/qtcompat $(QPEDIR)/include
+INCLUDEPATH += $(KDEPIMDIR) $(KDEPIMDIR)/kabc $(KDEPIMDIR)/microkde $(KDEPIMDIR)/microkde/kdecore $(KDEPIMDIR)/microkde/kio/kfile $(KDEPIMDIR)/microkde/kio/kio $(KDEPIMDIR)/microkde/kresources $(KDEPIMDIR)/qtcompat $(QPEDIR)/include
 
 OBJECTS_DIR = obj/$(PLATFORM)
 MOC_DIR = moc/$(PLATFORM)
 DESTDIR = $(QPEDIR)/lib
 LIBS += -lmicrokde 
 LIBS += -lmicrokabc
 LIBS += -L$(QPEDIR)/lib
 LIBS += -lqpepim
 LIBS += -lqpe
 
 INTERFACES = \
 
 HEADERS = \
  resourceqtopia.h \
  resourceqtopiaconfig.h \
  qtopiaconverter.h
 
 SOURCES = \
  resourceqtopia.cpp \
  resourceqtopiaconfig.cpp \
  qtopiaconverter.cpp 
diff --git a/kabc/plugins/qtopia/qtopiaconverter.cpp b/kabc/plugins/qtopia/qtopiaconverter.cpp
index 7d00a3f..de45e63 100644
--- a/kabc/plugins/qtopia/qtopiaconverter.cpp
+++ b/kabc/plugins/qtopia/qtopiaconverter.cpp
@@ -1,369 +1,376 @@
 /*
     This file is part of libkabc.
     Copyright (c) 2002 Tobias Koenig <tokoe@kde.org>
 
     This library is free software; you can redistribute it and/or
     modify it under the terms of the GNU Library General Public
     License as published by the Free Software Foundation; either
     version 2 of the License, or (at your option) any later version.
 
     This library is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
     Library General Public License for more details.
 
     You should have received a copy of the GNU Library General Public License
     along with this library; see the file COPYING.LIB.  If not, write to
     the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
     Boston, MA 02111-1307, USA.
 */
 
 /*
 Enhanced Version of the file for platform independent KDE tools.
 Copyright (c) 2004 Ulf Schenk
 
 $Id$
 */
 
 //US
 #include "kglobal.h"
 
 
 #include "qtopiaconverter.h"
 
 #include <qpe/categories.h>
+#include <libkdepim/ksyncprofile.h>
 //US #include <qpe/categoryselect.h>
 
 
 using namespace KABC;
 
 QtopiaConverter::QtopiaConverter() : catDB(0)
 {
 }
 
 QtopiaConverter::~QtopiaConverter()
 {
   deinit();
 }
 
 bool QtopiaConverter::init()
 {
   catDB = new Categories();
 
   if (!catDB)
     return false;
 
   catDB->load( categoryFileName() );
   return true;
 }
 
 void QtopiaConverter::deinit()
 {
   if (catDB)
   {
     delete catDB;
     catDB = 0;
   }
 }
 
 bool QtopiaConverter::qtopiaToAddressee( const PimContact &contact, Addressee &addr )
 {
     // name
     addr.setFormattedName(contact.fileAs());
     addr.setFamilyName( contact.lastName() );
     addr.setGivenName( contact.firstName() );
     addr.setAdditionalName( contact.middleName() );
     addr.setPrefix( contact.nameTitle() );
     addr.setSuffix( contact.suffix() );
+
+    addr.setTempSyncStat(  SYNC_TEMPSTATE_NEW_EXTERNAL );
     QString exuid = contact.uid().toString();
+    addr.setOriginalExternalUID( exuid );
     int ente = exuid.find( "-0000");
     if ( exuid.left(1) == "{" )
         exuid = exuid.mid(1);
     if ( ente > -1 )
         exuid = exuid.left( ente-1 );
     addr.setExternalUID( exuid );
     //qDebug("QtopiaConverter:set uid %s ",addr.externalUID().latin1() );
 
     // email
     QStringList emails = contact.emailList();
     for ( QStringList::Iterator it = emails.begin(); it != emails.end(); ++it ) {
       addr.insertEmail( *it, ((*it) == contact.defaultEmail()) );
     }
 
     if (!contact.defaultEmail().isEmpty())
       addr.insertEmail(contact.defaultEmail(), true);
 
     // home
     if ((!contact.homeStreet().isEmpty()) ||
         (!contact.homeCity().isEmpty()) ||
         (!contact.homeState().isEmpty()) ||
         (!contact.homeZip().isEmpty()) ||
         (!contact.homeCountry().isEmpty()))
     {
       Address homeaddress;
       homeaddress.setType(Address::Home);
 //US    homeaddress.setPostOfficeBox( "" );
 //US    homeaddress.setExtended( "" );
       homeaddress.setStreet( contact.homeStreet() );
       homeaddress.setLocality( contact.homeCity() );
       homeaddress.setRegion( contact.homeState() );
       homeaddress.setPostalCode( contact.homeZip() );
       homeaddress.setCountry( contact.homeCountry() );
 
       addr.insertAddress( homeaddress );
     }
 
     if (!contact.homePhone().isEmpty())
     {
       PhoneNumber homephone;
       homephone.setType( PhoneNumber::Home );
       homephone.setNumber( contact.homePhone() );
       addr.insertPhoneNumber( homephone );
     }
 
     if (!contact.homeFax().isEmpty())
     {
       PhoneNumber homefax;
       homefax.setType( PhoneNumber::Home | PhoneNumber::Fax );
       homefax.setNumber( contact.homeFax() );
       addr.insertPhoneNumber( homefax );
     }
 
     if (!contact.homeMobile().isEmpty())
     {
       PhoneNumber homemobile;
       homemobile.setType( PhoneNumber::Home | PhoneNumber::Cell );
       homemobile.setNumber( contact.homeMobile() );
       addr.insertPhoneNumber( homemobile );
     }
 
     addr.setUrl( contact.homeWebpage() );
 
 
     // business
     if ((!contact.businessStreet().isEmpty()) ||
         (!contact.businessCity().isEmpty()) ||
         (!contact.businessState().isEmpty()) ||
         (!contact.businessZip().isEmpty()) ||
         (!contact.businessCountry().isEmpty()))
     {
       Address businessaddress;
       businessaddress.setType(Address::Work);
 //US    businessaddress.setPostOfficeBox( "" );
 //US    businessaddress.setExtended( "" );
       businessaddress.setStreet( contact.businessStreet() );
       businessaddress.setLocality( contact.businessCity() );
       businessaddress.setRegion( contact.businessState() );
       businessaddress.setPostalCode( contact.businessZip() );
       businessaddress.setCountry( contact.businessCountry() );
 
       addr.insertAddress( businessaddress );
     }
 
 
     if (!contact.businessPhone().isEmpty())
     {
       PhoneNumber businessphone;
       businessphone.setType( PhoneNumber::Work );
       businessphone.setNumber( contact.businessPhone() );
       addr.insertPhoneNumber( businessphone );
     }
 
     if (!contact.businessFax().isEmpty())
     {
       PhoneNumber businessfax;
       businessfax.setType( PhoneNumber::Work | PhoneNumber::Fax );
       businessfax.setNumber( contact.businessFax() );
       addr.insertPhoneNumber( businessfax );
     }
 
     if (!contact.businessMobile().isEmpty())
     {
       PhoneNumber businessmobile;
       businessmobile.setType( PhoneNumber::Work | PhoneNumber::Cell );
       businessmobile.setNumber( contact.businessMobile() );
       addr.insertPhoneNumber( businessmobile );
     }
 
     if (!contact.businessPager().isEmpty())
     {
       PhoneNumber businesspager;
       businesspager.setType( PhoneNumber::Work | PhoneNumber::Pager );
       businesspager.setNumber( contact.businessPager() );
       addr.insertPhoneNumber( businesspager );
     }
 
     addr.setRole( contact.jobTitle() ); //?
     addr.setOrganization( contact.company() );
     addr.insertCustom( "KADDRESSBOOK", "X-Profession", contact.profession() );
     addr.insertCustom( "KADDRESSBOOK", "X-AssistantsName", contact.assistant() );
     addr.insertCustom( "KADDRESSBOOK", "X-Department", contact.department() );
     addr.insertCustom( "KADDRESSBOOK", "X-ManagersName", contact.manager() );
     addr.insertCustom( "KADDRESSBOOK", "X-Office", contact.office() );
 
     //personal
     addr.insertCustom( "KADDRESSBOOK", "X-SpousesName", contact.spouse() );
     // qtopia uses this categorization:
     // enum GenderType { UnspecifiedGender=0, Male, Female };
     if (contact.gender() == PimContact::Male)
       addr.insertCustom( "KADDRESSBOOK", "X-Gender", "male");
     else if (contact.gender() == PimContact::Female)
       addr.insertCustom( "KADDRESSBOOK", "X-Gender", "female");
 
     if (contact.anniversary().isValid()) {
       QString dt = KGlobal::locale()->formatDate(contact.anniversary(), true, KLocale::ISODate);
 //US
 //      qDebug("QtopiaConverter::qtopiaToAddressee found:%s", dt.latin1());
       addr.insertCustom( "KADDRESSBOOK", "X-Anniversary", dt);
     }
 
     addr.insertCustom( "KADDRESSBOOK", "X-Children", contact.children() );
     if (contact.birthday().isValid())
       addr.setBirthday( contact.birthday() );
 
     addr.setNickName( contact.nickname() );
 
     // others
     //US I put opies BusinessWebPage into Ka/Pi's notes block, because no other native field is available.
     QString notes = contact.notes();
     notes += "\nBusinessWebPage: " + contact.businessWebpage() + "\n";
 
     addr.setNote( contact.notes() );
 
 
 
 //US    QString groups() const { return find( Qtopia::Groups ); }
 //US    QStringList groupList() const;
 
     QArray<int> catArray = contact.categories();
     QString cat;
 
     for ( unsigned int i=0; i < catArray.size(); i++ ) {
       cat = catDB->label("contact", catArray[i]);
       if ( cat.isEmpty() )
         addr.insertCategory(QString::number(catArray[i]));
       else
         addr.insertCategory( cat );
     }
 
     return true;
 }
 
 bool QtopiaConverter::addresseeToQtopia( const Addressee &addr, PimContact &contact )
 {
+
+
+    
     // name
     contact.setLastName(addr.familyName());
     contact.setFirstName(addr.givenName());
     contact.setMiddleName(addr.additionalName());
     contact.setNameTitle(addr.prefix());
     contact.setSuffix(addr.suffix());
     contact.setFileAs();
 
 
     // email
     QStringList emails = addr.emails();
     for ( QStringList::Iterator it = emails.begin(); it != emails.end(); ++it ) {
       contact.insertEmail(*it);
     }
     contact.setDefaultEmail( addr.preferredEmail() );
 
 
     // home
     const Address homeaddress = addr.address(Address::Home);
     if (!homeaddress.isEmpty()) {
       contact.setHomeStreet(homeaddress.street());
       contact.setHomeCity(homeaddress.locality());
       contact.setHomeState(homeaddress.region());
       contact.setHomeZip(homeaddress.postalCode());
       contact.setHomeCountry(homeaddress.country());
     }
 
     PhoneNumber homephone = addr.phoneNumber( PhoneNumber::Home );
     if (!homephone.number().isEmpty())
       contact.setHomePhone(homephone.number());
 
     PhoneNumber homefax = addr.phoneNumber( PhoneNumber::Home | PhoneNumber::Fax );
     if (!homefax.number().isEmpty())
       contact.setHomeFax(homefax.number());
 
     PhoneNumber homemobile = addr.phoneNumber( PhoneNumber::Home | PhoneNumber::Cell );
     if (!homemobile.number().isEmpty())
       contact.setHomeMobile(homemobile.number());
 
     contact.setHomeWebpage(addr.url().url());
 
 
     // business
     const Address businessaddress = addr.address(Address::Work);
     if (!businessaddress.isEmpty()) {
       contact.setBusinessStreet(businessaddress.street());
       contact.setBusinessCity(businessaddress.locality());
       contact.setBusinessState(businessaddress.region());
       contact.setBusinessZip(businessaddress.postalCode());
       contact.setBusinessCountry(businessaddress.country());
     }
 
     PhoneNumber businessphone = addr.phoneNumber( PhoneNumber::Work );
     if (!businessphone.number().isEmpty())
       contact.setBusinessPhone(businessphone.number());
 
     PhoneNumber businessfax = addr.phoneNumber( PhoneNumber::Work | PhoneNumber::Fax );
     if (!businessfax.number().isEmpty())
       contact.setBusinessFax(businessfax.number());
 
     PhoneNumber businessmobile = addr.phoneNumber( PhoneNumber::Work | PhoneNumber::Cell );
     if (!businessmobile.number().isEmpty())
       contact.setBusinessMobile(businessmobile.number());
 
     PhoneNumber businesspager = addr.phoneNumber( PhoneNumber::Work | PhoneNumber::Pager );
     if (!businesspager.number().isEmpty())
       contact.setBusinessPager(businesspager.number());
 
     contact.setJobTitle(addr.role());
     contact.setCompany(addr.organization());
 
     contact.setProfession(addr.custom( "KADDRESSBOOK", "X-Profession" ));
     contact.setAssistant(addr.custom( "KADDRESSBOOK", "X-AssistantsName" ));
     contact.setDepartment(addr.custom( "KADDRESSBOOK", "X-Department" ));
     contact.setManager(addr.custom( "KADDRESSBOOK", "X-ManagersName" ));
     contact.setOffice(addr.custom( "KADDRESSBOOK", "X-Office" ));
 
     //personal
     contact.setSpouse(addr.custom( "KADDRESSBOOK", "X-Spouse" ));
     // qtopia uses this categorization:
     // enum GenderType { UnspecifiedGender=0, Male, Female };
     QString gt = addr.custom( "KADDRESSBOOK", "X-Gender" );
     if (gt = "male")
       contact.setGender(PimContact::Male);
     else if (gt = "female")
       contact.setGender(PimContact::Female);
     else
       contact.setGender(PimContact::UnspecifiedGender);
 
 
     QDate dt = KGlobal::locale()->readDate(
             addr.custom("KADDRESSBOOK", "X-Anniversary" ), "%Y-%m-%d"); // = Qt::ISODate
     contact.setAnniversary( dt );
 
     contact.setChildren(addr.custom( "KADDRESSBOOK", "X-Children" ));
 
     contact.setBirthday(addr.birthday().date());
     contact.setNickname(addr.nickName());
 
     // other
     contact.setNotes(addr.note());
 
 //US    QString groups() const { return find( Qtopia::Groups ); }
 //US    QStringList groupList() const;
 
 
     QStringList cats = addr.categories();
 
     QArray<int> iar;
     if ( !cats.isEmpty() ) {
       QArray<int> iar = catDB->ids("contact", cats);
       contact.setCategories(iar);
     }
 
     return true;
 }
diff --git a/kabc/plugins/qtopia/qtopiaconverter.h b/kabc/plugins/qtopia/qtopiaconverter.h
index 8f4c698..012a6e2 100644
--- a/kabc/plugins/qtopia/qtopiaconverter.h
+++ b/kabc/plugins/qtopia/qtopiaconverter.h
@@ -1,79 +1,80 @@
 /*
     This file is part of libkabc.
     Copyright (c) 2002 Tobias Koenig <tokoe@kde.org>
 
     This library is free software; you can redistribute it and/or
     modify it under the terms of the GNU Library General Public
     License as published by the Free Software Foundation; either
     version 2 of the License, or (at your option) any later version.
 
     This library is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
     Library General Public License for more details.
 
     You should have received a copy of the GNU Library General Public License
     along with this library; see the file COPYING.LIB.  If not, write to
     the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
     Boston, MA 02111-1307, USA.
 */
 
 /*
 Enhanced Version of the file for platform independent KDE tools.
 Copyright (c) 2004 Ulf Schenk
 $Id$
 */
 
 #ifndef KABC_QTOPIACONVERTER_H
 #define KABC_QTOPIACONVERTER_H
 
 #include <qstring.h>
 
 #include "addressee.h"
 #include <qpe/pim/contact.h>
+#include <qpe/quuid.h>
 
 class Categories;
 
 namespace KABC {
 
 class QtopiaConverter
 {
 public:
 
   /**
    * Constructor.
    */
   QtopiaConverter();
 
   /**
    * Destructor.
    */
   virtual ~QtopiaConverter();
   
   bool init();
   void deinit();
   
   /**
    * Converts a vcard string to an addressee.
    *
    * @param contact The qtopia contact.
    * @param addr    The addressee.
    */
   bool qtopiaToAddressee( const PimContact &contact, Addressee &addr );
 
   /**
    * Converts an addressee to a vcard string.
    *
    * @param addr    The addressee.
    * @param contact The qtopia contact.
    */
   bool addresseeToQtopia( const Addressee &addr, PimContact &contact );
 
   private:
     Categories* catDB;
   
     
 };
 
 }
 #endif
diff --git a/kabc/plugins/qtopia/resourceqtopia.cpp b/kabc/plugins/qtopia/resourceqtopia.cpp
index 48a9f22..935a1cf 100644
--- a/kabc/plugins/qtopia/resourceqtopia.cpp
+++ b/kabc/plugins/qtopia/resourceqtopia.cpp
@@ -1,322 +1,346 @@
 /*
     This file is part of libkabc.
     Copyright (c) 2001 Cornelius Schumacher <schumacher@kde.org>
 
     This library is free software; you can redistribute it and/or
     modify it under the terms of the GNU Library General Public
     License as published by the Free Software Foundation; either
     version 2 of the License, or (at your option) any later version.
 
     This library is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
     Library General Public License for more details.
 
     You should have received a copy of the GNU Library General Public License
     along with this library; see the file COPYING.LIB.  If not, write to
     the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
     Boston, MA 02111-1307, USA.
 */
 
 /*
 Enhanced Version of the file for platform independent KDE tools.
 Copyright (c) 2004 Ulf Schenk
 
 $Id$
 */
 #include <sys/types.h>
 #include <sys/stat.h>
 #include <unistd.h>
 
 #include <qdir.h>
 #include <qfile.h>
 #include <qfileinfo.h>
 #include <qregexp.h>
 //US #include <qtimer.h>
 
 #include <kapplication.h>
 #include <kconfig.h>
 #include <kdebug.h>
 #include <klocale.h>
 //US #include <ksavefile.h>
 #include <kstandarddirs.h>
 #include <kmessagebox.h>
 
 #include <qpe/pim/addressbookaccess.h>
 
 
 #include "resourceqtopiaconfig.h"
 #include "stdaddressbook.h"
 
 #include "qtopiaconverter.h"
 #include "syncprefwidget.h"
 
 #include "resourceqtopia.h"
+#include <libkdepim/ksyncprofile.h>
+#include <qpe/quuid.h>
 
 using namespace KABC;
 extern "C"
 {
   void *init_microkabc_qtopia()
   {
     return new KRES::PluginFactory<ResourceQtopia,ResourceQtopiaConfig, SyncPrefWidgetContainer>();
   }
 }
 
 ResourceQtopia::ResourceQtopia( const KConfig *config, bool syncable  )
   : Resource( config, syncable ), mConverter (0)
 {
   // we can not choose the filename. Therefore use the default to display
   QString fileName = QDir::homeDirPath() + "/Applications/addressbook/addressbook.xml";
   init( fileName );
 }
 
 ResourceQtopia::ResourceQtopia( const QString &fileName, bool syncable  )
   : Resource( 0, syncable )
 {
   init( fileName );
 }
 
 void ResourceQtopia::init( const QString &fileName )
 {
 
   connect( &mDirWatch, SIGNAL( dirty(const QString&) ), SLOT( fileChanged() ) );
   connect( &mDirWatch, SIGNAL( created(const QString&) ), SLOT( fileChanged() ) );
   connect( &mDirWatch, SIGNAL( deleted(const QString&) ), SLOT( fileChanged() ) );
 
   setFileName( fileName );
 }
 
 ResourceQtopia::~ResourceQtopia()
 {
   if (mConverter != 0)
     delete mConverter;
 
   if(mAccess != 0)
     delete mAccess;
 }
 
 void ResourceQtopia::writeConfig( KConfig *config )
 {
   Resource::writeConfig( config );
 }
 
 Ticket *ResourceQtopia::requestSaveTicket()
 {
   kdDebug(5700) << "ResourceQtopia::requestSaveTicket()" << endl;
 
   qDebug("ResourceQtopia::requestSaveTicket: %s", fileName().latin1());
 
   if ( !addressBook() ) return 0;
 
   if ( !lock( fileName() ) ) {
     kdDebug(5700) << "ResourceQtopia::requestSaveTicket(): Unable to lock file '"
                   << fileName() << "'" << endl;
     return 0;
   }
   return createTicket( this );
 }
 
 
 bool ResourceQtopia::doOpen()
 {
   qDebug("ResourceQtopia::doOpen(): %s", fileName().latin1());
 
   mAccess = new AddressBookAccess();
 
   if ( !mAccess ) {
     qDebug("Unable to load file() %s", fileName().latin1());
     return false;
   }
 
 
   if (mConverter == 0)
   {
     mConverter = new QtopiaConverter();
     bool res = mConverter->init();
     if ( !res )
     {
 	  QString msg("Unable to initialize qtopia converter. Most likely a problem with the category file");
       qDebug(msg);
       delete mAccess;
       mAccess = 0;
       return false;
     }
   }
 
   return true;
 }
 
 void ResourceQtopia::doClose()
 {
   qDebug("ResourceQtopia::doClose: %s", fileName().latin1());
 
   if(mAccess)
   {
     delete mAccess;
     mAccess = 0;
   }
   // it seems so, that deletion of access deletes backend as well
   //delete backend;
 
   return;
 }
 
 bool ResourceQtopia::load()
 {
   qDebug("ResourceQtopia::load: %s", fileName().latin1());
 
   AddressBookIterator it(*mAccess);
   const PimContact* contact;
   bool res;
 
   for (contact=it.toFirst(); it.current(); ++it)
   {
     contact = it.current();
 
     KABC::Addressee addressee;
 
     res = mConverter->qtopiaToAddressee( (*contact), addressee );
 
     if ( !addressee.isEmpty() && res )
     {
       addressee.setResource( this );
       addressBook()->insertAddressee( addressee );
     }
   }
 
   return true;
 }
 
 bool ResourceQtopia::save( Ticket *ticket )
 {
-  qDebug("ResourceQtopia::save: %s", fileName().latin1());
-
-  mDirWatch.stopScan();
-
-  KABC::AddressBook::Iterator it;
-  bool res;
-
-  for ( it = addressBook()->begin(); it != addressBook()->end(); ++it ) {
-    PimContact c;
-    KABC::Addressee addressee = (*it);
-
-    res = mConverter->addresseeToQtopia( *it, c );
-    if (res == true)
-    {
-      mAccess->addContact(c);
-//      if (res == false)
-//        qDebug("Unable to append Contact %s", c.fullName().latin1());
+    qDebug("ResourceQtopia::save: %s", fileName().latin1());
+
+    mDirWatch.stopScan();
+
+    KABC::AddressBook::Iterator it;
+    bool res;
+
+    for ( it = addressBook()->begin(); it != addressBook()->end(); ++it ) {
+        //KABC::Addressee addressee = (*it);
+        if ( (*it).tempSyncStat() != SYNC_TEMPSTATE_NEW_EXTERNAL ) {
+            QUuid uid( (*it).originalExternalUID() );
+            bool ok;
+            PimContact c = mAccess->contactForId( uid, &ok );
+            res = mConverter->addresseeToQtopia( *it, c );
+            if (res == true) {
+                if ( (*it).tempSyncStat() == SYNC_TEMPSTATE_ADDED_EXTERNAL ) {
+                    mAccess->addContact(c);
+                    KABC::Addressee addressee;
+                    mConverter->qtopiaToAddressee( c, addressee );
+                    addressee.setTempSyncStat( SYNC_TEMPSTATE_NEW_ID );
+                    addressBook()->insertAddressee( addressee );
+
+                } else if ( (*it).tempSyncStat() == SYNC_TEMPSTATE_DELETE ) {
+                    if (  ok ) 
+                        mAccess->removeContact(c);
+                    else
+                        qDebug("Error revoe contact from qtopia ");
+                } else if ( (*it).tempSyncStat() != SYNC_TEMPSTATE_NEW_EXTERNAL ) {
+                    if (  ok ) {
+                        mAccess->updateContact(c);
+                        KABC::Addressee addressee;
+                        mConverter->qtopiaToAddressee( c, addressee );
+                        addressee.setTempSyncStat( SYNC_TEMPSTATE_NEW_CSUM );
+                        addressBook()->insertAddressee( addressee );
+                    }
+                    else
+                        qDebug("Error update contact from qtopia ");
+                        
+                }
+       
+            }  else {
+                qDebug("Unable to convert Addressee %s", (*it).formattedName().latin1());
+            }
+        }
     }
-    else
-    {
-      qDebug("Unable to convert Addressee %s", addressee.formattedName().latin1());
-    }
-  }
 
-//  mAccess->addressBookUpdated();
+    //  mAccess->addressBookUpdated();
 
-  mDirWatch.startScan();
+    mDirWatch.startScan();
 
-  delete ticket;
-  unlock( fileName() );
+    delete ticket;
+    unlock( fileName() );
 
-  return true;
+    return true;
 }
 
 bool ResourceQtopia::lock( const QString &lockfileName )
 {
   qDebug("ResourceQtopia::lock: %s", fileName().latin1());
 
   kdDebug(5700) << "ResourceQtopia::lock()" << endl;
 
   QString fn = lockfileName;
 
   KURL url(fn);
   QString lockName = locateLocal( "data", "kabc/lock/" + url.fileName() + ".lock" );
 
   kdDebug(5700) << "-- lock name: " << lockName << endl;
 
   if (QFile::exists( lockName ))
   {
     qDebug("ResourceOpie::lock: lockfile %s already exists. (Delete it before continuing if nobody else is accessing the resourcefile %s)", lockName.latin1(), fileName().latin1());
     return false;
   }
 
   QString lockUniqueName;
   lockUniqueName = fn + KApplication::randomString( 8 );
 
   url = lockUniqueName;
 //US  mLockUniqueName = locateLocal( "data", "kabc/lock/" + lockUniqueName );
   mLockUniqueName = locateLocal( "data", "kabc/lock/" + url.fileName() );
   kdDebug(5700) << "-- lock unique name: " << mLockUniqueName << endl;
 
   // Create unique file
   QFile file( mLockUniqueName );
   file.open( IO_WriteOnly );
   file.close();
 
   // Create lock file
   int result = 0;
 #ifndef _WIN32_
   result = ::link( QFile::encodeName( mLockUniqueName ),
                        QFile::encodeName( lockName ) );
 #endif
   if ( result == 0 ) {
     addressBook()->emitAddressBookLocked();
     return true;
   }
 
   // TODO: check stat
 
   return false;
 }
 
 void ResourceQtopia::unlock( const QString &fileName )
 {
   qDebug("ResourceQtopia::unlock() %s", fileName.latin1());
 
   QString fn = fileName;
   KURL url(fn);
   QString lockName = locateLocal( "data", "kabc/lock/" + url.fileName() + ".lock" );
 
   QFile::remove( lockName );
   QFile::remove( mLockUniqueName );
   addressBook()->emitAddressBookUnlocked();
 }
 
 void ResourceQtopia::setFileName( const QString &newFileName )
 {
   mDirWatch.stopScan();
   mDirWatch.removeFile( fileName() );
 
   Resource::setFileName( newFileName );
 
   mDirWatch.addFile( fileName() );
   mDirWatch.startScan();
 }
 
 
 void ResourceQtopia::fileChanged()
 {
   // There is a small theoretical chance that KDirWatch calls us before
   // we are fully constructed
   if (!addressBook())
     return;
 
   QString text( i18n( "Qtopia resource '%1'<br> has been changed by third party.<br>Do you want to reload?").arg( fileName() ) );
   if ( readOnly() || KMessageBox::questionYesNo( 0, text ) == KMessageBox::Yes ) {
     load();
     addressBook()->emitAddressBookChanged();
   }
 }
 
 void ResourceQtopia::removeAddressee( const Addressee &addr )
 {
 }
 
 void ResourceQtopia::cleanUp()
 {
   unlock( fileName() );
 }
 
 //US #include "resourceqtopia.moc"
diff --git a/kaddressbook/kabcore.cpp b/kaddressbook/kabcore.cpp
index d6482fb..b3d88de 100644
--- a/kaddressbook/kabcore.cpp
+++ b/kaddressbook/kabcore.cpp
@@ -1987,1038 +1987,1073 @@ void KABCore::configureResources()
 
 
 /* this method will be called through the QCop interface from Ko/Pi to select addresses
  * for the attendees list of an event.
  */
 void KABCore::requestForNameEmailUidList(const QString& sourceChannel, const QString& uid)
 {
   QStringList nameList;
   QStringList emailList;
   QStringList uidList;
 
   KABC::Addressee::List list = KABC::AddresseeDialog::getAddressees(this);
   uint i=0;
   for (i=0; i < list.count(); i++)
   {
 	nameList.append(list[i].realName());
 	emailList.append(list[i].preferredEmail());
 	uidList.append(list[i].uid());
   }
 
   bool res = ExternalAppHandler::instance()->returnNameEmailUidListFromKAPI(sourceChannel, uid, nameList, emailList, uidList);
 
 }
 
 /* this method will be called through the QCop interface from other apps to show details of a contact.
  */
 void KABCore::requestForDetails(const QString& sourceChannel, const QString& sessionuid, const QString& name, const QString& email, const QString& uid)
 {
     qDebug("KABCore::requestForDetails %s %s %s %s %s", sourceChannel.latin1(), sessionuid.latin1(), name.latin1(), email.latin1(), uid.latin1());
 
     QString foundUid = QString::null;
     if ( ! uid.isEmpty() ) {
         Addressee adrr = mAddressBook->findByUid( uid );
         if (  !adrr.isEmpty() ) {
             foundUid = uid;
         }
             if ( email == "sendbacklist" ) {
                 //qDebug("ssssssssssssssssssssssend ");
                 QStringList nameList;
                 QStringList emailList;
                 QStringList uidList;
                 nameList.append(adrr.realName());
                 emailList = adrr.emails();
                 uidList.append( adrr.preferredEmail());
                 bool res = ExternalAppHandler::instance()->returnNameEmailUidListFromKAPI("QPE/Application/ompi", uid, nameList, emailList, uidList);
                 return;
             }
         
     }
   
   if ( email == "sendbacklist" ) 
       return;
   if (foundUid.isEmpty())
   {
     //find the uid of the person first
     Addressee::List namelist;
     Addressee::List emaillist;
 
     if (!name.isEmpty())
       namelist = mAddressBook->findByName( name );
 
     if (!email.isEmpty())
       emaillist = mAddressBook->findByEmail( email );
     qDebug("count %d %d ",  namelist.count(),emaillist.count() );
     //check if we have a match in Namelist and Emaillist
     if ((namelist.count() == 0) && (emaillist.count() > 0)) {
       foundUid = emaillist[0].uid();
     }
     else if ((namelist.count() > 0) && (emaillist.count() == 0))
       foundUid = namelist[0].uid();
     else
     {
       for (int i = 0; i < namelist.count(); i++)
       {
         for (int j = 0; j < emaillist.count(); j++)
         {
           if (namelist[i] == emaillist[j])
           {
             foundUid = namelist[i].uid();
           }
         }
       }
     }
   }
   else
   {
     foundUid = uid;
   }
 
   if (!foundUid.isEmpty())
   {
    
     // raise Ka/Pi if it is in the background
 #ifndef DESKTOP_VERSION
 #ifndef KORG_NODCOP
       //QCopEnvelope e("QPE/Application/kapi", "raise()");
 #endif
 #endif
     
     mMainWindow->showMaximized();
     mMainWindow-> raise();
 
     mViewManager->setSelected( "", false);
     mViewManager->refreshView( "" );
     mViewManager->setSelected( foundUid, true );
     mViewManager->refreshView( foundUid );
 
     if ( !mMultipleViewsAtOnce )
     {
       setDetailsVisible( true );
       mActionDetails->setChecked(true);
     }
   }
 }
 
 
 void  KABCore::faq()
 {
   KApplication::showFile( "KA/Pi FAQ", "kdepim/kaddressbook/kapiFAQ.txt" );
 }
 
 
 void KABCore::fillSyncMenu()
 {
     if ( syncMenu->count() )
         syncMenu->clear();
     syncMenu->insertItem( i18n("Configure..."), 0 );
     syncMenu->insertSeparator();
     syncMenu->insertItem( i18n("Multiple sync"), 1 );
     syncMenu->insertSeparator();
     KConfig config ( locateLocal( "config","ksyncprofilesrc"  ) );
     config.setGroup("General");
     QStringList prof = config.readListEntry("SyncProfileNames");
     KABPrefs::instance()->mLocalMachineName = config.readEntry("LocalMachineName","undefined");
     if ( prof.count() < 3 ) {
         prof.clear();
         prof << i18n("Sharp_DTM");
         prof << i18n("Local_file");
         prof << i18n("Last_file");
         KSyncProfile* temp = new KSyncProfile ();
         temp->setName( prof[0] );
         temp->writeConfig(&config);
         temp->setName( prof[1] );
         temp->writeConfig(&config);
         temp->setName( prof[2] );
         temp->writeConfig(&config);
         config.setGroup("General");
         config.writeEntry("SyncProfileNames",prof);
         config.writeEntry("ExternSyncProfiles","Sharp_DTM");
         config.sync();
         delete temp;
     }
     KABPrefs::instance()->mExternSyncProfiles = config.readListEntry("ExternSyncProfiles");
     KABPrefs::instance()->mSyncProfileNames = prof;
     int i;
     for ( i = 0; i < prof.count(); ++i ) {
 
         syncMenu->insertItem(  prof[i], 1000+i );
         if ( i == 2 )
             syncMenu->insertSeparator();
     }
     QDir app_dir;
     if ( !app_dir.exists(QDir::homeDirPath()+"/Applications/dtm" ) ) {
         syncMenu->setItemEnabled( false , 1000 );
     }
     //probaly useless
     //mView->setupExternSyncProfiles();
 }
 void KABCore::slotSyncMenu( int action )
 {
     //qDebug("syncaction %d ", action);
     if ( action == 0 ) {
 
         // seems to be a Qt2 event handling bug
         // syncmenu.clear causes a segfault at first time
         // when we call it after the main event loop, it is ok
         // same behaviour when calling OM/Pi via QCOP for the first time
         QTimer::singleShot ( 1, this, SLOT ( confSync() ) ); 
         //confSync();
 
         return;
     }
     if ( action == 1 ) {
         multiSync( true );
         return;
     }
 
     if (mBlockSaveFlag)
       return;
     mBlockSaveFlag = true;
     mCurrentSyncProfile = action - 1000 ;
     mCurrentSyncDevice = KABPrefs::instance()->mSyncProfileNames[mCurrentSyncProfile] ;
     mCurrentSyncName =  KABPrefs::instance()->mLocalMachineName ;
     KConfig config ( locateLocal( "config","ksyncprofilesrc"  ) );
     KSyncProfile* temp = new KSyncProfile ();
     temp->setName(KABPrefs::instance()->mSyncProfileNames[mCurrentSyncProfile]);
     temp->readConfig(&config);
     KABPrefs::instance()->mAskForPreferences = temp->getAskForPreferences();
     KABPrefs::instance()->mSyncAlgoPrefs = temp->getSyncPrefs();
     KABPrefs::instance()->mWriteBackFile = temp->getWriteBackFile();
     KABPrefs::instance()->mWriteBackExistingOnly = temp->getWriteBackExisting();
     KABPrefs::instance()->mWriteBackInFuture = 0;
     if ( temp->getWriteBackFuture() )
         KABPrefs::instance()->mWriteBackInFuture =  temp->getWriteBackFutureWeeks( );
     KABPrefs::instance()->mShowSyncSummary = temp->getShowSummaryAfterSync();
     if ( action == 1000  ) {
         syncSharp();
 
     } else if ( action == 1001 ) {
         syncLocalFile();
 
     } else if ( action == 1002 ) {
         quickSyncLocalFile();
 
     } else if ( action >= 1003  ) {
         if ( temp->getIsLocalFileSync() ) {
             if ( syncWithFile( temp->getRemoteFileNameAB( ), false ) )
                 KABPrefs::instance()->mLastSyncedLocalFile = temp->getRemoteFileNameAB();
         } else {
             if (  temp->getIsPhoneSync() ) {
                 KABPrefs::instance()->mPhoneDevice = temp->getPhoneDevice( ) ;
                 KABPrefs::instance()->mPhoneConnection = temp->getPhoneConnection( );
                 KABPrefs::instance()->mPhoneModel = temp->getPhoneModel( );
                 syncPhone();
             } else
                 syncRemote( temp );
 
         }
     }
     delete temp;
     mBlockSaveFlag = false;
 }
 
 void KABCore::syncLocalFile()
 {
 
     QString fn =KABPrefs::instance()->mLastSyncedLocalFile;
 
     fn =KFileDialog:: getOpenFileName( fn, i18n("Sync filename(*.ics/*.vcs)"), this );
     if ( fn == "" )
         return;
     if (  syncWithFile(  fn, false ) ) {
         qDebug("syncLocalFile() successful ");
     }
 
 }
 bool  KABCore::syncWithFile( QString fn , bool quick )
 {
     bool ret = false;
     QFileInfo info;
     info.setFile( fn );
     QString mess;
     bool loadbup = true;
     if ( !info. exists() ) {
         mess =  i18n( "Sync file \n...%1\ndoes not exist!\nNothing synced!\n").arg(fn.right( 30) );
         int result = QMessageBox::warning( this, i18n("KO/Pi: Warning!"),
                                            mess );
         return ret;
     }
     int result = 0;
     if ( !quick ) {
         mess =  i18n("Sync with file \n...%1\nfrom:\n%2\n").arg(fn.right( 25)).arg(KGlobal::locale()->formatDateTime(info.lastModified (), true, false ));
         result = QMessageBox::warning( this, i18n("KO/Pi: Warning!"),
                                        mess,
                                        i18n("Sync"), i18n("Cancel"), 0,
                                        0, 1 );
         if ( result )
             return false;
     }
     if ( KABPrefs::instance()->mAskForPreferences )
         edit_sync_options();
     if ( result == 0 ) {
         //qDebug("Now sycing ... ");
         if ( ret = syncAB( fn, KABPrefs::instance()->mSyncAlgoPrefs ) )
             setCaption( i18n("Synchronization successful") );
         else
             setCaption( i18n("Sync cancelled or failed. Nothing synced.") );
         if ( ! quick )
             KABPrefs::instance()->mLastSyncedLocalFile = fn;
         setModified();
     }
     return ret;
 }
 void KABCore::quickSyncLocalFile()
 {
     
     if ( syncWithFile( KABPrefs::instance()->mLastSyncedLocalFile, false ) ) {
         qDebug("quick syncLocalFile() successful ");
       
     }
 }
 void KABCore::multiSync( bool askforPrefs  )
 {
     if (mBlockSaveFlag)
         return;
     mBlockSaveFlag = true;
     QString question = i18n("Do you really want\nto multiple sync\nwith all checked profiles?\nSyncing takes some\ntime - all profiles\nare synced twice!");
     if ( QMessageBox::information( this, i18n("KO/Pi Sync"),
                                    question,
                                    i18n("Yes"), i18n("No"),
                                    0, 0 ) != 0 ) {
         mBlockSaveFlag = false;
         setCaption(i18n("Aborted! Nothing synced!"));
         return;
     }
     mCurrentSyncDevice = i18n("Multiple profiles") ;
     KABPrefs::instance()->mSyncAlgoPrefs = KABPrefs::instance()->mRingSyncAlgoPrefs;
     if ( askforPrefs ) {
         edit_sync_options();
         KABPrefs::instance()->mRingSyncAlgoPrefs = KABPrefs::instance()->mSyncAlgoPrefs;
     }
     setCaption(i18n("Multiple sync started.") );
     qApp->processEvents();
     int num = ringSync() ;
     if (  num > 1 )
         ringSync();
     mBlockSaveFlag = false;
     if ( num )
         save();
     if ( num )
         setCaption(i18n("%1 profiles synced. Multiple sync completed!").arg(num) );
     else
         setCaption(i18n("Nothing synced! No profiles defined for multisync!"));
     return;
 }
 int KABCore::ringSync()
 {
     int syncedProfiles = 0;
     int i;
     QTime timer;
     KConfig config ( locateLocal( "config","ksyncprofilesrc"  ) );
     QStringList syncProfileNames = KABPrefs::instance()->mSyncProfileNames;
     KSyncProfile* temp = new KSyncProfile ();
     KABPrefs::instance()->mAskForPreferences = false;
     for ( i = 0; i < syncProfileNames.count(); ++i ) {
         mCurrentSyncProfile = i;
         temp->setName(syncProfileNames[mCurrentSyncProfile]);
         temp->readConfig(&config);
         if ( temp->getIncludeInRingSyncAB() && ( i < 1 || i > 2  )) {
             setCaption(i18n("Profile ")+syncProfileNames[mCurrentSyncProfile]+ i18n(" is synced ... "));
             ++syncedProfiles;
             // KABPrefs::instance()->mAskForPreferences = temp->getAskForPreferences();
             KABPrefs::instance()->mWriteBackFile = temp->getWriteBackFile();
             KABPrefs::instance()->mWriteBackExistingOnly = temp->getWriteBackExisting();
             KABPrefs::instance()->mWriteBackInFuture = 0;
             if ( temp->getWriteBackFuture() )
                 KABPrefs::instance()->mWriteBackInFuture =  temp->getWriteBackFutureWeeks( );
             KABPrefs::instance()->mShowSyncSummary = false;
             mCurrentSyncDevice = syncProfileNames[i] ;
             mCurrentSyncName = KABPrefs::instance()->mLocalMachineName;
             if ( i == 0 ) {
                 syncSharp();
             } else {
                 if ( temp->getIsLocalFileSync() ) {
                     if ( syncWithFile( temp->getRemoteFileNameAB( ), true ) )
                         KABPrefs::instance()->mLastSyncedLocalFile = temp->getRemoteFileNameAB();
                 } else {
                     if (  temp->getIsPhoneSync() ) {
                         KABPrefs::instance()->mPhoneDevice = temp->getPhoneDevice( ) ;
                         KABPrefs::instance()->mPhoneConnection = temp->getPhoneConnection( );
                         KABPrefs::instance()->mPhoneModel = temp->getPhoneModel( );
                         syncPhone();
                     } else
                         syncRemote( temp, false );
 
                 }
             }
             timer.start();
             setCaption(i18n("Multiple sync in progress ... please wait!") );
             while ( timer.elapsed () < 2000 ) {
                 qApp->processEvents();
 #ifndef _WIN32_
                 sleep (1);
 #endif
             }
 
         }
 
     }
     delete temp;
     return syncedProfiles;
 }
 
 void KABCore::syncRemote( KSyncProfile* prof,  bool ask)
 {
     QString question;
     if ( ask ) {
     question = i18n("Do you really want\nto remote sync\nwith profile \n")+ prof->getName()+" ?\n";
     if ( QMessageBox::information( this, i18n("KO/Pi Sync"),
                                    question,
                                    i18n("Yes"), i18n("No"),
                                    0, 0 ) != 0 )
         return;
     }
     QString command = prof->getPreSyncCommandAB();
     int fi;
     if ( (fi = command.find("$PWD$")) > 0 ) {
         QString pwd = getPassword();
         command = command.left( fi )+ pwd + command.mid( fi+5 );
 
     }
     int maxlen = 30;
     if ( QApplication::desktop()->width() > 320 )
         maxlen += 25;
     setCaption ( i18n( "Copy remote file to local machine..." ) );
     int fileSize = 0;
     int result = system ( command );
     // 0 : okay
     // 256: no such file or dir
     //
     qDebug("KO: Remote copy result(0 = okay): %d ",result );
     if ( result != 0 ) {
         int len = maxlen;
         while ( len <  command.length() ) {
             command.insert( len , "\n" );
             len += maxlen +2;
         }
         question = i18n("Sorry, the copy command failed!\nCommand was:\n%1\n \nTry command on console to get more\ndetailed info about the reason.\n").arg (command) ;
         QMessageBox::information( this, i18n("KO/Pi Sync - ERROR"),
                                   question,
                                   i18n("Okay!")) ;
         setCaption ("KO/Pi");
         return;
     }
     setCaption ( i18n( "Copying succeed." ) );
     //qDebug(" file **%s** ",prof->getLocalTempFile().latin1() );
     if ( syncWithFile( prof->getLocalTempFileAB(), true ) ) {
 //         Event* e = mView->getLastSyncEvent();
 //         e->setReadOnly( false );
 //         e->setLocation( KOPrefs::instance()->mSyncProfileNames[mCurrentSyncProfile]);
 //         e->setReadOnly( true );
         if ( KABPrefs::instance()->mWriteBackFile ) {
             command =  prof->getPostSyncCommandAB(); 
             int fi;
             if ( (fi = command.find("$PWD$")) > 0 ) {
                 QString pwd = getPassword();
                 command = command.left( fi )+ pwd + command.mid( fi+5 );
                 
             }
             setCaption ( i18n( "Writing back file ..." ) );
             result = system ( command );
             qDebug("KO: Writing back file result: %d ", result);
             if ( result != 0 ) {
                 setCaption ( i18n( "Writing back file result: " )+QString::number( result ) );
                 return;
             } else {
                 setCaption ( i18n( "Syncronization sucessfully completed" ) );
             }
         }
     }
     return;
 }
 #include <qpushbutton.h>
 #include <qradiobutton.h>
 #include <qbuttongroup.h>
 void KABCore::edit_sync_options()
 {
     //mDialogManager->showSyncOptions();
     //KABPrefs::instance()->mSyncAlgoPrefs 
     QDialog dia( this, "dia", true );
     dia.setCaption( i18n("Device: " ) +mCurrentSyncDevice );
     QButtonGroup gr ( 1,  Qt::Horizontal, i18n("Sync preferences"), &dia);
     QVBoxLayout lay ( &dia );
     lay.setSpacing( 2 );
     lay.setMargin( 3 );
     lay.addWidget(&gr);
     QRadioButton loc ( i18n("Take local entry on conflict"), &gr );
     QRadioButton rem ( i18n("Take remote entry on conflict"), &gr );
     QRadioButton newest( i18n("Take newest entry on conflict"), &gr );
     QRadioButton ask( i18n("Ask for every entry on conflict"), &gr );
     QRadioButton f_loc( i18n("Force: Take local entry always"), &gr );
     QRadioButton f_rem( i18n("Force: Take remote entry always"), &gr );
     //QRadioButton both( i18n("Take both on conflict"), &gr );
     QPushButton pb ( "OK",  &dia); 
     lay.addWidget( &pb );
     connect(&pb, SIGNAL( clicked() ), &dia, SLOT ( accept() ) ); 
     switch ( KABPrefs::instance()->mSyncAlgoPrefs ) {
     case 0:
         loc.setChecked( true);
         break;
     case 1:
         rem.setChecked( true );
         break;
     case 2:
         newest.setChecked( true);
         break;
     case 3:
         ask.setChecked( true);
         break;
     case 4:
         f_loc.setChecked( true);
         break;
     case 5:
         f_rem.setChecked( true);
         break;
     case 6:
         // both.setChecked( true);
         break; 
     default:
         break;
     }
     if ( dia.exec() ) {
         KABPrefs::instance()->mSyncAlgoPrefs = rem.isChecked()*1+newest.isChecked()*2+  ask.isChecked()*3+  f_loc.isChecked()*4+  f_rem.isChecked()*5;//+  both.isChecked()*6 ;
     }
    
 
 }
 QString  KABCore::getPassword( )
 {
     QString retfile = "";
     QDialog dia ( this, "input-dialog", true );
     QLineEdit lab ( &dia );
     lab.setEchoMode( QLineEdit::Password );
     QVBoxLayout lay( &dia );
     lay.setMargin(7);
     lay.setSpacing(7);
     lay.addWidget( &lab);
     dia.setFixedSize( 230,50 );
     dia.setCaption( i18n("Enter password") );
     QPushButton pb ( "OK",  &dia);
     lay.addWidget( &pb );
     connect(&pb, SIGNAL( clicked() ), &dia, SLOT ( accept() ) );
     dia.show();
     int res = dia.exec();
     if ( res )
         retfile = lab.text();
     dia.hide();
     qApp->processEvents();
     return retfile;
 
 }
 #include <libkcal/syncdefines.h>
 
 KABC::Addressee KABCore::getLastSyncAddressee()
 {
     Addressee lse; 
     //qDebug("CurrentSyncDevice %s ",mCurrentSyncDevice .latin1() );
     lse =   mAddressBook->findByUid( "last-syncAddressee-"+mCurrentSyncDevice );
     if (lse.isEmpty()) {
         qDebug("Creating new last-syncAddressee ");
         lse.setUid( "last-syncAddressee-"+mCurrentSyncDevice ); 
         QString sum = "";
         if ( mGlobalSyncMode == SYNC_MODE_EXTERNAL )
             sum = "E: ";
         lse.setFamilyName("!"+sum+mCurrentSyncDevice + i18n(" - sync event"));
         lse.setRevision( mLastAddressbookSync );
         lse.setCategories( i18n("SyncEvent") );
         mAddressBook->insertAddressee( lse );
     }
     return lse;
 }
 int  KABCore::takeAddressee( KABC::Addressee* local,  KABC::Addressee* remote, int mode , bool full )
 {
  
     //void setZaurusId(int id);
     // int zaurusId() const;
     //  void setZaurusUid(int id);
    // int zaurusUid() const;
    // void setZaurusStat(int id);
    // int zaurusStat() const;
     // 0 equal
     // 1 take local
     // 2 take remote
     // 3 cancel 
     QDateTime lastSync = mLastAddressbookSync;
     if ( mGlobalSyncMode == SYNC_MODE_EXTERNAL ) {
         bool remCh, locCh;
         remCh = ( remote->getCsum(mCurrentSyncDevice) != local->getCsum(mCurrentSyncDevice) );
        
         //qDebug("loc %s  rem %s", local->getCsum(mCurrentSyncDevice).latin1(), remote->getCsum(mCurrentSyncDevice).latin1() );
         locCh = ( local->revision() > mLastAddressbookSync );
         if ( !remCh && ! locCh ) {
             //qDebug("both not changed ");
             lastSync = local->revision().addDays(1);
             if ( mode <= SYNC_PREF_ASK )
                 return 0;
         } else {
             if ( locCh ) {
                 //qDebug("loc changed %s %s",  local->revision().toString().latin1(), mLastAddressbookSync.toString().latin1());
                 lastSync = local->revision().addDays( -1 );
                 if ( !remCh )
                     remote->setRevision( lastSync.addDays( -1 ) );
             } else {
                 //qDebug(" not loc changed ");
                 lastSync = local->revision().addDays( 1 );
                 if ( remCh )
                     remote->setRevision( lastSync.addDays( 1 ) );
                 
             }
         }
         full = true;  
         if ( mode < SYNC_PREF_ASK )
             mode = SYNC_PREF_ASK;
     } else {
           if ( local->revision() == remote->revision() )
                 return 0;
         
     }
     // qDebug(" %d %d conflict on %s %s ", mode, full, local->summary().latin1(), remote->summary().latin1() );
 
     //qDebug("%s %d  %s %d", local->lastModified().toString().latin1() , local->revision(), remote->lastModified().toString().latin1(), remote->revision());  
     //qDebug("%d %d %d %d ", local->lastModified().time().second(), local->lastModified().time().msec(),  remote->lastModified().time().second(), remote->lastModified().time().msec() );
     //full = true; //debug only
     if ( full ) {
         bool equ = ( (*local) == (*remote) );
         if ( equ ) {
             //qDebug("equal ");
             if ( mGlobalSyncMode == SYNC_MODE_EXTERNAL ) {
                 local->setCsum( mCurrentSyncDevice, remote->getCsum(mCurrentSyncDevice) );
             }
             if ( mode < SYNC_PREF_FORCE_LOCAL )
                 return 0;
               
         }//else //debug only
         //qDebug("not equal %s %s ", local->summary().latin1(), remote->summary().latin1());
     }
     int result;
     bool localIsNew;
     //qDebug("%s -- %s mLastCalendarSync %s lastsync %s --- local %s remote %s ",local->summary().latin1(), remote->summary().latin1(),mLastCalendarSync.toString().latin1() ,lastSync.toString().latin1()  ,  local->lastModified().toString().latin1() , remote->lastModified().toString().latin1()  );
 
     if ( full && mode < SYNC_PREF_NEWEST )
         mode = SYNC_PREF_ASK;
 
     switch( mode ) {
     case SYNC_PREF_LOCAL:
         if ( lastSync > remote->revision() )
             return 1;
         if ( lastSync > local->revision() )
             return 2;
         return 1;
         break;
     case SYNC_PREF_REMOTE:
         if ( lastSync > remote->revision() )
             return 1;
         if ( lastSync > local->revision() )
             return 2;
         return 2;
         break;
     case SYNC_PREF_NEWEST:
         if ( local->revision() > remote->revision() )
             return 1;
         else
             return 2;
         break;
     case SYNC_PREF_ASK: 
         //qDebug("lsy %s  ---  lo %s  --- re %s ", lastSync.toString().latin1(), local->revision().toString().latin1(), remote->revision().toString().latin1()  );
         if ( lastSync > remote->revision() )
             return 1;
         if ( lastSync > local->revision() )
             return 2;
         localIsNew = local->revision() >= remote->revision();
         //qDebug("conflict! ************************************** ");
         {
             KPIM::AddresseeChooser acd ( *local,*remote, localIsNew , this );
             result = acd.executeD(localIsNew);
             return result;
         }
         break;
     case SYNC_PREF_FORCE_LOCAL:
         return 1;
         break;
     case SYNC_PREF_FORCE_REMOTE:
         return 2;
         break;
        
     default:
         // SYNC_PREF_TAKE_BOTH not implemented
         break;
     }
     return 0;
 }
 bool KABCore::synchronizeAddressbooks( KABC::AddressBook* local, KABC::AddressBook* remote,int mode)
 {
     bool syncOK = true;
     int addedAddressee = 0;
     int addedAddresseeR = 0;
     int deletedAddresseeR = 0;
     int deletedAddresseeL = 0;
     int changedLocal = 0;
     int changedRemote = 0;
     //QPtrList<Addressee> el = local->rawAddressees(); 
     Addressee addresseeR;
     QString uid;
     int take;
     Addressee addresseeL;
     Addressee addresseeRSync;
     Addressee addresseeLSync;
     // KABC::Addressee::List  addresseeRSyncSharp = remote->getExternLastSyncAddressees();
     //KABC::Addressee::List  addresseeLSyncSharp = local->getExternLastSyncAddressees();
     bool fullDateRange = false;
     local->resetTempSyncStat();
     mLastAddressbookSync = QDateTime::currentDateTime();
     QDateTime modifiedCalendar = mLastAddressbookSync;;
     addresseeLSync = getLastSyncAddressee();
     qDebug("Last Sync %s ", addresseeLSync.revision().toString().latin1());
     addresseeR = remote->findByUid("last-syncAddressee-"+mCurrentSyncName );
     if ( !addresseeR.isEmpty() ) {
         addresseeRSync = addresseeR;
         remote->removeAddressee(addresseeR );
 
     } else {
         if ( mGlobalSyncMode == SYNC_MODE_EXTERNAL ) {
             addresseeRSync = addresseeLSync         ;
         } else {
             qDebug("FULLDATE 1");
             fullDateRange = true;
             Addressee newAdd;
             addresseeRSync = newAdd;
             addresseeRSync.setFamilyName(mCurrentSyncName + i18n(" - sync addressee"));
             addresseeRSync.setUid("last-syncAddressee-"+mCurrentSyncName ); 
             addresseeRSync.setRevision( mLastAddressbookSync );
             addresseeRSync.setCategories( i18n("SyncAddressee") );
         }
     }
     if ( addresseeLSync.revision() == mLastAddressbookSync ) {
             qDebug("FULLDATE 2");
         fullDateRange = true;
     }
     if ( ! fullDateRange  ) {
         if ( addresseeLSync.revision() != addresseeRSync.revision() ) {
             
             // qDebug("set fulldate to true %s %s" ,addresseeLSync->dtStart().toString().latin1(), addresseeRSync->dtStart().toString().latin1() ); 
             //qDebug("%d %d %d %d ", addresseeLSync->dtStart().time().second(), addresseeLSync->dtStart().time().msec() , addresseeRSync->dtStart().time().second(), addresseeRSync->dtStart().time().msec());
             fullDateRange = true;
             qDebug("FULLDATE 3 %s %s", addresseeLSync.revision().toString().latin1() , addresseeRSync.revision().toString().latin1() );
         } 
     }
     // fullDateRange = true; // debug only!
     if ( fullDateRange )
         mLastAddressbookSync = QDateTime::currentDateTime().addDays( -100*365);
     else
         mLastAddressbookSync = addresseeLSync.revision();
     // for resyncing if own file has changed
     // PENDING fixme later when implemented
 #if 0
     if ( mCurrentSyncDevice == "deleteaftersync" ) {
         mLastAddressbookSync = loadedFileVersion;
         qDebug("setting mLastAddressbookSync ");
     }
 #endif
 
     //qDebug("*************************** ");
     // qDebug("mLastAddressbookSync %s ",mLastAddressbookSync.toString().latin1() );
     QStringList er = remote->uidList(); 
     Addressee inR ;//= er.first();
     Addressee  inL;
     QProgressBar bar( er.count(),0 );
     bar.setCaption (i18n("Syncing - close to abort!") );
     
     int w = 300;
     if ( QApplication::desktop()->width() < 320 )
         w = 220;
     int h = bar.sizeHint().height() ;
     int dw = QApplication::desktop()->width();
     int dh = QApplication::desktop()->height();
     bar.setGeometry( (dw-w)/2, (dh - h )/2 ,w,h );
     bar.show();
     int modulo = (er.count()/10)+1;
     int incCounter = 0;
     while ( incCounter < er.count()) {
         if ( ! bar.isVisible() )
             return false;
         if ( incCounter % modulo == 0 )
             bar.setProgress( incCounter );
         uid = er[ incCounter ]; 
         bool skipIncidence = false;
         if ( uid.left(19) == QString("last-syncAddressee-") )
             skipIncidence = true;
-        QString idS;
+        QString idS,OidS;
         qApp->processEvents();
         if ( !skipIncidence ) {
             inL = local->findByUid( uid );
             inR = remote->findByUid( uid );
             //inL.setResource( 0 );
             //inR.setResource( 0 );
             if ( !inL.isEmpty() ) { // maybe conflict - same uid in both calendars
                 if ( take = takeAddressee( &inL, &inR, mode, fullDateRange ) ) {
                     //qDebug("take %d %s ", take, inL.summary().latin1());
                     if ( take == 3 )
                         return false;
                     if ( take == 1  ) {// take local
                         if ( mGlobalSyncMode == SYNC_MODE_EXTERNAL ) {
                             inL.setCsum( mCurrentSyncDevice, inR.getCsum(mCurrentSyncDevice) );
                             local->insertAddressee(  inL, false );
+                            idS = inR.externalUID();
+                            OidS = inR.originalExternalUID();
                         }
                         else
                             idS = inR.IDStr();
                         remote->removeAddressee( inR );
                         inR = inL;
                         inR.setTempSyncStat( SYNC_TEMPSTATE_INITIAL );
-                        if ( mGlobalSyncMode != SYNC_MODE_EXTERNAL )
+                        if ( mGlobalSyncMode == SYNC_MODE_EXTERNAL ) {
+                            inR.setOriginalExternalUID( OidS );
+                            inR.setExternalUID( idS );
+                        } else {
                             inR.setIDStr( idS );
+                        }
                         inR.setResource( 0 );
                         remote->insertAddressee(  inR , false);
                         ++changedRemote;
-                    } else {
+                    } else { // take == 2  take remote
                         idS = inL.IDStr();
                         local->removeAddressee( inL );
                         inL = inR;
                         inL.setIDStr( idS );
                         inL.setResource( 0 );
                         local->insertAddressee(  inL , false );
                         ++changedLocal;
                     }
                 }
             } else { //  no conflict
                 if ( mGlobalSyncMode == SYNC_MODE_EXTERNAL ) {
                     QString des = addresseeLSync.note(); 
                     if ( des.find( inR.getID(mCurrentSyncDevice)  +"," ) >= 0 && mode != 5) { // delete it
                         inR.setTempSyncStat( SYNC_TEMPSTATE_DELETE );
                         remote->insertAddressee( inR, false );
                         ++deletedAddresseeR; 
                     } else {
                         inR.setRevision( modifiedCalendar );
                         remote->insertAddressee( inR, false );
                         inL = inR;
                         inL.setResource( 0 );
                         local->insertAddressee( inL , false);
                         ++addedAddressee;
                     }
                 } else {
                     if ( inR.revision() > mLastAddressbookSync || mode == 5 ) {
                         inR.setRevision( modifiedCalendar );
                         remote->insertAddressee( inR, false );
                         inR.setResource( 0 );
                         local->insertAddressee( inR, false );
                         ++addedAddressee;
                     } else {
                         // pending checkExternSyncAddressee(addresseeRSyncSharp, inR);
                         remote->removeAddressee( inR );
                         ++deletedAddresseeR; 
                     }
                 }
             }
         }
         ++incCounter;
     }
     er.clear();
     QStringList el = local->uidList(); 
     modulo = (el.count()/10)+1;
     bar.setCaption (i18n("Add / remove addressees") ); 
     bar.setTotalSteps (  el.count()  ) ;
     bar.show();
     incCounter = 0;
     while ( incCounter < el.count()) {
         qApp->processEvents();
         if ( ! bar.isVisible() )
             return false;
         if ( incCounter % modulo == 0 )
             bar.setProgress( incCounter );
         uid = el[ incCounter ]; 
         bool skipIncidence = false;
         if ( uid.left(19) == QString("last-syncAddressee-") )
             skipIncidence = true;
         if ( !skipIncidence )  {
             inL = local->findByUid( uid );
             inR = remote->findByUid( uid );
             if ( inR.isEmpty() ) { 
                 if ( mGlobalSyncMode == SYNC_MODE_EXTERNAL ) {
                     if ( !inL.getID(mCurrentSyncDevice).isEmpty() && mode != 4 ) {
                         // pending checkExternSyncAddressee(addresseeLSyncSharp, inL);
                         local->removeAddressee( inL );
                         ++deletedAddresseeL; 
                     } else {
                         if ( ! KABPrefs::instance()->mWriteBackExistingOnly ) {
                             inL.removeID(mCurrentSyncDevice );
                             ++addedAddresseeR;
                             inL.setRevision( modifiedCalendar );
                             local->insertAddressee( inL, false );
                             inR = inL;
-                            inR.setTempSyncStat( SYNC_TEMPSTATE_INITIAL );
+                            inR.setTempSyncStat( SYNC_TEMPSTATE_ADDED_EXTERNAL );
                             inR.setResource( 0 );
                             remote->insertAddressee( inR, false );
                         }
                     }
                 } else {
                     if ( inL.revision() < mLastAddressbookSync && mode != 4 ) {
                         // pending checkExternSyncAddressee(addresseeLSyncSharp, inL);
                         local->removeAddressee( inL );
                         ++deletedAddresseeL; 
                     } else {
                         if ( ! KABPrefs::instance()->mWriteBackExistingOnly ) {
                             ++addedAddresseeR; 
                             inL.setRevision( modifiedCalendar );
                             local->insertAddressee( inL, false );
                             inR = inL;
                             inR.setResource( 0 );
                             remote->insertAddressee( inR, false );
                         }
                     }
                 }
             }
         }
         ++incCounter;
     }
     el.clear();
     bar.hide();
     mLastAddressbookSync = QDateTime::currentDateTime().addSecs( 1 );
     // get rid of micro seconds
     QTime t =  mLastAddressbookSync.time();
     mLastAddressbookSync.setTime( QTime (t.hour (), t.minute (), t.second () )  );
     addresseeLSync.setRevision( mLastAddressbookSync );
     addresseeRSync.setRevision( mLastAddressbookSync );
     addresseeRSync.setRole( i18n("!Remote from: ")+mCurrentSyncName ) ;
     addresseeLSync.setRole(i18n("!Local from: ") + mCurrentSyncName  );
     addresseeRSync.setGivenName( i18n("!DO NOT EDIT!") ) ;
     addresseeLSync.setGivenName(i18n("!DO NOT EDIT!")   );
     addresseeRSync.setOrganization( "!"+mLastAddressbookSync.toString() ) ;
     addresseeLSync.setOrganization("!"+ mLastAddressbookSync.toString() );
     addresseeRSync.setNote( "" ) ;
     addresseeLSync.setNote( "" );
 
     if ( mGlobalSyncMode ==  SYNC_MODE_NORMAL)
         remote->insertAddressee( addresseeRSync, false );
     local->insertAddressee( addresseeLSync, false );
     QString mes;
     mes .sprintf(  i18n("Synchronization summary:\n\n %d items added to local\n %d items added to remote\n %d items updated on local\n %d items updated on remote\n %d items deleted on local\n %d items deleted on remote\n"),addedAddressee, addedAddresseeR, changedLocal, changedRemote, deletedAddresseeL, deletedAddresseeR ); 
     if ( KABPrefs::instance()->mShowSyncSummary ) {
         KMessageBox::information(this, mes, i18n("KA/Pi Synchronization") );
     }
     qDebug( mes );
     return syncOK;
 }
 
 bool KABCore::syncAB(QString filename, int mode)
 {
 
     //pending prepare addresseeview for output
     //pending detect, if remote file has REV field. if not switch to external sync
     mGlobalSyncMode = SYNC_MODE_NORMAL;
     AddressBook abLocal(filename,"syncContact");
     bool syncOK = false;
     if ( abLocal.load() ) {
         qDebug("AB loaded %s,sync mode %d",filename.latin1(), mode );
         bool external = false;
-        Addressee lse =   mAddressBook->findByUid( "last-syncAddressee-"+mCurrentSyncDevice );
-        if ( ! lse.isEmpty() ) {
-            if ( lse.familyName().left(4) == "!E: " )
-                external = true;
-        } else {
-            bool found = false;
-            QDateTime dt( QDate( 2004,1,1));
-            AddressBook::Iterator it;
-            for ( it = abLocal.begin(); it != abLocal.end(); ++it ) {
-                if ( (*it).revision() != dt ) {
-                    found = true;
-                    break;
-                }
-            }
-            external = ! found;
-        }
 
-        if ( external ) {
-            qDebug("Setting vcf mode to external ");
+        if ( filename.right(4) == ".xml") {
             mGlobalSyncMode = SYNC_MODE_EXTERNAL;
             AddressBook::Iterator it;  
             for ( it = abLocal.begin(); it != abLocal.end(); ++it ) {
-                (*it).setID( mCurrentSyncDevice, (*it).uid() );
+                (*it).setID( mCurrentSyncDevice, (*it).externalUID() );
                 (*it).computeCsum( mCurrentSyncDevice );
             }
+            abLocal.mergeAB( mAddressBook ,mCurrentSyncDevice );
+
+        } else {
+            Addressee lse =   mAddressBook->findByUid( "last-syncAddressee-"+mCurrentSyncDevice );
+            if ( ! lse.isEmpty() ) {
+                if ( lse.familyName().left(4) == "!E: " )
+                    external = true;
+            } else {
+                bool found = false;
+                QDateTime dt( QDate( 2004,1,1));
+                AddressBook::Iterator it;
+                for ( it = abLocal.begin(); it != abLocal.end(); ++it ) {
+                    if ( (*it).revision() != dt ) {
+                        found = true;
+                        break;
+                    }
+                }
+                external = ! found;
+            }
+
+            if ( external ) {
+                qDebug("Setting vcf mode to external ");
+                mGlobalSyncMode = SYNC_MODE_EXTERNAL;
+                AddressBook::Iterator it;  
+                for ( it = abLocal.begin(); it != abLocal.end(); ++it ) {
+                    (*it).setID( mCurrentSyncDevice, (*it).uid() );
+                    (*it).computeCsum( mCurrentSyncDevice );
+                }
+            }
         }
         //AddressBook::Iterator it;
         //QStringList vcards;
         //for ( it = abLocal.begin(); it != abLocal.end(); ++it ) {
         //  qDebug("Name %s ", (*it).familyName().latin1());
         //}
-        if ( filename.right(4) == ".xml")
-            abLocal.mergeAB( mAddressBook ,mCurrentSyncDevice );
         syncOK = synchronizeAddressbooks( mAddressBook, &abLocal, mode );
         if (  syncOK ) {
             if ( KABPrefs::instance()->mWriteBackFile )
                 {
-                    if ( external )
+                    if ( external && filename.right(4) != ".xml")
                         abLocal.removeDeletedAddressees();
                     qDebug("Saving remote AB ");
                     abLocal.saveAB();
+                    if ( external && filename.right(4) == ".xml") {
+                        // afterwrite processing
+                        AddressBook::Iterator it;  
+                        for ( it = abLocal.begin(); it != abLocal.end(); ++it ) {
+                            if ( (*it).tempSyncStat() == SYNC_TEMPSTATE_NEW_ID ||
+                                 (*it).tempSyncStat() == SYNC_TEMPSTATE_NEW_CSUM ) {
+                                Addressee ad = mAddressBook->findByUid( ( (*it).uid() ));
+                                if ( ad.isEmpty() ) {
+                                    qDebug("ERROR ad empty ");
+                                } else {
+                                    (*it).computeCsum( mCurrentSyncDevice );
+                                    if ( (*it).tempSyncStat() == SYNC_TEMPSTATE_NEW_ID )
+                                        ad.setID( mCurrentSyncDevice, (*it).externalUID() );
+                                    ad.setCsum( mCurrentSyncDevice, (*it).getCsum( mCurrentSyncDevice ) );
+                                    mAddressBook->insertAddressee( ad );
+                                }
+                            }
+                        }
+                    }
                 }
         }
         setModified();
         
     }
     if ( syncOK )
         mViewManager->refreshView();
     return syncOK;
 #if 0
 
     if ( storage->load(KOPrefs::instance()->mUseQuicksave) ) {
         getEventViewerDialog()->setSyncMode( true );
         syncOK = synchronizeCalendar( mCalendar, calendar, mode );
         getEventViewerDialog()->setSyncMode( false );
         if (  syncOK ) {
            if ( KOPrefs::instance()->mWriteBackFile )
             {
                 storage->setSaveFormat( new ICalFormat( KOPrefs::instance()->mUseQuicksave) );
                 storage->save();
             }
         }
         setModified();
     }
   
 #endif
 }
 
 void KABCore::confSync()
 { 
     static KSyncPrefsDialog* sp = 0;
     if ( ! sp ) {
         sp = new KSyncPrefsDialog( this, "syncprefs", true );
     }
     sp->usrReadConfig();
 #ifndef DESKTOP_VERSION
     sp->showMaximized();
 #else
     sp->show();
 #endif
     sp->exec();
     KABPrefs::instance()->mSyncProfileNames = sp->getSyncProfileNames();
     KABPrefs::instance()->mLocalMachineName = sp->getLocalMachineName ();
     fillSyncMenu();
 }
 void KABCore::syncSharp()
 {
     if (  mModified  )
         save();
     qDebug("pending syncSharp() ");
     //mView->syncSharp();
     setModified();
 
 }
 void KABCore::syncPhone()
 {
     if ( mModified  )
         save();
     qDebug("pending syncPhone(); ");
     //mView->syncPhone();
     setModified();
 
 }
diff --git a/libkcal/sharpformat.cpp b/libkcal/sharpformat.cpp
index e7fc670..d56eab6 100644
--- a/libkcal/sharpformat.cpp
+++ b/libkcal/sharpformat.cpp
@@ -1,1035 +1,1035 @@
 /*
     This file is part of libkcal.
 
     Copyright (c) 2003 Cornelius Schumacher <schumacher@kde.org>
 
     This library is free software; you can redistribute it and/or
     modify it under the terms of the GNU Library General Public
     License as published by the Free Software Foundation; either
     version 2 of the License, or (at your option) any later version.
 
     This library is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
     Library General Public License for more details.
 
     You should have received a copy of the GNU Library General Public License
     along with this library; see the file COPYING.LIB.  If not, write to
     the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
     Boston, MA 02111-1307, USA.
 */
 
 #include <qdatetime.h>
 #include <qstring.h>
 #include <qapplication.h>
 #include <qptrlist.h>
 #include <qregexp.h>
 #include <qmessagebox.h>
 #include <qclipboard.h>
 #include <qfile.h>
 #include <qtextstream.h>
 #include <qtextcodec.h>
 #include <qxml.h>
 #include <qlabel.h>
 
 #include <kdebug.h>
 #include <klocale.h>
 #include <kglobal.h>
 
 #include "calendar.h"
 #include "alarm.h"
 #include "recurrence.h"
 #include "calendarlocal.h"
 
 #include "sharpformat.h"
 #include "syncdefines.h"
 
 using namespace KCal;
 
 //CARDID,CATEGORY,DSRP,PLCE,MEM1,TIM1,TIM2,ADAY,ARON,ARMN,ARSD,RTYP,RFRQ,RPOS,RDYS,REND,REDT,ALSD,ALED,MDAY
 //  0       1      2     3   4    5     6   7    8     9   10   11   12   13   14   15   16   17   18   19
 
 //ARSD  silentalarm = 0
 // 11 RTYP 225 no /0 dialy/ 1 weekly/ 3 month by date/ 2 month by day(pos)/ yearly
 // 12 RFRQ
 // 13 RPOS pos = 4. monday in month
 // 14 RDYS days: 1 mon/ 2 tue .. 64 sun
 // 15 REND 0 = no end/ 1 = end
 // 16 REDT rec end dt  
 //ALSD
 //ALED
 //MDAY
 
 class SharpParser : public QObject
 {
   public:
     SharpParser( Calendar *calendar ) : mCalendar( calendar ) {
         oldCategories = 0;
     }
   
     bool startElement( Calendar *existingCalendar, const QStringList & attList, QString qName )
     {
         int i = 1;
         bool skip = true;
         int max = attList.count() -2;
         while ( i < max ) {
             if ( !attList[i].isEmpty() ) {
                 skip = false;
                 break;
             } 
             ++i ;
         }
         if ( skip )
             return false;
         ulong cSum = SharpFormat::getCsum(attList );
         
         if ( qName == "Event" ) {
             Event *event;
             event = existingCalendar->event( "Sharp_DTM",attList[0] );
             if ( event )
                 event = (Event*)event->clone();
             else
                 event = new Event;
             event->setID("Sharp_DTM", attList[0] );
             event->setCsum( "Sharp_DTM", QString::number( cSum ));
             event->setTempSyncStat(SYNC_TEMPSTATE_NEW_EXTERNAL );
 
             event->setSummary( attList[2] );
             event->setLocation( attList[3] );
             event->setDescription( attList[4]  );
             if ( attList[7] == "1" ) {
                 event->setDtStart( QDateTime(fromString( attList[17]+"T000000", false ).date(),QTime(0,0,0 ) ));
                 event->setDtEnd( QDateTime(fromString( attList[18]+"T000000", false ).date(),QTime(0,0,0 )));
                 event->setFloats( true );
             } else {
                 event->setFloats( false );
                 event->setDtStart( fromString( attList[5] ) );
                 event->setDtEnd( fromString( attList[6]  ));
             }
         
             QString rtype = attList[11];
             if ( rtype != "255" ) {
                 //  qDebug("recurs ");
                 QDate startDate = event->dtStart().date();
         
                 QString freqStr = attList[12];
                 int freq = freqStr.toInt();
 
                 QString hasEndDateStr = attList[15] ;
                 bool hasEndDate = hasEndDateStr == "1";
         
                 QString endDateStr = attList[16];
                 QDate endDate = fromString( endDateStr ).date();
 
                 QString weekDaysStr = attList[14];
                 uint weekDaysNum = weekDaysStr.toInt();
         
                 QBitArray weekDays( 7 );
                 int i;
                 int bb = 1;
                 for( i = 1; i <= 7; ++i ) {
                     weekDays.setBit( i - 1, ( bb & weekDaysNum )); 
                     bb =  2 << (i-1);
                     //qDebug(" %d bit %d ",i-1,weekDays.at(i-1) );
                 }
                 // qDebug("next ");
                 QString posStr = attList[13];
                 int pos = posStr.toInt();
                 Recurrence *r = event->recurrence();
 
                 if ( rtype == "0" ) {
                     if ( hasEndDate ) r->setDaily( freq, endDate );
                     else r->setDaily( freq, -1 );
                 } else if ( rtype == "1" ) {
                     if ( hasEndDate ) r->setWeekly( freq, weekDays, endDate );
                     else r->setWeekly( freq, weekDays, -1 );
                 } else if ( rtype == "3" ) {
                     if ( hasEndDate )
                         r->setMonthly( Recurrence::rMonthlyDay, freq, endDate );
                     else
                         r->setMonthly( Recurrence::rMonthlyDay, freq, -1 );
                     r->addMonthlyDay( startDate.day() );
                 } else if ( rtype == "2" ) {
                     if ( hasEndDate )
                         r->setMonthly( Recurrence::rMonthlyPos, freq, endDate );
                     else
                         r->setMonthly( Recurrence::rMonthlyPos, freq, -1 );
                     QBitArray days( 7 );
                     days.fill( false );
                     days.setBit( startDate.dayOfWeek() - 1 );
                     r->addMonthlyPos( pos, days );
                 } else if ( rtype == "4" ) {
                     if ( hasEndDate )
                         r->setYearly( Recurrence::rYearlyMonth, freq, endDate );
                     else
                         r->setYearly( Recurrence::rYearlyMonth, freq, -1 );
                     r->addYearlyNum( startDate.month() );
                 }
             } else {
                 event->recurrence()->unsetRecurs();
             }
         
             QString categoryList = attList[1] ;
             event->setCategories( lookupCategories( categoryList ) );
 
             // strange 0 semms to mean: alarm enabled
             if ( attList[8] == "0" ) {
                 Alarm *alarm;
                 if (  event->alarms().count() > 0 )
                     alarm = event->alarms().first();
                 else {
                     alarm = new Alarm( event );
                     event->addAlarm( alarm );
                     alarm->setType( Alarm::Audio );
                 }
                 //alarm->setType( Alarm::Audio );
                 alarm->setEnabled( true );
                 int alarmOffset = attList[9].toInt();
                 alarm->setStartOffset( alarmOffset * -60 );
             } else {
                 Alarm *alarm;
                 if (  event->alarms().count() > 0 ) {
                     alarm = event->alarms().first();
                     alarm->setType( Alarm::Audio );
                     alarm->setStartOffset( -60*15 );
                     alarm->setEnabled( false );
                 }
             }
         
             mCalendar->addEvent( event);
         } else if ( qName == "Todo" ) {
             Todo *todo;
 
             todo = existingCalendar->todo( "Sharp_DTM", attList[0] );
             if (todo )
                 todo = (Todo*)todo->clone();
             else
                 todo = new Todo;
 
 //CARDID,CATEGORY,ETDY,LTDY,FNDY,MARK,PRTY,TITL,MEM1
 //  0      1       2    3    4    5    6    7    8
 //1,,,,,1,4,Loch zumachen,""
 //3,Privat,20040317T000000,20040318T000000,20040319T000000,0,5,Call bbb,"notes123 bbb gggg ""bb ""   "
 //2,"Familie,Freunde,Holiday",20040318T000000,20040324T000000,20040317T000000,1,2,tod2,notes
      
             todo->setID( "Sharp_DTM", attList[0]);
             todo->setCsum( "Sharp_DTM", QString::number( cSum ));
             todo->setTempSyncStat( SYNC_TEMPSTATE_NEW_EXTERNAL );
       
             todo->setSummary( attList[7] );
             todo->setDescription( attList[8]);
         
             int priority = attList[6].toInt();
             if ( priority == 0 ) priority = 3;
             todo->setPriority( priority );
         
             QString categoryList = attList[1];
             todo->setCategories( lookupCategories( categoryList ) );
         
        
         
             QString hasDateStr = attList[3]; // due
             if ( !hasDateStr.isEmpty() ) {
                 if ( hasDateStr.right(6) == "000000" ) {
                     todo->setDtDue( QDateTime(fromString( hasDateStr, false ).date(), QTime(0,0,0 )) );
                     todo->setFloats( true );
                 }
                 else {
                     todo->setDtDue( fromString( hasDateStr ) );
                     todo->setFloats( false );
                 }
                 
                 todo->setHasDueDate( true );
             }
             hasDateStr = attList[2];//start
             if ( !hasDateStr.isEmpty() ) {
           
                 todo->setDtStart( fromString( hasDateStr ) );
                 todo->setHasStartDate( true);
             } else
                 todo->setHasStartDate( false );
             hasDateStr = attList[4];//completed
             if ( !hasDateStr.isEmpty() ) {
                 todo->setCompleted(fromString( hasDateStr ) );
             }
             QString completedStr = attList[5];
             if ( completedStr == "0" )
                 todo->setCompleted( true );
             else
                 todo->setCompleted( false );
             mCalendar->addTodo( todo );
         
         } else if ( qName == "Category" ) {
             /*
               QString id = attributes.value( "id" );
               QString name = attributes.value( "name" );
               setCategory( id, name );
             */
         }
         //qDebug("end ");
         return true;
     }
 
    
     void  setCategoriesList ( QStringList * c )
     {
         oldCategories = c;
     }
 
    QDateTime fromString ( QString  s, bool useTz = true ) {
        QDateTime dt;
        int y,m,t,h,min,sec;
        y = s.mid(0,4).toInt();
        m = s.mid(4,2).toInt();
        t = s.mid(6,2).toInt();
        h = s.mid(9,2).toInt();
        min = s.mid(11,2).toInt();
        sec = s.mid(13,2).toInt();
        dt = QDateTime(QDate(y,m,t), QTime(h,min,sec));
       int offset =  KGlobal::locale()->localTimeOffset( dt );
       if ( useTz )
           dt =  dt.addSecs ( offset*60);
        return dt;
 
    }
   protected:
     QDateTime toDateTime( const QString &value )
     {
       QDateTime dt;
       dt.setTime_t( value.toUInt() );
       
       return dt;
     }
 
     QStringList lookupCategories( const QString &categoryList )
     {
       QStringList categoryIds = QStringList::split( ";", categoryList );
       QStringList categories;
       QStringList::ConstIterator it;
       for( it = categoryIds.begin(); it != categoryIds.end(); ++it ) {
           QString cate = category( *it );
           if ( oldCategories ) {
               if ( ! oldCategories->contains( cate ) )
                   oldCategories->append( cate );
               }
           categories.append(cate );
       }
       return categories;
     }
 
   private:
     Calendar *mCalendar;
     QStringList * oldCategories;
     static QString category( const QString &id )
     {
       QMap<QString,QString>::ConstIterator it = mCategoriesMap.find( id );
       if ( it == mCategoriesMap.end() ) return id;
       else return *it;
     }
 
     static void setCategory( const QString &id, const QString &name )
     {
       mCategoriesMap.insert( id, name );
     }
 
     static QMap<QString,QString> mCategoriesMap;
 };
 
 QMap<QString,QString> SharpParser::mCategoriesMap;
 
 SharpFormat::SharpFormat()
 {
     mCategories = 0;
 }
 
 SharpFormat::~SharpFormat()
 {
 }
 ulong SharpFormat::getCsum( const QStringList &  attList)
 {
     int max = attList.count() -1;
     ulong cSum = 0;
     int j,k,i;
     int add;
     for ( i = 1; i < max ; ++i ) {
         QString s = attList[i];
         if ( ! s.isEmpty() ){
             j = s.length();
             for ( k = 0; k < j; ++k ) {
                 int mul = k +1;
                 add = s[k].unicode ();
                 if ( k < 16 )
                     mul = mul * mul;
                 add = add * mul *i*i*i;
                 cSum += add;
             }
         }
     }
     return cSum;
 
 }
 #include <stdlib.h>
 #define DEBUGMODE false
 //#define DEBUGMODE true
 bool SharpFormat::load( Calendar *calendar, Calendar *existngCal )
 {
 
    
     bool debug = DEBUGMODE;
     QString text;
     QString codec = "utf8";
     QLabel status ( i18n("Reading events ..."), 0 );
     
     int w = status.sizeHint().width()+20 ;
     if ( w < 200 ) w = 200;
     int h = status.sizeHint().height()+20 ;
     int dw = QApplication::desktop()->width();
     int dh = QApplication::desktop()->height();
     status.setCaption(i18n("Reading DTM Data") );
     status.setGeometry( (dw-w)/2, (dh - h )/2 ,w,h );
     status.show();
     status.raise();
     qApp->processEvents();
     QString  fileName; 
     if ( ! debug ) {
         fileName = "/tmp/kopitempout";
         QString command ="db2file datebook -r -c "+ codec + " > " + fileName;
         system (  command.latin1() );
     } else {
         fileName = "/tmp/events.txt";
         
     }  
     QFile file( fileName );
     if (!file.open( IO_ReadOnly ) ) {
         return false;
         
     } 
     QTextStream ts( &file );
     ts.setCodec( QTextCodec::codecForName("utf8") );
     text = ts.read();
     file.close();  
     status.setText(  i18n("Processing events ...") );
     status.raise();
     qApp->processEvents();
     fromString2Cal( calendar, existngCal, text, "Event" ); 
     status.setText(  i18n("Reading todos ...") );
     qApp->processEvents();
     if ( ! debug ) {
         fileName = "/tmp/kopitempout";
         QString command = "db2file todo -r -c " + codec+ " > " + fileName;
         system (  command.latin1() );
     } else {
         fileName = "/tmp/todo.txt";
     } 
     file.setName( fileName );
     if (!file.open( IO_ReadOnly ) ) {
         return false;
         
     } 
     ts.setDevice( &file );
     text = ts.read();
     file.close();  
 
     status.setText(  i18n("Processing todos ...") );
     status.raise();
     qApp->processEvents();
     fromString2Cal( calendar, existngCal, text, "Todo" ); 
     return true;
 }
 int  SharpFormat::getNumFromRecord( QString answer, Incidence* inc ) 
 {
     int retval = -1;
     QStringList templist; 
     QString tempString;         
     int start = 0;
     int len = answer.length();
     int end = answer.find ("\n",start)+1;
     bool ok = true;
     start = end;
     int ccc = 0;
     while ( start > 0 ) {
         templist.clear();
         ok = true;
         int loopCount = 0;
         while ( ok ) {
             ++loopCount;
             if ( loopCount >  25 ) {
                 qDebug("KO: Error in while loop"); 
                 ok = false;
                 start = 0;
                 break;
             }
             if ( ok )
                 tempString = getPart(  answer, ok, start );
             if ( start >= len || start == 0 ) {
                 start = 0;
                 ok = false;
             }
             if ( tempString.right(1) =="\n" )
                 tempString = tempString.left( tempString.length()-1);
            
             templist.append( tempString ); 
         }
         ++ccc;
         if ( ccc == 2 && loopCount < 25 ) { 
             start = 0;
             bool ok;
             int newnum = templist[0].toInt( &ok );
             if ( ok && newnum > 0) {
                 retval = newnum; 
                 inc->setID( "Sharp_DTM",templist[0] );
                 inc->setCsum( "Sharp_DTM", QString::number( getCsum( templist ) ));
                 inc->setTempSyncStat( SYNC_TEMPSTATE_NEW_ID );
             }
             if ( ok && newnum == -1 ) {
                 qDebug("Error writing back %s ", inc->summary().latin1());
             }
         }
     }
     //qDebug("getNumFromRecord returning : %d ", retval);
     return retval;
 }
 bool SharpFormat::save( Calendar *calendar)
 {
 
     QLabel status ( i18n("Processing/adding events ..."), 0 );
     int w = status.sizeHint().width()+20 ;
     if ( w < 200 ) w = 200;
     int h = status.sizeHint().height()+20 ;
     int dw = QApplication::desktop()->width();
     int dh = QApplication::desktop()->height();
     status.setCaption(i18n("Writing DTM Data") );
     status.setGeometry( (dw-w)/2, (dh - h )/2 ,w,h );
     status.show();
     status.raise();
     qApp->processEvents();
     bool debug = DEBUGMODE;
     QString codec = "utf8";
     QString answer;
     QString ePrefix = "CARDID,CATEGORY,DSRP,PLCE,MEM1,TIM1,TIM2,ADAY,ARON,ARMN,ARSD,RTYP,RFRQ,RPOS,RDYS,REND,REDT,ALSD,ALED,MDAY\n";
     QString tPrefix = "CARDID,CATEGORY,ETDY,LTDY,FNDY,MARK,PRTY,TITL,MEM1\n";
     QString command;
     QPtrList<Event> er = calendar->rawEvents(); 
     Event* ev = er.first();
     QString  fileName = "/tmp/kopitempout";
     int i = 0;
     QString changeString = ePrefix;
     QString  deleteString = ePrefix;
     bool deleteEnt = false;
     bool changeEnt = false;
     QString message = i18n("Processing event # ");
     int procCount = 0;
     while ( ev ) {
         //qDebug("i %d ", ++i);
         if ( ev->tempSyncStat() != SYNC_TEMPSTATE_NEW_EXTERNAL ) {
             status.setText ( message + QString::number ( ++procCount ) );
              qApp->processEvents();
             QString eString = getEventString( ev );
             if ( ev->tempSyncStat() == SYNC_TEMPSTATE_DELETE ) { // delete
                 // deleting empty strings does not work.
                 // we write first and x  and then delete the record with the x
                 eString = eString.replace( QRegExp(",\"\""),",\"x\"" );
                 changeString += eString + "\n";
                 deleteString += eString + "\n";
                 deleteEnt = true;
                 changeEnt = true;
                 }
             else  if ( ev->getID("Sharp_DTM").isEmpty()  ) {       // add new 
                 QString fileNameIn = "/tmp/kopitempin";
                 QFile fileIn( fileNameIn );
                 if (!fileIn.open( IO_WriteOnly ) ) {
                     return false;
                 } 
                 QTextStream tsIn( &fileIn );
                 tsIn.setCodec( QTextCodec::codecForName("utf8") );
                 tsIn << ePrefix << eString ;
                 fileIn.close();  
                 //command = "(echo \"" + ePrefix + eString + "\" ) | db2file datebook -w -g -c " + codec+ " > "+ fileName;
                 command = "(cat /tmp/kopitempin | db2file datebook -w -g -c " + codec+ ") > "+ fileName;
-                qDebug("command ++++++++ ");
-                qDebug("%s ",command.latin1());
-                qDebug("command -------- ");
+                //qDebug("command ++++++++ ");
+                //qDebug("%s ",command.latin1());
+                //qDebug("command -------- ");
                 system (  command.utf8() );
                 QFile file( fileName );
                 if (!file.open( IO_ReadOnly ) ) {
                     return false;
                     
                 } 
                 QTextStream ts( &file );
                 ts.setCodec( QTextCodec::codecForName("utf8") );
                 answer = ts.read();
                 file.close();  
                 //qDebug("answer \n%s ", answer.latin1());
                 getNumFromRecord( answer, ev  ) ;
 
             }
             else { // change existing
                 //qDebug("canging %d %d",ev->zaurusStat() ,ev->zaurusId() );
                 //command = "(echo \"" + ePrefix + eString + "\" ) | db2file datebook -w -g -c " + codec+ " > "+ fileName;
                 changeString += eString + "\n";
                 changeEnt = true;
 
             }
         } 
         ev =  er.next();
     }
     status.setText ( i18n("Changing events ...") );
     qApp->processEvents();
     //qDebug("changing... ");
     if ( changeEnt ) {
         QFile file( fileName );
         if (!file.open( IO_WriteOnly ) ) {
             return false;
             
         } 
         QTextStream ts( &file );
         ts.setCodec( QTextCodec::codecForName("utf8") );
         ts << changeString ;
         file.close();
         command = "db2file datebook -w -g -c " + codec+ " < "+ fileName;
         system (  command.latin1() );
         //qDebug("command %s file :\n%s ", command.latin1(), changeString.latin1());
         
     }
     status.setText ( i18n("Deleting events ...") );
     qApp->processEvents();
     //qDebug("deleting... ");
     if ( deleteEnt  ) {
         QFile file( fileName );
         if (!file.open( IO_WriteOnly ) ) {
             return false;
             
         } 
         QTextStream ts( &file );
         ts.setCodec( QTextCodec::codecForName("utf8") );
         ts << deleteString;
         file.close();
         command = "db2file datebook -d -c " + codec+ " < "+ fileName;
         system ( command.latin1() );
         // qDebug("command %s file :\n%s ", command.latin1(), deleteString.latin1());
     }
 
 
     changeString = tPrefix;
     deleteString = tPrefix;
     status.setText ( i18n("Processing todos ...") );
     qApp->processEvents();
     QPtrList<Todo> tl = calendar->rawTodos(); 
     Todo* to = tl.first();
     i = 0;
     message = i18n("Processing todo # ");
     procCount = 0;
     while ( to ) {
        if ( to->tempSyncStat() != SYNC_TEMPSTATE_NEW_EXTERNAL ) {
              status.setText ( message + QString::number ( ++procCount ) );
              qApp->processEvents();
             QString eString = getTodoString( to );
             if ( to->tempSyncStat() == SYNC_TEMPSTATE_DELETE ) { // delete
                 // deleting empty strings does not work.
                 // we write first and x  and then delete the record with the x
                 eString = eString.replace( QRegExp(",\"\""),",\"x\"" );
                 changeString += eString + "\n";
                 deleteString += eString + "\n";
                 deleteEnt = true;
                 changeEnt = true;
                 }
             else  if ( to->getID("Sharp_DTM").isEmpty() ) {       // add new 
                 command = "(echo \"" + tPrefix + eString + "\" ) | db2file todo -w -g -c " + codec+ " > "+ fileName;
                 system (  command.utf8() );
                 QFile file( fileName );
                 if (!file.open( IO_ReadOnly ) ) {
                     return false;
                     
                 } 
                 QTextStream ts( &file );
                 ts.setCodec( QTextCodec::codecForName("utf8") );
                 answer = ts.read();
                 file.close();  
                 //qDebug("answer \n%s ", answer.latin1());
                 getNumFromRecord( answer, to  ) ;
 
             }
             else { // change existing
                 //qDebug("canging %d %d",to->zaurusStat() ,to->zaurusId() );
                 //command = "(echo \"" + ePrefix + eString + "\" ) | db2file datebook -w -g -c " + codec+ " > "+ fileName;
                 changeString += eString + "\n";
                 changeEnt = true;
 
             }
         } 
         
         to = tl.next();
     }
     status.setText ( i18n("Changing todos ...") );
     qApp->processEvents();
     //qDebug("changing... ");
     if ( changeEnt ) {
         QFile file( fileName );
         if (!file.open( IO_WriteOnly ) ) {
             return false;
             
         } 
         QTextStream ts( &file );
         ts.setCodec( QTextCodec::codecForName("utf8") );
         ts << changeString ;
         file.close();
         command = "db2file todo -w -g -c " + codec+ " < "+ fileName;
         system (  command.latin1() );
         //qDebug("command %s file :\n%s ", command.latin1(), changeString.latin1());
         
     }
     status.setText ( i18n("Deleting todos ...") );
     qApp->processEvents();
     //qDebug("deleting... ");
     if ( deleteEnt  ) {
         QFile file( fileName );
         if (!file.open( IO_WriteOnly ) ) {
             return false;
             
         } 
         QTextStream ts( &file );
         ts.setCodec( QTextCodec::codecForName("utf8") );
         ts << deleteString;
         file.close();
         command = "db2file todo -d -c " + codec+ " < "+ fileName;
         system ( command.latin1() );
         // qDebug("command %s file :\n%s ", command.latin1(), deleteString.latin1());
     }
         
   return true;
 }
 QString SharpFormat::dtToString( const QDateTime& dti, bool useTZ )
 {
 	QString datestr;
 	QString timestr;
     int offset =  KGlobal::locale()->localTimeOffset( dti );
     QDateTime   dt;
     if (useTZ)
         dt =  dti.addSecs ( -(offset*60));
     else
         dt =  dti;
 	if(dt.date().isValid()){
 		const QDate& date = dt.date();
 		datestr.sprintf("%04d%02d%02d",
     		date.year(), date.month(), date.day());
 	}
 	if(dt.time().isValid()){
 		const QTime& time = dt.time();
 		timestr.sprintf("T%02d%02d%02d",
     		time.hour(), time.minute(), time.second());
 	}
 	return datestr + timestr;
 }
 QString SharpFormat::getEventString( Event* event )
 {
     QStringList list;
     list.append( event->getID("Sharp_DTM")  );
     list.append( event->categories().join(",") );
     if ( !event->summary().isEmpty() )
         list.append( event->summary() );
     else
         list.append("" );
     if ( !event->location().isEmpty() )
         list.append( event->location() );
     else
         list.append("" );
     if ( !event->description().isEmpty() )
         list.append( event->description() );
     else
         list.append( "" );
     if ( event->doesFloat () ) {
         list.append( dtToString( QDateTime(event->dtStart().date(), QTime(0,0,0)), false ));
         list.append( dtToString( QDateTime(event->dtEnd().date(),QTime(23,59,59)), false )); //6
         list.append( "1" );
 
     }
     else {
         list.append( dtToString( event->dtStart()) );
         list.append( dtToString( event->dtEnd()) ); //6
         list.append( "0" );
     }
     bool noAlarm = true;
     if ( event->alarms().count() > 0 ) {
         Alarm * al = event->alarms().first();
         if ( al->enabled() ) {
             noAlarm = false;
             list.append( "0" ); // yes, 0 == alarm
             list.append( QString::number( al->startOffset().asSeconds()/(-60) ) ); 
             if ( al->type() == Alarm::Audio )
                 list.append( "1" ); //  type audio
             else
                 list.append( "0" ); //  type silent     
         }
     }
     if ( noAlarm ) {
         list.append( "1" ); // yes, 1 == no alarm
         list.append( "0" ); // no alarm offset
         list.append( "1" ); // type
     }
     // next is: 11
     // next is: 11-16 are recurrence
     Recurrence* rec = event->recurrence();
    
     bool writeEndDate = false;
     switch ( rec->doesRecur() )
         {
         case Recurrence::rDaily: // 0
             list.append( "0" );
             list.append( QString::number( rec->frequency() ));//12
             list.append( "0" );
             list.append( "0" );
             writeEndDate = true;
             break;
         case Recurrence::rWeekly:// 1
             list.append( "1" );
             list.append( QString::number( rec->frequency()) );//12
             list.append( "0" );
             {
                 int days = 0;
                 QBitArray weekDays = rec->days(); 
                 int i;
                 for( i = 1; i <= 7; ++i ) {
                     if ( weekDays[i-1] ) {
                         days += 1 << (i-1);
                     }
                 }
                 list.append( QString::number( days ) );
             }
             //pending weekdays
             writeEndDate = true;
            
             break;
         case Recurrence::rMonthlyPos:// 2
             list.append( "2" );
             list.append( QString::number( rec->frequency()) );//12
            
             writeEndDate = true; 
             {
                 int count = 1;
                 QPtrList<Recurrence::rMonthPos> rmp;
                 rmp = rec->monthPositions();
                 if ( rmp.first()->negative )
                     count = 5 - rmp.first()->rPos - 1;
                 else
                     count = rmp.first()->rPos - 1;
                 list.append( QString::number( count ) );
            
             }
 
             list.append( "0" );
             break;
         case Recurrence::rMonthlyDay:// 3
             list.append( "3" );
             list.append( QString::number( rec->frequency()) );//12
             list.append( "0" );
             list.append( "0" );
             writeEndDate = true;
             break;
         case Recurrence::rYearlyMonth://4
             list.append( "4" );
             list.append( QString::number( rec->frequency()) );//12
             list.append( "0" );
             list.append( "0" );
             writeEndDate = true;
             break;
        
         default:
             list.append( "255" );
             list.append( QString() );
             list.append( "0" );
             list.append( QString() );
             list.append( "0" );
             list.append( "20991231T000000" );
             break;
         }
     if  ( writeEndDate ) {
         
         if ( rec->endDate().isValid() ) { // 15 + 16
             list.append( "1" );
             list.append( dtToString( rec->endDate()) );
         } else {
             list.append( "0" );
             list.append( "20991231T000000" );
         }
         
     }
     if ( event->doesFloat () ) {
         list.append( dtToString( event->dtStart(), false ).left( 8 ));
         list.append( dtToString( event->dtEnd(), false ).left( 8 )); //6
         
     }
     else {
         list.append( QString() );
         list.append( QString() );
         
     }
     if (event->dtStart().date() == event->dtEnd().date() )
         list.append( "0" );
     else
         list.append( "1" );
 
 
 		for(QStringList::Iterator it=list.begin();
 				it!=list.end(); ++it){
 			QString& s = (*it);
 			s.replace(QRegExp("\""), "\"\"");
 			if(s.contains(QRegExp("[,\"\r\n]")) || s.stripWhiteSpace() != s){
 				s.prepend('\"');
 				s.append('\"');
 			} else if(s.isEmpty() && !s.isNull()){
 				s = "\"\"";
 			}
 		}
 		return list.join(",");
 
 
 }
 QString SharpFormat::getTodoString( Todo* todo )
 {
     QStringList list;
     list.append(  todo->getID("Sharp_DTM")  );
     list.append( todo->categories().join(",") );
 
     if ( todo->hasStartDate() ) {
         list.append( dtToString( todo->dtStart()) );
     } else
         list.append( QString() );
 
     if ( todo->hasDueDate() ) {
         QTime tim;
         if ( todo->doesFloat()) {
         list.append( dtToString( QDateTime(todo->dtDue().date(),QTime( 0,0,0  )), false)) ;
         } else {
             list.append( dtToString(todo->dtDue() ) );
         }
     } else
         list.append( QString() );
 
     if ( todo->isCompleted() ) {  
         list.append( dtToString( todo->completed()) );
         list.append( "0" ); // yes 0 == completed
     } else {
         list.append( dtToString( todo->completed()) );
         list.append( "1" );
     }
     list.append( QString::number( todo->priority() ));
     if( ! todo->summary().isEmpty() )
         list.append( todo->summary() );
     else
         list.append( "" );
     if (! todo->description().isEmpty()  )
         list.append( todo->description() );
     else
         list.append( "" );
 	for(QStringList::Iterator it=list.begin();
         it!=list.end(); ++it){
         QString& s = (*it);
         s.replace(QRegExp("\""), "\"\"");
         if(s.contains(QRegExp("[,\"\r\n]")) || s.stripWhiteSpace() != s){
             s.prepend('\"');
             s.append('\"');
         } else if(s.isEmpty() && !s.isNull()){
             s = "\"\"";
         }
     }
     return list.join(",");
 }
 QString SharpFormat::getPart( const QString & text, bool &ok, int &start )
 {
     //qDebug("start %d ", start);
   
     QString retval ="";
     if ( text.at(start) == '"' ) {
         if ( text.mid( start,2) == "\"\"" && !( text.mid( start+2,1) == "\"")) {
             start = start +2; 
             if ( text.mid( start,1) == "," ) {
                 start += 1;
             }
             retval = "";
             if ( text.mid( start,1) == "\n" ) {
                 start += 1;
                 ok = false; 
             }
             return retval;
         }
         int hk = start+1;
         hk = text.find ('"',hk);
         while ( text.at(hk+1) == '"' )
             hk = text.find ('"',hk+2);
         retval = text.mid( start+1, hk-start-1);
         start = hk+1;
         retval.replace( QRegExp("\"\""), "\""); 
         if ( text.mid( start,1) == "," ) {
             start += 1;
         }
         if ( text.mid( start,1) == "\n" ) {
             start += 1;
             ok = false; 
         }
         //qDebug("retval***%s*** ",retval.latin1() );
         return retval;
 
     } else {
         int nl = text.find ("\n",start);
         int kom = text.find (',',start);
         if ( kom < nl ) {
             // qDebug("kom < nl %d ", kom);
             retval = text.mid(start, kom-start);
             start = kom+1;
             return retval;
         } else {
             if ( nl == kom ) {
                 // qDebug(" nl == kom ");
                 start = 0;
                 ok = false;
                 return "0";
             }
             // qDebug(" nl < kom ", nl);
             retval = text.mid( start, nl-start);
             ok = false;
             start = nl+1;
             return retval;
         }
     }
 }
 bool SharpFormat::fromString( Calendar *calendar, const QString & text)
 {
     return false;
 }
 bool SharpFormat::fromString2Cal( Calendar *calendar,Calendar *existingCalendar, const QString & text, const QString & type)
 {
     // qDebug("test %s ", text.latin1());
     QStringList templist;
     QString tempString;
     int start = 0;
     int len = text.length();
     int end = text.find ("\n",start)+1;
     bool ok = true;
     start = end;
     SharpParser handler( calendar );
     handler.setCategoriesList( mCategories );
     while ( start > 0 ) {
         templist.clear();
         ok = true;
         while ( ok ) {
             tempString = getPart(  text, ok, start );
             if ( start >= len || start == 0 ) {
                 start = 0;
                 ok = false;
             }
             if ( tempString.right(1) =="\n" )
                 tempString = tempString.left( tempString.length()-1);
             //if ( ok ) 
                 templist.append( tempString ); 
                 //qDebug("%d ---%s---", templist.count(),tempString.latin1() );
         }
         handler.startElement( existingCalendar, templist, type );
     }
 
     return false;
 }
 
 QString SharpFormat::toString( Calendar * )
 {
   return QString::null;
 }
diff --git a/libkcal/syncdefines.h b/libkcal/syncdefines.h
index 57642ec..704a670 100644
--- a/libkcal/syncdefines.h
+++ b/libkcal/syncdefines.h
@@ -1,22 +1,24 @@
  
 #ifndef _KSYNC_DEFINES_H_
 #define _KSYNC_DEFINES_H_
 
 #define SYNC_PREF_LOCAL 0
 #define SYNC_PREF_REMOTE 1
 #define SYNC_PREF_NEWEST 2
 #define SYNC_PREF_ASK 3
 #define SYNC_PREF_FORCE_LOCAL 4
 #define SYNC_PREF_FORCE_REMOTE 5
 #define SYNC_PREF_TAKE_BOTH 6
 
 #define SYNC_MODE_NORMAL 0
 #define SYNC_MODE_EXTERNAL 1
 
 #define SYNC_TEMPSTATE_INITIAL 0
+#define SYNC_TEMPSTATE_ADDED_EXTERNAL -1
 #define SYNC_TEMPSTATE_NEW_EXTERNAL  -2
 #define SYNC_TEMPSTATE_DELETE -3
 #define SYNC_TEMPSTATE_NEW_ID -4
+#define SYNC_TEMPSTATE_NEW_CSUM -5
 
 
 #endif