added removeSyncInfo to KSyncInterface class

9 files changed, 27 insertions, 2 deletions

diff --git a/kaddressbook/kabcore.cpp b/kaddressbook/kabcore.cpp
index 2a3334e..efae874 100644
--- a/kaddressbook/kabcore.cpp
+++ b/kaddressbook/kabcore.cpp
@@ -2765,96 +2765,101 @@ bool KABCore::sync(KSyncManager* manager, QString filename, int mode)
     if ( abLocal.load() ) {
         qDebug("AB loaded %s,sync mode %d",filename.latin1(), mode );
         bool external = false;
         bool isXML = false;
         if ( filename.right(4) == ".xml") {
             mGlobalSyncMode = SYNC_MODE_EXTERNAL;
             isXML = true;
             abLocal.preExternSync( mAddressBook ,mCurrentSyncDevice, true );
         } else {
             external = !manager->mIsKapiFile;
             if ( external ) {
                 qDebug("Setting vcf mode to external ");
                 mGlobalSyncMode = SYNC_MODE_EXTERNAL;
                 AddressBook::Iterator it;  
                 for ( it = abLocal.begin(); it != abLocal.end(); ++it ) {
                     (*it).setID( mCurrentSyncDevice, (*it).uid() );
                     (*it).computeCsum( mCurrentSyncDevice );
                 }
             }
         }
         //AddressBook::Iterator it;
         //QStringList vcards;
         //for ( it = abLocal.begin(); it != abLocal.end(); ++it ) {
         //  qDebug("Name %s ", (*it).familyName().latin1());
         //}
         syncOK = synchronizeAddressbooks( mAddressBook, &abLocal, mode );
         if (  syncOK ) {
             if ( syncManager->mWriteBackFile )
                 {
                     if ( external )
                         abLocal.removeSyncAddressees( !isXML);
                     qDebug("Saving remote AB ");
                     if ( ! abLocal.saveAB()) 
                         qDebug("Error writing back AB to file ");
                     if ( isXML ) {
                         // afterwrite processing
                         abLocal.postExternSync( mAddressBook,mCurrentSyncDevice );
                     }
                 }
         }
         setModified();
         
     }
     if ( syncOK )
         mViewManager->refreshView();
     return syncOK;
 
 }
