fix in kapi translation call, clone fix and kde first sync fix

3 files changed, 14 insertions, 6 deletions

diff --git a/kaddressbook/mainembedded.cpp b/kaddressbook/mainembedded.cpp
index 547d208..771bec9 100644
--- a/kaddressbook/mainembedded.cpp
+++ b/kaddressbook/mainembedded.cpp
@@ -1,100 +1,99 @@
 #ifndef DESKTOP_VERSION
 #include <qpe/qpeapplication.h>
 #include <qcopchannel_qws.h> 
 #include <stdlib.h>
 #else
 #include <qapplication.h>
 #include <qwindowsstyle.h>
 #include <qplatinumstyle.h>
 #include <qmainwindow.h>
 #endif
 
 #include <qtextcodec.h> 
 #include <kstandarddirs.h>
 #include <qregexp.h>
 #include <kglobal.h>
 #include <stdio.h>
 #include <qdir.h>
 #include "kabprefs.h"
 #include "kaddressbookmain.h"
 #include "externalapphandler.h"
 #include <libkdepim/kpimglobalprefs.h>
 void dumpMissing();
 int main( int argc, char **argv )
 {
 #ifndef DESKTOP_VERSION
   QPEApplication a( argc, argv );
   a.setKeepRunning ();
 #else
   QApplication a( argc, argv );
   QApplication::setStyle( new QPlatinumStyle ());
   QString hdir = QDir::homeDirPath();
   // there is a bug when creating dirs for WIN 98
   // it is difficult to fix, because we have no WIN 98 runnung
   // such that we try it to create the dirs at startup here
   if ( hdir == "C:\\" ) { // win 98 or ME
        QDir app_dir;
        if ( !app_dir.exists("C:\\kdepim") )
            app_dir.mkdir ("C:\\kdepim");
        if ( !app_dir.exists("C:\\kdepim\\apps") )
            app_dir.mkdir ("C:\\kdepim\\apps");
        if ( !app_dir.exists("C:\\kdepim\\config") )
            app_dir.mkdir ("C:\\kdepim\\config");
        if ( !app_dir.exists("C:\\kdepim\\apps\\kaddressbook") )
            app_dir.mkdir ("C:\\kdepim\\apps\\kaddressbook");
   }
 #endif
 
   bool exitHelp = false;
   if ( argc > 1 ) {
       QString command = argv[1];
       if (  command == "-help" ){
           printf("KA/E command line commands:\n");
           printf("  no command: Start KA/E in usual way\n");
           printf("  -help: This output\n");
           printf(" KA/E is exiting now. Bye!\n");
           exitHelp = true;
       }
   }
   if ( ! exitHelp ) {
 
     KGlobal::setAppName( "kaddressbook" );
 #ifndef DESKTOP_VERSION
     if ( QApplication::desktop()->width() > 320 )
         KGlobal::iconLoader()->setIconPath(QString(getenv("QPEDIR"))+"/pics/kdepim/kaddressbook/icons22/");
     else
         KGlobal::iconLoader()->setIconPath(QString(getenv("QPEDIR"))+"/pics/kdepim/kaddressbook/icons16/");
 #else
       QString fileName ;
       fileName  = qApp->applicationDirPath () + "/kdepim/kaddressbook/icons22/";
       KGlobal::iconLoader()->setIconPath(QDir::convertSeparators(fileName));
       QApplication::addLibraryPath ( qApp->applicationDirPath () );
 
 #endif
       KStandardDirs::setAppDir( QDir::convertSeparators(locateLocal("data", "kaddressbook")));
     // init language
-    KABPrefs::instance();
+      KPimGlobalPrefs::instance()->setGlobalConfig();
        KAddressBookMain m ;
 //US      MainWindow m;
       QObject::connect(&a, SIGNAL (appMessage ( const QCString &, const QByteArray & )), ExternalAppHandler::instance(), SLOT (appMessage ( const QCString &, const QByteArray & )));
 
       
-      KPimGlobalPrefs::instance()->setGlobalConfig();
       
 #ifndef DESKTOP_VERSION
        a.showMainWidget( &m ); 
       
 #else
       a.setMainWidget( &m );
       m.resize (640, 480 );
       m.show();
 #endif 
       a.exec();
 
       dumpMissing();
 
       KPimGlobalPrefs::instance()->writeConfig();
   }
   qDebug("KA: Bye! ");
 }
 
