5 files changed, 435 insertions, 13 deletions

diff --git a/kaddressbook/kabcore.cpp b/kaddressbook/kabcore.cpp
index 6807bed..e7c815e 100644
--- a/kaddressbook/kabcore.cpp
+++ b/kaddressbook/kabcore.cpp
@@ -1,316 +1,323 @@
 /*
     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.
 */
 
 #include "kabcore.h"
 
 #include <stdaddressbook.h>
 #include <klocale.h>
 
 #ifndef KAB_EMBEDDED
 #include <qclipboard.h>
 #include <qdir.h>
 #include <qfile.h>
 #include <qapplicaton.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"
+
 #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>
 #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"
 #endif
 
 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
 {
 
   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() ) );
 
   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" );
 
   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&, const QString&)),this, SLOT(requestForNameEmailUidList(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();
 
  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 );
 
   }
 
 
 }
 
 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
 {
@@ -1872,100 +1879,126 @@ void KABCore::addActionsManually()
   // 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
 }
 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, const QString& param1)
+{
+  //param1 is usually empty for this kind of request
+
+  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);
+
+}
+
+
+
 
 #ifndef KAB_EMBEDDED
 #include "kabcore.moc"
 #endif //KAB_EMBEDDED
diff --git a/kaddressbook/kabcore.h b/kaddressbook/kabcore.h
index d4d28f1..fe778af 100644
--- a/kaddressbook/kabcore.h
+++ b/kaddressbook/kabcore.h
@@ -235,192 +235,195 @@ class KABCore : public QWidget
      */
     void setSearchFields( const KABC::Field::List &fields );
 
     /**
       Search with the current search field for a contact, that matches
       the given text, and selects it in the view.
      */
     void incrementalSearch( const QString& text );
 
     /**
       Marks the address book as modified.
      */
     void setModified();
     /**
       Marks the address book as modified without refreshing the view.
      */
     void setModifiedWOrefresh();
 
     /**
       Marks the address book as modified concerning the argument.
      */
     void setModified( bool modified );
 
     /**
       Returns whether the address book is modified.
      */
     bool modified() const;
 
     /**
       Called whenever an contact is modified in the contact editor
       dialog or the quick edit.
      */
     void contactModified( const KABC::Addressee &addr );
 
     /**
       DCOP METHODS.
      */
     void addEmail( QString addr );
     void importVCard( const KURL& url, bool showPreview );
     void importVCard( const QString& vCard, bool showPreview );
     void newContact();
     QString getNameByPhone( const QString& phone );
     /**
       END DCOP METHODS
      */
 
     /**
       Saves the contents of the AddressBook back to disk.
      */
     void save();
 
     /**
       Undos the last command using the undo stack.
      */
     void undo();
 
     /**
       Redos the last command that was undone, using the redo stack.
      */
     void redo();
 
     /**
       Shows the edit dialog for the given uid. If the uid is QString::null,
       the method will try to find a selected addressee in the view.
      */
     void editContact( const QString &uid /*US = QString::null*/ );
 //US added a second method without defaultparameter
     void editContact2();
 
     /**
       Shows or edits the detail view for the given uid. If the uid is QString::null,
       the method will try to find a selected addressee in the view.
      */
     void executeContact( const QString &uid /*US = QString::null*/ );
 
     /**
       Launches the configuration dialog.
      */
     void openConfigDialog();
 
     /**
       Launches the ldap search dialog.
      */
     void openLDAPDialog();
 
     /**
       Creates a KAddressBookPrinter, which will display the print
       dialog and do the printing.
      */
     void print();
 
     /**
       Registers a new GUI client, so plugins can register its actions.
      */
    void addGUIClient( KXMLGUIClient *client );
 
+   void requestForNameEmailUidList(const QString& sourceChannel, const QString& uid, const QString& param1);
+
+
   signals:
     void contactSelected( const QString &name );
     void contactSelected( const QPixmap &pixmap );
   public slots:
     void setDetailsVisible( bool visible );
     void setDetailsToState();
   private slots:
     void setJumpButtonBarVisible( bool visible );
   void importFromOL();
     void extensionModified( const KABC::Addressee::List &list );
     void extensionChanged( int id );
     void clipboardDataChanged();
     void updateActionMenu();
     void configureKeyBindings();
     void removeVoice();
 #ifdef KAB_EMBEDDED
     void configureResources();
 #endif //KAB_EMBEDDED
 
     void slotEditorDestroyed( const QString &uid );
     void configurationChanged();
     void addressBookChanged();
 
   private:
     void initGUI();
     void initActions();
 
     AddresseeEditorDialog *createAddresseeEditorDialog( QWidget *parent,
                                                         const char *name = 0 );
 
  KXMLGUIClient *mGUIClient;
 
   KABC::AddressBook *mAddressBook;
 
   ViewManager *mViewManager;
   // QSplitter *mDetailsSplitter;
   KDGanttMinimizeSplitter *mExtensionBarSplitter;
   ViewContainer *mDetails;
   KDGanttMinimizeSplitter* mMiniSplitter;
   XXPortManager *mXXPortManager;
   JumpButtonBar *mJumpButtonBar;
   IncSearchWidget *mIncSearchWidget;
   ExtensionManager *mExtensionManager;
 
   KCMultiDialog *mConfigureDialog;
 
 #ifndef KAB_EMBEDDED
     LDAPSearchDialog *mLdapSearchDialog;
 #endif //KAB_EMBEDDED
     // QDict<AddresseeEditorDialog> mEditorDict;
     AddresseeEditorDialog *mEditorDialog;
     bool mReadWrite;
     bool mModified;
     bool mIsPart;
     bool mMultipleViewsAtOnce;
 
 
     //US file menu
     KAction *mActionMail;
     KAction *mActionBeam;
     KAction* mActionPrint;
     KAction* mActionNewContact;
     KAction *mActionSave;
     KAction *mActionEditAddressee;
     KAction *mActionMailVCard;
     KAction *mActionBeamVCard;
 
     KAction *mActionQuit;
 
     //US edit menu
     KAction *mActionCopy;
     KAction *mActionCut;
     KAction *mActionPaste;
     KAction *mActionSelectAll;
     KAction *mActionUndo;
     KAction *mActionRedo;
     KAction *mActionDelete;
 
     //US settings menu
     KAction *mActionConfigResources;
     KAction *mActionConfigKAddressbook;
     KAction *mActionConfigShortcuts;
     KAction *mActionConfigureToolbars;
     KAction *mActionKeyBindings;
     KToggleAction *mActionJumpBar;
     KToggleAction *mActionDetails;
     KAction *mActionWhoAmI;
     KAction *mActionCategories;
     KAction *mActionAboutKAddressbook;
     KAction *mActionLicence;
 
     KAction *mActionDeleteView;
 
     QPopupMenu *viewMenu;
     QPopupMenu *filterMenu;
     QPopupMenu *settingsMenu;