+void  KABCore::removeSyncInfo( QString syncProfile) 
+{
+    qDebug("removeSyncInfo for profile %s ", syncProfile.latin1());
+
+}
 
 
 //this is a overwritten callbackmethods from the syncinterface
 bool KABCore::syncExternal(KSyncManager* manager, QString  resource)
 {
     if (  resource == "phone" )
         return syncPhone();
     disableBR( true );
     QString mCurrentSyncDevice = manager->getCurrentSyncDevice();
 
     AddressBook abLocal( resource,"syncContact");
     bool syncOK = false;
     if ( abLocal.load() ) {
         qDebug("AB sharp loaded ,sync device %s",mCurrentSyncDevice.latin1());
         mGlobalSyncMode = SYNC_MODE_EXTERNAL;
         abLocal.preExternSync( mAddressBook ,mCurrentSyncDevice, false );
         syncOK = synchronizeAddressbooks( mAddressBook, &abLocal, syncManager->mSyncAlgoPrefs );
         if (  syncOK ) {
             if ( syncManager->mWriteBackFile ) {
                 abLocal.removeSyncAddressees( false );
                 abLocal.saveAB();
                 abLocal.postExternSync( mAddressBook,mCurrentSyncDevice );
             }
         }
         setModified();
     }
     if ( syncOK )
         mViewManager->refreshView();
     disableBR( false );
     return syncOK;
 
 }
 void KABCore::message( QString m )
 {
     topLevelWidget()->setCaption( m );
     mMessageTimer->start( 15000, true );
 }
 bool KABCore::syncPhone()
 {
     QString mCurrentSyncDevice = syncManager->getCurrentSyncDevice();
     QString fileName = getPhoneFile();
     if ( !PhoneAccess::readFromPhone( fileName) ) {
         message(i18n("Phone access failed!"));
         return false;
     }   
     AddressBook abLocal( fileName,"syncContact");
     bool syncOK = false;
      {
diff --git a/kaddressbook/kabcore.h b/kaddressbook/kabcore.h
index fcbe1e8..a288505 100644
--- a/kaddressbook/kabcore.h
+++ b/kaddressbook/kabcore.h
@@ -437,66 +437,67 @@ class KABCore : public QWidget, public KSyncInterface
     KAction *mActionUndo;
     KAction *mActionRedo;
     KAction *mActionDelete;
 
     //US settings menu
     KAction *mActionConfigResources;
     KAction *mActionConfigKAddressbook;
     KAction *mActionConfigShortcuts;
     KAction *mActionConfigureToolbars;
     KAction *mActionKeyBindings;
     KToggleAction *mActionJumpBar;
     KToggleAction *mActionDetails;
     KAction *mActionWhoAmI;
     KAction *mActionCategories;
     KAction *mActionAboutKAddressbook;
     KAction *mActionLicence;
     KAction *mActionFaq;
     KAction *mActionWN;
     KAction *mActionSyncHowto;
 
     KAction *mActionDeleteView;
 
     QPopupMenu *viewMenu;
     QPopupMenu *filterMenu;
     QPopupMenu *settingsMenu;
     QPopupMenu *changeMenu;
 //US    QAction *mActionSave;
     QPopupMenu *ImportMenu;
     QPopupMenu *ExportMenu;
     //LR additional methods
     KAction *mActionRemoveVoice;
     KAction * mActionImportOL;
 
 #ifndef KAB_EMBEDDED
     KAddressBookService *mAddressBookService;
 #endif //KAB_EMBEDDED
 
     class KABCorePrivate;
     KABCorePrivate *d;
     //US    bool mBlockSaveFlag;
 
 #ifdef KAB_EMBEDDED
     KAddressBookMain *mMainWindow;  // should be the same like mGUIClient
 #endif //KAB_EMBEDDED
 
     //this are the overwritten callbackmethods from the syncinterface
     virtual bool sync(KSyncManager* manager, QString filename, int mode);
     virtual bool syncExternal(KSyncManager* manager, QString resource);
+    virtual void removeSyncInfo( QString syncProfile);
     bool syncPhone();
     void message( QString m );
 
     // LR *******************************
     // sync stuff!
     QString sentSyncFile();
     QPopupMenu *syncMenu;
     KSyncManager* syncManager;
     int mGlobalSyncMode; 
     bool synchronizeAddressbooks( KABC::AddressBook* local, KABC::AddressBook* remote,int mode);
     KABC::Addressee getLastSyncAddressee();
     QDateTime mLastAddressbookSync;
     int  takeAddressee( KABC::Addressee* local,  KABC::Addressee* remote, int mode , bool full );
     // *********************
 
 };
 
 #endif
diff --git a/korganizer/calendarview.cpp b/korganizer/calendarview.cpp
index 2ccccfa..af01625 100644
--- a/korganizer/calendarview.cpp
+++ b/korganizer/calendarview.cpp
@@ -3719,48 +3719,54 @@ void CalendarView::purgeCompleted()
 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());
+
+}
diff --git a/korganizer/calendarview.h b/korganizer/calendarview.h
index 2818ee9..acc20d6 100644
--- a/korganizer/calendarview.h
+++ b/korganizer/calendarview.h
@@ -420,96 +420,97 @@ class CalendarView : public KOrg::CalendarViewBase, public KCal::Calendar::Obser
     void dialogClosing(Incidence *);
   
     /** Look for new messages in the inbox */
     void lookForIncomingMessages();
    /** Look for new messages in the outbox */
     void lookForOutgoingMessages();
 
     void processMainViewSelection( Incidence * );
     void processTodoListSelection( Incidence * );
     
     void processIncidenceSelection( Incidence * );
 
     void purgeCompleted();
     bool removeCompletedSubTodos( Todo* );
     void slotCalendarChanged();
     bool importBday();
     bool addAnniversary( QDate data, QString name, KCal::Attendee* a , bool birthday  );
     bool importQtopia( const QString &categoriesFile,
                        const QString &datebookFile,
                        const QString &tasklistFile );
     void syncExternal( int mode );
     void slotSelectPickerDate( QDate ) ;
     void showDatePicker( ) ;
     void moveIncidence(Incidence *) ;
     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();
 