diff --git a/korganizer/calendarview.cpp b/korganizer/calendarview.cpp
index 284ddbf..2ccccfa 100644
--- a/korganizer/calendarview.cpp
+++ b/korganizer/calendarview.cpp
@@ -579,926 +579,935 @@ void  CalendarView::computeAlarm( QString msg )
         }
        
         //qDebug("+++++++system command %s ",tempfilename.latin1() );
     }  
     if ( mess.left( 11 )  == "audio_alarm") {
         bool error = false;
         int len = mess.mid( 11 ).find("+++");
         if ( len < 2 )
             error = true;
         else {
             tempfilename = mess.mid( 11, len );
             if ( !QFile::exists( tempfilename  ) )
                 error = true;
         }
         if ( ! error ) {
             filename = tempfilename;
         }
         mAlarmMessage = mess.mid( 11+len+3+9 );
         //qDebug("audio file command %s ",tempfilename.latin1() );
     } 
     if ( mess.left( 9 )  == "cal_alarm") {
         mAlarmMessage = mess.mid( 9 ) ;
     }
     
     startAlarm( mAlarmMessage, filename );
 
 
 }
 
 void CalendarView::addSuspendAlarm(const QDateTime &qdt, const QString &noti  )
 {
     //qDebug("+++++addSUSPENDAlarm %s %s ", qdt.toString().latin1() , noti.latin1() );
    
     mSuspendAlarmNotification = noti;
     int ms = QDateTime::currentDateTime().secsTo( qdt )*1000;
     //qDebug("Suspend Alarm timer started with secs: %d ", ms/1000);
     mSuspendTimer->start( ms , true );
 
 }
 
 void CalendarView::addAlarm(const QDateTime &qdt, const QString &noti  )
 {
     //qDebug("+++++addAlarm %s %s ", qdt.toString().latin1() , noti.latin1() );
     if ( ! KOPrefs::instance()->mUseInternalAlarmNotification ) {
 #ifndef DESKTOP_VERSION
         AlarmServer::addAlarm ( qdt,"koalarm", noti.latin1() );
 #endif     
         return;
     }
     int maxSec;
     //maxSec = 5; //testing only 
     maxSec = 86400+3600; // one day+1hour
     mAlarmNotification = noti;
     int sec = QDateTime::currentDateTime().secsTo( qdt );
     if ( sec > maxSec ) {
         mRecheckAlarmTimer->start( maxSec * 1000 );
         //  qDebug("recheck Alarm timer started with secs: %d next alarm in sec:%d", maxSec,sec  );
         return;
     } else {
         mRecheckAlarmTimer->stop();
     }
     //qDebug("Alarm timer started with secs: %d ", sec);
     mAlarmTimer->start( sec *1000 , true );
 
 }
 // called by mRecheckAlarmTimer to get next alarm
 // we need this, because a QTimer has only a max range of 25 days
 void CalendarView::recheckTimerAlarm()
 {
     mAlarmTimer->stop();
     mRecheckAlarmTimer->stop();
     mCalendar->checkAlarmForIncidence( 0, true );
 }
 void CalendarView::removeAlarm(const QDateTime &qdt, const QString &noti  )
 {
     //qDebug("-----removeAlarm %s %s ", qdt.toString().latin1() , noti.latin1() );
     if ( ! KOPrefs::instance()->mUseInternalAlarmNotification ) {
 #ifndef DESKTOP_VERSION
         AlarmServer::deleteAlarm (qdt ,"koalarm" ,noti.latin1() );
 #endif   
         return;
     }
     mAlarmTimer->stop();
 }
 void CalendarView::selectWeekNum ( int num  )
 {
     dateNavigator()->selectWeek( num );
     mViewManager->showWeekView();
 }
 KOViewManager *CalendarView::viewManager()
 {
     return mViewManager;
 }
 
 KODialogManager *CalendarView::dialogManager()
 {
     return mDialogManager;
 }
 
 QDate CalendarView::startDate()
 {
     DateList dates = mNavigator->selectedDates();
 
     return dates.first();
 }
 
 QDate CalendarView::endDate()
 {
     DateList dates = mNavigator->selectedDates();
 
     return dates.last();
 }
 
 
 void CalendarView::createPrinter()
 {
 #ifndef KORG_NOPRINTER
     if (!mCalPrinter) {
         mCalPrinter = new CalPrinter(this, mCalendar);
         connect(this, SIGNAL(configChanged()), mCalPrinter, SLOT(updateConfig()));
     }
 #endif
 }
 
 
 //KOPrefs::instance()->mWriteBackFile
 //KOPrefs::instance()->mWriteBackExistingOnly
 
 //  0  syncPrefsGroup->addRadio(i18n("Take local entry on conflict"));
 //  1  syncPrefsGroup->addRadio(i18n("Take remote entry on conflict"));
 //  2  syncPrefsGroup->addRadio(i18n("Take newest entry on conflict"));
 //  3  syncPrefsGroup->addRadio(i18n("Ask for every entry on conflict"));
 //  4  syncPrefsGroup->addRadio(i18n("Force take local entry always"));
 //  5  syncPrefsGroup->addRadio(i18n("Force take remote entry always"));
 
 int  CalendarView::takeEvent( Incidence* local,  Incidence* remote, int mode , bool full )
 {
  
     // 0 equal
     // 1 take local
     // 2 take remote
     // 3 cancel 
     QDateTime lastSync = mLastCalendarSync;
     QDateTime localMod = local->lastModified();
     QDateTime remoteMod = remote->lastModified();
     if ( mGlobalSyncMode == SYNC_MODE_EXTERNAL ) {
         bool remCh, locCh;
         remCh = ( remote->getCsum(mCurrentSyncDevice) != local->getCsum(mCurrentSyncDevice) );
         //if ( remCh )        
             //qDebug("loc %s  rem %s", local->getCsum(mCurrentSyncDevice).latin1(), remote->getCsum(mCurrentSyncDevice).latin1() );
         locCh = ( localMod > mLastCalendarSync );
         if ( !remCh && ! locCh ) {
             //qDebug("both not changed ");
             lastSync = localMod.addDays(1);
             if ( mode <= SYNC_PREF_ASK )
                 return 0;
         } else {
             if ( locCh ) {
                 //qDebug("loc changed %d %s %s", local->revision() , localMod.toString().latin1(), mLastCalendarSync.toString().latin1());
                 lastSync = localMod.addDays( -1 );
                 if ( !remCh )
                     remoteMod = ( lastSync.addDays( -1 ) );
             } else {
                 //qDebug(" not loc changed ");
                 lastSync = localMod.addDays( 1 );
                 if ( remCh )
                     remoteMod =( lastSync.addDays( 1 ) );
                 
             }
         }
         full = true;  
         if ( mode < SYNC_PREF_ASK )
             mode = SYNC_PREF_ASK;
     } else {
           if ( localMod == remoteMod )
               // 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", localMod.toString().latin1() , local->revision(), remoteMod.toString().latin1(), remote->revision());  
     //qDebug("%d %d %d %d ", localMod.time().second(), localMod.time().msec(),  remoteMod.time().second(), remoteMod.time().msec() );
     //full = true; //debug only
     if ( full ) {
         bool equ = false;
         if ( local->type() == "Event" ) {
             equ =  (*((Event*) local) == *((Event*) remote));
         }
         else if ( local->type() =="Todo" )
             equ =  (*((Todo*) local) == (*(Todo*) remote));
         else if ( local->type() =="Journal" )
             equ =  (*((Journal*) local) == *((Journal*) 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()  ,  localMod.toString().latin1() , remoteMod.toString().latin1()  );
 
     if ( full && mode < SYNC_PREF_NEWEST )
         mode = SYNC_PREF_ASK;
 
     switch( mode ) {
     case SYNC_PREF_LOCAL:
         if ( lastSync > remoteMod )
             return 1;
         if ( lastSync > localMod )
             return 2;
         return 1;
         break;
     case SYNC_PREF_REMOTE:
         if ( lastSync > remoteMod )
             return 1;
         if ( lastSync > localMod )
             return 2;
         return 2;
         break;
     case SYNC_PREF_NEWEST:
         if ( localMod > remoteMod )
             return 1;
         else
             return 2;
         break;
     case SYNC_PREF_ASK: 
         //qDebug("lsy %s  ---  lo %s  --- re %s ", lastSync.toString().latin1(), localMod.toString().latin1(), remoteMod.toString().latin1()  );
         if ( lastSync > remoteMod )
             return 1;
         if ( lastSync > localMod )
             return 2;
         //qDebug("lsy %s  ---  lo %s  --- re %s ", lastSync.toString().latin1(), localMod.toString().latin1(), remoteMod.toString().latin1()  );
         localIsNew = localMod >= remoteMod;
         if ( localIsNew )
             getEventViewerDialog()->setColorMode( 1 );
          else 
             getEventViewerDialog()->setColorMode( 2 );
         getEventViewerDialog()->setIncidence(local);
         if ( localIsNew )
             getEventViewerDialog()->setColorMode( 2 );
          else 
             getEventViewerDialog()->setColorMode( 1 );
         getEventViewerDialog()->addIncidence(remote);
         getEventViewerDialog()->setColorMode( 0 );
         //qDebug("local %d remote %d ",local->relatedTo(),remote->relatedTo()  );
         getEventViewerDialog()->setCaption( mCurrentSyncDevice +i18n(" : Conflict! Please choose entry!"));
         getEventViewerDialog()->showMe();
         result = getEventViewerDialog()->executeS( 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;
 }
 Event* CalendarView::getLastSyncEvent()
 {
     Event* lse; 
     //qDebug("CurrentSyncDevice %s ",mCurrentSyncDevice .latin1() );
     lse =   mCalendar->event( "last-syncEvent-"+mCurrentSyncDevice );
     if (!lse) {
         lse = new Event();
         lse->setUid( "last-syncEvent-"+mCurrentSyncDevice ); 
         QString sum = "";
         if ( mSyncManager->mExternSyncProfiles.contains( mCurrentSyncDevice ) )
             sum = "E: ";
         lse->setSummary(sum+mCurrentSyncDevice + i18n(" - sync event"));
         lse->setDtStart( mLastCalendarSync );
         lse->setDtEnd( mLastCalendarSync.addSecs( 7200 ) );
         lse->setCategories( i18n("SyncEvent") );
         lse->setReadOnly( true );
         mCalendar->addEvent( lse );
     }
 
     return lse;
 
 }
 
 // we check, if the to delete event has a id for a profile
 //  if yes, we set this id in the profile to delete
 void CalendarView::checkExternSyncEvent( QPtrList<Event> lastSync , Incidence* toDelete )
 {
     if ( lastSync.count() == 0 ) {
         //qDebug(" lastSync.count() == 0");
         return;
     }
     if ( toDelete->type() == "Journal" )
         return;
 
     Event* eve = lastSync.first();
 
     while ( eve ) {
         QString id = toDelete->getID( eve->uid().mid( 15 ) ); // this is the sync profile name
         if ( !id.isEmpty() ) {
             QString des = eve->description();
             QString pref = "e";
             if ( toDelete->type() == "Todo" )
                 pref = "t";
             des += pref+  id  + ",";
             eve->setReadOnly( false );
             eve->setDescription( des );
             //qDebug("setdes %s ", des.latin1());
             eve->setReadOnly( true );
         }
         eve = lastSync.next();
     }
 
 }
 void CalendarView::checkExternalId( Incidence * inc )
 {
     QPtrList<Event> lastSync = mCalendar->getExternLastSyncEvents() ;
     checkExternSyncEvent( lastSync, inc );
 
 }
 bool  CalendarView::synchronizeCalendar( Calendar* local,  Calendar* remote, int mode )
 {
     bool syncOK = true;
     int addedEvent = 0;
     int addedEventR = 0;
     int deletedEventR = 0;
     int deletedEventL = 0;
     int changedLocal = 0;
     int changedRemote = 0;
     //QPtrList<Event> el = local->rawEvents(); 
     Event* eventR;
     QString uid;
     int take;
     Event* eventL;
     Event* eventRSync;
     Event* eventLSync;
     QPtrList<Event>  eventRSyncSharp = remote->getExternLastSyncEvents();
     QPtrList<Event>  eventLSyncSharp = local->getExternLastSyncEvents();
     bool fullDateRange = false;
     local->resetTempSyncStat();
     if ( mSyncKDE )
         remote->resetPilotStat(1);
     mLastCalendarSync = QDateTime::currentDateTime();
     QDateTime modifiedCalendar = mLastCalendarSync;;
     eventLSync = getLastSyncEvent();
     eventR = remote->event("last-syncEvent-"+mCurrentSyncName );
     if ( eventR ) {
         eventRSync = (Event*) eventR->clone();
         remote->deleteEvent(eventR );
 
     } else {
         if ( mGlobalSyncMode == SYNC_MODE_EXTERNAL || mSyncKDE) {
             eventRSync = (Event*)eventLSync->clone();
         } else {
             fullDateRange = true;
             eventRSync = new Event();
             eventRSync->setSummary(mCurrentSyncName + i18n(" - sync event"));
             eventRSync->setUid("last-syncEvent-"+mCurrentSyncName ); 
             eventRSync->setDtStart( mLastCalendarSync );
             eventRSync->setDtEnd( mLastCalendarSync.addSecs( 7200 ) );
             eventRSync->setCategories( i18n("SyncEvent") );
         }
     }
     if ( eventLSync->dtStart() == mLastCalendarSync )
         fullDateRange = true;
    
     if ( ! fullDateRange  ) {
         if ( eventLSync->dtStart() != eventRSync->dtStart() ) {
             
             // qDebug("set fulldate to true %s %s" ,eventLSync->dtStart().toString().latin1(), eventRSync->dtStart().toString().latin1() ); 
             //qDebug("%d %d %d %d ", eventLSync->dtStart().time().second(), eventLSync->dtStart().time().msec() , eventRSync->dtStart().time().second(), eventRSync->dtStart().time().msec());
             fullDateRange = true;
         } 
     }
-    if ( fullDateRange && !mSyncKDE )
+    if ( mSyncKDE ) {
+        fullDateRange = ( eventLSync->dtStart() == mLastCalendarSync ); 
+    }
+    if ( fullDateRange )
         mLastCalendarSync = QDateTime::currentDateTime().addDays( -100*365);
     else
         mLastCalendarSync = eventLSync->dtStart();
     // for resyncing if own file has changed
     if ( mCurrentSyncDevice == "deleteaftersync" ) {
         mLastCalendarSync = loadedFileVersion;
         //qDebug("setting mLastCalendarSync ");
     }
     //qDebug("*************************** ");
     qDebug("mLastCalendarSync %s full: %d",mLastCalendarSync.toString().latin1(), fullDateRange);
     QPtrList<Incidence> er = remote->rawIncidences(); 
     Incidence* inR = er.first();
     Incidence* 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 ( inR ) {
         if ( ! bar.isVisible() )
             return false;
         if ( incCounter % modulo == 0 )
             bar.setProgress( incCounter );
         ++incCounter;
         uid = inR->uid(); 
         bool skipIncidence = false;
         if ( uid.left(15) == QString("last-syncEvent-") )
             skipIncidence = true;
         QString idS;
         qApp->processEvents();
         if ( !skipIncidence ) {
             inL = local->incidence( uid );
             if ( inL ) { // maybe conflict - same uid in both calendars
                 if ( (take = takeEvent( inL, inR, mode, fullDateRange )) > 0 ) {
                     //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) );
                         else
                             idS = inR->IDStr();
                         remote->deleteIncidence( inR );
                         inR = inL->clone();
                         inR->setTempSyncStat( SYNC_TEMPSTATE_INITIAL );
                         if ( mGlobalSyncMode != SYNC_MODE_EXTERNAL )
                             inR->setIDStr( idS );
                         remote->addIncidence(  inR );
                         if ( mSyncKDE )
                             inR->setPilotId( 2 );
                         ++changedRemote;
                     } else {
                         idS = inL->IDStr();
                         int pid = inL->pilotId();
                         local->deleteIncidence( inL );
                         inL = inR->clone();
                         if ( mSyncKDE )
                             inL->setPilotId( pid  );
                         inL->setIDStr( idS );
                         if ( mGlobalSyncMode == SYNC_MODE_EXTERNAL ) {
                             inL->setCsum( mCurrentSyncDevice, inR->getCsum(mCurrentSyncDevice) );
                             inL->setID( mCurrentSyncDevice, inR->getID(mCurrentSyncDevice) );
                         }
                         local->addIncidence(  inL  );
                         ++changedLocal;
                     }
                 }
             } else { //  no conflict
                 if ( mGlobalSyncMode == SYNC_MODE_EXTERNAL ) {
                     QString des = eventLSync->description(); 
                     QString pref = "e";
                     if ( inR->type() == "Todo" )
                         pref = "t";
                     if ( des.find(pref+ inR->getID(mCurrentSyncDevice)  +"," ) >= 0 && mode != 5) { // delete it
                         inR->setTempSyncStat( SYNC_TEMPSTATE_DELETE );
                         //remote->deleteIncidence( inR );
                         ++deletedEventR; 
                     } else {
                         inR->setLastModified( modifiedCalendar );
                         inL = inR->clone();
+                        inL->setIDStr( ":" );
                         local->addIncidence( inL );
                         ++addedEvent;
                     }
                 } else {
                     if ( inR->lastModified() > mLastCalendarSync || mode == 5 ) {
                         inR->setLastModified( modifiedCalendar );
-                        local->addIncidence( inR->clone() );
+                        inL = inR->clone();
+                        inL->setIDStr( ":" );
+                        local->addIncidence( inL );
                         ++addedEvent;
                     } else {
                         checkExternSyncEvent(eventRSyncSharp, inR);
                         remote->deleteIncidence( inR );
                         ++deletedEventR; 
                     }
                 }
             }
         }
         inR =  er.next();
     }
     QPtrList<Incidence> el = local->rawIncidences(); 
     inL = el.first();
     modulo = (el.count()/10)+1;
     bar.setCaption (i18n("Add / remove events") ); 
     bar.setTotalSteps (  el.count()  ) ;
     bar.show();
     incCounter = 0;
    
     while ( inL ) {
            
         qApp->processEvents();
         if ( ! bar.isVisible() )
             return false;
         if ( incCounter % modulo == 0 )
             bar.setProgress( incCounter );
         ++incCounter;
         uid = inL->uid();
         bool skipIncidence = false;
         if ( uid.left(15) == QString("last-syncEvent-") )
             skipIncidence = true;
         if ( mGlobalSyncMode == SYNC_MODE_EXTERNAL && inL->type() == "Journal" )
             skipIncidence = true;
         if ( !skipIncidence )  {
             inR = remote->incidence( uid );
             if ( ! inR ) { 
                 if ( mGlobalSyncMode == SYNC_MODE_EXTERNAL ) {
                     if ( !inL->getID(mCurrentSyncDevice).isEmpty() && mode != 4 ) {
                         checkExternSyncEvent(eventLSyncSharp, inL);
                         local->deleteIncidence( inL );
                         ++deletedEventL; 
                     } else {
                         if ( ! mSyncManager->mWriteBackExistingOnly ) {
                             inL->removeID(mCurrentSyncDevice );
                             ++addedEventR; 
                             //qDebug("remote added Incidence %s ", inL->summary().latin1());
                             inL->setLastModified( modifiedCalendar );
                             inR = inL->clone();
+                            inR->setIDStr( ":" );
                             inR->setTempSyncStat( SYNC_TEMPSTATE_INITIAL );
                             remote->addIncidence(  inR );
                         }
                     }
                 } else {
                     if ( inL->lastModified() < mLastCalendarSync && mode != 4 ) {
                         checkExternSyncEvent(eventLSyncSharp, inL);
                         local->deleteIncidence( inL );
                         ++deletedEventL; 
                     } else {
                         if ( ! mSyncManager->mWriteBackExistingOnly ) {
                             ++addedEventR; 
                             inL->setLastModified( modifiedCalendar );
-                            remote->addIncidence(  inL->clone() );
+                            inR = inL->clone();
+                            inR->setIDStr( ":" );
+                            remote->addIncidence(  inR );
                         }
                     }
                 }
             }
         }
         inL = el.next();
     }
     int delFut = 0;
     int remRem = 0;
     if ( mSyncManager->mWriteBackInFuture ) {
         er = remote->rawIncidences(); 
         remRem = er.count();
         inR = er.first();
         QDateTime dt;
         QDateTime cur = QDateTime::currentDateTime().addDays( -7 );
         QDateTime end = cur.addDays( (mSyncManager->mWriteBackInFuture +1 ) *7 );
         while ( inR ) {
             if ( inR->type() == "Todo" ) {
                 Todo * t = (Todo*)inR;
                 if ( t->hasDueDate() )
                     dt = t->dtDue();
                 else
                     dt = cur.addSecs( 62 );
             }
             else if (inR->type() == "Event" ) {
                 bool ok;
                 dt =  inR->getNextOccurence( cur, &ok );
                     if ( !ok )
                         dt = cur.addSecs( -62 );
                 }
             else
                 dt = inR->dtStart();
             if ( dt < cur || dt > end ) {
                 remote->deleteIncidence( inR );
                 ++delFut;
             }
             inR =  er.next();
         }
     }
     bar.hide();
     mLastCalendarSync = QDateTime::currentDateTime().addSecs( 1 );
     eventLSync->setReadOnly( false );
     eventLSync->setDtStart( mLastCalendarSync );
     eventRSync->setDtStart( mLastCalendarSync );
     eventLSync->setDtEnd( mLastCalendarSync.addSecs( 3600 ) );
     eventRSync->setDtEnd( mLastCalendarSync.addSecs( 3600 ) );
     eventRSync->setLocation( i18n("Remote from: ")+mCurrentSyncName ) ;
     eventLSync->setLocation(i18n("Local from: ") + mCurrentSyncName  );
     eventLSync->setReadOnly( true );
     if ( mGlobalSyncMode ==  SYNC_MODE_NORMAL && !mSyncKDE) // kde is abnormal...
         remote->addEvent( eventRSync );
     else
         delete eventRSync;
     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"),addedEvent, addedEventR, changedLocal, changedRemote, deletedEventL, deletedEventR ); 
     QString delmess;
     if ( delFut  ) {
         delmess.sprintf(  i18n("%d items skipped on remote,\nbecause they are in the past or\nmore than %d weeks in the future.\nAfter skipping, remote has\n%d calendar/todo items."), delFut,mSyncManager->mWriteBackInFuture, remRem-delFut); 
         mes += delmess;
     }
     if ( mSyncManager->mShowSyncSummary ) {
         KMessageBox::information(this, mes, i18n("KO/Pi Synchronization") );
     }
     qDebug( mes );
     mCalendar->checkAlarmForIncidence( 0, true );
     return syncOK;
 }
 
 void CalendarView::setSyncDevice( QString s )
 {
     mCurrentSyncDevice= s;
 }
 void CalendarView::setSyncName( QString s )
 {
     mCurrentSyncName= s;
 }
 bool CalendarView::syncCalendar(QString filename, int mode)
 {
     //qDebug("syncCalendar %s ", filename.latin1());
     mGlobalSyncMode = SYNC_MODE_NORMAL;
     CalendarLocal* calendar = new CalendarLocal();
     calendar->setTimeZoneId(KPimGlobalPrefs::instance()->mTimeZoneId);
     FileStorage* storage = new FileStorage( calendar );
     bool syncOK = false;
     storage->setFileName( filename );
     // qDebug("loading ... ");
     if ( storage->load() ) {
         getEventViewerDialog()->setSyncMode( true );
         syncOK = synchronizeCalendar( mCalendar, calendar, mode );
         getEventViewerDialog()->setSyncMode( false );
         if (  syncOK ) {
            if ( mSyncManager->mWriteBackFile )
             {
                 storage->setSaveFormat( new ICalFormat() );
                 storage->save();
             }
         }
         setModified( true );
     }
     delete storage;
     delete calendar;
     if ( syncOK )
         updateView();
     return syncOK;
 }
 
 void CalendarView::syncExternal( int mode  )
 {
     mGlobalSyncMode = SYNC_MODE_EXTERNAL;
    
     qApp->processEvents();
     CalendarLocal* calendar = new CalendarLocal();
     calendar->setTimeZoneId(KPimGlobalPrefs::instance()->mTimeZoneId);
     bool syncOK = false;
     bool loadSuccess = false;
     PhoneFormat* phoneFormat = 0;
     emit tempDisableBR(true);
 #ifndef DESKTOP_VERSION
     SharpFormat* sharpFormat = 0;
     if ( mode == 0 ) { // sharp
         sharpFormat = new SharpFormat () ;
         loadSuccess = sharpFormat->load( calendar, mCalendar ); 
 
     } else 
 #endif
         if ( mode == 1 ) { // phone 
         phoneFormat = new PhoneFormat (mCurrentSyncDevice,
                                          mSyncManager->mPhoneDevice,
                                          mSyncManager->mPhoneConnection,
                                          mSyncManager->mPhoneModel);
         loadSuccess = phoneFormat->load( calendar,mCalendar); 
         
         } else {
             emit tempDisableBR(false);
             return;
         }
     if ( loadSuccess ) {
         getEventViewerDialog()->setSyncMode( true );
         syncOK = synchronizeCalendar( mCalendar, calendar, mSyncManager->mSyncAlgoPrefs );
         getEventViewerDialog()->setSyncMode( false );
         qApp->processEvents();
         if (  syncOK ) {
             if ( mSyncManager->mWriteBackFile )
             {
                 QPtrList<Incidence> iL = mCalendar->rawIncidences(); 
                 Incidence* inc = iL.first();
                 if ( phoneFormat ) {
                     while ( inc ) {
                         inc->removeID(mCurrentSyncDevice);
                         inc =  iL.next();
                     }
                 }
 #ifndef DESKTOP_VERSION
                 if ( sharpFormat )
                     sharpFormat->save(calendar);
 #endif
                 if ( phoneFormat )
                     phoneFormat->save(calendar);
                 iL = calendar->rawIncidences(); 
                 inc = iL.first();
                 Incidence* loc;
                 while ( inc ) {
                     if ( inc->tempSyncStat() == SYNC_TEMPSTATE_NEW_ID ) {
                         loc = mCalendar->incidence(inc->uid() );
                         if ( loc ) {
                             loc->setID(mCurrentSyncDevice, inc->getID(mCurrentSyncDevice) );
                             loc->setCsum( mCurrentSyncDevice, inc->getCsum(mCurrentSyncDevice) );
                         }
                     }
                     inc =  iL.next();
                 }
                 Incidence* lse = getLastSyncEvent();
                 if ( lse ) {
                     lse->setReadOnly( false );
                     lse->setDescription( "" );
                     lse->setReadOnly( true );
                 }
             }
         }
         setModified( true );
     } else {
         QString question = i18n("Sorry, the database access\ncommand failed!\n\nNothing synced!\n") ;
         QMessageBox::information( 0, i18n("KO/Pi Import - ERROR"),
                                       question, i18n("Ok")) ;
 
     }
     delete calendar;
     updateView();
     emit tempDisableBR(false);
     return ;//syncOK;
 
 }
 
 bool CalendarView::importBday()
 {
 #ifndef KORG_NOKABC
 
 #ifdef DESKTOP_VERSION
     KABC::StdAddressBook* AddressBook = KABC::StdAddressBook::self( true );
     KABC::AddressBook::Iterator it;
     int count = 0;
     for( it = AddressBook->begin(); it != AddressBook->end(); ++it ) { 
         ++count;
     }
     QProgressBar bar(count,0 );
     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();
     bar.setCaption (i18n("Reading addressbook - close to abort!") );
     qApp->processEvents();
     count = 0;
     int addCount = 0;
     KCal::Attendee* a = 0;
     for( it = AddressBook->begin(); it != AddressBook->end(); ++it ) { 
         if ( ! bar.isVisible() )
             return false;
         bar.setProgress( count++ );
         qApp->processEvents();
         //qDebug("add BDay %s %s", (*it).realName().latin1(),(*it).birthday().date().toString().latin1() );
         if ( (*it).birthday().date().isValid() ){
             a = new KCal::Attendee( (*it).realName(), (*it).preferredEmail(),false,KCal::Attendee::NeedsAction,KCal::Attendee::ReqParticipant,(*it).uid()) ;
             if ( addAnniversary(  (*it).birthday().date(), (*it).assembledName(),  a, true ) )
             ++addCount;
         } 
         QDate anni = KGlobal::locale()->readDate( (*it).custom("KADDRESSBOOK", "X-Anniversary" ), "%Y-%m-%d"); 
         if ( anni.isValid() ){ 
             a = new KCal::Attendee( (*it).realName(), (*it).preferredEmail(),false,KCal::Attendee::NeedsAction,KCal::Attendee::ReqParticipant,(*it).uid()) ;
             if ( addAnniversary(  anni, (*it).assembledName(),  a, false ) )
             ++addCount;
         }
     }
     updateView(); 
     topLevelWidget()->setCaption(QString::number( addCount )+ i18n(" birthdays/anniversaries added!"));
 #else //DESKTOP_VERSION
 
   ExternalAppHandler::instance()->requestBirthdayListFromKAPI("QPE/Application/kopi", this->name() /* name is here the unique uid*/);
   // the result should now arrive through method insertBirthdays
 
 #endif //DESKTOP_VERSION
 
 #endif //KORG_NOKABC
 
 
     return true;
 }
  
 // This method will be called from Ka/Pi as a response to requestBirthdayListFromKAPI
 void CalendarView::insertBirthdays(const QString& uid, const QStringList& birthdayList, 
 				   const QStringList& anniversaryList, const QStringList& realNameList,
 				   const QStringList& emailList, const QStringList& assembledNameList, 
 				   const QStringList& uidList)
 {
   qDebug("CalendarView::insertBirthdays");
   if (uid == this->name())
   {
     int count = birthdayList.count();
     int addCount = 0;
     KCal::Attendee* a = 0;
 
     qDebug("CalView 1 %i", count);
 
     QProgressBar bar(count,0 );
     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();
     bar.setCaption (i18n("inserting birthdays - close to abort!") );
     qApp->processEvents();
 
     QDate birthday;
     QDate anniversary;
     QString realName;
     QString email;
     QString assembledName;
     QString uid;
     bool ok = true;
     for ( int i = 0; i < count; i++)
         {
             if ( ! bar.isVisible() )
                 return;
             bar.setProgress( i );
             qApp->processEvents();
 
             birthday = KGlobal::locale()->readDate(birthdayList[i], KLocale::ISODate, &ok);
             if (!ok) {
                 ;//qDebug("CalendarView::insertBirthdays found invalid birthday: %s",birthdayList[i].latin1());
             }
 
             anniversary = KGlobal::locale()->readDate(anniversaryList[i], KLocale::ISODate, &ok);
             if (!ok) {
                 ;//qDebug("CalendarView::insertBirthdays found invalid anniversary: %s",anniversaryList[i].latin1());
             }
             realName = realNameList[i]; 
             email = emailList[i];
             assembledName = assembledNameList[i];
             uid = uidList[i];
             //qDebug("insert birthday in KO/Pi: %s,%s,%s,%s: %s, %s", realName.latin1(), email.latin1(), assembledName.latin1(), uid.latin1(), birthdayList[i].latin1(), anniversaryList[i].latin1() );
 
             if ( birthday.isValid() ){
                 a = new KCal::Attendee( realName, email,false,KCal::Attendee::NeedsAction,
                                         KCal::Attendee::ReqParticipant,uid) ;
                 if ( addAnniversary(  birthday, assembledName,  a, true ) )
                     ++addCount;
             } 
 
             if ( anniversary.isValid() ){ 
                 a = new KCal::Attendee( realName, email,false,KCal::Attendee::NeedsAction,
                                         KCal::Attendee::ReqParticipant,uid) ;
                 if ( addAnniversary(  anniversary, assembledName,  a, false ) )
                     ++addCount;
             }
         }
 
     updateView(); 
     topLevelWidget()->setCaption(QString::number( addCount )+ i18n(" birthdays/anniversaries added!"));
 
   }
 
 }
 
 
 
 bool  CalendarView::addAnniversary(  QDate date, QString name, KCal::Attendee* a,  bool birthday)
 {
     //qDebug("addAnni ");
     Event * ev = new Event();
     if ( a ) {
         ev->addAttendee( a );
     }
     QString kind;
     if ( birthday )
         kind = i18n( "Birthday" );
     else
         kind = i18n( "Anniversary" );
     ev->setSummary( name + " - " + kind ); 
     ev->setOrganizer(a->email());
     ev->setCategories( kind );
     ev->setDtStart( QDateTime(date) );
     ev->setDtEnd(  QDateTime(date) );
     ev->setFloats( true );
     Recurrence * rec = ev->recurrence();
     rec->setYearly(Recurrence::rYearlyMonth,1,-1);
     rec->addYearlyNum( date.month() );
     if ( !mCalendar->addAnniversaryNoDup( ev ) ) {
         delete ev;
         return false;
     }
     return true;
 
 }
 bool CalendarView::importQtopia( const QString &categories,
                                  const QString &datebook,
                                  const QString &todolist )
 {
     
    QtopiaFormat qtopiaFormat;
     qtopiaFormat.setCategoriesList (  &(KOPrefs::instance()->mCustomCategories));
     if ( !categories.isEmpty() ) qtopiaFormat.load( mCalendar, categories );
     if ( !datebook.isEmpty() ) qtopiaFormat.load( mCalendar, datebook );
     if ( !todolist.isEmpty() ) qtopiaFormat.load( mCalendar, todolist );
    
     updateView();
     return true;
 
 #if 0
  mGlobalSyncMode = SYNC_MODE_QTOPIA;
     mCurrentSyncDevice = "qtopia-XML";
     if ( mSyncManager->mAskForPreferences )
         edit_sync_options(); 
     qApp->processEvents();
     CalendarLocal* calendar = new CalendarLocal();
     calendar->setTimeZoneId(KPimGlobalPrefs::instance()->mTimeZoneId);
     bool syncOK = false;
  QtopiaFormat qtopiaFormat;
     qtopiaFormat.setCategoriesList (  &(KOPrefs::instance()->mCustomCategories));
diff --git a/libkcal/incidence.cpp b/libkcal/incidence.cpp
index 55ac6d4..5a9ef0e 100644
--- a/libkcal/incidence.cpp
+++ b/libkcal/incidence.cpp
@@ -1,568 +1,568 @@
 /*
     This file is part of libkcal.
     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.
 */
 
 #include <kglobal.h>
 #include <klocale.h>
 #include <kdebug.h>
 
 #include "calformat.h"
 
 #include "incidence.h"
 #include "todo.h"
 
 using namespace KCal;
 
 Incidence::Incidence() :
   IncidenceBase(),
   mRelatedTo(0), mSecrecy(SecrecyPublic), mPriority(3)
 {
   mRecurrence = new Recurrence(this);
   mCancelled = false;
   recreate();
   mHasStartDate = true;
   mAlarms.setAutoDelete(true);
   mAttachments.setAutoDelete(true);
 }
 
 Incidence::Incidence( const Incidence &i ) : IncidenceBase( i )
 {
 // TODO: reenable attributes currently commented out.
   mRevision = i.mRevision;
   mCreated = i.mCreated;
   mDescription = i.mDescription;
   mSummary = i.mSummary;
   mCategories = i.mCategories;
 //  Incidence *mRelatedTo;          Incidence *mRelatedTo;
   mRelatedTo = 0;
   mRelatedToUid = i.mRelatedToUid;
 //  QPtrList<Incidence> mRelations;    QPtrList<Incidence> mRelations;
   mExDates = i.mExDates;
   mAttachments = i.mAttachments;
   mResources = i.mResources;
   mSecrecy = i.mSecrecy;
   mPriority = i.mPriority;
   mLocation = i.mLocation;
   mCancelled = i.mCancelled;
   mHasStartDate = i.mHasStartDate;
   QPtrListIterator<Alarm> it( i.mAlarms );
   const Alarm *a;
   while( (a = it.current()) ) {
     Alarm *b = new Alarm( *a );
     b->setParent( this );
     mAlarms.append( b );
 
     ++it;
   }
   mAlarms.setAutoDelete(true);
 
   mRecurrence = new Recurrence( *(i.mRecurrence), this );
 }
 
 Incidence::~Incidence()
 {
    
   Incidence *ev;
    QPtrList<Incidence> Relations = relations();
   for (ev=Relations.first();ev;ev=Relations.next()) {
     if (ev->relatedTo() == this) ev->setRelatedTo(0);
   } 
   if (relatedTo()) relatedTo()->removeRelation(this);
   delete mRecurrence; 
  
 }
 
 bool Incidence::cancelled() const
 {
     return mCancelled;
 }
 void Incidence::setCancelled( bool b )
 {
     mCancelled = b;
     updated();
 }
 bool Incidence::hasStartDate() const
 {
   return mHasStartDate;
 }
 
 void Incidence::setHasStartDate(bool f)
 {
   if (mReadOnly) return;
   mHasStartDate = f;
   updated();
 }
 
 // A string comparison that considers that null and empty are the same
 static bool stringCompare( const QString& s1, const QString& s2 )
 {
     if ( s1.isEmpty() && s2.isEmpty() )
         return true;
     return s1 == s2;
 }
 
 bool KCal::operator==( const Incidence& i1, const Incidence& i2 )
 {
   
     if( i1.alarms().count() != i2.alarms().count() ) {
         return false; // no need to check further
     }
     if ( i1.alarms().count() > 0 ) {
         if ( !( *(i1.alarms().first()) == *(i2.alarms().first())) ) 
             {
             qDebug("alarm not equal ");
             return false;
         }
     }
 #if 0
     QPtrListIterator<Alarm> a1( i1.alarms() );
     QPtrListIterator<Alarm> a2( i2.alarms() );
     for( ; a1.current() && a2.current(); ++a1, ++a2 ) {
         if( *a1.current() == *a2.current() ) {
             continue;
         }
         else {
             return false;
         }
     }
 #endif
   
     if ( ! operator==( (const IncidenceBase&)i1, (const IncidenceBase&)i2 ) )
         return false;
     if ( i1.hasStartDate() == i2.hasStartDate() ) {
         if ( i1.hasStartDate() ) {
             if ( i1.dtStart() != i2.dtStart() )
                 return false;
         }
     } else {
         return false;
     }
     if (!( *i1.recurrence() == *i2.recurrence()) ) {
         qDebug("recurrence is NOT equal ");
         return false;
     }
     return
         //  i1.created() == i2.created() &&
         stringCompare( i1.description(), i2.description() ) &&
         stringCompare( i1.summary(), i2.summary() ) &&
         i1.categories() == i2.categories() &&
         // no need to compare mRelatedTo
         stringCompare( i1.relatedToUid(), i2.relatedToUid() ) &&
         //      i1.relations() == i2.relations() &&
         i1.exDates() == i2.exDates() &&
         i1.attachments() == i2.attachments() &&
         i1.resources() == i2.resources() &&
         i1.secrecy() == i2.secrecy() &&
         i1.priority() == i2.priority() &&
         stringCompare( i1.location(), i2.location() );
 }
 
 
 void Incidence::recreate()
 {
   setCreated(QDateTime::currentDateTime());
 
   setUid(CalFormat::createUniqueId());
 
   setRevision(0);
-
+  setIDStr( ":" );
   setLastModified(QDateTime::currentDateTime());
 }
 
 void Incidence::setReadOnly( bool readOnly )
 {
   IncidenceBase::setReadOnly( readOnly );
   recurrence()->setRecurReadOnly( readOnly);
 }
 
 void Incidence::setCreated(QDateTime created)
 {
   if (mReadOnly) return;
   mCreated = getEvenTime(created);
 }
 
 QDateTime Incidence::created() const
 {
   return mCreated;
 }
 
 void Incidence::setRevision(int rev)
 {
   if (mReadOnly) return;
   mRevision = rev;
 
   updated();
 }
 
 int Incidence::revision() const
 {
   return mRevision;
 }
 
 void Incidence::setDtStart(const QDateTime &dtStart)
 {
 
   QDateTime  dt = getEvenTime(dtStart);
   recurrence()->setRecurStart( dt);
   IncidenceBase::setDtStart( dt );
 }
 
 void Incidence::setDescription(const QString &description)
 {
   if (mReadOnly) return;
   mDescription = description;
   updated();
 }
 
 QString Incidence::description() const
 {
   return mDescription;
 }
 
 
 void Incidence::setSummary(const QString &summary)
 {
   if (mReadOnly) return;
   mSummary = summary;
   updated();
 }
 
 QString Incidence::summary() const
 {
   return mSummary;
 }
 
 void Incidence::setCategories(const QStringList &categories)
 {
   if (mReadOnly) return;
   mCategories = categories;
   updated();
 }
 
 // TODO: remove setCategories(QString) function
 void Incidence::setCategories(const QString &catStr)
 {
   if (mReadOnly) return;
   mCategories.clear();
 
   if (catStr.isEmpty()) return;
 
   mCategories = QStringList::split(",",catStr);
 
   QStringList::Iterator it;
   for(it = mCategories.begin();it != mCategories.end(); ++it) {
     *it = (*it).stripWhiteSpace();
   }
 
   updated();
 }
 
 QStringList Incidence::categories() const
 {
   return mCategories;
 }
 
 QString Incidence::categoriesStr()
 {
   return mCategories.join(",");
 }
 
 void Incidence::setRelatedToUid(const QString &relatedToUid)
 {
   if (mReadOnly) return;
   mRelatedToUid = relatedToUid;
 }
 
 QString Incidence::relatedToUid() const
 {
   return mRelatedToUid;
 }
 
 void Incidence::setRelatedTo(Incidence *relatedTo)
 {
     //qDebug("Incidence::setRelatedTo %d ", relatedTo);
     //qDebug("setRelatedTo(Incidence *relatedTo) %s %s", summary().latin1(), relatedTo->summary().latin1() );
   if (mReadOnly || mRelatedTo == relatedTo) return;
   if(mRelatedTo) {
       // updated();
     mRelatedTo->removeRelation(this);
   }
   mRelatedTo = relatedTo;
   if (mRelatedTo) mRelatedTo->addRelation(this);
 }
 
 Incidence *Incidence::relatedTo() const
 {
   return mRelatedTo;
 }
 
 QPtrList<Incidence> Incidence::relations() const
 {
   return mRelations;
 }
 
 void Incidence::addRelation(Incidence *event)
 {
   if( mRelations.findRef( event ) == -1 ) {
     mRelations.append(event);
     //updated();
   }
 }
 
 void Incidence::removeRelation(Incidence *event)
 {
   
   mRelations.removeRef(event); 
  
 //  if (event->getRelatedTo() == this) event->setRelatedTo(0);
 }
 
 bool Incidence::recursOn(const QDate &qd) const
 {
   if (recurrence()->recursOnPure(qd) && !isException(qd)) return true;
   else return false;
 }
 
 void Incidence::setExDates(const DateList &exDates)
 {
   if (mReadOnly) return;
   mExDates = exDates;
 
   recurrence()->setRecurExDatesCount(mExDates.count());
 
   updated();
 }
 
 void Incidence::addExDate(const QDate &date)
 {
   if (mReadOnly) return;
   mExDates.append(date);
 
   recurrence()->setRecurExDatesCount(mExDates.count());
 
   updated();
 }
 
 DateList Incidence::exDates() const
 {
   return mExDates;
 }
 
 bool Incidence::isException(const QDate &date) const
 {
   DateList::ConstIterator it;
   for( it = mExDates.begin(); it != mExDates.end(); ++it ) {
     if ( (*it) == date ) {
       return true;
     }
   }
 
   return false;
 }
 
 void Incidence::addAttachment(Attachment *attachment)
 {
   if (mReadOnly || !attachment) return;
   mAttachments.append(attachment);
   updated();
 }
 
 void Incidence::deleteAttachment(Attachment *attachment)
 {
   mAttachments.removeRef(attachment);
 }
 
 void Incidence::deleteAttachments(const QString& mime)
 {
   Attachment *at = mAttachments.first();
   while (at) {
     if (at->mimeType() == mime)
       mAttachments.remove();
     else
       at = mAttachments.next();
   }
 }
 
 QPtrList<Attachment> Incidence::attachments() const
 {
   return mAttachments;
 }
 
 QPtrList<Attachment> Incidence::attachments(const QString& mime) const
 {
   QPtrList<Attachment> attachments;
   QPtrListIterator<Attachment> it( mAttachments );
   Attachment *at;
   while ( (at = it.current()) ) {
     if (at->mimeType() == mime)
       attachments.append(at);
     ++it;
   }
 
   return attachments;
 }
 
 void Incidence::setResources(const QStringList &resources)
 {
   if (mReadOnly) return;
   mResources = resources;
   updated();
 }
 
 QStringList Incidence::resources() const
 {
   return mResources;
 }
 
 
 void Incidence::setPriority(int priority)
 {
   if (mReadOnly) return;
   mPriority = priority;
   updated();
 }
 
 int Incidence::priority() const
 {
   return mPriority;
 }
 
 void Incidence::setSecrecy(int sec)
 {
   if (mReadOnly) return;
   mSecrecy = sec;
   updated();
 }
 
 int Incidence::secrecy() const
 {
   return mSecrecy;
 }
 
 QString Incidence::secrecyStr() const
 {
   return secrecyName(mSecrecy);
 }
 
 QString Incidence::secrecyName(int secrecy)
 {
   switch (secrecy) {
     case SecrecyPublic:
       return i18n("Public");
       break;
     case SecrecyPrivate:
       return i18n("Private");
       break;
     case SecrecyConfidential:
       return i18n("Confidential");
       break;
     default:
       return i18n("Undefined");
       break;
   }
 }
 
 QStringList Incidence::secrecyList()
 {
   QStringList list;
   list << secrecyName(SecrecyPublic);
   list << secrecyName(SecrecyPrivate);
   list << secrecyName(SecrecyConfidential);
 
   return list;
 }
 
 
 QPtrList<Alarm> Incidence::alarms() const
 {
   return mAlarms;
 }
 
 Alarm* Incidence::newAlarm()
 {
   Alarm* alarm = new Alarm(this);
   mAlarms.append(alarm);
 //  updated();
   return alarm;
 }
 
 void Incidence::addAlarm(Alarm *alarm)
 {
   mAlarms.append(alarm);
   updated();
 }
 
 void Incidence::removeAlarm(Alarm *alarm)
 {
   mAlarms.removeRef(alarm);
   updated();
 }
 
 void Incidence::clearAlarms()
 {
   mAlarms.clear();
   updated();
 }
 
 bool Incidence::isAlarmEnabled() const
 {
   Alarm* alarm;
   for (QPtrListIterator<Alarm> it(mAlarms); (alarm = it.current()) != 0; ++it) {
     if (alarm->enabled())
       return true;
   }
   return false;
 }
 
 Recurrence *Incidence::recurrence() const
 {
   return mRecurrence;
 }
 void Incidence::setRecurrence( Recurrence * r) 
 {
   delete mRecurrence;
   mRecurrence = r;
 }
 
 void Incidence::setLocation(const QString &location)
 {
   if (mReadOnly) return;
   mLocation = location;
   updated();
 }
 
 QString Incidence::location() const
 {
   return mLocation;
 }
 
 ushort Incidence::doesRecur() const
 {
   if ( mRecurrence ) return mRecurrence->doesRecur();
   else return Recurrence::rNone;
 }
 
 QDateTime Incidence::getNextOccurence( const QDateTime& dt, bool* ok ) const
 {
     QDateTime incidenceStart = dt;
     *ok = false;
     if ( doesRecur() ) {
         bool last;
          recurrence()->getPreviousDateTime( incidenceStart , &last );
          int count = 0;