diff --git a/kaddressbook/mainembedded.cpp b/kaddressbook/mainembedded.cpp
index 7f368eb..850e5b2 100644
--- a/kaddressbook/mainembedded.cpp
+++ b/kaddressbook/mainembedded.cpp
@@ -1,162 +1,163 @@
 #ifndef DESKTOP_VERSION
 #include <qpe/qpeapplication.h>
 #include <stdlib.h>
 #else
 #include <qapplication.h>
-#include <qwindowsstyle.h> 
-#include <qplatinumstyle.h> 
-#include <qmainwindow.h> 
+#include <qwindowsstyle.h>
+#include <qplatinumstyle.h>
+#include <qmainwindow.h>
 #endif
 
 #include <kstandarddirs.h>
 #include <kglobal.h>
 #include <stdio.h>
 #include <qdir.h>
 #include "kaddressbookmain.h"
+#include "externalapphandler.h"
 
 int main( int argc, char **argv )
 {
 #ifndef DESKTOP_VERSION
   QPEApplication a( argc, argv );
   a.setKeepRunning ();
 #else
-  QApplication a( argc, argv ); 
+  QApplication a( argc, argv );
   QApplication::setStyle( new QPlatinumStyle ());
 #endif
-  
+
   bool exitHelp = false;
   if ( argc > 1 ) {
       QString command = argv[1];
       if (  command == "-help" ){
           printf("KA/E command line commands:\n");
           printf("  no command: Start KA/E in usual way\n");
-          printf("  -help: This output\n");  
+          printf("  -help: This output\n");
           printf(" KA/E is exiting now. Bye!\n");
           exitHelp = true;
       }
   }
   if ( ! exitHelp ) {
 
     KGlobal::setAppName( "kaddressbook" );
 #ifndef DESKTOP_VERSION
     if ( QApplication::desktop()->width() > 320 )
         KGlobal::iconLoader()->setIconPath(QString(getenv("QPEDIR"))+"/pics/kdepim/kaddressbook/icons22/");
     else
         KGlobal::iconLoader()->setIconPath(QString(getenv("QPEDIR"))+"/pics/kdepim/kaddressbook/icons16/");
 #else
       QString fileName ;
       fileName  = qApp->applicationDirPath () + "/kdepim/kaddressbook/icons22/";
       KGlobal::iconLoader()->setIconPath(QDir::convertSeparators(fileName));
       QApplication::addLibraryPath ( qApp->applicationDirPath () );
 
-#endif 
+#endif
       KStandardDirs::setAppDir( QDir::convertSeparators(locateLocal("data", "kaddressbook")));
        KAddressBookMain m ;
 //US      MainWindow m;
-//US      QObject::connect( &a, SIGNAL (appMessage ( const QCString &, const QByteArray & )),&m, SLOT(recieve(  const QCString&, const QByteArray& )));
+      QObject::connect(&a, SIGNAL (appMessage ( const QCString &, const QByteArray & )), ExternalAppHandler::instance(), SLOT (appMessage ( const QCString &, const QByteArray & )));
 
 #ifndef DESKTOP_VERSION
        a.showMainWidget( &m );
 #else
       a.setMainWidget( &m );
       m.resize (640, 480 );
       m.show();
 #endif
       a.exec();
-      
+
   }
   qDebug("KA: Bye! ");
 }
 
 /*
 #include <stdlib.h>
 
 #include <qstring.h>
 
 #include <kabc/stdaddressbook.h>
 #include <kaboutdata.h>
 #include <kcmdlineargs.h>
 #include <kcrash.h>
 #include <kdebug.h>
 #include <klocale.h>
 #include <kstartupinfo.h>
 #include <kuniqueapplication.h>
 #include <kwin.h>
 
 #include "kaddressbookmain.h"
 #include "kabcore.h"
 
 extern "C" {
 
 void crashHandler( int )
 {
   KABC::StdAddressBook::handleCrash();
   ::exit( 0 );
 }
 
 }
 
 class KAddressBookApp : public KUniqueApplication {
   public:
     KAddressBookApp() : mMainWin( 0 ) {}
     ~KAddressBookApp() {}
 
     int newInstance();
 
   private:
     KAddressBookMain *mMainWin;
 };
 
 int KAddressBookApp::newInstance()
 {
   if ( isRestored() ) {
     // There can only be one main window
     if ( KMainWindow::canBeRestored( 1 ) ) {
       mMainWin = new KAddressBookMain;
       mMainWin->show();
       mMainWin->restore( 1 );
     }
   } else {
     KCmdLineArgs *args = KCmdLineArgs::parsedArgs();
 
     QCString addrStr = args->getOption( "addr" );
     QCString uidStr = args->getOption( "uid" );
     QString addr;
     QString uid;
     if ( !addrStr.isEmpty() )
       addr = QString::fromLocal8Bit( addrStr );
     if ( !uidStr.isEmpty() )
       uid = QString::fromLocal8Bit( uidStr );
 
 
     if ( args->isSet( "editor-only" ) ) {
       if ( !mMainWin )
         mMainWin = new KAddressBookMain;
         KStartupInfo::appStarted();
         mMainWin->hide();
     } else {
       if ( mMainWin ) {
         mMainWin->show();
         KWin::setActiveWindow( mMainWin->winId() );
       } else {
         mMainWin = new KAddressBookMain;
         mMainWin->show();
       }
     }
     // Can not see why anyone would pass both a uid and an email address, so I'll leave it that two contact editors will show if they do
     if ( !addr.isEmpty() )
       mMainWin->addEmail( addr );
 
     if ( !uid.isEmpty() )
       mMainWin->showContactEditor( uid );
     if ( args->isSet( "new-contact" ) ) {
       mMainWin->newContact();
     }
   }
 
   KCrash::setEmergencySaveFunction( crashHandler );
 
   return 0;
 }
 
 // the dummy argument is required, because KMail apparently sends an empty
diff --git a/libkdepim/externalapphandler.cpp b/libkdepim/externalapphandler.cpp
index 35638b1..64caa7d 100644
--- a/libkdepim/externalapphandler.cpp
+++ b/libkdepim/externalapphandler.cpp
@@ -1,156 +1,392 @@
 /*
     This file is part of libkdepim.
     Copyright (c) 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.
 
     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 <stdlib.h>
 
 #include <qfile.h>
 #include <qmap.h>
 #include <qregexp.h>
 
 #ifndef DESKTOP_VERSION
 #include <qtopia/qcopenvelope_qws.h>
 #endif
 
 #include <kstaticdeleter.h>
 #include <kmessagebox.h>
 
 
 #include "externalapphandler.h"
 
 #include "kpimglobalprefs.h"
 
+/*********************************************************************************
+ *
+ ********************************************************************************/
+
+
+QCopTransferItem::QCopTransferItem(const QString& sourceMessage, const QString& targetChannel, const QString& targetMessage)
+  : _sourceMessage(sourceMessage), _targetChannel(targetChannel), _targetMessage(targetMessage)
+{
+  //sourceMessage passes later three parameters: sourceChannel, uid, param1
+  _sourceMessageParameters = "(QString,QString,QString)";
+}
+
+/*********************************************************************************/
+
+QCopTransferItem::QCopTransferItem()
+{
+}
+
+/*********************************************************************************/
+bool QCopTransferItem::sendMessageToTarget(const QString& uid, const QString& param1)
+{
+
+#ifndef DESKTOP_VERSION
+  //sourceMessage passes two parameters: sourceChannel, uid
+  QString sourceMessage = _sourceMessage + _sourceMessageParameters;
+
+  qDebug("Using QCopEnvelope e(\"%s\",\"%s\")", _targetChannel.latin1(), sourceMessage.latin1());
+  qDebug("passing sourcechannel(%s), uid(%s), param1(%s) as parameter to QCopEnvelope", _sourceChannel.latin1(), uid.latin1(), param1.latin1());
+
+  QCopEnvelope e(_targetChannel.latin1(), sourceMessage.latin1());
+
+  e << _sourceChannel << uid << param1;
+
+  return true;
+
+#else
+  KMessageBox::sorry( 0, i18n( "This version does not support QCop." ) );
+  return false;
+#endif
+
+}
+
+
+/*********************************************************************************/
+void QCopTransferItem::setSourceChannel(const QString& sourceChannel)
+{
+
+  if (_sourceChannel.isEmpty())
+    _sourceChannel = sourceChannel;
+}
+
+
+/*********************************************************************************/
+bool QCopTransferItem::appMessage( const QCString& cmsg, const QByteArray& data )
+{
+/*US
+  // copied from old mail2
+  static int ii = 0;
+
+  // block second call
+  if ( ii < 2 ) {
+    ++ii;
+    if ( ii > 1 ) {
+      qDebug("qcop call blocked ");
+      return true;
+    }
+  }
+*/
+  qDebug("QCopTransferItem- QCOP message received: %s ", cmsg.data()  );
+
+  //we are in the target and get a request from the source
+  if ( (_sourceMessage + _sourceMessageParameters) == cmsg.data())
+  {
+    QDataStream stream( data, IO_ReadOnly );
+
+
+    QString sourceChannel;
+    QString uid;
+    QString param1;
 
+    stream >> sourceChannel >> uid >> param1;
 
+    emit receivedMessageFromSource(sourceChannel, uid, param1);
 
+    return true;
+  }
+
+  return false;
+}
+
+
+/*********************************************************************************
+ *
+ ********************************************************************************/
+
+
+QCopMapTransferItem::QCopMapTransferItem(const QString& sourceMessage, const QString& targetChannel, const QString& targetMessage)
+  : QCopTransferItem(sourceMessage, targetChannel,targetMessage)
+{
+  //targetMessage returns later two parameters: uid, and map<qstring,qstring>
+  _targetMessageParameters = "(QString,QMAP<QString,QString>)";
+}
+
+/*********************************************************************************/
+bool QCopMapTransferItem::sendMessageToSource(const QString& uid, const QMap<QString,QString>& nameEmailMap)
+{
+#ifndef DESKTOP_VERSION
+  //targetMessage passes two parameters: uid, map
+  QString targetMessage = _targetMessage + _targetMessageParameters;
+
+  qDebug("Using QCopEnvelope e(\"%s\",\"%s\")", _sourceChannel.latin1(), targetMessage.latin1());
+  qDebug("passing uid(%s) and map as parameter to QCopEnvelope", uid.latin1());
 
+  QCopEnvelope e(_sourceChannel.latin1(), targetMessage.latin1());
+    //US we need no names in the To field. The emailadresses are enough
+
+  e << uid << nameEmailMap;
+
+  return true;
+
+#else
+  KMessageBox::sorry( 0, i18n( "This version does not support QCop." ) );
+  return false;
+#endif
+
+}
+
+
+/*********************************************************************************/
+bool QCopMapTransferItem::appMessage( const QCString& cmsg, const QByteArray& data )
+{
+  bool res = QCopTransferItem::appMessage( cmsg, data );
+
+  if (res == false)
+  {
+    QDataStream stream( data, IO_ReadOnly );
+
+    qDebug("QCopMapTransferItem- QCOP message received: %s ", cmsg.data()  );
+
+    //we are in the source and get an answer from the target
+    if ((_targetMessage + _targetMessageParameters) == cmsg.data())
+    {
+      QMap<QString,QString> adrMap;
+      QString uid;
+
+      stream >> uid >> adrMap;
+
+      emit receivedMessageFromTarget(uid, adrMap);
+
+
+      return true;
+    }
+  }
+
+  return false;
+}
+
+
+/*********************************************************************************
+ *
+ ********************************************************************************/
+
+
+QCopListTransferItem::QCopListTransferItem(const QString& sourceMessage, const QString& targetChannel, const QString& targetMessage)
+  : QCopTransferItem(sourceMessage, targetChannel,targetMessage)
+{
+  //targetMessage returns later two parameters: uid, and map<qstring,qstring>
+  _targetMessageParameters = "(QString,QStringList,QStringList,QStringList)";
+}
+
+/*********************************************************************************/
+bool QCopListTransferItem::sendMessageToSource(const QString& uid, const QStringList& list1, const QStringList& list2, const QStringList& list3)
+{
+#ifndef DESKTOP_VERSION
+  //targetMessage passes two parameters: uid, map
+  QString targetMessage = _targetMessage + _targetMessageParameters;
+
+  qDebug("Using QCopEnvelope e(\"%s\",\"%s\")", _sourceChannel.latin1(), targetMessage.latin1());
+  qDebug("passing uid(%s) and list1, list2, list3 as parameter to QCopEnvelope", uid.latin1());
+
+  QCopEnvelope e(_sourceChannel.latin1(), targetMessage.latin1());
+    //US we need no names in the To field. The emailadresses are enough
+
+  e << uid << list1 << list2 << list3;
+
+  return true;
+
+#else
+  KMessageBox::sorry( 0, i18n( "This version does not support QCop." ) );
+  return false;
+#endif
+
+}
+
+
+/*********************************************************************************/
+bool QCopListTransferItem::appMessage( const QCString& cmsg, const QByteArray& data )
+{
+  bool res = QCopTransferItem::appMessage( cmsg, data );
+
+  if (res == false)
+  {
+    QDataStream stream( data, IO_ReadOnly );
+
+    qDebug("QCopListTransferItem- QCOP message received: %s ", cmsg.data()  );
+
+    //we are in the source and get an answer from the target
+    if ((_targetMessage + _targetMessageParameters) == cmsg.data())
+    {
+      QStringList list1;
+      QStringList list2;
+      QStringList list3;
+      QString uid;
+
+      stream >> uid >> list1 >> list2 >> list3;
+
+      emit receivedMessageFromTarget(uid, list1, list2, list3);
+
+
+      return true;
+    }
+  }
+
+  return false;
+}
+
+
+
+/*********************************************************************************
+ *
+ ********************************************************************************/
 
 
 ExternalAppHandler *ExternalAppHandler::sInstance = 0;
 static KStaticDeleter<ExternalAppHandler> staticDeleter;
 