diff --git a/libkdepim/ksyncmanager.h b/libkdepim/ksyncmanager.h
index 4a610fa..af4f1ab 100644
--- a/libkdepim/ksyncmanager.h
+++ b/libkdepim/ksyncmanager.h
@@ -151,61 +151,62 @@ class KSyncManager : public QObject
     void save();
     void request_file();
     void getFile( bool );
 
     public slots:
     void slotSyncMenu( int );
     void deleteCommandSocket(KCommandSocket*s, int state);
     void readFileFromSocket();
     void fillSyncMenu();
 
  private:
     void syncPi();
     KServerSocket * mServerSocket;
     KPimPrefs* mPrefs;
     QString mDefFileName;
     QString mCurrentSyncDevice;
     QString mCurrentSyncName;
     void quickSyncLocalFile();
     bool syncWithFile( QString fn , bool quick );
     void syncLocalFile();
     void syncPhone();
     void syncSharp();
     void syncKDE();
     bool syncExternalApplication(QString);
     int mCurrentSyncProfile ;
     void syncRemote( KSyncProfile* prof,  bool ask = true);
     bool edit_sync_options();
     bool edit_pisync_options();
     int ringSync();
     QString  getPassword( );
     bool mPisyncFinished;
     bool mBlockSaveFlag;
     QWidget* mParent;
     KSyncInterface* mImplementation;
     TargetApp mTargetApp; 
     QPopupMenu* mSyncMenu;
     QProgressBar* bar;
 
 private slots:
     void confSync();
 
 
 };
 
 
 class KSyncInterface 
 { 
  public :
+    virtual void removeSyncInfo( QString syncProfile) = 0;
     virtual bool sync(KSyncManager* manager, QString filename, int mode) = 0;
     virtual bool syncExternal(KSyncManager* manager, QString resource)
     {
         // empty implementation, because some syncable applications do not 
         // have an external(sharpdtm)  syncmode, like pwmanager.
         return false;
     }
 
    
 };
 
 
 #endif
diff --git a/pwmanager/pwmanager/pwm.cpp b/pwmanager/pwmanager/pwm.cpp
index 2b8f2fa..6ae6e28 100644
--- a/pwmanager/pwmanager/pwm.cpp
+++ b/pwmanager/pwmanager/pwm.cpp
@@ -1419,54 +1419,60 @@ void PwM::createAboutData_slot()
 ;
     QMessageBox::about( this, "About PwManager/Pi",
                         "PwManager/Platform-independent\n"
                         "(PWM/Pi) " +version + " - " +
 #ifdef DESKTOP_VERSION
                         "Desktop Edition\n"
 #else
                         "PDA-Edition\n"
                         "for: Zaurus 5500 / 7x0 / 8x0\n"
 #endif
 
                         "(c) 2004 Ulf Schenk\n"
                         "(c) 2004 Lutz Rogowski\n"
                         "(c) 1997-2004, The KDE PIM Team\n"
 
         "(c) Michael Buesch - main programming\nand current maintainer\nmbuesch@freenet.de\n"
         "Matt Scifo - mscifo@o1.com\n"
         "Elias Probst - elias.probst@gmx.de\n"
         "George Staikos - staikos@kde.org\n"
         "Matthew Palmer - mjp16@uow.edu.au\n"
         "Olivier Sessink - gpasman@nl.linux.org\n"
         "The libgcrypt developers -\nBlowfish and SHA1 algorithms\nftp://ftp.gnupg.org/gcrypt/alpha/libgcrypt/\n"
         "Troy Engel - tengel@sonic.net\n"
         "Wickey - wickey@gmx.at\n"
         "Ian MacGregor - original documentation author.\n"
  );
 }
 
 
 //this are the overwritten callbackmethods from the syncinterface
 bool PwM::sync(KSyncManager* manager, QString filename, int mode)
 {
   PWM_ASSERT(curDoc());
 
   bool ret =  curDoc()->sync(manager, filename, mode);
 
   qDebug("PwM::sync save now: ret=%i", ret);
  
   if (ret == true) {
     //US BUG: what can we call here to update the view of the current doc?
     //mViewManager->refreshView();
 
     //US curDoc()->sync sets the dirtyFlag in case the sync was successfull.
     save();
   }
 
   return ret;
 }
