ync

6 files changed, 83 insertions, 20 deletions

diff --git a/libkcal/calendar.cpp b/libkcal/calendar.cpp
index 8535191..1350f6d 100644
--- a/libkcal/calendar.cpp
+++ b/libkcal/calendar.cpp
@@ -1,34 +1,33 @@
 /*
     This file is part of libkcal.
     Copyright (c) 1998 Preston Brown
     Copyright (c) 2000,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 <stdlib.h>
 #include <time.h>
 
 #include <kdebug.h>
 #include <kglobal.h>
 #include <klocale.h>
 
 #include "exceptions.h"
 #include "calfilter.h"
 
 #include "calendar.h"
 #include "syncdefines.h"
 
@@ -399,67 +398,71 @@ Incidence* Calendar::incidence( const QString& uid )
   Incidence* i;
 
   if( (i = todo( uid )) != 0 )
     return i;
   if( (i = event( uid )) != 0 )
     return i;
   if( (i = journal( uid )) != 0 )
       return i;
 
   return 0;
 }
 
 QPtrList<Todo> Calendar::todos()
 {
   QPtrList<Todo> tl = rawTodos();
   mFilter->apply( &tl );
   return tl;
 }
 
 // When this is called, the todo have already been added to the calendar.
 // This method is only about linking related todos
 void Calendar::setupRelations( Incidence *incidence )
 {
   QString uid = incidence->uid();
-  //qDebug("Calendar::setupRelations ");
+  //qDebug("Calendar::setupRelations %s", incidence->summary().latin1());
   // First, go over the list of orphans and see if this is their parent
   while( Incidence* i = mOrphans[ uid ] ) {
     mOrphans.remove( uid );
     i->setRelatedTo( incidence );
+    //qDebug("Add child %s ti inc  %s", i->summary().latin1(),incidence->summary().latin1());
     incidence->addRelation( i );
     mOrphanUids.remove( i->uid() );
   }
 
   // Now see about this incidences parent
   if( !incidence->relatedTo() && !incidence->relatedToUid().isEmpty() ) {
     // This incidence has a uid it is related to, but is not registered to it yet
     // Try to find it
-    Incidence* parent = this->incidence( incidence->relatedToUid() );
+    //qDebug("Test parent for   %s", incidence->summary().latin1());
+    Incidence* parent = this->incidenceForUid( incidence->relatedToUid(), true );
     if( parent ) {
       // Found it
+        // qDebug("parent found for for   %s", incidence->summary().latin1());
       incidence->setRelatedTo( parent );
       parent->addRelation( incidence );
     } else {
+        // qDebug("NO parent found for for   %s", incidence->summary().latin1());
       // Not found, put this in the mOrphans list
       mOrphans.insert( incidence->relatedToUid(), incidence );
       mOrphanUids.insert( incidence->uid(), incidence );
     }
   }
 }
 
 // If a task with subtasks is deleted, move it's subtasks to the orphans list
 void Calendar::removeRelations( Incidence *incidence )
 {
     // qDebug("Calendar::removeRelations ");
     QString uid = incidence->uid();
 
     QPtrList<Incidence> relations = incidence->relations();
     for( Incidence* i = relations.first(); i; i = relations.next() )
         if( !mOrphanUids.find( i->uid() ) ) {
             mOrphans.insert( uid, i );
             mOrphanUids.insert( i->uid(), i );
             i->setRelatedTo( 0 );
             i->setRelatedToUid( uid );
         }
 
     // If this incidence is related to something else, tell that about it
     if( incidence->relatedTo() )
diff --git a/libkcal/calendar.h b/libkcal/calendar.h
index f301768..fbc40ad 100644
--- a/libkcal/calendar.h
+++ b/libkcal/calendar.h
@@ -56,49 +56,50 @@ namespace KCal {
   as pointers, that means all changes to the returned events are immediately
   visible in the Calendar. You shouldn't delete any Event object you get from
   Calendar.
 */
 class Calendar : public QObject, public CustomProperties,
                  public IncidenceBase::Observer
 {
     Q_OBJECT
 public:
     Calendar();
     Calendar(const QString &timeZoneId);
     virtual ~Calendar();
     Incidence * undoIncidence() { return mUndoIncidence; };
     bool undoDeleteIncidence();
     void deleteIncidence(Incidence *in);
     void resetTempSyncStat();
     void resetPilotStat(int id);
     /**
       Clears out the current calendar, freeing all used memory etc.
     */
     virtual void close() = 0;
     virtual void addCalendar( Calendar*  ) = 0;
     virtual bool addCalendarFile( QString name, int id ) = 0;
     virtual bool mergeCalendarFile( QString name ) = 0;
-    virtual Incidence* incidenceForUid( const QString& uid, bool doNotCheckDuplicates , bool enabledOnly = false  ) = 0;
+    virtual Incidence* incidenceForUid( const QString& uid, bool doNotCheckDuplicates , bool enabledOnly = false ,int * isDup = 0 ) = 0;
+    virtual Todo* todoForUid( const QString& uid, bool doNotCheckDuplicates = true, bool enabledOnly = false  ,int * isDup = 0) = 0;
     virtual void setSyncEventsReadOnly() = 0;
     virtual void setSyncEventsEnabled() = 0;
     virtual void stopAllTodos() = 0;
     virtual void clearUndo( Incidence * newUndo );
   
     /**
       Sync changes in memory to persistant storage.
     */
     virtual void save() = 0;
     virtual QPtrList<Event> getExternLastSyncEvents() = 0;
     virtual void removeSyncInfo( QString syncProfile) = 0; 
     virtual bool isSaving() { return false; }
 
     /**
       Return the owner of the calendar's full name.
     */
     const QString &getOwner() const;
     /**
       Set the owner of the calendar. Should be owner's full name.
     */
     void setOwner( const QString &os );
     /**
       Return the email address of the calendar owner.
     */
diff --git a/libkcal/calendarlocal.cpp b/libkcal/calendarlocal.cpp
index ad8ace3..980663f 100644
--- a/libkcal/calendarlocal.cpp
+++ b/libkcal/calendarlocal.cpp
@@ -58,94 +58,145 @@ CalendarLocal::CalendarLocal(const QString &timeZoneId)
 }
 
 void CalendarLocal::init()
 {
     mNextAlarmIncidence = 0;
 }
 
 
 CalendarLocal::~CalendarLocal()
 {
     registerObserver( 0 );
     if ( mDeleteIncidencesOnClose )
         close();
 }
 bool CalendarLocal::mergeCalendarFile( QString name )
 {
     CalendarLocal calendar( timeZoneId() );
     calendar.setDefaultCalendar( 1 );
     if ( calendar.load( name ) ) {
         mergeCalendar( &calendar  );
         return true;
     }
     return false;
 }