-
 ExternalAppHandler::ExternalAppHandler()
 {
   mDefaultItems.setAutoDelete(true);
+
+  mNameEmailUidListFromKAPITransfer = new QCopListTransferItem("requestNameEmailUIDListFromKAPI", "QPE/Application/kapi", "receiveNameEmailUIDList");
+  connect(mNameEmailUidListFromKAPITransfer, SIGNAL (receivedMessageFromSource(const QString&, const QString&, const QString&)), this, SIGNAL (requestForNameEmailUidList(const QString&, const QString&, const QString&)));
+  connect(mNameEmailUidListFromKAPITransfer, SIGNAL (receivedMessageFromTarget(const QString&, const QStringList&, const QStringList&, const QStringList&)), this, SIGNAL (receivedNameEmailUidListEvent(const QString&, const QStringList&, const QStringList&, const QStringList&)));
+
+//US  mFindByEmailFromKAPITransfer = new QCopListTransferItem("requestFindByEmailFromKAPI", "QPE/Application/kapi", "receiveFindByEmailNameEmailUIDList");
+//US  connect(mFindByEmailFromKAPITransfer, SIGNAL (receivedMessageFromSource(const QString&, const QString&, const QString&)), this, SIGNAL (requestForFindByEmail(const QString&, const QString&, const QString&)));
+//US  connect(mFindByEmailFromKAPITransfer, SIGNAL (receivedMessageFromTarget(const QString&, const QStringList&, const QStringList&, const QStringList&)), this, SIGNAL (receivedFindByEmailEvent(const QString&, const QStringList&, const QStringList&, const QStringList&)));
+
+
 }
 
 ExternalAppHandler::~ExternalAppHandler()
 {
 }
 
 void ExternalAppHandler::loadConfig()
 {
 
   mDefaultItems.clear();
 
   mEmailAppAvailable = UNDEFINED;
   mPhoneAppAvailable = UNDEFINED;
   mFaxAppAvailable = UNDEFINED;
   mSMSAppAvailable = UNDEFINED;
   mPagerAppAvailable = UNDEFINED;
 
 
   QString opiepath = QString::fromLatin1( getenv("OPIEDIR") );
   QString qtopiapath = QString::fromLatin1( getenv("QPEDIR") );
 
   if (opiepath.isEmpty())
     opiepath = qtopiapath;
 
   //mailclients
   QString mailmsg1 = "writeMail(QString,QString)";
   QString mailmsg2 = "writeMail(QMap(QString,QString))";
 
   QString undefined = "";
 
   addDefaultAppItem(ExternalAppHandler::EMAIL, KPimGlobalPrefs::NONE_EMC,   "No email client installed",       undefined,                undefined,        undefined, undefined, undefined);
   addDefaultAppItem(ExternalAppHandler::EMAIL, KPimGlobalPrefs::OTHER_EMC,  "Userdefined email client",       undefined,                undefined,        undefined, undefined, undefined);
 
   if (( QFile::exists( qtopiapath + "/bin/ompi" )) ||
      ( QFile::exists( opiepath + "/bin/ompi" )))
     addDefaultAppItem(ExternalAppHandler::EMAIL, KPimGlobalPrefs::OMPI_EMC,   "OM/Pi email client",   "QPE/Application/ompi",    mailmsg1, "%1;%2",        mailmsg2,   "TO=%1;ATTACHMENT=%2");
 
   if ( QFile::exists( qtopiapath + "/bin/qtmail" ))
     addDefaultAppItem(ExternalAppHandler::EMAIL, KPimGlobalPrefs::QTOPIA_EMC, "Qtopia email client", "QPE/Application/qtmail",   mailmsg1, "%1;%2",       mailmsg2,    "TO=%1;ATTACHMENT=%2");
 
   if ( QFile::exists( opiepath + "/bin/opiemail" ))
     addDefaultAppItem(ExternalAppHandler::EMAIL, KPimGlobalPrefs::OPIE_EMC,   "Opie email client",   "QPE/Application/opiemail", mailmsg1, "%1;%2",       mailmsg2,    "TO=%1;ATTACHMENT=%2");
 
 
 
   //phoneclients
 
   addDefaultAppItem(ExternalAppHandler::PHONE, KPimGlobalPrefs::NONE_PHC,  "No phone client installed",       undefined,            undefined, undefined, undefined, undefined);
   addDefaultAppItem(ExternalAppHandler::PHONE, KPimGlobalPrefs::OTHER_PHC,  "Other phone client",       undefined,            undefined, undefined, undefined, undefined);
   if (( QFile::exists( qtopiapath + "/bin/kppi" )) ||
      ( QFile::exists( opiepath + "/bin/kppi" )))
     addDefaultAppItem(ExternalAppHandler::PHONE, KPimGlobalPrefs::KPPI_PHC,   "KP/Pi phone client",       "QPE/Application/kppi", "-ring:%1", "", undefined, undefined);
 
   //faxclients
   addDefaultAppItem(ExternalAppHandler::FAX,   KPimGlobalPrefs::NONE_FAC,  "No fax client installed",       undefined,            undefined, undefined, undefined, undefined);
   addDefaultAppItem(ExternalAppHandler::FAX,   KPimGlobalPrefs::OTHER_FAC,  "Other fax client",       undefined,            undefined, undefined, undefined, undefined);
 
   //smsclients
   addDefaultAppItem(ExternalAppHandler::SMS,   KPimGlobalPrefs::NONE_SMC,  "No sms client installed",       undefined,            undefined, undefined, undefined, undefined);
   addDefaultAppItem(ExternalAppHandler::SMS,   KPimGlobalPrefs::OTHER_SMC,  "Other sms client",       undefined,            undefined, undefined, undefined, undefined);
 
   //pagerclients
   addDefaultAppItem(ExternalAppHandler::PAGER, KPimGlobalPrefs::NONE_PAC,  "No pager client installed",       undefined,            undefined, undefined, undefined, undefined);
   addDefaultAppItem(ExternalAppHandler::PAGER, KPimGlobalPrefs::OTHER_PAC,  "Other pager client",       undefined,            undefined, undefined, undefined, undefined);
 
 }
 
 ExternalAppHandler *ExternalAppHandler::instance()
 {
   if ( !sInstance ) {
     sInstance = staticDeleter.setObject( new ExternalAppHandler() );
     sInstance->loadConfig();
   }
 
   return sInstance;
 }
 
 void ExternalAppHandler::addDefaultAppItem(Types type, int id, const QString& label,  const QString& channel, const QString& message, const QString& parameter, const QString& message2, const QString& parameter2)
 {
   DefaultAppItem* dai = new DefaultAppItem(type, id, label,  channel, message, parameter, message2, parameter2);
 
   mDefaultItems.append(dai);
 }
 
 
 QList<DefaultAppItem> ExternalAppHandler::getAvailableDefaultItems(Types type)
 {
   QList<DefaultAppItem> list;
 
   DefaultAppItem* dai;
 
   for ( dai=mDefaultItems.first(); dai != 0; dai=mDefaultItems.next() )
   {
     if (dai->_type == type)
       list.append(dai);
   }
@@ -298,193 +534,194 @@ bool ExternalAppHandler::mailToMultipleContacts( const QString& emails, const QS
 
   //first check if one of the mailers need the emails right in the message.
   message2 = translateMessage(message2, emails, urls);
 
 
   qDebug("Using QCopEnvelope e(\"%s\",\"%s\")", channel.latin1(), message2.latin1());
   qDebug("passing emailadresses(%s), attachmenturls(%s) as parameters in the form %s to QCopEnvelope", emails.latin1() , urls.latin1(), parameters2.latin1());
 
 
   QCopEnvelope e(channel.latin1(), message2.latin1());
     //US we need no names in the To field. The emailadresses are enough
 
   passParameters(&e, parameters2, emails, urls);
 
 
 
 #else
   KMessageBox::sorry( 0, i18n( "This version does not support the sending of emails." ) );
 #endif
 
   return true;
 }
 
 /**************************************************************************
  *
  **************************************************************************/
 
 
 //calls the emailapplication and creates a mail with parameter emails as recipients
 bool ExternalAppHandler::mailToOneContact( const QString& name, const QString& emailadress )
 {
 #ifndef DESKTOP_VERSION
   QString channel;
   QString message;
   QString parameters;
 
 
   int client = KPimGlobalPrefs::instance()->mEmailClient;
   if (client == KPimGlobalPrefs::OTHER_EMC)
   {
     channel = KPimGlobalPrefs::instance()->mEmailOtherChannel;
     message = KPimGlobalPrefs::instance()->mEmailOtherMessage;
     parameters = KPimGlobalPrefs::instance()->mEmailOtherMessageParameters;
   }
   else
   {
     DefaultAppItem* dai = ExternalAppHandler::getDefaultItem(EMAIL, client);
     if (!dai)
     {
       qDebug("could not find configured email application.");
           return false;
     }
     channel = dai->_channel;
     message = dai->_message;
     parameters = dai->_parameters;
   }
 
 
   //first check if one of the mailers need the emails right in the message.
   message = translateMessage(message, name, emailadress);
 
 
   qDebug("Using QCopEnvelope e(\"%s\",\"%s\")", channel.latin1(), message.latin1());
   qDebug("passing name(%s), emailadresses(%s) as parameters in the form %s to QCopEnvelope", name.latin1(), emailadress.latin1(), parameters.latin1());
 
   QCopEnvelope e(channel.latin1(), message.latin1());
     //US we need no names in the To field. The emailadresses are enough
 
   passParameters(&e, parameters, name, emailadress);
 
 
 #else
   KMessageBox::sorry( 0, i18n( "This version does not support the sending of emails." ) );
 #endif
 
 
   return true;
 }
 
 /**************************************************************************
  *
  **************************************************************************/
 
 //calls the emailapplication and creates a mail with parameter as recipients
 // parameters format is
 //  NAME <EMAIL>:SUBJECT
 bool ExternalAppHandler::mailToOneContact( const QString& adressline )
 {
   QString line = adressline;
 
   int first = line.find( "<");
   int last = line.find( ">");
   QString name = line.left(first);
   QString emailadress = line.mid(first+1, last-first-1);
 
   //Subject can not be handled right now.
-  mailToOneContact( name, emailadress );
+  return mailToOneContact( name, emailadress );
+
 }
 
 
 /**************************************************************************
  *
  **************************************************************************/
 
 //calls the phoneapplication with the number
 bool ExternalAppHandler::callByPhone( const QString& phonenumber )
 {
 #ifndef DESKTOP_VERSION
   QString channel;
   QString message;
   QString parameters;
 
 
   int client = KPimGlobalPrefs::instance()->mPhoneClient;
   if (client == KPimGlobalPrefs::OTHER_PHC)
   {
     channel = KPimGlobalPrefs::instance()->mPhoneOtherChannel;
     message = KPimGlobalPrefs::instance()->mPhoneOtherMessage;
     parameters = KPimGlobalPrefs::instance()->mPhoneOtherMessageParameters;
   }
   else
   {
     DefaultAppItem* dai = ExternalAppHandler::getDefaultItem(PHONE, client);
     if (!dai)
     {
       qDebug("could not find configured phone application.");
           return false;
     }
     channel = dai->_channel;
     message = dai->_message;
     parameters = dai->_parameters;
   }
 
 
   //first check if one of the mailers need the emails right in the message.
   message = translateMessage(message, phonenumber, "");
 
 
   qDebug("Using QCopEnvelope e(\"%s\",\"%s\")", channel.latin1(), message.latin1());
   qDebug("passing phonenumber(%s) as parameter in the form %s to QCopEnvelope", phonenumber.latin1(), parameters.latin1());
 
   QCopEnvelope e(channel.latin1(), message.latin1());
     //US we need no names in the To field. The emailadresses are enough
 
   passParameters(&e, parameters, phonenumber, "");
 
 
 #else
   KMessageBox::sorry( 0, i18n( "This version does not support phonecalls." ) );
 #endif
 
 
   return true;
 }
 
 /**************************************************************************
  *
  **************************************************************************/
 
 //calls the smsapplication with the number
 bool ExternalAppHandler::callBySMS( const QString& phonenumber )
 {
 #ifndef DESKTOP_VERSION
   QString channel;
   QString message;
   QString parameters;
 
 
   int client = KPimGlobalPrefs::instance()->mSMSClient;
   if (client == KPimGlobalPrefs::OTHER_SMC)
   {
     channel = KPimGlobalPrefs::instance()->mSMSOtherChannel;
     message = KPimGlobalPrefs::instance()->mSMSOtherMessage;
     parameters = KPimGlobalPrefs::instance()->mSMSOtherMessageParameters;
   }
   else
   {
     DefaultAppItem* dai = ExternalAppHandler::getDefaultItem(SMS, client);
     if (!dai)
     {
       qDebug("could not find configured sms application.");
           return false;
     }
     channel = dai->_channel;
     message = dai->_message;
     parameters = dai->_parameters;
   }
 
 
   //first check if one of the mailers need the emails right in the message.
   message = translateMessage(message, phonenumber, "");
 
 
@@ -586,96 +823,137 @@ bool ExternalAppHandler::callByFax( const QString& faxnumber )
     if (!dai)
     {
       qDebug("could not find configured fax application.");
           return false;
     }
     channel = dai->_channel;
     message = dai->_message;
     parameters = dai->_parameters;
   }
 
 
   //first check if one of the mailers need the emails right in the message.
   message = translateMessage(message, faxnumber, "");
 
 
   qDebug("Using QCopEnvelope e(\"%s\",\"%s\")", channel.latin1(), message.latin1());
   qDebug("passing faxnumber(%s) as parameter in the form %s to QCopEnvelope", faxnumber.latin1(), parameters.latin1());
 
   QCopEnvelope e(channel.latin1(), message.latin1());
     //US we need no names in the To field. The emailadresses are enough
 
   passParameters(&e, parameters, faxnumber, "");
 
 
 #else
   KMessageBox::sorry( 0, i18n( "This version does not support the sending of faxes." ) );
 #endif
 
 
   return true;
 }
 
 /**************************************************************************
  *
  **************************************************************************/
 
 
 QString& ExternalAppHandler::translateMessage(QString& message, const QString& param1, const QString& param2 ) const
 {
   message = message.replace( QRegExp("%1"), param1 );
   return message.replace( QRegExp("%2"), param2 );
 }
 
 /**************************************************************************
  *
  **************************************************************************/
 
 void ExternalAppHandler::passParameters(QCopEnvelope* e, const QString& parameters, const QString& param1 , const QString& param2) const
 {
 #ifndef DESKTOP_VERSION
   QMap<QString, QString> valmap;
   bool useValMap = false;
 
   // first extract all parts of the parameters.
   QStringList paramlist = QStringList::split(";", parameters);
 
   //Now check how many parts we have.
   //=0 :no params to pass
   //>0 :parameters to pass
   for ( QStringList::Iterator it = paramlist.begin(); it != paramlist.end(); ++it )
   {
     QString param = (*it);
     QStringList keyvallist = QStringList::split("=", param);
 
     //if we have keyvalue pairs, we assume that we pass a map to the envelope
     QStringList::Iterator it2 = keyvallist.begin();
     QString key = (*it2);
     key = key.replace( QRegExp("%1"), param1 );
     key = key.replace( QRegExp("%2"), param2 );
     ++it2;
 
     if(it2 != keyvallist.end())
     {
       QString value = (*it2);
       value = value.replace( QRegExp("%1"), param1 );
       value = value.replace( QRegExp("%2"), param2 );
 
           valmap.insert(key, value);
           useValMap = true;
     }
     else
     {
       //      qDebug("pass parameter << %s", key.latin1());
       (*e) << key;
     }
   }
 
   if (useValMap == true)
     (*e) << valmap;
 
 #endif
 
 }
 
 
 
