completed KDE AB sync. but will it work ...?

2 files changed, 6 insertions, 10 deletions

diff --git a/korganizer/calendarview.cpp b/korganizer/calendarview.cpp
index 326db88..6e61351 100644
--- a/korganizer/calendarview.cpp
+++ b/korganizer/calendarview.cpp
@@ -882,205 +882,205 @@ void CalendarView::checkExternSyncEvent( QPtrList<Event> lastSync , Incidence* t
         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();
     mLastCalendarSync = QDateTime::currentDateTime();
-    if ( mSyncKDE ) {
+    if ( mSyncManager->syncWithDesktop() ) {
         remote->resetPilotStat(1);
         if (  KSyncManager::mRequestedSyncEvent.isValid() ) {
             mLastCalendarSync = KSyncManager::mRequestedSyncEvent;
             qDebug("using extern time for calendar sync: %s ", mLastCalendarSync.toString().latin1() );
             } else {
             qDebug("ERROR: KSyncManager::mRequestedSyncEvent has invalid datatime ");
         }
     }
     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) {
+        if ( mGlobalSyncMode == SYNC_MODE_EXTERNAL || mSyncManager->syncWithDesktop()) {
             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 ( mSyncKDE ) {
+    if ( mSyncManager->syncWithDesktop() ) {
         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 )
+                        if ( mSyncManager->syncWithDesktop() )
                             inR->setPilotId( 2 );
                         ++changedRemote;
                     } else {
                         idS = inL->IDStr();
                         int pid = inL->pilotId();
                         local->deleteIncidence( inL );
                         inL = inR->clone();
-                        if ( mSyncKDE )
+                        if ( mSyncManager->syncWithDesktop() )
                             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 );
                         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") ); 
@@ -1138,97 +1138,97 @@ bool  CalendarView::synchronizeCalendar( Calendar* local,  Calendar* remote, int
                     }
                 }
             }
         }
         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...
+    if ( mGlobalSyncMode ==  SYNC_MODE_NORMAL && !mSyncManager->syncWithDesktop()) // 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 );
@@ -3700,81 +3700,78 @@ void CalendarView::purgeCompleted()
 {
     int result = KMessageBox::warningContinueCancel(this,
                                                     i18n("Delete all\ncompleted To-Dos?"),i18n("Purge To-Dos"),i18n("Purge"));
 
     if (result == KMessageBox::Continue) {
 
         QPtrList<Todo> todoCal;
         QPtrList<Todo> rootTodos;
         //QPtrList<Incidence> rel;
         Todo *aTodo;//, *rTodo;
         Incidence *rIncidence;
         bool childDelete = false;
         bool deletedOne = true;
         todoCal = calendar()->todos();
         for (aTodo = todoCal.first(); aTodo; aTodo = todoCal.next()) {
             if ( !aTodo->relatedTo() )
                 rootTodos.append( aTodo );
         }
         for (aTodo = rootTodos.first(); aTodo; aTodo = rootTodos.next()) {
             removeCompletedSubTodos( aTodo );
         }
 
         updateView();
     }
 }
 
 void CalendarView::slotCalendarChanged()
 {
    ; 
 }
 
 NavigatorBar *CalendarView::navigatorBar()
 {
     return mNavigatorBar;
 }
 
 
 
 void CalendarView::keyPressEvent ( QKeyEvent *e) 
 {
     //qDebug(" alendarView::keyPressEvent ");
     e->ignore();
 }
 
 
 bool CalendarView::sync(KSyncManager* manager, QString filename, int mode)
 {
     // mSyncManager = manager;
-    mSyncKDE = false;
     if ( filename == QDir::homeDirPath ()+"/.kdecalendardump.ics" ) {
         qDebug("SyncKDE request detected!");
-        mSyncKDE = true;
     }
     mCurrentSyncDevice = mSyncManager->getCurrentSyncDevice();
     mCurrentSyncName = mSyncManager->getCurrentSyncName();
     return syncCalendar( filename, mode );
 }
 bool CalendarView::syncExternal(KSyncManager* manager, QString resource)
 {
-    mSyncKDE = false;
     //mSyncManager = manager;
     mCurrentSyncDevice = mSyncManager->getCurrentSyncDevice();
     mCurrentSyncName = mSyncManager->getCurrentSyncName();
     if ( resource == "sharp" )
         syncExternal( 0 );
     if ( resource == "phone" )
          syncExternal( 1 );  
     // pending setmodified
     return true;
 }
 void CalendarView::setSyncManager(KSyncManager* manager)
 {
    mSyncManager = manager;
 }
 
 void  CalendarView::removeSyncInfo( QString syncProfile) 
 {
     qDebug("removeSyncInfo for profile %s ", syncProfile.latin1());
     mCalendar->removeSyncInfo( syncProfile );
 
 }
