added removeSyncInfo to KSyncInterface class

9 files changed, 26 insertions, 1 deletions

diff --git a/kaddressbook/kabcore.cpp b/kaddressbook/kabcore.cpp
index 2a3334e..efae874 100644
--- a/kaddressbook/kabcore.cpp
+++ b/kaddressbook/kabcore.cpp
@@ -1789,1123 +1789,1128 @@ void KABCore::initActions()
                                "kaddressbook_undo" );
     mActionRedo = new KAction( i18n( "Re&do" ), "redo", CTRL + SHIFT + Key_Z,
                                this, SLOT( redo() ), actionCollection(),
                                "kaddressbook_redo" );
   } else {
     mActionCopy = KStdAction::copy( this, SLOT( copyContacts() ), actionCollection() );
     mActionCut = KStdAction::cut( this, SLOT( cutContacts() ), actionCollection() );
     mActionPaste = KStdAction::paste( this, SLOT( pasteContacts() ), actionCollection() );
     mActionSelectAll = KStdAction::selectAll( this, SLOT( selectAllContacts() ), actionCollection() );
     mActionUndo = KStdAction::undo( this, SLOT( undo() ), actionCollection() );
     mActionRedo = KStdAction::redo( this, SLOT( redo() ), actionCollection() );
   }
 
   mActionDelete = new KAction( i18n( "&Delete Contact" ), "editdelete",
                                Key_Delete, this, SLOT( deleteContacts() ),
                                actionCollection(), "edit_delete" );
 
   mActionUndo->setEnabled( false );
   mActionRedo->setEnabled( false );
 
   // settings menu
 #ifdef KAB_EMBEDDED
 //US special menuentry to configure the addressbook resources. On KDE
 // you do that through the control center !!!
   mActionConfigResources = new KAction( i18n( "Configure &Resources..." ), "configure_resources", 0, this,
                SLOT( configureResources() ), actionCollection(),
                "kaddressbook_configure_resources" );
 #endif //KAB_EMBEDDED
 
   if ( mIsPart ) {
     mActionConfigKAddressbook = new KAction( i18n( "&Configure KAddressBook..." ), "configure", 0, this,
                  SLOT( openConfigDialog() ), actionCollection(),
                  "kaddressbook_configure" );
 
     //US not implemented yet
     //mActionConfigShortcuts = new KAction( i18n( "Configure S&hortcuts..." ), "configure_shortcuts", 0,
     //             this, SLOT( configureKeyBindings() ), actionCollection(),
     //             "kaddressbook_configure_shortcuts" );
 #ifdef KAB_EMBEDDED
   mActionConfigureToolbars = KStdAction::configureToolbars( this, SLOT( mMainWindow->configureToolbars() ), actionCollection() );
   mActionConfigureToolbars->setEnabled( false );
 #endif //KAB_EMBEDDED
 
   } else {
     mActionConfigKAddressbook = KStdAction::preferences( this, SLOT( openConfigDialog() ), actionCollection() );
 
     //US not implemented yet
     //mActionKeyBindings = KStdAction::keyBindings( this, SLOT( configureKeyBindings() ), actionCollection() );
   }
 
   mActionJumpBar = new KToggleAction( i18n( "Show Jump Bar" ), 0, 0,
                                       actionCollection(), "options_show_jump_bar" );
   connect( mActionJumpBar, SIGNAL( toggled( bool ) ), SLOT( setJumpButtonBarVisible( bool ) ) );
 
   mActionDetails = new KToggleAction( i18n( "Show Details" ), "listview", 0,
                                       actionCollection(), "options_show_details" );
   connect( mActionDetails, SIGNAL( toggled( bool ) ), SLOT( setDetailsVisible( bool ) ) );
 
 
   mActionBR = new KToggleAction( i18n( "Beam receive enabled" ), "beam", 0, this,
                                SLOT( toggleBeamReceive() ), actionCollection(),
                                "kaddressbook_beam_rec" );
 
 
   // misc
   // only enable LDAP lookup if we can handle the protocol
 #ifndef KAB_EMBEDDED
   if ( KProtocolInfo::isKnownProtocol( KURL( "ldap://localhost" ) ) ) {
     new KAction( i18n( "&Lookup Addresses in Directory" ), "find", 0,
                  this, SLOT( openLDAPDialog() ), actionCollection(),
                  "ldap_lookup" );
   }
 #else //KAB_EMBEDDED
   //qDebug("KABCore::initActions() LDAP has to be implemented");
 #endif //KAB_EMBEDDED
 
 
   mActionWhoAmI = new KAction( i18n( "Set Who Am I" ), "personal", 0, this,
                                SLOT( setWhoAmI() ), actionCollection(),
                                "set_personal" );
 
 
 
 
   mActionCategories = new KAction( i18n( "Set Categories" ), 0, this,
                                    SLOT( setCategories() ), actionCollection(),
                                    "edit_set_categories" );
 
   mActionRemoveVoice = new KAction( i18n( "Remove \"voice\"..." ), 0, this,
                                     SLOT( removeVoice() ), actionCollection(),
                                    "remove_voice" );
   mActionImportOL = new KAction( i18n( "Import from Outlook..." ), 0, this,
                                     SLOT( importFromOL() ), actionCollection(),
                                    "import_OL" );
 #ifdef KAB_EMBEDDED
  mActionLicence = new KAction( i18n( "Licence" ), 0,
                  this, SLOT( showLicence() ), actionCollection(),
                  "licence_about_data" );
  mActionFaq = new KAction( i18n( "Faq" ), 0,
                  this, SLOT( faq() ), actionCollection(),
                  "faq_about_data" );
  mActionWN = new KAction( i18n( "What's New?" ), 0,
                  this, SLOT( whatsnew() ), actionCollection(),
                  "wn" );
  mActionSyncHowto = new KAction( i18n( "Sync HowTo" ), 0,
                  this, SLOT( synchowto() ), actionCollection(),
                  "sync" );
 
   mActionAboutKAddressbook = new KAction( i18n( "&About KAddressBook" ), "kaddressbook2", 0,
                  this, SLOT( createAboutData() ), actionCollection(),
                  "kaddressbook_about_data" );
 #endif //KAB_EMBEDDED
 
   clipboardDataChanged();
   connect( UndoStack::instance(), SIGNAL( changed() ), SLOT( updateActionMenu() ) );
   connect( RedoStack::instance(), SIGNAL( changed() ), SLOT( updateActionMenu() ) );
 }
 
 //US we need this function, to plug all actions into the correct menues.
 // KDE uses a XML format to plug the actions, but we work her without this overhead.
 void KABCore::addActionsManually()
 {
 //US  qDebug("KABCore::initActions(): mIsPart %i", mIsPart);
 
 #ifdef KAB_EMBEDDED
   QPopupMenu *fileMenu = new QPopupMenu( this );
   QPopupMenu *editMenu = new QPopupMenu( this );
   QPopupMenu *helpMenu = new QPopupMenu( this );
 
   KToolBar* tb =  mMainWindow->toolBar();
 
 #ifdef DESKTOP_VERSION
   QMenuBar* mb = mMainWindow->menuBar();
 
   //US setup menubar.
   //Disable the following block if you do not want to have a menubar.
   mb->insertItem( "&File", fileMenu );
   mb->insertItem( "&Edit", editMenu );
   mb->insertItem( "&View", viewMenu );
   mb->insertItem( "&Settings", settingsMenu );
   mb->insertItem( i18n("Synchronize"), syncMenu );
   mb->insertItem( "&Change selected", changeMenu );
   mb->insertItem( "&Help", helpMenu );
   mIncSearchWidget = new IncSearchWidget( tb );
   // tb->insertWidget(-1, 0, mIncSearchWidget);
 
 #else
   //US setup toolbar
   QPEMenuBar   *menuBarTB = new QPEMenuBar( tb );
   QPopupMenu *popupBarTB = new QPopupMenu( this );
   menuBarTB->insertItem( "ME", popupBarTB);
   tb->insertWidget(-1, 0, menuBarTB);
   mIncSearchWidget = new IncSearchWidget( tb );
 
   tb->enableMoving(false);
   popupBarTB->insertItem( "&File", fileMenu );
   popupBarTB->insertItem( "&Edit", editMenu );
   popupBarTB->insertItem( "&View", viewMenu );
   popupBarTB->insertItem( "&Settings", settingsMenu );
   popupBarTB->insertItem( i18n("Synchronize"), syncMenu );
   mViewManager->getFilterAction()->plug ( popupBarTB);
   popupBarTB->insertItem( "&Change selected", changeMenu );
   popupBarTB->insertItem( "&Help", helpMenu );
   if (QApplication::desktop()->width() > 320 ) {
       // mViewManager->getFilterAction()->plug ( tb);
   }
 #endif
   // mActionQuit->plug ( mMainWindow->toolBar());
 
 
 
   //US Now connect the actions with the menue entries.
   mActionPrint->plug( fileMenu );
   mActionMail->plug( fileMenu );
   fileMenu->insertSeparator();
 
   mActionNewContact->plug( fileMenu );
   mActionNewContact->plug( tb );
 
   mActionEditAddressee->plug( fileMenu );
   if ((KGlobal::getDesktopSize() > KGlobal::Small ) ||
       (!KABPrefs::instance()->mMultipleViewsAtOnce ))
     mActionEditAddressee->plug( tb );
 
   fileMenu->insertSeparator();
   mActionSave->plug( fileMenu );
   fileMenu->insertItem( "&Import", ImportMenu );
   fileMenu->insertItem( "&Export", ExportMenu );
   fileMenu->insertSeparator();
   mActionMailVCard->plug( fileMenu );
 #ifndef DESKTOP_VERSION
   if ( Ir::supported() ) mActionBeamVCard->plug( fileMenu );
   if ( Ir::supported() ) mActionBeam->plug(fileMenu );
 #endif
   fileMenu->insertSeparator();
   mActionQuit->plug( fileMenu );
 #ifdef _WIN32_
   mActionImportOL->plug( ImportMenu  );
 #endif
   // edit menu
   mActionUndo->plug( editMenu );
   mActionRedo->plug( editMenu );
   editMenu->insertSeparator();
   mActionCut->plug( editMenu );
   mActionCopy->plug( editMenu );
   mActionPaste->plug( editMenu );
   mActionDelete->plug( editMenu );
   editMenu->insertSeparator();
   mActionSelectAll->plug( editMenu );
 
   mActionRemoveVoice->plug( changeMenu );
   // settings menu
 //US special menuentry to configure the addressbook resources. On KDE
 // you do that through the control center !!!
   mActionConfigResources->plug( settingsMenu );
   settingsMenu->insertSeparator();
 
   mActionConfigKAddressbook->plug( settingsMenu );
 
   if ( mIsPart ) {
     //US not implemented yet
     //mActionConfigShortcuts->plug( settingsMenu );
     //mActionConfigureToolbars->plug( settingsMenu );
 
   } else {
     //US not implemented yet
     //mActionKeyBindings->plug( settingsMenu );
   }
 
   settingsMenu->insertSeparator();
 
   mActionJumpBar->plug( settingsMenu );
   mActionDetails->plug( settingsMenu );
   if (!KABPrefs::instance()->mMultipleViewsAtOnce || KGlobal::getDesktopSize() == KGlobal::Desktop  )
     mActionDetails->plug( tb );
   settingsMenu->insertSeparator();
   mActionBR->plug(settingsMenu );
   settingsMenu->insertSeparator();
 
   mActionWhoAmI->plug( settingsMenu );
   mActionCategories->plug( settingsMenu );
 
      
   mActionWN->plug( helpMenu );
   mActionSyncHowto->plug( helpMenu );
   mActionLicence->plug( helpMenu );
   mActionFaq->plug( helpMenu );
   mActionAboutKAddressbook->plug( helpMenu );
 
   if (KGlobal::getDesktopSize() > KGlobal::Small ) {
 
       mActionSave->plug( tb );
       mViewManager->getFilterAction()->plug ( tb);
       if (KGlobal::getDesktopSize() == KGlobal::Desktop ) {
 	mActionUndo->plug( tb );
 	mActionDelete->plug( tb );
 	mActionRedo->plug( tb );
       }
   }
   //mActionQuit->plug ( tb );
   // tb->insertWidget(-1, 0, mIncSearchWidget, 6);
 
   //US link the searchwidget first to this.
   // The real linkage to the toolbar happens later.
 //US  mIncSearchWidget->reparent(tb, 0, QPoint(50,0), TRUE);
 //US  tb->insertItem( mIncSearchWidget );
 /*US
   mIncSearchWidget = new IncSearchWidget( tb );
   connect( mIncSearchWidget, SIGNAL( doSearch( const QString& ) ),
            SLOT( incrementalSearch( const QString& ) ) );
 
   mJumpButtonBar = new JumpButtonBar( this, this );
 
 //US topLayout->addWidget( mJumpButtonBar );
  this->layout()->add( mJumpButtonBar );
 */
 
 #endif //KAB_EMBEDDED
 
   mActionExport2phone->plug( ExportMenu );
  connect ( syncMenu, SIGNAL( activated ( int )  ), syncManager, SLOT (slotSyncMenu( int ) ) );
  syncManager->fillSyncMenu();
 
 }
 void KABCore::showLicence()
 {
     KApplication::showLicence();
 }
 void KABCore::removeVoice()
 {
     if ( KMessageBox::questionYesNo( this, i18n("After importing, phone numbers\nmay have two or more types.\n(E.g. work+voice)\nThese numbers are shown as \"other\".\nClick Yes to remove the voice type\nfrom numbers with more than one type.\n\nRemove voice type?") ) == KMessageBox::No )
         return;
     KABC::Addressee::List list = mViewManager->selectedAddressees();
     KABC::Addressee::List::Iterator it;
     for ( it = list.begin(); it != list.end(); ++it ) {
         
         if ( (*it).removeVoice() )
             contactModified((*it) );
     }
 }
 
 
 
 void KABCore::clipboardDataChanged()
 {
 
   if ( mReadWrite )
     mActionPaste->setEnabled( !QApplication::clipboard()->text().isEmpty() );
 
 }
 
 void KABCore::updateActionMenu()
 {
   UndoStack *undo = UndoStack::instance();
   RedoStack *redo = RedoStack::instance();
 
   if ( undo->isEmpty() )
     mActionUndo->setText( i18n( "Undo" ) );
   else
     mActionUndo->setText( i18n( "Undo %1" ).arg( undo->top()->name() ) );
 
   mActionUndo->setEnabled( !undo->isEmpty() );
 
   if ( !redo->top() )
     mActionRedo->setText( i18n( "Redo" ) );
   else
     mActionRedo->setText( i18n( "Redo %1" ).arg( redo->top()->name() ) );
 
   mActionRedo->setEnabled( !redo->isEmpty() );
 }
 
 void KABCore::configureKeyBindings()
 {
 #ifndef KAB_EMBEDDED
   KKeyDialog::configure( actionCollection(), true );
 #else //KAB_EMBEDDED
   qDebug("KABCore::configureKeyBindings() not implemented");
 #endif //KAB_EMBEDDED
 }
 
 #ifdef KAB_EMBEDDED
 void KABCore::configureResources()
 {
   KRES::KCMKResources dlg( this, "" , 0 );
 
   if ( !dlg.exec() )
     return;
   KMessageBox::information( this,  i18n("Please restart to get the \nchanged resources (re)loaded!\n") );
 }
 #endif //KAB_EMBEDDED
 
 
 /* this method will be called through the QCop interface from Ko/Pi to select addresses
  * for the attendees list of an event.
  */
 void KABCore::requestForNameEmailUidList(const QString& sourceChannel, const QString& uid)
 {
   QStringList nameList;
   QStringList emailList;
   QStringList uidList;
 
   KABC::Addressee::List list = KABC::AddresseeDialog::getAddressees(this);
   uint i=0;
   for (i=0; i < list.count(); i++)
   {
 	nameList.append(list[i].realName());
 	emailList.append(list[i].preferredEmail());
 	uidList.append(list[i].uid());
   }
 
   bool res = ExternalAppHandler::instance()->returnNameEmailUidListFromKAPI(sourceChannel, uid, nameList, emailList, uidList);
 
 }
 
 /* this method will be called through the QCop interface from Ko/Pi to select birthdays
  * to put them into the calendar.
  */
 void KABCore::requestForBirthdayList(const QString& sourceChannel, const QString& uid)
 {
   //  qDebug("KABCore::requestForBirthdayList");
   QStringList birthdayList;
   QStringList anniversaryList;
   QStringList realNameList;
   QStringList preferredEmailList;
   QStringList assembledNameList;
   QStringList uidList;
 
   KABC::AddressBook::Iterator it;
 
     int count = 0;
     for( it = mAddressBook->begin(); it != mAddressBook->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("Collecting birthdays - close to abort!") );
     qApp->processEvents();
 
     QDate bday;
     QString anni;
     QString formattedbday;
 
   for( it = mAddressBook->begin(); it != mAddressBook->end(); ++it )  
   {
         if ( ! bar.isVisible() )
             return;
         bar.setProgress( count++ );
         qApp->processEvents();
 	bday = (*it).birthday().date();
 	anni = (*it).custom("KADDRESSBOOK", "X-Anniversary" );
 
         if ( bday.isValid() || !anni.isEmpty())
 	{
 	  if (bday.isValid()) 
 	    formattedbday = KGlobal::locale()->formatDate(bday,  true, KLocale::ISODate);
 	  else
 	    formattedbday = "NOTVALID";
 	  if (anni.isEmpty())
 	    anni = "INVALID";
 	    
 	  birthdayList.append(formattedbday);
 	  anniversaryList.append(anni); //should be ISODate
 	  realNameList.append((*it).realName());
 	  preferredEmailList.append((*it).preferredEmail());
 	  assembledNameList.append((*it).assembledName());
 	  uidList.append((*it).uid());
 
 	  qDebug("found birthday in KA/Pi: %s,%s,%s,%s: %s, %s", (*it).realName().latin1(), (*it).preferredEmail().latin1(), (*it).assembledName().latin1(), (*it).uid().latin1(), formattedbday.latin1(), anni.latin1() );
 	}
   }
 
   bool res = ExternalAppHandler::instance()->returnBirthdayListFromKAPI(sourceChannel, uid, birthdayList, anniversaryList, realNameList, preferredEmailList, assembledNameList, uidList);
 
 }
 
 /* this method will be called through the QCop interface from other apps to show details of a contact.
  */
 void KABCore::requestForDetails(const QString& sourceChannel, const QString& sessionuid, const QString& name, const QString& email, const QString& uid)
 {
     qDebug("KABCore::requestForDetails %s %s %s %s %s", sourceChannel.latin1(), sessionuid.latin1(), name.latin1(), email.latin1(), uid.latin1());
 
     QString foundUid = QString::null;
     if ( ! uid.isEmpty() ) {
         Addressee adrr = mAddressBook->findByUid( uid );
         if (  !adrr.isEmpty() ) {
             foundUid = uid;
         }
             if ( email == "sendbacklist" ) {
                 //qDebug("ssssssssssssssssssssssend ");
                 QStringList nameList;
                 QStringList emailList;
                 QStringList uidList;
                 nameList.append(adrr.realName());
                 emailList = adrr.emails();
                 uidList.append( adrr.preferredEmail());
                 bool res = ExternalAppHandler::instance()->returnNameEmailUidListFromKAPI("QPE/Application/ompi", uid, nameList, emailList, uidList);
                 return;
             }
         
     }
   
   if ( email == "sendbacklist" ) 
       return;
   if (foundUid.isEmpty())
   {
     //find the uid of the person first
     Addressee::List namelist;
     Addressee::List emaillist;
 
     if (!name.isEmpty())
       namelist = mAddressBook->findByName( name );
 
     if (!email.isEmpty())
       emaillist = mAddressBook->findByEmail( email );
     qDebug("count %d %d ",  namelist.count(),emaillist.count() );
     //check if we have a match in Namelist and Emaillist
     if ((namelist.count() == 0) && (emaillist.count() > 0)) {
       foundUid = emaillist[0].uid();
     }
     else if ((namelist.count() > 0) && (emaillist.count() == 0))
       foundUid = namelist[0].uid();
     else
     {
       for (int i = 0; i < namelist.count(); i++)
       {
         for (int j = 0; j < emaillist.count(); j++)
         {
           if (namelist[i] == emaillist[j])
           {
             foundUid = namelist[i].uid();
           }
         }
       }
     }
   }
   else
   {
     foundUid = uid;
   }
 
   if (!foundUid.isEmpty())
   {
    
     // raise Ka/Pi if it is in the background
 #ifndef DESKTOP_VERSION
 #ifndef KORG_NODCOP
       //QCopEnvelope e("QPE/Application/kapi", "raise()");
 #endif
 #endif
     
     mMainWindow->showMaximized();
     mMainWindow-> raise();
 
     mViewManager->setSelected( "", false);
     mViewManager->refreshView( "" );
     mViewManager->setSelected( foundUid, true );
     mViewManager->refreshView( foundUid );
 
     if ( !mMultipleViewsAtOnce )
     {
       setDetailsVisible( true );
       mActionDetails->setChecked(true);
     }
   }
 }
 
 void KABCore::whatsnew()
 {
     KApplication::showFile( "KDE-Pim/Pi Version Info", "kdepim/WhatsNew.txt" );
 }
 void KABCore::synchowto()
 {
     KApplication::showFile( "KDE-Pim/Pi Synchronization HowTo", "kdepim/SyncHowto.txt" );
 }
 
 void  KABCore::faq()
 {
   KApplication::showFile( "KA/Pi FAQ", "kdepim/kaddressbook/kapiFAQ.txt" );
 }
 
 #include <libkcal/syncdefines.h>
 
 KABC::Addressee KABCore::getLastSyncAddressee()
 {
     Addressee lse; 
     QString mCurrentSyncDevice = syncManager->getCurrentSyncDevice();
 
     //qDebug("CurrentSyncDevice %s ",mCurrentSyncDevice .latin1() );
     lse =   mAddressBook->findByUid( "last-syncAddressee-"+mCurrentSyncDevice );
     if (lse.isEmpty()) {
         qDebug("Creating new last-syncAddressee ");
         lse.setUid( "last-syncAddressee-"+mCurrentSyncDevice ); 
         QString sum = "";
         if ( mGlobalSyncMode == SYNC_MODE_EXTERNAL )
             sum = "E: ";
         lse.setFamilyName("!"+sum+mCurrentSyncDevice + i18n(" - sync event"));
         lse.setRevision( mLastAddressbookSync );
         lse.setCategories( i18n("SyncEvent") );
         mAddressBook->insertAddressee( lse );
     }
     return lse;
 }
 int  KABCore::takeAddressee( KABC::Addressee* local,  KABC::Addressee* remote, int mode , bool full )
 {
  
     //void setZaurusId(int id);
     // int zaurusId() const;
     //  void setZaurusUid(int id);
    // int zaurusUid() const;
    // void setZaurusStat(int id);
    // int zaurusStat() const;
     // 0 equal
     // 1 take local
     // 2 take remote
     // 3 cancel 
     QDateTime lastSync = mLastAddressbookSync;
     QDateTime localMod = local->revision();
     QDateTime remoteMod = remote->revision();
 
     QString mCurrentSyncDevice = syncManager->getCurrentSyncDevice();
 
     if ( mGlobalSyncMode == SYNC_MODE_EXTERNAL ) {
         bool remCh, locCh;
         remCh = ( remote->getCsum(mCurrentSyncDevice) != local->getCsum(mCurrentSyncDevice) );
        
         //qDebug("loc %s  rem %s", local->getCsum(mCurrentSyncDevice).latin1(), remote->getCsum(mCurrentSyncDevice).latin1() );
         locCh = ( localMod > mLastAddressbookSync );
         if ( !remCh && ! locCh ) {
             //qDebug("both not changed ");
             lastSync = localMod.addDays(1);
             if ( mode <= SYNC_PREF_ASK )
                 return 0;
         } else {
             if ( locCh ) {
                 //qDebug("loc changed %s %s",  localMod.toString().latin1(), mLastAddressbookSync.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 )
                 return 0;
         
     }
     // qDebug(" %d %d conflict on %s %s ", mode, full, local->summary().latin1(), remote->summary().latin1() );
 
     //qDebug("%s %d  %s %d", local->lastModified().toString().latin1() , localMod, remote->lastModified().toString().latin1(), remoteMod);  
     //qDebug("%d %d %d %d ", local->lastModified().time().second(), local->lastModified().time().msec(),  remote->lastModified().time().second(), remote->lastModified().time().msec() );
     //full = true; //debug only
     if ( full ) {
         bool equ = ( (*local) == (*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()  ,  local->lastModified().toString().latin1() , remote->lastModified().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;
         localIsNew = localMod >= remoteMod;
         //qDebug("conflict! ************************************** ");
         {
             KPIM::AddresseeChooser acd ( *local,*remote, localIsNew , 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;
 }
 
 
 bool KABCore::synchronizeAddressbooks( KABC::AddressBook* local, KABC::AddressBook* remote,int mode)
 {
     bool syncOK = true;
     int addedAddressee = 0;
     int addedAddresseeR = 0;
     int deletedAddresseeR = 0;
     int deletedAddresseeL = 0;
     int changedLocal = 0;
     int changedRemote = 0;
 
     QString mCurrentSyncName = syncManager->getCurrentSyncName();
     QString mCurrentSyncDevice = syncManager->getCurrentSyncDevice();
 
     //QPtrList<Addressee> el = local->rawAddressees(); 
     Addressee addresseeR;
     QString uid;
     int take;
     Addressee addresseeL;
     Addressee addresseeRSync;
     Addressee addresseeLSync;
     // KABC::Addressee::List  addresseeRSyncSharp = remote->getExternLastSyncAddressees();
     //KABC::Addressee::List  addresseeLSyncSharp = local->getExternLastSyncAddressees();
     bool fullDateRange = false;
     local->resetTempSyncStat();
     mLastAddressbookSync = QDateTime::currentDateTime();
     QDateTime modifiedCalendar = mLastAddressbookSync;;
     addresseeLSync = getLastSyncAddressee();
     qDebug("Last Sync %s ", addresseeLSync.revision().toString().latin1());
     addresseeR = remote->findByUid("last-syncAddressee-"+mCurrentSyncName );
     if ( !addresseeR.isEmpty() ) {
         addresseeRSync = addresseeR;
         remote->removeAddressee(addresseeR );
 
     } else {
         if ( mGlobalSyncMode == SYNC_MODE_EXTERNAL ) {
             addresseeRSync = addresseeLSync         ;
         } else {
             qDebug("FULLDATE 1");
             fullDateRange = true;
             Addressee newAdd;
             addresseeRSync = newAdd;
             addresseeRSync.setFamilyName(mCurrentSyncName + i18n(" - sync addressee"));
             addresseeRSync.setUid("last-syncAddressee-"+mCurrentSyncName ); 
             addresseeRSync.setRevision( mLastAddressbookSync );
             addresseeRSync.setCategories( i18n("SyncAddressee") );
         }
     }
     if ( addresseeLSync.revision() == mLastAddressbookSync ) {
             qDebug("FULLDATE 2");
         fullDateRange = true;
     }
     if ( ! fullDateRange  ) {
         if ( addresseeLSync.revision() != addresseeRSync.revision() ) {
             
             // qDebug("set fulldate to true %s %s" ,addresseeLSync->dtStart().toString().latin1(), addresseeRSync->dtStart().toString().latin1() ); 
             //qDebug("%d %d %d %d ", addresseeLSync->dtStart().time().second(), addresseeLSync->dtStart().time().msec() , addresseeRSync->dtStart().time().second(), addresseeRSync->dtStart().time().msec());
             fullDateRange = true;
             qDebug("FULLDATE 3 %s %s", addresseeLSync.revision().toString().latin1() , addresseeRSync.revision().toString().latin1() );
         } 
     }
     // fullDateRange = true; // debug only!
     if ( fullDateRange )
         mLastAddressbookSync = QDateTime::currentDateTime().addDays( -100*365);
     else
         mLastAddressbookSync = addresseeLSync.revision();
     // for resyncing if own file has changed
     // PENDING fixme later when implemented
 #if 0
     if ( mCurrentSyncDevice == "deleteaftersync" ) {
         mLastAddressbookSync = loadedFileVersion;
         qDebug("setting mLastAddressbookSync ");
     }
 #endif
 
     //qDebug("*************************** ");
     // qDebug("mLastAddressbookSync %s ",mLastAddressbookSync.toString().latin1() );
     QStringList er = remote->uidList(); 
     Addressee inR ;//= er.first();
     Addressee  inL;
 
     syncManager->showProgressBar(0, i18n("Syncing - close to abort!"), er.count());
 
     int modulo = (er.count()/10)+1;
     int incCounter = 0;
     while ( incCounter < er.count()) {
 	if (syncManager->isProgressBarCanceled())
             return false;
         if ( incCounter % modulo == 0 )
 	  syncManager->showProgressBar(incCounter);
 
         uid = er[ incCounter ]; 
         bool skipIncidence = false;
         if ( uid.left(19) == QString("last-syncAddressee-") )
             skipIncidence = true;
         QString idS,OidS;
         qApp->processEvents();
         if ( !skipIncidence ) {
             inL = local->findByUid( uid );
             inR = remote->findByUid( uid );
             //inL.setResource( 0 );
             //inR.setResource( 0 );
             if ( !inL.isEmpty() ) { // maybe conflict - same uid in both calendars
                 if ( !inL.resource() || inL.resource()->includeInSync() ) {
                     if ( take = takeAddressee( &inL, &inR, mode, fullDateRange ) ) {
                         //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) );
                                 inL.setID( mCurrentSyncDevice, inR.getID(mCurrentSyncDevice) );
                                 local->insertAddressee(  inL, false );
                                 idS = inR.externalUID();
                                 OidS = inR.originalExternalUID();
                             }
                             else
                                 idS = inR.IDStr();
                             remote->removeAddressee( inR );
                             inR = inL;
                             inR.setTempSyncStat( SYNC_TEMPSTATE_INITIAL );
                             if ( mGlobalSyncMode == SYNC_MODE_EXTERNAL ) {
                                 inR.setOriginalExternalUID( OidS );
                                 inR.setExternalUID( idS );
                             } else {
                                 inR.setIDStr( idS );
                             }
                             inR.setResource( 0 );
                             remote->insertAddressee(  inR , false);
                             ++changedRemote;
                         } else { // take == 2  take remote
                             if ( mGlobalSyncMode == SYNC_MODE_EXTERNAL ) {
                                 if ( inR.revision().date().year() < 2004 )
                                     inR.setRevision( modifiedCalendar );
                             }
                             idS = inL.IDStr();
                             local->removeAddressee( inL );
                             inL = inR;
                             inL.setIDStr( idS );
                             if ( mGlobalSyncMode == SYNC_MODE_EXTERNAL ) {
                                 inL.setCsum( mCurrentSyncDevice, inR.getCsum(mCurrentSyncDevice) );
                                 inL.setID( mCurrentSyncDevice, inR.getID(mCurrentSyncDevice) );
                             }
                             inL.setResource( 0 );
                             local->insertAddressee(  inL , false );
                             ++changedLocal;
                         }
                     }
                 }
             } else { //  no conflict
                 if ( mGlobalSyncMode == SYNC_MODE_EXTERNAL ) {
                     QString des = addresseeLSync.note(); 
                     if ( des.find( inR.getID(mCurrentSyncDevice)  +"," ) >= 0 && mode != 5) { // delete it
                         inR.setTempSyncStat( SYNC_TEMPSTATE_DELETE );
                         remote->insertAddressee( inR, false );
                         ++deletedAddresseeR; 
                     } else {
                         inR.setRevision( modifiedCalendar );
                         remote->insertAddressee( inR, false );
                         inL = inR;
                         inL.setResource( 0 );
                         local->insertAddressee( inL , false);
                         ++addedAddressee;
                     }
                 } else {
                     if ( inR.revision() > mLastAddressbookSync || mode == 5 ) {
                         inR.setRevision( modifiedCalendar );
                         remote->insertAddressee( inR, false );
                         inR.setResource( 0 );
                         local->insertAddressee( inR, false );
                         ++addedAddressee;
                     } else {
                         // pending checkExternSyncAddressee(addresseeRSyncSharp, inR);
                         remote->removeAddressee( inR );
                         ++deletedAddresseeR; 
                     }
                 }
             }
         }
         ++incCounter;
     }
     er.clear();
     QStringList el = local->uidList(); 
     modulo = (el.count()/10)+1;
 
     syncManager->showProgressBar(0, i18n("Add / remove addressees"), el.count());
     incCounter = 0;
     while ( incCounter < el.count()) {
         qApp->processEvents();
 	if (syncManager->isProgressBarCanceled())
             return false;
         if ( incCounter % modulo == 0 )
 	  syncManager->showProgressBar(incCounter);
         uid = el[ incCounter ]; 
         bool skipIncidence = false;
         if ( uid.left(19) == QString("last-syncAddressee-") )
             skipIncidence = true;
         if ( !skipIncidence )  {
             inL = local->findByUid( uid );
             if ( !inL.resource() || inL.resource()->includeInSync() ) {
                 inR = remote->findByUid( uid );
                 if ( inR.isEmpty() ) { 
                     if ( mGlobalSyncMode == SYNC_MODE_EXTERNAL ) {
                         if ( !inL.getID(mCurrentSyncDevice).isEmpty() && mode != 4 ) {
                             // pending checkExternSyncAddressee(addresseeLSyncSharp, inL);
                             local->removeAddressee( inL );
                             ++deletedAddresseeL; 
                         } else {
                             if ( ! syncManager->mWriteBackExistingOnly ) {
                                 inL.removeID(mCurrentSyncDevice );
                                 ++addedAddresseeR;
                                 inL.setRevision( modifiedCalendar );
                                 local->insertAddressee( inL, false );
                                 inR = inL;
                                 inR.setTempSyncStat( SYNC_TEMPSTATE_ADDED_EXTERNAL );
                                 inR.setResource( 0 );
                                 remote->insertAddressee( inR, false );
                             }
                         }
                     } else {
                         if ( inL.revision() < mLastAddressbookSync && mode != 4 ) {
                             // pending checkExternSyncAddressee(addresseeLSyncSharp, inL);
                             local->removeAddressee( inL );
                             ++deletedAddresseeL; 
                         } else {
                             if ( ! syncManager->mWriteBackExistingOnly ) {
                                 ++addedAddresseeR; 
                                 inL.setRevision( modifiedCalendar );
                                 local->insertAddressee( inL, false );
                                 inR = inL;
                                 inR.setResource( 0 );
                                 remote->insertAddressee( inR, false );
                             }
                         }
                     }
                 }
             }
         }
         ++incCounter;
     }
     el.clear();
     syncManager->hideProgressBar();
     mLastAddressbookSync = QDateTime::currentDateTime().addSecs( 1 );
     // get rid of micro seconds
     QTime t =  mLastAddressbookSync.time();
     mLastAddressbookSync.setTime( QTime (t.hour (), t.minute (), t.second () )  );
     addresseeLSync.setRevision( mLastAddressbookSync );
     addresseeRSync.setRevision( mLastAddressbookSync );
     addresseeRSync.setRole( i18n("!Remote from: ")+mCurrentSyncName ) ;
     addresseeLSync.setRole(i18n("!Local from: ") + mCurrentSyncName  );
     addresseeRSync.setGivenName( i18n("!DO NOT EDIT!") ) ;
     addresseeLSync.setGivenName(i18n("!DO NOT EDIT!")   );
     addresseeRSync.setOrganization( "!"+mLastAddressbookSync.toString() ) ;
     addresseeLSync.setOrganization("!"+ mLastAddressbookSync.toString() );
     addresseeRSync.setNote( "" ) ;
     addresseeLSync.setNote( "" );
 
     if ( mGlobalSyncMode ==  SYNC_MODE_NORMAL)
         remote->insertAddressee( addresseeRSync, false );
     local->insertAddressee( addresseeLSync, false );
     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"),addedAddressee, addedAddresseeR, changedLocal, changedRemote, deletedAddresseeL, deletedAddresseeR ); 
     if ( syncManager->mShowSyncSummary ) {
         KMessageBox::information(this, mes, i18n("KA/Pi Synchronization") );
     }
     qDebug( mes );
     return syncOK;
 }
 
 
 //this is a overwritten callbackmethods from the syncinterface
 bool KABCore::sync(KSyncManager* manager, QString filename, int mode)
 { 
 
     //pending prepare addresseeview for output
     //pending detect, if remote file has REV field. if not switch to external sync
     mGlobalSyncMode = SYNC_MODE_NORMAL;
     QString mCurrentSyncDevice = manager->getCurrentSyncDevice();
 
     AddressBook abLocal(filename,"syncContact");
     bool syncOK = false;
     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;
      {
          abLocal.importFromFile( fileName );
         qDebug("AB phone loaded ,sync device %s",mCurrentSyncDevice.latin1());
         mGlobalSyncMode = SYNC_MODE_EXTERNAL;
         abLocal.preparePhoneSync( mCurrentSyncDevice, true );
         abLocal.preExternSync( mAddressBook ,mCurrentSyncDevice, true );
         syncOK = synchronizeAddressbooks( mAddressBook, &abLocal, syncManager->mSyncAlgoPrefs );
         if (  syncOK ) {
             if ( syncManager->mWriteBackFile ) {
                 abLocal.removeSyncAddressees( true );
                 abLocal.saveABphone( fileName );
                 abLocal.findNewExtIds( fileName, mCurrentSyncDevice );
                 //abLocal.preparePhoneSync( mCurrentSyncDevice, false );
                 abLocal.postExternSync( mAddressBook,mCurrentSyncDevice );
             }
         }
         setModified();
     }
     if ( syncOK )
         mViewManager->refreshView();
     return syncOK;
 }
 void KABCore::getFile( bool success )
 {
     if ( ! success ) {
         message( i18n("Error receiving file. Nothing changed!") );
         return;
     }
     int count = mAddressBook->importFromFile( sentSyncFile() , false, true );
     if ( count )
         setModified( true );
     message( i18n("Pi-Sync successful!") );
     mViewManager->refreshView();
 }
 void KABCore::syncFileRequest()
 {
     mAddressBook->export2File( sentSyncFile() );
 }
 QString KABCore::sentSyncFile()
 {
 #ifdef DESKTOP_VERSION
     return  locateLocal( "tmp", "copysyncab.vcf" );
 #else
     return QString( "/tmp/copysyncab.vcf" );
 #endif 
 }
 
 void KABCore::setCaptionBack()
 {
     mMessageTimer->stop();
     topLevelWidget()->setCaption( i18n("KAddressbook/Pi") );
 }
diff --git a/kaddressbook/kabcore.h b/kaddressbook/kabcore.h
index fcbe1e8..a288505 100644
--- a/kaddressbook/kabcore.h
+++ b/kaddressbook/kabcore.h
@@ -1,502 +1,503 @@
 /*
     This file is part of KAddressbook.
     Copyright (c) 2003 Tobias Koenig <tokoe@kde.org>
 
     This program is free software; you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
     the Free Software Foundation; either version 2 of the License, or
     (at your option) any later version.
 
     This program 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 General Public License for more details.
 
     You should have received a copy of the GNU General Public License
     along with this program; if not, write to the Free Software
     Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 
     As a special exception, permission is given to link this program
     with any edition of Qt, and distribute the resulting executable,
     without including the source code for Qt in the source distribution.
 */
 
 #ifndef KABCORE_H
 #define KABCORE_H
 
 #include <kabc/field.h>
 
 #ifndef KAB_EMBEDDED
 #endif //KAB_EMBEDDED
 #include <qdict.h>
 #include <qtimer.h>
 
 #include <qwidget.h>
 #include <qpopupmenu.h>
 #include <ksyncmanager.h>
 #ifndef DESKTOP_VERSION
 #include <qcopchannel_qws.h> 
 #endif
 
 namespace KABC {
 class AddressBook;
 }
 
 #ifndef KAB_EMBEDDED
 class KAboutData;
 class KConfig;
 
 class KAddressBookService;
 class LDAPSearchDialog;
 #else //KAB_EMBEDDED
 class KAddressBookMain;
 //US class QAction;
 #endif //KAB_EMBEDDED
 class KCMultiDialog;
 class KXMLGUIClient;
 class ExtensionManager;
 class XXPortManager;
 class JumpButtonBar;
 class IncSearchWidget;
 class KDGanttMinimizeSplitter;
 class KAction;
 class KActionCollection;
 class KToggleAction;
 class KSyncProfile;
 
 class QAction;
 class QMenuBar;
 class QSplitter;
 class ViewContainer;
 class ViewManager;
 class AddresseeEditorDialog;
 class Ir;
 
 class KABCore : public QWidget, public KSyncInterface
 {
   Q_OBJECT
 
   public:
     KABCore( KAddressBookMain *client, bool readWrite, QWidget *parent, const char *name = 0 );
 
 
     ~KABCore();
 
 
 #ifdef KAB_EMBEDDED
   //US added functionality
     QPopupMenu* getViewMenu() {return viewMenu;}
     QPopupMenu* getFilterMenu() {return filterMenu;}
     QPopupMenu* getSettingsMenu() {return settingsMenu;}
     void addActionsManually();
 #endif //KAB_EMBEDDED
     /**
       Restores the global settings.
      */
     void restoreSettings();
 
     /**
       Saves the global settings.
      */
     void saveSettings();
 
     /**
       Returns a pointer to the StdAddressBook of the application.
      */
     KABC::AddressBook *addressBook() const;
 
     /**
       Returns a pointer to the KConfig object of the application.
      */
     static KConfig *config();
 
     /**
       Returns a pointer to the global KActionCollection object. So
       other classes can register their actions easily.
      */
     KActionCollection *actionCollection() const;
 
     /**
       Returns the current search field of the Incremental Search Widget.
      */
     KABC::Field *currentSearchField() const;
 
     /**
       Returns the uid list of the currently selected contacts.
      */
     QStringList selectedUIDs() const;
 
     /**
       Displays the ResourceSelectDialog and returns the selected
       resource or a null pointer if no resource was selected by
       the user.
      */
     KABC::Resource *requestResource( QWidget *parent );
 
 #ifndef KAB_EMBEDDED
     static KAboutData *createAboutData();
 #endif //KAB_EMBEDDED
 
 #ifdef KAB_EMBEDDED
     inline QPopupMenu* getImportMenu() { return ImportMenu;}
     inline QPopupMenu* getExportMenu() { return ExportMenu;}
 #endif //KAB_EMBEDDED
 
   public slots:
 #ifdef KAB_EMBEDDED
     void createAboutData();
 #endif //KAB_EMBEDDED
 
     void showLicence();
     void faq();
     void whatsnew() ;
     void synchowto() ;
     void writeToPhone();
 
     /**
       Is called whenever a contact is selected in the view.
      */
     void setContactSelected( const QString &uid );
 
     /**
       Opens the preferred mail composer with all selected contacts as
       arguments.
      */
     void sendMail();
 
     /**
       Opens the preferred mail composer with the given contacts as
       arguments.
      */
     void sendMail( const QString& email );
 
 
     void mailVCard();
     void mailVCard(const QStringList& uids);
 
     /**
       Beams the "WhoAmI contact.
      */
     void beamMySelf();
 
     void beamVCard();
     void export2phone();
     void beamVCard(const QStringList& uids);
     void beamDone( Ir *ir );
 
 
     /**
       Starts the preferred web browser with the given URL as argument.
      */
     void browse( const QString& url );
 
     /**
       Select all contacts in the view.
      */
     void selectAllContacts();
 
     /**
       Deletes all selected contacts from the address book.
      */
     void deleteContacts();
 
     /**
       Deletes given contacts from the address book.
 
       @param uids The uids of the contacts, which shall be deleted.
      */
     void deleteContacts( const QStringList &uids );
 
     /**
       Copys the selected contacts into clipboard for later pasting.
      */
     void copyContacts();
 
     /**
       Cuts the selected contacts and stores them for later pasting.
      */
     void cutContacts();
 
     /**
       Paste contacts from clipboard into the address book.
      */
     void pasteContacts();
 
     /**
       Paste given contacts into the address book.
 
       @param list The list of addressee, which shall be pasted.
      */
     void pasteContacts( KABC::Addressee::List &list );
 
     /**
       Sets the whoAmI contact, that is used by many other programs to
       get personal information about the current user.
      */
     void setWhoAmI();
 
     /**
       Displays the category dialog and applies the result to all
       selected contacts.
      */
     void setCategories();
 
     /**
       Sets the field list of the Incremental Search Widget.
      */
     void setSearchFields( const KABC::Field::List &fields );
 
     /**
       Search with the current search field for a contact, that matches
       the given text, and selects it in the view.
      */
     void incrementalSearch( const QString& text );
 
     /**
       Marks the address book as modified.
      */
     void setModified();
     /**
       Marks the address book as modified without refreshing the view.
      */
     void setModifiedWOrefresh();
 
     /**
       Marks the address book as modified concerning the argument.
      */
     void setModified( bool modified );
 
     /**
       Returns whether the address book is modified.
      */
     bool modified() const;
 
     /**
       Called whenever an contact is modified in the contact editor
       dialog or the quick edit.
      */
     void contactModified( const KABC::Addressee &addr );
 
     /**
       DCOP METHODS.
      */
     void addEmail( QString addr );
     void importVCard( const KURL& url, bool showPreview );
     void importVCard( const QString& vCard, bool showPreview );
     void newContact();
     QString getNameByPhone( const QString& phone );
     /**
       END DCOP METHODS
      */
 
     /**
       Saves the contents of the AddressBook back to disk.
      */
     void save();
 
     /**
       Undos the last command using the undo stack.
      */
     void undo();
 
     /**
       Redos the last command that was undone, using the redo stack.
      */
     void redo();
 
     /**
       Shows the edit dialog for the given uid. If the uid is QString::null,
       the method will try to find a selected addressee in the view.
      */
     void editContact( const QString &uid /*US = QString::null*/ );
 //US added a second method without defaultparameter
     void editContact2();
 
     /**
       Shows or edits the detail view for the given uid. If the uid is QString::null,
       the method will try to find a selected addressee in the view.
      */
     void executeContact( const QString &uid /*US = QString::null*/ );
 
     /**
       Launches the configuration dialog.
      */
     void openConfigDialog();
 
     /**
       Launches the ldap search dialog.
      */
     void openLDAPDialog();
 
     /**
       Creates a KAddressBookPrinter, which will display the print
       dialog and do the printing.
      */
     void print();
 
     /**
       Registers a new GUI client, so plugins can register its actions.
      */
    void addGUIClient( KXMLGUIClient *client );
 
    void requestForNameEmailUidList(const QString& sourceChannel, const QString& sessionuid);
    void requestForDetails(const QString& sourceChannel, const QString& sessionuid, const QString& name, const QString& email, const QString& uid);
    void requestForBirthdayList(const QString& sourceChannel, const QString& sessionuid);
 
 
   signals:
     void contactSelected( const QString &name );
     void contactSelected( const QPixmap &pixmap );
   public slots:
     void recieve(QString cmsg );
     void getFile( bool success );
     void syncFileRequest();
     void setDetailsVisible( bool visible );
     void setDetailsToState();
     //    void slotSyncMenu( int );
   private slots:
     void receive( const QCString& cmsg, const QByteArray& data );
     void toggleBeamReceive( );
     void disableBR(bool);
     void setJumpButtonBarVisible( bool visible );
     void setCaptionBack();
   void importFromOL();
     void extensionModified( const KABC::Addressee::List &list );
     void extensionChanged( int id );
     void clipboardDataChanged();
     void updateActionMenu();
     void configureKeyBindings();
     void removeVoice();
 #ifdef KAB_EMBEDDED
     void configureResources();
 #endif //KAB_EMBEDDED
 
     void slotEditorDestroyed( const QString &uid );
     void configurationChanged();
     void addressBookChanged();
 
   private:
     bool mBRdisabled;
 #ifndef DESKTOP_VERSION
     QCopChannel* infrared;
 #endif
     QTimer *mMessageTimer;
     void initGUI();
     void initActions();
     QString getPhoneFile();
 
     AddresseeEditorDialog *createAddresseeEditorDialog( QWidget *parent,
                                                         const char *name = 0 );
 
  KXMLGUIClient *mGUIClient;
 
   KABC::AddressBook *mAddressBook;
 
   ViewManager *mViewManager;
   // QSplitter *mDetailsSplitter;
   KDGanttMinimizeSplitter *mExtensionBarSplitter;
   ViewContainer *mDetails;
   KDGanttMinimizeSplitter* mMiniSplitter;
   XXPortManager *mXXPortManager;
   JumpButtonBar *mJumpButtonBar;
   IncSearchWidget *mIncSearchWidget;
   ExtensionManager *mExtensionManager;
 
   KCMultiDialog *mConfigureDialog;
 
 #ifndef KAB_EMBEDDED
     LDAPSearchDialog *mLdapSearchDialog;
 #endif //KAB_EMBEDDED
     // QDict<AddresseeEditorDialog> mEditorDict;
     AddresseeEditorDialog *mEditorDialog;
     bool mReadWrite;
     bool mModified;
     bool mIsPart;
     bool mMultipleViewsAtOnce;
 
 
     //US file menu
     KAction *mActionMail;
     KAction *mActionBeam;
     KToggleAction *mActionBR;
     KAction *mActionExport2phone;
     KAction* mActionPrint;
     KAction* mActionNewContact;
     KAction *mActionSave;
     KAction *mActionEditAddressee;
     KAction *mActionMailVCard;
     KAction *mActionBeamVCard;
 
     KAction *mActionQuit;
 
     //US edit menu
     KAction *mActionCopy;
     KAction *mActionCut;
     KAction *mActionPaste;
     KAction *mActionSelectAll;
     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
@@ -2743,1024 +2743,1030 @@ void CalendarView::appointment_edit()
 void CalendarView::appointment_delete()
 {
     Event *anEvent = 0;
 
     Incidence *incidence = mViewManager->currentView()->selectedIncidences().first();
 
     if (mViewManager->currentView()->isEventView()) {
         if ( incidence && incidence->type() == "Event" ) {
             anEvent = static_cast<Event *>(incidence);
         }
     }
 
     if (!anEvent) {
         KNotifyClient::beep();
         return;
     }
 
     deleteEvent(anEvent);
 }
 
 void CalendarView::todo_resub( Todo * parent, Todo * sub )
 {
     if (!sub) return;
     if (!parent) return;
     if ( sub->relatedTo() )
         sub->relatedTo()->removeRelation(sub);
     sub->setRelatedTo(parent);
     sub->setRelatedToUid(parent->uid());
     parent->addRelation(sub);
     sub->updated();
     parent->updated();
     setModified(true);
     updateView();
 }
 void CalendarView::todo_unsub(Todo *anTodo )
 {
     // Todo *anTodo = selectedTodo();
     if (!anTodo) return;
     if (!anTodo->relatedTo()) return;
     anTodo->relatedTo()->removeRelation(anTodo);
     anTodo->setRelatedTo(0);
     anTodo->updated();
     anTodo->setRelatedToUid("");
     setModified(true);
     updateView();
 }
 
 void CalendarView::deleteTodo(Todo *todo)
 {
     if (!todo) {
         KNotifyClient::beep();
         return;
     }
     if (KOPrefs::instance()->mConfirm) {
         switch (msgItemDelete()) {
         case KMessageBox::Continue: // OK
             if (!todo->relations().isEmpty()) {
                 KMessageBox::sorry(this,i18n("Cannot delete To-Do\nwhich has children."),
                                    i18n("Delete To-Do"));
             } else {
                 checkExternalId(  todo );
                 calendar()->deleteTodo(todo);
                 changeTodoDisplay( todo,KOGlobals::EVENTDELETED );
                 updateView();
             }
             break;
         } // switch
     } else {
         if (!todo->relations().isEmpty()) {
             KMessageBox::sorry(this,i18n("Cannot delete To-Do\nwhich has children."),
                                i18n("Delete To-Do"));
         } else {
             checkExternalId(  todo );
             mCalendar->deleteTodo(todo);
             changeTodoDisplay( todo,KOGlobals::EVENTDELETED );
             updateView();
         }
     }
     emit updateSearchDialog();
 }
 void CalendarView::deleteJournal(Journal *jour)
 {
     if (!jour) {
         KNotifyClient::beep();
         return;
     }
     if (KOPrefs::instance()->mConfirm) {
         switch (msgItemDelete()) {
         case KMessageBox::Continue: // OK
             calendar()->deleteJournal(jour);
             updateView();
             break;
         } // switch
     } else {
         calendar()->deleteJournal(jour);;
         updateView();
     }
     emit updateSearchDialog();
 }
 
 void CalendarView::deleteEvent(Event *anEvent)
 {
     if (!anEvent) {
         KNotifyClient::beep();
         return;
     }
 
     if (anEvent->recurrence()->doesRecur()) {
         QDate itemDate = mViewManager->currentSelectionDate();
         int km;
         if (!itemDate.isValid()) {
             //kdDebug() << "Date Not Valid" << endl;
             if (KOPrefs::instance()->mConfirm) {
                 km = KMessageBox::warningContinueCancel(this,anEvent->summary() +
                                                         i18n("\nThis event recurs\nover multiple dates.\nAre you sure you want\nto delete this event\nand all its recurrences?"),
                                                         i18n("KO/Pi Confirmation"),i18n("Delete All"));
                 if ( km == KMessageBox::Continue )
                     km = KMessageBox::No; // No = all below
             } else
                 km = KMessageBox::No;
         } else {
             km = KMessageBox::warningYesNoCancel(this,anEvent->summary() +
                                                  i18n("\nThis event recurs\nover multiple dates.\nDo you want to delete\nall it's recurrences,\nor only the current one on:\n")+
                                                       KGlobal::locale()->formatDate(itemDate)+i18n(" ?\n\nDelete:\n"),
                                                  i18n("KO/Pi Confirmation"),i18n("Current"),
                                                  i18n("All"));
         }
         switch(km) {
 
         case KMessageBox::No: // Continue // all
             //qDebug("KMessageBox::No ");
             if (anEvent->organizer()==KOPrefs::instance()->email() && anEvent->attendeeCount()>0)
                 schedule(Scheduler::Cancel,anEvent);
 
             checkExternalId( anEvent);
             mCalendar->deleteEvent(anEvent);
             changeEventDisplay(anEvent,KOGlobals::EVENTDELETED);
             break;
 
             // Disabled because it does not work
             //#if 0
         case KMessageBox::Yes: // just this one
             //QDate qd = mNavigator->selectedDates().first();
             //if (!qd.isValid()) {
             //  kdDebug() << "no date selected, or invalid date" << endl;
             //  KNotifyClient::beep();
             //  return;
             //}
             //while (!anEvent->recursOn(qd)) qd = qd.addDays(1);
             if (itemDate!=QDate(1,1,1) || itemDate.isValid()) {
                 anEvent->addExDate(itemDate);
                 int duration = anEvent->recurrence()->duration();
                 if ( duration > 0 ) {
                     anEvent->recurrence()->setDuration( duration - 1 );
                 }
                 changeEventDisplay(anEvent, KOGlobals::EVENTEDITED);
             }
             break;
             //#endif
         } // switch
     } else {
         if (KOPrefs::instance()->mConfirm) {
             switch (KMessageBox::warningContinueCancel(this,anEvent->summary() +
                                                        i18n("\nAre you sure you want\nto delete this event?"),
                                                        i18n("KO/Pi Confirmation"),i18n("Delete"))) {
             case KMessageBox::Continue: // OK
                 if (anEvent->organizer()==KOPrefs::instance()->email() && anEvent->attendeeCount()>0)
                     schedule(Scheduler::Cancel,anEvent);
                 checkExternalId( anEvent);
                 mCalendar->deleteEvent(anEvent);
                 changeEventDisplay(anEvent, KOGlobals::EVENTDELETED);
                 break;
             } // switch
         } else {
             if (anEvent->organizer()==KOPrefs::instance()->email() && anEvent->attendeeCount()>0)
                 schedule(Scheduler::Cancel,anEvent);
             checkExternalId( anEvent);
             mCalendar->deleteEvent(anEvent);
             changeEventDisplay(anEvent, KOGlobals::EVENTDELETED);
         }
     } // if-else
     emit updateSearchDialog();
 }
 
 bool CalendarView::deleteEvent(const QString &uid)
 {
     Event *ev = mCalendar->event(uid);
     if (ev) {
         deleteEvent(ev);
         return true;
     } else {
         return false;
     }
 }
 
 /*****************************************************************************/
 
 void CalendarView::action_mail()
 {
 #ifndef KORG_NOMAIL
     KOMailClient mailClient;
 
     Incidence *incidence = currentSelection();
 
     if (!incidence) {
         KMessageBox::sorry(this,i18n("Can't generate mail:\nNo event selected."));
         return;
     }
     if(incidence->attendeeCount() == 0 ) {
         KMessageBox::sorry(this,
                            i18n("Can't generate mail:\nNo attendees defined.\n"));
         return;
     }
 
     CalendarLocal cal_tmp;
     Event *event = 0;
     Event *ev = 0;
     if ( incidence && incidence->type() == "Event" ) {
         event = static_cast<Event *>(incidence);
         ev = new Event(*event);
         cal_tmp.addEvent(ev);
     }
     ICalFormat mForm();
     QString attachment = mForm.toString( &cal_tmp );
     if (ev) delete(ev);
 
     mailClient.mailAttendees(currentSelection(), attachment);
 
 #endif
 
 #if 0
     Event *anEvent = 0;
     if (mViewManager->currentView()->isEventView()) {
         anEvent = dynamic_cast<Event *>((mViewManager->currentView()->selectedIncidences()).first());
     }
 
     if (!anEvent) {
         KMessageBox::sorry(this,i18n("Can't generate mail:\nNo event selected."));
         return;
     }
     if(anEvent->attendeeCount() == 0 ) {
         KMessageBox::sorry(this,
                            i18n("Can't generate mail:\nNo attendees defined.\n"));
         return;
     }
 
     mailobject.emailEvent(anEvent);
 #endif
 }
 
 
 void CalendarView::schedule_publish(Incidence *incidence)
 {
     Event *event = 0;
     Todo *todo = 0;
 
     if (incidence == 0) {
         incidence = mViewManager->currentView()->selectedIncidences().first();
         if (incidence == 0) {
             incidence = mTodoList->selectedIncidences().first();
         }
     }
     if ( incidence && incidence->type() == "Event" ) {
         event = static_cast<Event *>(incidence);
     } else {
         if ( incidence && incidence->type() == "Todo" ) {
             todo = static_cast<Todo *>(incidence);
         }
     }
 
     if (!event && !todo) {
         KMessageBox::sorry(this,i18n("No event selected."));
         return;
     }
 
     PublishDialog *publishdlg = new PublishDialog();
     if (incidence->attendeeCount()>0) {
         QPtrList<Attendee> attendees = incidence->attendees();
         attendees.first();
         while ( attendees.current()!=0 ) {
             publishdlg->addAttendee(attendees.current());
             attendees.next();
         }
     }
     bool send = true;
     if ( KOPrefs::instance()->mMailClient == KOPrefs::MailClientSendmail ) {
         if ( publishdlg->exec() != QDialog::Accepted )
             send = false;
     }
     if ( send ) {
         OutgoingDialog *dlg = mDialogManager->outgoingDialog();
         if ( event ) {
             Event *ev = new Event(*event);
             ev->registerObserver(0);
             ev->clearAttendees();
             if (!dlg->addMessage(ev,Scheduler::Publish,publishdlg->addresses())) {
                 delete(ev);
             }
         } else {
             if ( todo ) {
                 Todo *ev = new Todo(*todo);
                 ev->registerObserver(0);
                 ev->clearAttendees();
                 if (!dlg->addMessage(ev,Scheduler::Publish,publishdlg->addresses())) {
                     delete(ev);
                 }
             }
         }
     }
     delete publishdlg;
 }
 
 void CalendarView::schedule_request(Incidence *incidence)
 {
     schedule(Scheduler::Request,incidence);
 }
 
 void CalendarView::schedule_refresh(Incidence *incidence)
 {
     schedule(Scheduler::Refresh,incidence);
 }
 
 void CalendarView::schedule_cancel(Incidence *incidence)
 {
     schedule(Scheduler::Cancel,incidence);
 }
 
 void CalendarView::schedule_add(Incidence *incidence)
 {
     schedule(Scheduler::Add,incidence);
 }
 
 void CalendarView::schedule_reply(Incidence *incidence)
 {
     schedule(Scheduler::Reply,incidence);
 }
 
 void CalendarView::schedule_counter(Incidence *incidence)
 {
     schedule(Scheduler::Counter,incidence);
 }
 
 void CalendarView::schedule_declinecounter(Incidence *incidence)
 {
     schedule(Scheduler::Declinecounter,incidence);
 }
 
 void CalendarView::schedule_publish_freebusy(int daysToPublish)
 {
     QDateTime start = QDateTime::currentDateTime();
     QDateTime end = start.addDays(daysToPublish);
 
     FreeBusy *freebusy = new FreeBusy(mCalendar, start, end);
     freebusy->setOrganizer(KOPrefs::instance()->email());
 
 
     PublishDialog *publishdlg = new PublishDialog();
     if ( publishdlg->exec() == QDialog::Accepted ) {
         OutgoingDialog *dlg = mDialogManager->outgoingDialog();
         if (!dlg->addMessage(freebusy,Scheduler::Publish,publishdlg->addresses())) {
             delete(freebusy);
         }
     }
     delete publishdlg;
 }
 
 void CalendarView::schedule(Scheduler::Method method, Incidence *incidence)
 {
     Event *event = 0;
     Todo *todo = 0;
 
     if (incidence == 0) {
         incidence = mViewManager->currentView()->selectedIncidences().first();
         if (incidence == 0) {
             incidence = mTodoList->selectedIncidences().first();
         }
     }
     if ( incidence && incidence->type() == "Event" ) {
         event = static_cast<Event *>(incidence);
     }
     if ( incidence && incidence->type() == "Todo" ) {
         todo = static_cast<Todo *>(incidence);
     }
 
     if (!event && !todo) {
         KMessageBox::sorry(this,i18n("No event selected."));
         return;
     }
 
     if( incidence->attendeeCount() == 0 && method != Scheduler::Publish ) {
         KMessageBox::sorry(this,i18n("The event has no attendees."));
         return;
     }
 
     Event *ev = 0;
     if (event) ev = new Event(*event);
     Todo *to = 0;
     if (todo) to = new Todo(*todo);
 
     if (method == Scheduler::Reply || method == Scheduler::Refresh) {
         Attendee *me = incidence->attendeeByMails(KOPrefs::instance()->mAdditionalMails,KOPrefs::instance()->email());
         if (!me) {
             KMessageBox::sorry(this,i18n("Could not find your attendee entry.\nPlease check the emails."));
             return;
         }
         if (me->status()==Attendee::NeedsAction && me->RSVP() && method==Scheduler::Reply) {
             StatusDialog *statdlg = new StatusDialog(this);
             if (!statdlg->exec()==QDialog::Accepted) return;
             me->setStatus( statdlg->status() );
             delete(statdlg);
         }
         Attendee *menew = new Attendee(*me);
         if (ev) {
             ev->clearAttendees();
             ev->addAttendee(menew,false);
         } else {
             if (to) {
                 todo->clearAttendees();
                 todo->addAttendee(menew,false);
             }
         }
     }
 
     OutgoingDialog *dlg = mDialogManager->outgoingDialog();
     if (ev) {
         if ( !dlg->addMessage(ev,method) ) delete(ev);
     } else {
         if (to) {
             if ( !dlg->addMessage(to,method) ) delete(to);
         }
     }
 }
 
 void CalendarView::openAddressbook()
 {
     KRun::runCommand("kaddressbook");
 }
 
 void CalendarView::setModified(bool modified)
 {
     if ( modified )
         emit signalmodified();
     if (mModified != modified) {
         mModified = modified;
         emit modifiedChanged(mModified);
     }
 }
 
 bool CalendarView::isReadOnly()
 {
     return mReadOnly;
 }
 
 void CalendarView::setReadOnly(bool readOnly)
 {
     if (mReadOnly != readOnly) {
         mReadOnly = readOnly;
         emit readOnlyChanged(mReadOnly);
     }
 }
 
 bool CalendarView::isModified()
 {
     return mModified;
 }
 
 void CalendarView::printSetup()
 {
 #ifndef KORG_NOPRINTER
     createPrinter();
 
     mCalPrinter->setupPrinter();
 #endif
 }
 
 void CalendarView::print()
 {
 #ifndef KORG_NOPRINTER
     createPrinter();
 
     DateList tmpDateList = mNavigator->selectedDates();
     mCalPrinter->print(CalPrinter::Month,
                        tmpDateList.first(), tmpDateList.last());
 #endif
 }
 
 void CalendarView::printPreview()
 {
 #ifndef KORG_NOPRINTER
     kdDebug() << "CalendarView::printPreview()" << endl;
 
     createPrinter();
 
     DateList tmpDateList = mNavigator->selectedDates();
 
     mViewManager->currentView()->printPreview(mCalPrinter,tmpDateList.first(),
                                               tmpDateList.last());
 #endif
 }
 
 void CalendarView::exportICalendar()
 {
     QString filename = KFileDialog::getSaveFileName("icalout.ics",i18n("*.ics|ICalendars"),this);
 
     // Force correct extension
     if (filename.right(4) != ".ics") filename += ".ics";
 
     FileStorage storage( mCalendar, filename, new ICalFormat() );
     storage.save();
 }
 
 bool CalendarView::exportVCalendar( QString filename )
 {
     if (mCalendar->journals().count() > 0) {
         int result = KMessageBox::warningContinueCancel(this,
                                                         i18n("The journal entries can not be\nexported to a vCalendar file."),
                                                         i18n("Data Loss Warning"),i18n("Proceed"),i18n("Cancel"),
                                                         true);
         if (result != KMessageBox::Continue) return false;
     }
 
     //QString filename = KFileDialog::getSaveFileName("vcalout.vcs",i18n("*.vcs|VCalendars"),this);
 
     // Force correct extension
     if (filename.right(4) != ".vcs") filename += ".vcs";
 
     FileStorage storage( mCalendar, filename, new VCalFormat );
     return storage.save();
  
 }
 
 void CalendarView::eventUpdated(Incidence *)
 {
     setModified();
     // Don't call updateView here. The code, which has caused the update of the
     // event is responsible for updating the view.
     //  updateView();
 }
 
 void CalendarView::adaptNavigationUnits()
 {
     if (mViewManager->currentView()->isEventView()) {
         int days = mViewManager->currentView()->currentDateCount();
         if (days == 1) {
             emit changeNavStringPrev(i18n("&Previous Day"));
             emit changeNavStringNext(i18n("&Next Day"));
         } else {
             emit changeNavStringPrev(i18n("&Previous Week"));
             emit changeNavStringNext(i18n("&Next Week"));
         }
     }
 }
 
 void CalendarView::processMainViewSelection( Incidence *incidence )
 {
     if ( incidence ) mTodoList->clearSelection();
     processIncidenceSelection( incidence );
 }
 
 void CalendarView::processTodoListSelection( Incidence *incidence )
 {
     if ( incidence && mViewManager->currentView() ) {
         mViewManager->currentView()->clearSelection();
     }
     processIncidenceSelection( incidence );
 }
 
 void CalendarView::processIncidenceSelection( Incidence *incidence )
 {
     if ( incidence == mSelectedIncidence ) return;
 
     mSelectedIncidence = incidence;
 
     emit incidenceSelected( mSelectedIncidence );
 
     if ( incidence && incidence->type() == "Event" ) {
         Event *event = static_cast<Event *>( incidence );
         if ( event->organizer() == KOPrefs::instance()->email() ) {
             emit organizerEventsSelected( true );
         } else {
             emit organizerEventsSelected(false);
         }
         if (event->attendeeByMails( KOPrefs::instance()->mAdditionalMails,
                                     KOPrefs::instance()->email() ) ) {
             emit groupEventsSelected( true );
         } else {
             emit groupEventsSelected(false);
         }
         return;
     } else {
         if  ( incidence && incidence->type() == "Todo" ) {
             emit todoSelected( true );
             Todo *event = static_cast<Todo *>( incidence );
             if ( event->organizer() == KOPrefs::instance()->email() ) {
                 emit organizerEventsSelected( true );
             } else {
                 emit organizerEventsSelected(false);
             }
             if (event->attendeeByMails( KOPrefs::instance()->mAdditionalMails,
                                         KOPrefs::instance()->email() ) ) {
                 emit groupEventsSelected( true );
             } else {
                 emit groupEventsSelected(false);
             }
             return;
         } else {
             emit todoSelected( false );
             emit organizerEventsSelected(false);
             emit groupEventsSelected(false);
         }
         return;
     }
 
     /*  if  ( incidence && incidence->type() == "Todo" ) {
         emit todoSelected( true );
         } else {
         emit todoSelected( false );
         }*/
 }
 
 
 void CalendarView::checkClipboard()
 {
 #ifndef KORG_NODND
     if (ICalDrag::canDecode(QApplication::clipboard()->data())) {
         emit pasteEnabled(true);
     } else {
         emit pasteEnabled(false);
     }
 #endif
 }
 
 void CalendarView::showDates(const DateList &selectedDates)
 {
     //  kdDebug() << "CalendarView::selectDates()" << endl;
   
     if ( mViewManager->currentView() ) {
         updateView( selectedDates.first(), selectedDates.last() );
     } else {
         mViewManager->showAgendaView();
     }
 
     QString selDates;
     selDates = KGlobal::locale()->formatDate( selectedDates.first(), true);
     if  (selectedDates.first() < selectedDates.last() )
         selDates += " - " + KGlobal::locale()->formatDate( selectedDates.last(),true);
     topLevelWidget()->setCaption( i18n("Dates: ") + selDates );
   
 }
 
 QPtrList<CalFilter> CalendarView::filters()
 {
     return mFilters;
 
 }
 void CalendarView::editFilters()
 {
     //  kdDebug() << "CalendarView::editFilters()" << endl;
 
     CalFilter *filter = mFilters.first();
     while(filter) {
         kdDebug() << " Filter: " << filter->name() << endl;
         filter = mFilters.next();
     }
 
     mDialogManager->showFilterEditDialog(&mFilters);
 }
 void CalendarView::toggleFilter()
 {
     showFilter(! mFilterView->isVisible());
 }
 
 KOFilterView *CalendarView::filterView()
 {
     return mFilterView;
 }
 void CalendarView::selectFilter( int fil )
 {
     mFilterView->setSelectedFilter( fil );
 }
 void CalendarView::showFilter(bool visible)
 {
     if (visible) mFilterView->show();
     else mFilterView->hide();
 }
 void CalendarView::toggleFilerEnabled( )
 {
     mFilterView->setFiltersEnabled ( !mFilterView->filtersEnabled()  );
     if ( !mFilterView->filtersEnabled()   ) 
         topLevelWidget()->setCaption( i18n("Filter disabled ") );
         
 }
 void CalendarView::updateFilter()
 {
     CalFilter *filter = mFilterView->selectedFilter();
     if (filter) {
         if (mFilterView->filtersEnabled()) {
             topLevelWidget()->setCaption( i18n("Filter selected: ")+filter->name() );
             filter->setEnabled(true);
         }
         else filter->setEnabled(false);
         mCalendar->setFilter(filter);
         updateView();
     }
 }
 
 void CalendarView::filterEdited()
 {
     mFilterView->updateFilters();
     updateFilter();
     writeSettings();
 }
 
 
 void CalendarView::takeOverEvent()
 {
     Incidence *incidence = currentSelection();
 
     if (!incidence) return;
 
     incidence->setOrganizer(KOPrefs::instance()->email());
     incidence->recreate();
     incidence->setReadOnly(false);
 
     updateView();
 }
 
 void CalendarView::takeOverCalendar()
 {
     // TODO: Create Calendar::allIncidences() function and use it here
 
     QPtrList<Event> events = mCalendar->events();
     for(uint i=0; i<events.count(); ++i) {
         events.at(i)->setOrganizer(KOPrefs::instance()->email());
         events.at(i)->recreate();
         events.at(i)->setReadOnly(false);
     }
 
     QPtrList<Todo> todos = mCalendar->todos();
     for(uint i=0; i<todos.count(); ++i) {
         todos.at(i)->setOrganizer(KOPrefs::instance()->email());
         todos.at(i)->recreate();
         todos.at(i)->setReadOnly(false);
     }
 
     QPtrList<Journal> journals = mCalendar->journals();
     for(uint i=0; i<journals.count(); ++i) {
         journals.at(i)->setOrganizer(KOPrefs::instance()->email());
         journals.at(i)->recreate();
         journals.at(i)->setReadOnly(false);
     }
 
     updateView();
 }
 
 void CalendarView::showIntro()
 {
     kdDebug() << "To be implemented." << endl;
 }
 
 QWidgetStack *CalendarView::viewStack()
 {
     return mRightFrame;
 }
 
 QWidget *CalendarView::leftFrame()
 {
     return mLeftFrame;
 }
 
 DateNavigator *CalendarView::dateNavigator()
 {
     return mNavigator;
 }
 
 KDateNavigator* CalendarView::dateNavigatorWidget()
 {
     return mDateNavigator;
 }
 void CalendarView::toggleDateNavigatorWidget()
 {
     if (mDateNavigator->isVisible())
         mDateNavigator->hide();
     else
         mDateNavigator->show();
 }
 void CalendarView::addView(KOrg::BaseView *view)
 {
     mViewManager->addView(view);
 }
 
 void CalendarView::showView(KOrg::BaseView *view)
 {
     mViewManager->showView(view, mLeftFrame->isVisible());
 }
 
 Incidence *CalendarView::currentSelection()
 {
     return mViewManager->currentSelection();
 }
 void CalendarView::toggleAllDaySize()
 {
     /*
     if ( KOPrefs::instance()->mAllDaySize > 47 )
         KOPrefs::instance()->mAllDaySize = KOPrefs::instance()->mAllDaySize /2;
     else
         KOPrefs::instance()->mAllDaySize = KOPrefs::instance()->mAllDaySize *2;
     */
     viewManager()->agendaView()->toggleAllDay();
 }
 void CalendarView::toggleExpand()
 {
     //  if ( mLeftFrame->isHidden() ) {
     //     mLeftFrame->show(); 
     //     emit calendarViewExpanded( false );
     //   } else {
     //     mLeftFrame->hide();
     //     emit calendarViewExpanded( true );
     //   }
 
     globalFlagBlockAgenda = 1;
     emit calendarViewExpanded( !mLeftFrame->isHidden() );
     globalFlagBlockAgenda = 5;
     mViewManager->raiseCurrentView( !mLeftFrame->isHidden() );
     //mViewManager->showView( 0, true );
 }
 
 void CalendarView::calendarModified( bool modified, Calendar * )
 {
     setModified( modified );
 }
 
 Todo *CalendarView::selectedTodo()
 {
     Incidence *incidence = currentSelection();
     if ( incidence && incidence->type() == "Todo" ) {
         return static_cast<Todo *>( incidence );
     }
 
     incidence = mTodoList->selectedIncidences().first();
     if ( incidence && incidence->type() == "Todo" ) {
         return static_cast<Todo *>( incidence );
     }
 
     return 0;
 }
 
 void CalendarView::dialogClosing(Incidence *in)
 {
     // mDialogList.remove(in);
 }
 
 void CalendarView::showIncidence()
 {
     Incidence *incidence = currentSelection();
     if ( !incidence ) incidence = mTodoList->selectedIncidences().first();
     if ( incidence ) {
         ShowIncidenceVisitor v;
         v.act( incidence, this );
     }
 }
 void CalendarView::editIncidenceDescription()
 { 
     mFlagEditDescription = true;
     editIncidence();
     mFlagEditDescription = false;
 }
 void CalendarView::editIncidence()
 {
     // qDebug("editIncidence() ");
     Incidence *incidence = currentSelection();
     if ( !incidence ) incidence = mTodoList->selectedIncidences().first();
     if ( incidence ) {
         EditIncidenceVisitor v;
         v.act( incidence, this );
     }
 }
 
 void CalendarView::deleteIncidence()
 {
     Incidence *incidence = currentSelection();
     if ( !incidence ) incidence = mTodoList->selectedIncidences().first();
     if ( incidence ) {
         deleteIncidence(incidence);
     }
 }
 
 void CalendarView::showIncidence(Incidence *incidence)
 {
     if ( incidence ) {
         ShowIncidenceVisitor v;
         v.act( incidence, this );
     }
 }
 
 void CalendarView::editIncidence(Incidence *incidence)
 { 
     if ( incidence ) {
        
         EditIncidenceVisitor v;
         v.act( incidence, this );
         
     }
 }
 
 void CalendarView::deleteIncidence(Incidence *incidence)
 {
     //qDebug(" CalendarView::deleteIncidence ");
     if ( incidence ) {
         DeleteIncidenceVisitor v;
         v.act( incidence, this );
     }
 }
 
 
 void CalendarView::lookForOutgoingMessages()
 {
     OutgoingDialog *ogd = mDialogManager->outgoingDialog();
     ogd->loadMessages();
 }
 
 void CalendarView::lookForIncomingMessages()
 {
     IncomingDialog *icd = mDialogManager->incomingDialog();
     icd->retrieve();
 }
 
 bool  CalendarView::removeCompletedSubTodos( Todo* t )
 {
     bool deleteTodo = true;
     QPtrList<Incidence> subTodos;
     Incidence *aTodo;
     subTodos = t->relations();
     for (aTodo = subTodos.first(); aTodo; aTodo = subTodos.next()) {
         if (! removeCompletedSubTodos( (Todo*) aTodo ))
             deleteTodo = false;
     }
     if ( deleteTodo ) {
         if ( t->isCompleted() ) {
             checkExternalId(  t );
             mCalendar->deleteTodo( t );
             changeTodoDisplay( t,KOGlobals::EVENTDELETED );
         }
         else
             deleteTodo = false;
     }
     return deleteTodo;
 
 }
 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());
+
+}
diff --git a/korganizer/calendarview.h b/korganizer/calendarview.h
index 2818ee9..acc20d6 100644
--- a/korganizer/calendarview.h
+++ b/korganizer/calendarview.h
@@ -1,605 +1,606 @@
 /*
     This file is part of KOrganizer.
     Copyright (c) 2000, 2001
     Cornelius Schumacher <schumacher@kde.org>
 
     This program is free software; you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
     the Free Software Foundation; either version 2 of the License, or
     (at your option) any later version.
 
     This program 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 General Public License for more details.
 
     You should have received a copy of the GNU General Public License
     along with this program; if not, write to the Free Software
     Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 
     As a special exception, permission is given to link this program
     with any edition of Qt, and distribute the resulting executable,
     without including the source code for Qt in the source distribution.
 */
 #ifndef CALENDARVIEW_H
 #define CALENDARVIEW_H
 
 #include <qframe.h>
 #include <qlayout.h>
 #include <qwidget.h>
 #include <qptrlist.h>
 #include <qvbox.h>
 #include <qmap.h>
 #ifndef DESKTOP_VERSION
 #include <qtopia/ir.h> 
 #else
 #define Ir char
 #endif
 #include <libkcal/calendar.h>
 #include <libkcal/scheduler.h>
 #include <libkcal/calendarresources.h>
 #include <libkcal/resourcecalendar.h>
 
 #include <korganizer/calendarviewbase.h>
 
 #include <ksyncmanager.h>
 
 class QWidgetStack;
 class QSplitter;
 
 class CalPrinter;
 class KOFilterView;
 class KOViewManager;
 class KODialogManager;
 class KOTodoView;
 class KDateNavigator;
 class DateNavigator;
 class KOIncidenceEditor;
 class KDatePicker;
 class ResourceView;
 class NavigatorBar; 
 class KOEventEditor;
 class KOTodoEditor ;
 class KOEventViewerDialog;
 class KOBeamPrefs;
 class KSyncProfile;
 class AlarmDialog;
 class KCal::Attendee;
 
 namespace KCal { class FileStorage; }
 
 using namespace KCal;
 
 /**
   This is the main calendar widget. It provides the different vies on t he
   calendar data as well as the date navigator. It also handles synchronisation
   of the different views and controls the different dialogs like preferences,
   event editor, search dialog etc.
   
   @short main calendar view widget
   @author Cornelius Schumacher
 */
 class CalendarView : public KOrg::CalendarViewBase, public KCal::Calendar::Observer, public KSyncInterface
 {
     Q_OBJECT
   public:
     /**
       Constructs a new calendar view widget.
 
       @param calendar calendar document
       @param parent   parent window
       @param name     Qt internal widget object name
     */
     CalendarView( CalendarResources *calendar, QWidget *parent = 0,
                   const char *name = 0 );
     CalendarView( Calendar *calendar, QWidget *parent = 0,
                   const char *name = 0 );
     virtual ~CalendarView();
   
     Calendar *calendar() { return mCalendar; }
 
     KOViewManager *viewManager();
     KODialogManager *dialogManager();
 
     QDate startDate();
     QDate endDate();
 
     QWidgetStack *viewStack();
     QWidget *leftFrame();
     NavigatorBar *navigatorBar();
 
     DateNavigator *dateNavigator();
     KDateNavigator *dateNavigatorWidget();
 
     void addView(KOrg::BaseView *);
     void showView(KOrg::BaseView *);
     KOEventViewerDialog* getEventViewerDialog();
     Incidence *currentSelection();
 
   signals:
     void tempDisableBR(bool);
     /** This todo has been modified */
     void todoModified(Todo *, int);
   
     /** when change is made to options dialog, the topwidget will catch this
      *  and emit this signal which notifies all widgets which have registered 
      *  for notification to update their settings. */
     void configChanged();
     /** emitted when the topwidget is closing down, so that any attached
         child windows can also close. */
     void closingDown();
     /** emitted right before we die */
     void closed(QWidget *);
     
     /** Emitted when state of modified flag changes */
     void modifiedChanged(bool);
     void signalmodified();
   
     /** Emitted when state of read-only flag changes */
     void readOnlyChanged(bool);
   
     /** Emitted when the unit of navigation changes */
     void changeNavStringPrev(const QString &);
     void changeNavStringNext(const QString &);
   
     /** Emitted when state of events selection has changed and user is organizer*/
     void organizerEventsSelected(bool);
     /** Emitted when state of events selection has changed and user is attendee*/
     void groupEventsSelected(bool);
     /**
       Emitted when an incidence gets selected. If the selection is cleared the
       signal is emitted with 0 as argument.
     */
     void incidenceSelected( Incidence * );
     /** Emitted, when a todoitem is selected or deselected. */
     void todoSelected( bool );
 
     /**
       Emitted, when clipboard content changes. Parameter indicates if paste
       is possible or not.
     */
     void pasteEnabled(bool);
     
     /** Emitted, when the number of incoming messages has changed. */
     void numIncomingChanged(int);
 
     /** Emitted, when the number of outgoing messages has changed. */
     void numOutgoingChanged(int);
 
     /** Send status message, which can e.g. be displayed in the status bar. */
     void statusMessage(const QString &);
     
     void calendarViewExpanded( bool );
     void updateSearchDialog();
 
 
   public slots:
     void showOpenError();
     void watchSavedFile();
     void recheckTimerAlarm();
     void checkNextTimerAlarm();
     void addAlarm(const QDateTime &qdt, const QString &noti  );
     void addSuspendAlarm(const QDateTime &qdt, const QString &noti  );
     void removeAlarm(const QDateTime &qdt, const QString &noti  );
 
     /** options dialog made a changed to the configuration. we catch this
      *  and notify all widgets which need to update their configuration. */
     void updateConfig();
 
     void insertBirthdays(const QString& uid, const QStringList& birthdayList, 
 			 const QStringList& anniversaryList, const QStringList& realNameList,
 			 const QStringList& emailList, const QStringList& assembledNameList,
 			 const QStringList& uidList);
 
     /**
       Load calendar from file \a filename. If \a merge is true, load 
       calendar into existing one, if it is false, clear calendar, before
       loading. Return true, if calendar could be successfully loaded.
     */
     bool openCalendar(QString filename, bool merge=false);
     bool syncCalendar(QString filename,int mode = 0 );
 
     /**
       Save calendar data to file. Return true if calendar could be
       successfully saved.
     */
     bool saveCalendar(QString filename);
   
     /**
       Close calendar. Clear calendar data and reset views to display an empty
       calendar.
     */
     void closeCalendar();
   
     /** Archive old events of calendar */
     void archiveCalendar();
 
     void showIncidence();
     void editIncidence();
     void editIncidenceDescription();
     void deleteIncidence();
     void cloneIncidence();
     void moveIncidence();
     void beamIncidence();
     void toggleCancelIncidence();
   
     /** create an editeventwin with supplied date/time, and if bool is true,
      * make the event take all day. */
     void newEvent(QDateTime, QDateTime, bool allDay = false);
     void newEvent(QDateTime fh);
     void newEvent(QDate dt);
     /** create new event without having a date hint. Takes current date as
      default hint. */ 
     void newEvent();
     void newFloatingEvent();
 
     /** Create a read-only viewer dialog for the supplied incidence. It calls the correct showXXX method*/
     void showIncidence(Incidence *);
     /** Create an editor for the supplied incidence. It calls the correct editXXX method*/
     void editIncidence(Incidence *);
     /** Delete the supplied incidence. It calls the correct deleteXXX method*/
     void deleteIncidence(Incidence *);
     void cloneIncidence(Incidence *);
     void cancelIncidence(Incidence *);
     /** Create an editor for the supplied event. */
     void editEvent(Event *);
     /** Delete the supplied event. */
     void deleteEvent(Event *);
     /** Delete the event with the given unique ID. Returns false, if event wasn't
     found. */
     bool deleteEvent(const QString &uid);
     /** Create a read-only viewer dialog for the supplied event. */
     void showEvent(Event *);
 
     void editJournal(Journal *);
     void showJournal(Journal *);
     void deleteJournal(Journal *);
     /** Create an editor dialog for a todo */
     void editTodo(Todo *);
     /** Create a read-only viewer dialog for the supplied todo */
     void showTodo(Todo *);
     /** create new todo */
     void newTodo();
     /** create new todo with a parent todo */
     void newSubTodo();
     /** create new todo with a parent todo */
     void newSubTodo(Todo *);
     /** Delete todo */
     void deleteTodo(Todo *);
 
             
     /** Check if clipboard contains vCalendar event. The signal pasteEnabled() is
      * emitted as result. */
     void checkClipboard();
     
     /** using the KConfig associated with the kapp variable, read in the
      * settings from the config file. 
      */
     void readSettings();
     
     /** write current state to config file. */
     void writeSettings();
 
     /** read settings for calendar filters */
     void readFilterSettings(KConfig *config);
     
     /** write settings for calendar filters */
     void writeFilterSettings(KConfig *config);
 
     /** passes on the message that an event has changed to the currently
      * activated view so that it can make appropriate display changes. */
     void changeEventDisplay(Event *, int);
     void changeIncidenceDisplay(Incidence *, int);
     void changeTodoDisplay(Todo *, int);
   
     void eventAdded(Event *);
     void eventChanged(Event *);
     void eventToBeDeleted(Event *);
     void eventDeleted();
   
     void todoAdded(Todo *);
     void todoChanged(Todo *);
     void todoToBeDeleted(Todo *);
     void todoDeleted();
 
     void updateView(const QDate &start, const QDate &end);
     void updateView();
   
     /** Full update of visible todo views */
     void updateTodoViews();
 
     void updateUnmanagedViews();
   
     /** cut the current appointment to the clipboard */
     void edit_cut();
   
     /** copy the current appointment(s) to the clipboard */
     void edit_copy();
 
     /** paste the current vobject(s) in the clipboard buffer into calendar */
     void edit_paste();
   
     /** edit viewing and configuration options. */
     void edit_options();
     /**
       Functions for printing, previewing a print, and setting up printing
       parameters.
     */
     void print();
     void printSetup();
     void printPreview();
 
     /** Export as iCalendar file */
     void exportICalendar();
   
     /** Export as vCalendar file */
     bool exportVCalendar( QString fn);
   
     /** pop up a dialog to show an existing appointment. */
     void appointment_show();
     /**
      * pop up an Appointment Dialog to edit an existing appointment.	Get
      * information on the appointment from the list of unique IDs that is
      * currently in the View, called currIds.
      */
     void appointment_edit();
     /**
      * pop up dialog confirming deletion of currently selected event in the
      * View.
      */
     void appointment_delete();
 
     /** mails the currently selected event to a particular user as a vCalendar
       attachment. */
     void action_mail();
 
     /* frees a subtodo from it's relation */
     void todo_unsub( Todo * );
     void todo_resub( Todo * parent, Todo * sub );
 
     /** Take ownership of selected event. */
     void takeOverEvent();
 
     /** Take ownership of all events in calendar. */
     void takeOverCalendar();
   
     /** query whether or not the calendar is "dirty". */
     bool isModified();
     /** set the state of calendar. Modified means "dirty", i.e. needing a save. */
     void setModified(bool modified=true);
 
     /** query if the calendar is read-only. */
     bool isReadOnly();
     /** set state of calendar to read-only */
     void setReadOnly(bool readOnly=true);
 
     void eventUpdated(Incidence *);
 
     /* iTIP scheduling actions */
     void schedule_publish(Incidence *incidence = 0);
     void schedule_request(Incidence *incidence = 0);
     void schedule_refresh(Incidence *incidence = 0);
     void schedule_cancel(Incidence *incidence = 0);
     void schedule_add(Incidence *incidence = 0);
     void schedule_reply(Incidence *incidence = 0);
     void schedule_counter(Incidence *incidence = 0);
     void schedule_declinecounter(Incidence *incidence = 0);
     void schedule_publish_freebusy(int daysToPublish = 30);
 
     void openAddressbook();
 
     void editFilters();
     void toggleFilerEnabled();
     QPtrList<CalFilter> filters();
     void toggleFilter();
     void showFilter(bool visible);
     void updateFilter();
     void filterEdited();
     void selectFilter( int );
     KOFilterView *filterView();
 
     void showIntro();
 
     /** Move the curdatepient view date to today */
     void goToday();
 
     /** Move to the next date(s) in the current view */
     void goNext();
   
     /** Move to the previous date(s) in the current view */
     void goPrevious();
   /** Move to the next date(s) in the current view */
     void goNextMonth();
   
     /** Move to the previous date(s) in the current view */
     void goPreviousMonth();
 
     void toggleExpand();
     void toggleDateNavigatorWidget();
     void toggleAllDaySize();
     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();
 
     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;
 
     FileStorage *mStorage;
 
     DateNavigator *mNavigator;
 
     KOViewManager *mViewManager;
     KODialogManager *mDialogManager;
 
     // Calendar filters
     QPtrList<CalFilter> mFilters;
 
     // various housekeeping variables.
     bool            mModified;	   // flag indicating if calendar is modified
     bool            mReadOnly; // flag indicating if calendar is read-only
     QDate mSaveSingleDate;
 
     Incidence *mSelectedIncidence;
     Incidence *mMoveIncidence;
     KOTodoView *mTodoList;
     KOEventEditor * mEventEditor;
     KOTodoEditor  * mTodoEditor;
     KOEventViewerDialog * mEventViewerDialog;
     void keyPressEvent ( QKeyEvent *e) ;
     //QMap<Incidence*,KOIncidenceEditor*> mDialogList;
 };
 
 
 class CalendarViewVisitor : public Incidence::Visitor
 {
   public:
     CalendarViewVisitor() : mView( 0 ) {}
 
     bool act( Incidence *incidence, CalendarView *view )
     {
       mView = view;
       return incidence->accept( *this );
     }
     
   protected:
     CalendarView *mView;
 };
 
 class ShowIncidenceVisitor : public CalendarViewVisitor
 {
   protected:
     bool visit( Event *event ) { mView->showEvent( event ); return true; }  
     bool visit( Todo *todo ) { mView->showTodo( todo ); return true; }  
     bool visit( Journal * j ) { mView->showJournal( j );return true; }
 };
 
 class EditIncidenceVisitor : public CalendarViewVisitor
 {
   protected:
     bool visit( Event *event ) { mView->editEvent( event ); return true; }  
     bool visit( Todo *todo ) { mView->editTodo( todo ); return true; }  
     bool visit( Journal *j ) {  mView->editJournal( j); return true; }
 };
 
 class DeleteIncidenceVisitor : public CalendarViewVisitor
 {
   protected:
     bool visit( Event *event ) { mView->deleteEvent( event ); return true; }  
     bool visit( Todo *todo ) { mView->deleteTodo( todo ); return true; }  
     bool visit( Journal * j) {mView->deleteJournal( j ); return true; }
 };
 
 #endif
diff --git a/libkdepim/ksyncmanager.h b/libkdepim/ksyncmanager.h
index 4a610fa..af4f1ab 100644
--- a/libkdepim/ksyncmanager.h
+++ b/libkdepim/ksyncmanager.h
@@ -1,211 +1,212 @@
 /*
   This file is part of KDE-Pim/Pi.
   Copyright (c) 2004 Ulf Schenk
 
   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.
 
   $Id$
 */
 #ifndef _KSYNCMANAGER_H
 #define _KSYNCMANAGER_H
 
 #include <qobject.h>
 #include <qstring.h>
 #include <qsocket.h>
 #include <qdatetime.h>
 #include <qserversocket.h> 
 #include <qtextstream.h>
 #include <qregexp.h>
 
 class QPopupMenu;
 class KSyncProfile;
 class KPimPrefs;
 class QWidget;
 class KSyncManager;
 class KSyncInterface;
 class QProgressBar;
 
 
 class KServerSocket : public QServerSocket
 {
     Q_OBJECT
 
         public:
     KServerSocket ( QString password, Q_UINT16 port, int backlog = 0, QObject * parent=0, const char * name=0 );
 
     void newConnection ( int socket ) ;
     void setFileName( QString fn  ) {mFileName = fn;};
  signals:
     void file_received( bool );
     void request_file();
     void saveFile();
     void endConnect();
     private slots:
     void discardClient();
     void readClient();
     void readBackFileFromSocket();
  private :
     bool blockRC;
     void send_file();
     void get_file();
     void end_connect();
     QDialog* mSyncActionDialog;
     QSocket* mSocket; 
     QString mPassWord;
     QString mFileName; 
     QTime piTime;
     QString piFileString;
 };
 
 class KCommandSocket : public QObject
 {
     Q_OBJECT
         public:
     enum state { successR, errorR, successW, errorW, errorTO, quiet };
     KCommandSocket ( QString password, Q_UINT16 port, QString host, QObject * parent=0, const char * name=0 );
     void readFile( QString );
     void writeFile( QString );
     void sendStop();
        
  signals:
     void commandFinished( KCommandSocket*, int );
     private slots:
     void startReadFileFromSocket();
     void readFileFromSocket();
     void deleteSocket();
     void writeFileToSocket();
  private :
     QSocket* mSocket; 
     QString mPassWord;
     Q_UINT16 mPort;
     QString mHost;
     QString mFileName;
     QTimer* mTimerSocket;
     int mRetVal;
     QTime mTime;
     QString mFileString;
     bool mFirst;
 };
 
 
 class KSyncManager : public QObject
 {
     Q_OBJECT
 
         public:
     enum TargetApp {
         KOPI = 0,
         KAPI = 1,
         PWMPI = 2 };
   
     KSyncManager(QWidget* parent, KSyncInterface* implementation, TargetApp ta, KPimPrefs* prefs, QPopupMenu* syncmenu);
     ~KSyncManager() ;
 
     void multiSync( bool askforPrefs  );
     bool blockSave() { return mBlockSaveFlag; }
     void setBlockSave(bool sa) { mBlockSaveFlag = sa; }
     void setDefaultFileName( QString s) { mDefFileName = s ;}
     QString defaultFileName() { return mDefFileName ;}
     QString syncFileName();
     void enableQuick( bool ask = true);
 
     QString getCurrentSyncDevice() { return mCurrentSyncDevice; }
     QString getCurrentSyncName() { return mCurrentSyncName; }
 
     void showProgressBar(int percentage, QString caption = QString::null, int total=100);
     void hideProgressBar();
     bool isProgressBarCanceled();
 
     // sync stuff
     QString mLocalMachineName;
     QStringList  mExternSyncProfiles;
     QStringList  mSyncProfileNames;
     bool mAskForPreferences;
     bool mShowSyncSummary;
     bool mIsKapiFile;
     bool mWriteBackExistingOnly;
     int mSyncAlgoPrefs;
     bool mWriteBackFile;
     int  mWriteBackInFuture;
     QString mPhoneDevice;
     QString mPhoneConnection;
     QString mPhoneModel;
     QString mPassWordPiSync;
     QString mActiveSyncPort;
     QString mActiveSyncIP ;
 
  signals:
     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
@@ -443,1030 +443,1036 @@ void PwM::initToolbar()
 				BUTTON_TOOL_FIND, SIGNAL(clicked(int)), this,
 				SLOT(find_slot()), true, i18n("Find entry"));
 	toolBar()->insertSeparator();
 	toolBar()->insertButton(picons->loadIcon("halfencrypted", KIcon::Toolbar),
 				BUTTON_TOOL_LOCK, SIGNAL(clicked(int)), this,
 				SLOT(lockWnd_slot()), true,
 				i18n("Lock all entries"));
 	toolBar()->insertButton(picons->loadIcon("encrypted", KIcon::Toolbar),
 				BUTTON_TOOL_DEEPLOCK, SIGNAL(clicked(int)), this,
 				SLOT(deepLockWnd_slot()), true,
 				i18n("Deep-Lock all entries"));
 	toolBar()->insertButton(picons->loadIcon("decrypted", KIcon::Toolbar),
 				BUTTON_TOOL_UNLOCK, SIGNAL(clicked(int)), this,
 				SLOT(unlockWnd_slot()), true,
 				i18n("Unlock all entries"));
 }
 
 void PwM::initMetrics()
 {
 	QSize s = conf()->confWndMainWndSize();
 	if (s.isValid())
 		resize(s);
 	else
 		resize(DEFAULT_SIZE);
 }
 
 void PwM::updateCaption()
 {
 	setPlainCaption(curDoc()->getTitle() + " - " PROG_NAME " " PACKAGE_VER);
 }
 
 void PwM::hideEvent(QHideEvent *)
 {
 	if (isMinimized()) {
 		if (init->tray()) {
 			forceMinimizeToTray = true;
 			close();
 		}
 		int mmlock = conf()->confGlobMinimizeLock();
 		switch (mmlock) {
 		case 0:		// don't lock anything
 			break;
 		case 1: {	// normal lock
 			curDoc()->lockAll(true);
 			break;
 		} case 2: {	// deep-lock
 			curDoc()->deepLock();
 			break;
 		} default:
 			WARN();
 		}
 	}
 }
 
 void PwM::setVirgin(bool v)
 {
 	if (virgin == v)
 		return;
 	virgin = v;
 	filePopup->setItemEnabled(BUTTON_POPUP_FILE_SAVE, !v);
 	filePopup->setItemEnabled(BUTTON_POPUP_FILE_SAVEAS, !v);
 	filePopup->setItemEnabled(BUTTON_POPUP_FILE_EXPORT, !v);
 	filePopup->setItemEnabled(BUTTON_POPUP_FILE_PRINT, !v);
 	managePopup->setItemEnabled(BUTTON_POPUP_MANAGE_EDIT, !v);
 	managePopup->setItemEnabled(BUTTON_POPUP_MANAGE_DEL, !v);
 	managePopup->setItemEnabled(BUTTON_POPUP_MANAGE_CHANGEMP, !v);
 	viewPopup->setItemEnabled(BUTTON_POPUP_VIEW_LOCK, !v);
 	viewPopup->setItemEnabled(BUTTON_POPUP_VIEW_DEEPLOCK, !v);
 	viewPopup->setItemEnabled(BUTTON_POPUP_VIEW_UNLOCK, !v);
 	viewPopup->setItemEnabled(BUTTON_POPUP_VIEW_FIND, !v);
 	toolBar()->setItemEnabled(BUTTON_TOOL_SAVE, !v);
 	toolBar()->setItemEnabled(BUTTON_TOOL_SAVEAS, !v);
 	toolBar()->setItemEnabled(BUTTON_TOOL_PRINT, !v);
 	toolBar()->setItemEnabled(BUTTON_TOOL_EDIT, !v);
 	toolBar()->setItemEnabled(BUTTON_TOOL_DEL, !v);
 	toolBar()->setItemEnabled(BUTTON_TOOL_LOCK, !v);
 	toolBar()->setItemEnabled(BUTTON_TOOL_DEEPLOCK, !v);
 	toolBar()->setItemEnabled(BUTTON_TOOL_UNLOCK, !v);
 	toolBar()->setItemEnabled(BUTTON_TOOL_FIND, !v);
 }
 
 void PwM::new_slot()
 {
 	init->createMainWnd();
 }
 
 //US ENH
 void PwM::open_slot()
 {
 	open_slot("");
 }
 
 void PwM::open_slot(QString fn)
 {
 	openDoc(fn);
 }
 
 PwMDoc * PwM::openDoc(QString filename, bool openDeepLocked)
 {
 	if (!isVirgin()) {
 		// open the document in a new window.
 		PwM *newInstance = init->createMainWnd();
 		PwMDoc *newDoc = newInstance->openDoc(filename, openDeepLocked);
 		if (!newDoc) {
 			newInstance->setForceQuit(true);
 			delete_and_null(newInstance);
 		}
 		return newDoc;
 	}
 
 	if (!curDoc()->openDocUi(curDoc(), filename, openDeepLocked))
 		return 0;
 	showStatMsg(i18n("Successfully opened file."));
 	updateCaption();
 	setVirgin(false);
 	return curDoc();
 }
 
 PwMView * PwM::makeNewListView(PwMDoc *doc)
 {
 	PwMView *ret = new PwMView(this, this, doc);
 	ret->setFont(conf()->confGlobEntryFont());
 	ret->show();
 	return ret;
 }
 
 void PwM::close_slot()
 {
 	close();
 }
 
 void PwM::quitButton_slot()
 {
 	init->shutdownApp(0);
 }
 
 void PwM::save_slot()
 {
 	save();
 }
 
 bool PwM::save()
 {
 	if (!curDoc()->saveDocUi(curDoc()))
 		return false;
 	showStatMsg(i18n("Successfully saved data."));
 	updateCaption();
 	return true;
 }
 
 void PwM::saveAs_slot()
 {
 	saveAs();
 }
 
 bool PwM::saveAs()
 {
 	if (!curDoc()->saveAsDocUi(curDoc()))
 		return false;
 	showStatMsg(i18n("Successfully saved data."));
 	updateCaption();
 	return true;
 }
 
 //US ENH : changed code to run with older MOC
 void PwM::addPwd_slot()
 {
   addPwd_slot1(0, 0);
 }
 
 void PwM::addPwd_slot1(QString *pw, PwMDoc *_doc)
 {
 	PwMDoc *doc;
 	if (_doc) {
 		doc = _doc;
 	} else {
 		doc = curDoc();
 	}
 	PWM_ASSERT(doc);
 	doc->timer()->getLock(DocTimer::id_autoLockTimer);
 #ifndef PWM_EMBEDDED
 	AddEntryWndImpl w;
 #else
 	AddEntryWndImpl w(this, "addentrywndimpl");
 #endif
 
 	vector<string> catList;
 	doc->getCategoryList(&catList);
 	unsigned i, size = catList.size();
 	for (i = 0; i < size; ++i) {
 		w.addCategory(catList[i].c_str());
 	}
 	w.setCurrCategory(view->getCurrentCategory());
 	if (pw)
 		w.pwLineEdit->setText(*pw);
 
       tryAgain:
 	if (w.exec() == 1) 
 	  {
 		PwMDataItem d;
 
 		//US BUG: to initialize all values of curEntr with meaningfulldata,
 		// we call clear on it. Reason: Metadata will be uninitialized otherwise.
 		// another option would be to create a constructor for PwMDataItem
 		d.clear(true);
 
 		d.desc = w.getDescription().latin1();
 		d.name = w.getUsername().latin1();
 		d.pw = w.getPassword().latin1();
 		d.comment = w.getComment().latin1();
 		d.url = w.getUrl().latin1();
 		d.launcher = w.getLauncher().latin1();
 		PwMerror ret = doc->addEntry(w.getCategory(), &d);
 		if (ret == e_entryExists) {
 			KMessageBox::error(this,
 					   i18n
 					   ("An entry with this \"Description\",\n"
 					    "does already exist.\n"
 					    "Please select another description."),
 					   i18n("entry already exists."));
 			goto tryAgain;
 		} else if (ret == e_maxAllowedEntr) {
 			KMessageBox::error(this, i18n("The maximum possible number of\nentries"
 						      "has been reached.\nYou can't add more entries."),
 						 i18n("maximum number of entries"));
 			doc->timer()->putLock(DocTimer::id_autoLockTimer);
 			return;
 		}
 	}
 	setVirgin(false);
 	doc->timer()->putLock(DocTimer::id_autoLockTimer);
 }
 
 //US ENH : changed code to run with older MOC
 void PwM::editPwd_slot()
 {
   editPwd_slot3(0,0,0);
 }
 
 void PwM::editPwd_slot1(const QString *category)
 {
   editPwd_slot3(category, 0, 0);
 }
 
 void PwM::editPwd_slot3(const QString *category, const int *index,
 		       PwMDoc *_doc)
 {
 	PwMDoc *doc;
 	if (_doc) {
 		doc = _doc;
 	} else {
 		doc = curDoc();
 	}
 	PWM_ASSERT(doc);
 	if (doc->isDocEmpty())
 		return;
 	if (doc->isDeepLocked())
 		return;
 	doc->timer()->getLock(DocTimer::id_autoLockTimer);
 	unsigned int curEntryIndex;
 	if (index) {
 		curEntryIndex = *index;
 	} else {
 		if (!(view->getCurEntryIndex(&curEntryIndex))) {
 			printDebug("couldn't get index. Maybe we have a binary entry here.");
 			doc->timer()->putLock(DocTimer::id_autoLockTimer);
 			return;
 		}
 	}
 	QString curCategory;
 	if (category) {
 		curCategory = *category;
 	} else {
 		curCategory = view->getCurrentCategory();
 	}
 	PwMDataItem currItem;
 	if (!doc->getEntry(curCategory, curEntryIndex, &currItem, true)) {
 		doc->timer()->putLock(DocTimer::id_autoLockTimer);
 		return;
 	}
 	BUG_ON(currItem.binary);
 
 	AddEntryWndImpl w;
 	vector<string> catList;
 	doc->getCategoryList(&catList);
 	unsigned i, size = catList.size();
 	for (i = 0; i < size; ++i) {
 		w.addCategory(catList[i].c_str());
 	}
 	w.setCurrCategory(curCategory);
 	w.setDescription(currItem.desc.c_str());
 	w.setUsername(currItem.name.c_str());
 	w.setPassword(currItem.pw.c_str());
 	w.setUrl(currItem.url.c_str());
 	w.setLauncher(currItem.launcher.c_str());
 	w.setComment(currItem.comment.c_str());
 	if (w.exec() == 1) {
 		currItem.desc = w.getDescription().latin1();
 		currItem.name = w.getUsername().latin1();
 		currItem.pw = w.getPassword().latin1();
 		currItem.comment = w.getComment().latin1();
 		currItem.url = w.getUrl().latin1();
 		currItem.launcher = w.getLauncher().latin1();
 		if (!doc->editEntry(curCategory, w.getCategory(),
 					 curEntryIndex, &currItem)) {
 			KMessageBox::error(this,
 					   i18n("Couldn't edit the entry.\n"
 						"Maybe you changed the category and\n"
 						"this entry is already present\nin the new "
 						"category?"),
 					   i18n("couldn't edit entry."));
 			doc->timer()->putLock(DocTimer::id_autoLockTimer);
 			return;
 		}
 	}
 	doc->timer()->putLock(DocTimer::id_autoLockTimer);
 }
 
 void PwM::deletePwd_slot()
 {
 	PWM_ASSERT(curDoc());
 	if (curDoc()->isDocEmpty())
 		return;
 	if (curDoc()->isDeepLocked())
 		return;
 	curDoc()->timer()->getLock(DocTimer::id_autoLockTimer);
 	unsigned int curEntryIndex = 0;
 	if (!(view->getCurEntryIndex(&curEntryIndex))) {
 		printDebug("couldn't get index");
 		curDoc()->timer()->putLock(DocTimer::id_autoLockTimer);
 		return;
 	}
 
 	PwMDataItem currItem;
 	QString curCategory = view->getCurrentCategory();
 	if (!curDoc()->getEntry(curCategory, curEntryIndex, &currItem)) {
 		printDebug("couldn't get entry");
 		curDoc()->timer()->putLock(DocTimer::id_autoLockTimer);
 		return;
 	}
 	if (KMessageBox::
 	    questionYesNo(this,
 			  i18n
 			  ("Do you really want to delete\nthe selected entry") +
 			  " \n\"" + QString(currItem.desc.c_str())
 			  + "\" ?", i18n("delete?"))
 	    == KMessageBox::Yes) {
 
 		curDoc()->delEntry(curCategory, curEntryIndex);
 	}
 	curDoc()->timer()->putLock(DocTimer::id_autoLockTimer);
 }
 
 void PwM::changeMasterPwd_slot()
 {
 	PWM_ASSERT(curDoc());
 	curDoc()->changeCurrentPw();
 }
 
 void PwM::lockWnd_slot()
 {
 	PWM_ASSERT(curDoc());
 	curDoc()->lockAll(true);
 }
 
 void PwM::deepLockWnd_slot()
 {
 	PWM_ASSERT(curDoc());
 	curDoc()->deepLock();
 }
 
 void PwM::unlockWnd_slot()
 {
 	PWM_ASSERT(curDoc());
 	curDoc()->lockAll(false);
 }
 
 void PwM::config_slot()
 {
   int oldStyle = conf()->confWndMainViewStyle();
 #ifdef PWM_EMBEDDED  
     KCMultiDialog*  ConfigureDialog = new KCMultiDialog( "PIM", this ,"pwmconfigdialog", true );
 
     KCMPwmConfig* pwmcfg = new KCMPwmConfig( ConfigureDialog->getNewVBoxPage(i18n( "PwManager")) , "KCMPwmConfig" );
     ConfigureDialog->addModule(pwmcfg );
 
     KCMKdePimConfig* kdelibcfg = new KCMKdePimConfig( ConfigureDialog->getNewVBoxPage(i18n( "Global")) , "KCMKdeLibConfig" );
     ConfigureDialog->addModule(kdelibcfg );
 
 #ifndef DESKTOP_VERSION
     ConfigureDialog->showMaximized();
 #endif
     if ( ConfigureDialog->exec() )
         KMessageBox::information( this,  i18n("Some changes are only\neffective after a restart!\n") );
     delete ConfigureDialog;
 
 #else //PWM_EMBEDDED
 	// display the configuration window (modal mode)
 	if (!conf()->showConfWnd(this))
 		return;
 #endif
 
 	int newStyle = conf()->confWndMainViewStyle();
 	// reinitialize tray
 	init->initTray();
 	// reinitialize KWallet emulation
 	init->initKWalletEmu();
 
 	PwMDocList *_dl = PwMDoc::getOpenDocList();
 	const vector<PwMDocList::listItem> *dl = _dl->getList();
 	vector<PwMDocList::listItem>::const_iterator i = dl->begin(),
 						     end = dl->end();
 	PwMDoc *doc;
 	while (i != end) {
 		doc = (*i).doc;
 		// unlock-without-mpw timeout
 		doc->timer()->start(DocTimer::id_mpwTimer);
 		// auto-lock timeout
 		doc->timer()->start(DocTimer::id_autoLockTimer);
 		++i;
 	}
 
 	const QValueList<PwM *> *ml = init->mainWndList();
 #ifndef PWM_EMBEDDED
 	QValueList<PwM *>::const_iterator i2 = ml->begin(),
 					  end2 = ml->end();
 #else
 	QValueList<PwM *>::ConstIterator i2 = ml->begin(),
 					  end2 = ml->end();
 #endif
 	PwM *pwm;
 	while (i2 != end2) {
 		pwm = *i2;
 		// reinitialize the window style.
 		if (oldStyle != newStyle)
 			pwm->curView()->initStyle(newStyle);
 		// set the new font
 		pwm->curView()->setFont(conf()->confGlobEntryFont());
 		++i2;
 	}
 }
 
 void PwM::activateMpButton(bool activate)
 {
 	managePopup->setItemEnabled(BUTTON_POPUP_MANAGE_CHANGEMP, activate);
 }
 
 void PwM::closeEvent(QCloseEvent *e)
 {
     qDebug("PwM::closeEvent ");
     emit closed( this );
     return;
 	e->accept();
 }
 
 void PwM::docClosed(PwMDoc *doc)
 {
     qDebug("PwM::docClosed ");
 	PARAM_UNUSED(doc);
 	PWM_ASSERT(doc == curDoc());
 	close();
 }
 
 void PwM::find_slot()
 {
 	PWM_ASSERT(curDoc());
 	if (curDoc()->isDocEmpty())
 		return;
 	if (curDoc()->isDeepLocked())
 		return;
 	curDoc()->timer()->getLock(DocTimer::id_autoLockTimer);
 	FindWndImpl findWnd(view);
 	findWnd.exec();
 	curDoc()->timer()->putLock(DocTimer::id_autoLockTimer);
 }
 
 void PwM::exportToText()
 {
 	PWM_ASSERT(curDoc());
 	if (curDoc()->isDocEmpty()) {
 		KMessageBox::information(this,
 					 i18n
 					 ("Sorry, there's nothing to export.\n"
 					  "Please first add some passwords."),
 					 i18n("nothing to do"));
 		return;
 	}
 	curDoc()->timer()->getLock(DocTimer::id_autoLockTimer);
 	QString fn(KFileDialog::getSaveFileName(QString::null,
 						i18n("*|plain-text file"),
 						this));
 	if (fn == "") {
 		curDoc()->timer()->putLock(DocTimer::id_autoLockTimer);
 		return;
 	}
 
 	PwMerror ret = curDoc()->exportToText(&fn);
 	if (ret != e_success) {
 		KMessageBox::error(this,
 				   i18n("Error: Couldn't write to file.\n"
 					"Please check if you have permission to write\n"
 					"to the file in that directory."),
 				   i18n("error while writing"));
 	} else
 		showStatMsg(i18n("Successfully exported data."));
 	curDoc()->timer()->putLock(DocTimer::id_autoLockTimer);
 }
 
 bool PwM::importFromText()
 {
 	if (!isVirgin()) {
 		if (KMessageBox::questionYesNo(this,
 					       i18n("Do you want to import the data\n"
 					            "into the current document? (If you\n"
 					            "select \"no\", a new document will be\n"
 					            "opened.)"),
 					       i18n("import into this document?"))
 		    == KMessageBox::No) {
 			// import the data to a new window.
 			PwM *newInstance = init->createMainWnd();
 			bool ok = newInstance->importFromText();
 			if (!ok) {
 				newInstance->setForceQuit(true);
 				delete_and_null(newInstance);
 			}
 			return ok;
 		}
 	}
 
 	curDoc()->timer()->getLock(DocTimer::id_autoLockTimer);
 	PwMerror ret;
 	QString path(KFileDialog::getOpenFileName(QString::null,
 						  i18n("*|PWM-exported text file"),
 						  this));
 	if (path == "")
 		goto cancelImport;
 
 	ret = curDoc()->importFromText(&path, 0);
 	if (ret == e_fileFormat) {
 		KMessageBox::error(this,
 				   i18n("Could not read file-format.\n"
 					"This seems to be _not_ a valid file\n"
 					"exported by PwM."),
 				   i18n("invalid file-format"));
 		goto cancelImport;
 	} else if (ret == e_invalidArg) {
 		BUG();
 		goto cancelImport;
 	} else if (ret != e_success) {
 		KMessageBox::error(this,
 				   i18n("Could not import file!\n"
 					"Do you have permission to read this file?\n"
 					"Do you have enough free memory?"),
 				   i18n("import failed"));
 		goto cancelImport;
 	}
 	setVirgin(false);
 	curDoc()->timer()->putLock(DocTimer::id_autoLockTimer);
 	return true;
 
 cancelImport:
 	curDoc()->timer()->putLock(DocTimer::id_autoLockTimer);
 	return false;
 }
 
 void PwM::exportToGpasman()
 {
 	PWM_ASSERT(curDoc());
 	if (curDoc()->isDocEmpty()) {
 		KMessageBox::information(this,
 					 i18n
 					 ("Sorry, there's nothing to export.\n"
 					  "Please first add some passwords."),
 					 i18n("nothing to do"));
 		return;
 	}
 	curDoc()->timer()->getLock(DocTimer::id_autoLockTimer);
 	QString fn(KFileDialog::getSaveFileName(QString::null,
 						i18n("*|Gpasman or Kpasman file"),
 						this));
 	if (fn == "") {
 		curDoc()->timer()->putLock(DocTimer::id_autoLockTimer);
 		return;
 	}
 
 	PwMerror ret = curDoc()->exportToGpasman(&fn);
 	if (ret != e_success) {
 		if (ret == e_noPw) {
 			curDoc()->timer()->putLock(DocTimer::id_autoLockTimer);
 			return;
 		}
 		KMessageBox::error(this,
 				   i18n("Error: Couldn't write to file.\n"
 					"Please check if you have permission to write "
 					"to the file in that directory."),
 				   i18n("error while writing"));
 	} else
 		showStatMsg(i18n("Successfully exported data."));
 	curDoc()->timer()->putLock(DocTimer::id_autoLockTimer);
 }
 
 
 
 void PwM::exportToCsv()
 {
   PWM_ASSERT(curDoc());
   if (curDoc()->isDocEmpty()) {
     KMessageBox::information(this,
 			     i18n
 			     ("Sorry, there is nothing to export;\n"
 			      "please add some passwords first."),
 			     i18n("Nothing to Do"));
     return;
   }
 
   curDoc()->timer()->getLock(DocTimer::id_autoLockTimer);
   QString fn(KFileDialog::getSaveFileName("*.csv", i18n("*|CSV Text File"), this));
   if (fn.isEmpty()) {
     curDoc()->timer()->putLock(DocTimer::id_autoLockTimer);
     return;
   }
 
   Csv csv(this);
   if (!csv.exportData(fn, curDoc())) {
     curDoc()->timer()->putLock(DocTimer::id_autoLockTimer);
     showStatMsg(i18n("CSV file export failed."));
     return;
   }
   showStatMsg(i18n("Successfully exported data."));
   curDoc()->timer()->putLock(DocTimer::id_autoLockTimer);
 }
 
 bool PwM::importCsv()
 {
   Csv csv(this);
   if (!isVirgin()) {
     if (KMessageBox::questionYesNo(this,
        i18n("Do you want to import the data\n"
             "into the current document? (If you\n"
             "select \"no\", a new document will be\n"
             "opened.)"),
        i18n("Import into This Document?"))
     == KMessageBox::No) {
       // import the data to a new window.
       PwM *newInstance = init->createMainWnd();
       bool ok = newInstance->importCsv();
       if (!ok) {
 	newInstance->setForceQuit(true);
 	delete_and_null(newInstance);
       }
       return ok;
     }
   }
 
   QString filename = KFileDialog::getOpenFileName("*.csv", i18n("*|CSV Text File"), this);
   if (filename.isEmpty())
     return false;
   curDoc()->timer()->getLock(DocTimer::id_autoLockTimer);
   if (!csv.importData(filename, curDoc())) {
     curDoc()->timer()->putLock(DocTimer::id_autoLockTimer);
     showStatMsg(i18n("CSV file import failed."));
     return false;
   }
   curDoc()->timer()->putLock(DocTimer::id_autoLockTimer);
   KMessageBox::information(this,
 			   i18n("Successfully imported the CSV data\n"
       "into the current document."), i18n("Successfully Imported"));
   showStatMsg(i18n("Successfully imported"));
   setVirgin(false);
   return true;
 }
 
 
 void PwM::exportToKWallet()
 {
 #ifdef CONFIG_KWALLETIF
 	if (!checkAndAskForKWalletEmu())
 		return;
 	PWM_ASSERT(curDoc());
 	if (curDoc()->isDocEmpty()) {
 		KMessageBox::information(this,
 					 i18n
 					 ("Sorry, there's nothing to export.\n"
 					  "Please first add some passwords."),
 					 i18n("nothing to do"));
 		init->initKWalletEmu();
 		return;
 	}
 	curDoc()->timer()->getLock(DocTimer::id_autoLockTimer);
 	KWalletIf walletIf(this);
 	if (walletIf.kwalletExport(curDoc())) {
 		KMessageBox::information(this,
 					 i18n("Successfully exported the data of the current "
 					      "document to KWallet."),
 					 i18n("Successfully exported data."));
 		showStatMsg(i18n("Successfully exported data."));
 	}
 	init->initKWalletEmu();
 	curDoc()->timer()->putLock(DocTimer::id_autoLockTimer);
 #endif // CONFIG_KWALLETIF
 }
 
 bool PwM::importFromGpasman()
 {
 	if (!isVirgin()) {
 		if (KMessageBox::questionYesNo(this,
 					       i18n("Do you want to import the data\n"
 					            "into the current document? (If you\n"
 					            "select \"no\", a new document will be\n"
 					            "opened.)"),
 					       i18n("import into this document?"))
 		    == KMessageBox::No) {
 			// import the data to a new window.
 			PwM *newInstance = init->createMainWnd();
 			bool ok = newInstance->importFromGpasman();
 			if (!ok) {
 				newInstance->setForceQuit(true);
 				delete_and_null(newInstance);
 			}
 			return ok;
 		}
 	}
 
 	curDoc()->timer()->getLock(DocTimer::id_autoLockTimer);
 	PwMerror ret;
 	QString path(KFileDialog::getOpenFileName(QString::null,
 						  i18n("*|Gpasman or Kpasman file"), this));
 	if (path == "")
 		goto cancelImport;
 	ret = curDoc()->importFromGpasman(&path);
 	if (ret == e_wrongPw) {
 		if (KMessageBox::questionYesNo(this,
 				 	       i18n
 					       ("This is probably the wrong master-password\n"
 					        "you have typed in.\n"
 					        "There is no real way to determine the\n"
 					        "correctness of the password in the Gpasman\n"
 					        "file-format. But I think this\n"
 					        "password ist wrong.\n"
 					        "Do you want to continue nevertheless?"),
 					       i18n("password error"))
 		    == KMessageBox::No) {
 			goto cancelImport;
 		}
 	} else if (ret != e_success) {
 		KMessageBox::error(this,
 				   i18n("Could not import file!\n"
 					"Do you have permission to read this file?"),
 				   i18n("import failed"));
 		goto cancelImport;
 	}
 	setVirgin(false);
 	curDoc()->timer()->putLock(DocTimer::id_autoLockTimer);
 	return true;
 
 cancelImport:
 	curDoc()->timer()->putLock(DocTimer::id_autoLockTimer);
 	return false;
 }
 
 #ifdef CONFIG_KWALLETIF
 bool PwM::checkAndAskForKWalletEmu()
 {
 	if (init->kwalletEmu()) {
 		/* KWallet emulation is enabled. We can't import/export
 		 * data from/to it, while emulation is active.
 		 */
 		if (KMessageBox::questionYesNo(this,
 					       i18n("KWallet emulation is enabled.\n"
 						    "You can't import or export data from/to "
 						    "the original KWallet, while the emulation "
 						    "is active.\n"
 						    "Do you want to tempoarly disable the KWallet emulation?"),
 					       i18n("Tempoarly disable KWallet emulation?"))
 		    == KMessageBox::Yes) {
 			init->initKWalletEmu(true);
 			PWM_ASSERT(!init->kwalletEmu());
 			return true;
 		}
 		return false;
 	}
 	return true;
 }
 #endif // CONFIG_KWALLETIF
 
 bool PwM::importKWallet()
 {
 #ifdef CONFIG_KWALLETIF
 	if (!checkAndAskForKWalletEmu())
 		return false;
 	KWalletIf walletIf(this);
 	if (!isVirgin()) {
 		if (KMessageBox::questionYesNo(this,
 					       i18n("Do you want to import the data "
 					            "into the current document? (If you "
 					            "select \"no\", a new document will be "
 					            "opened.)"),
 					       i18n("import into this document?"))
 		    == KMessageBox::No) {
 			// import the data to a new window.
 			PwM *newInstance = init->createMainWnd();
 			bool ok = newInstance->importKWallet();
 			if (!ok) {
 				newInstance->setForceQuit(true);
 				delete_and_null(newInstance);
 				goto exit_fail;
 			} else {
 				goto exit_ok;
 			}
 		}
 	}
 	curDoc()->timer()->getLock(DocTimer::id_autoLockTimer);
 	if (!walletIf.kwalletImport(curDoc())) {
 		curDoc()->timer()->putLock(DocTimer::id_autoLockTimer);
 		showStatMsg(i18n("KWallet import failed"));
 		goto exit_fail;
 	}
 	KMessageBox::information(this,
 				 i18n("Successfully imported the KWallet data "
 				      "into the current document."),
 				 i18n("successfully imported"));
 	showStatMsg(i18n("successfully imported"));
 	setVirgin(false);
 	curDoc()->timer()->putLock(DocTimer::id_autoLockTimer);
 
 exit_ok:
 	init->initKWalletEmu();
 	return true;
 
 exit_fail:
 	init->initKWalletEmu();
 #endif // CONFIG_KWALLETIF
 	return false;
 }
 
 void PwM::print_slot()
 {
 	curDoc()->timer()->getLock(DocTimer::id_autoLockTimer);
 #ifndef PWM_EMBEDDED
 	PwMPrint p(curDoc(), this);
 	p.printNow();
 #else
 	qDebug("PwM::print_slot , PRINTING IS NOT IMPLEMENTED");
 #endif
 	curDoc()->timer()->putLock(DocTimer::id_autoLockTimer);
 }
 
 void PwM::genNewCard_slot()
 {
 #ifdef CONFIG_KEYCARD
 	init->keycard()->genNewCard();
 #endif
 }
 
 void PwM::eraseCard_slot()
 {
 #ifdef CONFIG_KEYCARD
 	init->keycard()->eraseCard();
 #endif
 }
 
 void PwM::readCardId_slot()
 {
 #ifdef CONFIG_KEYCARD
 	init->keycard()->displayKey();
 #endif
 }
 
 void PwM::makeCardBackup_slot()
 {
 #ifdef CONFIG_KEYCARD
 	init->keycard()->makeBackupImage();
 #endif
 }
 
 void PwM::replayCardBackup_slot()
 {
 #ifdef CONFIG_KEYCARD
 	init->keycard()->replayBackupImage();
 #endif
 }
 
 void PwM::execLauncher_slot()
 {
 	PWM_ASSERT(curDoc());
 	if (curDoc()->isDeepLocked())
 		return;
 	unsigned int curEntryIndex;
 	if (!view->getCurEntryIndex(&curEntryIndex))
 		return;
 	bool ret = curDoc()->execLauncher(view->getCurrentCategory(),
 					  curEntryIndex);
 	if (ret)
 		showStatMsg(i18n("Executed the \"Launcher\"."));
 	else
 		showStatMsg(i18n("ERROR: Couldn't execute the \"Launcher\"!"));
 }
 
 void PwM::goToURL_slot()
 {
 	PWM_ASSERT(curDoc());
 	if (curDoc()->isDeepLocked())
 		return;
 	unsigned int curEntryIndex;
 	if (!view->getCurEntryIndex(&curEntryIndex))
 		return;
 	bool ret = curDoc()->goToURL(view->getCurrentCategory(),
 				     curEntryIndex);
 	if (ret)
 		showStatMsg(i18n("started browser with current URL."));
 	else
 		showStatMsg(i18n("ERROR: Couldn't start browser! Maybe invalid URL?"));
 }
 
 void PwM::copyToClipboard(const QString &s)
 {
 	QClipboard *cb = QApplication::clipboard();
 #ifndef PWM_EMBEDDED
 	if (cb->supportsSelection())
 		cb->setText(s, QClipboard::Selection);
 	cb->setText(s, QClipboard::Clipboard);
 #else
 	cb->setText(s);
 
 #endif
 
 }
 
 
 void PwM::showStatMsg(const QString &msg)
 {
 #ifdef DESKTOP_VERSION
 	statusBar()->message(msg, STATUSBAR_MSG_TIMEOUT * 1000);
 #else
 	qDebug("Statusbar : %s",msg.latin1());
     Global::statusMessage(msg);
 #endif
 }
 
 void PwM::focusInEvent(QFocusEvent *e)
 {
 	if (e->gotFocus()) {
 		emit gotFocus(this);
 	} else if (e->lostFocus()) {
 		emit lostFocus(this);
 	}
 }
 
 
 #ifdef PWM_EMBEDDED
 
 void PwM::whatsnew_slot()
 {
     KApplication::showFile( "KDE-Pim/Pi Version Info", "kdepim/WhatsNew.txt" );
 }
 
 void PwM::showLicense_slot()
 {
     KApplication::showLicence();
 }
 
 void PwM::faq_slot()
 {
   KApplication::showFile( "PWM/Pi FAQ", "kdepim/pwmanager/pwmanagerFAQ.txt" );
 }
 
 void PwM::syncHowTo_slot()
 {
     KApplication::showFile( "KDE-Pim/Pi Synchronization HowTo", "kdepim/SyncHowto.txt" );
 }
 
 
 void PwM::createAboutData_slot()
 {
   QString version;
 #include <../version>
 ;
     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
@@ -1,297 +1,298 @@
 /***************************************************************************
  *                                                                         *
  *   copyright (C) 2003, 2004 by Michael Buesch                            *
  *   email: mbuesch@freenet.de                                             *
  *                                                                         *
  *   This program is free software; you can redistribute it and/or modify  *
  *   it under the terms of the GNU General Public License version 2        *
  *   as published by the Free Software Foundation.                         *
  *                                                                         *
  ***************************************************************************/
 
 /***************************************************************************
  * copyright (C) 2004 by Ulf Schenk
  * This file is originaly based on version 1.0.1 of pwmanager
  * and was modified to run on embedded devices that run microkde
  *
  * $Id$
  **************************************************************************/  
 
 #ifndef __PWM_H
 #define __PWM_H
 
 
 #include <kpopupmenu.h>
 #include <klistview.h>
 #include <kmainwindow.h>
 
 #ifndef PWM_EMBEDDED
 #include <kwin.h>
 #include <kapp.h>
 #include <kdeversion.h>
 #else
 #include <ksyncmanager.h>
 #endif
 
 #include <kaction.h>
 
 #include <qglobal.h>
 
 #include "pwmview.h"
 #include "pwmexception.h"
 
 
 /** timeout for displaying a message on the status-bar (in seconds) */
 #define STATUSBAR_MSG_TIMEOUT	5
 
 
 class PwMInit;
 class KSyncManager;
 
 /** PwM is the base class of the project */
 #ifndef PWM_EMBEDDED
 //MOC_SKIP_BEGIN
 class PwM : public KMainWindow
 //MOC_SKIP_END
 #else
 class PwM : public KMainWindow, public KSyncInterface
 #endif
 {
 	Q_OBJECT
 public:
 	friend class PwMView;
 	/** construtor */
 	PwM(PwMInit *_init, PwMDoc *doc,
 	    bool virginity = true,
 	    QWidget* parent = 0, const char *name = 0);
 	/** destructor */
 	~PwM();
 
 	/** copy some text to the global clipboard */
 	static void copyToClipboard(const QString &s);
 
 	/** returns pointer to the view */
 	PwMView * curView()
 			{ return view; }
 	/** returns pointer to the currently using document. */
 	PwMDoc * curDoc()
 			{ return curView()->document(); }
 	/** open a new doc with the given filename */
 	PwMDoc * openDoc(QString filename, bool openDeepLocked = false);
 	/** show a message on the global status bar.
 	  * The message times out after some seconds.
 	  */
 	void showStatMsg(const QString &msg);
 	/** ask the user where to save the doc (if it has not been saved, yet)
 	  * and write the data to disk.
 	  */
 	bool save();
 	/** ask the user where to save the doc
 	  * and write the data to disk.
 	  */
 	bool saveAs();
 	/** force quit. Quit this window, always! Don't minimize it */
 	bool isForceQuit()
 			{ return forceQuit; }
 	/** set forceQuit */
 	void setForceQuit(bool force)
 			{ forceQuit = force; }
 	/** force minimize this window */
 	bool isForceMinimizeToTray()
 			{ return forceMinimizeToTray; }
 	/** set forceMinimizeToTray */
 	void setForceMinimizeToTray(bool force)
 			{ forceMinimizeToTray = force; }
 
 public slots:
 	/** file/new triggered */
 	void new_slot();
 	/** file/open triggered */
 //US ENH
 	void open_slot();
 	void open_slot(QString fn);
 	/** file/close triggered */
 	void close_slot();
 	/** file/quit triggered */
 	void quitButton_slot();
 	/** file/save triggered */
 	void save_slot();
 	/** file/saveAs triggered */
 	void saveAs_slot();
 	/** file/export/text triggered */
 	void exportToText();
 	/** file/export/gpasman triggered */
 	void exportToGpasman();
 	/** file/export/kwallet triggered */
 	void exportToKWallet();
 	/** file/export/csv triggered */
 	void exportToCsv();
 	/** file/import/text triggered */
 	bool importFromText();
 	/** file/import/gpasman triggered */
 	bool importFromGpasman();
 	/** file/import/kwallet triggered */
 	bool importKWallet();
 	/** file/import/csv triggered */
 	bool importCsv();
 	/** file/print triggered */
 	void print_slot();
 	/** manage/add triggered */
 	//US ENH : changed code to run with older MOC
 
 	void addPwd_slot();
 	void addPwd_slot1(QString *pw, PwMDoc *_doc);
 	/** manage/edit triggered */
 	//US ENH : changed code to run with older MOC
 	void editPwd_slot();
 	void editPwd_slot1(const QString *category);
 	void editPwd_slot3(const QString *category, const int *index ,PwMDoc *_doc );
 
 	/** manage/delete triggered */
 	void deletePwd_slot();
 	/** execute the "Launcher" entry */
 	void execLauncher_slot();
 	/** open browser with URL entry */
 	void goToURL_slot();
 	/** manage/changeMasterPwd triggered */
 	void changeMasterPwd_slot();
 	/** lock current document */
 	void lockWnd_slot();
 	/** deeplock current document */
 	void deepLockWnd_slot();
 	/** window/unlock triggered */
 	void unlockWnd_slot();
 	/** find item */
 	void find_slot();
 	/** configure clicked */
 	void config_slot();
 	/** (de)activate the "change master pw" button in the menu-bar */
 	void activateMpButton(bool activate = true);
 	/** generate a new chipcard */
 	void genNewCard_slot();
 	/** completely erase the current card */
 	void eraseCard_slot();
 	/** returns the ID number of the current card */
 	void readCardId_slot();
 	/** make backup image of the current card */
 	void makeCardBackup_slot();
 	/** write backup image to current card */
 	void replayCardBackup_slot();
 
 #ifdef PWM_EMBEDDED
 	void whatsnew_slot();
 	void showLicense_slot();
 	void faq_slot();
 	void createAboutData_slot();
 	void syncHowTo_slot();
 #endif
 
 protected:
 	/** is this window virgin? */
 	bool isVirgin()
 			{ return virgin; }
 	/** add/remove virginity */
 	void setVirgin(bool v);
 	/** initialize the menubar */
 	void initMenubar();
 	/** initialize the toolbar */
 	void initToolbar();
 	/** initialize the window-metrics */
 	void initMetrics();
 	/** close-event */
 	void closeEvent(QCloseEvent *e);
 	/** creates a new PwM-ListView and returns it */
 	PwMView * makeNewListView(PwMDoc *doc);
 	/** Window hide-event */
 	void hideEvent(QHideEvent *);
 	/** is this window minimized? */
 	bool isMinimized()
 		{
 #ifndef PWM_EMBEDDED
 		  #if KDE_VERSION >= KDE_MAKE_VERSION(3, 2, 0)
 			return KWin::windowInfo(winId()).isMinimized();
 		  #else // KDE_VERSION
 			return KWin::info(winId()).isIconified();
 		  #endif // KDE_VERSION
 #else
 			return false;
 #endif
 		}
 	/** window got the focus */
 	void focusInEvent(QFocusEvent *e);
 	/** update the caption string */
 	void updateCaption();
 #ifdef CONFIG_KWALLETIF
 	/** check if kwalletemu is enabled and ask the user what to do */
 	bool checkAndAskForKWalletEmu();
 #endif // CONFIG_KWALLETIF
 
 protected slots:
 	/** doc got closed */
 	void docClosed(PwMDoc *doc);
 
 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 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
@@ -2283,1216 +2283,1219 @@ bool PwMDoc::goToURL(unsigned int category, unsigned int entryIndex)
 #endif
 	QString url(dti.dta[category].d[entryIndex].url.c_str());
 	if (url.isEmpty())
 		return false;
 
 	QString customBrowser(conf()->confGlobBrowserCommand());
 	if (!customBrowser.isEmpty()) {
 		browserProc.clearArguments();
 		browserProc << customBrowser << url;
 		if (browserProc.start(KProcess::DontCare))
 			return true;
 	}
 
 	browserProc.clearArguments();
 	browserProc << "konqueror" << url;
 	if (browserProc.start(KProcess::DontCare))
 		return true;
 
 	browserProc.clearArguments();
 	browserProc << "mozilla" << url;
 	if (browserProc.start(KProcess::DontCare))
 		return true;
 
 	browserProc.clearArguments();
 	browserProc << "opera" << url;
 	if (browserProc.start(KProcess::DontCare))
 		return true;
 	return false;
 }
 
 PwMerror PwMDoc::exportToText(const QString *file)
 {
 	PWM_ASSERT(file);
 	if (QFile::exists(*file)) {
 		if (!QFile::remove(*file))
 			return e_accessFile;
 	}
 	QFile f(*file);
 	if (!f.open(IO_ReadWrite))
 		return e_openFile;
 
 	if (!unlockAll_tempoary()) {
 		f.close();
 		return e_lock;
 	}
 
 	// write header
 	string header = i18n("Password table generated by\nPwM v").latin1();
 	header += PACKAGE_VER;
 	header += i18n("\non ").latin1();
 	QDate currDate = QDate::currentDate();
 	QTime currTime = QTime::currentTime();
 
 #ifndef PWM_EMBEDDED
 	header += currDate.toString("ddd MMMM d ").latin1();
 	header += currTime.toString("hh:mm:ss ").latin1();
 #else
 	QString dfs = KGlobal::locale()->dateFormatShort();
 	bool ampm = KGlobal::locale()->use12Clock();
 	KGlobal::locale()->setDateFormatShort("%A %B %d");
 	KGlobal::locale()->setHore24Format(true);
 
 	header += KGlobal::locale()->formatDate(currDate, true, KLocale::Userdefined).latin1();
 	header += KGlobal::locale()->formatTime(currTime, true).latin1();
 	KGlobal::locale()->setDateFormatShort(dfs);
 	KGlobal::locale()->setHore24Format(!ampm);
 
 #endif
 	header += tostr(currDate.year());
 	header += "\n==============================\n\n";
 
 
 #ifndef PWM_EMBEDDED
 	if (f.writeBlock(header.c_str(), header.length()) != (Q_LONG)header.length()) {
 		unlockAll_tempoary(true);
 		f.close();
 		return e_writeFile;
 	}
 #else
 	if (f.writeBlock(header.c_str(), header.length()) != (long)header.length()) {
 		unlockAll_tempoary(true);
 		f.close();
 		return e_writeFile;
 	}
 #endif
 	unsigned int i, numCat = numCategories();
 	unsigned int j, numEnt;
 	string exp;
 	for (i = 0; i < numCat; ++i) {
 		numEnt = numEntries(i);
 
 		exp = "\n== Category: ";
 		exp += dti.dta[i].name;
 		exp += " ==\n";
 #ifndef PWM_EMBEDDED
 		if (f.writeBlock(exp.c_str(), exp.length()) != (Q_LONG)exp.length()) {
 				unlockAll_tempoary(true);
 				f.close();
 				return e_writeFile;
 		}
 #else
 		if (f.writeBlock(exp.c_str(), exp.length()) != (long)exp.length()) {
 				unlockAll_tempoary(true);
 				f.close();
 				return e_writeFile;
 		}
 #endif
 		for (j = 0; j < numEnt; ++j) {
 			exp = "\n-- ";
 			exp += dti.dta[i].d[j].desc;
 			exp += " --\n";
 
 			exp += i18n("Username: ").latin1();
 			exp += dti.dta[i].d[j].name;
 			exp += "\n";
 
 			exp += i18n("Password: ").latin1();
 			exp += dti.dta[i].d[j].pw;
 			exp += "\n";
 
 			exp += i18n("Comment: ").latin1();
 			exp += dti.dta[i].d[j].comment;
 			exp += "\n";
 
 			exp += i18n("URL: ").latin1();
 			exp += dti.dta[i].d[j].url;
 			exp += "\n";
 
 			exp += i18n("Launcher: ").latin1();
 			exp += dti.dta[i].d[j].launcher;
 			exp += "\n";
 
 #ifndef PWM_EMBEDDED
 			if (f.writeBlock(exp.c_str(), exp.length()) != (Q_LONG)exp.length()) {
 				unlockAll_tempoary(true);
 				f.close();
 				return e_writeFile;
 			}
 #else
 			if (f.writeBlock(exp.c_str(), exp.length()) != (long)exp.length()) {
 				unlockAll_tempoary(true);
 				f.close();
 				return e_writeFile;
 			}
 #endif
 		}
 	}
 	unlockAll_tempoary(true);
 	f.close();
 
 	return e_success;
 }
 
 PwMerror PwMDoc::importFromText(const QString *file, int format)
 {
 	PWM_ASSERT(file);
 	if (format == 0)
 		return importText_PwM(file);
 	else if (format == -1) {
 		// probe for all formats
 		if (importText_PwM(file) == e_success)
 			return e_success;
 		dti.clear();
 		emitDataChanged(this);
 		// add next format here...
 		return e_fileFormat;
 	}
 	return e_invalidArg;
 }
 
 PwMerror PwMDoc::importText_PwM(const QString *file)
 {
 #ifndef PWM_EMBEDDED
 	PWM_ASSERT(file);
 	FILE *f;
 	int tmp;
 	ssize_t ret;
 	string curCat;
 	unsigned int entriesRead = 0;
 	PwMDataItem currItem;
 	f = fopen(file->latin1(), "r");
 	if (!f)
 		return e_openFile;
 	size_t ch_tmp_size = 1024;
 	char *ch_tmp = (char*)malloc(ch_tmp_size);
 	if (!ch_tmp) {
 		fclose(f);
 		return e_outOfMem;
 	}
 
 	// - check header
 	if (getline(&ch_tmp, &ch_tmp_size, f) == -1) // skip first line.
 		goto formatError;
 	// check version-string and return version in "ch_tmp".
 	if (fscanf(f, "PwM v%s", ch_tmp) != 1) {
 		// header not recognized as PwM generated header
 		goto formatError;
 	}
 	// set filepointer behind version-string-line previously checked
 	if (getline(&ch_tmp, &ch_tmp_size, f) == -1)
 		goto formatError;
 	// skip next line containing the build-date
 	if (getline(&ch_tmp, &ch_tmp_size, f) == -1)
 		goto formatError;
 	// read header termination line
 	if (getline(&ch_tmp, &ch_tmp_size, f) == -1)
 		goto formatError;
 	if (strcmp(ch_tmp, "==============================\n"))
 		goto formatError;
 
 	// - read entries
 	do {
 		// find beginning of next category
 		do {
 			tmp = fgetc(f);
 		} while (tmp == '\n' && tmp != EOF);
 		if (tmp == EOF)
 			break;
 
 		// decrement filepos by one
 		fseek(f, -1, SEEK_CUR);
 		// read cat-name
 		if (getline(&ch_tmp, &ch_tmp_size, f) == -1)
 			goto formatError;
 		// check cat-name format
 		if (memcmp(ch_tmp, "== Category: ", 13) != 0)
 			goto formatError;
 		if (memcmp(ch_tmp + (strlen(ch_tmp) - 1 - 3), " ==", 3) != 0)
 			goto formatError;
 		// copy cat-name
 		curCat.assign(ch_tmp + 13, strlen(ch_tmp) - 1 - 16);
 
 		do {
 			// find beginning of next entry
 			do {
 				tmp = fgetc(f);
 			} while (tmp == '\n' && tmp != EOF && tmp != '=');
 			if (tmp == EOF)
 				break;
 			if (tmp == '=') {
 				fseek(f, -1, SEEK_CUR);
 				break;
 			}
 			// decrement filepos by one
 			fseek(f, -1, SEEK_CUR);
 			// read desc-line
 			if (getline(&ch_tmp, &ch_tmp_size, f) == -1)
 				goto formatError;
 			// check desc-line format
 			if (memcmp(ch_tmp, "-- ", 3) != 0)
 				goto formatError;
 			if (memcmp(ch_tmp + (strlen(ch_tmp) - 1 - 3), " --", 3) != 0)
 				goto formatError;
 			// add desc-line
 			currItem.desc.assign(ch_tmp + 3, strlen(ch_tmp) - 1 - 6);
 
 			// read username-line
 			if ((ret = getline(&ch_tmp, &ch_tmp_size, f)) == -1)
 				goto formatError;
 			if (!textExtractEntry_PwM(ch_tmp, ret, &currItem.name))
 				goto formatError;
 
 			// read pw-line
 			if ((ret = getline(&ch_tmp, &ch_tmp_size, f)) == -1)
 				goto formatError;
 			if (!textExtractEntry_PwM(ch_tmp, ret, &currItem.pw))
 				goto formatError;
 
 			// read comment-line
 			if ((ret = getline(&ch_tmp, &ch_tmp_size, f)) == -1)
 				goto formatError;
 			if (!textExtractEntry_PwM(ch_tmp, ret, &currItem.comment))
 				goto formatError;
 
 			// read URL-line
 			if ((ret = getline(&ch_tmp, &ch_tmp_size, f)) == -1)
 				goto formatError;
 			if (!textExtractEntry_PwM(ch_tmp, ret, &currItem.url))
 				goto formatError;
 
 			// read launcher-line
 			if ((ret = getline(&ch_tmp, &ch_tmp_size, f)) == -1)
 				goto formatError;
 			if (!textExtractEntry_PwM(ch_tmp, ret, &currItem.launcher))
 				goto formatError;
 
 			currItem.lockStat = true;
 			currItem.listViewPos = -1;
 			addEntry(curCat.c_str(), &currItem, true);
 			++entriesRead;
 		} while (1);
 	} while (1);
 	if (!entriesRead)
 		goto formatError;
 
 	free(ch_tmp);
 	fclose(f);
 	flagDirty();
 	return e_success;
 
       formatError:
 	free(ch_tmp);
 	fclose(f);
 	return e_fileFormat;
 #else
 	PWM_ASSERT(file);
 	QFile f(file->latin1());
 	int tmp;
 	ssize_t ret;
 	string curCat;
 	unsigned int entriesRead = 0;
 	PwMDataItem currItem;
 	bool res = f.open(IO_ReadOnly);
 	if (res == false)
 	  return e_openFile;
 
 	unsigned int ch_tmp_size = 1024;
 	char *ch_tmp = (char*)malloc(ch_tmp_size);
 	if (!ch_tmp) {
 		f.close();
 		return e_outOfMem;
 	}
 
 	// - check header
 	if (f.readLine(ch_tmp, ch_tmp_size) == -1) // skip first line.
 		goto formatError;
 
 	//US read fileversion first, then check if ok.
 	if (f.readLine(ch_tmp, ch_tmp_size) == -1)
 		goto formatError;
 
 	// check version-string and return version in "ch_tmp".
 	//US 	if (fscanf(f, "PwM v%s", ch_tmp) != 1) {
 	//US		// header not recognized as PwM generated header
 	//US		goto formatError;
 	//US	}
 	//US set filepointer behind version-string-line previously checked
 	//US if (f.readLine(ch_tmp, ch_tmp_size) == -1)
 	//US		goto formatError;
 	// skip next line containing the build-date
 	if (f.readLine(ch_tmp, ch_tmp_size) == -1)
 		goto formatError;
 	// read header termination line
 	if (f.readLine(ch_tmp, ch_tmp_size) == -1)
 		goto formatError;
 	if (strcmp(ch_tmp, "==============================\n"))
 		goto formatError;
 
 	// - read entries
 	do {
 		// find beginning of next category
 		do {
 			tmp = f.getch();
 		} while (tmp == '\n' && tmp != EOF);
 		if (tmp == EOF)
 			break;
 
 		// decrement filepos by one
 		f.at(f.at()-1);
 		// read cat-name
 		if (f.readLine(ch_tmp, ch_tmp_size) == -1)
 			goto formatError;
 		// check cat-name format
 		if (memcmp(ch_tmp, "== Category: ", 13) != 0)
 			goto formatError;
 		if (memcmp(ch_tmp + (strlen(ch_tmp) - 1 - 3), " ==", 3) != 0)
 			goto formatError;
 		// copy cat-name
 		curCat.assign(ch_tmp + 13, strlen(ch_tmp) - 1 - 16);
 
 		do {
 			// find beginning of next entry
 			do {
 				tmp = f.getch();
 			} while (tmp == '\n' && tmp != EOF && tmp != '=');
 			if (tmp == EOF)
 				break;
 			if (tmp == '=') {
 			        f.at(f.at()-1);
 				break;
 			}
 			// decrement filepos by one
 		        f.at(f.at()-1);
 			// read desc-line
 			if (f.readLine(ch_tmp, ch_tmp_size) == -1)
 				goto formatError;
 			// check desc-line format
 			if (memcmp(ch_tmp, "-- ", 3) != 0)
 				goto formatError;
 			if (memcmp(ch_tmp + (strlen(ch_tmp) - 1 - 3), " --", 3) != 0)
 				goto formatError;
 			// add desc-line
 			currItem.desc.assign(ch_tmp + 3, strlen(ch_tmp) - 1 - 6);
 
 			// read username-line
 			if ((ret = f.readLine(ch_tmp, ch_tmp_size)) == -1)
 				goto formatError;
 			if (!textExtractEntry_PwM(ch_tmp, ret, &currItem.name))
 				goto formatError;
 
 			// read pw-line
 			if ((ret = f.readLine(ch_tmp, ch_tmp_size)) == -1)
 				goto formatError;
 			if (!textExtractEntry_PwM(ch_tmp, ret, &currItem.pw))
 				goto formatError;
 
 			// read comment-line
 			if ((ret = f.readLine(ch_tmp, ch_tmp_size)) == -1)
 				goto formatError;
 			if (!textExtractEntry_PwM(ch_tmp, ret, &currItem.comment))
 				goto formatError;
 
 			// read URL-line
 			if ((ret = f.readLine(ch_tmp, ch_tmp_size)) == -1)
 				goto formatError;
 			if (!textExtractEntry_PwM(ch_tmp, ret, &currItem.url))
 				goto formatError;
 
 			// read launcher-line
 			if ((ret = f.readLine(ch_tmp, ch_tmp_size)) == -1)
 				goto formatError;
 			if (!textExtractEntry_PwM(ch_tmp, ret, &currItem.launcher))
 				goto formatError;
 
 			currItem.lockStat = true;
 			currItem.listViewPos = -1;
 			addEntry(curCat.c_str(), &currItem, true);
 			++entriesRead;
 		} while (1);
 	} while (1);
 	if (!entriesRead)
 		goto formatError;
 
 	free(ch_tmp);
 	f.close();
 	flagDirty();
 	return e_success;
 
       formatError:
 	free(ch_tmp);
 	f.close();
 	return e_fileFormat;
 
 #endif
 
 }
 
 bool PwMDoc::textExtractEntry_PwM(const char *in, ssize_t in_size, string *out)
 {
 	PWM_ASSERT(in && out);
 	ssize_t i = 0, len = in_size - 1;
 	while (i < len) {
 		if (in[i] == ':')
 			break;
 		++i;
 	}
 	i += 2;
 	*out = "";
 	out->append(in + i, in_size - i - 1);
 	return true;
 }
 
 PwMerror PwMDoc::exportToGpasman(const QString *file)
 {
 	PWM_ASSERT(file);
 	GpasmanFile gp;
 	int ret;
 
 	if (!unlockAll_tempoary())
 		return e_lock;
 
 	QString gpmPassword;
 	while (1) {
 		gpmPassword = requestNewMpw(0);
 		if (gpmPassword == "") {
 			unlockAll_tempoary(true);
 			return e_noPw;
 		}
 		if (gpmPassword.length() < 4) {
 			gpmPwLenErrMsgBox();
 		} else {
 			break;
 		}
 	}
 
 	ret = gp.save_init(file->latin1(), gpmPassword.latin1());
 	if (ret != 1) {
 		unlockAll_tempoary(true);
 		return e_accessFile;
 	}
 
 	char *entry[4];
 	unsigned int numCat = numCategories(), i;
 	unsigned int numEntr, j;
 	int descLen, nameLen, pwLen, commentLen;
 	for (i = 0; i < numCat; ++i) {
 		numEntr = numEntries(i);
 		for (j = 0; j < numEntr; ++j) {
 			descLen = dti.dta[i].d[j].desc.length();
 			nameLen = dti.dta[i].d[j].name.length();
 			pwLen = dti.dta[i].d[j].pw.length();
 			commentLen = dti.dta[i].d[j].comment.length();
 			entry[0] = new char[descLen + 1];
 			entry[1] = new char[nameLen + 1];
 			entry[2] = new char[pwLen + 1];
 			entry[3] = new char[commentLen + 1];
 			strcpy(entry[0], descLen == 0 ? " " : dti.dta[i].d[j].desc.c_str());
 			strcpy(entry[1], nameLen == 0 ? " " : dti.dta[i].d[j].name.c_str());
 			strcpy(entry[2], pwLen == 0 ? " " : dti.dta[i].d[j].pw.c_str());
 			strcpy(entry[3], commentLen == 0 ? " " : dti.dta[i].d[j].comment.c_str());
 			entry[0][descLen == 0 ? descLen + 1 : descLen] = '\0';
 			entry[1][nameLen == 0 ? nameLen + 1 : nameLen] = '\0';
 			entry[2][pwLen == 0 ? pwLen + 1 : pwLen] = '\0';
 			entry[3][commentLen == 0 ? commentLen + 1 : commentLen] = '\0';
 
 			ret = gp.save_entry(entry);
 			if (ret == -1){
 				delete [] entry[0];
 				delete [] entry[1];
 				delete [] entry[2];
 				delete [] entry[3];
 				gp.save_finalize();
 				unlockAll_tempoary(true);
 				return e_writeFile;
 			}
 
 			delete [] entry[0];
 			delete [] entry[1];
 			delete [] entry[2];
 			delete [] entry[3];
 		}
 	}
 	unlockAll_tempoary(true);
 	if (gp.save_finalize() == -1)
 		return e_writeFile;
 
 	return e_success;
 }
 
 PwMerror PwMDoc::importFromGpasman(const QString *file)
 {
 	PWM_ASSERT(file);
 	QString pw = requestMpw(false);
 	if (pw == "")
 		return e_noPw;
 	GpasmanFile gp;
 	int ret, i;
 	PwMerror ret2;
 	char *entry[4];
 	PwMDataItem tmpData;
 	ret = gp.load_init(file->latin1(), pw.latin1());
 	if (ret != 1)
 		return e_accessFile;
 
 	do {
 		ret = gp.load_entry(entry);
 		if(ret != 1)
 			break;
 		tmpData.desc = entry[0];
 		tmpData.name = entry[1];
 		tmpData.pw = entry[2];
 		tmpData.comment = entry[3];
 		tmpData.lockStat = true;
 		tmpData.listViewPos = -1;
 		ret2 = addEntry(DEFAULT_CATEGORY, &tmpData, true);
 		for (i = 0; i < 4; ++i)
          		free(entry[i]);
 		if (ret2 == e_maxAllowedEntr) {
 			gp.load_finalize();
 			return e_maxAllowedEntr;
 		}
 	} while (1);
 	gp.load_finalize();
 	if (isDocEmpty())
 		return e_wrongPw; // we assume this.
 
 	flagDirty();
 	return e_success;
 }
 
 
 //US: we use the stl sort algorythm to sort all elements in the order 
 //of its listViewPos (in the order 1,2,3,5,...,x,-1, -1, -1
 struct PwMDataItemListViewPosSort
 {
   bool operator()(PwMDataItem* rpStart, PwMDataItem* rpEnd)
   {
     //qDebug("pwMDoc::PwMDataItemListViewPosSort()");
     if ((rpEnd)->listViewPos < 0)
 	return false;
     else
       return (rpStart)->listViewPos < (rpEnd)->listViewPos;
   }
 };
 
 void PwMDoc::ensureLvp()
 {
 	if (isDocEmpty())
 		return;
 
 	//US ENH BUG: when using syncronizing, this way of sorting
 	//is not sufficient, because there might be empty spaces
 	// at the beginning. But the old algorythm only can add elements
 	//to the end.The result are crashes because of list overflows
 	//we need something to fill all gaps.
 	vector<PwMDataItem*> sorted;
 	vector< PwMDataItem*>::iterator sortedBegin,
 					sortedEnd,
 					sortedI;
 	vector<PwMCategoryItem>::iterator catBegin = dti.dta.begin(),
 					  catEnd = dti.dta.end(),
 					  catI = catBegin;
 	vector<PwMDataItem>::iterator entrBegin, entrEnd, entrI;
 	int lvpTop, tmpLvp;
 
 	//qDebug("collect:"); 
 
 	while (catI != catEnd) {
 		lvpTop = -1;
 		sorted.clear();
 
 		entrBegin = catI->d.begin();
 		entrEnd = catI->d.end();
 		entrI = entrBegin;
 
 		//US: we use the stl sort algorythm to sort all elements in the order 
 		//of its listViewPos (in the order 1,2,2,3,5,...,x,-1, -1, -1
 		while (entrI != entrEnd) {
 		  //qDebug("found: %s, pos=%i", (*entrI).desc.c_str(), (*entrI).listViewPos);
 		  sorted.push_back((PwMDataItem*)&(*entrI));
 		  ++entrI;
 		}
 
 		sortedBegin = sorted.begin();
 		sortedEnd = sorted.end();
 
 		sort(sortedBegin, sortedEnd, PwMDataItemListViewPosSort());
 
 		//		qDebug("resort:"); 
 		//now we have all sorted in a collection
 		//Now start with the sorted and reset listviewpos.
 		sortedBegin = sorted.begin();
 		sortedEnd = sorted.end();
 		sortedI = sortedBegin;
 
 		while (sortedI != sortedEnd) {
 		  //		  qDebug("reset defined: %s, from pos=%i to pos=%i", (*sortedI)->desc.c_str(), (*sortedI)->listViewPos, lvpTop+1);
 		  (*sortedI)->listViewPos = ++lvpTop;
 		  ++sortedI;
 		}
 
 		/*/debug
 		entrBegin = catI->d.begin();
 		entrEnd = catI->d.end();
 		entrI = entrBegin;
 
 		while (entrI != entrEnd) {
 		  qDebug("check: %s, pos=%i", (*entrI).desc.c_str(), (*entrI).listViewPos);
 		  ++entrI;
 		}
 		*/
 
 		++catI;
 	}
 }
 
 QString PwMDoc::getTitle()
 {
 	/* NOTE: We have to ensure, that the returned title
 	 *       is unique and not reused somewhere else while
 	 *       this document is valid (open).
 	 */
 	QString title(getFilename());
 
 	//US ENH: The whole filename on PDAs is too long. So use only the last characters
         if (QApplication::desktop()->width() < 640)
 	{
 	  if (title.length() > 30)
 	    title = "..." + title.right(30);
 
 	}
 
 
 	if (title.isEmpty()) {
 		if (unnamedNum == 0) {
 			unnamedNum = PwMDocList::getNewUnnamedNumber();
 			PWM_ASSERT(unnamedNum != 0);
 		}
 		title = DEFAULT_TITLE;
 		title += " ";
 		title += tostr(unnamedNum).c_str();
 	}
 	return title;
 }
 
 bool PwMDoc::tryDelete()
 {
  
 	if (deleted)
 		return true;
 	int ret;
 	if (isDirty()) {
 		ret = dirtyAskSave(getTitle());
 		if (ret == 0) { // save to disk
 			if (!saveDocUi(this))
 				goto out_ignore;
 		} else if (ret == 1) { // don't save and delete
 			goto out_accept;
 		} else { // cancel operation
 			goto out_ignore;
 		}
 	}
 out_accept:
 	deleted = true;
 	delete this;
 	return true;
 out_ignore:
 	return false;
 }
 
 
 
 #ifdef PWM_EMBEDDED
 //US ENH: this is the magic function that syncronizes the this doc with the remote doc
 //US it could have been defined as static, but I did not want to. 
 PwMerror PwMDoc::syncronize(KSyncManager* manager, PwMDoc* syncLocal , PwMDoc* syncRemote, int mode )
 {
   int addedPasswordsLocal = 0;
   int addedPasswordsRemote = 0;
   int deletedPasswordsRemote = 0;
   int deletedPasswordsLocal = 0;
   int changedLocal = 0;
   int changedRemote = 0;
 
   PwMSyncItem* syncItemLocal;
   PwMSyncItem* syncItemRemote;
 
   QString mCurrentSyncName = manager->getCurrentSyncName();
   QString mCurrentSyncDevice = manager->getCurrentSyncDevice();
 
   bool fullDateRange = false;
   int take;
   //    local->resetTempSyncStat();
   QDateTime mLastSync = QDateTime::currentDateTime();
   QDateTime modifiedSync = mLastSync;
 
   unsigned int index;
   //Step 1. Find syncinfo in Local file and create if not existent.
   bool found = syncLocal->findSyncData(mCurrentSyncDevice, &index);
   if (found == false)
     {
       PwMSyncItem newSyncItemLocal;
       newSyncItemLocal.syncName = mCurrentSyncDevice.latin1();
       newSyncItemLocal.lastSyncDate = mLastSync;
       syncLocal->addSyncDataEntry(&newSyncItemLocal, true);
       found = syncLocal->findSyncData(mCurrentSyncDevice, &index);
       if (found == false) {
 	qDebug("PwMDoc::syncronize : newly created local sync data could not be found");
 	return e_syncError;
       }
     }	
 
   syncItemLocal = syncLocal->getSyncDataEntry(index); 
   qDebug("Last Sync Local %s ", syncItemLocal->lastSyncDate.toString().latin1());
 
   //Step 2. Find syncinfo in remote file and create if not existent.
   found = syncRemote->findSyncData(mCurrentSyncName, &index);
   if (found == false)
     {
       qDebug("FULLDATE 1");
       fullDateRange = true;
       PwMSyncItem newSyncItemRemote;
       newSyncItemRemote.syncName = mCurrentSyncName.latin1();
       newSyncItemRemote.lastSyncDate = mLastSync;
       syncRemote->addSyncDataEntry(&newSyncItemRemote, true);
       found = syncRemote->findSyncData(mCurrentSyncName, &index);
       if (found == false) {
 	qDebug("PwMDoc::syncronize : newly created remote sync data could not be found");
 	return e_syncError;
       }
     }
   
   syncItemRemote = syncRemote->getSyncDataEntry(index); 
   qDebug("Last Sync Remote %s ", syncItemRemote->lastSyncDate.toString().latin1());
   //and remove the found entry here. We will reenter it later again.
   //US  syncRemote->delSyncDataEntry(index, true);
 
 
   if ( syncItemLocal->lastSyncDate == mLastSync ) {
     qDebug("FULLDATE 2");
     fullDateRange = true;
   }
   
   if ( ! fullDateRange  ) {
         if ( syncItemLocal->lastSyncDate != syncItemRemote->lastSyncDate ) {
             
             fullDateRange = true;
             qDebug("FULLDATE 3 %s %s", syncItemLocal->lastSyncDate.toString().latin1() , syncItemRemote->lastSyncDate.toString().latin1() );
         } 
     }
     // fullDateRange = true; // debug only!
     if ( fullDateRange )
         mLastSync = QDateTime::currentDateTime().addDays( -100*365);
     else
         mLastSync = syncItemLocal->lastSyncDate;
 
 
     qDebug("*************************** ");
     qDebug("mLastSync %s ",mLastSync.toString().latin1() );
     QStringList er = syncRemote->getIDEntryList(); 
     PwMDataItem* inRemote ;//= er.first();
     PwMDataItem* inLocal;
     unsigned int catLocal, indexLocal;
     unsigned int catRemote, indexRemote;
 
     QString uid;
     manager->showProgressBar(0, i18n("Syncing - close to abort!"), er.count());
 
     int modulo = (er.count()/10)+1;
     unsigned int incCounter = 0;
     while ( incCounter < er.count()) {
 	if (manager->isProgressBarCanceled())
             return e_syncError;
         if ( incCounter % modulo == 0 )
 	  manager->showProgressBar(incCounter);
 
         uid = er[ incCounter ]; 
 	qDebug("sync uid %s from remote file", uid.latin1());
 
         qApp->processEvents();
 
             inLocal = syncLocal->findEntryByID( uid, &catLocal, &indexLocal );
             inRemote = syncRemote->findEntryByID( uid, &catRemote, &indexRemote );
 	    PWM_ASSERT(inRemote);
             if ( inLocal != 0 ) { // maybe conflict - same uid in both files
                 if ( (take = takePwMDataItem( inLocal, inRemote, mLastSync, mode, fullDateRange) ) ) {
                     qDebug("take %d %s ", take, inLocal->desc.c_str());
                     if ( take == 3 )
                         return e_syncError;
                     if ( take == 1  ) {// take local
 		        int oldlistpos = inRemote->listViewPos;
                         (*inRemote) = (*inLocal);
 			inRemote->listViewPos = oldlistpos;
                         ++changedRemote;
                     } else { // take == 2  take remote
 		        int oldlistpos = inLocal->listViewPos;
                         (*inLocal) = (*inRemote);
 			inLocal->listViewPos = oldlistpos;
                         ++changedLocal;
                     }
                 }
             } else { //  no conflict
                     if ( inRemote->meta.update > mLastSync || mode == 5 ) {
                         inRemote->meta.update = modifiedSync;
 
 			//first check if we have a matching category in the local file
 			const string* remotecat = syncRemote->getCategory(catRemote);
 			syncLocal->addEntry(remotecat->c_str(), inRemote, true, false);
 
                         ++addedPasswordsLocal;
                     } else {
                         // pending checkExternSyncAddressee(addresseeRSyncSharp, inR);
 		        syncRemote->delEntry(catRemote, indexRemote, true);
                         ++deletedPasswordsRemote; 
                     }
             }
 
         ++incCounter;
     }
 
 
     er.clear();
     QStringList el = syncLocal->getIDEntryList(); 
     modulo = (el.count()/10)+1;
 
     manager->showProgressBar(0, i18n("Add / remove addressees"), el.count());
     incCounter = 0;
     while ( incCounter < el.count()) {
         qApp->processEvents();
 	if (manager->isProgressBarCanceled())
             return e_syncError;
         if ( incCounter % modulo == 0 )
 	  manager->showProgressBar(incCounter);
         uid = el[ incCounter ]; 
 	qDebug("sync uid %s from local file", uid.latin1());
 
         inLocal = syncLocal->findEntryByID( uid, &catLocal, &indexLocal );
         inRemote = syncRemote->findEntryByID( uid, &catRemote, &indexRemote );
 	PWM_ASSERT(inLocal);
 
         if ( inRemote == 0 ) { 
                 if ( inLocal->meta.update < mLastSync && mode != 4 ) {
                     // pending checkExternSyncAddressee(addresseeLSyncSharp, inL);
 		    syncLocal->delEntry(catLocal, indexLocal, true);
                     ++deletedPasswordsLocal; 
                 } else {
                     if ( ! manager->mWriteBackExistingOnly ) {
                         ++addedPasswordsRemote; 
                         inLocal->meta.update = modifiedSync;
 
 			//first check if we have a matching category in the remote file
 			const string* localcat = syncLocal->getCategory(catLocal);
 
                         PwMDataItem newEntry;
 			newEntry = *inLocal; 
 			inRemote = &newEntry;
 	
                         //USsyncRemote->insertAddressee( inRemote, false );
 			syncRemote->addEntry(localcat->c_str(), inRemote, true, false);
 
                     }
                 }
 
         }
         ++incCounter;
     }
     el.clear();
     manager->hideProgressBar();
 
     // Now write the info back into the sync data space of the files
 
     mLastSync = QDateTime::currentDateTime().addSecs( 1 );
     // get rid of micro seconds
     QTime t =  mLastSync.time();
     mLastSync.setTime( QTime (t.hour (), t.minute (), t.second () )  );
 
    
     syncItemLocal->lastSyncDate = mLastSync;
     syncItemRemote->lastSyncDate = mLastSync;
 
     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"),addedPasswordsLocal, addedPasswordsRemote, changedLocal, changedRemote, deletedPasswordsLocal, deletedPasswordsRemote ); 
     if ( manager->mShowSyncSummary ) {
         KMessageBox::information(0, mes, i18n("PWM/Pi Synchronization") );
     }
     qDebug( mes );
   return e_success;
 }
 
 
 int PwMDoc::takePwMDataItem( PwMDataItem* local,  PwMDataItem* remote, QDateTime lastSync, int mode , bool full )
 {
     // 0 equal
     // 1 take local
     // 2 take remote
     // 3 cancel 
     QDateTime localMod = local->meta.update;
     QDateTime remoteMod = remote->meta.update;
 
      if ( localMod == remoteMod )
        return 0;
         
     qDebug(" %d %d conflict on %s %s ", mode, full, local->desc.c_str(), remote->desc.c_str() );
 
     //qDebug("%s %d  %s %d", local->lastModified().toString().latin1() , localMod, remote->lastModified().toString().latin1(), remoteMod);  
     //qDebug("%d %d %d %d ", local->lastModified().time().second(), local->lastModified().time().msec(),  remote->lastModified().time().second(), remote->lastModified().time().msec() );
     //full = true; //debug only
     if ( full ) {
       bool equ = ( (*local) == (*remote) );
         if ( equ ) {
 	  //qDebug("equal ");
             if ( mode < SYNC_PREF_FORCE_LOCAL )
                 return 0;
               
         }//else //debug only
 	  //qDebug("not equal %s %s ", local->desc.c_str(), remote->desc.c_str());
     }
     
     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()  ,  local->lastModified().toString().latin1() , remote->lastModified().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;
         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 );
 
   if (err == e_success) {
     if ( manager->mWriteBackFile )	{
       qDebug("Saving remote PWManager file");
       err = pSyncTarget->saveDoc(conf()->confGlobCompression());
       if (err != e_success) {
 	qDebug("PwmDoc::sync: Sync failed. Error %i while storing file %s",err, filename.latin1());
 	return false;
       }
     }
 
     flagDirty();
     return true;
   }
   else {
     return false;
   }
 }
 
 #endif
 
 
 bool PwMDoc::findSyncData(const QString &syncname, unsigned int *index)
 {
 	vector<PwMSyncItem>::iterator i = dti.syncDta.begin(), 
 	                              end = dti.syncDta.end();
 
 	while (i != end) {
 		if ((*i).syncName == syncname.latin1()) {
 			if (index) {
 				*index = i - dti.syncDta.begin();
 			}
 			return true;
 		}
 		++i;
 	}
 	return false;
 };
 
 /** add new syncdataentry */
 PwMerror PwMDoc::addSyncDataEntry(PwMSyncItem *d, bool dontFlagDirty)
 {
 	PWM_ASSERT(d);
 
 	if (isDeepLocked()) {
 		PwMerror ret;
 		ret = deepLock(false);
 		if (ret != e_success)
 			return e_lock;
 	}
 	unsigned int index;
 
 	const QString tmp = d->syncName.c_str();
 	bool exists = findSyncData(d->syncName.c_str(), &index);
 
 	if (exists == true) {
 		// DOH! We found this entry.
 		return e_entryExists;
 	}
 
 	dti.syncDta.push_back(*d);
 
 	if (!dontFlagDirty)
 		flagDirty();
 	return e_success;
 }
 
 
 
 /** delete syncdata entry */
 bool PwMDoc::delSyncDataEntry(unsigned int index, bool dontFlagDirty)
 {
 	if (isDeepLocked())
 		return false;
 	if (index > dti.syncDta.size() - 1)
 		return false;
 
 	// delete entry
 	dti.syncDta.erase(dti.syncDta.begin() + index);
 
 	if (!dontFlagDirty)
 		flagDirty();
 	return true;
 }
 
 
 PwMDataItem* PwMDoc::findEntryByID(const QString &uid, unsigned int *category, unsigned int *index)
 {
   vector<PwMCategoryItem>::iterator catcounter = dti.dta.begin(),
 				  catend = dti.dta.end();
 
   vector<PwMDataItem>::iterator entrBegin, entrEnd, entrI;
 
   while (catcounter != catend) {
     entrBegin = catcounter->d.begin();
     entrEnd = catcounter->d.end();
     entrI = entrBegin;
     while (entrI != entrEnd) {
       if ((*entrI).meta.uniqueid == uid.latin1()) {
 	if (category)
 	  *category = catcounter - dti.dta.begin();
 	if (index)
 	  *index = entrI - entrBegin;
 
 	return &(*entrI);
       }
       ++entrI;
     }
     ++catcounter;
   }
 
   return 0;
 }
 
 QStringList PwMDoc::getIDEntryList()
 {
   QStringList results;
 
   vector<PwMCategoryItem>::iterator catcounter = dti.dta.begin(),
 				  catend = dti.dta.end();
 
   vector<PwMDataItem>::iterator entrBegin, entrEnd, entrI;
 
   while (catcounter != catend) {
     entrBegin = catcounter->d.begin();
     entrEnd = catcounter->d.end();
     entrI = entrBegin;
     while (entrI != entrEnd) {
       results.append( (*entrI).meta.uniqueid.c_str() );
       ++entrI;
     }
     ++catcounter;
   }
 
   return results;
 }
 
 
 
 
 
 #ifndef PWM_EMBEDDED
 #include "pwmdoc.moc"
 #endif
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
@@ -1,788 +1,789 @@
 /***************************************************************************
  *                                                                         *
  *   copyright (C) 2003, 2004 by Michael Buesch                            *
  *   email: mbuesch@freenet.de                                             *
  *                                                                         *
  *   This program is free software; you can redistribute it and/or modify  *
  *   it under the terms of the GNU General Public License version 2        *
  *   as published by the Free Software Foundation.                         *
  *                                                                         *
  ***************************************************************************/
 
 /***************************************************************************
  * copyright (C) 2004 by Ulf Schenk
  * This file is originaly based on version 1.1 of pwmanager
  * and was modified to run on embedded devices that run microkde
  *
  * $Id$
  **************************************************************************/  
 
 #ifndef __PWMDOC_H
 #define __PWMDOC_H
 #ifdef _WIN32_
 #define ssize_t unsigned int
 #endif
 #define PWM_FILE_VER		(static_cast<char>(0x05))
 
 #define PWM_HASH_SHA1		(static_cast<char>(0x01))
 #define PWM_HASH_SHA256		(static_cast<char>(0x02))
 #define PWM_HASH_SHA384		(static_cast<char>(0x03))
 #define PWM_HASH_SHA512		(static_cast<char>(0x04))
 #define PWM_HASH_MD5		(static_cast<char>(0x05))
 #define PWM_HASH_RMD160		(static_cast<char>(0x06))
 #define PWM_HASH_TIGER		(static_cast<char>(0x07))
 
 #define PWM_CRYPT_BLOWFISH	(static_cast<char>(0x01))
 #define PWM_CRYPT_AES128	(static_cast<char>(0x02))
 #define PWM_CRYPT_AES192	(static_cast<char>(0x03))
 #define PWM_CRYPT_AES256	(static_cast<char>(0x04))
 #define PWM_CRYPT_3DES		(static_cast<char>(0x05))
 #define PWM_CRYPT_TWOFISH	(static_cast<char>(0x06))
 #define PWM_CRYPT_TWOFISH128	(static_cast<char>(0x07))
 
 #define PWM_COMPRESS_NONE	(static_cast<char>(0x00))
 #define PWM_COMPRESS_GZIP	(static_cast<char>(0x01))
 #define PWM_COMPRESS_BZIP2	(static_cast<char>(0x02))
 
 #define DEFAULT_MAX_ENTRIES	(~(static_cast<unsigned int>(0)))
 #define FILE_ID_HEADER  	"PWM_PASSWORD_FILE"
 
 
 #include "pwmexception.h"
 #include "pwmdocui.h"
 
 #include <qobject.h>
 #include <qtimer.h>
 #include <qdatetime.h>
 
 #include <kprocess.h>
 
 #ifndef PWM_EMBEDDED
 #include "configuration.h"
 #else
 #include <kapplication.h>
 #include <ksyncmanager.h>
 #endif
 
 #include <string>
 #include <vector>
 #include <utility>
 
 using std::vector;
 using std::string;
 using std::pair;
 
 /* used in findEntry() function */
 #define SEARCH_IN_DESC		(1)
 #define SEARCH_IN_NAME		(1 << 1)
 #define SEARCH_IN_PW		(1 << 2)
 #define SEARCH_IN_COMMENT	(1 << 3)
 #define SEARCH_IN_URL		(1 << 4)
 #define SEARCH_IN_LAUNCHER	(1 << 5)
 #define SEARCH_IN_ALL		(SEARCH_IN_DESC	| SEARCH_IN_NAME	|  \
 				 SEARCH_IN_PW	| SEARCH_IN_COMMENT	|  \
 				 SEARCH_IN_URL	| SEARCH_IN_LAUNCHER)
 
 /** document deeplocked. Data is out for lunch to disk */
 #define DOC_STAT_DEEPLOCKED		(1)
 /** encrypted document on disk is dirty. data has to go to disk. */
 #define DOC_STAT_DISK_DIRTY		(1 << 1)
 /** we are using a chipcard to encrypt the data */
 #define DOC_STAT_USE_CHIPCARD		(1 << 2)
 /** use "currentPw" to unlock. (This flag is set/unset by a timer) */
 #define DOC_STAT_UNLOCK_WITHOUT_PW	(1 << 3)
 
 class PwMDoc;
 class PwMView;
 class QFile;
 
 /* meta data for a PwMDataItem */
 struct PwMMetaData
 {
 	PwMMetaData()
 	 : updateInt (0)
 		{ }
 	/** creation date of the PwMDataItem to which
 	  * this meta data belongs.
 	  */
 	QDateTime	create;
 	/** becomes valid on this date */
 	QDateTime	valid;
 	/** expire date */
 	QDateTime	expire;
 	/** update date (last updated at this date) */
 	QDateTime	update;
 	/** update interval (in minutes). Time since the
 	  * last update to remind the user to update the item.
 	  * 0 disables.
 	  */
 	unsigned long updateInt;
  
 	//US ENH: enhancements of the filestructure
 	/* each entry gets a unique id assigned  */
 	string  uniqueid;
 
 
 	void clear()
 		{
 			create = QDateTime();
 			expire = QDateTime();
 			update = QDateTime();
 			updateInt = 0;
 			uniqueid = KApplication::randomString(8).latin1();
 		}
 
 	inline bool isValid() const
 		{
 			if (valid.isNull())
 				return true;
 			return (valid < QDateTime::currentDateTime());
 		}
 	inline bool isExpired() const
 		{
 			if (expire.isNull())
 				return false;
 			return (expire < QDateTime::currentDateTime());
 		}
 	inline bool isUpdateIntOver() const
 		{
 			if (updateInt == 0 ||
 			    update.isNull())
 				return false;
 			QDateTime d(update);
 			return (d.addSecs(updateInt * 60) < QDateTime::currentDateTime());
 		}
 };
 
 struct PwMDataItem
 {
 	PwMDataItem()
 	 : lockStat (true)
 	 , listViewPos (-1)
 	 , binary (false)
 	 , rev (0)
 		{ }
 
 	/** password description */
 	string	desc;
 	/** user-name */
 	string	name;
 	/** the password itself */
 	string	pw;
 	/** some comment */
 	string	comment;
 	/** an URL string */
 	string	url;
 	/** launcher. Can be executed as a system() command */
 	string	launcher;
 	/** locking status. If locked (true), pw is not emitted through getEntry() */
 	bool	lockStat;
 	/** position of this item in main "list-view"
 	  * If -1, the position is not yet specified and should be appended to the list
 	  */
 	int	listViewPos;
 	/** does this entry contain binary data? */
 	bool binary;
 	/** meta data for this data item. */
 	PwMMetaData meta;
 	/** data revision counter. This counter can be used
 	  * to easily, efficiently determine if this data item
 	  * has changed since some time.
 	  * This counter is incremented on every update.
 	  */
 	unsigned int rev;
 
 	void clear(bool clearMeta = true)
 	{
 		/* NOTE: Don't use .clear() here to be
 		 *       backward compatible with gcc-2 (Debian Woody)
 		 */
 		desc = "";
 		name = "";
 		pw = "";
 		comment = "";
 		url = "";
 		launcher = "";
 		lockStat = true;
 		listViewPos = -1;
 		binary = false;
 		if (clearMeta)
 			meta.clear();
 	}
   //US ENH: we need this operator to compare two items if we have no unique ids
   //available. Generaly this happens before the first sync
 
 	bool PwMDataItem::operator==( const PwMDataItem &a ) const
 	{
 	  //qDebug("oper==%s", a.desc.c_str());
 	  if ( desc != a.desc ) return false;
 	  if ( name != a.name ) return false;
 	  if ( pw != a.pw ) return false;
 	  if ( comment != a.comment ) return false;
 	  if ( url != a.url ) return false;
 	  if ( launcher != a.launcher ) return false;
 	  //all other field will not be checked.
 	  return true;
 	}
 };
 
 struct PwMCategoryItem
 {
 	/** all PwMDataItems (all passwords) within this category */
 	vector<PwMDataItem>	d;
 	/** category name/description */
 	string			name;
 
 	void clear()
 	{
 		d.clear();
 		name = "";
 	}
 };
 
 struct PwMSyncItem
 {
   string syncName;
   QDateTime lastSyncDate;
   
   void clear()
 	{
 		lastSyncDate = QDateTime();
 		syncName = "";
 	}
 };
 
 struct PwMItem
 {
   vector<PwMCategoryItem> dta;
   vector<PwMSyncItem> syncDta;
 
   void clear()
 	{
 		dta.clear();
 		syncDta.clear(); 
 	}
 };
 
 
 /** "Function Object" for sort()ing PwMDataItem::listViewPos */
 class dta_lvp_greater
 {
 public:
 	bool operator() (const pair<unsigned int, unsigned int> &d1,
 			 const pair<unsigned int, unsigned int> &d2)
 	{
 		return d1.second > d2.second;
 	}
 };
 
 /** list of PwMDoc documents and it's IDs */
 class PwMDocList
 {
 public:
 	struct listItem
 	{
 		/** document filename (known as ID, here) */
 		string docId;
 		/** pointer to the document class */
 		PwMDoc *doc;
 	};
 
 	PwMDocList() {}
 
 	/** add a new item to the list */
 	void add(PwMDoc *doc, const string &id);
 	/** changes the contents of an existing item */
 	void edit(PwMDoc *doc, const string &newId);
 	/** remove the given item */
 	void del(PwMDoc *doc);
 	/** get the item at index */
 	listItem getAt(int index)
 			{ return docList[index]; }
 	/** find an entry with this id */
 	bool find(const string &id, listItem *ret = 0);
 	/** returns a copy of the list */
 	const vector<listItem>* getList() const
 			{ return &docList; }
 
 
 	/** returns a new unique number to extend the name of
 	  * an unnamed document.
 	  */
 	static unsigned int getNewUnnamedNumber()
 			{ return unnamedDocCnt++; }
 
 protected:
 	/* Hm, I think we shouldn't really use a "list" here, should we?
 	 * So I decided to actually use a vector.
 	 */
 	vector<listItem> docList;
 	/** This value is used to get a new number for yet unnamed
 	  * documents. It is incremented on every request. So it's
 	  * theoretically possible to overflow it, but... :)
 	  */
 	static unsigned int unnamedDocCnt;
 };
 
 /** implements timers for the document */
 class DocTimer : public QObject
 {
 	Q_OBJECT
 public:
 	enum TimerIDs
 	{
 		id_mpwTimer,
 		id_autoLockTimer,
 		id_metaCheckTimer
 	};
 
 public:
 	DocTimer(PwMDoc *_doc);
 	~DocTimer();
 
 	/** start the timer */
 	void start(TimerIDs timer);
 	/** stop the timer */
 	void stop(TimerIDs timer);
 	/** get the lock for a timer.
 	  * This lock is a recursive lock. When a lock is
 	  * held, the timer will be stopped and timeout is
 	  * guaranteed to not happen
 	  */
 	void getLock(TimerIDs timer);
 	/** put a recursive timer lock */
 	void putLock(TimerIDs timer);
 
 protected slots:
 	/** timeout slot for the mpw timer */
 	void mpwTimeout();
 	/** timeout slot for the autoLock timer */
 	void autoLockTimeout();
 	/** timeout slot for the metaCheck timer */
 	void metaCheckTimeout();
 
 protected:
 	/** pointer to the document associated with this timer. */
 	PwMDoc *doc;
 	/** timer object for mpw timer */
 	QTimer *mpwTimer;
 	/** timer object for the autoLock timer */
 	QTimer *autoLockTimer;
 	/** timer object for the metaCheck timer */
 	QTimer *metaCheckTimer;
 	/** lock counter for the mpw timer */
 	unsigned int mpwLock;
 	/** lock counter for the autoLock timer */
 	unsigned int autoLockLock;
 	/** lock counter for the metaCheck timer */
 	unsigned int metaCheckLock;
 };
 
 /** Document class for PwM */
 //US ENH: derived from KSyncInterfaces, to get called by PwM when a sync is required.
 // But PwMDoc is handling the sync by itself.
 class PwMDoc : public PwMDocUi, public KSyncInterface
 
 {
 	Q_OBJECT
 	friend class DocTimer;
 
 public:
 	/** construtor */
 	PwMDoc(QObject* parent = 0, const char *name = 0);
 	/** destructor */
 	~PwMDoc();
 
 	/** returns a pointer to a list of all open documents */
 	static PwMDocList* getOpenDocList()
 			{ return &openDocList; }
 
 	/** flag document dirty. dta changed */
 	void flagDirty()
 		{
 			setDocStatFlag(DOC_STAT_DISK_DIRTY);
 			emitDataChanged(this);
 		}
 	/** modified? */
 	bool isDirty()
 			{ return getDocStatFlag(DOC_STAT_DISK_DIRTY); }
 	/** save document to disk */
 	PwMerror saveDoc(char compress, const QString *file = 0);
 	/** read document from file.
 	  * "openLocked is must be set to either of these values:
 	  *  0 == open with all entries unlocked
 	  *  1 == open with all entries locked
 	  *  2 == open deep-locked
 	  */
 	PwMerror openDoc(const QString *file, int openLocked);
 	/** export document to ascii-textfile */
 	PwMerror exportToText(const QString *file);
 	/** export document to gpasman / kpasman file */
 	PwMerror exportToGpasman(const QString *file);
 	/** import document from ascii-textfile */
 	PwMerror importFromText(const QString *file, int format = -1);
 	/** import document from gpasman / kpasman file */
 	PwMerror importFromGpasman(const QString *file);
 	/** add new entry */
 	PwMerror addEntry(const QString &category, PwMDataItem *d,
 			  bool dontFlagDirty = false, bool updateMeta = true);
 	/** add new category. This function doesn't flag the document dirty! */
 	PwMerror addCategory(const QString &category, unsigned int *categoryIndex,
 			     bool checkIfExist = true);
 	/** rename an existing category */
 	bool renameCategory(const QString &category, const QString &newName);
 	/** rename an existing category */
 	bool renameCategory(unsigned int category, const QString &newName,
 			    bool dontFlagDirty = false);
 	/** delete an existing category */
 	bool delCategory(const QString &category);
 	/** delete an existing category */
 	bool delCategory(unsigned int category, bool dontFlagDirty = false);
 	/** returns a list of all category-names */
 	void getCategoryList(vector<string> *list);
 	/** returns a list of all category-names */
 	void getCategoryList(QStringList *list);
 	/** returns a list of all entry-descs in the given category */
 	void getEntryList(const QString &category, QStringList *list);
 	/** returns a list of all entry-descs in the given category */
 	void getEntryList(const QString &category, vector<string> *list);
 	/** returns a list of all entry-descs in the given category */
 	void getEntryList(unsigned int category, vector<string> *list);
 	/** returns a list of all entry-descs in the given category */
 	void getEntryList(unsigned int category, QStringList *list);
 	/** delete entry */
 	bool delEntry(const QString &category, unsigned int index, bool dontFlagDirty = false);
 	/** delete entry */
 	bool delEntry(unsigned int category, unsigned int index, bool dontFlagDirty = false);
 	/** edit entry */
 	bool editEntry(const QString &oldCategory, const QString &newCategory,
 		       unsigned int index, PwMDataItem *d, bool updateMeta = true);
 	/** edit entry */
 	bool editEntry(unsigned int oldCategory, const QString &newCategory,
 		       unsigned int index, PwMDataItem *d, bool updateMeta = true);
 	/** finds the category with the "name" and return it's index */
 	bool findCategory(const QString &name, unsigned int *index);
 	/** search for an entry "find" and check while searching only for
 	  * the data-fields specified by "searchIn". To set the "searchIn"
 	  * value, we may use one or more of the SEARCH_IN_* defines at
 	  * the top of this header-file. It returns the positions of all
 	  * matched entries in "foundPositions". If "breakAfterFound" is true,
 	  * the function terminates after the first occurence of the entry
 	  * and doesn't go on searching. So foundPositions->size() is never
 	  * > 1 if breakAfterFound is true.
 	  */
 	void findEntry(unsigned int category, PwMDataItem find, unsigned int searchIn,
 		       vector<unsigned int> *foundPositions, bool breakAfterFound = false,
 		       bool caseSensitive = true, bool exactWordMatch = true,
 		       bool sortByLvp = false);
 	/** see the above funtion. This function allows to set the category by name. */
 	void findEntry(const QString &category, PwMDataItem find, unsigned int searchIn,
 		       vector<unsigned int> *foundPositions, bool breakAfterFound = false,
 		       bool caseSensitive = true, bool exactWordMatch = true,
 		       bool sortByLvp = false);
 	/** returns number of entries */
 	unsigned int numEntries(const QString &category);
 	unsigned int numEntries(unsigned int category)
 			{ return dti.dta[category].d.size(); }
 	/** returns number of categories */
 	unsigned int numCategories()
 			{ return dti.dta.size(); }
 	/** returns the name of the category at "index" */
 	const string* getCategory(unsigned int index)
 			{ return (&(dti.dta[index].name)); }
 
 	/** returns the data of item at "index".
 	  * It unlocks the entry if it's locked and unlockIfLocked is true.
 	  * If the entry is locked, but unlockIfLocked is false, it'll not return
 	  * the pw.
 	  */
 	bool getEntry(const QString &category, unsigned int index,
 		      PwMDataItem *d, bool unlockIfLocked = false);
 	bool getEntry(unsigned int category, unsigned int index,
 		      PwMDataItem *d, bool unlockIfLocked = false);
 	/** returns the comment-string by looking at the category
 	  * and the listViewPos
 	  */
 	PwMerror getCommentByLvp(const QString &category, int listViewPos,
 				 string *foundComment);
 	/** checks if a password is already available. (currentPw) */
 	bool isPwAvailable()
 			{ return (currentPw != ""); }
 	/** un/lock entry at "index". If needed, ask for password. */
 	bool lockAt(const QString &category, unsigned int index,
 		    bool lock = true);
 	bool lockAt(unsigned int category, unsigned int index,
 		    bool lock = true);
 	/** returns the lock-status at "index" */
 	bool isLocked(const QString &category, unsigned int index);
 	bool isLocked(unsigned int category, unsigned int index)
 			{ return dti.dta[category].d[index].lockStat; }
 	/** returns the deeplock status */
 	bool isDeepLocked()
 			{ return getDocStatFlag(DOC_STAT_DEEPLOCKED); }
 	/** (un)lock all entries */
 	bool lockAll(bool lock);
 	/** unlocks all entries tempoarly.
 	  * 1st NOTE: Be very careful with this function! :)
 	  * 2nd NOTE: After you have called unlockAll_Tempoary(); ,
 	  *           please DON'T forget to call unlockAll_Tempoary(true);
 	  *           _before_ the user (or someone else) is able to change
 	  *           the document!
 	  * 3rd NOTE: Please DON'T change "dta" while the data is tempoary
 	  *           unlocked! This will cause corruption.
 	  */
 	bool unlockAll_tempoary(bool revert = false);
 	/** deep-(un)locks the document.
 	  * deep-locking writes all data to the file, deletes all data
 	  * in memory, but doesn't close the document.
 	  * deep-locking is only available, if the user previously saved
 	  * the doc to a file (with a password).
 	  * If "saveToFile" is false, it does NOT write the data to the file!
 	  */
 	PwMerror deepLock(bool lock = true, bool saveToFile = true);
 	/** is unlockable without pw? */
 	bool unlockWoPw()
 			{ return getDocStatFlag(DOC_STAT_UNLOCK_WITHOUT_PW); }
 	/** get the "currentPassword" */
 	const QString& getCurrentPw()
 			{ return currentPw; }
 	/** open a window and request the user to change the mpw */
 	void changeCurrentPw();
 	/** set the "listViewPos" variable of "dta" */
 	void setListViewPos(const QString &category, unsigned int index,
 			    int pos);
 	/** set the "listViewPos" variable of "dta" */
 	void setListViewPos(unsigned int category, unsigned int index,
 			    int pos);
 	/** get the "listViewPos" variable of "dta" */
 	int getListViewPos(const QString &category, unsigned int index);
 	/** set the maximum number of entries allowed */
 	void setMaxNumEntries(unsigned int num = DEFAULT_MAX_ENTRIES)
 			{ maxEntries = num; }
 	/** get the maximum number of entries allowed */
 	unsigned int getMaxNumEntries()
 			{ return maxEntries; }
 	/** ensure all listViewPos of all dta items are set. (are ! -1).
 	  * If there are some undefined entries, add them to the end of
 	  * the listViewPos(itions). */
 	void ensureLvp();
 	/** execute the "launcher" of this entry */
 	bool execLauncher(const QString &category, unsigned int entryIndex);
 	/** see above */
 	bool execLauncher(unsigned int category, unsigned int entryIndex);
 	/** open a browser with the URL-section of the given entry */
 	bool goToURL(const QString &category, unsigned int entryIndex);
 	/** see above */
 	bool goToURL(unsigned int category, unsigned int entryIndex);
 	/** returns true if there is no entry present in the document.
 	  * Note: The "default" Category is present everytime, so
 	  *       it's checked for it's entries.
 	  */
 	bool isDocEmpty()
 		{
 			if (numCategories() > 1)
 				return false;
 			if (numEntries(0))
 				return false;
 			return true;
 		}
 	/** returns the filename of this doc */
 	const QString& getFilename()
 			{ return filename; }
 	/** returns the title of the doc */
 	QString getTitle();
 	/** sets the list-view-pointer hold in the doc */
 	void setListViewPointer(PwMView *_listView)
 			{ listView = _listView; }
 	/** returns the list-view-pointer */
 	PwMView * getListViewPointer()
 			{ return listView; }
 	/** try to delete the doc. The user may be asked to save
 	  * the data. The user may cancel the whole operation.
 	  * false is returned, then.
 	  */
 	bool tryDelete();
 	/** is the doc deleted? (with tryDelete() ) */
 	bool isDeleted()
 			{ return deleted; }
 	/** returns the document timer object */
 	DocTimer * timer()
 			{ return _timer; }
 	/** get a lock on the dataChanged signal.
 	  * If someone is holding a lock, the signal is not emitted.
 	  */
 	void getDataChangedLock()
 			{ ++dataChangedLock; }
 	/** put the dataChanged lock */
 	void putDataChangedLock()
 			{ --dataChangedLock; }
 	/** returns the revision count of the item at cat/index */
 	unsigned int getEntryRevCnt(unsigned int category, unsigned int index)
 			{ return dti.dta[category].d[index].rev; }
 	/** returns a const pointer to the entries meta */
 	const PwMMetaData * getEntryMeta(unsigned int category, unsigned int index)
 			{ return &(dti.dta[category].d[index].meta); }
 	/** is the entry at "category" "index" a binary entry? */
 	bool isBinEntry(unsigned int category, unsigned int index)
 			{ return dti.dta[category].d[index].binary; }
 
 public slots:
 	/** wrapper for PwMTray */
 	void _deepUnlock();
 
 signals:
 	/** the data of the document has changed and must be updated
 	  * in all views.
 	  * NOTE: use emitDataChanged(PwMDoc *document) to emit this signal!
 	  */
 	void dataChanged(PwMDoc *document);
 	/** the document class is going to close. This signal may be
 	  * used to nofify all views, that the user closed the document,
 	  * so the views can go down, too.
 	  */
 	void docClosed(PwMDoc *document);
 	/** somebody just opened the document */
 	void docOpened(PwMDoc *document);
 	/** this document object just got created */
 	void docCreated(PwMDoc *document);
 
 public:
 	/** emit the dataChanged signal after checking for a lock */
 	void emitDataChanged(PwMDoc *document)
 		{
 			if (!dataChangedLock)
 				emit dataChanged(document);
 		}
 
 protected:
 	/** current file for this doc */
 	QString filename;
 //US ENH: we need a place where we keep the syncentries. So I invented
 // struct PwMItem, that has a vector of PwMCategoryItem and vector of PwMSyncItem 
 	/** holds all data */
 	PwMItem dti;
 	/** maximum number of entries */
 	unsigned int maxEntries;
 	/** currently used password to encrypt data */
 	QString currentPw;
 	/** current global document status flags */
 	unsigned int curDocStat;
 	/** browser process for goToURL() */
 	KProcess browserProc;
 	/** pointer to the list-view, using this document.
 	  * As there can only be one list-view per doc, we
 	  * don't need a list here.
 	  */
 	PwMView *listView;
 	/** unnamedNum is used to store the "unnamed counter"
 	  * for this document, while it's unnamed. If it's 0,
 	  * we have to get a new unique one.
 	  */
 	unsigned int unnamedNum;
 	/** is this doc going to be deleted (executing in destructor context) */
 	bool deleted;
 	/** document timer */
 	DocTimer *_timer;
 	/** lock counter for the "dataChanged" signal */
 	unsigned int dataChangedLock;
 
 	/** list of all open documents */
 	static PwMDocList openDocList;
 
 protected:
 	/** serialize "dta" and return it in "d". */
 	bool serializeDta(string *d);
 	/** de-serialize "d" and overwrite "dta" */
 	bool deSerializeDta(const string *d, bool entriesLocked);
 	/** write header to file */
 	PwMerror writeFileHeader(char keyHash, char dataHash, char crypt, char compress,
 				 QString *pw, QFile *f);
 	/** write data-hash to file */
 	PwMerror writeDataHash(char dataHash, string *d, QFile *f);
 	/** check header. Read header info and verify key-hash and filever.
 	  * returns length of header in "headerLength" */
 	PwMerror checkHeader(char *cryptAlgo, QString *pw, char *compress,
 			     unsigned int *headerLength, char *dataHashType,
 			     string *dataHash, QFile *f);
 	/** check the data-hash */
 	PwMerror checkDataHash(char dataHashType, const string *dataHash, const string *dataStream);
 	/** encrypt data "d" and write to "filename" */
 	PwMerror encrypt(string *d, const QString *pw, QFile *f, char algo);
 	/** read data from file beginning at "pos", decrypt and return it */
 	PwMerror decrypt(string *d, unsigned int pos, const QString *pw, char algo, QFile *f);
 	/** compress the data */
 	bool compressDta(string *d, char algo);
 	/** uncompress the data */
 	bool decompressDta(string *d, char algo);
 	/** 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