+/**************************************************************************
+ *
+ **************************************************************************/
+
+void ExternalAppHandler::appMessage( const QCString& cmsg, const QByteArray& data )
+{
+  bool res = mNameEmailUidListFromKAPITransfer->appMessage( cmsg, data );
+
+//  if (!res)
+//    res = mNameEmailUidListFromKAPITransfer->appMessage( cmsg, data );
+}
+
+
+
+bool ExternalAppHandler::requestNameEmailUidListFromKAPI(const QString& sourceChannel, const QString& uid)
+{
+  mNameEmailUidListFromKAPITransfer->setSourceChannel(sourceChannel);
+  return mNameEmailUidListFromKAPITransfer->sendMessageToTarget(uid, QString::null);
+}
+
+bool ExternalAppHandler::returnNameEmailUidListFromKAPI(const QString& sourceChannel, const QString& uid, const QStringList& list1, const QStringList& list2, const QStringList& list3)
+{
+  mNameEmailUidListFromKAPITransfer->setSourceChannel(sourceChannel);
+  return mNameEmailUidListFromKAPITransfer->sendMessageToSource(uid, list1, list2, list3);
+}
+
+bool ExternalAppHandler::requestFindByEmailFromKAPI(const QString& sourceChannel, const QString& uid, const QString& email)
+{
+  mFindByEmailFromKAPITransfer->setSourceChannel(sourceChannel);
+  return mFindByEmailFromKAPITransfer->sendMessageToTarget(uid, email);
+}
+
+bool ExternalAppHandler::returnFindByEmailFromKAPI(const QString& sourceChannel, const QString& uid, const QStringList& list1, const QStringList& list2, const QStringList& list3)
+{
+  mFindByEmailFromKAPITransfer->setSourceChannel(sourceChannel);
+  return mFindByEmailFromKAPITransfer->sendMessageToSource(uid, list1, list2, list3);
+}
+
+
+
+
diff --git a/libkdepim/externalapphandler.h b/libkdepim/externalapphandler.h
index 3cf9e06..7c8de4e 100644
--- a/libkdepim/externalapphandler.h
+++ b/libkdepim/externalapphandler.h
@@ -1,145 +1,252 @@
 /*
     This file is part of libkdepim.
     Copyright (c) 2004 Ulf Schenk
 
     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$
 */
 
 #ifndef EXTERNALAPPHANDLER_H
 #define EXTERNALAPPHANDLER_H
 