- 
-Incidence* CalendarLocal::incidenceForUid( const QString& uid , bool doNotCheckDuplicates, bool enabledOnly ) 
+
+Todo* CalendarLocal::todoForUid( const QString& uid, bool doNotCheckDuplicates, bool enabledOnly,int * isDup )
 {
+
+    int calID = 0;
+    if ( isDup  && *isDup > 0 )
+        calID = *isDup;
     Todo *todo;;
-    Incidence *retVal = 0;
+    Todo *retVal = 0;
     for ( todo = mTodoList.first(); todo; todo = mTodoList.next() ) {
         if ( todo->uid() == uid ) {
-            if ( enabledOnly )
-                if ( !todo->calEnabled() )
+            if( calID ) {
+                if ( todo->calID() != calID )
                     continue;
+            }
+            else {
+                if ( enabledOnly ) {
+                    if ( !todo->calEnabled() ) {
+                        if ( isDup )
+                            *isDup = todo->calID();
+                        continue;
+                    }
+                }
+            }
             if ( doNotCheckDuplicates ) return todo;
             if ( retVal ) {
                 if ( retVal->calID() > todo->calID() ) {
+                    if ( isDup )
+                        *isDup = retVal->calID();
                     retVal = todo;
                 }
             } else {
                 retVal = todo;
             }
         } 
     }
+    return retVal;
+} 
+//if ( isDup) and * isDup == 0: store duplicate found cal id in  isDup
+//if ( isDup) and * isDup > 0: search only in calendar with ID *isDup, ignore enabledOnly
+
+Incidence* CalendarLocal::incidenceForUid( const QString& uid , bool doNotCheckDuplicates, bool enabledOnly, int * isDup ) 
+{
+    int calID = 0;
+    if ( isDup  && *isDup > 0 )
+        calID = *isDup;
+    Incidence *retVal = todoForUid( uid , doNotCheckDuplicates,enabledOnly, isDup );
     if ( retVal ) return retVal;
     Event *event;
     for ( event = mEventList.first(); event; event = mEventList.next() ) {
         if (  event->uid() == uid ) {
-            if ( enabledOnly )
-                if ( !event->calEnabled() )
+            if( calID ) {
+                if ( event->calID() != calID )
                     continue;
+            }
+            else {
+                if ( enabledOnly ) {
+                    if ( !event->calEnabled() )  {
+                        if ( isDup )
+                            *isDup =event->calID() ;
+                        continue;
+                    }
+                }
+            }
             if ( doNotCheckDuplicates ) return event;
             if ( retVal ) {
                 if ( retVal->calID() > event->calID() ) {
+                    if ( isDup )
+                        *isDup = retVal->calID();
                     retVal = event;
                 }
             } else {
                 retVal = event;
             }
         }
     }
     if ( retVal ) return retVal;
     for ( Journal *it = mJournalList.first(); it; it = mJournalList.next() )
         if ( it->uid() == uid ) {
-            if ( enabledOnly )
-                if ( !it->calEnabled() )
+            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 ( 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();
     }
@@ -212,53 +263,49 @@ void CalendarLocal::addCalendar( Calendar* cal )
         QPtrList<Event> EventList = cal->rawEvents();
         QPtrList<Event> el;
         Event * ev = EventList.first();
         while ( ev ) {
             if ( ev->uid().left( 15 ) == QString("last-syncEvent-") ) {
                 Event * se = event( ev->uid() );
                 if ( se )
                     el.append( se );    
                 ev->setCalID_block( 1 );
             }
             ev->unRegisterObserver( cal );
             ev->registerObserver( this );
             mEventList.append( ev );
             ev = EventList.next();
         }
          for ( ev = el.first(); ev; ev = el.next() ) {
            deleteIncidence ( ev );
         }
     }
     {
 
         QPtrList<Todo> TodoList = cal->rawTodos();
         Todo * ev = TodoList.first();
         while ( ev ) {
-            QString rel = ev->relatedToUid();
-            if ( !rel.isEmpty() ){
-                ev->setRelatedTo ( 0 );
-                ev->setRelatedToUid( rel );
-            }
+            ev->resetRelatedTo();
             ev = TodoList.next();
         }
         //TodoList = cal->rawTodos();
         ev = TodoList.first();
         while ( ev ) {
             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 ) {
             ev->unRegisterObserver( cal );
             ev->registerObserver( this );
             mJournalList.append( ev );
             ev = JournalList.next();
         }
     }
     setModified( true );
 }
