5 files changed, 70 insertions, 7 deletions

diff --git a/kabc/plugins/file/resourcefile.cpp b/kabc/plugins/file/resourcefile.cpp
index b8c32d5..6cd63fd 100644
--- a/kabc/plugins/file/resourcefile.cpp
+++ b/kabc/plugins/file/resourcefile.cpp
@@ -1,408 +1,409 @@
 /*
     This file is part of libkabc.
     Copyright (c) 2001 Cornelius Schumacher <schumacher@kde.org>
 
     This library is free software; you can redistribute it and/or
     modify it under the terms of the GNU Library General Public
     License as published by the Free Software Foundation; either
     version 2 of the License, or (at your option) any later version.
 
     This library is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
     Library General Public License for more details.
 
     You should have received a copy of the GNU Library General Public License
     along with this library; see the file COPYING.LIB.  If not, write to
     the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
     Boston, MA 02111-1307, USA.
 */
 
 /*
 Enhanced Version of the file for platform independent KDE tools.
 Copyright (c) 2004 Ulf Schenk
 
 $Id$
 */
 
 #include <sys/types.h>
 #include <sys/stat.h>
 #ifndef _WIN32_
 #include <unistd.h>
 #endif
 
 #include <qfile.h>
 #include <qfileinfo.h>
 #include <qregexp.h>
 #include <qtimer.h>
 
 #include <kapplication.h>
 #include <kconfig.h>
 #include <kdebug.h>
 #include <klocale.h>
 //US #include <ksavefile.h>
 #include <kstandarddirs.h>
 #include <kmessagebox.h>
 
 #include "formatfactory.h"
 
 #include "resource.h"
 #include "resourcefileconfig.h"
 #include "stdaddressbook.h"
 #define NO_DIRWATCH
 #include "resourcefile.h"
 #include "syncprefwidget.h"
 
 //#define ALLOW_LOCKING
 
 
 
 using namespace KABC;
 
 extern "C"
 #ifdef _WIN32_
 __declspec(dllexport)
 #else
 {
 #endif
 
 //US  void *init_kabc_file()
   void *init_microkabc_file()
   {
     return new KRES::PluginFactory<ResourceFile,ResourceFileConfig, SyncPrefWidgetContainer>();
   }
 #ifndef _WIN32_
 }
 #endif
 
 ResourceFile::ResourceFile( const KConfig *config, bool syncable )
   : Resource( config, syncable ) , mFormat( 0 )
 {
   QString fileName, formatName, default_fileName;
 
   if (syncable == true)
     default_fileName = "/home/polo/kdepim/apps/kabc/localfile.vcf";
   else
     default_fileName = StdAddressBook::fileName();
 
   KConfig *cfg = (KConfig *)config;
   if ( cfg ) {
     fileName = cfg->readEntry( "FileName", default_fileName );
     formatName = cfg->readEntry( "FileFormat", "vcard" );
   } else {
     fileName = default_fileName;
     formatName = "vcard";
   }
 
   init( fileName, formatName );
 }
 
 ResourceFile::ResourceFile( const QString &fileName, bool syncable ,
                             const QString &formatName )
   : Resource( 0, syncable )
 {
 //  qDebug("ResourceFile::ResourceFile : 3 %s, %s", fileName.latin1(), formatName.latin1());
   init( fileName, formatName );
 }
 
 void ResourceFile::init( const QString &fileName, const QString &formatName )
 {
   mFormatName = formatName;
 
   FormatFactory *factory = FormatFactory::self();
   mFormat = factory->format( mFormatName );
 
   if ( !mFormat ) {
     mFormatName = "vcard";
     mFormat = factory->format( mFormatName );
   }
 
 #ifndef NO_DIRWATCH
   connect( &mDirWatch, SIGNAL( dirty(const QString&) ), SLOT( fileChanged() ) );
   connect( &mDirWatch, SIGNAL( created(const QString&) ), SLOT( fileChanged() ) );
   connect( &mDirWatch, SIGNAL( deleted(const QString&) ), SLOT( fileChanged() ) );
 #endif
   setFileName( fileName );
 }
 
 ResourceFile::~ResourceFile()
 {
   delete mFormat;
   mFormat = 0;
 }
 
 void ResourceFile::writeConfig( KConfig *config )
 {
 
     config->setGroup( "Resource_" + identifier() );
   Resource::writeConfig( config );
 
   config->writeEntry( "FileName", mFileName );
   config->writeEntry( "FileFormat", mFormatName );
 
 //    qDebug("ResourceFile::writeConfig format %s, %s", mFileName.latin1(), mFormatName.latin1());
 
 }
 
 Ticket *ResourceFile::requestSaveTicket()
 {
   kdDebug(5700) << "ResourceFile::requestSaveTicket()" << endl;
 
   if ( !addressBook() ) return 0;
 
 #ifdef ALLOW_LOCKING
   if ( !lock( mFileName ) ) {
       qDebug("unablt to lock file ");
     return 0;
   }
 #endif
   return createTicket( this );
 }
 
 
 bool ResourceFile::doOpen()
 {
   QFile file( mFileName );
+  qDebug("ResourceFile::openfile %s ", mFileName.latin1());
 
   if ( !file.exists() ) {
     // try to create the file
     bool ok = file.open( IO_WriteOnly );
     if ( ok )
       file.close();
 
     return ok;
   } else {
     if ( !file.open( IO_ReadWrite ) )
       return false;
 
     if ( file.size() == 0 ) {
       file.close();
       return true;
     }
 
     bool ok = mFormat->checkFormat( &file );
     file.close();
 
     return ok;
   }
 }
 
 void ResourceFile::doClose()
 {
 }
 
 bool ResourceFile::load()
 {
 
-
+    qDebug("ResourceFile::loadfile %s ", mFileName.latin1());
   QFile file( mFileName );
   if ( !file.open( IO_ReadOnly ) ) {
     addressBook()->error( i18n( "Unable to open file '%1'." ).arg( mFileName ) );
     return false;
   }
 
 //    qDebug("ResourceFile::load format %s, %s", mFileName.latin1(), mFormatName.latin1());
 
   return mFormat->loadAll( addressBook(), this, &file );
 }
 
 bool ResourceFile::save( Ticket *ticket )
 {
 //  qDebug("ResourceFile::save format %s, %s", mFileName.latin1(), mFormatName.latin1());
 
 
   // create backup file
   QString extension = "_" + QString::number( QDate::currentDate().dayOfWeek() );
 
 /*US we use a simpler method to create a backupfile
 
   (void) KSaveFile::backupFile( mFileName, QString::null
   ,extension );
 
   KSaveFile saveFile( mFileName );
   bool ok = false;
   if ( saveFile.status() == 0 && saveFile.file() )
   {
     mFormat->saveAll( addressBook(), this, saveFile.file() );
     ok = saveFile.close();
   }
 */
 
 //US ToDo: write backupfile
 #ifndef NO_DIRWATCH
   mDirWatch.stopScan();
 #endif
   QFile info;
   info.setName( mFileName );
   bool ok = info.open( IO_WriteOnly );
   if ( ok ) {
     mFormat->saveAll( addressBook(), this, &info );
 
     info.close();
     ok = true;
   }
   else {
 
   }
 
   if ( !ok )
     addressBook()->error( i18n( "Unable to save file '%1'." ).arg( mFileName ) );
 #ifndef NO_DIRWATCH
   mDirWatch.startScan();
 #endif
   delete ticket;
 #ifdef ALLOW_LOCKING
   unlock( mFileName );
 #endif
 
   return ok;
 }
 
 bool ResourceFile::lock( const QString &fileName )
 {
 #ifdef ALLOW_LOCKING
 
 
   QString fn = fileName;
 
 //US change the implementation how the lockfilename is getting created
 //US  fn.replace( QRegExp("/"), "_" );
 //US  QString lockName = locateLocal( "data", "kabc/lock/" + fn + ".lock" );
 
   KURL url(fn);
   QString lockName = locateLocal( "data", "kabc/lock/" + url.fileName() + ".lock" );
 
 
 
   if (QFile::exists( lockName )) return false;
 
   QString lockUniqueName;
   lockUniqueName = fn + KApplication::randomString( 8 );
 
   url = lockUniqueName;
 //US  mLockUniqueName = locateLocal( "data", "kabc/lock/" + lockUniqueName );
   mLockUniqueName = locateLocal( "data", "kabc/lock/" + url.fileName() );
   kdDebug(5700) << "-- lock unique name: " << mLockUniqueName << endl;
 
   // Create unique file
   QFile file( mLockUniqueName );
   file.open( IO_WriteOnly );
   file.close();
 
   // Create lock file
   int result = 0;
 #ifndef _WIN32_
    result = ::link( QFile::encodeName( mLockUniqueName ),
                        QFile::encodeName( lockName ) );
 #endif
   if ( result == 0 ) {
     addressBook()->emitAddressBookLocked();
     return true;
   }
 
   // TODO: check stat
 
   return false;
 #else
   return true;
 #endif
 }
 
 void ResourceFile::unlock( const QString &fileName )
 {
 #ifdef ALLOW_LOCKING
   QString fn = fileName;
 //US change the implementation how the lockfilename is getting created
 //US  fn.replace( QRegExp( "/" ), "_" );
 //US  QString lockName = locateLocal( "data", "kabc/lock/" + fn + ".lock" );
 //US  QString lockName = fn + ".lock";
   KURL url(fn);
   QString lockName = locateLocal( "data", "kabc/lock/" + url.fileName() + ".lock" );
 
   QFile::remove( lockName );
   QFile::remove( mLockUniqueName );
   addressBook()->emitAddressBookUnlocked();
 #else
   return;
 #endif
 }
 
 void ResourceFile::setFileName( const QString &fileName )
 {
 #ifndef NO_DIRWATCH
   mDirWatch.stopScan();
   mDirWatch.removeFile( mFileName );
   mFileName = fileName;
 
 
   mDirWatch.addFile( mFileName );
   mDirWatch.startScan();
 #else
   mFileName = fileName;
 #endif
 
 //US simulate KDirWatch event
 //US  fileChanged();
 }
 
 QString ResourceFile::fileName() const
 {
   return mFileName;
 }
 
 void ResourceFile::setFormat( const QString &format )
 {
   mFormatName = format;
   delete mFormat;
 
   FormatFactory *factory = FormatFactory::self();
   mFormat = factory->format( mFormatName );
 /*US
 //qDebug("ResourceFile::setFormat initialized with format %s ", format.latin1());
   if (mFormatName == "vcard") {
     mFormat = new VCardFormatPlugin2();
 //    qDebug("ResourceFile::setFormat format %s", mFormatName.latin1());
   }
   else if (mFormatName == "binary") {
     mFormat = new BinaryFormat();
 //    qDebug("ResourceFile::setFormat format %s", mFormatName.latin1());
   }
   else
     qDebug("ResourceFile::setFormat format unknown !!! %s ", format.latin1());
 */
 
 }
 
 QString ResourceFile::format() const
 {
   return mFormatName;
 }
 
 void ResourceFile::fileChanged()
 {
   // There is a small theoretical chance that KDirWatch calls us before
   // we are fully constructed
   if (!addressBook())
     return;
 
 
   QString text( i18n( "File resource '%1'<br> has been changed by third party.<br>Do you want to reload?").arg( mFileName ) );
   if ( readOnly() || KMessageBox::questionYesNo( 0, text ) == KMessageBox::Yes ) {
     load();
     addressBook()->emitAddressBookChanged();
   }
 }
 
 void ResourceFile::removeAddressee( const Addressee &addr )
 {
   QFile::remove( QFile::encodeName( locateLocal( "data", "kabc/photos/" ) + addr.uid() ) );
   QFile::remove( QFile::encodeName( locateLocal( "data", "kabc/logos/" ) + addr.uid() ) );
   QFile::remove( QFile::encodeName( locateLocal( "data", "kabc/sounds/" ) + addr.uid() ) );
 }
 
 void ResourceFile::cleanUp()
 {
   unlock( mFileName );
 }
 
 //US #include "resourcefile.moc"
diff --git a/kabc/plugins/sharpdtm/resourcesharpdtm.cpp b/kabc/plugins/sharpdtm/resourcesharpdtm.cpp
index 48d3985..437bda8 100644
--- a/kabc/plugins/sharpdtm/resourcesharpdtm.cpp
+++ b/kabc/plugins/sharpdtm/resourcesharpdtm.cpp
@@ -1,400 +1,442 @@
 /*
     This file is part of libkabc.
     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.
 */
 
 /*
 Enhanced Version of the file for platform independent KDE tools.
 Copyright (c) 2004 Ulf Schenk
 
 $Id$
 */
 
 #include <sys/types.h>
 #include <sys/stat.h>
 #include <unistd.h>
 
 #include <qdir.h>
 #include <qfile.h>
 #include <qfileinfo.h>
 #include <qregexp.h>
 //US #include <qtimer.h>
 
 #include <kapplication.h>
 #include <kconfig.h>
 #include <kdebug.h>
 #include <klocale.h>
 //US #include <ksavefile.h>
 #include <kstandarddirs.h>
 #include <kmessagebox.h>
 
 #include <sl/slzdb.h>
 
 #include <libkdepim/ksyncprofile.h>
 
 #include "resourcesharpdtmconfig.h"
 #include "resourcesharpdtm.h"
 
 #include "syncprefwidget.h"
 
 #include "stdaddressbook.h"
 
 #include "sharpdtmconverter.h"
 //#define ALLOW_LOCKING
 using namespace KABC;
 extern "C"
 {
   void *init_microkabc_sharpdtm()
   {
     return new KRES::PluginFactory<ResourceSharpDTM,ResourceSharpDTMConfig,SyncPrefWidgetContainer>();
   }
 }
 
 ResourceSharpDTM::ResourceSharpDTM( const KConfig *config, bool syncable  )
   : Resource( config, syncable ), mConverter (0)
 {
   // we can not choose the filename. Therefore use the default to display
 
   QString fileName = SlZDataBase::addressbookFileName();
   init( fileName );
 }
 
 ResourceSharpDTM::ResourceSharpDTM( const QString &fileName, bool syncable  )
   : Resource( 0, syncable )
 {
   init( fileName );
 }
 
 void ResourceSharpDTM::init( const QString &fileName )
 {
 
   connect( &mDirWatch, SIGNAL( dirty(const QString&) ), SLOT( fileChanged() ) );
   connect( &mDirWatch, SIGNAL( created(const QString&) ), SLOT( fileChanged() ) );
   connect( &mDirWatch, SIGNAL( deleted(const QString&) ), SLOT( fileChanged() ) );
 
   setFileName( fileName );
 }
 
 ResourceSharpDTM::~ResourceSharpDTM()
 {
   if (mConverter != 0)
     delete mConverter;
 
   if(mAccess != 0)
     delete mAccess;
 }
 
 void ResourceSharpDTM::writeConfig( KConfig *config )
 {
   Resource::writeConfig( config );
 }
 
 Ticket *ResourceSharpDTM::requestSaveTicket()
 {
  
 
   qDebug("ResourceSharpDTM::requestSaveTicket: %s", fileName().latin1());
 
   if ( !addressBook() ) return 0;
 
 #ifdef ALLOW_LOCKING
   if ( !lock( fileName() ) ) {
       qDebug("ResourceSharpDTM::requestSaveTicket(): Unable to lock file ");
     return 0;
   }
 #endif
   return createTicket( this );
 }
 
 
 bool ResourceSharpDTM::doOpen()
 {
   qDebug("ResourceSharpDTM::doOpen: %s", fileName().latin1());
 
   // the last parameter in the SlZDataBase constructor means "readonly"
   mAccess = new SlZDataBase(fileName(),
                         SlZDataBase::addressbookItems(),
                         NULL, false);
 
   if ( !mAccess ) {
     qDebug("Unable to load file() %s", fileName().latin1());
     return false;
   }
 
   if (mConverter == 0)
   {
     mConverter = new SharpDTMConverter();
     bool res = mConverter->init(); 
     if ( !res )
     {
           QString msg("Unable to initialize sharp converter. Most likely a problem with the category file");
 
       qDebug(msg);
       delete mAccess;
       mAccess = 0;
       return false;
     }
   }
 
  return true;
 }
 
 void ResourceSharpDTM::doClose()
 {
   qDebug("ResourceSharpDTM::doClose: %s", fileName().latin1());
 
   if(mAccess)
   {
     delete mAccess;
     mAccess = 0;
   }
   // it seems so, that deletion of access deletes backend as well
   //delete backend;
 
   return;
 }
 
 bool ResourceSharpDTM::load()
 {
   qDebug("ResourceSharpDTM::load: %s", fileName().latin1());
 
   bool res = false;
 
   CardId id;
 
   for (bool res=mAccess->first(); res == true; res=mAccess->next())
   {
     id = mAccess->cardId();
 
     KABC::Addressee addressee;
 
     res = mConverter->sharpToAddressee( id, mAccess, addressee );
 
     if ( !addressee.isEmpty() && res )
     {
       addressee.setResource( this );
       addressBook()->insertAddressee( addressee );
     }
   }
 
   return true;
 }
 
 bool ResourceSharpDTM::save( Ticket *ticket )
 {
   qDebug("ResourceSharpDTM::save: %s", fileName().latin1());
 
   mDirWatch.stopScan();
 
   KABC::AddressBook::Iterator it;
   bool res;
   KABC::Addressee::List changedAddressees;
+  typedef QMap<int,QString> AddresseeMap;
+  AddresseeMap map;
+  CardId id ;
 
   for ( it = addressBook()->begin(); it != addressBook()->end(); ++it ) {
 
       if ( (*it).tempSyncStat() != SYNC_TEMPSTATE_NEW_EXTERNAL ) {
           QString uid = (*it).originalExternalUID();
-          CardId id ;
           bool res;
           if ( uid.isEmpty() )
               id = 0;
           else
               id = uid.toUInt();
           KABC::Addressee addressee = (*it);
           if ( (*it).tempSyncStat() == SYNC_TEMPSTATE_ADDED_EXTERNAL ) {
               res = mAccess->startEditCard(id);
               if (res == true)
                   {
                       res = mConverter->addresseeToSharp( (*it), mAccess, id  );
                       if (res == true)
                           {
+                              res = mAccess->finishEditCard(&id);
+                              //(*it).setTempSyncStat( SYNC_TEMPSTATE_NEW_ID );
+                              //(*it).setExternalUID( QString::number( id ) );
+                              //(*it).setOriginalExternalUID( QString::number( id ) ); 
+                              map.insert(id,(*it).uid());
+
+#if 0
                               KABC::Addressee addressee;
                               res = mConverter->sharpToAddressee( id, mAccess, addressee );
                               addressee.setUid((*it).uid() );
-                              addressee.setTempSyncStat( SYNC_TEMPSTATE_NEW_ID );
+                              (it*).setTempSyncStat( SYNC_TEMPSTATE_NEW_ID );
                               res = mAccess->finishEditCard(&id);
                               //qDebug("2NEW id is %d", id);
                               addressee.setExternalUID( QString::number( id ) );
                               addressee.setOriginalExternalUID( QString::number( id ) ); 
                               changedAddressees.append( addressee );
+#endif
                               
                               if (res == false)
                                   qDebug("Unable to append Contact: %s", addressee.formattedName().latin1());
                              
                           }
                       else
                           {
                               qDebug("Unable to convert Addressee: %s", addressee.formattedName().latin1());
                               mAccess->cancelEditCard();
                           }
                   }
 
           } else if ( (*it).tempSyncStat() == SYNC_TEMPSTATE_DELETE ) {
               res = mAccess->deleteCard(&id);
               if ( res ) 
                   qDebug("delete success ");
               else
                   qDebug("delete error ");
 
 
           } else if ( (*it).tempSyncStat() != SYNC_TEMPSTATE_NEW_EXTERNAL ) {
               //changed
               qDebug("changed ****");
               res = mAccess->startEditCard(id);
               if (res == true)
                   {
                       res = mConverter->addresseeToSharp( (*it), mAccess, id  );
                       if (res == true)
                           {
+                              res = mAccess->finishEditCard(&id);
+                              //(*it).setTempSyncStat( SYNC_TEMPSTATE_NEW_CSUM );
+                              map.insert(id,(*it).uid());
+
+#if 0
                               KABC::Addressee addressee;
                               res = mConverter->sharpToAddressee( id, mAccess, addressee );
                               addressee.setUid((*it).uid() );
                               addressee.setTempSyncStat( SYNC_TEMPSTATE_NEW_CSUM );
                               changedAddressees.append( addressee );
                               res = mAccess->finishEditCard(&id);
+#endif
                               if (res == false)
                                   qDebug("Unable to append Contact: %s", addressee.formattedName().latin1());
                               
                           }
                       else
                           {
                               qDebug("Unable to convert Addressee: %s", addressee.formattedName().latin1());
                               mAccess->cancelEditCard();
                           }
                   }
           }
       }
 
   }
+  AddresseeMap::Iterator itam;
+  res;
+  for ( res=mAccess->first(); res == true; res=mAccess->next())
+      {
+          id = mAccess->cardId();
+          int idint = id;
+          itam = map.find( idint );
+          if ( itam != map.end() ) {
+              KABC::Addressee addressee;
+              qDebug("found change %d %s ", idint, itam.data().latin1());
+              res = mConverter->sharpToAddressee( id, mAccess, addressee );
+
+              if ( !addressee.isEmpty() && res )
+                  {
+                      addressee.setResource( this ); 
+                      addressee.setUid( itam.data() );
+                      addressee.setTempSyncStat( SYNC_TEMPSTATE_NEW_ID );
+                      addressBook()->insertAddressee( addressee , false );
+                  }
+          }
+      }
+#if 0
   KABC::Addressee::List::Iterator it2;
-  for ( it2 = changedAddressees.begin(); it2 != changedAddressees.end(); ++it2 )
+  for ( it2 = changedAddressees.begin(); it2 != changedAddressees.end(); ++it2 ) {
+      (*it2).computeCsum( "Sharp_DTM" );
+      qDebug("CSUM: %s ",(*it2).getCsum( "Sharp_DTM" ).latin1() );
       addressBook()->insertAddressee((*it2));
+  }
+#endif
   //US  mAccess->save();
 
   mDirWatch.startScan();
   delete ticket;
   unlock( fileName() );
 
   return true;
 }
 
 bool ResourceSharpDTM::lock( const QString &lockfileName )
 {
 #ifdef ALLOW_LOCKING
   qDebug("ResourceSharpDTM::lock: %s", fileName().latin1());
 
   kdDebug(5700) << "ResourceSharpDTM::lock()" << endl;
 
   QString fn = lockfileName;
 
   KURL url(fn);
   QString lockName = locateLocal( "data", "kabc/lock/" + url.fileName() + ".lock" );
 
   kdDebug(5700) << "-- lock name: " << lockName << endl;
 
   if (QFile::exists( lockName ))
   {
     qDebug("ResourceSharpDTM::lock: lockfile %s already exists. (Delete it before continuing if nobody else is accessing the resourcefile %s)", lockName.latin1(), fileName());
     return false;
   }
 
 
   QString lockUniqueName;
   lockUniqueName = fn + KApplication::randomString( 8 );
 
   url = lockUniqueName;
 //US  mLockUniqueName = locateLocal( "data", "kabc/lock/" + lockUniqueName );
   mLockUniqueName = locateLocal( "data", "kabc/lock/" + url.fileName() );
   kdDebug(5700) << "-- lock unique name: " << mLockUniqueName << endl;
 
   // Create unique file
   QFile file( mLockUniqueName );
   file.open( IO_WriteOnly );
   file.close();
 
   // Create lock file
   int result = 0;
 #ifndef _WIN32_
   result = ::link( QFile::encodeName( mLockUniqueName ),
                        QFile::encodeName( lockName ) );
 #endif
   if ( result == 0 ) {
     addressBook()->emitAddressBookLocked();
     return true;
   }
 
   // TODO: check stat
 
   return false;
 #else
   return true;
 #endif 
 }
 
 void ResourceSharpDTM::unlock( const QString &fileName )
 {
 #ifdef ALLOW_LOCKING
   qDebug("ResourceSharpDTM::unlock() %s", fileName.latin1());
 
   QString fn = fileName;
   KURL url(fn);
   QString lockName = locateLocal( "data", "kabc/lock/" + url.fileName() + ".lock" );
 
   QFile::remove( lockName );
   QFile::remove( mLockUniqueName );
   addressBook()->emitAddressBookUnlocked();
 #endif 
 }
 
 void ResourceSharpDTM::setFileName( const QString &newFileName )
 {
   mDirWatch.stopScan();
   mDirWatch.removeFile( fileName() );
 
   Resource::setFileName( newFileName );
 
   mDirWatch.addFile( fileName() );
   mDirWatch.startScan();
 
 }
 
 void ResourceSharpDTM::fileChanged()
 {
   // There is a small theoretical chance that KDirWatch calls us before
   // we are fully constructed
   if (!addressBook())
     return;
 
   QString text( i18n( "Sharp DTM resource '%1'<br> has been changed by third party.<br>Do you want to reload?").arg( fileName() ) );
   if ( readOnly() || KMessageBox::questionYesNo( 0, text ) == KMessageBox::Yes ) {
     load();
     addressBook()->emitAddressBookChanged();
   }
 }
 
 void ResourceSharpDTM::removeAddressee( const Addressee &addr )
 {
 }
 
 void ResourceSharpDTM::cleanUp()
 {
   unlock( fileName() );
 }
 
 
 
