1 files changed, 7 insertions, 7 deletions

diff --git a/libkcal/calendarlocal.cpp b/libkcal/calendarlocal.cpp
index 8a5a76f..ce3cd09 100644
--- a/libkcal/calendarlocal.cpp
+++ b/libkcal/calendarlocal.cpp
@@ -158,287 +158,287 @@ Incidence* CalendarLocal::incidenceForUid( const QString& uid , bool doNotCheckD
     if ( retVal ) return retVal;
     for ( Journal *it = mJournalList.first(); it; it = mJournalList.next() )
         if ( it->uid() == uid ) {
             if( calID ) {
                 if ( event->calID() != calID )
                     continue;
             }
             else {
                 if ( enabledOnly ) {
                     if ( !it->calEnabled() ) {
                         if ( isDup )
                             *isDup = it->calID();
                         continue;
                     }
                 }
             }
             if ( doNotCheckDuplicates ) return it;
             if ( retVal ) {
                 if ( retVal->calID() > it->calID() ) { 
                     if ( isDup )
                         *isDup = retVal->calID();
                     retVal = it;
                 }
             } else {
                 retVal = it;
             }
         }
     return retVal;
 }
 
 bool CalendarLocal::mergeCalendar( Calendar* remote  )
 {
     // 1 look for raw inc in local
     //   if inc not in remote, delete in local
     // 2 look for raw inc in remote
     //   if inc in local, replace it
     //   if not in local, add it to default calendar
     QPtrList<Incidence> localInc = rawIncidences(); 
     Incidence* inL = localInc.first(); 
     while ( inL ) {
         if ( ! inL->isReadOnly () )
             if ( !remote->incidenceForUid( inL->uid(), true ))
                 deleteIncidence( inL );
         inL = localInc.next();
     }
     QPtrList<Incidence> er = remote->rawIncidences(); 
     Incidence* inR = er.first();
     while ( inR ) {
         inL = incidenceForUid( inR->uid(),false );
         if ( inL ) {
             if ( ! inL->isReadOnly () || inL->uid().left(15) == QString("last-syncEvent-") ) {
                 int calID = inL->calID();
                 deleteIncidence( inL );
                 inL = inR->clone();
                 inL->setCalID_block( calID );
                 addIncidence( inL );
             }
         } else {
             inL = inR->clone();
             inL->setCalID_block( 0 );// add to default cal
             addIncidence( inL );
         }
         inR = er.next();
     }
     return true;
 }
 
 
 bool CalendarLocal::addCalendarFile( QString name, int id )
 {
     CalendarLocal calendar( timeZoneId() );
     calendar.setDefaultCalendar( id );
     if ( calendar.load( name ) ) {
         addCalendar( &calendar  );
         return true;
     }
     return false;
 }
 void CalendarLocal::setSyncEventsEnabled()
 {
     Event * ev;
     ev = mEventList.first();
     while ( ev ) {
         if ( ev->uid().left(15) == QString("last-syncEvent-") )
             ev->setCalEnabled( true );
         ev =  mEventList.next();
     } 
 }
 void CalendarLocal::setSyncEventsReadOnly()
 {
     Event * ev;
     ev = mEventList.first();
     while ( ev ) {
         if ( ev->uid().left(15) == QString("last-syncEvent-") ) {
             ev->setReadOnly( true ); 
         }
         ev =  mEventList.next();
     } 
 }
 
 void CalendarLocal::addCalendar( Calendar* cal )
 {
     cal->setDontDeleteIncidencesOnClose();
     setSyncEventsEnabled();
     QPtrList<Incidence> incList;
     {
         QPtrList<Event> EventList = cal->rawEvents();
         Event * ev = EventList.first();
         while ( ev ) {
             if ( ev->uid().left( 15 ) == QString("last-syncEvent-") ) {   
                 ev->setCalID_block( 1 );
             }
             Event * se = event( ev->uid() );
             if ( se )
                 incList.append( se );    
             ev->unRegisterObserver( cal );
             ev->registerObserver( this );
             mEventList.append( ev );
             ev = EventList.next();
         }
          
     }
     {
 
         QPtrList<Todo> TodoList = cal->rawTodos();
         Todo * ev = TodoList.first();
         while ( ev ) {
             ev->resetRelatedTo();
-            ev = TodoList.next();
+            Todo * se = todo( ev->uid() );
+            if ( se )
+                deleteTodo( se ); 
+            ev = TodoList.next();   
         }
-        //TodoList = cal->rawTodos();
+        //TodoList = cal->rawTodos(); 
         ev = TodoList.first();
         while ( ev ) { 
-            Todo * se = todo( ev->uid() );
-            if ( se )
-                incList.append( se );    
             ev->unRegisterObserver( cal );
             ev->registerObserver( this );
             mTodoList.append( ev );
             setupRelations( ev );
             ev = TodoList.next();
         }
     }
     {
         QPtrList<Journal> JournalList = cal->journals();
         Journal * ev = JournalList.first();
         while ( ev ) {
             Journal * se = journal( ev->uid() );
             if ( se )
                 incList.append( se );    
             ev->unRegisterObserver( cal );
             ev->registerObserver( this );
             mJournalList.append( ev );
             ev = JournalList.next();
         }
     }
     {
-        for (Incidence * ev = incList.first(); ev; ev = incList.next() ) {
-            deleteIncidence ( ev );
+        for (Incidence * inc = incList.first(); inc; inc = incList.next() ) {
+            deleteIncidence ( inc );
         }
     }
     setModified( true );
 }
 bool CalendarLocal::load( const QString &fileName )
 {
   FileStorage storage( this, fileName );
   return storage.load();
 }
 
 bool CalendarLocal::save( const QString &fileName, CalFormat *format )
 {
   FileStorage storage( this, fileName, format );
   return storage.save();
 }
 
 void CalendarLocal::stopAllTodos()
 {
     for ( Todo *it = mTodoList.first(); it; it = mTodoList.next() )
         it->setRunning( false );
 
 }
 void CalendarLocal::close()
 {
 
   Todo * i;
   for( i = mTodoList.first(); i; i = mTodoList.next() ) i->setRunning(false);
 
   mEventList.setAutoDelete( true );
   mTodoList.setAutoDelete( true );
   mJournalList.setAutoDelete( true );
 
   mEventList.clear();
   mTodoList.clear();
   mJournalList.clear();
 
   mEventList.setAutoDelete( false );
   mTodoList.setAutoDelete( false );
   mJournalList.setAutoDelete( false );
 
   setModified( false );
 }
 
 bool CalendarLocal::addAnniversaryNoDup( Event *event )
 {
     QString cat;
     bool isBirthday = true;
     if(  event->categoriesStr() == i18n( "Anniversary" ) ) {
         isBirthday = false;
         cat = i18n( "Anniversary" );
     } else if(  event->categoriesStr() == i18n( "Birthday" ) ) {
         isBirthday = true;
         cat = i18n( "Birthday" );
     } else {
         qDebug("addAnniversaryNoDup called without fitting category! ");
         return false;
     }
     Event * eve;
     for ( eve = mEventList.first(); eve ; eve = mEventList.next() ) {
         if ( !(eve->categories().contains( cat ) ))
             continue;
         // now we have an event with fitting category
         if ( eve->dtStart().date() != event->dtStart().date() )
             continue;
         // now we have an event with fitting category+date
         if ( eve->summary() != event->summary() )
             continue;
         // now we have an event with fitting category+date+summary
         return false;
     }
     return addEvent( event );
 
 }
 bool CalendarLocal::addEventNoDup( Event *event )
 {
     Event * eve;
     for ( eve = mEventList.first(); eve ; eve = mEventList.next() ) {
         if ( *eve == *event ) {
             //qDebug("CalendarLocal::Duplicate event found! Not inserted! ");
             return false;
         }
     }
     return addEvent( event );
 }
 
 bool CalendarLocal::addEvent( Event *event )
 {
   insertEvent( event );
 
   event->registerObserver( this );
 
   setModified( true );
   if ( event->calID() == 0 )
       event->setCalID_block( mDefaultCalendar );
   event->setCalEnabled( true );
 
   return true;
 }
 
 void CalendarLocal::deleteEvent( Event *event )
 {
     clearUndo(event);
     if ( mEventList.removeRef( event ) ) {
         setModified( true );
     }
 }
 
 
 Event *CalendarLocal::event( const QString &uid )
 {
     Event *event;
     Event *retVal = 0;
     for ( event = mEventList.first(); event; event = mEventList.next() ) {
         if ( event->calEnabled() && event->uid() == uid ) {
             if ( retVal ) {
                 if ( retVal->calID() > event->calID() ) {
                     retVal = event;
                 }
             } else {
                 retVal = event;
             }
         }
     }
   return retVal;
 }
 bool CalendarLocal::addTodoNoDup( Todo *todo )
 {
   Todo * eve;