@@ -391,55 +438,59 @@ bool CalendarLocal::addTodoNoDup( Todo *todo )
             //qDebug("duplicate todo found! not inserted! ");
             return false;
         }
     }
     return addTodo( todo );
 }
 bool CalendarLocal::addTodo( Todo *todo )
 {
   mTodoList.append( todo );
 
   todo->registerObserver( this );
 
   // Set up subtask relations
   setupRelations( todo );
 
   setModified( true );
   if ( todo->calID() == 0 )
   todo->setCalID_block( mDefaultCalendar );
   todo->setCalEnabled( true );
   return true;
 }
 
 void CalendarLocal::deleteTodo( Todo *todo )
 {
+    QString uid =  todo->uid();
   // Handle orphaned children
     removeRelations( todo );
     clearUndo(todo);
 
   if ( mTodoList.removeRef( todo ) ) {
     setModified( true );
   }
+   Todo* dup = todoForUid(  uid );
+   if ( dup )
+       setupRelations( dup );
 }
 
 QPtrList<Todo> CalendarLocal::rawTodos()
 {
     QPtrList<Todo> el;
     for ( Todo *it = mTodoList.first(); it; it = mTodoList.next() )
         if ( it->calEnabled() ) el.append( it );
     return el;
 }
 Todo *CalendarLocal::todo( QString syncProf, QString id )
 {
   Todo *todo;
   for ( todo = mTodoList.first(); todo; todo = mTodoList.next() ) {
       if ( todo->calEnabled() && todo->getID( syncProf ) == id ) return todo;
   }
 
   return 0;
 }
 void CalendarLocal::removeSyncInfo( QString syncProfile)
 {
     QPtrList<Incidence> all = rawIncidences() ;
     Incidence *inc;
     for ( inc = all.first(); inc; inc = all.next() ) {
         inc->removeID( syncProfile );
diff --git a/libkcal/calendarlocal.h b/libkcal/calendarlocal.h
index b611704..1ceabce 100644
--- a/libkcal/calendarlocal.h
+++ b/libkcal/calendarlocal.h
@@ -26,49 +26,50 @@
 
 namespace KCal {
 
 class CalFormat;
 
 /**
   This class provides a calendar stored as a local file.
 */
 class CalendarLocal : public Calendar
 {
   public:
     /**
       Constructs a new calendar, with variables initialized to sane values.
     */
     CalendarLocal();
     /**
       Constructs a new calendar, with variables initialized to sane values.
     */
     CalendarLocal( const QString &timeZoneId );
     ~CalendarLocal();
     void addCalendar( Calendar*  );
     bool addCalendarFile( QString name, int id );
     bool mergeCalendarFile( QString name );
     bool mergeCalendar( Calendar* cal );
-    Incidence* incidenceForUid( const QString& uid, bool doNotCheckDuplicates,  bool enabledOnly = false );
+    Incidence* incidenceForUid( const QString& uid, bool doNotCheckDuplicates,  bool enabledOnly = false,int * isDup = 0 );
+    Todo* todoForUid( const QString& uid, bool doNotCheckDuplicates = true, bool enabledOnly = false ,int * isDup = 0 );
     void setSyncEventsReadOnly();
     void setSyncEventsEnabled();
     void stopAllTodos();
     /**
       Loads a calendar on disk in vCalendar or iCalendar format into the current
       calendar. Any information already present is lost.
       @return true, if successfull, false on error.
       @param fileName the name of the calendar on disk.
     */
     bool load( const QString &fileName );
     /**
       Writes out the calendar to disk in the specified \a format.
       CalendarLocal takes ownership of the CalFormat object.
       @return true, if successfull, false on error.
       @param fileName the name of the file
     */
     bool save( const QString &fileName, CalFormat *format = 0 );
 
     /**
       Clears out the current calendar, freeing all used memory etc. etc.
     */
     void close();
 
     void save() {}
diff --git a/libkcal/incidence.cpp b/libkcal/incidence.cpp
index fe9f854..7dd9bd2 100644
--- a/libkcal/incidence.cpp
+++ b/libkcal/incidence.cpp
@@ -499,48 +499,54 @@ QStringList Incidence::categories() const
 
 QString Incidence::categoriesStr()
 {
   return mCategories.join(",");
 }
 QString Incidence::categoriesStrWithSpace()
 {
   return mCategories.join(", ");
 }
 
 void Incidence::setRelatedToUid(const QString &relatedToUid)
 {
   if (mReadOnly) return;
   mRelatedToUid = relatedToUid;
 }
 void Incidence::clearRelations()
 {
     mRelatedTo = 0;
     mRelations.clear();
 }
 QString Incidence::relatedToUid() const
 {
   return mRelatedToUid;
 }
+void Incidence::resetRelatedTo()
+{
+    QString store = mRelatedToUid;
+    setRelatedTo( 0 );
+    mRelatedToUid = store;
+}
 
 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);
       mRelatedToUid = mRelatedTo->uid();
   } else {
       mRelatedToUid = "";
   }
 }
 
 Incidence *Incidence::relatedTo() const
 {
   return mRelatedTo;
 }
 
diff --git a/libkcal/incidence.h b/libkcal/incidence.h
index dc49640..f89942f 100644
--- a/libkcal/incidence.h
+++ b/libkcal/incidence.h
@@ -152,48 +152,49 @@ class Incidence : public IncidenceBase
     QString summary() const;
 
     /** set event's applicable categories */
     void setCategories(const QStringList &categories, bool setForRelations = false);
     void addCategories(const QStringList &categories, bool addToRelations = false);
     /** set event's categories based on a comma delimited string */
     void setCategories(const QString &catStr);
     /** return categories in a list */
     QStringList categories() const;
     QStringList* categoriesP();
     /** return categories as a comma separated string */
     QString categoriesStr();
     QString categoriesStrWithSpace();
 
     /** point at some other event to which the event relates. This function should
      *  only be used when constructing a calendar before the related Event
      *  exists. */
     void setRelatedToUid(const QString &);
     /** what event does this one relate to? This function should
      *  only be used when constructing a calendar before the related Event
      *  exists. */
     QString relatedToUid() const;
     /** point at some other event to which the event relates */
     void setRelatedTo(Incidence *relatedTo);
+    void resetRelatedTo();
     /** what event does this one relate to? */
     Incidence *relatedTo() const;
     /** All events that are related to this event */
     QPtrList<Incidence> relations() const;
     /** Add an event which is related to this event */
     void addRelation(Incidence *);
     /** Remove event that is related to this event */
     void removeRelation(Incidence *);
 
     /** returns the list of dates which are exceptions to the recurrence rule */
     DateList exDates() const;
     /** sets the list of dates which are exceptions to the recurrence rule */
     void setExDates(const DateList &_exDates);
     void setExDates(const char *dates);
     /** Add a date to the list of exceptions of the recurrence rule. */
     void addExDate(const QDate &date);
 
     /** returns true if there is an exception for this date in the recurrence
      rule set, or false otherwise. */
     bool isException(const QDate &qd) const;
 
     /** add attachment to this event */
     void addAttachment(Attachment *attachment);
     /** remove and delete a specific attachment */