diff --git a/kabc/plugins/sharpdtm/sharpdtmconverter.cpp b/kabc/plugins/sharpdtm/sharpdtmconverter.cpp
index f3bf2c5..fccf625 100644
--- a/kabc/plugins/sharpdtm/sharpdtmconverter.cpp
+++ b/kabc/plugins/sharpdtm/sharpdtmconverter.cpp
@@ -1,431 +1,442 @@
 /*
     This file is part of libkabc.
     Copyright (c) 2002 Tobias Koenig <tokoe@kde.org>
 
     This library is free software; you can redistribute it and/or
     modify it under the terms of the GNU Library General Public
     License as published by the Free Software Foundation; either
     version 2 of the License, or (at your option) any later version.
 
     This library is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
     Library General Public License for more details.
 
     You should have received a copy of the GNU Library General Public License
     along with this library; see the file COPYING.LIB.  If not, write to
     the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
     Boston, MA 02111-1307, USA.
 */
 
 /*
 Enhanced Version of the file for platform independent KDE tools.
 Copyright (c) 2004 Ulf Schenk
 
 $Id$
 */
 
 #include "kglobal.h"
 #include <qregexp.h>
 
 
 #include "sharpdtmconverter.h"
 
 #include <sl/slcategories.h>
 #include <libkdepim/ksyncprofile.h>
 //US #include <qpe/categoryselect.h>
 
 
 using namespace KABC;
 using namespace SlCategory;
 
 SharpDTMConverter::SharpDTMConverter() : catDB(0)
 {
 }
 
 SharpDTMConverter::~SharpDTMConverter()
 {
   deinit();
 }
 
 bool SharpDTMConverter::init()
 {
   catDB = new SlCategory::SlCategories();
 
   if (!catDB)
     return false;
 
 //  catDB->load( categoryFileName() );
   return true;
 }
 
 void SharpDTMConverter::deinit()
 {
   if (catDB)
   {
     delete catDB;
     catDB = 0;
   }
 }
 
 bool SharpDTMConverter::sharpToAddressee( const CardId &contact, const SlZDataBase* database, Addressee &addr )
 {
         SlZDataBase* db = (SlZDataBase*)database;
 
     // for syncing: we need setting of the two fields
     addr.setExternalUID( QString::number( contact ) );
     addr.setOriginalExternalUID( QString::number( contact ) ); 
     addr.setTempSyncStat(  SYNC_TEMPSTATE_NEW_EXTERNAL );
 
 
     // name
     //qDebug("SharpDTMConverter::sharpToAddressee check if the fileAs transformation works!!");
     addr.setFormattedName(db->readField(ZdbAdrs::FileAs)); // needs fix
 
     addr.setFamilyName( db->readField(ZdbAdrs::LastName) );
     addr.setGivenName( db->readField(ZdbAdrs::FirstName) );
     addr.setAdditionalName( db->readField(ZdbAdrs::MiddleName) );
     addr.setPrefix( db->readField(ZdbAdrs::Title) );
     addr.setSuffix( db->readField(ZdbAdrs::Suffix) );
 
 
     QString emailstr = db->readField(ZdbAdrs::Emails);
     emailstr.replace( QRegExp(","), " " ); 
     emailstr.replace( QRegExp(";"), " " ); 
     emailstr.replace( QRegExp(":"), " " ); 
     //qDebug("SharpDTMConverter::sharpToAddressee whats the character to seperate the emailadresses? %s ", emailstr.latin1());
     QStringList emails = QStringList::split(" ", emailstr.simplifyWhiteSpace());
     bool defE = false;
     bool found = false;
     for ( QStringList::Iterator it = emails.begin(); it != emails.end(); ++it ) {
         if (found )
             defE = false;
         else
             found = defE = ((*it).lower() == db->readField(ZdbAdrs::DefaultEmail).lower());
       addr.insertEmail( *it, defE );
     }
     if ( ! found )
         if (!db->readField(ZdbAdrs::DefaultEmail).isEmpty())
             addr.insertEmail(db->readField(ZdbAdrs::DefaultEmail), true);
 
     // home
     if ((!db->readField(ZdbAdrs::HomeStreet).isEmpty()) ||
         (!db->readField(ZdbAdrs::HomeCity).isEmpty()) ||
         (!db->readField(ZdbAdrs::HomeState).isEmpty()) ||
         (!db->readField(ZdbAdrs::HomeZip).isEmpty()) ||
         (!db->readField(ZdbAdrs::HomeCountry).isEmpty()))
     {
       Address homeaddress;
       homeaddress.setType(Address::Home);
 //US    homeaddress.setPostOfficeBox( "" );
 //US    homeaddress.setExtended( "" );
       homeaddress.setStreet( db->readField(ZdbAdrs::HomeStreet) );
       homeaddress.setLocality( db->readField(ZdbAdrs::HomeCity) );
       homeaddress.setRegion( db->readField(ZdbAdrs::HomeState) );
       homeaddress.setPostalCode( db->readField(ZdbAdrs::HomeZip) );
       homeaddress.setCountry( db->readField(ZdbAdrs::HomeCountry) );
 
       addr.insertAddress( homeaddress );
     }
 
     if (!db->readField(ZdbAdrs::HomePhone).isEmpty())
     {
       PhoneNumber homephone;
       homephone.setType( PhoneNumber::Home );
       homephone.setNumber( db->readField(ZdbAdrs::HomePhone) );
       addr.insertPhoneNumber( homephone );
     }
 
     if (!db->readField(ZdbAdrs::HomeFax).isEmpty())
     {
       PhoneNumber homefax;
       homefax.setType( PhoneNumber::Home | PhoneNumber::Fax );
       homefax.setNumber( db->readField(ZdbAdrs::HomeFax) );
       addr.insertPhoneNumber( homefax );
     }
 
     if (!db->readField(ZdbAdrs::HomeMobile).isEmpty())
     {
       PhoneNumber homemobile;
       homemobile.setType( PhoneNumber::Home | PhoneNumber::Cell );
       homemobile.setNumber( db->readField(ZdbAdrs::HomeMobile) );
       addr.insertPhoneNumber( homemobile );
     }
 
     addr.setUrl( db->readField(ZdbAdrs::HomeWebPage) );
 
 
     // business
     if ((!db->readField(ZdbAdrs::BusinessStreet).isEmpty()) ||
         (!db->readField(ZdbAdrs::BusinessCity).isEmpty()) ||
         (!db->readField(ZdbAdrs::BusinessState).isEmpty()) ||
         (!db->readField(ZdbAdrs::BusinessZip).isEmpty()) ||
         (!db->readField(ZdbAdrs::BusinessCountry).isEmpty()))
     {
       Address businessaddress;
       businessaddress.setType(Address::Work);
 //US    businessaddress.setPostOfficeBox( "" );
 //US    businessaddress.setExtended( "" );
       businessaddress.setStreet( db->readField(ZdbAdrs::BusinessStreet) );
       businessaddress.setLocality( db->readField(ZdbAdrs::BusinessCity) );
       businessaddress.setRegion( db->readField(ZdbAdrs::BusinessState) );
       businessaddress.setPostalCode( db->readField(ZdbAdrs::BusinessZip) );
       businessaddress.setCountry( db->readField(ZdbAdrs::BusinessCountry) );
 
       addr.insertAddress( businessaddress );
     }
 
 
     if (!db->readField(ZdbAdrs::BusinessPhone).isEmpty())
     {
       PhoneNumber businessphone;
       businessphone.setType( PhoneNumber::Work );
       businessphone.setNumber( db->readField(ZdbAdrs::BusinessPhone) );
       addr.insertPhoneNumber( businessphone );
     }
 
     if (!db->readField(ZdbAdrs::BusinessFax).isEmpty())
     {
       PhoneNumber businessfax;
       businessfax.setType( PhoneNumber::Work | PhoneNumber::Fax );
       businessfax.setNumber( db->readField(ZdbAdrs::BusinessFax) );
       addr.insertPhoneNumber( businessfax );
     }
 
     if (!db->readField(ZdbAdrs::BusinessMobile).isEmpty())
     {
       PhoneNumber businessmobile;
       businessmobile.setType( PhoneNumber::Work | PhoneNumber::Cell );
       businessmobile.setNumber( db->readField(ZdbAdrs::BusinessMobile) );
       addr.insertPhoneNumber( businessmobile );
     }
 
     if (!db->readField(ZdbAdrs::BusinessPager).isEmpty())
     {
       PhoneNumber businesspager;
       businesspager.setType( PhoneNumber::Work | PhoneNumber::Pager );
       businesspager.setNumber( db->readField(ZdbAdrs::BusinessPager) );
       addr.insertPhoneNumber( businesspager );
     }
 
     addr.setRole( db->readField(ZdbAdrs::JobTitle) );
     addr.setOrganization( db->readField(ZdbAdrs::Company) );
     addr.insertCustom( "KADDRESSBOOK", "X-Profession", db->readField(ZdbAdrs::Profession) );
     addr.insertCustom( "KADDRESSBOOK", "X-AssistantsName", db->readField(ZdbAdrs::Assistant) );
     addr.insertCustom( "KADDRESSBOOK", "X-Department", db->readField(ZdbAdrs::Department) );
     addr.insertCustom( "KADDRESSBOOK", "X-ManagersName", db->readField(ZdbAdrs::Manager) );
     addr.insertCustom( "KADDRESSBOOK", "X-Office", db->readField(ZdbAdrs::Office) );
 
     //personal
     addr.insertCustom( "KADDRESSBOOK", "X-SpousesName", db->readField(ZdbAdrs::Spouse) );
 
         QString gen = db->readField(ZdbAdrs::Gender);
         //qDebug("SharpDTMConverter::sharpToAddressee pleas check that gender works!! : Gender: %s", gen.latin1());
         //qDebug("SharpDTMConverter::sharpToAddressee: may be int db->readUshortField(\"ZdbAdrs::Gender\") is here better suited");
 
     if (gen == "male")
       addr.insertCustom( "KADDRESSBOOK", "X-Gender", "male");
     else if (gen == "female")
       addr.insertCustom( "KADDRESSBOOK", "X-Gender", "female");
 
 
     QDate ann = KGlobal::locale()->readDate( db->readField(ZdbAdrs::Anniversary) ); 
     if (ann.isValid()) {
       QString dt = KGlobal::locale()->formatDate(ann, true, KLocale::ISODate);
       //qDebug("qtopiaToAddressee annyversary found:%s", dt.latin1());
       addr.insertCustom( "KADDRESSBOOK", "X-Anniversary", dt);
     }
   
 
     addr.insertCustom( "KADDRESSBOOK", "X-Children", db->readField(ZdbAdrs::Children) );
 
 
     QDate birthd = KGlobal::locale()->readDate( db->readField(ZdbAdrs::Birthday) );
     //qDebug("birtd %s ", birthd.toString().latin1());
     if (birthd.isValid())
       addr.setBirthday( birthd );
 
     addr.setNickName( db->readField(ZdbAdrs::Nickname) );
 
     // others
     //US I put opies BusinessWebPage into Ka/Pi's notes block, because no other native field is available.
     QString notes = db->readField(ZdbAdrs::Notes);
     //notes += "\nBusinessWebPage: " + db->readField(ZdbAdrs::BusinessWebPage) + "\n";
     if ( addr.url().isEmpty() )
         addr.setUrl( db->readField(ZdbAdrs::BusinessWebPage) );
     addr.setNote( db->readField(ZdbAdrs::Notes) );
 
 
 
 //US    QString groups() const { return find( Qtopia::Groups ); }
 //US    QStringList groupList() const;
 
         //qDebug("SharpDTMConverter::sharpToAddressee please check that the categories will be converted" );
     QArray<int> catArray = db->readCategories();
     QString cat;
 
     for ( unsigned int i=0; i < catArray.size(); i++ ) {
       cat = catDB->label(catArray[i]);
       if ( cat.isEmpty() )
         addr.insertCategory(QString::number(catArray[i]));
       else
         addr.insertCategory( cat );
     }
 
     return true;
 }
 
 bool SharpDTMConverter::addresseeToSharp( const Addressee &addr, SlZDataBase* database , const CardId &contact )
 {
     bool cellHome = false, cellWork = false;
     // name
     database->writeField(ZdbAdrs::LastName, addr.familyName());
     database->writeField(ZdbAdrs::FirstName, addr.givenName());
     database->writeField(ZdbAdrs::MiddleName, addr.additionalName());
     database->writeField(ZdbAdrs::Title, addr.prefix());
     database->writeField(ZdbAdrs::Suffix, addr.suffix());
 
     //qDebug("SharpDTMConverter::addresseeToSharp check if the fileAs transformation works!!\n%s",addr.formattedName().latin1() );
-    database->writeField(ZdbAdrs::FileAs, addr.formattedName());
-    database->writeField(ZdbAdrs::FullName, addr.formattedName());
+    QString formattedName = addr.formattedName();
+    if ( formattedName.isEmpty() ) {
+        if ( !addr.familyName().isEmpty() ) {
+            formattedName = addr.familyName();
+            if ( !addr.givenName().isEmpty() ) {
+                formattedName += ", ";
+                formattedName += addr.givenName();
+            }
+        } else
+            formattedName = addr.givenName();
+    }
+    database->writeField(ZdbAdrs::FileAs, formattedName);
+    database->writeField(ZdbAdrs::FullName, formattedName);
 
     // email
     //qDebug("SharpDTMConverter::addresseeToSharp check which seperator we need here for the emails!!");
     //qDebug("SharpDTMConverter::addresseeToSharp its probably the same from sharpToAddressee");
     QString emails = addr.emails().join(" ");
     database->writeField(ZdbAdrs::Emails, emails );
 
     database->writeField(ZdbAdrs::DefaultEmail, addr.preferredEmail() );
 
 
     // home
     const Address homeaddress = addr.address(Address::Home);
     if (!homeaddress.isEmpty()) {
       database->writeField(ZdbAdrs::HomeStreet, homeaddress.street());
       database->writeField(ZdbAdrs::HomeCity, homeaddress.locality());
       database->writeField(ZdbAdrs::HomeState, homeaddress.region());
       database->writeField(ZdbAdrs::HomeZip, homeaddress.postalCode());
       database->writeField(ZdbAdrs::HomeCountry, homeaddress.country());
     }
 
     PhoneNumber homephone = addr.phoneNumber( PhoneNumber::Home );
     if (!homephone.number().isEmpty())
       database->writeField(ZdbAdrs::HomePhone, homephone.number());
 
     PhoneNumber homefax = addr.phoneNumber( PhoneNumber::Home | PhoneNumber::Fax );
     if (!homefax.number().isEmpty())
       database->writeField(ZdbAdrs::HomeFax, homefax.number());
 
     PhoneNumber homemobile = addr.phoneNumber( PhoneNumber::Home | PhoneNumber::Cell );
     if (!homemobile.number().isEmpty()) {
       database->writeField(ZdbAdrs::HomeMobile, homemobile.number());
       cellHome = true;
     }
 
     database->writeField(ZdbAdrs::HomeWebPage, addr.url().url());
 
 
     // business
     const Address businessaddress = addr.address(Address::Work);
     if (!businessaddress.isEmpty()) {
       database->writeField(ZdbAdrs::BusinessStreet, businessaddress.street());
       database->writeField(ZdbAdrs::BusinessCity, businessaddress.locality());
       database->writeField(ZdbAdrs::BusinessState, businessaddress.region());
       database->writeField(ZdbAdrs::BusinessZip, businessaddress.postalCode());
       database->writeField(ZdbAdrs::BusinessCountry, businessaddress.country());
     }
 
     PhoneNumber businessphone = addr.phoneNumber( PhoneNumber::Work );
     if (!businessphone.number().isEmpty())
       database->writeField(ZdbAdrs::BusinessPhone, businessphone.number());
 
     PhoneNumber businessfax = addr.phoneNumber( PhoneNumber::Work | PhoneNumber::Fax );
     if (!businessfax.number().isEmpty())
       database->writeField(ZdbAdrs::BusinessFax, businessfax.number());
 
     PhoneNumber businessmobile = addr.phoneNumber( PhoneNumber::Work | PhoneNumber::Cell );
     if (!businessmobile.number().isEmpty()) {
         cellWork = true;
         database->writeField(ZdbAdrs::BusinessMobile, businessmobile.number());
     }
     PhoneNumber mobile = addr.phoneNumber( PhoneNumber::Cell );
-    if (!businessmobile.number().isEmpty()) {
+    if (! mobile.number().isEmpty()) {
         if ( ! cellHome ) 
             database->writeField(ZdbAdrs::HomeMobile, mobile.number());
         else if (! cellWork )
             database->writeField(ZdbAdrs::BusinessMobile, mobile.number());
     }
 
     PhoneNumber businesspager = addr.phoneNumber( PhoneNumber::Work | PhoneNumber::Pager );
     if (!businesspager.number().isEmpty())
       database->writeField(ZdbAdrs::BusinessPager, businesspager.number());
 
     database->writeField(ZdbAdrs::JobTitle, addr.role());
     database->writeField(ZdbAdrs::Company, addr.organization());
 
     database->writeField(ZdbAdrs::Profession, addr.custom( "KADDRESSBOOK", "X-Profession" ));
     database->writeField(ZdbAdrs::Assistant, addr.custom( "KADDRESSBOOK", "X-AssistantsName" ));
     database->writeField(ZdbAdrs::Department, addr.custom( "KADDRESSBOOK", "X-Department" ));
     database->writeField(ZdbAdrs::Manager, addr.custom( "KADDRESSBOOK", "X-ManagersName" ));
     database->writeField(ZdbAdrs::Office, addr.custom( "KADDRESSBOOK", "X-Office" ));
 
     //personal
     database->writeField(ZdbAdrs::Spouse, addr.custom( "KADDRESSBOOK", "X-Spouse" ));
 
     QString gt = addr.custom( "KADDRESSBOOK", "X-Gender" );
         //qDebug("SharpDTMConverter::addresseeToSharp please check that gender works!! : Gender: %s", gt.latin1());
         //qDebug("SharpDTMConverter::addresseeToSharp: may be writeField(\"ZdbAdrs::Gender\", ushort) is here better suited?");
         //qDebug("SharpDTMConverter::addresseeToSharp: check also the reverse functionality in sharpToAddressee");
     if (gt == "male")
       database->writeField(ZdbAdrs::Gender, "male");
     else if (gt == "female")
       database->writeField(ZdbAdrs::Gender, "female");
     else
       database->writeField(ZdbAdrs::Gender, "");
 
 
     QDate dt = KGlobal::locale()->readDate(
             addr.custom("KADDRESSBOOK", "X-Anniversary" ), "%Y-%m-%d"); // = Qt::ISODate
     if ( dt.isValid() ) {
         QString dateS =  KGlobal::locale()->formatDate(dt, true  );
         database->writeField(ZdbAdrs::Anniversary, dateS );
     }
     database->writeField(ZdbAdrs::Children, addr.custom( "KADDRESSBOOK", "X-Children" ));
     dt = addr.birthday().date();
     if ( dt.isValid() ) {
         QString dateS =  KGlobal::locale()->formatDate(dt, true );
         database->writeField(ZdbAdrs::Birthday, dateS);
     }
     database->writeField(ZdbAdrs::Nickname, addr.nickName());
 
     // other
     database->writeField(ZdbAdrs::Notes, addr.note());
 
 //US    QString groups() const { return find( Qtopia::Groups ); }
 //US    QStringList groupList() const;
 
 
         //qDebug("SharpDTMConverter::addresseeToSharp please check if category transformation works");
 
     QStringList cats = addr.categories();
     int ii;
     for ( ii = 0; ii < cats.count() ;++ii ) {
         if ( !catDB->exists( cats[ii]  ))
             catDB->addCategory(cats[ii]);
     }
     QArray<int> iar;
     if ( !cats.isEmpty() ) {
       QArray<int> iar = catDB->ids(cats);
       qDebug("***cat count is %d ", iar.count());
       database->updateCategories(contact, iar);
     }
 
     return true;
 }
 
 QDate SharpDTMConverter::convertDate( QString  s)
 {
     QDate dt = KGlobal::locale()->readDate( s ); 
     return dt;
     return QDate ();
 }
diff --git a/kaddressbook/kabcore.cpp b/kaddressbook/kabcore.cpp
index c1ead9d..c2f031a 100644
--- a/kaddressbook/kabcore.cpp
+++ b/kaddressbook/kabcore.cpp
@@ -1,3067 +1,3072 @@
 /*
     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.
 */
 
 /*
 Enhanced Version of the file for platform independent KDE tools.
 Copyright (c) 2004 Ulf Schenk
 
 $Id$
 */
 
 #include "kabcore.h"
 
 #include <stdaddressbook.h>
 #include <klocale.h>
 #include <kfiledialog.h>
 #include <qprogressbar.h>
 
 #ifndef KAB_EMBEDDED
 #include <qclipboard.h>
 #include <qdir.h>
 #include <qfile.h>
 #include <qapplicaton.h>
 #include <qprogressbar.h>
 #include <qlayout.h>
 #include <qregexp.h>
 #include <qvbox.h>
 #include <kabc/addresseelist.h>
 #include <kabc/errorhandler.h>
 #include <kabc/resource.h>
 #include <kabc/vcardconverter.h>
 #include <kapplication.h>
 #include <kactionclasses.h>
 #include <kcmultidialog.h>
 #include <kdebug.h>
 #include <kdeversion.h>
 #include <kkeydialog.h>
 #include <kmessagebox.h>
 #include <kprinter.h>
 #include <kprotocolinfo.h>
 #include <kresources/selectdialog.h>
 #include <kstandarddirs.h>
 #include <ktempfile.h>
 #include <kxmlguiclient.h>
 #include <kaboutdata.h>
 #include <libkdepim/categoryselectdialog.h>
 
 #include "addresseeutil.h"
 #include "addresseeeditordialog.h"
 #include "extensionmanager.h"
 #include "kstdaction.h"
 #include "kaddressbookservice.h"
 #include "ldapsearchdialog.h"
 #include "printing/printingwizard.h"
 #else // KAB_EMBEDDED
 
 #include <kapplication.h>
 #include "KDGanttMinimizeSplitter.h"
 #include "kaddressbookmain.h"
 #include "kactioncollection.h"
 #include "addresseedialog.h"
 //US
 #include <addresseeview.h>
 
 #include <qapp.h>
 #include <qmenubar.h>
 //#include <qtoolbar.h>
 #include <qmessagebox.h>
 #include <kdebug.h>
 #include <kiconloader.h> // needed for SmallIcon
 #include <kresources/kcmkresources.h>
 #include <ktoolbar.h>
 
 
 //#include <qlabel.h>
 
 
 #ifndef DESKTOP_VERSION
 #include <qpe/ir.h>
 #include <qpe/qpemenubar.h>
 #include <qtopia/qcopenvelope_qws.h>
 #else
 
 #include <qmenubar.h>
 #endif
 
 #endif // KAB_EMBEDDED
 #include "kcmconfigs/kcmkabconfig.h"
 #include "kcmconfigs/kcmkdepimconfig.h"
 #include "kpimglobalprefs.h"
 #include "externalapphandler.h"
 
 
 #include <kresources/selectdialog.h>
 #include <kmessagebox.h>
 
 #include <picture.h>
 #include <resource.h>
 
 //US#include <qsplitter.h>
 #include <qmap.h>
 #include <qdir.h>
 #include <qfile.h>
 #include <qvbox.h>
 #include <qlayout.h>
 #include <qclipboard.h>
 #include <qtextstream.h>
 
 #include <libkdepim/categoryselectdialog.h>
 #include <kabc/vcardconverter.h>
 
 
 #include "addresseeutil.h"
 #include "undocmds.h"
 #include "addresseeeditordialog.h"
 #include "viewmanager.h"
 #include "details/detailsviewcontainer.h"
 #include "kabprefs.h"
 #include "xxportmanager.h"
 #include "incsearchwidget.h"
 #include "jumpbuttonbar.h"
 #include "extensionmanager.h"
 #include "addresseeconfig.h"
 #include <kcmultidialog.h>
 
 #ifdef _WIN32_
 
 #include "kaimportoldialog.h"
 #else
 #include <unistd.h>
 #endif
 // sync includes
 #include <libkdepim/ksyncprofile.h>
 #include <libkdepim/ksyncprefsdialog.h>
 
 
 bool pasteWithNewUid = true;
 
 #ifdef KAB_EMBEDDED
 KABCore::KABCore( KAddressBookMain *client, bool readWrite, QWidget *parent, const char *name )
   : QWidget( parent, name ), mGUIClient( client ), mViewManager( 0 ),
     mExtensionManager( 0 ),mConfigureDialog( 0 ),/*US  mLdapSearchDialog( 0 ),*/
     mReadWrite( readWrite ), mModified( false ), mMainWindow(client)
 #else //KAB_EMBEDDED
 KABCore::KABCore( KXMLGUIClient *client, bool readWrite, QWidget *parent, const char *name )
   : QWidget( parent, name ), mGUIClient( client ), mViewManager( 0 ),
     mExtensionManager( 0 ), mConfigureDialog( 0 ), mLdapSearchDialog( 0 ),
     mReadWrite( readWrite ), mModified( false )
 #endif //KAB_EMBEDDED
 {
 
     mBlockSaveFlag = false;
   mExtensionBarSplitter = 0;
   mIsPart = !parent->inherits( "KAddressBookMain" );
 
   mAddressBook = KABC::StdAddressBook::self();
   KABC::StdAddressBook::setAutomaticSave( false );
 
 #ifndef KAB_EMBEDDED
   mAddressBook->setErrorHandler( new KABC::GUIErrorHandler );
 #endif //KAB_EMBEDDED
 
   connect( mAddressBook, SIGNAL( addressBookChanged( AddressBook * ) ),
            SLOT( addressBookChanged() ) );
 
 #if 0
   // LP moved to addressbook init method
   mAddressBook->addCustomField( i18n( "Department" ), KABC::Field::Organization,
                                 "X-Department", "KADDRESSBOOK" );
   mAddressBook->addCustomField( i18n( "Profession" ), KABC::Field::Organization,
                                 "X-Profession", "KADDRESSBOOK" );
   mAddressBook->addCustomField( i18n( "Assistant's Name" ), KABC::Field::Organization,
                                 "X-AssistantsName", "KADDRESSBOOK" );
   mAddressBook->addCustomField( i18n( "Manager's Name" ), KABC::Field::Organization,
                                 "X-ManagersName", "KADDRESSBOOK" );
   mAddressBook->addCustomField( i18n( "Spouse's Name" ), KABC::Field::Personal,
                                 "X-SpousesName", "KADDRESSBOOK" );
   mAddressBook->addCustomField( i18n( "Office" ), KABC::Field::Personal,
                                 "X-Office", "KADDRESSBOOK" );
   mAddressBook->addCustomField( i18n( "IM Address" ), KABC::Field::Personal,
                                 "X-IMAddress", "KADDRESSBOOK" );
   mAddressBook->addCustomField( i18n( "Anniversary" ), KABC::Field::Personal,
                                 "X-Anniversary", "KADDRESSBOOK" );
 
   //US added this field to become compatible with Opie/qtopia addressbook
   // values can be "female" or "male" or "". An empty field represents undefined.
   mAddressBook->addCustomField( i18n( "Gender" ), KABC::Field::Personal,
                                 "X-Gender", "KADDRESSBOOK" );
   mAddressBook->addCustomField( i18n( "Children" ), KABC::Field::Personal,
                                 "X-Children", "KADDRESSBOOK" );
   mAddressBook->addCustomField( i18n( "FreeBusyUrl" ), KABC::Field::Personal,
                                 "X-FreeBusyUrl", "KADDRESSBOOK" );
 #endif
   initGUI();
 
   mIncSearchWidget->setFocus();
 
 
   connect( mViewManager, SIGNAL( selected( const QString& ) ),
            SLOT( setContactSelected( const QString& ) ) );
   connect( mViewManager, SIGNAL( executed( const QString& ) ),
            SLOT( executeContact( const QString& ) ) );
 
   connect( mViewManager, SIGNAL( deleteRequest( ) ),
            SLOT( deleteContacts( ) ) );
   connect( mViewManager, SIGNAL( modified() ),
            SLOT( setModified() ) );
 
   connect( mExtensionManager, SIGNAL( modified( const KABC::Addressee::List& ) ), this, SLOT( extensionModified( const KABC::Addressee::List& ) ) );
   connect( mExtensionManager, SIGNAL( changedActiveExtension( int ) ), this, SLOT( extensionChanged( int ) ) );
 
   connect( mXXPortManager, SIGNAL( modified() ),
            SLOT( setModified() ) );
 
   connect( mJumpButtonBar, SIGNAL( jumpToLetter( const QString& ) ),
            SLOT( incrementalSearch( const QString& ) ) );
   connect( mIncSearchWidget, SIGNAL( fieldChanged() ),
            mJumpButtonBar, SLOT( recreateButtons() ) );
 
   connect( mDetails, SIGNAL( sendEmail( const QString& ) ),
            SLOT( sendMail( const QString& ) ) );
 
 
   connect( ExternalAppHandler::instance(), SIGNAL (requestForNameEmailUidList(const QString&, const QString&)),this, SLOT(requestForNameEmailUidList(const QString&, const QString&)));
   connect( ExternalAppHandler::instance(), SIGNAL (requestForDetails(const QString&, const QString&, const QString&, const QString&, const QString&)),this, SLOT(requestForDetails(const QString&, const QString&, const QString&, const QString&, const QString&)));
 
 
 #ifndef KAB_EMBEDDED
   connect( mViewManager, SIGNAL( urlDropped( const KURL& ) ),
            mXXPortManager, SLOT( importVCard( const KURL& ) ) );
 
   connect( mDetails, SIGNAL( browse( const QString& ) ),
            SLOT( browse( const QString& ) ) );
 
 
   mAddressBookService = new KAddressBookService( this );
 
 #endif //KAB_EMBEDDED
   mEditorDialog = 0;
   createAddresseeEditorDialog( this );
   setModified( false );
 }
 
 KABCore::~KABCore()
 {
     //  save();
     //saveSettings();
     //KABPrefs::instance()->writeConfig();
     delete AddresseeConfig::instance();
   mAddressBook = 0;
   KABC::StdAddressBook::close();
 }
 
 void KABCore::restoreSettings()
 {
   mMultipleViewsAtOnce = KABPrefs::instance()->mMultipleViewsAtOnce;
 
   bool state;
 
   if (mMultipleViewsAtOnce)
     state = KABPrefs::instance()->mDetailsPageVisible;
   else
     state = false;
 
   mActionDetails->setChecked( state );
   setDetailsVisible( state );
 
   state = KABPrefs::instance()->mJumpButtonBarVisible;
 
   mActionJumpBar->setChecked( state );
   setJumpButtonBarVisible( state );
 /*US
  QValueList<int> splitterSize = KABPrefs::instance()->mDetailsSplitter;
   if ( splitterSize.count() == 0 ) {
     splitterSize.append( width() / 2 );
     splitterSize.append( width() / 2 );
   }
   mMiniSplitter->setSizes( splitterSize );
   if (  mExtensionBarSplitter ) {
   splitterSize = KABPrefs::instance()->mExtensionsSplitter;
   if ( splitterSize.count() == 0 ) {
     splitterSize.append( width() / 2 );
     splitterSize.append( width() / 2 );
   }
   mExtensionBarSplitter->setSizes( splitterSize );
 
   }
 */
   mViewManager->restoreSettings();
   mIncSearchWidget->setCurrentItem( KABPrefs::instance()->mCurrentIncSearchField );
   mExtensionManager->restoreSettings();
 #ifdef DESKTOP_VERSION
   int wid = width();
   if ( wid < 10 )
       wid = 400;
 #else
   int wid = QApplication::desktop()->width();
   if ( wid < 640 )
       wid = QApplication::desktop()->height();
 #endif
   QValueList<int> splitterSize;// = KABPrefs::instance()->mDetailsSplitter;
   if ( true /*splitterSize.count() == 0*/ ) {
       splitterSize.append( wid / 2 );
       splitterSize.append( wid / 2 );
   }
   mMiniSplitter->setSizes( splitterSize );
   if (  mExtensionBarSplitter ) {
       //splitterSize = KABPrefs::instance()->mExtensionsSplitter;
       if ( true /*splitterSize.count() == 0*/ ) {
           splitterSize.append( wid / 2 );
           splitterSize.append( wid / 2 );
       }
       mExtensionBarSplitter->setSizes( splitterSize );
 
   }
 
 
 }
 
 void KABCore::saveSettings()
 {
   KABPrefs::instance()->mJumpButtonBarVisible = mActionJumpBar->isChecked();
   if ( mExtensionBarSplitter )
     KABPrefs::instance()->mExtensionsSplitter = mExtensionBarSplitter->sizes();
   KABPrefs::instance()->mDetailsPageVisible = mActionDetails->isChecked();
   KABPrefs::instance()->mDetailsSplitter = mMiniSplitter->sizes();
 #ifndef KAB_EMBEDDED
 
   KABPrefs::instance()->mExtensionsSplitter = mExtensionBarSplitter->sizes();
   KABPrefs::instance()->mDetailsSplitter = mDetailsSplitter->sizes();
 #endif //KAB_EMBEDDED
   mExtensionManager->saveSettings();
   mViewManager->saveSettings();
 
   KABPrefs::instance()->mCurrentIncSearchField = mIncSearchWidget->currentItem();
 }
 
 KABC::AddressBook *KABCore::addressBook() const
 {
   return mAddressBook;
 }
 
 KConfig *KABCore::config()
 {
 #ifndef KAB_EMBEDDED
   return KABPrefs::instance()->config();
 #else //KAB_EMBEDDED
   return KABPrefs::instance()->getConfig();
 #endif //KAB_EMBEDDED
 }
 
 KActionCollection *KABCore::actionCollection() const
 {
   return mGUIClient->actionCollection();
 }
 
 KABC::Field *KABCore::currentSearchField() const
 {
    if (mIncSearchWidget)
     return mIncSearchWidget->currentField();
   else
     return 0;
 }
 
 QStringList KABCore::selectedUIDs() const
 {
   return mViewManager->selectedUids();
 }
 
 KABC::Resource *KABCore::requestResource( QWidget *parent )
 {
   QPtrList<KABC::Resource> kabcResources = addressBook()->resources();
 
   QPtrList<KRES::Resource> kresResources;
   QPtrListIterator<KABC::Resource> resIt( kabcResources );
   KABC::Resource *resource;
   while ( ( resource = resIt.current() ) != 0 ) {
     ++resIt;
     if ( !resource->readOnly() ) {
       KRES::Resource *res = static_cast<KRES::Resource*>( resource );
       if ( res )
         kresResources.append( res );
     }
   }
 
   KRES::Resource *res = KRES::SelectDialog::getResource( kresResources, parent );
   return static_cast<KABC::Resource*>( res );
 }
 
 #ifndef KAB_EMBEDDED
 KAboutData *KABCore::createAboutData()
 #else //KAB_EMBEDDED
 void KABCore::createAboutData()
 #endif //KAB_EMBEDDED
 {
 #ifndef KAB_EMBEDDED
   KAboutData *about = new KAboutData( "kaddressbook", I18N_NOOP( "KAddressBook" ),
                                       "3.1", I18N_NOOP( "The KDE Address Book" ),
                                       KAboutData::License_GPL_V2,
                                       I18N_NOOP( "(c) 1997-2003, The KDE PIM Team" ) );
   about->addAuthor( "Tobias Koenig", I18N_NOOP( "Current maintainer " ), "tokoe@kde.org" );
   about->addAuthor( "Don Sanders", I18N_NOOP( "Original author " ) );
   about->addAuthor( "Cornelius Schumacher",
                     I18N_NOOP( "Co-maintainer, libkabc port, CSV import/export " ),
                     "schumacher@kde.org" );
   about->addAuthor( "Mike Pilone", I18N_NOOP( "GUI and framework redesign " ),
                     "mpilone@slac.com" );
   about->addAuthor( "Greg Stern", I18N_NOOP( "DCOP interface" ) );
   about->addAuthor( "Mark Westcott", I18N_NOOP( "Contact pinning" ) );
   about->addAuthor( "Michel Boyer de la Giroday", I18N_NOOP( "LDAP Lookup\n" ),
                     "michel@klaralvdalens-datakonsult.se" );
   about->addAuthor( "Steffen Hansen", I18N_NOOP( "LDAP Lookup " ),
                     "hansen@kde.org" );
 
   return about;
 #endif //KAB_EMBEDDED
 
   QString version;
 #include <../version>
     QMessageBox::about( this, "About KAddressbook/Pi",
                         "KAddressbook/Platform-independent\n"
                         "(KA/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-2003, The KDE PIM Team\n"
   "Tobias Koenig Current maintainer\ntokoe@kde.org\n"
   "Don Sanders Original author\n"
   "Cornelius Schumacher Co-maintainer\nschumacher@kde.org\n"
   "Mike Pilone GUI and framework redesign\nmpilone@slac.com\n"
   "Greg Stern DCOP interface\n"
   "Mark Westcot Contact pinning\n"
   "Michel Boyer de la Giroday LDAP Lookup\n" "michel@klaralvdalens-datakonsult.se\n"
   "Steffen Hansen LDAP Lookup\nhansen@kde.org\n"
 #ifdef _WIN32_
  "(c) 2004 Lutz Rogowski Import from OL\nrogowski@kde.org\n"
 #endif
  );
 }
 
 void KABCore::setContactSelected( const QString &uid )
 {
   KABC::Addressee addr = mAddressBook->findByUid( uid );
   if ( !mDetails->isHidden() )
     mDetails->setAddressee( addr );
 
   if ( !addr.isEmpty() ) {
     emit contactSelected( addr.formattedName() );
     KABC::Picture pic = addr.photo();
     if ( pic.isIntern() ) {
 //US      emit contactSelected( pic.data() );
 //US instead use:
       QPixmap px;
       if (pic.data().isNull() != true)
       {
         px.convertFromImage(pic.data());
       }
 
       emit contactSelected( px );
     }
   }
 
 
   mExtensionManager->setSelectionChanged();
 
   // update the actions
   bool selected = !uid.isEmpty();
 
   if ( mReadWrite ) {
     mActionCut->setEnabled( selected );
     mActionPaste->setEnabled( selected );
   }
 
   mActionCopy->setEnabled( selected );
   mActionDelete->setEnabled( selected );
   mActionEditAddressee->setEnabled( selected );
   mActionMail->setEnabled( selected );
   mActionMailVCard->setEnabled( selected );
   //if (mActionBeam)
   //mActionBeam->setEnabled( selected );
 
   if (mActionBeamVCard)
    mActionBeamVCard->setEnabled( selected );
 
   mActionWhoAmI->setEnabled( selected );
   mActionCategories->setEnabled( selected );
 }
 
 void KABCore::sendMail()
 {
   sendMail( mViewManager->selectedEmails().join( ", " ) );
 }
 
 void KABCore::sendMail( const QString& emaillist )
 {
   // the parameter has the form "name1 <abc@aol.com>,name2 <abc@aol.com>;... "
   if (emaillist.contains(",") > 0)
     ExternalAppHandler::instance()->mailToMultipleContacts( emaillist, QString::null );
   else
     ExternalAppHandler::instance()->mailToOneContact( emaillist );
 }
 
 
 
 void KABCore::mailVCard()
 {
   QStringList uids = mViewManager->selectedUids();
   if ( !uids.isEmpty() )
     mailVCard( uids );
 }
 
 void KABCore::mailVCard( const QStringList& uids )
 {
   QStringList urls;
 
 //  QString tmpdir = locateLocal("tmp", KGlobal::getAppName());
 
   QString dirName = "/tmp/" + KApplication::randomString( 8 );
 
 
 
   QDir().mkdir( dirName, true );
 
   for( QStringList::ConstIterator it = uids.begin(); it != uids.end(); ++it ) {
     KABC::Addressee a = mAddressBook->findByUid( *it );
 
     if ( a.isEmpty() )
       continue;
 
     QString name = a.givenName() + "_" + a.familyName() + ".vcf";
 
     QString fileName = dirName + "/" + name;
 
     QFile outFile(fileName);
 
     if ( outFile.open(IO_WriteOnly) ) {  // file opened successfully
       KABC::VCardConverter converter;
       QString vcard;
 
       converter.addresseeToVCard( a, vcard );
 
       QTextStream t( &outFile );  // use a text stream
       t.setEncoding( QTextStream::UnicodeUTF8 );
       t << vcard;
 
       outFile.close();
 
       urls.append( fileName );
     }
   }
 
   bool result = ExternalAppHandler::instance()->mailToMultipleContacts( QString::null, urls.join(", ") );
 
 
 /*US
   kapp->invokeMailer( QString::null, QString::null, QString::null,
                       QString::null,  // subject
                       QString::null,  // body
                       QString::null,
                       urls );  // attachments
 */
 
 }
 
 /**
   Beams the "WhoAmI contact.
 */
 void KABCore::beamMySelf()
 {
   KABC::Addressee a = KABC::StdAddressBook::self()->whoAmI();
   if (!a.isEmpty())
   {
     QStringList uids;
     uids << a.uid();
 
         beamVCard(uids);
   } else {
       KMessageBox::information( this, i18n( "Your personal contact is\nnot set! Please select it\nand set it with menu:\nSettings - Set Who Am I\n" ) );
 
 
   }
 }
 
 void KABCore::beamVCard()
 {
   QStringList uids = mViewManager->selectedUids();
   if ( !uids.isEmpty() )
     beamVCard( uids );
 }
 
 
 void KABCore::beamVCard(const QStringList& uids)
 {
 /*US
         QString beamFilename;
         Opie::OPimContact c;
         if ( actionPersonal->isOn() ) {
                 beamFilename = addressbookPersonalVCardName();
                 if ( !QFile::exists( beamFilename ) )
                         return; // can't beam a non-existent file
                 Opie::OPimContactAccessBackend* vcard_backend = new Opie::OPimContactAccessBackend_VCard( QString::null,
                                                                                         beamFilename );
                 Opie::OPimContactAccess* access = new Opie::OPimContactAccess ( "addressbook", QString::null , vcard_backend, true );
                 Opie::OPimContactAccess::List allList = access->allRecords();
                 Opie::OPimContactAccess::List::Iterator it = allList.begin();  // Just take first
                 c = *it;
 
                 delete access;
         } else {
                 unlink( beamfile ); // delete if exists
                 mkdir("/tmp/obex/", 0755);
                 c = m_abView -> currentEntry();
                 Opie::OPimContactAccessBackend* vcard_backend = new Opie::OPimContactAccessBackend_VCard( QString::null,
                                                                                         beamfile );
                 Opie::OPimContactAccess* access = new Opie::OPimContactAccess ( "addressbook", QString::null , vcard_backend, true );
                 access->add( c );
                 access->save();
                 delete access;
 
                 beamFilename = beamfile;
         }
 
         owarn << "Beaming: " << beamFilename << oendl;
 */
 
 #if 0
   QString tmpdir = locateLocal("tmp", KGlobal::getAppName());
 
   QString dirName = tmpdir + "/" + KApplication::randomString( 8 );
 
   QString name = "contact.vcf";
 
   QString fileName = dirName + "/" + name;
 #endif
   // LR: we should use the /tmp dir, because: /tmp = RAM, (HOME)/kdepim = flash memory
   //
   QString fileName = "/tmp/kapibeamfile.vcf";
 
 
   //QDir().mkdir( dirName, true );
 
  
   KABC::VCardConverter converter;
   QString description;
   QString datastream;
   for( QStringList::ConstIterator it = uids.begin(); it != uids.end(); ++it ) {
       KABC::Addressee a = mAddressBook->findByUid( *it );
 
       if ( a.isEmpty() )
           continue;
 
       if (description.isEmpty())
           description = a.formattedName();
 
       QString vcard;
       converter.addresseeToVCard( a, vcard );
       int start = 0;
       int next;
       while ( (next = vcard.find("TYPE=", start) )>= 0 ) {
           int semi = vcard.find(";", next);
           int dopp = vcard.find(":", next);
           int sep;
           if ( semi < dopp && semi >= 0 )
               sep = semi ;
           else
               sep = dopp;
           datastream +=vcard.mid( start, next - start);
           datastream +=vcard.mid( next+5,sep -next -5 ).upper();
           start = sep;
       }
       datastream += vcard.mid( start,vcard.length() );
   }
 #ifndef DESKTOP_VERSION
   QFile outFile(fileName);
   if ( outFile.open(IO_WriteOnly) ) { 
       datastream.replace ( QRegExp("VERSION:3.0") , "VERSION:2.1" );
       QTextStream t( &outFile );  // use a text stream
       t.setEncoding( QTextStream::UnicodeUTF8 );
       t <<datastream;
       outFile.close();
       Ir *ir = new Ir( this );
       connect( ir, SIGNAL( done(Ir*) ), this, SLOT( beamDone(Ir*) ) );
       ir->send( fileName, description, "text/x-vCard" );
   } else {
       qDebug("Error open temp  beam file ");
       return;
   }
 #endif
 
 }
 
 void KABCore::beamDone( Ir *ir )
 {
 #ifndef DESKTOP_VERSION
   delete ir;
 #endif
 }
 
 
 void KABCore::browse( const QString& url )
 {
 #ifndef KAB_EMBEDDED
   kapp->invokeBrowser( url );
 #else //KAB_EMBEDDED
   qDebug("KABCore::browse must be fixed");
 #endif //KAB_EMBEDDED
 }
 
 void KABCore::selectAllContacts()
 {
   mViewManager->setSelected( QString::null, true );
 }
 
 void KABCore::deleteContacts()
 {
   QStringList uidList = mViewManager->selectedUids();
   deleteContacts( uidList );
 }
 
 void KABCore::deleteContacts( const QStringList &uids )
 {
   if ( uids.count() > 0 ) {
     PwDeleteCommand *command = new PwDeleteCommand( mAddressBook, uids );
     UndoStack::instance()->push( command );
     RedoStack::instance()->clear();
 
     // now if we deleted anything, refresh
     setContactSelected( QString::null );
     setModified( true );
   }
 }
 
 void KABCore::copyContacts()
 {
   KABC::Addressee::List addrList = mViewManager->selectedAddressees();
 
   QString clipText = AddresseeUtil::addresseesToClipboard( addrList );
 
   kdDebug(5720) << "KABCore::copyContacts: " << clipText << endl;
 
   QClipboard *cb = QApplication::clipboard();
   cb->setText( clipText );
 }
 
 void KABCore::cutContacts()
 {
   QStringList uidList = mViewManager->selectedUids();
 
 //US  if ( uidList.size() > 0 ) {
   if ( uidList.count() > 0 ) {
     PwCutCommand *command = new PwCutCommand( mAddressBook, uidList );
     UndoStack::instance()->push( command );
     RedoStack::instance()->clear();
 
     setModified( true );
   }
 }
 
 void KABCore::pasteContacts()
 {
   QClipboard *cb = QApplication::clipboard();
 
   KABC::Addressee::List list = AddresseeUtil::clipboardToAddressees( cb->text() );
 
   pasteContacts( list );
 }
 
 void KABCore::pasteContacts( KABC::Addressee::List &list  )
 {
   KABC::Resource *resource = requestResource( this );
   KABC::Addressee::List::Iterator it;
   for ( it = list.begin(); it != list.end(); ++it )
     (*it).setResource( resource );
 
   PwPasteCommand *command = new PwPasteCommand( this, list );
   UndoStack::instance()->push( command );
   RedoStack::instance()->clear();
 
   setModified( true );
 }
 
 void KABCore::setWhoAmI()
 {
   KABC::Addressee::List addrList = mViewManager->selectedAddressees();
 
   if ( addrList.count() > 1 ) {
     KMessageBox::sorry( this, i18n( "Please select only one contact." ) );
     return;
   }
 
   QString text( i18n( "<qt>Do you really want to use <b>%1</b> as your new personal contact?</qt>" ) );
   if ( KMessageBox::questionYesNo( this, text.arg( addrList[ 0 ].assembledName() ) ) == KMessageBox::Yes )
     static_cast<KABC::StdAddressBook*>( KABC::StdAddressBook::self() )->setWhoAmI( addrList[ 0 ] );
 }
 
 void KABCore::setCategories()
 {
   KPIM::CategorySelectDialog dlg( KABPrefs::instance(), this, "", true );
   if ( !dlg.exec() )
     return;
 
   bool merge = false;
   QString msg = i18n( "Merge with existing categories?" );
   if ( KMessageBox::questionYesNo( this, msg ) == KMessageBox::Yes )
     merge = true;
 
   QStringList categories = dlg.selectedCategories();
 
   QStringList uids = mViewManager->selectedUids();
   QStringList::Iterator it;
   for ( it = uids.begin(); it != uids.end(); ++it ) {
     KABC::Addressee addr = mAddressBook->findByUid( *it );
     if ( !addr.isEmpty() ) {
       if ( !merge )
         addr.setCategories( categories );
       else {
         QStringList addrCategories = addr.categories();
         QStringList::Iterator catIt;
         for ( catIt = categories.begin(); catIt != categories.end(); ++catIt ) {
           if ( !addrCategories.contains( *catIt ) )
             addrCategories.append( *catIt );
         }
         addr.setCategories( addrCategories );
       }
 
       mAddressBook->insertAddressee( addr );
     }
   }
 
   if ( uids.count() > 0 )
     setModified( true );
 }
 
 void KABCore::setSearchFields( const KABC::Field::List &fields )
 {
   mIncSearchWidget->setFields( fields );
 }
 
 void KABCore::incrementalSearch( const QString& text )
 {
     mViewManager->doSearch( text, mIncSearchWidget->currentField() );
 }
 
 void KABCore::setModified()
 {
   setModified( true );
 }
 
 void KABCore::setModifiedWOrefresh()
 {
     // qDebug("KABCore::setModifiedWOrefresh() ");
     mModified = true;
     mActionSave->setEnabled( mModified );
 #ifdef DESKTOP_VERSION
   mDetails->refreshView();
 #endif
 
 }
 void KABCore::setModified( bool modified )
 {
   mModified = modified;
   mActionSave->setEnabled( mModified );
 
   if ( modified )
     mJumpButtonBar->recreateButtons();
 
   mViewManager->refreshView();
   mDetails->refreshView();
 
 }
 
 bool KABCore::modified() const
 {
   return mModified;
 }
 
 void KABCore::contactModified( const KABC::Addressee &addr )
 {
 
   Command *command = 0;
   QString uid;
 
   // check if it exists already
   KABC::Addressee origAddr = mAddressBook->findByUid( addr.uid() );
   if ( origAddr.isEmpty() )
     command = new PwNewCommand( mAddressBook, addr );
   else {
     command = new PwEditCommand( mAddressBook, origAddr, addr );
     uid = addr.uid();
   }
 
   UndoStack::instance()->push( command );
   RedoStack::instance()->clear();
 
   setModified( true );
 }
 
 void KABCore::newContact()
 {
 
 
   QPtrList<KABC::Resource> kabcResources = mAddressBook->resources();
 
   QPtrList<KRES::Resource> kresResources;
   QPtrListIterator<KABC::Resource> it( kabcResources );
   KABC::Resource *resource;
   while ( ( resource = it.current() ) != 0 ) {
     ++it;
     if ( !resource->readOnly() ) {
       KRES::Resource *res = static_cast<KRES::Resource*>( resource );
       if ( res )
         kresResources.append( res );
     }
   }
 
   KRES::Resource *res = KRES::SelectDialog::getResource( kresResources, this );
   resource = static_cast<KABC::Resource*>( res );
 
   if ( resource ) {
     KABC::Addressee addr;
     addr.setResource( resource );
     mEditorDialog->setAddressee( addr );
     KApplication::execDialog ( mEditorDialog );
 
   } else
     return;
 
   // mEditorDict.insert( dialog->addressee().uid(), dialog );
 
 
 }
 
 void KABCore::addEmail( QString aStr )
 {
 #ifndef KAB_EMBEDDED
   QString fullName, email;
 
   KABC::Addressee::parseEmailAddress( aStr, fullName, email );
 
   // Try to lookup the addressee matching the email address
   bool found = false;
   QStringList emailList;
   KABC::AddressBook::Iterator it;
   for ( it = mAddressBook->begin(); !found && (it != mAddressBook->end()); ++it ) {
     emailList = (*it).emails();
     if ( emailList.contains( email ) > 0 ) {
       found = true;
       (*it).setNameFromString( fullName );
       editContact( (*it).uid() );
     }
   }
 
   if ( !found ) {
     KABC::Addressee addr;
     addr.setNameFromString( fullName );
     addr.insertEmail( email, true );
 
     mAddressBook->insertAddressee( addr );
     mViewManager->refreshView( addr.uid() );
     editContact( addr.uid() );
   }
 #else //KAB_EMBEDDED
   qDebug("KABCore::addEmail finsih method");
 #endif //KAB_EMBEDDED
 }
 
 void KABCore::importVCard( const KURL &url, bool showPreview )
 {
   mXXPortManager->importVCard( url, showPreview );
 }
 void KABCore::importFromOL()
 {
 #ifdef _WIN32_
   KAImportOLdialog* idgl = new KAImportOLdialog( i18n("Import Contacts from OL"),  mAddressBook, this );
   idgl->exec();
   KABC::Addressee::List list = idgl->getAddressList();
   if ( list.count() > 0 ) {
     KABC::Addressee::List listNew;
     KABC::Addressee::List listExisting;
     KABC::Addressee::List::Iterator it;
     KABC::AddressBook::Iterator iter;
     for ( it = list.begin(); it != list.end(); ++it ) {
       if ( mAddressBook->findByUid((*it).uid() ).isEmpty())
         listNew.append( (*it) );
       else
         listExisting.append( (*it) );
     }
     if ( listExisting.count()  > 0 )
       KMessageBox::information( this, i18n("%1 contacts not added to addressbook\nbecause they were already in the addressbook!").arg( listExisting.count() ));
     if ( listNew.count() > 0 ) {
       pasteWithNewUid = false;
       pasteContacts( listNew );
       pasteWithNewUid = true;
     }
   }
   delete idgl;
 #endif
 }
 
 void KABCore::importVCard( const QString &vCard, bool showPreview )
 {
   mXXPortManager->importVCard( vCard, showPreview );
 }
 
 //US added a second method without defaultparameter
 void KABCore::editContact2() {
   editContact( QString::null );
 }
 
 void KABCore::editContact( const QString &uid )
 {
 
   if ( mExtensionManager->isQuickEditVisible() )
     return;
 
   // First, locate the contact entry
   QString localUID = uid;
   if ( localUID.isNull() ) {
     QStringList uidList = mViewManager->selectedUids();
     if ( uidList.count() > 0 )
       localUID = *( uidList.at( 0 ) );
   }
 
   KABC::Addressee addr = mAddressBook->findByUid( localUID );
   if ( !addr.isEmpty() ) {
       mEditorDialog->setAddressee( addr );
       KApplication::execDialog ( mEditorDialog );
   }
 }
 
 /**
   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 KABCore::executeContact( const QString &uid /*US = QString::null*/ )
 {
   if ( mMultipleViewsAtOnce )
   {
     editContact( uid );
   }
   else
   {
     setDetailsVisible( true );
     mActionDetails->setChecked(true);
   }
 
 }
 
 void KABCore::save()
 {
      if (mBlockSaveFlag)
         return;
     mBlockSaveFlag = true;
     if ( !mModified )
         return;
    QString text = i18n( "There was an error while attempting to save\n the "
     "address book. Please check that some \nother application is "
     "not using it. " );
    statusMessage(i18n("Saving addressbook ... "));
 #ifndef KAB_EMBEDDED
   KABC::StdAddressBook *b = dynamic_cast<KABC::StdAddressBook*>( mAddressBook );
   if ( !b || !b->save() ) {
     KMessageBox::error( this, text, i18n( "Unable to Save" ) );
   }
 #else //KAB_EMBEDDED
   KABC::StdAddressBook *b = (KABC::StdAddressBook*)( mAddressBook );
   if ( !b || !b->save() ) {
     QMessageBox::critical( this, i18n( "Unable to Save" ), text,  i18n("Ok"));
   }
 #endif //KAB_EMBEDDED
 
   statusMessage(i18n("Addressbook saved!"));
   setModified( false );
     mBlockSaveFlag = false;
 }
 
 void KABCore::statusMessage(QString mess , int time )
 {
     //topLevelWidget()->setCaption( mess );
     // pending setting timer to revome message
 }
 void KABCore::undo()
 {
   UndoStack::instance()->undo();
 
   // Refresh the view
   mViewManager->refreshView();
 }
 
 void KABCore::redo()
 {
   RedoStack::instance()->redo();
 
   // Refresh the view
   mViewManager->refreshView();
 }
 
 void KABCore::setJumpButtonBarVisible( bool visible )
 {
   if (mMultipleViewsAtOnce)
   {
     if ( visible )
       mJumpButtonBar->show();
     else
       mJumpButtonBar->hide();
   }
   else
   {
         // show the jumpbar only if "the details are hidden" == "viewmanager are shown"
     if (mViewManager->isVisible())
     {
       if ( visible )
         mJumpButtonBar->show();
       else
         mJumpButtonBar->hide();
         }
         else
         {
       mJumpButtonBar->hide();
         }
   }
 }
 
 
 void KABCore::setDetailsToState()
 {
     setDetailsVisible(  mActionDetails->isChecked() );
 }
 
 
 
 void KABCore::setDetailsVisible( bool visible )
 {
   if (visible && mDetails->isHidden())
   {
     KABC::Addressee::List addrList = mViewManager->selectedAddressees();
     if ( addrList.count() > 0 )
       mDetails->setAddressee( addrList[ 0 ] );
   }
 
   // mMultipleViewsAtOnce=false: mDetails is always visible. But we switch between
   // the listview and the detailview. We do that by changing the splitbar size.
   if (mMultipleViewsAtOnce)
   {
     if ( visible )
       mDetails->show();
     else
       mDetails->hide();
   }
   else
   {
     if ( visible ) {
       mViewManager->hide();
       mDetails->show();
     }
     else {
       mViewManager->show();
       mDetails->hide();
     }
     setJumpButtonBarVisible( !visible );
   }
 
 }
 
 void KABCore::extensionChanged( int id )
 {
   //change the details view only for non desktop systems
 #ifndef DESKTOP_VERSION
 
   if (id == 0)
   {
     //the user disabled the extension.
 
     if (mMultipleViewsAtOnce)
     { // enable detailsview again
       setDetailsVisible( true );
       mActionDetails->setChecked( true );
     }
     else
     {  //go back to the listview
       setDetailsVisible( false );
       mActionDetails->setChecked( false );
       mActionDetails->setEnabled(true);
         }
 
   }
   else
   {
     //the user enabled the extension.
     setDetailsVisible( false );
     mActionDetails->setChecked( false );
 
     if (!mMultipleViewsAtOnce)
     {
       mActionDetails->setEnabled(false);
         }
 
     mExtensionManager->setSelectionChanged();
 
   }
 
 #endif// DESKTOP_VERSION
 
 }
 
 
 void KABCore::extensionModified( const KABC::Addressee::List &list )
 {
 
   if ( list.count() != 0 ) {
     KABC::Addressee::List::ConstIterator it;
     for ( it = list.begin(); it != list.end(); ++it )
       mAddressBook->insertAddressee( *it );
     if ( list.count() > 1 )
         setModified();
     else
         setModifiedWOrefresh();
   }
   if ( list.count() == 0 )
     mViewManager->refreshView();
   else
      mViewManager->refreshView( list[ 0 ].uid() );
 
 
 
 }
 
 QString KABCore::getNameByPhone( const QString &phone )
 {
 #ifndef KAB_EMBEDDED
   QRegExp r( "[/*/-/ ]" );
   QString localPhone( phone );
 
   bool found = false;
   QString ownerName = "";
   KABC::AddressBook::Iterator iter;
   KABC::PhoneNumber::List::Iterator phoneIter;
   KABC::PhoneNumber::List phoneList;
   for ( iter = mAddressBook->begin(); !found && ( iter != mAddressBook->end() ); ++iter ) {
     phoneList = (*iter).phoneNumbers();
     for ( phoneIter = phoneList.begin(); !found && ( phoneIter != phoneList.end() );
           ++phoneIter) {
       // Get rid of separator chars so just the numbers are compared.
       if ( (*phoneIter).number().replace( r, "" ) == localPhone.replace( r, "" ) ) {
         ownerName = (*iter).formattedName();
         found = true;
       }
     }
   }
 
   return ownerName;
 #else //KAB_EMBEDDED
   qDebug("KABCore::getNameByPhone finsih method");
   return "";
 #endif //KAB_EMBEDDED
 
 }
 
 void KABCore::openConfigDialog()
 {
         KABPrefs* kab_prefs = KABPrefs::instance();
         KPimGlobalPrefs* kpim_prefs = KPimGlobalPrefs::instance();
 
     KCMultiDialog*  ConfigureDialog = new KCMultiDialog( "PIM", this ,"kabconfigdialog", true );
     KCMKabConfig* kabcfg = new KCMKabConfig( kab_prefs, ConfigureDialog->getNewVBoxPage(i18n( "Addressbook")) , "KCMKabConfig" );
     ConfigureDialog->addModule(kabcfg );
     KCMKdePimConfig* kdelibcfg = new KCMKdePimConfig( kpim_prefs, ConfigureDialog->getNewVBoxPage(i18n( "Global")) , "KCMKdeLibConfig" );
     ConfigureDialog->addModule(kdelibcfg );
 
 
 
     connect( ConfigureDialog, SIGNAL( applyClicked() ),
              this, SLOT( configurationChanged() ) );
     connect( ConfigureDialog, SIGNAL( okClicked() ),
              this, SLOT( configurationChanged() ) );
     saveSettings();
 #ifndef DESKTOP_VERSION
     ConfigureDialog->showMaximized();
 #endif
     if ( ConfigureDialog->exec() )
         KMessageBox::information( this,  i18n("Some changes are only\neffective after a restart!\n") );
     delete ConfigureDialog;
 }
 
 void KABCore::openLDAPDialog()
 {
 #ifndef KAB_EMBEDDED
   if ( !mLdapSearchDialog ) {
     mLdapSearchDialog = new LDAPSearchDialog( mAddressBook, this );
     connect( mLdapSearchDialog, SIGNAL( addresseesAdded() ), mViewManager,
             SLOT( refreshView() ) );
     connect( mLdapSearchDialog, SIGNAL( addresseesAdded() ), this,
             SLOT( setModified() ) );
   } else
     mLdapSearchDialog->restoreSettings();
 
   if ( mLdapSearchDialog->isOK() )
     mLdapSearchDialog->exec();
 #else //KAB_EMBEDDED
   qDebug("KABCore::openLDAPDialog() finsih method");
 #endif //KAB_EMBEDDED
 }
 
 void KABCore::print()
 {
 #ifndef KAB_EMBEDDED
   KPrinter printer;
   if ( !printer.setup( this ) )
     return;
 
   KABPrinting::PrintingWizard wizard( &printer, mAddressBook,
                                       mViewManager->selectedUids(), this );
 
   wizard.exec();
 #else //KAB_EMBEDDED
   qDebug("KABCore::print() finsih method");
 #endif //KAB_EMBEDDED
 
 }
 
 
 void KABCore::addGUIClient( KXMLGUIClient *client )
 {
   if ( mGUIClient )
     mGUIClient->insertChildClient( client );
   else
     KMessageBox::error( this, "no KXMLGUICLient");
 }
 
 
 void KABCore::configurationChanged()
 {
   mExtensionManager->reconfigure();
 }
 
 void KABCore::addressBookChanged()
 {
 /*US
   QDictIterator<AddresseeEditorDialog> it( mEditorDict );
   while ( it.current() ) {
     if ( it.current()->dirty() ) {
       QString text = i18n( "Data has been changed externally. Unsaved "
                            "changes will be lost." );
       KMessageBox::information( this, text );
     }
     it.current()->setAddressee( mAddressBook->findByUid( it.currentKey() ) );
     ++it;
   }
 */
   if (mEditorDialog)
   {
     if (mEditorDialog->dirty())
     {
       QString text = i18n( "Data has been changed externally. Unsaved "
                            "changes will be lost." );
       KMessageBox::information( this, text );
     }
     QString currentuid = mEditorDialog->addressee().uid();
     mEditorDialog->setAddressee( mAddressBook->findByUid( currentuid ) );
   }
   mViewManager->refreshView();
 //  mDetails->refreshView();
 
 
 }
 
 AddresseeEditorDialog *KABCore::createAddresseeEditorDialog( QWidget *parent,
                                                              const char *name )
 {
 
     if ( mEditorDialog == 0 ) {
   mEditorDialog = new AddresseeEditorDialog( this, parent,
                                                  name ? name : "editorDialog" );
 
 
   connect( mEditorDialog, SIGNAL( contactModified( const KABC::Addressee& ) ),
            SLOT( contactModified( const KABC::Addressee& ) ) );
   //connect( mEditorDialog, SIGNAL( editorDestroyed( const QString& ) ),
   //       SLOT( slotEditorDestroyed( const QString& ) ) ;
     }
 
   return mEditorDialog;
 }
 
 void KABCore::slotEditorDestroyed( const QString &uid )
 {
     //mEditorDict.remove( uid );
 }
 
 void KABCore::initGUI()
 {
 #ifndef KAB_EMBEDDED
   QHBoxLayout *topLayout = new QHBoxLayout( this );
   topLayout->setSpacing( KDialogBase::spacingHint() );
 
   mExtensionBarSplitter = new QSplitter( this );
   mExtensionBarSplitter->setOrientation( Qt::Vertical );
 
   mDetailsSplitter = new QSplitter( mExtensionBarSplitter );
 
   QVBox *viewSpace = new QVBox( mDetailsSplitter );
   mIncSearchWidget = new IncSearchWidget( viewSpace );
   connect( mIncSearchWidget, SIGNAL( doSearch( const QString& ) ),
            SLOT( incrementalSearch( const QString& ) ) );
 
   mViewManager = new ViewManager( this, viewSpace );
   viewSpace->setStretchFactor( mViewManager, 1 );
 
   mDetails = new ViewContainer( mDetailsSplitter );
 
   mJumpButtonBar = new JumpButtonBar( this, this );
 
   mExtensionManager = new ExtensionManager( this, mExtensionBarSplitter );
 
   topLayout->addWidget( mExtensionBarSplitter );
   topLayout->setStretchFactor( mExtensionBarSplitter, 100 );
   topLayout->addWidget( mJumpButtonBar );
   topLayout->setStretchFactor( mJumpButtonBar, 1 );
 
   mXXPortManager = new XXPortManager( this, this );
 
 #else //KAB_EMBEDDED
   //US initialize viewMenu before settingup viewmanager.
   //  Viewmanager needs this menu to plugin submenues.
   viewMenu = new QPopupMenu( this );
   settingsMenu = new QPopupMenu( this );
   //filterMenu = new QPopupMenu( this );
   ImportMenu = new QPopupMenu( this );
   ExportMenu = new QPopupMenu( this );
   syncMenu = new QPopupMenu( this );
   changeMenu= new QPopupMenu( this );
 
 //US since we have no splitter for the embedded system, setup
 // a layout with two frames. One left and one right.
 
   QBoxLayout *topLayout;
 
   // = new QHBoxLayout( this );
 //  QBoxLayout *topLayout = (QBoxLayout*)layout();
 
 //  QWidget *mainBox = new QWidget( this );
 //  QBoxLayout * mainBoxLayout  = new QHBoxLayout(mainBox);
 
 #ifdef DESKTOP_VERSION
   topLayout = new QHBoxLayout( this );
 
 
   mMiniSplitter = new KDGanttMinimizeSplitter( Qt::Horizontal, this);
   mMiniSplitter->setMinimizeDirection ( KDGanttMinimizeSplitter::Right );
 
   topLayout->addWidget(mMiniSplitter );
 
   mExtensionBarSplitter = new KDGanttMinimizeSplitter( Qt::Vertical,mMiniSplitter );
   mExtensionBarSplitter->setMinimizeDirection ( KDGanttMinimizeSplitter::Down );
   mViewManager = new ViewManager( this, mExtensionBarSplitter  );
   mDetails = new ViewContainer( mMiniSplitter );
   mExtensionManager = new ExtensionManager( this, mExtensionBarSplitter );
 #else
   if ( QApplication::desktop()->width() > 480 ) {
       topLayout = new QHBoxLayout( this );
       mMiniSplitter = new KDGanttMinimizeSplitter( Qt::Horizontal, this);
       mMiniSplitter->setMinimizeDirection ( KDGanttMinimizeSplitter::Right );
   } else {
 
       topLayout = new QHBoxLayout( this );
       mMiniSplitter = new KDGanttMinimizeSplitter( Qt::Vertical, this);
       mMiniSplitter->setMinimizeDirection ( KDGanttMinimizeSplitter::Down );
   }
 
   topLayout->addWidget(mMiniSplitter );
   mViewManager = new ViewManager( this,  mMiniSplitter );
   mDetails = new ViewContainer( mMiniSplitter );
 
 
    mExtensionManager = new ExtensionManager( this, mMiniSplitter );
 #endif
    //eh->hide();
   // topLayout->addWidget(mExtensionManager );
 
 
 /*US
 #ifndef KAB_NOSPLITTER
   QHBoxLayout *topLayout = new QHBoxLayout( this );
 //US  topLayout->setSpacing( KDialogBase::spacingHint() );
   topLayout->setSpacing( 10 );
 
   mDetailsSplitter = new QSplitter( this );
 
   QVBox *viewSpace = new QVBox( mDetailsSplitter );
 
   mViewManager = new ViewManager( this, viewSpace );
   viewSpace->setStretchFactor( mViewManager, 1 );
 
   mDetails = new ViewContainer( mDetailsSplitter );
 
   topLayout->addWidget( mDetailsSplitter );
   topLayout->setStretchFactor( mDetailsSplitter, 100 );
 #else //KAB_NOSPLITTER
   QHBoxLayout *topLayout = new QHBoxLayout( this );
 //US  topLayout->setSpacing( KDialogBase::spacingHint() );
   topLayout->setSpacing( 10 );
 
 //  mDetailsSplitter = new QSplitter( this );
 
   QVBox *viewSpace = new QVBox( this );
 
   mViewManager = new ViewManager( this, viewSpace );
   viewSpace->setStretchFactor( mViewManager, 1 );
 
   mDetails = new ViewContainer( this );
 
   topLayout->addWidget( viewSpace );
 //  topLayout->setStretchFactor( mDetailsSplitter, 100 );
   topLayout->addWidget( mDetails );
 #endif //KAB_NOSPLITTER
 */
 
 
 #endif //KAB_EMBEDDED
   initActions();
 
 #ifdef KAB_EMBEDDED
   addActionsManually();
   //US make sure the export and import menues are initialized before creating the xxPortManager.
   mXXPortManager = new XXPortManager( this, this );
 
   // LR mIncSearchWidget = new IncSearchWidget( mMainWindow->getIconToolBar() );
   //mMainWindow->toolBar()->insertWidget(-1, 4, mIncSearchWidget);
   // mActionQuit->plug ( mMainWindow->toolBar());
   //mIncSearchWidget = new IncSearchWidget( mMainWindow->toolBar() );
   //mMainWindow->toolBar()->insertWidget(-1, 0, mIncSearchWidget);
   // mIncSearchWidget->hide();
   connect( mIncSearchWidget, SIGNAL( doSearch( const QString& ) ),
            SLOT( incrementalSearch( const QString& ) ) );
 
 
   mJumpButtonBar = new JumpButtonBar( this, this );
 
   topLayout->addWidget( mJumpButtonBar );
 //US  topLayout->setStretchFactor( mJumpButtonBar, 10 );
 
 // mMainWindow->getIconToolBar()->raise();
 
 #endif //KAB_EMBEDDED
 
 }
 void KABCore::initActions()
 {
 //US  qDebug("KABCore::initActions(): mIsPart %i", mIsPart);
 
 #ifndef KAB_EMBEDDED
   connect( QApplication::clipboard(), SIGNAL( dataChanged() ),
            SLOT( clipboardDataChanged() ) );
 #endif //KAB_EMBEDDED
 
   // file menu
   if ( mIsPart ) {
     mActionMail = new KAction( i18n( "&Mail" ), "mail_generic", 0, this,
                                SLOT( sendMail() ), actionCollection(),
                                "kaddressbook_mail" );
     mActionPrint = new KAction( i18n( "&Print" ), "fileprint", CTRL + Key_P, this,
                  SLOT( print() ), actionCollection(), "kaddressbook_print" );
 
   } else {
     mActionMail = KStdAction::mail( this, SLOT( sendMail() ), actionCollection() );
     mActionPrint = KStdAction::print( this, SLOT( print() ), actionCollection() );
   }
 
 
   mActionSave = new KAction( i18n( "&Save" ), "filesave", CTRL+Key_S, this,
                              SLOT( save() ), actionCollection(), "file_sync" );
 
   mActionNewContact = new KAction( i18n( "&New Contact..." ), "filenew", CTRL+Key_N, this,
                              SLOT( newContact() ), actionCollection(), "file_new_contact" );
 
   mActionMailVCard = new KAction(i18n("Mail &vCard..."), "mail_post_to", 0,
                                  this, SLOT( mailVCard() ),
                                  actionCollection(), "file_mail_vcard");
 
   mActionBeamVCard = 0;
  mActionBeam = 0;
 
 #ifndef DESKTOP_VERSION
   if ( Ir::supported() ) {
     mActionBeamVCard = new KAction( i18n( "Beam selected v&Card(s)" ), "beam", 0, this,
                                SLOT( beamVCard() ), actionCollection(),
                                "kaddressbook_beam_vcard" );
 
     mActionBeam = new KAction( i18n( "&Beam personal vCard" ), "beam", 0, this,
                                SLOT( beamMySelf() ), actionCollection(),
                                "kaddressbook_beam_myself" );
   }
 #endif
 
   mActionEditAddressee = new KAction( i18n( "&Edit Contact..." ), "edit", 0,
                                       this, SLOT( editContact2() ),
                                       actionCollection(), "file_properties" );
 
 #ifdef KAB_EMBEDDED
   // mActionQuit = KStdAction::quit( mMainWindow, SLOT( exit() ), actionCollection() );
   mActionQuit = new KAction( i18n( "&Exit" ), "exit", 0,
                                       mMainWindow, SLOT( exit() ),
                                       actionCollection(), "quit" );
 #endif //KAB_EMBEDDED
 
   // edit menu
   if ( mIsPart ) {
     mActionCopy = new KAction( i18n( "&Copy" ), "editcopy", CTRL + Key_C, this,
                                SLOT( copyContacts() ), actionCollection(),
                                "kaddressbook_copy" );
     mActionCut = new KAction( i18n( "Cu&t" ), "editcut", CTRL + Key_X, this,
                               SLOT( cutContacts() ), actionCollection(),
                               "kaddressbook_cut" );
     mActionPaste = new KAction( i18n( "&Paste" ), "editpaste", CTRL + Key_V, this,
                                 SLOT( pasteContacts() ), actionCollection(),
                                 "kaddressbook_paste" );
     mActionSelectAll = new KAction( i18n( "Select &All" ), CTRL + Key_A, this,
                   SLOT( selectAllContacts() ), actionCollection(),
                  "kaddressbook_select_all" );
     mActionUndo = new KAction( i18n( "&Undo" ), "undo", CTRL + Key_Z, this,
                                SLOT( undo() ), actionCollection(),
                                "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" );
 
     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() );
 
     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 ) ) );
 
   // 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" );
 
   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 ) {
     mActionConfigShortcuts->plug( settingsMenu );
     mActionConfigureToolbars->plug( settingsMenu );
 
   } else {
     mActionKeyBindings->plug( settingsMenu );
   }
 
   settingsMenu->insertSeparator();
 
   mActionJumpBar->plug( settingsMenu );
   mActionDetails->plug( settingsMenu );
   if (!KABPrefs::instance()->mMultipleViewsAtOnce || KGlobal::getDesktopSize() == KGlobal::Desktop  )
     mActionDetails->plug( tb );
   settingsMenu->insertSeparator();
 
   mActionWhoAmI->plug( settingsMenu );
   mActionCategories->plug( settingsMenu );
 
   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
 
  connect ( syncMenu, SIGNAL( activated ( int )  ), this, SLOT (slotSyncMenu( int ) ) );
  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 ) {
         PhoneNumber::List phoneNumbers = (*it).phoneNumbers();
         PhoneNumber::List::Iterator phoneIt;
         bool found = false;
         for ( phoneIt = phoneNumbers.begin(); phoneIt != phoneNumbers.end(); ++phoneIt ) {
             if ( (*phoneIt).type() & PhoneNumber::Voice) { // voice found
                 if ((*phoneIt).type() - PhoneNumber::Voice ) {
                     (*phoneIt).setType((*phoneIt).type() - PhoneNumber::Voice );
                     (*it).insertPhoneNumber( (*phoneIt) );
                     found = true;
                 }
             }
 
         }
         if ( found )
             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 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::faq()
 {
   KApplication::showFile( "KA/Pi FAQ", "kdepim/kaddressbook/kapiFAQ.txt" );
 }
 
 
 void KABCore::fillSyncMenu()
 {
     if ( syncMenu->count() )
         syncMenu->clear();
     syncMenu->insertItem( i18n("Configure..."), 0 );
     syncMenu->insertSeparator();
     syncMenu->insertItem( i18n("Multiple sync"), 1 );
     syncMenu->insertSeparator();
     KConfig config ( locateLocal( "config","ksyncprofilesrc"  ) );
     config.setGroup("General");
     QStringList prof = config.readListEntry("SyncProfileNames");
     KABPrefs::instance()->mLocalMachineName = config.readEntry("LocalMachineName","undefined");
     if ( prof.count() < 3 ) {
         prof.clear();
         prof << i18n("Sharp_DTM");
         prof << i18n("Local_file");
         prof << i18n("Last_file");
         KSyncProfile* temp = new KSyncProfile ();
         temp->setName( prof[0] );
         temp->writeConfig(&config);
         temp->setName( prof[1] );
         temp->writeConfig(&config);
         temp->setName( prof[2] );
         temp->writeConfig(&config);
         config.setGroup("General");
         config.writeEntry("SyncProfileNames",prof);
         config.writeEntry("ExternSyncProfiles","Sharp_DTM");
         config.sync();
         delete temp;
     }
     KABPrefs::instance()->mExternSyncProfiles = config.readListEntry("ExternSyncProfiles");
     KABPrefs::instance()->mSyncProfileNames = prof;
     int i;
     for ( i = 0; i < prof.count(); ++i ) {
 
         syncMenu->insertItem(  prof[i], 1000+i );
         if ( i == 2 )
             syncMenu->insertSeparator();
     }
     QDir app_dir;
     if ( !app_dir.exists(QDir::homeDirPath()+"/Applications/dtm" ) ) {
         syncMenu->setItemEnabled( false , 1000 );
     }
     //probaly useless
     //mView->setupExternSyncProfiles();
 }
 void KABCore::slotSyncMenu( int action )
 {
     //qDebug("syncaction %d ", action);
     if ( action == 0 ) {
 
         // seems to be a Qt2 event handling bug
         // syncmenu.clear causes a segfault at first time
         // when we call it after the main event loop, it is ok
         // same behaviour when calling OM/Pi via QCOP for the first time
         QTimer::singleShot ( 1, this, SLOT ( confSync() ) ); 
         //confSync();
 
         return;
     }
     if ( action == 1 ) {
         multiSync( true );
         return;
     }
 
     if (mBlockSaveFlag)
       return;
     mBlockSaveFlag = true;
     mCurrentSyncProfile = action - 1000 ;
     mCurrentSyncDevice = KABPrefs::instance()->mSyncProfileNames[mCurrentSyncProfile] ;
     mCurrentSyncName =  KABPrefs::instance()->mLocalMachineName ;
     KConfig config ( locateLocal( "config","ksyncprofilesrc"  ) );
     KSyncProfile* temp = new KSyncProfile ();
     temp->setName(KABPrefs::instance()->mSyncProfileNames[mCurrentSyncProfile]);
     temp->readConfig(&config);
     KABPrefs::instance()->mAskForPreferences = temp->getAskForPreferences();
     KABPrefs::instance()->mSyncAlgoPrefs = temp->getSyncPrefs();
     KABPrefs::instance()->mWriteBackFile = temp->getWriteBackFile();
     KABPrefs::instance()->mWriteBackExistingOnly = temp->getWriteBackExisting();
     KABPrefs::instance()->mWriteBackInFuture = 0;
     if ( temp->getWriteBackFuture() )
         KABPrefs::instance()->mWriteBackInFuture =  temp->getWriteBackFutureWeeks( );
     KABPrefs::instance()->mShowSyncSummary = temp->getShowSummaryAfterSync();
     if ( action == 1000  ) {
         syncSharp();
 
     } else if ( action == 1001 ) {
         syncLocalFile();
 
     } else if ( action == 1002 ) {
         quickSyncLocalFile();
 
     } else if ( action >= 1003  ) {
         if ( temp->getIsLocalFileSync() ) {
             if ( syncWithFile( temp->getRemoteFileNameAB( ), false ) )
                 KABPrefs::instance()->mLastSyncedLocalFile = temp->getRemoteFileNameAB();
         } else {
             if (  temp->getIsPhoneSync() ) {
                 KABPrefs::instance()->mPhoneDevice = temp->getPhoneDevice( ) ;
                 KABPrefs::instance()->mPhoneConnection = temp->getPhoneConnection( );
                 KABPrefs::instance()->mPhoneModel = temp->getPhoneModel( );
                 syncPhone();
             } else
                 syncRemote( temp );
 
         }
     }
     delete temp;
     mBlockSaveFlag = false;
 }
 
 void KABCore::syncLocalFile()
 {
 
     QString fn =KABPrefs::instance()->mLastSyncedLocalFile;
 
     fn =KFileDialog:: getOpenFileName( fn, i18n("Sync filename(*.ics/*.vcs)"), this );
     if ( fn == "" )
         return;
     if (  syncWithFile(  fn, false ) ) {
         qDebug("syncLocalFile() successful ");
     }
 
 }
 bool  KABCore::syncWithFile( QString fn , bool quick )
 {
     bool ret = false;
     QFileInfo info;
     info.setFile( fn );
     QString mess;
     bool loadbup = true;
     if ( !info. exists() ) {
         mess =  i18n( "Sync file \n...%1\ndoes not exist!\nNothing synced!\n").arg(fn.right( 30) );
         int result = QMessageBox::warning( this, i18n("KO/Pi: Warning!"),
                                            mess );
         return ret;
     }
     int result = 0;
     if ( !quick ) {
         mess =  i18n("Sync with file \n...%1\nfrom:\n%2\n").arg(fn.right( 25)).arg(KGlobal::locale()->formatDateTime(info.lastModified (), true, false ));
         result = QMessageBox::warning( this, i18n("KO/Pi: Warning!"),
                                        mess,
                                        i18n("Sync"), i18n("Cancel"), 0,
                                        0, 1 );
         if ( result )
             return false;
     }
     if ( KABPrefs::instance()->mAskForPreferences )
         edit_sync_options();
     if ( result == 0 ) {
         //qDebug("Now sycing ... ");
         if ( ret = syncAB( fn, KABPrefs::instance()->mSyncAlgoPrefs ) )
             setCaption( i18n("Synchronization successful") );
         else
             setCaption( i18n("Sync cancelled or failed. Nothing synced.") );
         if ( ! quick )
             KABPrefs::instance()->mLastSyncedLocalFile = fn;
         setModified();
     }
     return ret;
 }
 void KABCore::quickSyncLocalFile()
 {
     
     if ( syncWithFile( KABPrefs::instance()->mLastSyncedLocalFile, false ) ) {
         qDebug("quick syncLocalFile() successful ");
       
     }
 }
 void KABCore::multiSync( bool askforPrefs  )
 {
     if (mBlockSaveFlag)
         return;
     mBlockSaveFlag = true;
     QString question = i18n("Do you really want\nto multiple sync\nwith all checked profiles?\nSyncing takes some\ntime - all profiles\nare synced twice!");
     if ( QMessageBox::information( this, i18n("KO/Pi Sync"),
                                    question,
                                    i18n("Yes"), i18n("No"),
                                    0, 0 ) != 0 ) {
         mBlockSaveFlag = false;
         setCaption(i18n("Aborted! Nothing synced!"));
         return;
     }
     mCurrentSyncDevice = i18n("Multiple profiles") ;
     KABPrefs::instance()->mSyncAlgoPrefs = KABPrefs::instance()->mRingSyncAlgoPrefs;
     if ( askforPrefs ) {
         edit_sync_options();
         KABPrefs::instance()->mRingSyncAlgoPrefs = KABPrefs::instance()->mSyncAlgoPrefs;
     }
     setCaption(i18n("Multiple sync started.") );
     qApp->processEvents();
     int num = ringSync() ;
     if (  num > 1 )
         ringSync();
     mBlockSaveFlag = false;
     if ( num )
         save();
     if ( num )
         setCaption(i18n("%1 profiles synced. Multiple sync completed!").arg(num) );
     else
         setCaption(i18n("Nothing synced! No profiles defined for multisync!"));
     return;
 }
 int KABCore::ringSync()
 {
     int syncedProfiles = 0;
     int i;
     QTime timer;
     KConfig config ( locateLocal( "config","ksyncprofilesrc"  ) );
     QStringList syncProfileNames = KABPrefs::instance()->mSyncProfileNames;
     KSyncProfile* temp = new KSyncProfile ();
     KABPrefs::instance()->mAskForPreferences = false;
     for ( i = 0; i < syncProfileNames.count(); ++i ) {
         mCurrentSyncProfile = i;
         temp->setName(syncProfileNames[mCurrentSyncProfile]);
         temp->readConfig(&config);
         if ( temp->getIncludeInRingSyncAB() && ( i < 1 || i > 2  )) {
             setCaption(i18n("Profile ")+syncProfileNames[mCurrentSyncProfile]+ i18n(" is synced ... "));
             ++syncedProfiles;
             // KABPrefs::instance()->mAskForPreferences = temp->getAskForPreferences();
             KABPrefs::instance()->mWriteBackFile = temp->getWriteBackFile();
             KABPrefs::instance()->mWriteBackExistingOnly = temp->getWriteBackExisting();
             KABPrefs::instance()->mWriteBackInFuture = 0;
             if ( temp->getWriteBackFuture() )
                 KABPrefs::instance()->mWriteBackInFuture =  temp->getWriteBackFutureWeeks( );
             KABPrefs::instance()->mShowSyncSummary = false;
             mCurrentSyncDevice = syncProfileNames[i] ;
             mCurrentSyncName = KABPrefs::instance()->mLocalMachineName;
             if ( i == 0 ) {
                 syncSharp();
             } else {
                 if ( temp->getIsLocalFileSync() ) {
                     if ( syncWithFile( temp->getRemoteFileNameAB( ), true ) )
                         KABPrefs::instance()->mLastSyncedLocalFile = temp->getRemoteFileNameAB();
                 } else {
                     if (  temp->getIsPhoneSync() ) {
                         KABPrefs::instance()->mPhoneDevice = temp->getPhoneDevice( ) ;
                         KABPrefs::instance()->mPhoneConnection = temp->getPhoneConnection( );
                         KABPrefs::instance()->mPhoneModel = temp->getPhoneModel( );
                         syncPhone();
                     } else
                         syncRemote( temp, false );
 
                 }
             }
             timer.start();
             setCaption(i18n("Multiple sync in progress ... please wait!") );
             while ( timer.elapsed () < 2000 ) {
                 qApp->processEvents();
 #ifndef _WIN32_
                 sleep (1);
 #endif
             }
 
         }
 
     }
     delete temp;
     return syncedProfiles;
 }
 
 void KABCore::syncRemote( KSyncProfile* prof,  bool ask)
 {
     QString question;
     if ( ask ) {
     question = i18n("Do you really want\nto remote sync\nwith profile \n")+ prof->getName()+" ?\n";
     if ( QMessageBox::information( this, i18n("KO/Pi Sync"),
                                    question,
                                    i18n("Yes"), i18n("No"),
                                    0, 0 ) != 0 )
         return;
     }
     QString command = prof->getPreSyncCommandAB();
     int fi;
     if ( (fi = command.find("$PWD$")) > 0 ) {
         QString pwd = getPassword();
         command = command.left( fi )+ pwd + command.mid( fi+5 );
 
     }
     int maxlen = 30;
     if ( QApplication::desktop()->width() > 320 )
         maxlen += 25;
     setCaption ( i18n( "Copy remote file to local machine..." ) );
     int fileSize = 0;
     int result = system ( command );
     // 0 : okay
     // 256: no such file or dir
     //
     qDebug("KO: Remote copy result(0 = okay): %d ",result );
     if ( result != 0 ) {
         int len = maxlen;
         while ( len <  command.length() ) {
             command.insert( len , "\n" );
             len += maxlen +2;
         }
         question = i18n("Sorry, the copy command failed!\nCommand was:\n%1\n \nTry command on console to get more\ndetailed info about the reason.\n").arg (command) ;
         QMessageBox::information( this, i18n("KO/Pi Sync - ERROR"),
                                   question,
                                   i18n("Okay!")) ;
         setCaption ("KO/Pi");
         return;
     }
     setCaption ( i18n( "Copying succeed." ) );
     //qDebug(" file **%s** ",prof->getLocalTempFile().latin1() );
     if ( syncWithFile( prof->getLocalTempFileAB(), true ) ) {
 //         Event* e = mView->getLastSyncEvent();
 //         e->setReadOnly( false );
 //         e->setLocation( KOPrefs::instance()->mSyncProfileNames[mCurrentSyncProfile]);
 //         e->setReadOnly( true );
         if ( KABPrefs::instance()->mWriteBackFile ) {
             command =  prof->getPostSyncCommandAB(); 
             int fi;
             if ( (fi = command.find("$PWD$")) > 0 ) {
                 QString pwd = getPassword();
                 command = command.left( fi )+ pwd + command.mid( fi+5 );
                 
             }
             setCaption ( i18n( "Writing back file ..." ) );
             result = system ( command );
             qDebug("KO: Writing back file result: %d ", result);
             if ( result != 0 ) {
                 setCaption ( i18n( "Writing back file result: " )+QString::number( result ) );
                 return;
             } else {
                 setCaption ( i18n( "Syncronization sucessfully completed" ) );
             }
         }
     }
     return;
 }
 #include <qpushbutton.h>
 #include <qradiobutton.h>
 #include <qbuttongroup.h>
 void KABCore::edit_sync_options()
 {
     //mDialogManager->showSyncOptions();
     //KABPrefs::instance()->mSyncAlgoPrefs 
     QDialog dia( this, "dia", true );
     dia.setCaption( i18n("Device: " ) +mCurrentSyncDevice );
     QButtonGroup gr ( 1,  Qt::Horizontal, i18n("Sync preferences"), &dia);
     QVBoxLayout lay ( &dia );
     lay.setSpacing( 2 );
     lay.setMargin( 3 );
     lay.addWidget(&gr);
     QRadioButton loc ( i18n("Take local entry on conflict"), &gr );
     QRadioButton rem ( i18n("Take remote entry on conflict"), &gr );
     QRadioButton newest( i18n("Take newest entry on conflict"), &gr );
     QRadioButton ask( i18n("Ask for every entry on conflict"), &gr );
     QRadioButton f_loc( i18n("Force: Take local entry always"), &gr );
     QRadioButton f_rem( i18n("Force: Take remote entry always"), &gr );
     //QRadioButton both( i18n("Take both on conflict"), &gr );
     QPushButton pb ( "OK",  &dia); 
     lay.addWidget( &pb );
     connect(&pb, SIGNAL( clicked() ), &dia, SLOT ( accept() ) ); 
     switch ( KABPrefs::instance()->mSyncAlgoPrefs ) {
     case 0:
         loc.setChecked( true);
         break;
     case 1:
         rem.setChecked( true );
         break;
     case 2:
         newest.setChecked( true);
         break;
     case 3:
         ask.setChecked( true);
         break;
     case 4:
         f_loc.setChecked( true);
         break;
     case 5:
         f_rem.setChecked( true);
         break;
     case 6:
         // both.setChecked( true);
         break; 
     default:
         break;
     }
     if ( dia.exec() ) {
         KABPrefs::instance()->mSyncAlgoPrefs = rem.isChecked()*1+newest.isChecked()*2+  ask.isChecked()*3+  f_loc.isChecked()*4+  f_rem.isChecked()*5;//+  both.isChecked()*6 ;
     }
    
 
 }
 QString  KABCore::getPassword( )
 {
     QString retfile = "";
     QDialog dia ( this, "input-dialog", true );
     QLineEdit lab ( &dia );
     lab.setEchoMode( QLineEdit::Password );
     QVBoxLayout lay( &dia );
     lay.setMargin(7);
     lay.setSpacing(7);
     lay.addWidget( &lab);
     dia.setFixedSize( 230,50 );
     dia.setCaption( i18n("Enter password") );
     QPushButton pb ( "OK",  &dia);
     lay.addWidget( &pb );
     connect(&pb, SIGNAL( clicked() ), &dia, SLOT ( accept() ) );
     dia.show();
     int res = dia.exec();
     if ( res )
         retfile = lab.text();
     dia.hide();
     qApp->processEvents();
     return retfile;
 
 }
 #include <libkcal/syncdefines.h>
 
 KABC::Addressee KABCore::getLastSyncAddressee()
 {
     Addressee lse; 
     //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();
     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;
     //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;
     QProgressBar bar( er.count(),0 );
     bar.setCaption (i18n("Syncing - close to abort!") );
     
     int w = 300;
     if ( QApplication::desktop()->width() < 320 )
         w = 220;
     int h = bar.sizeHint().height() ;
     int dw = QApplication::desktop()->width();
     int dh = QApplication::desktop()->height();
     bar.setGeometry( (dw-w)/2, (dh - h )/2 ,w,h );
     bar.show();
     int modulo = (er.count()/10)+1;
     int incCounter = 0;
     while ( incCounter < er.count()) {
         if ( ! bar.isVisible() )
             return false;
         if ( incCounter % modulo == 0 )
             bar.setProgress( 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 ( 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;
     bar.setCaption (i18n("Add / remove addressees") ); 
     bar.setTotalSteps (  el.count()  ) ;
     bar.show();
     incCounter = 0;
     while ( incCounter < el.count()) {
         qApp->processEvents();
         if ( ! bar.isVisible() )
             return false;
         if ( incCounter % modulo == 0 )
             bar.setProgress( incCounter );
         uid = el[ incCounter ]; 
         bool skipIncidence = false;
         if ( uid.left(19) == QString("last-syncAddressee-") )
             skipIncidence = true;
         if ( !skipIncidence )  {
             inL = local->findByUid( uid );
             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 ( ! KABPrefs::instance()->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 ( ! KABPrefs::instance()->mWriteBackExistingOnly ) {
                             ++addedAddresseeR; 
                             inL.setRevision( modifiedCalendar );
                             local->insertAddressee( inL, false );
                             inR = inL;
                             inR.setResource( 0 );
                             remote->insertAddressee( inR, false );
                         }
                     }
                 }
             }
         }
         ++incCounter;
     }
     el.clear();
     bar.hide();
     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 ( KABPrefs::instance()->mShowSyncSummary ) {
         KMessageBox::information(this, mes, i18n("KA/Pi Synchronization") );
     }
     qDebug( mes );
     return syncOK;
 }
 
 bool KABCore::syncAB(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;
     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 );
         } else {
             Addressee lse =   mAddressBook->findByUid( "last-syncAddressee-"+mCurrentSyncDevice );
             if ( ! lse.isEmpty() ) {
                 if ( lse.familyName().left(4) == "!E: " )
                     external = true;
             } else {
                 bool found = false;
                 AddressBook::Iterator it;
                 for ( it = abLocal.begin(); it != abLocal.end(); ++it ) {
                     if ( (*it).revision().date().year() > 2003 ) {
                         found = true;
                         break;
                     }
                 }
                 external = ! found;
             }
 
             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 ( KABPrefs::instance()->mWriteBackFile )
                 {
                     if ( external )
                         abLocal.removeSyncAddressees( !isXML);
                     qDebug("Saving remote AB ");
                     abLocal.saveAB();
                     if ( isXML ) {
                         // afterwrite processing
                         abLocal.postExternSync( mAddressBook,mCurrentSyncDevice );
                     }
                 }
         }
         setModified();
         
     }
     if ( syncOK )
         mViewManager->refreshView();
     return syncOK;
 #if 0
 
     if ( storage->load(KOPrefs::instance()->mUseQuicksave) ) {
         getEventViewerDialog()->setSyncMode( true );
         syncOK = synchronizeCalendar( mCalendar, calendar, mode );
         getEventViewerDialog()->setSyncMode( false );
         if (  syncOK ) {
            if ( KOPrefs::instance()->mWriteBackFile )
             {
                 storage->setSaveFormat( new ICalFormat( KOPrefs::instance()->mUseQuicksave) );
                 storage->save();
             }
         }
         setModified();
     }
   
 #endif
 }
 
 void KABCore::confSync()
 { 
     static KSyncPrefsDialog* sp = 0;
     if ( ! sp ) {
         sp = new KSyncPrefsDialog( this, "syncprefs", true );
     }
     sp->usrReadConfig();
 #ifndef DESKTOP_VERSION
     sp->showMaximized();
 #else
     sp->show();
 #endif
     sp->exec();
     KABPrefs::instance()->mSyncProfileNames = sp->getSyncProfileNames();
     KABPrefs::instance()->mLocalMachineName = sp->getLocalMachineName ();
     fillSyncMenu();
 }
 void KABCore::syncSharp()
 {
     if ( ! syncExternal("sharp") )
         qDebug("ERROR sync sharp  ");;
 }
 bool KABCore::syncExternal(QString  resource)
 {
     if (  mModified  )
         save();
     if ( KABPrefs::instance()->mAskForPreferences )
         edit_sync_options();
     qDebug("syncSharp() ");
     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 );
         syncOK = synchronizeAddressbooks( mAddressBook, &abLocal, KABPrefs::instance()->mSyncAlgoPrefs );
         if (  syncOK ) {
             if ( KABPrefs::instance()->mWriteBackFile ) {
                 abLocal.saveAB();
                 abLocal.postExternSync( mAddressBook,mCurrentSyncDevice );
             }
         }
         setModified();
     }
     if ( syncOK )
         mViewManager->refreshView();
     return syncOK;
 
 }
 void KABCore::syncPhone()
 {
     if ( mModified  )
         save();
     qDebug("pending syncPhone(); ");
     //mView->syncPhone();
     setModified();
 
 }