+ 
+void PwM::removeSyncInfo( QString syncProfile)
+{
+    qDebug("PWM::not implemented: removeSyncInfo for profile %s ", syncProfile.latin1());
+}
+
 #endif
 
 
 #ifndef PWM_EMBEDDED
 #include "pwm.moc"
 #endif
diff --git a/pwmanager/pwmanager/pwm.h b/pwmanager/pwmanager/pwm.h
index 5822d59..fb34bca 100644
--- a/pwmanager/pwmanager/pwm.h
+++ b/pwmanager/pwmanager/pwm.h
@@ -232,66 +232,67 @@ protected slots:
 
 signals:
         /** window got closed (by user or someone else) */
         void closed(PwM *wnd);
         /** window got the focus (was brought to foreground) */
         void gotFocus(PwM *wnd);
         /** window lost the focus */
         void lostFocus(PwM *wnd);
 
 protected:
         /** pointer to the view active in this KMainWindow */
         PwMView *view;
         /** pointer to the init class */
         PwMInit *init;
         /** has this window already lost its virginity?
           * Means is there an open working document
           */
         bool virgin;
         /** "file" popup-menu */
         KPopupMenu *filePopup;
 
         /** "manage" popup-menu */
         KPopupMenu *managePopup;
 #ifdef CONFIG_KEYCARD
         /** "chipcard" popup-menu */
         KPopupMenu *chipcardPopup;
 #endif // CONFIG_KEYCARD
         /** "view" popup-menu */
         KPopupMenu *viewPopup;
         /** "options" popup-menu */
         KPopupMenu *optionsPopup;
         /** "help" popup-menu */
         KPopupMenu *helpPopup;
         /** "export" popup-menu */
         KPopupMenu *exportPopup;
         /** "import" popup-menu */
         KPopupMenu *importPopup;
         /** force quit this window? */
         bool forceQuit;
         /** force minimize this window to the tray */
         bool forceMinimizeToTray;
 
 
 
 
  private:
 #ifdef PWM_EMBEDDED
     //this are the overwritten callbackmethods from the syncinterface
-    virtual bool sync(KSyncManager* manager, QString filename, int mode);
+    virtual bool sync(KSyncManager* manager, QString filename, int mode); 
+    virtual void removeSyncInfo( QString syncProfile);
 
     // LR *******************************
     // sync stuff!
     QPopupMenu *syncPopup;
     KSyncManager* syncManager;
 #endif
 
 
 
 
 
 
 
 
 };
 
 #endif
diff --git a/pwmanager/pwmanager/pwmdoc.cpp b/pwmanager/pwmanager/pwmdoc.cpp
index cf8690f..fd17ce5 100644
--- a/pwmanager/pwmanager/pwmdoc.cpp
+++ b/pwmanager/pwmanager/pwmdoc.cpp
@@ -3259,97 +3259,100 @@ int PwMDoc::takePwMDataItem( PwMDataItem* local,  PwMDataItem* remote, QDateTime
     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;
         localIsNew = localMod >= remoteMod;
         //qDebug("conflict! ************************************** ");
         {
           PwMDataItemChooser acd ( *local,*remote, localIsNew , 0/*this*/ );
             result = acd.executeD(localIsNew);
             return result;
         }
         break;
     case SYNC_PREF_FORCE_LOCAL:
         return 1;
         break;
     case SYNC_PREF_FORCE_REMOTE:
         return 2;
         break;
        
     default:
         // SYNC_PREF_TAKE_BOTH not implemented
         break;
     }
     return 0;
 }
 