diff --git a/korganizer/calendarview.h b/korganizer/calendarview.h
index acc20d6..437a51c 100644
--- a/korganizer/calendarview.h
+++ b/korganizer/calendarview.h
@@ -444,97 +444,96 @@ class CalendarView : public KOrg::CalendarViewBase, public KCal::Calendar::Obser
     void beamIncidence(Incidence *) ;
     void beamCalendar() ;
     void beamFilteredCalendar() ;
     void beamIncidenceList(QPtrList<Incidence>) ;
     void manageCategories();
     int addCategories();
     void removeCategories();
     void setSyncDevice( QString );
     void setSyncName( QString );
   protected slots:
     void timerAlarm();
     void suspendAlarm();
     void beamDone( Ir *ir );
     /** Select a view or adapt the current view to display the specified dates. */
     void showDates( const KCal::DateList & );
     void selectWeekNum ( int );
   
   public:
     // show a standard warning
     // returns KMsgBox::yesNoCancel()
     int msgCalModified(); 
     virtual bool sync(KSyncManager* manager, QString filename, int mode);
 
     virtual bool syncExternal(KSyncManager* manager, QString resource);
     virtual void removeSyncInfo( QString syncProfile);
     void setSyncManager(KSyncManager* manager);
     void setLoadedFileVersion(QDateTime);
     bool checkFileVersion(QString fn);
     bool checkFileChanged(QString fn);
     Event* getLastSyncEvent();
     /** Adapt navigation units correpsonding to step size of navigation of the
      * current view.
      */
     void adaptNavigationUnits();
     bool synchronizeCalendar( Calendar* local,  Calendar* remote, int mode );
     int  takeEvent( Incidence* local,  Incidence* remote, int mode, bool full = false );
     //Attendee* getYourAttendee(Event *event);
   protected:
     void schedule(Scheduler::Method, Incidence *incidence = 0);
     
     // returns KMsgBox::OKCandel()
     int msgItemDelete();
     void showEventEditor();
     void showTodoEditor();
     void writeLocale();
     Todo *selectedTodo();
 
   private:
-    bool mSyncKDE;
     KSyncManager* mSyncManager;
     AlarmDialog * mAlarmDialog;
     QString mAlarmNotification;
     QString mSuspendAlarmNotification;
     QTimer* mSuspendTimer;
     QTimer* mAlarmTimer;
     QTimer* mRecheckAlarmTimer;
     void computeAlarm( QString );
     void startAlarm( QString, QString );
     void setSyncEventsReadOnly();
     
     QDateTime loadedFileVersion;
     void checkExternSyncEvent( QPtrList<Event> lastSync , Incidence* toDelete );
     void checkExternalId( Incidence * inc );
     int mGlobalSyncMode;
     QString  mCurrentSyncDevice;
     QString  mCurrentSyncName;
     KOBeamPrefs* beamDialog;
     void init();
     int mDatePickerMode;
     bool mFlagEditDescription;
     QDateTime mLastCalendarSync;
     void createPrinter();
 
     void calendarModified( bool, Calendar * );
 
     CalPrinter *mCalPrinter;
 
     QSplitter    *mPanner;
     QSplitter    *mLeftSplitter;
     QWidget      *mLeftFrame;
     QWidgetStack *mRightFrame;
 
     KDatePicker* mDatePicker;
     QVBox* mDateFrame;
     NavigatorBar *mNavigatorBar;
 
     KDateNavigator *mDateNavigator;       // widget showing small month view.
 
     KOFilterView *mFilterView;
 
     ResourceView *mResourceView;
 
     // calendar object for this viewing instance
     Calendar      *mCalendar;
 
     CalendarResourceManager *mResourceManager;