diff --git a/korganizer/calendarview.cpp b/korganizer/calendarview.cpp
index bbed05b..7fae4a9 100644
--- a/korganizer/calendarview.cpp
+++ b/korganizer/calendarview.cpp
@@ -1,3612 +1,3616 @@
 /*
   This file is part of KOrganizer.
 
   Requires the Qt and KDE widget libraries, available at no cost at
   http://www.troll.no and http://www.kde.org respectively
 
   Copyright (c) 1997, 1998, 1999
   Preston Brown (preston.brown@yale.edu)
   Fester Zigterman (F.J.F.ZigtermanRustenburg@student.utwente.nl)
   Ian Dawes (iadawes@globalserve.net)
   Laszlo Boloni (boloni@cs.purdue.edu)
 
   Copyright (c) 2000, 2001, 2002
   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.
 */
 
 #include <stdlib.h>
 
 #include <qapplication.h>
 #include <qradiobutton.h>
 #include <qbuttongroup.h>
 #include <qlayout.h>
 #include <qclipboard.h>
 #include <qcursor.h>
 #include <qmessagebox.h>
 #include <qprogressbar.h>
 #include <qmultilineedit.h>
 #include <qtimer.h>
 #include <qwidgetstack.h>
 #include <qptrlist.h>
 #include <qregexp.h>
 #include <qgroupbox.h>
 #include <qfile.h>
 #include <qdir.h>
 #ifndef KORG_NOSPLITTER
 #include <qsplitter.h>
 #endif
 
 #include <kglobal.h>
 #include <kdebug.h>
 #include <kstandarddirs.h>
 #include <kfiledialog.h>
 #include <kmessagebox.h>
 #include <knotifyclient.h>
 #include <kconfig.h>
 
 #include <libkdepim/ksyncprefsdialog.h>
 #include <krun.h>
 #include <kdirwatch.h>
 #include <libkdepim/kdatepicker.h>
 #include <libkdepim/ksyncprofile.h>
 
 #include <libkcal/vcaldrag.h>
 #include <libkcal/icaldrag.h>
 #include <libkcal/icalformat.h>
 #include <libkcal/vcalformat.h>
 #include <libkcal/scheduler.h>
 #include <libkcal/calendarlocal.h>
 #include <libkcal/journal.h>
 #include <libkcal/calfilter.h>
 #include <libkcal/attendee.h>
 #include <libkcal/dndfactory.h>
 #include <libkcal/freebusy.h>
 #include <libkcal/filestorage.h>
 #include <libkcal/calendarresources.h>
 #include <libkcal/qtopiaformat.h>
 #include "../kalarmd/alarmdialog.h"
 
 #ifndef DESKTOP_VERSION
 #include <libkcal/sharpformat.h>
 #endif
 #include <libkcal/phoneformat.h>
 #ifndef KORG_NOMAIL
 #include "komailclient.h"
 #endif
 #ifndef KORG_NOPRINTER
 #include "calprinter.h"
 #endif
 #ifndef KORG_NOPLUGINS
 #include "kocore.h"
 #endif
 #include "koeventeditor.h"
 #include "kotodoeditor.h"
 #include "koprefs.h"
 #include "koeventviewerdialog.h"
 #include "publishdialog.h"
 #include "kofilterview.h"
 #include "koglobals.h"
 #include "koviewmanager.h"
 #include "koagendaview.h"
 #include "kodialogmanager.h"
 #include "outgoingdialog.h"
 #include "incomingdialog.h"
 #include "statusdialog.h"
 #include "kdatenavigator.h"
 #include "kotodoview.h"
 #include "datenavigator.h"
 #include "resourceview.h"
 #include "navigatorbar.h"
 #include "searchdialog.h"
 #include "mainwindow.h"
 
 #include "calendarview.h"
 #ifndef DESKTOP_VERSION
 #include <qtopia/alarmserver.h> 
 #endif
 #ifndef _WIN32_
 #include <stdlib.h>
 #include <stdio.h>
 #include <unistd.h>
 #else
 #include <qprocess.h>
 #endif
 using namespace KOrg;
 using namespace KCal;
 extern int globalFlagBlockAgenda;
 extern int globalFlagBlockStartup;
 
 
 
 class KOBeamPrefs : public QDialog
 {
   public:
     KOBeamPrefs( QWidget *parent=0, const char *name=0 ) :
       QDialog( parent, name, true ) 
     {
         setCaption( i18n("Beam Options") );
         QVBoxLayout* lay = new QVBoxLayout( this );
         lay->setSpacing( 3 );
         lay->setMargin( 3 );
         QButtonGroup* format = new  QButtonGroup( 1, Horizontal, i18n("File format"), this );
         lay->addWidget( format ); 
         format->setExclusive ( true ) ;
         QButtonGroup* time = new  QButtonGroup(1, Horizontal, i18n("Time format"), this );
         lay->addWidget( time ); time->setExclusive ( true ) ;
         vcal = new QRadioButton(" vCalendar ", format );
         ical = new QRadioButton(" iCalendar ", format );
         vcal->setChecked( true );
         tz = new QRadioButton(i18n(" With timezone "), time );
         local = new QRadioButton(i18n(" Local time "), time );
         tz->setChecked( true );
         QPushButton * ok = new QPushButton( i18n("Beam via IR!"), this );
         lay->addWidget( ok );
         QPushButton * cancel = new QPushButton( i18n("Cancel"), this );
         lay->addWidget( cancel );
         connect ( ok,SIGNAL(clicked() ),this , SLOT ( accept() )  );
         connect (cancel, SIGNAL(clicked() ), this, SLOT ( reject())  );
         resize( 200, 200 );
     }
       
     bool beamVcal() { return vcal->isChecked(); }
     bool beamLocal() { return local->isChecked(); }
 private:
     QRadioButton* vcal, *ical, *local, *tz;
 };
 class KOCatPrefs : public QDialog
 {
   public:
     KOCatPrefs( QWidget *parent=0, const char *name=0 ) :
       QDialog( parent, name, true ) 
     {
         setCaption( i18n("Manage new Categories") );
         QVBoxLayout* lay = new QVBoxLayout( this );
         lay->setSpacing( 3 );
         lay->setMargin( 3 );
         QLabel * lab = new QLabel( i18n("After importing/loading/syncing\nthere may be new categories in\nevents or todos\nwhich are not in the category list.\nPlease choose what to do:\n "), this );
         lay->addWidget( lab ); 
         QButtonGroup* format = new  QButtonGroup( 1, Horizontal, i18n("New categories not in list:"), this );
         lay->addWidget( format ); 
         format->setExclusive ( true ) ;
         addCatBut = new QRadioButton(i18n("Add to category list"), format );
         new QRadioButton(i18n("Remove from Events/Todos"), format );
         addCatBut->setChecked( true );
         QPushButton * ok = new QPushButton( i18n("OK"), this );
         lay->addWidget( ok );
         QPushButton * cancel = new QPushButton( i18n("Cancel"), this );
         lay->addWidget( cancel );
         connect ( ok,SIGNAL(clicked() ),this , SLOT ( accept() )  );
         connect (cancel, SIGNAL(clicked() ), this, SLOT ( reject())  );
         resize( 200, 200 );
     }
       
     bool addCat() { return addCatBut->isChecked(); }
 private:
     QRadioButton* addCatBut;
 };
 
 
 
 CalendarView::CalendarView( CalendarResources *calendar,
                             QWidget *parent, const char *name )
     : CalendarViewBase( parent, name ),
       mCalendar( calendar ),
       mResourceManager( calendar->resourceManager() )
 {
 
     mEventEditor = 0;
     mTodoEditor = 0;
  
     init();
 }
 
 CalendarView::CalendarView( Calendar *calendar,
                             QWidget *parent, const char *name )
     : CalendarViewBase( parent, name ),
       mCalendar( calendar ),
       mResourceManager( 0 )
 {
  
     mEventEditor = 0;
     mTodoEditor = 0;
     init();}
 
 void CalendarView::init()
 { 
     beamDialog = new KOBeamPrefs();
     mDatePickerMode = 0;
     mCurrentSyncDevice = "";
     writeLocale();
     mViewManager = new KOViewManager( this );
     mDialogManager = new KODialogManager( this );
     mEventViewerDialog = 0;
     mModified = false;
     mReadOnly = false;
     mSelectedIncidence = 0;
     mCalPrinter = 0;
     mFilters.setAutoDelete(true);
 
     mCalendar->registerObserver( this );
     // TODO: Make sure that view is updated, when calendar is changed.
 
     mStorage = new FileStorage( mCalendar );
     mNavigator = new DateNavigator( this, "datevav", mViewManager );
 
     QBoxLayout *topLayout = (QBoxLayout*)layout();
 #ifndef KORG_NOSPLITTER
     // create the main layout frames.
     mPanner = new QSplitter(QSplitter::Horizontal,this,"CalendarView::Panner");
     topLayout->addWidget(mPanner);
 
     mLeftSplitter = new QSplitter(QSplitter::Vertical,mPanner,
                                   "CalendarView::LeftFrame");
     mPanner->setResizeMode(mLeftSplitter,QSplitter::KeepSize);
 
     mDateNavigator = new KDateNavigator(mLeftSplitter, mCalendar, TRUE,
                                         "CalendarView::DateNavigator", QDate::currentDate() );
     mLeftSplitter->setResizeMode(mDateNavigator,QSplitter::KeepSize);
     mTodoList = new KOTodoView(mCalendar, mLeftSplitter, "todolist_small2");
     mFilterView = new KOFilterView(&mFilters,mLeftSplitter,"CalendarView::FilterView");
 
 #ifdef KORG_NORESOURCEVIEW 
     mResourceView = 0;
 #else
     if ( mResourceManager ) {
         mResourceView = new ResourceView( mResourceManager, mLeftSplitter );
         mResourceView->updateView();
         connect( mResourceView, SIGNAL( resourcesChanged() ),
                  SLOT( updateView() ) );
     } else {
         mResourceView = 0;
     }
 #endif
     QWidget *rightBox = new QWidget( mPanner );
     QBoxLayout *rightLayout = new QVBoxLayout( rightBox );
 
     mNavigatorBar = new NavigatorBar( QDate::currentDate(), rightBox, "useBigPixmaps" );
     rightLayout->addWidget( mNavigatorBar );
 
     mRightFrame = new QWidgetStack( rightBox );
     rightLayout->addWidget( mRightFrame, 1 );
 
     mLeftFrame = mLeftSplitter;
 #else
     QWidget *mainBox = new QWidget( this );
     QWidget *leftFrame = new QWidget( mainBox );
 
     QBoxLayout * mainBoxLayout;
     QBoxLayout * leftFrameLayout;
     if ( KOPrefs::instance()->mVerticalScreen ) {
         mainBoxLayout  = new QVBoxLayout(mainBox); 
         leftFrameLayout = new QHBoxLayout(leftFrame ); 
     } else {
         mainBoxLayout  = new QHBoxLayout(mainBox);
         leftFrameLayout = new  QVBoxLayout(leftFrame ); 
     }
     topLayout->addWidget( mainBox );
     mainBoxLayout->addWidget (leftFrame);
     mDateNavigator = new KDateNavigator(leftFrame, mCalendar, TRUE,
                                         "CalendarView::DateNavigator", QDate::currentDate());
     // mDateNavigator->blockSignals( true );
     leftFrameLayout->addWidget( mDateNavigator  );
     mFilterView = new KOFilterView(&mFilters,leftFrame,"CalendarView::FilterView");
     mTodoList = new KOTodoView(mCalendar, leftFrame, "todolist");
     
     if (  QApplication::desktop()->width() < 480 ) {
         leftFrameLayout->addWidget(mFilterView);
         leftFrameLayout->addWidget(mTodoList, 2 );
       
     } else {
         leftFrameLayout->addWidget(mTodoList,2 );
         leftFrameLayout->addWidget(mFilterView );
     } 
     mFilterView->hide();
     QWidget *rightBox = new QWidget( mainBox );
     mainBoxLayout->addWidget ( rightBox, 10 );
     QBoxLayout *rightLayout = new QVBoxLayout( rightBox );
     mNavigatorBar = new NavigatorBar( QDate::currentDate(), rightBox, "useBigPixmaps" );
     mRightFrame = new QWidgetStack( rightBox );
     rightLayout->addWidget( mNavigatorBar );
     rightLayout->addWidget( mRightFrame, 10 );
 
     mLeftFrame = leftFrame;
     if ( KOPrefs::instance()->mVerticalScreen ) {
         mTodoList->setFixedHeight( mDateNavigator->sizeHint().height() );
         leftFrame->setFixedHeight( mDateNavigator->sizeHint().height() );
     } else {
         mTodoList->setFixedWidth( mDateNavigator->sizeHint().width() );
         leftFrame->setFixedWidth( mDateNavigator->sizeHint().width() );
     }
  
     //qDebug("Calendarview Size %d %d ", width(), height());
 #endif
  
     connect( mNavigator, SIGNAL( datesSelected( const KCal::DateList & ) ),
              SLOT( showDates( const KCal::DateList & ) ) );
     connect( mNavigator, SIGNAL( datesSelected( const KCal::DateList & ) ),
              mDateNavigator, SLOT( selectDates( const KCal::DateList & ) ) );
 
     connect( mNavigatorBar, SIGNAL( goPrevYear() ),
              mNavigator, SLOT( selectPreviousYear() ) );
     connect( mNavigatorBar, SIGNAL( goNextYear() ),
              mNavigator, SLOT( selectNextYear() ) );
     connect( mNavigatorBar, SIGNAL( goPrevMonth() ),
              mNavigator, SLOT( selectPreviousMonth() ) );
     connect( mNavigatorBar, SIGNAL( goNextMonth() ),
              mNavigator, SLOT( selectNextMonth() ) );
 
     connect( mNavigator, SIGNAL( datesSelected( const KCal::DateList & ) ),
              mNavigatorBar, SLOT( selectDates( const KCal::DateList & ) ) );
 
     connect( mDateNavigator, SIGNAL( weekClicked( const QDate & ) ),
              mNavigator, SLOT( selectWeek( const QDate & ) ) );
 
     connect( mDateNavigator, SIGNAL( goPrevYear() ),
              mNavigator, SLOT( selectPreviousYear() ) );
     connect( mDateNavigator, SIGNAL( goNextYear() ),
              mNavigator, SLOT( selectNextYear() ) );
     connect( mDateNavigator, SIGNAL( goPrevMonth() ),
              mNavigator, SLOT( selectPreviousMonth() ) );
     connect( mDateNavigator, SIGNAL( goNextMonth() ),
              mNavigator, SLOT( selectNextMonth() ) );
 
     connect( mDateNavigator, SIGNAL( goPrevious() ),
              mNavigator, SLOT( selectPrevious() ) );
     connect( mDateNavigator, SIGNAL( goNext() ),
              mNavigator, SLOT( selectNext() ) );
     connect( mDateNavigator, SIGNAL( monthSelected ( int ) ),
              mNavigator, SLOT( slotMonthSelect( int ) ) );
     connect( mNavigatorBar, SIGNAL( monthSelected ( int ) ),
              mNavigator, SLOT( slotMonthSelect( int ) ) );
 
     connect( mDateNavigator, SIGNAL( datesSelected( const KCal::DateList & ) ),
              mNavigator, SLOT( selectDates( const KCal::DateList & ) ) );
 
     connect( mDateNavigator, SIGNAL( eventDropped( Event * ) ),
              SLOT( eventAdded( Event *) ) );
 
     connect(mDateNavigator,SIGNAL(dayPassed(QDate)),SLOT(updateView()));
 
     connect( this, SIGNAL( configChanged() ),
              mDateNavigator, SLOT( updateConfig() ) );
 
     connect( mTodoList, SIGNAL( newTodoSignal() ),
              SLOT( newTodo() ) );
     connect( mTodoList, SIGNAL( newSubTodoSignal( Todo *) ),
              SLOT( newSubTodo( Todo * ) ) );
     connect( mTodoList, SIGNAL( editTodoSignal( Todo * ) ),
              SLOT( editTodo( Todo * ) ) );
     connect( mTodoList, SIGNAL( showTodoSignal( Todo * ) ),
              SLOT( showTodo( Todo *) ) );
     connect( mTodoList, SIGNAL( deleteTodoSignal( Todo *) ),
              SLOT( deleteTodo( Todo *) ) );
     connect( this, SIGNAL( configChanged()), mTodoList, SLOT( updateConfig() ) );
     connect( mTodoList, SIGNAL( purgeCompletedSignal() ),
              SLOT( purgeCompleted() ) );
     connect( mTodoList, SIGNAL( todoModifiedSignal( Todo *, int ) ),
              SIGNAL( todoModified( Todo *, int ) ) );
 
     connect( mTodoList, SIGNAL( cloneTodoSignal( Incidence *  ) ),
              this, SLOT ( cloneIncidence( Incidence * ) ) );
     connect( mTodoList, SIGNAL( cancelTodoSignal( Incidence *  ) ),
              this, SLOT (cancelIncidence( Incidence * ) ) );
 
     connect( mTodoList, SIGNAL( moveTodoSignal( Incidence *  ) ),
              this, SLOT ( moveIncidence( Incidence * ) ) );
     connect( mTodoList, SIGNAL( beamTodoSignal( Incidence *  ) ),
             this, SLOT ( beamIncidence( Incidence * ) ) );
   
     connect( mTodoList, SIGNAL( unparentTodoSignal( Todo * ) ),
              this, SLOT ( todo_unsub( Todo * ) ) );
   
     connect( this, SIGNAL( todoModified( Todo *, int )), mTodoList,
              SLOT( updateTodo( Todo *, int ) ) );
     connect( this, SIGNAL( todoModified( Todo *, int )), this,
              SLOT( changeTodoDisplay( Todo *, int ) ) );
 
 
     connect( mFilterView, SIGNAL( filterChanged() ), SLOT( updateFilter() ) );
     connect( mFilterView, SIGNAL( editFilters() ), SLOT( editFilters() ) );
     connect( mCalendar, SIGNAL( addAlarm(const QDateTime &, const QString &  ) ), SLOT( addAlarm(const QDateTime &, const QString &  ) ) );
     connect( mCalendar, SIGNAL( removeAlarm(const QDateTime &, const QString &  ) ), SLOT( removeAlarm(const QDateTime &, const QString & ) ) );
   
 
 
 
 
     connect(QApplication::clipboard(),SIGNAL(dataChanged()),
             SLOT(checkClipboard()));
     connect( mTodoList,SIGNAL( incidenceSelected( Incidence * ) ),
              SLOT( processTodoListSelection( Incidence * ) ) );
     connect(mTodoList,SIGNAL(isModified(bool)),SLOT(setModified(bool)));
 
     // kdDebug() << "CalendarView::CalendarView() done" << endl; 
 
     mDateFrame = new QVBox(0,0,WType_Popup);
     //mDateFrame->setFrameStyle(QFrame::PopupPanel | QFrame::Raised);
     mDateFrame->setFrameStyle( QFrame::WinPanel |QFrame::Raised );
     mDateFrame->setLineWidth(3);
     mDateFrame->hide(); 
     mDateFrame->setCaption( i18n( "Pick a date to display"));
     mDatePicker = new KDatePicker ( mDateFrame , QDate::currentDate() );
  
     connect(mDatePicker,SIGNAL(dateSelected(QDate)),SLOT(slotSelectPickerDate(QDate)));
  
     mEventEditor = mDialogManager->getEventEditor();  
     mTodoEditor = mDialogManager->getTodoEditor();  
    
     mFlagEditDescription = false; 
 
     mSuspendTimer = new QTimer( this );
     mAlarmTimer = new QTimer( this );
     mRecheckAlarmTimer = new QTimer( this );
     connect( mRecheckAlarmTimer, SIGNAL(  timeout ()  ), SLOT( recheckTimerAlarm() ) );
     connect( mSuspendTimer, SIGNAL(  timeout ()  ), SLOT( suspendAlarm() ) );
     connect( mAlarmTimer, SIGNAL(  timeout ()  ), SLOT( timerAlarm() ) );
     mAlarmDialog = new AlarmDialog( this );
     connect( mAlarmDialog, SIGNAL( addAlarm(const QDateTime &, const QString &  ) ), SLOT( addSuspendAlarm(const QDateTime &, const QString &  ) ) );
     mAlarmDialog->setServerNotification( false );
     mAlarmDialog->setSuspendTime( KOPrefs::instance()->mAlarmSuspendTime );
 }
 
 
 CalendarView::~CalendarView()
 {
     // kdDebug() << "~CalendarView()" << endl;
     //qDebug("CalendarView::~CalendarView() ");
     delete mDialogManager;
     delete mViewManager;
     delete mStorage;
     delete mDateFrame ;
     delete beamDialog;
     //kdDebug() << "~CalendarView() done" << endl;
 }
 void CalendarView::timerAlarm()
 {
     //qDebug("CalendarView::timerAlarm() ");
     computeAlarm(mAlarmNotification );
 }
 
 void CalendarView::suspendAlarm()
 {
     //qDebug(" CalendarView::suspendAlarm() ");
     computeAlarm(mSuspendAlarmNotification );
 
 }
 
 void  CalendarView::startAlarm( QString mess , QString filename)
 {
     mAlarmDialog->eventNotification( mess, KOPrefs::instance()->mAlarmPlayBeeps, filename, true,KOPrefs::instance()->mAlarmBeepInterval ,KOPrefs::instance()->mAlarmSuspendCount );
     QTimer::singleShot( 3000, this, SLOT( checkNextTimerAlarm() ) );
 
 }
     
 void CalendarView::checkNextTimerAlarm()
 {
     mCalendar->checkAlarmForIncidence( 0, true );
 }
 
 void  CalendarView::computeAlarm( QString msg )
 {
 
  QString mess = msg; 
     QString  mAlarmMessage = mess.mid( 9 ); 
     QString filename =  MainWindow::resourcePath();
     filename += "koalarm.wav";
     QString tempfilename;
     if ( mess.left( 13 )  == "suspend_alarm") {  
         bool error = false;
         int len = mess.mid( 13 ).find("+++");
         if ( len < 2 )
             error = true;
         else {
             tempfilename = mess.mid( 13, len );
             if ( !QFile::exists( tempfilename  ) )
                 error = true;
         }
         if ( ! error ) {
             filename = tempfilename;
         }
         mAlarmMessage = mess.mid( 13+len+3 );
         //qDebug("suspend file %s ",tempfilename.latin1() );
         startAlarm( mAlarmMessage, filename);
         return;
     }
     if ( mess.left( 11 )  == "timer_alarm") {
         //mTimerTime = 0;
         startAlarm( mess.mid( 11 ), filename );
         return;
     } 
     if ( mess.left( 10 )  == "proc_alarm") {
         bool error = false;
         int len = mess.mid( 10 ).find("+++");
         if ( len < 2 )
             error = true;
         else {
             tempfilename = mess.mid( 10, len );
             if ( !QFile::exists( tempfilename  ) )
                 error = true;
         }
         if ( error ) {
             mAlarmMessage = "Procedure Alarm\nError - File not found\n";
             mAlarmMessage += mess.mid( 10+len+3+9 );
         } else {
             //QCopEnvelope e("QPE/Application/kopi", "-writeFileSilent");
             //qDebug("-----system command %s ",tempfilename.latin1() );
 #ifndef _WIN32_
             if ( vfork () == 0 ) {
                 execl ( tempfilename.latin1(), 0 );
                 return;
             }
 #else
                 QProcess* p = new QProcess();
                 p->addArgument(  tempfilename.latin1()  );
                 p->start();
                 return;
 #endif
             
             return;
         }
        
         //qDebug("+++++++system command %s ",tempfilename.latin1() );
     }  
     if ( mess.left( 11 )  == "audio_alarm") {
         bool error = false;
         int len = mess.mid( 11 ).find("+++");
         if ( len < 2 )
             error = true;
         else {
             tempfilename = mess.mid( 11, len );
             if ( !QFile::exists( tempfilename  ) )
                 error = true;
         }
         if ( ! error ) {
             filename = tempfilename;
         }
         mAlarmMessage = mess.mid( 11+len+3+9 );
         //qDebug("audio file command %s ",tempfilename.latin1() );
     } 
     if ( mess.left( 9 )  == "cal_alarm") {
         mAlarmMessage = mess.mid( 9 ) ;
     }
     
     startAlarm( mAlarmMessage, filename );
 
 
 }
 
 void CalendarView::addSuspendAlarm(const QDateTime &qdt, const QString &noti  )
 {
     //qDebug("+++++addSUSPENDAlarm %s %s ", qdt.toString().latin1() , noti.latin1() );
    
     mSuspendAlarmNotification = noti;
     int ms = QDateTime::currentDateTime().secsTo( qdt )*1000;
     //qDebug("Suspend Alarm timer started with secs: %d ", ms/1000);
     mSuspendTimer->start( ms , true );
 
 }
 
 void CalendarView::addAlarm(const QDateTime &qdt, const QString &noti  )
 {
     //qDebug("+++++addAlarm %s %s ", qdt.toString().latin1() , noti.latin1() );
     if ( ! KOPrefs::instance()->mUseInternalAlarmNotification ) {
 #ifndef DESKTOP_VERSION
         AlarmServer::addAlarm ( qdt,"koalarm", noti.latin1() );
 #endif     
         return;
     }
     int maxSec;
     //maxSec = 5; //testing only 
     maxSec = 86400+3600; // one day+1hour
     mAlarmNotification = noti;
     int sec = QDateTime::currentDateTime().secsTo( qdt );
     if ( sec > maxSec ) {
         mRecheckAlarmTimer->start( maxSec * 1000 );
         //  qDebug("recheck Alarm timer started with secs: %d next alarm in sec:%d", maxSec,sec  );
         return;
     } else {
         mRecheckAlarmTimer->stop();
     }
     //qDebug("Alarm timer started with secs: %d ", sec);
     mAlarmTimer->start( sec *1000 , true );
 
 }
 // called by mRecheckAlarmTimer to get next alarm
 // we need this, because a QTimer has only a max range of 25 days
 void CalendarView::recheckTimerAlarm()
 {
     mAlarmTimer->stop();
     mRecheckAlarmTimer->stop();
     mCalendar->checkAlarmForIncidence( 0, true );
 }
 void CalendarView::removeAlarm(const QDateTime &qdt, const QString &noti  )
 {
     //qDebug("-----removeAlarm %s %s ", qdt.toString().latin1() , noti.latin1() );
     if ( ! KOPrefs::instance()->mUseInternalAlarmNotification ) {
 #ifndef DESKTOP_VERSION
         AlarmServer::deleteAlarm (qdt ,"koalarm" ,noti.latin1() );
 #endif   
         return;
     }
     mAlarmTimer->stop();
 }
 void CalendarView::selectWeekNum ( int num  )
 {
     dateNavigator()->selectWeek( num );
     mViewManager->showWeekView();
 }
 KOViewManager *CalendarView::viewManager()
 {
     return mViewManager;
 }
 
 KODialogManager *CalendarView::dialogManager()
 {
     return mDialogManager;
 }
 
 QDate CalendarView::startDate()
 {
     DateList dates = mNavigator->selectedDates();
 
     return dates.first();
 }
 
 QDate CalendarView::endDate()
 {
     DateList dates = mNavigator->selectedDates();
 
     return dates.last();
 }
 
 
 void CalendarView::createPrinter()
 {
 #ifndef KORG_NOPRINTER
     if (!mCalPrinter) {
         mCalPrinter = new CalPrinter(this, mCalendar);
         connect(this, SIGNAL(configChanged()), mCalPrinter, SLOT(updateConfig()));
     }
 #endif
 }
 
 void CalendarView::confSync()
 {
    static KSyncPrefsDialog* sp = 0;
     if ( ! sp ) {
         sp = new KSyncPrefsDialog( this, "syncprefs", true );
     }
     sp->usrReadConfig();
 #ifndef DESKTOP_VERSION
     sp->showMaximized();
 #else
     sp->show();
 #endif
     sp->exec();
     KOPrefs::instance()->mSyncProfileNames = sp->getSyncProfileNames();
     KOPrefs::instance()->mLocalMachineName = sp->getLocalMachineName ();
 }
 
 
 //KOPrefs::instance()->mWriteBackFile
 //KOPrefs::instance()->mWriteBackExistingOnly
 
 //  0  syncPrefsGroup->addRadio(i18n("Take local entry on conflict"));
 //  1  syncPrefsGroup->addRadio(i18n("Take remote entry on conflict"));
 //  2  syncPrefsGroup->addRadio(i18n("Take newest entry on conflict"));
 //  3  syncPrefsGroup->addRadio(i18n("Ask for every entry on conflict"));
 //  4  syncPrefsGroup->addRadio(i18n("Force take local entry always"));
 //  5  syncPrefsGroup->addRadio(i18n("Force take remote entry always"));
 
 int  CalendarView::takeEvent( Incidence* local,  Incidence* 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 = mLastCalendarSync;
     QDateTime localMod = local->lastModified();
     QDateTime remoteMod = remote->lastModified();
     if ( mGlobalSyncMode == SYNC_MODE_EXTERNAL ) {
         bool remCh, locCh;
         remCh = ( remote->getCsum(mCurrentSyncDevice) != local->getCsum(mCurrentSyncDevice) );
         //if ( remCh )        
             //qDebug("loc %s  rem %s", local->getCsum(mCurrentSyncDevice).latin1(), remote->getCsum(mCurrentSyncDevice).latin1() );
         locCh = ( localMod > mLastCalendarSync );
         if ( !remCh && ! locCh ) {
             //qDebug("both not changed ");
             lastSync = localMod.addDays(1);
             if ( mode <= SYNC_PREF_ASK )
                 return 0;
         } else {
             if ( locCh ) {
                 //qDebug("loc changed %d %s %s", local->revision() , localMod.toString().latin1(), mLastCalendarSync.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 )
             if ( local->revision() == remote->revision() )
                 return 0;
         
     }
     // qDebug(" %d %d conflict on %s %s ", mode, full, local->summary().latin1(), remote->summary().latin1() );
 
     //qDebug("%s %d  %s %d", localMod.toString().latin1() , local->revision(), remoteMod.toString().latin1(), remote->revision());  
     //qDebug("%d %d %d %d ", localMod.time().second(), localMod.time().msec(),  remoteMod.time().second(), remoteMod.time().msec() );
     //full = true; //debug only
     if ( full ) {
         bool equ = false;
         if ( local->type() == "Event" ) {
             equ =  (*((Event*) local) == *((Event*) remote));
         }
         else if ( local->type() =="Todo" )
             equ =  (*((Todo*) local) == (*(Todo*) remote));
         else if ( local->type() =="Journal" )
             equ =  (*((Journal*) local) == *((Journal*) 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()  ,  localMod.toString().latin1() , remoteMod.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;
         //qDebug("lsy %s  ---  lo %s  --- re %s ", lastSync.toString().latin1(), localMod.toString().latin1(), remoteMod.toString().latin1()  );
         localIsNew = localMod >= remoteMod;
         if ( localIsNew )
             getEventViewerDialog()->setColorMode( 1 );
          else 
             getEventViewerDialog()->setColorMode( 2 );
         getEventViewerDialog()->setIncidence(local);
         if ( localIsNew )
             getEventViewerDialog()->setColorMode( 2 );
          else 
             getEventViewerDialog()->setColorMode( 1 );
         getEventViewerDialog()->addIncidence(remote);
         getEventViewerDialog()->setColorMode( 0 );
         //qDebug("local %d remote %d ",local->relatedTo(),remote->relatedTo()  );
         getEventViewerDialog()->setCaption( mCurrentSyncDevice +i18n(" : Conflict! Please choose entry!"));
         getEventViewerDialog()->showMe();
         result = getEventViewerDialog()->executeS( 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;
 }
 Event* CalendarView::getLastSyncEvent()
 {
     Event* lse; 
     //qDebug("CurrentSyncDevice %s ",mCurrentSyncDevice .latin1() );
     lse =   mCalendar->event( "last-syncEvent-"+mCurrentSyncDevice );
     if (!lse) {
         lse = new Event();
         lse->setUid( "last-syncEvent-"+mCurrentSyncDevice ); 
         QString sum = "";
         if ( KOPrefs::instance()->mExternSyncProfiles.contains( mCurrentSyncDevice ) )
             sum = "E: ";
         lse->setSummary(sum+mCurrentSyncDevice + i18n(" - sync event"));
         lse->setDtStart( mLastCalendarSync );
         lse->setDtEnd( mLastCalendarSync.addSecs( 7200 ) );
         lse->setCategories( i18n("SyncEvent") );
         lse->setReadOnly( true );
         mCalendar->addEvent( lse );
     }
 
     return lse;
 
 }
 // probaly useless
 void CalendarView::setupExternSyncProfiles()
 {
     Event* lse; 
     mExternLastSyncEvent.clear();
     int i;
     for ( i = 0; i < KOPrefs::instance()->mExternSyncProfiles.count(); ++i ) {
         lse = mCalendar->event( "last-syncEvent-"+ KOPrefs::instance()->mExternSyncProfiles[i] );
         if ( lse )
             mExternLastSyncEvent.append( lse );
         else
             qDebug("Last Sync event not found for %s ",  KOPrefs::instance()->mExternSyncProfiles[i].latin1());
     }
 
 }
 // we check, if the to delete event has a id for a profile
 //  if yes, we set this id in the profile to delete
 void CalendarView::checkExternSyncEvent( QPtrList<Event> lastSync , Incidence* toDelete )
 {
     if ( lastSync.count() == 0 ) {
         //qDebug(" lastSync.count() == 0");
         return;
     }
     if ( toDelete->type() == "Journal" )
         return;
 
     Event* eve = lastSync.first();
 
     while ( eve ) {
         QString id = toDelete->getID( eve->uid().mid( 15 ) ); // this is the sync profile name
         if ( !id.isEmpty() ) {
             QString des = eve->description();
             QString pref = "e";
             if ( toDelete->type() == "Todo" )
                 pref = "t";
             des += pref+  id  + ",";
             eve->setReadOnly( false );
             eve->setDescription( des );
             //qDebug("setdes %s ", des.latin1());
             eve->setReadOnly( true );
         }
         eve = lastSync.next();
     }
 
 }
 void CalendarView::checkExternalId( Incidence * inc )
 {
     QPtrList<Event> lastSync = mCalendar->getExternLastSyncEvents() ;
     checkExternSyncEvent( lastSync, inc );
 
 }
 bool  CalendarView::synchronizeCalendar( Calendar* local,  Calendar* remote, int mode )
 {
     bool syncOK = true;
     int addedEvent = 0;
     int addedEventR = 0;
     int deletedEventR = 0;
     int deletedEventL = 0;
     int changedLocal = 0;
     int changedRemote = 0;
     //QPtrList<Event> el = local->rawEvents(); 
     Event* eventR;
     QString uid;
     int take;
     Event* eventL;
     Event* eventRSync;
     Event* eventLSync;
     QPtrList<Event>  eventRSyncSharp = remote->getExternLastSyncEvents();
     QPtrList<Event>  eventLSyncSharp = local->getExternLastSyncEvents();
     bool fullDateRange = false;
     local->resetTempSyncStat();
     mLastCalendarSync = QDateTime::currentDateTime();
     QDateTime modifiedCalendar = mLastCalendarSync;;
     eventLSync = getLastSyncEvent();
     eventR = remote->event("last-syncEvent-"+mCurrentSyncName );
     if ( eventR ) {
         eventRSync = (Event*) eventR->clone();
         remote->deleteEvent(eventR );
 
     } else {
         if ( mGlobalSyncMode == SYNC_MODE_EXTERNAL ) {
             eventRSync = (Event*)eventLSync->clone();
         } else {
             fullDateRange = true;
             eventRSync = new Event();
             eventRSync->setSummary(mCurrentSyncName + i18n(" - sync event"));
             eventRSync->setUid("last-syncEvent-"+mCurrentSyncName ); 
             eventRSync->setDtStart( mLastCalendarSync );
             eventRSync->setDtEnd( mLastCalendarSync.addSecs( 7200 ) );
             eventRSync->setCategories( i18n("SyncEvent") );
         }
     }
     if ( eventLSync->dtStart() == mLastCalendarSync )
         fullDateRange = true;
    
     if ( ! fullDateRange  ) {
         if ( eventLSync->dtStart() != eventRSync->dtStart() ) {
             
             // qDebug("set fulldate to true %s %s" ,eventLSync->dtStart().toString().latin1(), eventRSync->dtStart().toString().latin1() ); 
             //qDebug("%d %d %d %d ", eventLSync->dtStart().time().second(), eventLSync->dtStart().time().msec() , eventRSync->dtStart().time().second(), eventRSync->dtStart().time().msec());
             fullDateRange = true;
         } 
     }
     if ( fullDateRange )
         mLastCalendarSync = QDateTime::currentDateTime().addDays( -100*365);
     else
         mLastCalendarSync = eventLSync->dtStart();
     // for resyncing if own file has changed
     if ( mCurrentSyncDevice == "deleteaftersync" ) {
         mLastCalendarSync = loadedFileVersion;
         qDebug("setting mLastCalendarSync ");
     }
     //qDebug("*************************** ");
     qDebug("mLastCalendarSync %s ",mLastCalendarSync.toString().latin1() );
     QPtrList<Incidence> er = remote->rawIncidences(); 
     Incidence* inR = er.first();
     Incidence* inL;
     QProgressBar bar( er.count(),0 );
     bar.setCaption (i18n("Syncing - close to abort!") );
     
     int w = 300;
     if ( QApplication::desktop()->width() < 320 )
         w = 220;
     int h = bar.sizeHint().height() ;
     int dw = QApplication::desktop()->width();
     int dh = QApplication::desktop()->height();
     bar.setGeometry( (dw-w)/2, (dh - h )/2 ,w,h );
     bar.show();
     int modulo = (er.count()/10)+1;
     int incCounter = 0;
     while ( inR ) {
         if ( ! bar.isVisible() )
             return false;
         if ( incCounter % modulo == 0 )
             bar.setProgress( incCounter );
         ++incCounter;
         uid = inR->uid(); 
         bool skipIncidence = false;
         if ( uid.left(15) == QString("last-syncEvent-") )
             skipIncidence = true;
         QString idS;
         qApp->processEvents();
         if ( !skipIncidence ) {
             inL = local->incidence( uid );
             if ( inL ) { // maybe conflict - same uid in both calendars
                 int maxrev = inL->revision();
                 if ( maxrev < inR->revision() )
                     maxrev = inR->revision();
                 if ( (take = takeEvent( inL, inR, mode, fullDateRange )) > 0 ) {
                     //qDebug("take %d %s ", take, inL->summary().latin1());
                     if ( take == 3 )
                         return false;
                     if ( take == 1  ) {// take local
                         if ( mGlobalSyncMode == SYNC_MODE_EXTERNAL )
                             inL->setCsum( mCurrentSyncDevice, inR->getCsum(mCurrentSyncDevice) );
                         else
                             idS = inR->IDStr();
                         remote->deleteIncidence( inR );
                         if ( inL->revision() < maxrev )
                             inL->setRevision( maxrev );
                         inR = inL->clone();
                         inR->setTempSyncStat( SYNC_TEMPSTATE_INITIAL );
                         if ( mGlobalSyncMode != SYNC_MODE_EXTERNAL )
                             inR->setIDStr( idS );
                         remote->addIncidence(  inR );
                         ++changedRemote;
                     } else {
                         if ( inR->revision() < maxrev )
                             inR->setRevision( maxrev );
                         idS = inL->IDStr();
                         local->deleteIncidence( inL );
                         inL = inR->clone();
                         inL->setIDStr( idS );
+                        if ( mGlobalSyncMode == SYNC_MODE_EXTERNAL ) {
+                            inL->setCsum( mCurrentSyncDevice, inR->getCsum(mCurrentSyncDevice) );
+                            inL->setID( mCurrentSyncDevice, inR->getID(mCurrentSyncDevice) );
+                        }
                         local->addIncidence(  inL  );
                         ++changedLocal;
                     }
                 }
             } else { //  no conflict
                 if ( mGlobalSyncMode == SYNC_MODE_EXTERNAL ) {
                     QString des = eventLSync->description(); 
                     QString pref = "e";
                     if ( inR->type() == "Todo" )
                         pref = "t";
                     if ( des.find(pref+ inR->getID(mCurrentSyncDevice)  +"," ) >= 0 && mode != 5) { // delete it
                         inR->setTempSyncStat( SYNC_TEMPSTATE_DELETE );
                         //remote->deleteIncidence( inR );
                         ++deletedEventR; 
                     } else {
                         inR->setLastModified( modifiedCalendar );
                         inL = inR->clone();
                         local->addIncidence( inL );
                         ++addedEvent;
                     }
                 } else {
                     if ( inR->lastModified() > mLastCalendarSync || mode == 5 ) {
                         inR->setLastModified( modifiedCalendar );
                         local->addIncidence( inR->clone() );
                         ++addedEvent;
                     } else {
                         checkExternSyncEvent(eventRSyncSharp, inR);
                         remote->deleteIncidence( inR );
                         ++deletedEventR; 
                     }
                 }
             }
         }
         inR =  er.next();
     }
     QPtrList<Incidence> el = local->rawIncidences(); 
     inL = el.first();
     modulo = (el.count()/10)+1;
     bar.setCaption (i18n("Add / remove events") ); 
     bar.setTotalSteps (  el.count()  ) ;
     bar.show();
     incCounter = 0;
    
     while ( inL ) {
            
         qApp->processEvents();
         if ( ! bar.isVisible() )
             return false;
         if ( incCounter % modulo == 0 )
             bar.setProgress( incCounter );
         ++incCounter;
         uid = inL->uid();
         bool skipIncidence = false;
         if ( uid.left(15) == QString("last-syncEvent-") )
             skipIncidence = true;
         if ( mGlobalSyncMode == SYNC_MODE_EXTERNAL && inL->type() == "Journal" )
             skipIncidence = true;
         if ( !skipIncidence )  {
             inR = remote->incidence( uid );
             if ( ! inR ) { 
                 if ( mGlobalSyncMode == SYNC_MODE_EXTERNAL ) {
                     if ( !inL->getID(mCurrentSyncDevice).isEmpty() && mode != 4 ) {
                         checkExternSyncEvent(eventLSyncSharp, inL);
                         local->deleteIncidence( inL );
                         ++deletedEventL; 
                     } else {
                         if ( ! KOPrefs::instance()->mWriteBackExistingOnly ) {
                             inL->removeID(mCurrentSyncDevice );
                             ++addedEventR; 
                             //qDebug("remote added Incidence %s ", inL->summary().latin1());
                             inL->setLastModified( modifiedCalendar );
                             inR = inL->clone();
                             inR->setTempSyncStat( SYNC_TEMPSTATE_INITIAL );
                             remote->addIncidence(  inR );
                         }
                     }
                 } else {
                     if ( inL->lastModified() < mLastCalendarSync && mode != 4 ) {
                         checkExternSyncEvent(eventLSyncSharp, inL);
                         local->deleteIncidence( inL );
                         ++deletedEventL; 
                     } else {
                         if ( ! KOPrefs::instance()->mWriteBackExistingOnly ) {
                             ++addedEventR; 
                             inL->setLastModified( modifiedCalendar );
                             remote->addIncidence(  inL->clone() );
                         }
                     }
                 }
             }
         }
         inL = el.next();
     }
     int delFut = 0;
     if ( KOPrefs::instance()->mWriteBackInFuture ) {
         er = remote->rawIncidences(); 
         inR = er.first();
         QDateTime dt;
         QDateTime cur = QDateTime::currentDateTime();
         QDateTime end = cur.addSecs( KOPrefs::instance()->mWriteBackInFuture * 3600 *24 *7 );
         while ( inR ) {
             if ( inR->type() == "Todo" ) {
                 Todo * t = (Todo*)inR;
                 if ( t->hasDueDate() )
                     dt = t->dtDue();
                 else
                     dt = cur.addSecs( 62 );
             }
             else if (inR->type() == "Event" ) {
                 bool ok;
                 dt =  inR->getNextOccurence( cur, &ok );
                     if ( !ok )
                         dt = cur.addSecs( -62 );
                 }
             else
                 dt = inR->dtStart();
             if ( dt < cur || dt > end ) {
                 remote->deleteIncidence( inR );
                 ++delFut;
             }
             inR =  er.next();
         }
     }
     bar.hide();
     mLastCalendarSync = QDateTime::currentDateTime().addSecs( 1 );
     eventLSync->setReadOnly( false );
     eventLSync->setDtStart( mLastCalendarSync );
     eventRSync->setDtStart( mLastCalendarSync );
     eventLSync->setDtEnd( mLastCalendarSync.addSecs( 3600 ) );
     eventRSync->setDtEnd( mLastCalendarSync.addSecs( 3600 ) );
     eventRSync->setLocation( i18n("Remote from: ")+mCurrentSyncName ) ;
     eventLSync->setLocation(i18n("Local from: ") + mCurrentSyncName  );
     eventLSync->setReadOnly( true );
     if ( mGlobalSyncMode ==  SYNC_MODE_NORMAL)
         remote->addEvent( eventRSync );
     QString mes;
     mes .sprintf(  i18n("Synchronization summary:\n\n %d items added to local\n %d items added to remote\n %d items updated on local\n %d items updated on remote\n %d items deleted on local\n %d items deleted on remote\n"),addedEvent, addedEventR, changedLocal, changedRemote, deletedEventL, deletedEventR ); 
     QString delmess;
     if ( delFut  ) {
         delmess.sprintf(  i18n("%d items skipped on remote,\nbecause they are in the past or\nmore than %d weeks in the future.\n"),delFut, KOPrefs::instance()->mWriteBackInFuture ); 
         mes += delmess;
     }
     if ( KOPrefs::instance()->mShowSyncSummary ) {
         KMessageBox::information(this, mes, i18n("KO/Pi Synchronization") );
     }
     qDebug( mes );
     mCalendar->checkAlarmForIncidence( 0, true );
     return syncOK;
 }
 
 void CalendarView::setSyncDevice( QString s )
 {
     mCurrentSyncDevice= s;
 }
 void CalendarView::setSyncName( QString s )
 {
     mCurrentSyncName= s;
 }
 bool CalendarView::syncCalendar(QString filename, int mode)
 {
     mGlobalSyncMode = SYNC_MODE_NORMAL;
     CalendarLocal* calendar = new CalendarLocal();
     calendar->setTimeZoneId(KOPrefs::instance()->mTimeZoneId);
     FileStorage* storage = new FileStorage( calendar );
     bool syncOK = false;
     storage->setFileName( filename );
     // qDebug("loading ... ");
     if ( storage->load(KOPrefs::instance()->mUseQuicksave) ) {
         getEventViewerDialog()->setSyncMode( true );
         syncOK = synchronizeCalendar( mCalendar, calendar, mode );
         getEventViewerDialog()->setSyncMode( false );
         if (  syncOK ) {
            if ( KOPrefs::instance()->mWriteBackFile )
             {
                 storage->setSaveFormat( new ICalFormat( KOPrefs::instance()->mUseQuicksave) );
                 storage->save();
             }
         }
         setModified( true );
     }
     delete storage;
     delete calendar;
     if ( syncOK )
         updateView();
     return syncOK;
 }
 void CalendarView::syncPhone()
 {
     syncExternal( 1 );
 }
 void CalendarView::syncExternal( int mode  )
 {
     mGlobalSyncMode = SYNC_MODE_EXTERNAL;
     //mCurrentSyncDevice = "sharp-DTM";
     if ( KOPrefs::instance()->mAskForPreferences )
         edit_sync_options(); 
     qApp->processEvents();
     CalendarLocal* calendar = new CalendarLocal();
     calendar->setTimeZoneId(KOPrefs::instance()->mTimeZoneId);
     bool syncOK = false;
     bool loadSuccess = false;
     PhoneFormat* phoneFormat = 0;
 #ifndef DESKTOP_VERSION
     SharpFormat* sharpFormat = 0;
     if ( mode == 0 ) { // sharp
         sharpFormat = new SharpFormat () ;
         loadSuccess = sharpFormat->load( calendar, mCalendar ); 
 
     } else 
 #endif
         if ( mode == 1 ) { // phone 
         phoneFormat = new PhoneFormat (mCurrentSyncDevice,
                                          KOPrefs::instance()->mPhoneDevice,
                                          KOPrefs::instance()->mPhoneConnection,
                                          KOPrefs::instance()->mPhoneModel);
         loadSuccess = phoneFormat->load( calendar,mCalendar); 
         
     } else 
         return;
     if ( loadSuccess ) {
         getEventViewerDialog()->setSyncMode( true );
         syncOK = synchronizeCalendar( mCalendar, calendar, KOPrefs::instance()->mSyncAlgoPrefs );
         getEventViewerDialog()->setSyncMode( false );
         qApp->processEvents();
         if (  syncOK ) {
             if ( KOPrefs::instance()->mWriteBackFile )
             {
                 QPtrList<Incidence> iL = mCalendar->rawIncidences(); 
                 Incidence* inc = iL.first();
                 if ( phoneFormat ) {
                     while ( inc ) {
                         inc->removeID(mCurrentSyncDevice);
                         inc =  iL.next();
                     }
                 }
 #ifndef DESKTOP_VERSION
                 if ( sharpFormat )
                     sharpFormat->save(calendar);
 #endif
                 if ( phoneFormat )
                     phoneFormat->save(calendar);
                 iL = calendar->rawIncidences(); 
                 inc = iL.first();
                 Incidence* loc;
                 while ( inc ) {
                     if ( inc->tempSyncStat() == SYNC_TEMPSTATE_NEW_ID ) {
                         loc = mCalendar->incidence(inc->uid() );
                         if ( loc ) {
                             loc->setID(mCurrentSyncDevice, inc->getID(mCurrentSyncDevice) );
                             loc->setCsum( mCurrentSyncDevice, inc->getCsum(mCurrentSyncDevice) );
                         }
                     }
                     inc =  iL.next();
                 }
                 Incidence* lse = getLastSyncEvent();
                 if ( lse ) {
                     lse->setReadOnly( false );
                     lse->setDescription( "" );
                     lse->setReadOnly( true );
                 }
             }
         }
         setModified( true );
     } else {
         QString question = i18n("Sorry, the database access\ncommand failed!\n\nNothing synced!\n") ;
         QMessageBox::information( 0, i18n("KO/Pi Import - ERROR"),
                                       question, i18n("Ok")) ;
 
     }
     delete calendar;
     updateView();
     return ;//syncOK;
 
 }
 void CalendarView::syncSharp()
 {
     syncExternal( 0 );
 
 }
 
 
 //#include <kabc/stdaddressbook.h>
 bool CalendarView::importBday()
 {
 #if 0
     KABC::StdAddressBook* AddressBook = KABC::StdAddressBook::self( true );
     KABC::AddressBook::Iterator it;
     int count = 0;
     for( it = AddressBook->begin(); it != AddressBook->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("Reading addressbook - close to abort!") );
     qApp->processEvents();
     count = 0;
     int addCount = 0;
     KCal::Attendee* a = 0;
     for( it = AddressBook->begin(); it != AddressBook->end(); ++it ) { 
         if ( ! bar.isVisible() )
             return false;
         bar.setProgress( count++ );
         qApp->processEvents();
         //qDebug("add BDay %s %s", (*it).realName().latin1(),(*it).birthday().date().toString().latin1() );
         if ( (*it).birthday().date().isValid() ){
             a = new KCal::Attendee( (*it).realName(), (*it).preferredEmail(),false,KCal::Attendee::NeedsAction,KCal::Attendee::ReqParticipant,(*it).uid()) ;
             if ( addAnniversary(  (*it).birthday().date(), (*it).assembledName(),  a, true ) )
             ++addCount;
         } 
         QDate anni = KGlobal::locale()->readDate( (*it).custom("KADDRESSBOOK", "X-Anniversary" ), "%Y-%m-%d"); 
         if ( anni.isValid() ){ 
             a = new KCal::Attendee( (*it).realName(), (*it).preferredEmail(),false,KCal::Attendee::NeedsAction,KCal::Attendee::ReqParticipant,(*it).uid()) ;
             if ( addAnniversary(  anni, (*it).assembledName(),  a, false ) )
             ++addCount;
         }
     }
     updateView(); 
     topLevelWidget()->setCaption(QString::number( addCount )+ i18n(" birthdays/anniversaries added!"));
 #endif
     return true;
 }
  
 bool  CalendarView::addAnniversary(  QDate date, QString name, KCal::Attendee* a,  bool birthday)
 {
     //qDebug("addAnni ");
     Event * ev = new Event();
     if ( a ) {
         ev->addAttendee( a );
     }
     QString kind;
     if ( birthday )
         kind = i18n( "Birthday" );
     else
         kind = i18n( "Anniversary" );
     ev->setSummary( name + " - " + kind ); 
     ev->setOrganizer( "nobody@nowhere" );
     ev->setCategories( kind );
     ev->setDtStart( QDateTime(date) );
     ev->setDtEnd(  QDateTime(date) );
     ev->setFloats( true );
     Recurrence * rec = ev->recurrence();
     rec->setYearly(Recurrence::rYearlyMonth,1,-1);
     rec->addYearlyNum( date.month() );
     if ( !mCalendar->addAnniversaryNoDup( ev ) ) {
         delete ev;
         return false;
     }
     return true;
 
 }
 bool CalendarView::importQtopia( const QString &categories,
                                  const QString &datebook,
                                  const QString &todolist )
 {
     
    QtopiaFormat qtopiaFormat;
     qtopiaFormat.setCategoriesList (  &(KOPrefs::instance()->mCustomCategories));
     if ( !categories.isEmpty() ) qtopiaFormat.load( mCalendar, categories );
     if ( !datebook.isEmpty() ) qtopiaFormat.load( mCalendar, datebook );
     if ( !todolist.isEmpty() ) qtopiaFormat.load( mCalendar, todolist );
    
     updateView();
     return true;
 
 #if 0
  mGlobalSyncMode = SYNC_MODE_QTOPIA;
     mCurrentSyncDevice = "qtopia-XML";
     if ( KOPrefs::instance()->mAskForPreferences )
         edit_sync_options(); 
     qApp->processEvents();
     CalendarLocal* calendar = new CalendarLocal();
     calendar->setTimeZoneId(KOPrefs::instance()->mTimeZoneId);
     bool syncOK = false;
  QtopiaFormat qtopiaFormat;
     qtopiaFormat.setCategoriesList (  &(KOPrefs::instance()->mCustomCategories));
     bool loadOk = true;
     if ( !categories.isEmpty() ) 
         loadOk = qtopiaFormat.load( calendar, categories );
     if ( loadOk && !datebook.isEmpty() ) 
         loadOk = qtopiaFormat.load( calendar, datebook );
     if ( loadOk && !todolist.isEmpty() ) 
         loadOk = qtopiaFormat.load( calendar, todolist );
 
     if ( loadOk  ) {
         getEventViewerDialog()->setSyncMode( true );
         syncOK = synchronizeCalendar( mCalendar, calendar, KOPrefs::instance()->mSyncAlgoPrefs );
         getEventViewerDialog()->setSyncMode( false );
         qApp->processEvents();
         if (  syncOK ) {
             if ( KOPrefs::instance()->mWriteBackFile )
             {
                 // write back XML file
 
             }
         setModified( true );
         }
     } else {
         QString question = i18n("Sorry, the file loading\ncommand failed!\n\nNothing synced!\n") ;
         QMessageBox::information( 0, i18n("KO/Pi Sync - ERROR"),
                                       question, i18n("Ok")) ;
     }
     delete calendar;
     updateView();
     return syncOK;
 
 
 #endif
 
 }
     
 void CalendarView::setSyncEventsReadOnly()
 {
     Event * ev;
     QPtrList<Event> eL = mCalendar->rawEvents(); 
     ev = eL.first();
     while ( ev ) {
         if ( ev->uid().left(15) == QString("last-syncEvent-") )
             ev->setReadOnly( true );
         ev =  eL.next();
     } 
 }
 bool CalendarView::openCalendar(QString filename, bool merge)
 {
 
     if (filename.isEmpty()) {
         return false;
     }
 
     if (!QFile::exists(filename)) {
         KMessageBox::error(this,i18n("File does not exist:\n '%1'.").arg(filename));
         return false;
     }
 
     globalFlagBlockAgenda = 1;
     if (!merge) mCalendar->close();
 
     mStorage->setFileName( filename );
 
     if ( mStorage->load(KOPrefs::instance()->mUseQuicksave) ) {
         if ( merge ) ;//setModified( true );
         else {
             //setModified( true );
             mViewManager->setDocumentId( filename );
             mDialogManager->setDocumentId( filename );
             mTodoList->setDocumentId( filename );
         }
         globalFlagBlockAgenda = 2;
         // if ( getLastSyncEvent() )
         //  getLastSyncEvent()->setReadOnly( true );
         mCalendar->reInitAlarmSettings();
         setSyncEventsReadOnly();
         updateUnmanagedViews();
         updateView();
         if (  filename != MainWindow::defaultFileName() )
             saveCalendar( MainWindow::defaultFileName() );
         loadedFileVersion = QDateTime::currentDateTime();
         return true;
     } else {
         // while failing to load, the calendar object could
         // have become partially populated.  Clear it out.
         if ( !merge ) mCalendar->close();
 
         KMessageBox::error(this,i18n("Couldn't load calendar\n '%1'.").arg(filename));
 
         globalFlagBlockAgenda = 2;
         updateView();
     }
     return false;
 }
 void CalendarView::setLoadedFileVersion(QDateTime dt)
 {
     loadedFileVersion = dt;
 }
 bool CalendarView::checkFileChanged(QString fn)
 {
     QFileInfo finf ( fn ); 
     if ( !finf.exists() )
         return true;
     QDateTime dt = finf.lastModified ();
     if ( dt <= loadedFileVersion )
         return false;
     return true;
 
 }
 bool CalendarView::checkFileVersion(QString fn)
 {
     QFileInfo finf ( fn );  
     if ( !finf.exists() )
         return true;
     QDateTime dt = finf.lastModified ();
     //qDebug("loaded file version %s",loadedFileVersion.toString().latin1());
     //qDebug("file on disk version  %s",dt.toString().latin1());
     if ( dt <= loadedFileVersion )
         return true;
    int km = KMessageBox::warningYesNoCancel(this, i18n("\nThe file on disk has changed!\nFile size: %1 bytes.\nLast modified: %2\nDo you want to:\n\n - Save and overwrite file?\n - Sync with file, then save?\n - Cancel without saving? \n").arg( QString::number( finf.size())).arg( KGlobal::locale()->formatDateTime(finf.lastModified (), true, false)) ,
                                                  i18n("KO/Pi Warning"),i18n("Overwrite"),
                                                  i18n("Sync+save"));
    
    if ( km ==  KMessageBox::Cancel )
        return false;
    if ( km ==  KMessageBox::Yes )
        return true;
 
     setSyncDevice("deleteaftersync" );
     KOPrefs::instance()->mAskForPreferences = true;
     KOPrefs::instance()->mSyncAlgoPrefs = 3;
     KOPrefs::instance()->mWriteBackFile = false;
     KOPrefs::instance()->mWriteBackExistingOnly = false;
     KOPrefs::instance()->mShowSyncSummary = false;
     syncCalendar( fn, 3 );
     Event * e = getLastSyncEvent();
     mCalendar->deleteEvent ( e );
     updateView();
     return true;
 }
 
 bool CalendarView::saveCalendar( QString filename )
 {
  
     // Store back all unsaved data into calendar object
     // qDebug("file %s %d ",  filename.latin1()           , mViewManager->currentView()         );
     if ( mViewManager->currentView() )
         mViewManager->currentView()->flushView();
 
     //mStorage->setFileName( filename );
 
     mStorage->setSaveFormat( new ICalFormat( KOPrefs::instance()->mUseQuicksave) );
     mStorage->setFileName( filename );
     bool success;
     success = mStorage->save();
     if ( !success ) {
         return false;
     }
 
     return true;
 }
 
 void CalendarView::closeCalendar()
 {
  
     // child windows no longer valid
     emit closingDown();
 
     mCalendar->close();
     setModified(false);
     updateView();
 }
 
 void CalendarView::archiveCalendar()
 {
     mDialogManager->showArchiveDialog();
 }
 
 
 void CalendarView::readSettings()
 {
  
   
     // mViewManager->showAgendaView();
     QString str;
     //qDebug("CalendarView::readSettings() ");
     // read settings from the KConfig, supplying reasonable
     // defaults where none are to be found
     KConfig *config = KOGlobals::config();
 #ifndef KORG_NOSPLITTER
     config->setGroup("KOrganizer Geometry");
 
     QValueList<int> sizes = config->readIntListEntry("Separator1");
     if (sizes.count() != 2) {
         sizes << mDateNavigator->minimumSizeHint().width();
         sizes << 300;
     }
     mPanner->setSizes(sizes);
 
     sizes = config->readIntListEntry("Separator2");
     if ( ( mResourceView && sizes.count() == 4 ) ||
          ( !mResourceView && sizes.count() == 3 ) ) {
         mLeftSplitter->setSizes(sizes);
     }
 #endif
     globalFlagBlockAgenda = 1;
     mViewManager->showAgendaView();
     //mViewManager->readSettings( config );
     mTodoList->restoreLayout(config,QString("Todo Layout"));
     readFilterSettings(config);
     config->setGroup( "Views" );
     int dateCount = config->readNumEntry( "ShownDatesCount", 7 );
     if ( dateCount == 5 ) mNavigator->selectWorkWeek();
     else if ( dateCount == 7 ) mNavigator->selectWeek();
     else mNavigator->selectDates( dateCount );
     // mViewManager->readSettings( config );
     updateConfig(); 
     globalFlagBlockAgenda = 2;
     mViewManager->readSettings( config );
 #ifdef DESKTOP_VERSION
     config->setGroup("WidgetLayout");
     QStringList list;
     list = config->readListEntry("MainLayout");
     int x,y,w,h;
     if ( ! list.isEmpty() ) {
         x = list[0].toInt();
         y = list[1].toInt();
         w = list[2].toInt();
         h = list[3].toInt();
         topLevelWidget()->setGeometry(x,y,w,h);
 
     } else {
         topLevelWidget()->setGeometry( 40 ,40 , 640, 440);
     }
     list = config->readListEntry("EditEventLayout");
     if ( ! list.isEmpty() ) {
         x = list[0].toInt();
         y = list[1].toInt();
         w = list[2].toInt();
         h = list[3].toInt();
         mEventEditor->setGeometry(x,y,w,h);
 
     }
     list = config->readListEntry("EditTodoLayout");
     if ( ! list.isEmpty() ) {
         x = list[0].toInt();
         y = list[1].toInt();
         w = list[2].toInt();
         h = list[3].toInt();
         mTodoEditor->setGeometry(x,y,w,h);
 
     }
     list = config->readListEntry("ViewerLayout");
     if ( ! list.isEmpty() ) {
         x = list[0].toInt();
         y = list[1].toInt();
         w = list[2].toInt();
         h = list[3].toInt();
         getEventViewerDialog()->setGeometry(x,y,w,h);
     }
 #endif
 
 }
 
 
 void CalendarView::writeSettings()
 {
     //  kdDebug() << "CalendarView::writeSettings" << endl;
 
     KConfig *config = KOGlobals::config();
 
 #ifndef KORG_NOSPLITTER
     config->setGroup("KOrganizer Geometry");
 
     QValueList<int> list = mPanner->sizes();
     config->writeEntry("Separator1",list);
 
     list = mLeftSplitter->sizes();
     config->writeEntry("Separator2",list);
 #endif
 
     mViewManager->writeSettings( config );
     mTodoList->saveLayout(config,QString("Todo Layout"));
     mDialogManager->writeSettings( config );
     //KOPrefs::instance()->usrWriteConfig();
     KOPrefs::instance()->writeConfig();
 
     writeFilterSettings(config);
 
     config->setGroup( "Views" );
     config->writeEntry( "ShownDatesCount", mNavigator->selectedDates().count() );
 
 #ifdef DESKTOP_VERSION
     config->setGroup("WidgetLayout");
     QStringList list ;//= config->readListEntry("MainLayout");
     int x,y,w,h;
     QWidget* wid;
     wid = topLevelWidget();
     x = wid->geometry().x();
     y = wid->geometry().y();
     w = wid->width();
     h = wid->height();
     list.clear();
     list << QString::number( x );
     list << QString::number( y );
     list << QString::number( w );
     list << QString::number( h );
     config->writeEntry("MainLayout",list );
     
     wid = mEventEditor;
     x = wid->geometry().x();
     y = wid->geometry().y();
     w = wid->width();
     h = wid->height();
     list.clear();
     list << QString::number( x );
     list << QString::number( y );
     list << QString::number( w );
     list << QString::number( h );
     config->writeEntry("EditEventLayout",list );
  
     wid = mTodoEditor;
     x = wid->geometry().x();
     y = wid->geometry().y();
     w = wid->width();
     h = wid->height();
     list.clear();
     list << QString::number( x );
     list << QString::number( y );
     list << QString::number( w );
     list << QString::number( h );
     config->writeEntry("EditTodoLayout",list ); 
     wid = getEventViewerDialog();
     x = wid->geometry().x();
     y = wid->geometry().y();
     w = wid->width();
     h = wid->height();
     list.clear();
     list << QString::number( x );
     list << QString::number( y );
     list << QString::number( w );
     list << QString::number( h );
     config->writeEntry("ViewerLayout",list ); 
     wid = mDialogManager->getSearchDialog();
     if ( wid ) {
         x = wid->geometry().x();
         y = wid->geometry().y();
         w = wid->width();
         h = wid->height();
         list.clear();
         list << QString::number( x );
         list << QString::number( y );
         list << QString::number( w );
         list << QString::number( h );
         config->writeEntry("SearchLayout",list );
     }
 #endif
 
 
     config->sync();
 }
 
 void CalendarView::readFilterSettings(KConfig *config)
 {
     //  kdDebug() << "CalendarView::readFilterSettings()" << endl;
 
     mFilters.clear();
 
     config->setGroup("General");
     QStringList filterList = config->readListEntry("CalendarFilters");
 
     QStringList::ConstIterator it = filterList.begin();
     QStringList::ConstIterator end = filterList.end();
     while(it != end) {
         //    kdDebug() << "  filter: " << (*it) << endl;
 
         CalFilter *filter;
         filter = new CalFilter(*it);
         config->setGroup("Filter_" + (*it));
         //qDebug("readFilterSettings %d ",config->readNumEntry("Criteria",0) );
         filter->setCriteria(config->readNumEntry("Criteria",0));
         filter->setCategoryList(config->readListEntry("CategoryList"));
         mFilters.append(filter);
 
         ++it;
     }
 
     if (mFilters.count() == 0) {
         CalFilter *filter = new CalFilter(i18n("Default"));
         mFilters.append(filter);
     }
     mFilterView->updateFilters();
     config->setGroup("FilterView");
 
     mFilterView->blockSignals(true);
     mFilterView->setFiltersEnabled(config->readBoolEntry("FilterEnabled"));
     mFilterView->setSelectedFilter(config->readEntry("Current Filter"));
     mFilterView->blockSignals(false);
     // We do it manually to avoid it being done twice by the above calls
     updateFilter();
 }
 
 void CalendarView::writeFilterSettings(KConfig *config)
 {
     //  kdDebug() << "CalendarView::writeFilterSettings()" << endl;
 
     QStringList filterList;
 
     CalFilter *filter = mFilters.first();
     while(filter) {
         //    kdDebug() << " fn: " << filter->name() << endl;
         filterList << filter->name();
         config->setGroup("Filter_" + filter->name());
         config->writeEntry("Criteria",filter->criteria());
         config->writeEntry("CategoryList",filter->categoryList());
         filter = mFilters.next();
     }
     config->setGroup("General");
     config->writeEntry("CalendarFilters",filterList);
 
     config->setGroup("FilterView");
     config->writeEntry("FilterEnabled",mFilterView->filtersEnabled());
     config->writeEntry("Current Filter",mFilterView->selectedFilter()->name());
 }
 
 
 void CalendarView::goToday()
 {
     mNavigator->selectToday();
 }
 
 void CalendarView::goNext()
 {
     mNavigator->selectNext();
 }
 
 void CalendarView::goPrevious()
 {
     mNavigator->selectPrevious();
 }
 void CalendarView::goNextMonth()
 {
     mNavigator->selectNextMonth();
 }
 
 void CalendarView::goPreviousMonth()
 {
     mNavigator->selectPreviousMonth();
 }
 void CalendarView::writeLocale()
 {
     KGlobal::locale()->setHore24Format( !KOPrefs::instance()->mPreferredTime );
     KGlobal::locale()->setWeekStartMonday( !KOPrefs::instance()->mWeekStartsOnSunday );
     KGlobal::locale()->setIntDateFormat( (KLocale::IntDateFormat)KOPrefs::instance()->mPreferredDate );
     KGlobal::locale()->setLanguage( KOPrefs::instance()->mPreferredLanguage );
     QString dummy = KOPrefs::instance()->mUserDateFormatLong;
     KGlobal::locale()->setDateFormat(dummy.replace( QRegExp("K"), QString(",") ));
     dummy = KOPrefs::instance()->mUserDateFormatShort;
     KGlobal::locale()->setDateFormatShort(dummy.replace( QRegExp("K"), QString(",") ));
     KGlobal::locale()->setDaylightSaving( KOPrefs::instance()->mUseDaylightsaving,
                                           KOPrefs::instance()->mDaylightsavingStart,
                                           KOPrefs::instance()->mDaylightsavingEnd );
     KGlobal::locale()->setTimezone( KOPrefs::instance()->mTimeZoneId );
 }
 void CalendarView::updateConfig()
 {
     writeLocale();
     if ( KOPrefs::instance()->mUseAppColors )
         QApplication::setPalette( QPalette (KOPrefs::instance()->mAppColor1, KOPrefs::instance()->mAppColor2), true );
     emit configChanged();
     mTodoList->updateConfig();
     // mDateNavigator->setFont ( KOPrefs::instance()->mDateNavigatorFont);
     mCalendar->setTimeZoneId(KOPrefs::instance()->mTimeZoneId);
     // To make the "fill window" configurations work
     //mViewManager->raiseCurrentView();
 }
 
 
 void CalendarView::eventChanged(Event *event)
 {
     changeEventDisplay(event,KOGlobals::EVENTEDITED);
     //updateUnmanagedViews();
 }
 
 void CalendarView::eventAdded(Event *event)
 {
     changeEventDisplay(event,KOGlobals::EVENTADDED);
 }
 
 void CalendarView::eventToBeDeleted(Event *)
 {
     kdDebug() << "CalendarView::eventToBeDeleted(): to be implemented" << endl;
 }
 
 void CalendarView::eventDeleted()
 {
     changeEventDisplay(0,KOGlobals::EVENTDELETED);
 }
 void CalendarView::changeTodoDisplay(Todo *which, int action)
 {
     changeIncidenceDisplay((Incidence *)which,  action);
     mDateNavigator->updateView(); //LR
     //mDialogManager->updateSearchDialog();
 
     if (which) {
         mViewManager->updateWNview();
         //mTodoList->updateView();
     }
    
 }
 
 void CalendarView::changeIncidenceDisplay(Incidence *which, int action)
 {
     updateUnmanagedViews();
     //qDebug(" CalendarView::changeIncidenceDisplay++++++++++++++++++++++++++  %d  %d ",which, action );
     if ( action == KOGlobals::EVENTDELETED ) { //delete
         mCalendar->checkAlarmForIncidence( 0, true );
         if ( mEventViewerDialog )
             mEventViewerDialog->hide();
     } 
     else
         mCalendar->checkAlarmForIncidence( which , false );
 }
 
 // most of the changeEventDisplays() right now just call the view's
 // total update mode, but they SHOULD be recoded to be more refresh-efficient.
 void CalendarView::changeEventDisplay(Event *which, int action)
 {
     //  kdDebug() << "CalendarView::changeEventDisplay" << endl;
     changeIncidenceDisplay((Incidence *)which,  action);
     mDateNavigator->updateView();
     //mDialogManager->updateSearchDialog();
 
     if (which) {
         // If there is an event view visible update the display
         mViewManager->currentView()->changeEventDisplay(which,action);
         // TODO: check, if update needed
         //    if (which->getTodoStatus()) {
         mTodoList->updateView();
         //    }
     } else {
         mViewManager->currentView()->updateView();
     }
 }
 
 
 void CalendarView::updateTodoViews()
 {
    
     mTodoList->updateView();
     mViewManager->currentView()->updateView();
  
 }
 
 
 void CalendarView::updateView(const QDate &start, const QDate &end)
 {
     mTodoList->updateView();
     mViewManager->updateView(start, end);
     //mDateNavigator->updateView();
 }
 
 void CalendarView::updateView()
 {
     DateList tmpList = mNavigator->selectedDates();
 
     // We assume that the navigator only selects consecutive days.
     updateView( tmpList.first(), tmpList.last() );
 }
 
 void CalendarView::updateUnmanagedViews()
 {
     mDateNavigator->updateDayMatrix();
 }
 
 int CalendarView::msgItemDelete()
 {
     return KMessageBox::warningContinueCancel(this,
                                               i18n("This item will be\npermanently deleted."),
                                               i18n("KO/Pi Confirmation"),i18n("Delete"));
 }
 
 
 void CalendarView::edit_cut()
 {
     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;
     }
     DndFactory factory( mCalendar );
     factory.cutEvent(anEvent);
     changeEventDisplay(anEvent, KOGlobals::EVENTDELETED);
 }
 
 void CalendarView::edit_copy()
 {
     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;
     }
     DndFactory factory( mCalendar );
     factory.copyEvent(anEvent);
 }
 
 void CalendarView::edit_paste()
 {
     QDate date = mNavigator->selectedDates().first();
 
     DndFactory factory( mCalendar );
     Event *pastedEvent = factory.pasteEvent( date );
 
     changeEventDisplay( pastedEvent, KOGlobals::EVENTADDED );
 }
 
 void CalendarView::edit_options()
 {
     mDialogManager->showOptionsDialog();
     //writeSettings();
 }
 void CalendarView::edit_sync_options()
 {
     //mDialogManager->showSyncOptions();
     //KOPrefs::instance()->mSyncAlgoPrefs 
     QDialog dia( this, "dia", true );
     dia.setCaption( i18n("Device: " ) +mCurrentSyncDevice );
     QButtonGroup gr ( 1,  Qt::Horizontal, i18n("Sync preferences"), &dia);
     QVBoxLayout lay ( &dia );
     lay.setSpacing( 2 );
     lay.setMargin( 3 );
     lay.addWidget(&gr);
     QRadioButton loc ( i18n("Take local entry on conflict"), &gr );
     QRadioButton rem ( i18n("Take remote entry on conflict"), &gr );
     QRadioButton newest( i18n("Take newest entry on conflict"), &gr );
     QRadioButton ask( i18n("Ask for every entry on conflict"), &gr );
     QRadioButton f_loc( i18n("Force: Take local entry always"), &gr );
     QRadioButton f_rem( i18n("Force: Take remote entry always"), &gr );
     //QRadioButton both( i18n("Take both on conflict"), &gr );
     QPushButton pb ( "OK",  &dia); 
     lay.addWidget( &pb );
     connect(&pb, SIGNAL( clicked() ), &dia, SLOT ( accept() ) ); 
     switch ( KOPrefs::instance()->mSyncAlgoPrefs ) {
     case 0:
         loc.setChecked( true);
         break;
     case 1:
         rem.setChecked( true );
         break;
     case 2:
         newest.setChecked( true);
         break;
     case 3:
         ask.setChecked( true);
         break;
     case 4:
         f_loc.setChecked( true);
         break;
     case 5:
         f_rem.setChecked( true);
         break;
     case 6:
         // both.setChecked( true);
         break; 
     default:
         break;
     }
     if ( dia.exec() ) {
         KOPrefs::instance()->mSyncAlgoPrefs = rem.isChecked()*1+newest.isChecked()*2+  ask.isChecked()*3+  f_loc.isChecked()*4+  f_rem.isChecked()*5;//+  both.isChecked()*6 ;
     }
    
 }
 
 void  CalendarView::slotSelectPickerDate( QDate  d)
 {
     mDateFrame->hide();
     if ( mDatePickerMode == 1 ) {
         mNavigator->slotDaySelect( d );
     } else  if ( mDatePickerMode == 2 ) {
         if ( mMoveIncidence->type() == "Todo" ) {
             Todo * to = (Todo *) mMoveIncidence;
             QTime tim;
             if ( to->hasDueDate() ) 
                 tim = to->dtDue().time();
             else {
                 tim = QTime ( 0,0,0 );
                 to->setFloats( true );
                 to->setHasDueDate( true );
             }
             QDateTime dt ( d,tim );
             to->setDtDue( dt );
             todoChanged( to );
         } else { 
             QTime tim = mMoveIncidence->dtStart().time(); 
             int secs = mMoveIncidence->dtStart().secsTo(  mMoveIncidence->dtEnd());
             QDateTime dt ( d,tim );
             mMoveIncidence->setDtStart( dt );
             ((Event*)mMoveIncidence)->setDtEnd( dt.addSecs( secs ) );
             changeEventDisplay((Event*)mMoveIncidence, KOGlobals::EVENTEDITED);
         }
         
         mMoveIncidence->setRevision( mMoveIncidence->revision()+1  );
     }
 }
 
 void CalendarView::removeCategories()
 {
     QPtrList<Incidence> incList  = mCalendar->rawIncidences(); 
     QStringList catList = KOPrefs::instance()->mCustomCategories;
     QStringList catIncList;
     QStringList newCatList;
     Incidence* inc = incList.first();
     int i;
     int count = 0;
     while ( inc ) {
         newCatList.clear();
         catIncList =  inc->categories() ;
         for( i = 0; i<   catIncList.count(); ++i ) {
             if ( catList.contains (catIncList[i]))
                 newCatList.append( catIncList[i] );
         }
         newCatList.sort();
         inc->setCategories( newCatList.join(",") );
         inc = incList.next();
     }
 }
 
 int CalendarView::addCategories()
 { 
     QPtrList<Incidence> incList  = mCalendar->rawIncidences(); 
     QStringList catList = KOPrefs::instance()->mCustomCategories;
     QStringList catIncList;
     Incidence* inc = incList.first();
     int i;
     int count = 0;
      while ( inc ) {
         catIncList = inc->categories() ;
         for( i = 0; i<   catIncList.count(); ++i ) {
             if ( !catList.contains (catIncList[i])) {
                 catList.append( catIncList[i] );
                 //qDebug("add cat %s ",  catIncList[i].latin1());
                 ++count;
             }
         }
         inc = incList.next();
     }
     catList.sort();
     KOPrefs::instance()->mCustomCategories = catList;
     return count;
 }
 
 void CalendarView::manageCategories()
 {
     KOCatPrefs* cp = new KOCatPrefs(); 
     cp->show();
     int w =cp->sizeHint().width() ;
     int h = cp->sizeHint().height() ;
     int dw = QApplication::desktop()->width();
     int dh = QApplication::desktop()->height();
     cp->setGeometry( (dw-w)/2, (dh - h )/2 ,w,h );
     if ( !cp->exec() ) {
         delete cp;
         return;
     }
     int count = 0;
     if ( cp->addCat() ) {
         count = addCategories();
         if ( count ) {
             topLevelWidget()->setCaption(QString::number( count )+ i18n(" Categories added to list! "));
             writeSettings();
         }
     } else {
         removeCategories();
         updateView();
     }
     delete cp;
 }
 
 void CalendarView::beamIncidence(Incidence * Inc) 
 {
     QPtrList<Incidence> delSel ;
     delSel.append(Inc);
     beamIncidenceList( delSel );
 } 
 void CalendarView::beamCalendar() 
 {
     QPtrList<Incidence> delSel  = mCalendar->rawIncidences(); 
     //qDebug("beamCalendar()  ");
     beamIncidenceList( delSel );
 }
 void CalendarView::beamFilteredCalendar() 
 {
     QPtrList<Incidence> delSel  = mCalendar->incidences(); 
     //qDebug("beamFilteredCalendar()  ");
     beamIncidenceList( delSel );
 }
 void  CalendarView::beamIncidenceList(QPtrList<Incidence> delSel )
 {
     if ( beamDialog->exec () == QDialog::Rejected ) 
         return;
   
     QString fn = "/tmp/kopibeamfile";
     QString mes;
     bool createbup = true;
     if ( createbup ) {
         QString description = "\n";
         CalendarLocal* cal = new CalendarLocal();
         if ( beamDialog->beamLocal() )
             cal->setLocalTime();
         else
             cal->setTimeZoneId(KOPrefs::instance()->mTimeZoneId);
         Incidence *incidence = delSel.first();
         bool addText = false;
         if ( delSel.count() < 10 )
             addText = true;
         else {
             description.sprintf(i18n("  %d items?"),delSel.count() );
         }
         while ( incidence ) {
             Incidence *in = incidence->clone();
             if ( addText )
                 description += in->summary() + "\n";
             cal->addIncidence( in );
             incidence = delSel.next();
         }
         if ( beamDialog->beamVcal() ) {
             fn += ".vcs";
             FileStorage storage( cal, fn, new VCalFormat );
             storage.save();
         } else {
             fn += ".ics";
             FileStorage storage( cal, fn, new ICalFormat( KOPrefs::instance()->mUseQuicksave) );
             storage.save();
         }
         delete cal;
         mes = i18n("KO/Pi: Ready for beaming");
         setCaption(mes); 
         
 #ifndef DESKTOP_VERSION
         Ir *ir = new Ir( this ); 
         connect( ir, SIGNAL( done( Ir * ) ), this, SLOT( beamDone( Ir * ) ) );
         ir->send( fn, description, "text/x-vCalendar" );
 #endif
     }
 }
 void  CalendarView::beamDone( Ir *ir )
 {
 #ifndef DESKTOP_VERSION
     delete ir;
 #endif
 }
 
 void CalendarView::moveIncidence(Incidence * inc ) 
 {
     if ( !inc ) return;
     // qDebug("showDatePickerForIncidence( ) ");
     if ( mDateFrame->isVisible() )
         mDateFrame->hide();
     else {
         int w =mDatePicker->sizeHint().width()+2*mDateFrame->lineWidth() ;
         int h = mDatePicker->sizeHint().height()+2*mDateFrame->lineWidth() ;
         int dw = QApplication::desktop()->width();
         int dh = QApplication::desktop()->height();
         mDateFrame->setGeometry( (dw-w)/2, (dh - h )/2 ,w,h );
         mDateFrame->show();
     }
     mDatePickerMode = 2;
     mMoveIncidence = inc ;
     QDate da;
     if ( mMoveIncidence->type() == "Todo" ) {
         Todo * to = (Todo *) mMoveIncidence;
             if ( to->hasDueDate() ) 
                 da = to->dtDue().date();
             else
                 da = QDate::currentDate();
     } else {
         da = mMoveIncidence->dtStart().date();
     }
     mDatePicker->setDate( da );
 }
 void CalendarView::showDatePicker( ) 
 {
     //qDebug("CalendarView::showDatePicker( )  ");
     if ( mDateFrame->isVisible() )
         mDateFrame->hide();
     else {
         int w =mDatePicker->sizeHint().width() ;
         int h = mDatePicker->sizeHint().height() ;
         int dw = QApplication::desktop()->width();
         int dh = QApplication::desktop()->height();
         mDateFrame->setGeometry( (dw-w)/2, (dh - h )/2 ,w,h );
         mDateFrame->show();
     }
     mDatePickerMode = 1;
     mDatePicker->setDate( mNavigator->selectedDates().first() );
 }
 
 void CalendarView::showEventEditor()
 {
 #ifdef DESKTOP_VERSION
     mEventEditor->show();
 #else
     mEventEditor->showMaximized();
 #endif
 }
 void CalendarView::showTodoEditor()
 {
 #ifdef DESKTOP_VERSION
     mTodoEditor->show();
 #else
     mTodoEditor->showMaximized();
 #endif
 }
 void CalendarView::cancelIncidence(Incidence * inc )
 {
     inc->setCancelled( ! inc->cancelled() );
     changeIncidenceDisplay( inc,KOGlobals::EVENTEDITED );
     updateView();
 }
 void CalendarView::cloneIncidence(Incidence * orgInc )
 { 
     Incidence * newInc = orgInc->clone();
     newInc->recreate();
  
     if ( newInc->type() == "Todo" ) {
         Todo* t = (Todo*) newInc; 
         mTodoEditor->editTodo( t );
         showTodoEditor();
         if ( mTodoEditor->exec() ) {
             mCalendar->addTodo( t );
             updateView();
         } else {
             delete t;
         }
     }
     else {
         Event*  e = (Event*)  newInc;
         mEventEditor->editEvent( e );
         showEventEditor();
         if ( mEventEditor->exec() ) {
             mCalendar->addEvent( e );
             updateView();
         } else {
             delete e;
         }
     }
 }
 
 void CalendarView::newEvent()
 {
     // TODO: Replace this code by a common eventDurationHint of KOBaseView.
     KOAgendaView *aView = mViewManager->agendaView();
     if (aView) {
         if (aView->selectionStart().isValid()) {
             if (aView->selectedIsAllDay()) {
                 newEvent(aView->selectionStart(),aView->selectionEnd(),true);
             } else {
                 newEvent(aView->selectionStart(),aView->selectionEnd());
             }
             return;
         }
     }
 
     QDate date = mNavigator->selectedDates().first();
     QDateTime current =  QDateTime::currentDateTime();
     if ( date <= current.date() ) {
         int hour = current.time().hour() +1;
         newEvent( QDateTime(  current.date(), QTime( hour, 0, 0 ) ),
                   QDateTime( current.date(), QTime( hour+ KOPrefs::instance()->mDefaultDuration, 0, 0 ) ) );
     } else
         newEvent( QDateTime( date, QTime( KOPrefs::instance()->mStartTime, 0, 0 ) ),
                   QDateTime( date, QTime( KOPrefs::instance()->mStartTime +
                                           KOPrefs::instance()->mDefaultDuration, 0, 0 ) ) );
 }
 
 void CalendarView::newEvent(QDateTime fh)
 {
     newEvent(fh,
              QDateTime(fh.addSecs(3600*KOPrefs::instance()->mDefaultDuration)));
 }
 
 void CalendarView::newEvent(QDate dt)
 {
     newEvent(QDateTime(dt, QTime(0,0,0)),
              QDateTime(dt, QTime(0,0,0)), true);
 }
 
 void CalendarView::newEvent(QDateTime fromHint, QDateTime toHint, bool allDay)
 {
   
     mEventEditor->newEvent(fromHint,toHint,allDay);
     if ( mFilterView->filtersEnabled() ) {
         CalFilter *filter = mFilterView->selectedFilter();
         if (filter && filter->showCategories()) {
             mEventEditor->setCategories(filter->categoryList().join(",") );
         }
         if ( filter )
             mEventEditor->setSecrecy( filter->getSecrecy() );
     }
     showEventEditor();
 }
 void  CalendarView::todoAdded(Todo * t)
 {
   
     changeTodoDisplay ( t ,KOGlobals::EVENTADDED);
     updateTodoViews();
 }
 void  CalendarView::todoChanged(Todo * t)
 {
     emit todoModified( t, 4 );
     // updateTodoViews();
 }
 void  CalendarView::todoToBeDeleted(Todo *)
 {
     //qDebug("todoToBeDeleted(Todo *) ");
     updateTodoViews();
 }
 void  CalendarView::todoDeleted()
 {
     //qDebug(" todoDeleted()");
     updateTodoViews();
 }
 
 
 
 void CalendarView::newTodo()
 { 
  
     mTodoEditor->newTodo(QDateTime::currentDateTime().addDays(7),0,true);
     if ( mFilterView->filtersEnabled() ) {
         CalFilter *filter = mFilterView->selectedFilter();
         if (filter && filter->showCategories()) {
             mTodoEditor->setCategories(filter->categoryList().join(",") );
         }
         if ( filter )
             mTodoEditor->setSecrecy( filter->getSecrecy() );
     }
     showTodoEditor();
 }
 
 void CalendarView::newSubTodo()
 {
     Todo *todo = selectedTodo();
     if ( todo ) newSubTodo( todo );
 }
 
 void CalendarView::newSubTodo(Todo *parentEvent)
 {
   
     mTodoEditor->newTodo(QDateTime::currentDateTime().addDays(7),parentEvent,true);
     showTodoEditor();
 }
 
 void CalendarView::newFloatingEvent()
 {
     DateList tmpList = mNavigator->selectedDates();
     QDate date = tmpList.first();
 
     newEvent( QDateTime( date, QTime( 12, 0, 0 ) ),
               QDateTime( date, QTime( 12, 0, 0 ) ), true );
 }
 
 
 void CalendarView::editEvent( Event *event )
 {
 
     if ( !event ) return;
     if ( event->isReadOnly() ) {
         showEvent( event );
         return;
     }
     mEventEditor->editEvent( event , mFlagEditDescription);
     showEventEditor();
 }
 void CalendarView::editJournal( Journal *jour )
 { 
     if ( !jour ) return;
     mDialogManager->hideSearchDialog();
     mViewManager->showJournalView();
     mNavigator->slotDaySelect( jour->dtStart().date() );
 }
 void CalendarView::editTodo( Todo *todo )
 {
     if ( !todo ) return;
  
     if ( todo->isReadOnly() ) {
         showTodo( todo );
         return;
     }
     mTodoEditor->editTodo( todo ,mFlagEditDescription);
     showTodoEditor();
 
 }
 
 KOEventViewerDialog* CalendarView::getEventViewerDialog()
 {
     if ( !mEventViewerDialog ) {
         mEventViewerDialog = new KOEventViewerDialog(this);
         connect( mEventViewerDialog, SIGNAL(  editIncidence( Incidence* )), this, SLOT(editIncidence( Incidence* )  ) );
         connect( this, SIGNAL(configChanged()), mEventViewerDialog, SLOT(updateConfig()));
         connect( mEventViewerDialog, SIGNAL(jumpToTime( const QDate &)), 
                  dateNavigator(), SLOT( selectWeek( const QDate & ) ) );
         connect( mEventViewerDialog, SIGNAL(showAgendaView( bool ) ), 
                  viewManager(), SLOT( showAgendaView( bool ) ) );
         mEventViewerDialog->resize( 640, 480 );
         
     }
     return mEventViewerDialog;
 }
 void CalendarView::showEvent(Event *event)
 {
     getEventViewerDialog()->setEvent(event);
     getEventViewerDialog()->showMe();
 }
 
 void CalendarView::showTodo(Todo *event)
 {
     getEventViewerDialog()->setTodo(event);
     getEventViewerDialog()->showMe();
 }
 void CalendarView::showJournal( Journal *jour )
 { 
     getEventViewerDialog()->setJournal(jour);
     getEventViewerDialog()->showMe();
    
 }
 // void CalendarView::todoModified (Todo *event, int changed)
 // {
 //  //  if (mDialogList.find (event) != mDialogList.end ()) {
 // //     kdDebug() << "Todo modified and open" << endl;
 // //     KOTodoEditor* temp = (KOTodoEditor *) mDialogList[event];
 // //     temp->modified (changed);
 
 // //   }
 
 //   mViewManager->updateView();
 // }
 
 void CalendarView::appointment_show()
 {
     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;
     }
 
     showEvent(anEvent);
 }
 
 void CalendarView::appointment_edit()
 {
     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;
     }
 
     editEvent(anEvent);
 }
 
 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_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( KOPrefs::instance()->mUseQuicksave);
     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( KOPrefs::instance()->mUseQuicksave) );
     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();
 }
 
 //#include "calendarview.moc"
 
 //#include "calendarviewbase.moc"