-
+void PwMDoc::removeSyncInfo( QString syncProfile)
+{
+    qDebug("PwMDoc::not implemented: removeSyncInfo for profile %s ", syncProfile.latin1());
+}
 
 
 //this are the overwritten callbackmethods from the syncinterface
 bool PwMDoc::sync(KSyncManager* manager, QString filename, int mode)
 {
   QString mCurrentSyncDevice = manager->getCurrentSyncDevice();
 
   //1) unlock local file first if necessary (ask for password)
   if (this->isDeepLocked()) {
     PwMerror ret = this->deepLock(false);
     if (ret != e_success)
       return false;
   }
 
   //2)  construct and open a new doc on the stack(automatic cleanup of remote file).
   PwMDoc syncTarget(this, "synctarget");
   PwMDoc* pSyncTarget = &syncTarget;
 
 
   PwMerror err = pSyncTarget->openDoc(&filename, 1 /*== open with all entries locked*/);
 
   if (err == e_alreadyOpen) {
     PwMDocList::listItem li;
     if (getOpenDocList()->find(filename.latin1(), &li))
       pSyncTarget = li.doc;
     else {
       qDebug("PwmDoc::sync: sync failed. Error %i while opening file %s",err, filename.latin1());
       return false;
     }
   }
   else if (err != e_success) {
     qDebug("PwmDoc::sync: sync failed. Error %i while opening file %s",err, filename.latin1());
     return false;
   }
 
   qDebug("PWM file loaded %s,sync mode %d",filename.latin1(), mode );
 
 
   //3) unlock remote file first if necessary (ask for password)
   if (pSyncTarget->isDeepLocked()) {
     PwMerror ret = pSyncTarget->deepLock(false);
     if (ret != e_success)
       return false;
   }
 
   
   err = syncronize(manager, this, pSyncTarget, mode );
 
diff --git a/pwmanager/pwmanager/pwmdoc.h b/pwmanager/pwmanager/pwmdoc.h
index 55e3231..e419c24 100644
--- a/pwmanager/pwmanager/pwmdoc.h
+++ b/pwmanager/pwmanager/pwmdoc.h
@@ -717,72 +717,73 @@ protected:
         /** internal import function for a text-file generated by PwM.
           * If this is not a valid PwM-exported file, it returns e_fileFormat */
         PwMerror importText_PwM(const QString *file);
         /** PwM-text-import helper function to extract the name/pw/comment out
           * of one entry-line */
         bool textExtractEntry_PwM(const char *in, ssize_t in_size, string *out);
         /** compare two strings */
         bool compareString(const string &s1, const string &s2, bool caseSensitive,
                            bool exactWordMatch);
         /** clears all document-data */
         void clearDoc();
         /** delete all empty categories */
         void delAllEmptyCat(bool dontFlagDirty);
         /** set a document status flag */
         void setDocStatFlag(unsigned int statFlag)
                         { curDocStat |= statFlag; }
         /** unset a document status flag */
         void unsetDocStatFlag(unsigned int statFlag)
                         { curDocStat &= ~statFlag; }
         /** get a document status flag */
         bool getDocStatFlag(unsigned int statFlag) const
                         { return (curDocStat & statFlag); }
         /** set the "currentPassword" */
         void setCurrentPw(const QString &pw)
                 {
                         currentPw = pw;
                         setDocStatFlag(DOC_STAT_DISK_DIRTY);
                 }
         /** make a backup-copy of the given file */
         bool backupFile(const QString &filePath);
         /** copy a file from src to dst */
         bool copyFile(const QString &src, const QString &dst);
 
 
  public:
 #ifdef PWM_EMBEDDED
         //US ENH: this is the magic function that syncronizes the local doc with the remote doc.
         PwMerror syncronize(KSyncManager* manager, PwMDoc* syncLocal, PwMDoc* syncRemote, int mode );
 
         //takePwMDataItem returns the following values
         // 0 equal
         // 1 take local
         // 2 take remote
         // 3 cancel 
         int takePwMDataItem( PwMDataItem* local,  PwMDataItem* remote, QDateTime lastSync, int mode , bool full );
 
         //the following methods are the overwritten callbackmethods from the syncinterface
         virtual bool sync(KSyncManager* manager, QString filename, int mode);
+    virtual void removeSyncInfo( QString syncProfile);
 
 #endif
  private:
         //US ENH: helpermethods to access the sync data for a certain syncname.
         // It returns the syncdatas index
         bool findSyncData(const QString &syncname, unsigned int *index);
 
         /** add new syncdataentry */
         PwMerror addSyncDataEntry(PwMSyncItem *d, bool dontFlagDirty = false);
 
         /** returns a pointer to the syncdata */
         PwMSyncItem* getSyncDataEntry(unsigned int index)
                         { return &(dti.syncDta[index]); }
 
         /** delete entry */
         bool delSyncDataEntry(unsigned int index, bool dontFlagDirty = false);
 
         PwMDataItem* findEntryByID(const QString &uid, unsigned int *category, unsigned int *index);
 
         QStringList getIDEntryList(); 
 
 };
 
 #endif