+#include <qobject.h>
 #include <qlist.h>
+#include <qmap.h>
 
 class QCopEnvelope;
 
 
 class ExternalAppHandler;
+class QCopTransferItem  : public QObject
+{
+  Q_OBJECT
+  public:
+    QCopTransferItem(const QString& sourceMessage, const QString& targetChannel, const QString& targetMessage);
+        QCopTransferItem();
+
+    bool sendMessageToTarget(const QString& uid, const QString& param1);
+
+    void setSourceChannel(const QString& sourceChannel);
+
+    virtual bool appMessage( const QCString& msg, const QByteArray& data );
+
+
+ signals:
+    void receivedMessageFromSource(const QString& sourceChannel, const QString& uid, const QString& param1);
+
+
+  public:
+    QString _sourceChannel;
+    QString _sourceMessage;
+    QString _sourceMessageParameters;
+    QString _targetChannel;
+    QString _targetMessage;
+    QString _targetMessageParameters;
+
+};
+
+/*********************************************************************************
+ *
+ ********************************************************************************/
+
+class QCopMapTransferItem : public QCopTransferItem
+{
+  Q_OBJECT
+  public:
+    QCopMapTransferItem(const QString& sourceMessage, const QString& targetChannel, const QString& targetMessage);
+
+    bool sendMessageToSource(const QString& uid, const QMap<QString,QString>& nameEmailMap);
+
+
+    virtual bool appMessage( const QCString& msg, const QByteArray& data );
+
+
+ signals:
+    void receivedMessageFromTarget(const QString& uid, const QMap<QString,QString>& nameEmailMap);
+
+};
+
+/*********************************************************************************
+ *
+ ********************************************************************************/
+
+class QCopListTransferItem : public QCopTransferItem
+{
+  Q_OBJECT
+  public:
+    QCopListTransferItem(const QString& sourceMessage, const QString& targetChannel, const QString& targetMessage);
+
+    bool sendMessageToSource(const QString& uid, const QStringList& list1, const QStringList& list2, const QStringList& list3);
+
+
+    virtual bool appMessage( const QCString& msg, const QByteArray& data );
+
+
+ signals:
+    void receivedMessageFromTarget(const QString& uid, const QStringList& list1, const QStringList& list2, const QStringList& list3);
+
+};
+
+/*********************************************************************************
+ *
+ ********************************************************************************/
+
 
 class DefaultAppItem
 {
   public:
     DefaultAppItem(int type, int id, const QString& label,  const QString& channel, const QString& message, const QString& parameters, const QString& message2, const QString& parameters2)
       : _type(type), _id(id), _label(label), _channel(channel), _message(message), _parameters(parameters), _message2(message2), _parameters2(parameters2)
               {}
 
         DefaultAppItem()
         {  }
 
   public:
     int _type;
     int _id;
     QString _label;
     QString _channel;
     QString _message;
             QString _parameters;// a list of parameters in stringrepresentation. Delimiter is ;
     QString _message2;
     QString _parameters2;  // a list of parameters in stringrepresentation. Delimiter is ;
 
 };
 
-class ExternalAppHandler
+/*********************************************************************************
+ *
+ ********************************************************************************/
+
+class ExternalAppHandler : public QObject
 {
+  Q_OBJECT
   public:
     virtual ~ExternalAppHandler();
 
     static ExternalAppHandler *instance();
 
     enum Types {
                 EMAIL = 0,
                 PHONE = 1,
                 SMS   = 2,
                 FAX   = 3,
                 PAGER = 4
         };
 
     enum Availability {
                 UNDEFINED = -1,
                 UNAVAILABLE   = 0,
                 AVAILABLE = 1
         };
 
     //calls the emailapplication with a number of attachments that need to be send.
     //either parameter can be left empty.
     bool mailToMultipleContacts( const QString& recipients, const QString& attachmenturls );
 
     //calls the emailapplication and creates a mail with parameter emailadress as recipients
     bool mailToOneContact( const QString& name, const QString& emailadress );
 
     //calls the emailapplication and creates a mail with parameter as recipients
     // parameters format is
     //  NAME <EMAIL>:SUBJECT
     bool mailToOneContact( const QString& adressline );
 
     //calls the phoneapplication with the number
     bool callByPhone( const QString& phonenumber );
 
     //calls the smsapplication with the number
     bool callBySMS( const QString& phonenumber );
 
     //calls the pagerapplication with the number
     bool callByPager( const QString& pagernumber );
 
     //calls the faxapplication with the number
     bool callByFax( const QString& faxnumber );
 
     bool isEmailAppAvailable();
     bool isSMSAppAvailable();
     bool isPhoneAppAvailable();
     bool isFaxAppAvailable();
     bool isPagerAppAvailable();
 
 
+    //Call this method on the source when you want to select names from the addressbook by using QCop
+    bool requestNameEmailUidListFromKAPI(const QString& sourceChannel, const QString& uid);
+    //Call this method on the target when you want to return the name/email map to the source (client).
+    bool returnNameEmailUidListFromKAPI(const QString& sourceChannel, const QString& uid, const QStringList& name, const QStringList& email, const QStringList& uid);
+
+    bool requestFindByEmailFromKAPI(const QString& sourceChannel, const QString& uid, const QString& email);
+    bool returnFindByEmailFromKAPI(const QString& sourceChannel, const QString& uid, const QStringList& name, const QStringList& email, const QStringList& uid);
+
 
     //loadConfig clears the cache and checks again if the applications are available or not
     void loadConfig();
 
     QList<DefaultAppItem> getAvailableDefaultItems(Types);
     DefaultAppItem* getDefaultItem(Types, int);
 
+ public  slots:
+    void appMessage( const QCString& msg, const QByteArray& data );
+
+
+ signals:
+    // Emmitted when the target app receives a request from the source app
+    void requestForNameEmailUidList(const QString& sourceChannel, const QString& uid, const QString& param1);
+
+    // Emitted when the source app recieves a list of name/email pairs (=addresses) from another target app. Usually Ka/Pi
+    // The first parameter is a uniqueid. It can be used to identify the event
+    void receivedNameEmailUidListEvent(const QString& uid, const QStringList& nameList, const QStringList& emailList, const QStringList& uidList);
+
+    void requestFindByEmail(const QString& sourceChannel, const QString& uid, const QString& email);
+    void receivedFindBbyEmailEvent(const QString& uid, const QStringList& nameList, const QStringList& emailList, const QStringList& uidList);
+
 
   private:
     ExternalAppHandler();
     QList<DefaultAppItem> mDefaultItems;
 
     Availability mEmailAppAvailable;
     Availability mPhoneAppAvailable;
     Availability mFaxAppAvailable;
     Availability mSMSAppAvailable;
     Availability mPagerAppAvailable;
 
+    QCopListTransferItem* mNameEmailUidListFromKAPITransfer;
+    QCopListTransferItem* mFindByEmailFromKAPITransfer;
+
 
     void addDefaultAppItem(Types type, int id, const QString& label,  const QString& channel, const QString& message, const QString& parameters, const QString& message2, const QString& parameters2);
 
     QString& translateMessage(QString& message, const QString& param1, const QString& param2) const;
         void passParameters(QCopEnvelope* e, const QString& parameters, const QString& param1, const QString& param2) const;
 
 
     static ExternalAppHandler *sInstance;
 
-
 };
 
+
 #endif