14 files changed, 482 insertions, 13 deletions
diff --git a/kabc/addresseeview.cpp b/kabc/addresseeview.cpp
new file mode 100644
index 0000000..b4717d7
--- a/dev/null
+++ b/kabc/addresseeview.cpp
@@ -0,0 +1,401 @@
+/*
+    This file is part of libkdepim.
+    Copyright (c) 2003 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.
+*/
+#include <kabc/address.h>
+#include <kabc/addressee.h>
+#include <kabc/phonenumber.h>
+#include <kglobal.h>
+//US#include <kglobalsettings.h>
+#include <kiconloader.h>
+#include <klocale.h>
+//US #include <kstringhandler.h>
+#include <qscrollview.h>
+#include <qregexp.h>
+#include <qfile.h>
+#include <qapplication.h>
+#include "externalapphandler.h"
+#include "addresseeview.h"
+//US #ifndef DESKTOP_VERSION
+//US #include <qtopia/qcopenvelope_qws.h>
+//US #include <qpe/qpeapplication.h>
+//US #endif
+//US static int kphoneInstalled = 0;
+using namespace KPIM;
+AddresseeView::AddresseeView( QWidget *parent, const char *name )
+//US  : KTextBrowser( parent, name )
+  : QTextBrowser( parent, name )
+{
+//US  setWrapPolicy( QTextEdit::AtWordBoundary );
+  setLinkUnderline( false );
+  // setVScrollBarMode( QScrollView::AlwaysOff );
+  //setHScrollBarMode( QScrollView::AlwaysOff );
+//US  QStyleSheet *sheet = styleSheet();
+//US  QStyleSheetItem *link = sheet->item( "a" );
+//US  link->setColor( KGlobalSettings::linkColor() );
+}
+void AddresseeView::setSource(const QString& n)
+{
+    //qDebug("********AddresseeView::setSource %s", n.latin1());
+  if ( n.left( 6 ) == "mailto" )
+    ExternalAppHandler::instance()->mailToOneContact( n.mid(7) );
+  else if ( n.left( 7 ) == "phoneto" )
+    ExternalAppHandler::instance()->callByPhone(  n.mid(8) );
+  else if ( n.left( 5 ) == "faxto" )
+    ExternalAppHandler::instance()->callByFax(  n.mid(6) );
+  else if ( n.left( 5 ) == "smsto" )
+    ExternalAppHandler::instance()->callBySMS(  n.mid(6) );
+  else if ( n.left( 7 ) == "pagerto" )
+    ExternalAppHandler::instance()->callByPager(  n.mid(8) );
+  else if ( n.left( 5 ) == "sipto" )
+    ExternalAppHandler::instance()->callBySIP(  n.mid(6) );
+}
+void AddresseeView::setAddressee( const KABC::Addressee& addr )
+{
+  ExternalAppHandler* eah = ExternalAppHandler::instance();
+  bool kemailAvail = eah->isEmailAppAvailable();
+  bool kphoneAvail = eah->isPhoneAppAvailable();
+  bool kfaxAvail = eah->isFaxAppAvailable();
+  bool ksmsAvail = eah->isSMSAppAvailable();
+  bool kpagerAvail = eah->isPagerAppAvailable();
+  bool ksipAvail = eah->isSIPAppAvailable();
+  mAddressee = addr;
+  // clear view
+  setText( QString::null );
+  if ( mAddressee.isEmpty() )
+    return;
+  QString name = ( mAddressee.assembledName().isEmpty() ?
+                   mAddressee.formattedName() : mAddressee.assembledName() );
+  QString dynamicPart;
+  QStringList emails = mAddressee.emails();
+  QStringList::ConstIterator emailIt;
+  QString type = i18n( "Email" );
+  emailIt = emails.begin();
+  if ( emailIt != emails.end() ) {
+    if ( kemailAvail ) {
+      dynamicPart += QString(
+            "<tr><td align=\"right\"><b>%1</b></td>"
+           "<td align=\"left\"><a href=\"mailto:%2 <%3> \">%4</a></td></tr>" )
+          .arg( type )
+          .arg( name )
+          .arg( *emailIt )
+          .arg( *emailIt );
+      ++emailIt;
+    } else {
+      dynamicPart += QString(
+            "<tr><td align=\"right\"><b>%1</b></td>"
+           "<td align=\"left\">%2</td></tr>" )
+          .arg( type )
+          .arg( *emailIt );
+      ++emailIt;
+    }
+  }
+  if ( mAddressee.birthday().date().isValid() ) {
+      dynamicPart += QString(
+            "<tr><td align=\"right\"><b>%1</b></td>"
+           "<td align=\"left\">%2</td></tr>" )
+          .arg( i18n ("Birthday") )
+          .arg( KGlobal::locale()->formatDate( mAddressee.birthday().date()  ,true) );
+  }
+  KABC::PhoneNumber::List phones = mAddressee.phoneNumbers();
+  KABC::PhoneNumber::List::ConstIterator phoneIt;
+  QString extension;
+  int phonetype;
+  QString sms;
+  for ( phoneIt = phones.begin(); phoneIt != phones.end(); ++phoneIt ) {
+    phonetype = (*phoneIt).type();
+    if (ksmsAvail &&
+        (
+                 ((phonetype & KABC::PhoneNumber::Car) == KABC::PhoneNumber::Car) ||
+         ((phonetype & KABC::PhoneNumber::Cell) == KABC::PhoneNumber::Cell)
+        )
+       )
+    {
+      sms = QString("<a href=\"smsto:%1  \">(sms)</a>" )
+              .arg( (*phoneIt).number() );
+    }
+    else
+      sms = "";
+    extension = QString::null;
+    if ((phonetype & KABC::PhoneNumber::Fax) == KABC::PhoneNumber::Fax) {
+      if (kfaxAvail) extension = "faxto:";
+    }
+    else if ((phonetype & KABC::PhoneNumber::Pager) == KABC::PhoneNumber::Pager) {
+      if (kpagerAvail) extension = "pagerto:";
+    }
+    else if ((phonetype & KABC::PhoneNumber::Sip) == KABC::PhoneNumber::Sip) {
+      if (ksipAvail) extension = "sipto:";
+    }
+    else if (kphoneAvail) {
+      extension = "phoneto:";
+    }
+    else
+      extension = QString::null;
+      if ( !extension.isEmpty() ) {
+          dynamicPart += QString(
+                                 "<tr><td align=\"right\"><b>%1</b></td>"
+           "<td align=\"left\"><a href=\"%2%3  \">%4</a> %5</td></tr>" )
+              .arg( KABC::PhoneNumber::typeLabel( phonetype ) )
+              .arg( extension )
+              .arg( (*phoneIt).number() )
+              .arg( (*phoneIt).number() )
+              .arg( sms );
+      } else {
+          dynamicPart += QString(
+                                 "<tr><td align=\"right\"><b>%1</b></td>"
+                                 "<td align=\"left\">%2 %3</td></tr>" )
+              .arg( KABC::PhoneNumber::typeLabel( phonetype ) )
+              .arg( (*phoneIt).number() )
+              .arg( sms );
+      }
+  }
+  for ( ; emailIt != emails.end(); ++emailIt ) {
+    if ( kemailAvail ) {
+      dynamicPart += QString(
+        "<tr><td align=\"right\"><b>%1</b></td>"
+        "<td align=\"left\"><a href=\"mailto:%2 <%3> \">%4</a></td></tr>" )
+        .arg( type )
+        .arg( name )
+        .arg( *emailIt )
+        .arg( *emailIt );
+        } else {
+      dynamicPart += QString(
+        "<tr><td align=\"right\"><b>%1</b></td>"
+        "<td align=\"left\">%2</td></tr>" )
+        .arg( type )
+        .arg( *emailIt );
+    }
+  }
+  if ( !mAddressee.url().url().isEmpty() ) {
+    dynamicPart += QString(
+      "<tr><td align=\"right\"><b>%1</b></td>"
+      "<td align=\"left\">%2</td></tr>" )
+      .arg( i18n( "Homepage" ) )
+//US      .arg( KStringHandler::tagURLs( mAddressee.url().url() ) );
+      .arg( mAddressee.url().url() );
+    //qDebug("AddresseeView::setAddressee has to be verified.");
+  }
+  KABC::Address::List addresses = mAddressee.addresses();
+  KABC::Address::List::ConstIterator addrIt;
+  for ( addrIt = addresses.begin(); addrIt != addresses.end(); ++addrIt ) {
+      if ( true /*(*addrIt).label().isEmpty()*/ ) {
+      QString formattedAddress = (*addrIt).formattedAddress().stripWhiteSpace();
+//US      formattedAddress = formattedAddress.replace( '\n', "<br>" );
+      //qDebug("adresss %s ",formattedAddress.latin1() );
+       formattedAddress = formattedAddress.replace( QRegExp("\n"), "<br>" );
+       //qDebug("AddresseeView::setAddressee has to be verified.");
+      dynamicPart += QString(
+        "<tr><td align=\"right\"><b>%1</b></td>"
+        "<td align=\"left\">%2</td></tr>" )
+        .arg( KABC::Address::typeLabel( (*addrIt).type() ) )
+        .arg( formattedAddress );
+    } else {
+      dynamicPart += QString(
+        "<tr><td align=\"right\"><b>%1</b></td>"
+        "<td align=\"left\">%2</td></tr>" )
+        .arg( KABC::Address::typeLabel( (*addrIt).type() ) )
+//US        .arg( (*addrIt).label().replace( '\n', "<br>" ) );
+          .arg( (*addrIt).label() /*replace( QRegExp("\n"), "<br>" )*/ );
+    }
+  }
+  QString notes;
+  if ( !mAddressee.note().isEmpty() ) {
+    notes = QString(
+      "<tr>"
+      "<td align=\"right\" valign=\"top\"><b>%1</b></td>"  // note label
+      "<td align=\"left\">%2</td>"  // note
+      "</tr>" ).arg( i18n( "Notes" ) )
+//US      .arg( mAddressee.note().replace( '\n', "<br>" ) );
+      .arg( mAddressee.note().replace( QRegExp("\n"), "<br>" ) );
+    //qDebug("AddresseeView::setAddressee has to be verified.");
+  }
+  QString aRole = "";
+  QString aOrga = "";
+  if ( true /*!mAddressee.role().isEmpty()*/ ) {
+      aRole = "<tr>"
+          "<td align=\"left\">" + mAddressee.role() + "</td>"
+          "</tr>";
+  }
+  if ( true /*!mAddressee.organization().isEmpty()*/ ) {
+      aOrga = "<tr>"
+          "<td align=\"left\">" + mAddressee.organization() + "</td>" ;
+          "</tr>";
+  }
+  mText = "";
+  QString picString = "";
+  KABC::Picture picture = mAddressee.photo();
+  bool picAvailintern = false;
+  bool picAvailUrl = false;
+  if (! picture.undefined() ) {
+      picAvailintern = (picture.isIntern() && !picture.data().isNull());
+      picAvailUrl = !picture.isIntern() &&  QFile::exists(picture.url() );
+  }
+  if ( picAvailUrl || picAvailintern || QApplication::desktop()->width() > 320 ) {
+      if (  picAvailintern ) {
+          QMimeSourceFactory::defaultFactory()->setImage( "myimage", picture.data() );
+      } else {
+          if ( picAvailUrl ) {
+              QMimeSourceFactory::defaultFactory()->setPixmap( "myimage", QPixmap( picture.url() ));
+          } else {
+          QMimeSourceFactory::defaultFactory()->setPixmap( "myimage", KGlobal::iconLoader()->loadIcon( "package_toys", KIcon::Desktop, 128 ) );
+          }
+      }
+      picString =  "<img src=\"myimage\" width=\"50\" height=\"70\">";
+    mText = QString::fromLatin1(
+  "<html>"
+  "<body text=\"%1\" bgcolor=\"%2\">" // text and background color
+  "<table>"
+  "<tr>"
+  "<td rowspan=\"3\" align=\"right\" valign=\"top\">"
+  "%3"
+  "</td>"
+  "<td align=\"left\"><font size=\"+2\"><b>%4</b></font></td>"  // name
+  "</tr>"
+  "%5"  // role
+  "%6"  // organization
+  "<td colspan=\"2\">&nbsp;</td>"
+  "%7"  // dynamic part
+  "%8"  // notes
+  "</table>"
+  "</body>"
+  "</html>")
+//US
+  .arg( /*KGlobalSettings::textColor().name()*/ "black" )
+//US
+  .arg( /*KGlobalSettings::baseColor().name()*/ "white" )
+  .arg( picString )
+  .arg( name )
+  .arg( aRole )
+  .arg( aOrga )
+  .arg( dynamicPart )
+  .arg( notes );
+  } else { // no picture!
+mText = "<table width=\"100%\">\n";
+    //mText += "<tr bgcolor=\"#3679AD\"><td><h2>";
+#ifdef DESKTOP_VERSION
+    mText += "<tr bgcolor=\"#5699CD\"><td align=\"left\"><h1>";
+#else
+    mText += "<tr bgcolor=\"#5699CD\"><td align=\"left\"><h2>";
+#endif
+#ifdef DESKTOP_VERSION
+    mText += "<font color=\"#FFFFFF\"> <em>" +  name+"</em></font></h1>";
+#else
+    mText += "<font color=\"#FFFFFF\"> <em>" +  name +"</em></font></h2>";
+#endif
+    mText += "</td></tr>\n<tr  bgcolor=\"#EAF8FA\"><td>";
+    mText += "<table><td colspan=\"2\">&nbsp;</td>";
+    /*
+      mText += QString("<tr><td align=\"right\"><b2>%1</b2></td>"
+        "<td align=\"left\"><b>%2</b></td></tr>" )
+          .arg( i18n(" ") )
+        .arg( name );
+    */
+      if ( ! mAddressee.role().isEmpty() )
+      mText += QString("<tr><td align=\"right\"><b>%1</b></td>"
+        "<td align=\"left\">%2</td></tr>" )
+          .arg( i18n(" ") )
+        .arg( mAddressee.role());
+      if ( ! mAddressee.organization().isEmpty() )
+      mText += QString("<tr><td align=\"right\"><b>%1</b></td>"
+        "<td align=\"left\">%2</td></tr>" )
+          .arg( i18n(" ") )
+        .arg( mAddressee.organization());
+      mText += dynamicPart;
+      mText += notes;
+      mText += "</table>";
+ }
+  // at last display it...
+  setText( mText );
+}
+KABC::Addressee AddresseeView::addressee() const
+{
+  return mAddressee;
+}
+void AddresseeView::addTag(const QString & tag,const QString & text)
+{
+    if ( text.isEmpty() )
+        return;
+    int number=text.contains("\n");
+    QString str = "<" + tag + ">";
+    QString tmpText=text;
+    QString tmpStr=str;
+    if(number !=-1)
+        {
+            if (number > 0) {
+                int pos=0;
+                QString tmp;
+                for(int i=0;i<=number;i++) {
+                    pos=tmpText.find("\n");
+                    tmp=tmpText.left(pos);
+                    tmpText=tmpText.right(tmpText.length()-pos-1);
+                    tmpStr+=tmp+"<br>";
+                }
+            }
+            else tmpStr += tmpText;
+            tmpStr+="</" + tag + ">";
+            mText.append(tmpStr);
+        }
+    else
+        {
+            str += text + "</" + tag + ">";
+            mText.append(str);
+        }
+}
diff --git a/kabc/addresseeview.h b/kabc/addresseeview.h
new file mode 100644
index 0000000..1865fc4
--- a/dev/null
+++ b/kabc/addresseeview.h
@@ -0,0 +1,60 @@
+/*
+    This file is part of libkdepim.
+    Copyright (c) 2003 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.
+*/
+#ifndef KPIM_ADDRESSEEVIEW_H
+#define KPIM_ADDRESSEEVIEW_H
+#include <kabc/addressee.h>
+//US #include <ktextbrowser.h>
+#include <qtextbrowser.h>
+namespace KPIM {
+//US class AddresseeView : public KTextBrowser
+class AddresseeView : public QTextBrowser
+{
+  public:
+    AddresseeView( QWidget *parent = 0, const char *name = 0 );
+    /**
+      Sets the addressee object. The addressee is displayed immediately.
+      @param addr The addressee object.
+     */
+    void setAddressee( const KABC::Addressee& addr );
+    void setSource(const QString& n);
+    /**
+      Returns the current addressee object.
+     */
+    KABC::Addressee addressee() const;
+  private:
+    KABC::Addressee mAddressee;
+    QString mText;
+    void addTag(const QString & tag,const QString & text);
+    class AddresseeViewPrivate;
+    AddresseeViewPrivate *d;
+};
+}
+#endif
diff --git a/kabc/kabc.pro b/kabc/kabc.pro
index 417f5b0..d690acc 100644
--- a/kabc/kabc.pro
+++ b/kabc/kabc.pro
@@ -1,218 +1,220 @@
        TEMPLATE= lib
 CONFIG += qt warn_on 
 #release debug
 DESTDIR=../bin
 TARGET = microkabc
 include( ../variables.pri )
 INCLUDEPATH += . ./vcard/include ./vcard/include/generated ../microkde ../microkde/kdecore ../microkde/kio/kfile ../microkde/kio/kio ../libkdepim ../qtcompat ../microkde/kdeui ..
 #LIBS += -lmicrokde -lldap
 LIBS += -L$(QPEDIR)/lib
 DEFINES += KAB_EMBEDDED  DESKTOP_VERSION
 unix : {
 OBJECTS_DIR = obj/unix
 MOC_DIR = moc/unix
 }
 win32: {
 DEFINES += _WIN32_
 OBJECTS_DIR = obj/win
 MOC_DIR = moc/win
 }
 INTERFACES = \
 HEADERS = \
 resource.h \
 stdaddressbook.h \
 agent.h \
 geo.h \
 key.h \
 field.h \
 plugin.h \
 address.h \
 addresseelist.h \
+ addresseeview.h \
 formatfactory.h \
 formatplugin.h \
 phonenumber.h \
 distributionlist.h \
 distributionlistdialog.h \
 distributionlisteditor.h \
 vcardformatplugin.h \
 formats/vcardformatplugin2.h \
 picture.h \
 secrecy.h \
 sound.h \
 addressbook.h \
 syncprefwidget.h \
 timezone.h \
 tmpaddressbook.h \
 addressee.h \
 addresseedialog.h \
 vcardconverter.h \
 vcard21parser.h \
 vcardformatimpl.h \
 plugins/file/resourcefile.h \
 plugins/file/resourcefileconfig.h \
 plugins/dir/resourcedir.h \
 plugins/dir/resourcedirconfig.h \
 vcardparser/vcardline.h \
 vcardparser/vcard.h \
 vcardparser/vcardtool.h \
 vcardparser/vcardparser.h \
 vcard/include/VCardAdrParam.h \
 vcard/include/VCardAdrValue.h \
 vcard/include/VCardAgentParam.h \
 vcard/include/VCardContentLine.h \
 vcard/include/VCardDateParam.h \
 vcard/include/VCardDateValue.h \
 vcard/include/VCardEmailParam.h \
 vcard/include/VCardGeoValue.h \
 vcard/include/VCardGroup.h \
 vcard/include/VCardImageParam.h \
 vcard/include/VCardImageValue.h \
 vcard/include/VCardLangValue.h \
 vcard/include/VCardNValue.h \
 vcard/include/VCardParam.h \
 vcard/include/VCardPhoneNumberValue.h \
 vcard/include/VCardSourceParam.h \
 vcard/include/VCardTelParam.h \
 vcard/include/VCardTextParam.h \
 vcard/include/VCardTextValue.h \
 vcard/include/VCardTextBinParam.h \
 vcard/include/VCardURIValue.h \
 vcard/include/VCardVCard.h \
 vcard/include/VCardEntity.h \
 vcard/include/VCardValue.h \
 vcard/include/VCardSoundValue.h \
 vcard/include/VCardAgentValue.h \
 vcard/include/VCardTelValue.h \
 vcard/include/VCardTextBinValue.h \
 vcard/include/VCardOrgValue.h \
 vcard/include/VCardUTCValue.h \
 vcard/include/VCardClassValue.h \
 vcard/include/VCardFloatValue.h \
 vcard/include/VCardTextListValue.h \
 vcard/include/generated/AdrParam-generated.h \
 vcard/include/generated/AdrValue-generated.h \
 vcard/include/generated/AgentParam-generated.h \
 vcard/include/generated/ContentLine-generated.h \
 vcard/include/generated/DateParam-generated.h \
 vcard/include/generated/DateValue-generated.h \
 vcard/include/generated/EmailParam-generated.h \
 vcard/include/generated/GeoValue-generated.h \
 vcard/include/generated/Group-generated.h \
 vcard/include/generated/ImageParam-generated.h \
 vcard/include/generated/ImageValue-generated.h \
 vcard/include/generated/LangValue-generated.h \
 vcard/include/generated/NValue-generated.h \
 vcard/include/generated/Param-generated.h \
 vcard/include/generated/PhoneNumberValue-generated.h \
 vcard/include/generated/SourceParam-generated.h \
 vcard/include/generated/TelParam-generated.h \
 vcard/include/generated/TextParam-generated.h \
 vcard/include/generated/TextNSParam-generated.h \
 vcard/include/generated/TextValue-generated.h \
 vcard/include/generated/TextBinParam-generated.h \
 vcard/include/generated/URIValue-generated.h \
 vcard/include/generated/VCard-generated.h \
 vcard/include/generated/VCardEntity-generated.h \
 vcard/include/generated/Value-generated.h \
 vcard/include/generated/SoundValue-generated.h \
 vcard/include/generated/AgentValue-generated.h \
 vcard/include/generated/TelValue-generated.h \
 vcard/include/generated/TextBinValue-generated.h \
 vcard/include/generated/OrgValue-generated.h \
 vcard/include/generated/UTCValue-generated.h \
 vcard/include/generated/ClassValue-generated.h \
 vcard/include/generated/FloatValue-generated.h \
 vcard/include/generated/TextListValue-generated.h
 
 # plugins/ldap/resourceldap.h \
 # plugins/ldap/resourceldapconfig.h \
 #formats/binary/binaryformat.h \
 
 #vcard/include/VCardTextNSParam.h \
 
 SOURCES = \
 distributionlist.cpp \
 distributionlistdialog.cpp \
 distributionlisteditor.cpp \
 vcardformatplugin.cpp \
 formats/vcardformatplugin2.cpp \
 formatfactory.cpp \
 resource.cpp \
 stdaddressbook.cpp \
 plugin.cpp \
 agent.cpp \
 geo.cpp \
 key.cpp \
 field.cpp \
+ addresseeview.cpp \
 address.cpp \
 phonenumber.cpp \
 picture.cpp \
 secrecy.cpp \
 sound.cpp \
 addressbook.cpp \
 syncprefwidget.cpp \
 timezone.cpp \
 tmpaddressbook.cpp \
 addressee.cpp \
 addresseelist.cpp \
 addresseedialog.cpp \
 vcardconverter.cpp \
 vcard21parser.cpp \
 vcardformatimpl.cpp \
 plugins/file/resourcefile.cpp \
 plugins/file/resourcefileconfig.cpp \
 plugins/dir/resourcedir.cpp \
 plugins/dir/resourcedirconfig.cpp \
 vcardparser/vcardline.cpp \
 vcardparser/vcard.cpp \
 vcardparser/vcardtool.cpp \
 vcardparser/vcardparser.cpp \
 vcard/AdrParam.cpp \
 vcard/AdrValue.cpp \
 vcard/AgentParam.cpp \
 vcard/ContentLine.cpp \
 vcard/DateParam.cpp \
 vcard/DateValue.cpp \
 vcard/EmailParam.cpp \
 vcard/Entity.cpp \
 vcard/Enum.cpp \
 vcard/GeoValue.cpp \
 vcard/ImageParam.cpp \
 vcard/ImageValue.cpp \
 vcard/LangValue.cpp \
 vcard/NValue.cpp \
 vcard/Param.cpp \
 vcard/PhoneNumberValue.cpp \
 vcard/RToken.cpp \
 vcard/SourceParam.cpp \
 vcard/TelParam.cpp \
 vcard/TextParam.cpp \
 vcard/TextValue.cpp \
 vcard/TextBinParam.cpp \
 vcard/URIValue.cpp \
 vcard/VCardv.cpp \
 vcard/VCardEntity.cpp \
 vcard/Value.cpp \
 vcard/SoundValue.cpp \
 vcard/AgentValue.cpp \
 vcard/TelValue.cpp \
 vcard/TextBinValue.cpp \
 vcard/OrgValue.cpp \
 vcard/UTCValue.cpp \
 vcard/ClassValue.cpp \
 vcard/FloatValue.cpp \
 vcard/TextListValue.cpp
 # plugins/ldap/resourceldap.cpp \
 # plugins/ldap/resourceldapconfig.cpp \
 #formats/binary/binaryformat.cpp \
diff --git a/kabc/kabcE.pro b/kabc/kabcE.pro
index dfdbcff..b360e8c 100644
--- a/kabc/kabcE.pro
+++ b/kabc/kabcE.pro
@@ -1,193 +1,195 @@
        TEMPLATE= lib
 CONFIG += qt warn_on 
 TARGET = microkabc
 INCLUDEPATH += . $(KDEPIMDIR) vcard/include vcard/include/generated $(KDEPIMDIR)/microkde $(KDEPIMDIR)/microkde/kdecore $(KDEPIMDIR)/microkde/kdeui $(KDEPIMDIR)/microkde/kio/kfile $(KDEPIMDIR)/microkde/kio/kio $(KDEPIMDIR)/libkdepim $(KDEPIMDIR)/qtcompat $(QPEDIR)/include
 OBJECTS_DIR = obj/$(PLATFORM)
 MOC_DIR = moc/$(PLATFORM)
 DESTDIR = $(QPEDIR)/lib
 LIBS += -lmicrokde 
 LIBS += -lmicrokdepim 
 #LIBS += -lldap
 LIBS += -L$(QPEDIR)/lib
 DEFINES += KAB_EMBEDDED
 INTERFACES = \
 HEADERS = \
 address.h \
 addressbook.h \
 addressee.h \
 addresseedialog.h \
 addresseelist.h \
+ addresseeview.h \
 agent.h \
 distributionlist.h \
 distributionlistdialog.h \
 distributionlisteditor.h \
 field.h \
 formatfactory.h \
 formatplugin.h \
 geo.h \
 key.h \
 phonenumber.h \
 picture.h \
 plugin.h \
 resource.h \
 secrecy.h \
 sound.h \
 stdaddressbook.h \
 syncprefwidget.h \
 timezone.h \
 tmpaddressbook.h \
 vcardconverter.h \
 vcard21parser.h \
 vcardformatimpl.h \
 vcardformatplugin.h \
 vcardparser/vcardline.h \
 vcardparser/vcard.h \
 vcardparser/vcardtool.h \
 vcardparser/vcardparser.h \
 vcard/include/VCardAdrParam.h \
 vcard/include/VCardAdrValue.h \
 vcard/include/VCardAgentParam.h \
 vcard/include/VCardContentLine.h \
 vcard/include/VCardDateParam.h \
 vcard/include/VCardDateValue.h \
 vcard/include/VCardEmailParam.h \
 vcard/include/VCardGeoValue.h \
 vcard/include/VCardGroup.h \
 vcard/include/VCardImageParam.h \
 vcard/include/VCardImageValue.h \
 vcard/include/VCardLangValue.h \
 vcard/include/VCardNValue.h \
 vcard/include/VCardParam.h \
 vcard/include/VCardPhoneNumberValue.h \
 vcard/include/VCardSourceParam.h \
 vcard/include/VCardTelParam.h \
 vcard/include/VCardTextParam.h \
 vcard/include/VCardTextNSParam.h \
 vcard/include/VCardTextValue.h \
 vcard/include/VCardTextBinParam.h \
 vcard/include/VCardURIValue.h \
 vcard/include/VCardVCard.h \
 vcard/include/VCardEntity.h \
 vcard/include/VCardValue.h \
 vcard/include/VCardSoundValue.h \
 vcard/include/VCardAgentValue.h \
 vcard/include/VCardTelValue.h \
 vcard/include/VCardTextBinValue.h \
 vcard/include/VCardOrgValue.h \
 vcard/include/VCardUTCValue.h \
 vcard/include/VCardClassValue.h \
 vcard/include/VCardFloatValue.h \
 vcard/include/VCardTextListValue.h \
 vcard/include/generated/AdrParam-generated.h \
 vcard/include/generated/AdrValue-generated.h \
 vcard/include/generated/AgentParam-generated.h \
 vcard/include/generated/ContentLine-generated.h \
 vcard/include/generated/DateParam-generated.h \
 vcard/include/generated/DateValue-generated.h \
 vcard/include/generated/EmailParam-generated.h \
 vcard/include/generated/GeoValue-generated.h \
 vcard/include/generated/Group-generated.h \
 vcard/include/generated/ImageParam-generated.h \
 vcard/include/generated/ImageValue-generated.h \
 vcard/include/generated/LangValue-generated.h \
 vcard/include/generated/NValue-generated.h \
 vcard/include/generated/Param-generated.h \
 vcard/include/generated/PhoneNumberValue-generated.h \
 vcard/include/generated/SourceParam-generated.h \
 vcard/include/generated/TelParam-generated.h \
 vcard/include/generated/TextParam-generated.h \
 vcard/include/generated/TextNSParam-generated.h \
 vcard/include/generated/TextValue-generated.h \
 vcard/include/generated/TextBinParam-generated.h \
 vcard/include/generated/URIValue-generated.h \
 vcard/include/generated/VCard-generated.h \
 vcard/include/generated/VCardEntity-generated.h \
 vcard/include/generated/Value-generated.h \
 vcard/include/generated/SoundValue-generated.h \
 vcard/include/generated/AgentValue-generated.h \
 vcard/include/generated/TelValue-generated.h \
 vcard/include/generated/TextBinValue-generated.h \
 vcard/include/generated/OrgValue-generated.h \
 vcard/include/generated/UTCValue-generated.h \
 vcard/include/generated/ClassValue-generated.h \
 vcard/include/generated/FloatValue-generated.h \
 vcard/include/generated/TextListValue-generated.h
 
 
 
 SOURCES = \
 address.cpp \
 addressbook.cpp \
 addressee.cpp \
 addresseedialog.cpp \
 addresseelist.cpp \
+ addresseeview.cpp \
 agent.cpp \
 distributionlist.cpp \
 distributionlistdialog.cpp \
 distributionlisteditor.cpp \
 field.cpp \
 formatfactory.cpp \
 geo.cpp \
 key.cpp \
 phonenumber.cpp \
 picture.cpp \
 plugin.cpp \
 resource.cpp \
 secrecy.cpp \
 sound.cpp \
 stdaddressbook.cpp \
 syncprefwidget.cpp \
 timezone.cpp \
 tmpaddressbook.cpp \
 vcardconverter.cpp \
 vcard21parser.cpp \
 vcardformatimpl.cpp \
 vcardformatplugin.cpp \
 vcardparser/vcardline.cpp \
 vcardparser/vcard.cpp \
 vcardparser/vcardtool.cpp \
 vcardparser/vcardparser.cpp \
 vcard/AdrParam.cpp \
 vcard/AdrValue.cpp \
 vcard/AgentParam.cpp \
 vcard/ContentLine.cpp \
 vcard/DateParam.cpp \
 vcard/DateValue.cpp \
 vcard/EmailParam.cpp \
 vcard/Entity.cpp \
 vcard/Enum.cpp \
 vcard/GeoValue.cpp \
 vcard/ImageParam.cpp \
 vcard/ImageValue.cpp \
 vcard/LangValue.cpp \
 vcard/NValue.cpp \
 vcard/Param.cpp \
 vcard/PhoneNumberValue.cpp \
 vcard/RToken.cpp \
 vcard/SourceParam.cpp \
 vcard/TelParam.cpp \
 vcard/TextParam.cpp \
 vcard/TextValue.cpp \
 vcard/TextBinParam.cpp \
 vcard/URIValue.cpp \
 vcard/VCardv.cpp \
 vcard/VCardEntity.cpp \
 vcard/Value.cpp \
 vcard/SoundValue.cpp \
 vcard/AgentValue.cpp \
 vcard/TelValue.cpp \
 vcard/TextBinValue.cpp \
 vcard/OrgValue.cpp \
 vcard/UTCValue.cpp \
 vcard/ClassValue.cpp \
 vcard/FloatValue.cpp \
 vcard/TextListValue.cpp
 # plugins/ldap/resourceldap.cpp \
 # plugins/ldap/resourceldapconfig.cpp \
diff --git a/kaddressbook/details/look_html.cpp b/kaddressbook/details/look_html.cpp
index 2a70273..63364a7 100644
--- a/kaddressbook/details/look_html.cpp
+++ b/kaddressbook/details/look_html.cpp
@@ -1,45 +1,45 @@
 /*
    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 <libkdepim/addresseeview.h>
+#include <addresseeview.h>
 #include "look_html.h"
 #include <qscrollview.h> 
 KABHtmlView::KABHtmlView( QWidget *parent, const char *name )
  : KABBasicLook( parent, name )
 {
    mView = new KPIM::AddresseeView( this ); 
 }
 KABHtmlView::~KABHtmlView()
 {
 }
 void KABHtmlView::setAddressee( const KABC::Addressee &addr )
 {
  mView->setAddressee( addr );
 }
 #ifndef KAB_EMBEDDED
 #include "look_html.moc"
 #endif //KAB_EMBEDDED
diff --git a/kaddressbook/kabcore.cpp b/kaddressbook/kabcore.cpp
index f21507a..32dd43a 100644
--- a/kaddressbook/kabcore.cpp
+++ b/kaddressbook/kabcore.cpp
@@ -1,2091 +1,2091 @@
 /*
    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>
 #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"
 //US
-#include <libkdepim/addresseeview.h>
+#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"
 #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&)),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 ( !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 );
 }
 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 );
  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( "&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 );
  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
 }
 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" );
 }
 #ifndef KAB_EMBEDDED
 #include "kabcore.moc"
 #endif //KAB_EMBEDDED
diff --git a/kaddressbook/kaddressbookE.pro b/kaddressbook/kaddressbookE.pro
index 1c9eeef..c027895 100644
--- a/kaddressbook/kaddressbookE.pro
+++ b/kaddressbook/kaddressbookE.pro
@@ -1,159 +1,161 @@
        TEMPLATE= app
        CONFIG  += qt warn_on 
        TARGET  = kapi
 OBJECTS_DIR = obj/$(PLATFORM)
 MOC_DIR = moc/$(PLATFORM)
 DESTDIR=$(QPEDIR)/bin
 INCLUDEPATH += . ./details ./features ./xxport ../libkdepim ../microkde ../microkde/kdecore ../microkde/kutils ../microkde/kio/kfile ../microkde/kio/kio ../microkde/kdeui ../microkde/kresources ../kabc ../qtcompat ../ interfaces $(QPEDIR)/include
 DEFINES += KAB_EMBEDDED KAB_NOSPLITTER
 #DEFINES += KORG_NODND KORG_NOPLUGINS KORG_NOKABC KORG_NOARCHIVE KORG_NOMAIL
 #DEFINES += KORG_NOPRINTER  KORG_NODCOP KORG_NOKALARMD KORG_NORESOURCEVIEW KORG_NOSPLITTER
 #DEFINES += KORG_NOLVALTERNATION
-LIBS += -lmicrokdepim
+#LIBS += -lmicrokdepim
-LIBS += -lmicrokcal
+#LIBS += -lmicrokcal
 LIBS += -lmicrokde
 LIBS += -lmicroqtcompat
 LIBS += -lmicrokabc
 LIBS += -lqpe
 LIBS += -ljpeg
 LIBS += $(QTOPIALIB)
 LIBS += -L$(QPEDIR)/lib
 LIBS += -Wl,-export-dynamic
+LIBS += $(GCC3EXTRALIB1)
+LIBS += $(GCC3EXTRALIB2)
 INTERFACES = \
 # filteredit_base.ui \
 # kofilterview_base.ui \
 HEADERS = \
 features/mergewidget.h \
 features/distributionlistwidget.h \
 kcmconfigs/addresseewidget.h \
 kcmconfigs/extensionconfigdialog.h \
 kcmconfigs/kcmkabconfig.h \
 kcmconfigs/kabconfigwidget.h \
 addresseeeditordialog.h \
 addresseeeditorwidget.h \
 addresseditwidget.h \
 addresseeconfig.h \
 addresseeutil.h \
 emaileditwidget.h \
 filtereditdialog.h \
 kaddressbookmain.h \
 kabprefs.h \
 kabcore.h \
 viewmanager.h \
 extensionmanager.h \
 extensionwidget.h \
 kaddressbookview.h \
 geowidget.h \
 imagewidget.h \
 incsearchwidget.h \
 jumpbuttonbar.h \
 phoneeditwidget.h \
 secrecywidget.h \
 keywidget.h \
 nameeditdialog.h \
 filter.h \
 addviewdialog.h \
 configurewidget.h \
 viewconfigurewidget.h \
 viewconfigurefieldspage.h \
 viewconfigurefilterpage.h \
 typecombo.h \
 undo.h \
 undocmds.h \
 xxportmanager.h \
 xxportobject.h \
 xxportselectdialog.h \
 details/detailsviewcontainer.h \
 details/look_basic.h \
 details/look_html.h \
 views/kaddressbookiconview.h \
 views/kaddressbooktableview.h \
 views/kaddressbookcardview.h \
 views/configuretableviewdialog.h \
 views/configurecardviewdialog.h \
 views/cardview.h \
 views/colorlistbox.h \
 views/contactlistview.h \
 xxport/vcard_xxport.h \
 xxport/kde2_xxport.h \
 xxport/csv_xxport.h \
 xxport/csvimportdialog.h \
 xxport/opie_xxport.h \
 xxport/qtopia_xxport.h \
 xxport/sharpdtm_xxport.h \
 #details/look_details.h \
 #mainwindoiw.h \
 # alarmclient.h \
 # calendarview.h \
 # customlistviewitem.h \
 # datenavigator.h
 SOURCES = \
 addresseeeditordialog.cpp \
 addresseeeditorwidget.cpp \
 addresseditwidget.cpp \
 addresseeconfig.cpp \
 addresseeutil.cpp \
 extensionmanager.cpp \
 features/mergewidget.cpp \
 features/distributionlistwidget.cpp \
 kcmconfigs/addresseewidget.cpp \
 kcmconfigs/extensionconfigdialog.cpp \
 kcmconfigs/kcmkabconfig.cpp \
 kcmconfigs/kabconfigwidget.cpp \
 emaileditwidget.cpp \
 filtereditdialog.cpp \
 mainembedded.cpp \
 kaddressbookmain.cpp \
 kabcore.cpp \
 kabprefs.cpp \
 viewmanager.cpp \
 kaddressbookview.cpp \
 extensionwidget.cpp \
 geowidget.cpp \
 imagewidget.cpp \
 incsearchwidget.cpp \
 jumpbuttonbar.cpp \
 phoneeditwidget.cpp \
 secrecywidget.cpp \
 keywidget.cpp \
 nameeditdialog.cpp \
 filter.cpp \
 addviewdialog.cpp \
 configurewidget.cpp \
 viewconfigurewidget.cpp \
 viewconfigurefieldspage.cpp \
 viewconfigurefilterpage.cpp \
 undo.cpp \
 undocmds.cpp \
 xxportmanager.cpp \
 xxportobject.cpp \
 xxportselectdialog.cpp \
 details/detailsviewcontainer.cpp \
 details/look_basic.cpp \
 details/look_html.cpp \
 views/kaddressbookiconview.cpp \
 views/kaddressbooktableview.cpp \
 views/kaddressbookcardview.cpp \
 views/configuretableviewdialog.cpp \
 views/configurecardviewdialog.cpp \
 views/cardview.cpp \
 views/contactlistview.cpp \
 views/colorlistbox.cpp \
 xxport/vcard_xxport.cpp \
 xxport/kde2_xxport.cpp \
 xxport/csv_xxport.cpp \
 xxport/csvimportdialog.cpp \
 xxport/opie_xxport.cpp \
 xxport/qtopia_xxport.cpp \
 xxport/sharpdtm_xxport.cpp \
 #details/look_details.cpp \
 #mainwindow.cpp \
 # calendarview.cpp \
 # timespanview.cpp
diff --git a/kaddressbook/xxportmanager.cpp b/kaddressbook/xxportmanager.cpp
index 713b0fc..810c3e2 100644
--- a/kaddressbook/xxportmanager.cpp
+++ b/kaddressbook/xxportmanager.cpp
@@ -1,243 +1,243 @@
 /*
    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 <qlayout.h>
 #include <qlist.h>
 #include <kabc/addressbook.h>
 #include <kabc/resource.h>
 #include <kdebug.h>
 #include <kdialogbase.h>
 #include <klocale.h>
 #include <kmessagebox.h>
 #ifndef KAB_EMBEDDED
 #include <ktrader.h>
 #else //KAB_EMBEDDED
 extern "C"
 {
  void* init_microkaddrbk_csv_xxport();
  void* init_microkaddrbk_kde2_xxport();
  void* init_microkaddrbk_vcard_xxport();
  void* init_microkaddrbk_opie_xxport();
  void* init_microkaddrbk_qtopia_xxport();
  void* init_microkaddrbk_sharpdtm_xxport();
 }
 #endif //KAB_EMBEDDED
-#include <libkdepim/addresseeview.h>
+#include <addresseeview.h>
 #include "kabcore.h"
 #include "undocmds.h"
 #include "xxportselectdialog.h"
 #include "xxportmanager.h"
 KURL XXPortManager::importURL = KURL();
 QString XXPortManager::importData = QString::null;
 class PreviewDialog : public KDialogBase
 {
  public:
    PreviewDialog( const KABC::Addressee &addr,
                   QWidget *parent, const char *name = 0 );
 };
 XXPortManager::XXPortManager( KABCore *core, QObject *parent, const char *name )
  : QObject( parent, name ), mCore( core ), mShowPreview( false )
 {
  loadPlugins();
 }
 XXPortManager::~XXPortManager()
 {
 }
 void XXPortManager::restoreSettings()
 {
 }
 void XXPortManager::saveSettings()
 {
 }
 void XXPortManager::importVCard( const KURL &url )
 {
  importVCard( url, false );
 }
 void XXPortManager::importVCard( const KURL &url, bool showPreview )
 {
  importURL = url;
  mShowPreview = showPreview;
  slotImport( "vcard", "<empty>" );
  mShowPreview = false;
  importURL = KURL();
 }
 void XXPortManager::importVCard( const QString &vCard, bool showPreview )
 {
  importData = vCard;
  mShowPreview = showPreview;
  slotImport( "vcard", "<empty>" );
  mShowPreview = false;
  importData = "";
 }
 void XXPortManager::slotImport( const QString &identifier, const QString &data )
 {
  XXPortObject *obj = mXXPortObjects[ identifier ];
  if ( !obj ) {
    KMessageBox::error( mCore, i18n( "<qt>No import plugin available for <b>%1</b>.</qt>" ).arg( identifier ) );
    return;
  }
  KABC::Resource *resource = mCore->requestResource( mCore );
  if ( !resource )
    return;
  KABC::AddresseeList list = obj->importContacts( data );
  KABC::AddresseeList::Iterator it;
  bool imported = false;
  for ( it = list.begin(); it != list.end(); ++it ) {
    if ( mShowPreview ) {
      PreviewDialog dlg( *it, mCore );
      if ( !dlg.exec() )
        continue;
    }
    (*it).setResource( resource );
    // We use a PwNewCommand so the user can undo it.
    PwNewCommand *command = new PwNewCommand( mCore->addressBook(), *it );
    UndoStack::instance()->push( command );
    RedoStack::instance()->clear();
    imported = true;
  }
  if ( imported ) {
    KMessageBox::information( mCore, i18n( "contacts successfully imported." ) );
    emit modified();
  }
 }
 void XXPortManager::slotExport( const QString &identifier, const QString &data )
 {
  XXPortObject *obj = mXXPortObjects[ identifier ];
  if ( !obj ) {
    KMessageBox::error( mCore, i18n( "<qt>No export plugin available for <b>%1</b>.</qt>" ).arg( identifier ) );
    return;
  }
  KABC::AddresseeList addrList;
  XXPortSelectDialog dlg( mCore, obj->requiresSorting(), mCore );
  if ( dlg.exec() )
    addrList = dlg.contacts();
  else
    return;
  if ( !obj->exportContacts( addrList, data ) )
    KMessageBox::error( mCore, i18n( "Unable to export contacts." ) );
  else
    KMessageBox::information( mCore, i18n( "contacts successfully exported." ) );
 }
 void XXPortManager::loadPlugins()
 {
  mXXPortObjects.clear();
 #ifndef KAB_EMBEDDED
  KTrader::OfferList plugins = KTrader::self()->query( "KAddressBook/XXPort" );
  KTrader::OfferList::ConstIterator it;
  for ( it = plugins.begin(); it != plugins.end(); ++it ) {
    if ( !(*it)->hasServiceType( "KAddressBook/XXPort" ) )
      continue;
    KLibFactory *factory = KLibLoader::self()->factory( (*it)->library().latin1() );
    if ( !factory ) {
      kdDebug(5720) << "XXPortManager::loadExtensions(): Factory creation failed" << endl;
      continue;
    }
    XXPortFactory *xxportFactory = static_cast<XXPortFactory*>( factory );
    if ( !xxportFactory ) {
      kdDebug(5720) << "XXPortManager::loadExtensions(): Cast failed" << endl;
      continue;
    }
 #else //KAB_EMBEDDED
  QList<XXPortFactory> factorylist;
  factorylist.append(static_cast<XXPortFactory*>(init_microkaddrbk_csv_xxport()));
  factorylist.append(static_cast<XXPortFactory*>(init_microkaddrbk_kde2_xxport()));
  factorylist.append(static_cast<XXPortFactory*>(init_microkaddrbk_vcard_xxport()));
  factorylist.append(static_cast<XXPortFactory*>(init_microkaddrbk_opie_xxport()));
  factorylist.append(static_cast<XXPortFactory*>(init_microkaddrbk_qtopia_xxport()));
  factorylist.append(static_cast<XXPortFactory*>(init_microkaddrbk_sharpdtm_xxport()));
  QListIterator<XXPortFactory> it(factorylist);
  for ( ; it.current(); ++it )
  {
    XXPortFactory *xxportFactory = it.current();
 #endif //KAB_EMBEDDED
    XXPortObject *obj = xxportFactory->xxportObject( mCore->addressBook(), mCore );
    if ( obj ) {
      mCore->addGUIClient( obj );
      mXXPortObjects.insert( obj->identifier(), obj );
      connect( obj, SIGNAL( exportActivated( const QString&, const QString& ) ),
               this, SLOT( slotExport( const QString&, const QString& ) ) );
      connect( obj, SIGNAL( importActivated( const QString&, const QString& ) ),
               this, SLOT( slotImport( const QString&, const QString& ) ) );
    }
  }
 }
 PreviewDialog::PreviewDialog( const KABC::Addressee &addr, QWidget *parent,
                              const char *name )
  : KDialogBase( Plain, i18n( "Contact Preview" ), Ok | Cancel, Ok, parent,
                 name, true, true )
 {
  QWidget *page = plainPage();
  QVBoxLayout *layout = new QVBoxLayout( page, marginHint(), spacingHint() );
  KPIM::AddresseeView *view = new KPIM::AddresseeView( page );
  view->setAddressee( addr );
  layout->addWidget( view );
  resize( 400, 300 );
 }
 #ifndef KAB_EMBEDDED
 #include "xxportmanager.moc"
 #endif //KAB_EMBEDDED
diff --git a/korganizer/calendarview.cpp b/korganizer/calendarview.cpp
index 369c7a0..56b3fb0 100644
--- a/korganizer/calendarview.cpp
+++ b/korganizer/calendarview.cpp
@@ -1,3606 +1,3608 @@
 /*
  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;
    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 = ( local->lastModified() > mLastCalendarSync );
        if ( !remCh && ! locCh ) {
            //qDebug("both not changed ");
            lastSync = local->lastModified().addDays(1);
        } else {
            if ( locCh ) {
                //qDebug("loc changed %d %s %s", local->revision() , local->lastModified().toString().latin1(), mLastCalendarSync.toString().latin1());
                lastSync = local->lastModified().addDays( -1 );
                if ( !remCh )
                    remote->setLastModified( lastSync.addDays( -1 ) );
            } else {
                //qDebug(" not loc changed ");
                lastSync = local->lastModified().addDays( 1 );
                if ( remCh )
                    remote->setLastModified( lastSync.addDays( 1 ) );
                
            }
        }
        full = true;  
        if ( mode < SYNC_PREF_ASK )
            mode = SYNC_PREF_ASK;
    } else {
          if ( local->lastModified() == remote->lastModified() )
            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", local->lastModified().toString().latin1() , local->revision(), remote->lastModified().toString().latin1(), remote->revision());  
    //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 = 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()  ,  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 > remote->lastModified() )
            return 1;
        if ( lastSync > local->lastModified() )
            return 2;
        return 1;
        break;
    case SYNC_PREF_REMOTE:
        if ( lastSync > remote->lastModified() )
            return 1;
        if ( lastSync > local->lastModified() )
            return 2;
        return 2;
        break;
    case SYNC_PREF_NEWEST:
        if ( local->lastModified() > remote->lastModified() )
            return 1;
        else
            return 2;
        break;
    case SYNC_PREF_ASK: 
        //qDebug("lsy %s  ---  lo %s  --- re %s ", lastSync.toString().latin1(), local->lastModified().toString().latin1(), remote->lastModified().toString().latin1()  );
        if ( lastSync > remote->lastModified() )
            return 1;
        if ( lastSync > local->lastModified() )
            return 2;
        //qDebug("lsy %s  ---  lo %s  --- re %s ", lastSync.toString().latin1(), local->lastModified().toString().latin1(), remote->lastModified().toString().latin1()  );
        localIsNew = local->lastModified() >= remote->lastModified();
        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 );
                        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>
+//#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();
    //mDialogManager->updateSearchDialog();
    if (which) {
        mViewManager->currentView()->updateView();
        //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"
diff --git a/korganizer/incomingdialog.cpp b/korganizer/incomingdialog.cpp
index f3bd09f..50e3077 100644
--- a/korganizer/incomingdialog.cpp
+++ b/korganizer/incomingdialog.cpp
@@ -1,527 +1,528 @@
 /*
    This file is part of KOrganizer.
    Copyright (c) 2001 Cornelius Schumacher <schumacher@kde.org>
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 2 of the License, or
    (at your option) any later version.
    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
    GNU General Public License for more details.
    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 */
 #include <qlistview.h>
 #include <qfile.h>
 #include <qdir.h>
 #include <qmap.h>
 #include <kglobal.h>
 #include <klocale.h>
 #include <kdebug.h>
 #include <kstandarddirs.h>
 #include <kmessagebox.h>
 #include <libkcal/incidence.h>
 #include <libkcal/event.h>
 #include <libkcal/calendar.h>
 #include <libkcal/freebusy.h>
 #include <libkcal/attendee.h>
 #include <libkcal/calendarresources.h>
 #include <libkcal/resourcecalendar.h>
 #include <kresources/resourceselectdialog.h>
 #ifndef KORG_NOMAIL
 #include "mailscheduler.h"
 #else
 #include <libkcal/dummyscheduler.h>
 #endif
 #include "incomingdialog.h"
 #include "koeventviewerdialog.h"
 #include "kocounterdialog.h"
 #include "koprefs.h"
 #ifndef KORG_NOKABC
-#include <kabc/stdaddressbook.h>
+#define KORG_NOKABC
+//#include <kabc/stdaddressbook.h>
 #define size count
 #endif
 ScheduleItemIn::ScheduleItemIn(QListView *parent,IncidenceBase *ev,
                               Scheduler::Method method,ScheduleMessage::Status status)
  : QListViewItem(parent)
 {
  mIncidence = ev;
  mMethod = method;
  mStatus = status;
  setText(6,Scheduler::translatedMethodName(mMethod)+" ");
  setText(7,ScheduleMessage::statusName(status));
 }
 /* Visitor */
 ScheduleItemVisitor::ScheduleItemVisitor(ScheduleItemIn *item)
 {
  mItem = item;
 }
 ScheduleItemVisitor::~ScheduleItemVisitor()
 {
 }
 bool ScheduleItemVisitor::visit(Event *e)
 {
  mItem->setText(0,e->summary());
  mItem->setText(1,e->dtStartDateStr());
  if (e->doesFloat()) {
    mItem->setText(2,i18n("no time "));
    mItem->setText(4,i18n("no time "));
  }
  else {
    mItem->setText(2,e->dtStartTimeStr());
    mItem->setText(4,e->dtEndTimeStr());
  }
  if (e->hasEndDate()) {
    mItem->setText(3,e->dtEndDateStr());
  }
  else {
    mItem->setText(3,"");
  }
  mItem->setText(5,e->organizer()+" ");
  return true;
 }
 bool ScheduleItemVisitor::visit(Todo *e)
 {
  mItem->setText(0,e->summary());
  if (e->hasStartDate()) {
    mItem->setText(1,e->dtStartDateStr());
    if (!e->doesFloat()) {
      mItem->setText(2,e->dtStartTimeStr());
    }
  }
  if (e->hasDueDate()) {
    mItem->setText(1,e->dtDueDateStr());
    if (!e->doesFloat()) {
      mItem->setText(2,e->dtDueTimeStr());
    }
  }
  mItem->setText(5,e->organizer()+" ");
  return true;
 }
 bool ScheduleItemVisitor::visit(Journal *)
 {
  return false;
 }
 /*
 *  Constructs a IncomingDialog which is a child of 'parent', with the
 *  name 'name' and widget flags set to 'f'
 *
 *  The dialog will by default be modeless, unless you set 'modal' to
 *  TRUE to construct a modal dialog.
 */
 IncomingDialog::IncomingDialog(Calendar *calendar,OutgoingDialog *outgoing,
                QWidget* parent,const char* name,bool modal,WFlags fl) :
  IncomingDialog_base(parent,name,modal,fl)
 {
  mCalendar = calendar;
  mOutgoing = outgoing;
 #ifndef KORG_NOMAIL
  mScheduler = new MailScheduler(mCalendar);
 #else
  mScheduler = new DummyScheduler(mCalendar);
 #endif
  mMessageListView->setColumnAlignment(1,AlignHCenter);
  mMessageListView->setColumnAlignment(2,AlignHCenter);
  mMessageListView->setColumnAlignment(3,AlignHCenter);
  mMessageListView->setColumnAlignment(4,AlignHCenter);
  QObject::connect(mMessageListView,SIGNAL(doubleClicked(QListViewItem *)),
                   this,SLOT(showEvent(QListViewItem *)));
  retrieve();
 }
 /*
 *  Destroys the object and frees any allocated resources
 */
 IncomingDialog::~IncomingDialog()
 {
    // no need to delete child widgets, Qt does it all for us
 }
 void IncomingDialog::setOutgoingDialog(OutgoingDialog *outgoing)
 {
  mOutgoing = outgoing;
 }
 void IncomingDialog::retrieve()
 {
  QPtrList <ScheduleMessage> messages = mScheduler->retrieveTransactions();
  ScheduleMessage *message;
  for(message = messages.first();message;message = messages.next()) {
    IncidenceBase *inc = message->event();
    Scheduler::Method method = (Scheduler::Method)message->method();
    ScheduleMessage::Status status = message->status();
    
    ScheduleItemIn *item = new ScheduleItemIn(mMessageListView,inc,method,status);
    if(inc->type()!="FreeBusy") {
      Incidence *incidence = static_cast<Incidence *>(inc);
      ScheduleItemVisitor v(item);
      if (!incidence->accept(v)) delete item;
    } else {
      FreeBusy *fb = static_cast<FreeBusy *>(item->event());
      item->setText(0, "FreeBusy");
      item->setText(1, KGlobal::locale()->formatDate( fb->dtStart().date() ) );
      item->setText(2, KGlobal::locale()->formatTime( fb->dtStart().time() ) );
      item->setText(3, KGlobal::locale()->formatDate( fb->dtEnd().date() ) );
      item->setText(4, KGlobal::locale()->formatTime( fb->dtEnd().time() ) );
      item->setText(5, fb->organizer());
    }
    automaticAction(item);
  }
  emit numMessagesChanged(mMessageListView->childCount());
 }
 void IncomingDialog::acceptAllMessages()
 {
  bool success = false;
  ScheduleItemIn *item = (ScheduleItemIn *)mMessageListView->firstChild();
  while(item) {
    ScheduleItemIn *nextitem = (ScheduleItemIn *)(item->nextSibling());
    if (acceptMessage(item)) success = true;
    item = nextitem;
  }
  if (success) emit calendarUpdated();
 }
 void IncomingDialog::acceptMessage()
 {
  ScheduleItemIn *item = (ScheduleItemIn *)mMessageListView->selectedItem();
  if (item) {
    if (acceptMessage(item)) emit calendarUpdated();
  }
 }
 bool IncomingDialog::acceptMessage(ScheduleItemIn *item)
 {
  switch (item->method()) {
    case Scheduler::Refresh:
        return incomeRefresh(item);
        break;
    case Scheduler::Counter:
        return incomeCounter(item);
        break;
    case Scheduler::Declinecounter:
        return incomeDeclineCounter(item);
        break;
    case Scheduler::Add:
        return incomeAdd(item);
        break;
    case Scheduler::Request:
        return incomeRequest(item);
        break;
    default:
        return incomeDefault(item);
  }
  return false;
 }
 void IncomingDialog::rejectMessage()
 {
  ScheduleItemIn *item = (ScheduleItemIn *)mMessageListView->selectedItem();
  if (item) {
    mScheduler->deleteTransaction(item->event());
    delete item;
    emit numMessagesChanged(mMessageListView->childCount());
  }
 }
 void IncomingDialog::showEvent(QListViewItem *item)
 {
  IncidenceBase *incidence = ((ScheduleItemIn *)item)->event();
  if( incidence && incidence->type() == "Event" ) {
    Event *event = static_cast<Event *>(incidence);
    KOEventViewerDialog *eventViewer = new KOEventViewerDialog(this);
    eventViewer->setEvent(event);
    eventViewer->show();
  }
 }
 bool IncomingDialog::incomeRefresh(ScheduleItemIn *item)
 {
  Event *ev = mCalendar->event(item->event()->uid());
  if (ev) {
    //user interaction before??
    Attendee *att;
    QPtrList<Attendee> attlist = ev->attendees();
    for (att=attlist.first(); att; att=attlist.next()) {
      Event *event = new Event(*ev);
      mOutgoing->addMessage(event,Scheduler::Request,att->email());
      delete(event);
    }
    mScheduler->deleteTransaction(item->event());
    delete item;
    emit numMessagesChanged(mMessageListView->childCount());
    return true;
  }
  mScheduler->deleteTransaction(item->event());
  delete item;
  emit numMessagesChanged(mMessageListView->childCount());
  return false;
 }
 bool IncomingDialog::incomeCounter(ScheduleItemIn *item)
 {
  IncidenceBase *incidence = ((ScheduleItemIn *)item)->event();
  // currently only events supportet - attetion at insertion below!
  if ( incidence->type() != "Event" ) return false;
  Event *counterEvent = static_cast<Event *>( incidence );
  Event *even = mCalendar->event(counterEvent->uid());
  KOCounterDialog *eventViewer = new KOCounterDialog(this);
  eventViewer->addText(i18n("counter proposal event","<b>Counter-event:</b><p>"));
  eventViewer->addEvent(counterEvent);
  eventViewer->addText("<hr>");
  eventViewer->addText(i18n("<b>Original event:</b><p>"));
  if (even) eventViewer->addEvent(even);
  else eventViewer->addText(i18n("A corresponding event is missing in your calendar!"));
  eventViewer->addText("<hr>");
  eventViewer->addText(i18n("If this counter-event is a good proposal for your event, press 'Accept'. All Attendees will then get the new version of this event"));
  eventViewer->show();
  eventViewer->exec();
  if (eventViewer->result()) {
    kdDebug() << "IncomingDialog::Counter:Accept" << endl;
    int revision = 0;
    if (even) {
      revision = even->revision();
      mCalendar->deleteEvent(even);
    }
    mCalendar->addIncidence(counterEvent);
    even = mCalendar->event(item->event()->uid());
    if (even) {
      if (revision < even->revision())
        even->setRevision(even->revision()+1);
      else
        even->setRevision(revision+1);
      Event *ev = new Event(*even);
      mOutgoing->addMessage(ev,Scheduler::Request);
      delete(ev);
    }
    mScheduler->deleteTransaction(item->event());
    delete item;
    emit numMessagesChanged(mMessageListView->childCount());
    return true;
  } else {
    kdDebug() << "IncomingDialog::Counter:Decline" << endl;
    //the counter-sender's email is missing...
    //now every attendee gets an declinecounter :-(
    mOutgoing->addMessage(counterEvent,Scheduler::Declinecounter);
    delete item;
    emit numMessagesChanged(mMessageListView->childCount());
    mScheduler->deleteTransaction(item->event());
    delete item;
    emit numMessagesChanged(mMessageListView->childCount());
    return true;
  }
  //mScheduler->deleteTransaction(item->event());
  delete item;
  emit numMessagesChanged(mMessageListView->childCount());
  return false;
 }
 bool IncomingDialog::incomeDeclineCounter(ScheduleItemIn *item)
 {
  Event *even = mCalendar->event(item->event()->uid());
  if (even) {
    mOutgoing->addMessage(even,Scheduler::Refresh);
    mScheduler->deleteTransaction(item->event());
    delete item;
    emit numMessagesChanged(mMessageListView->childCount());
    return true;
  }
  mScheduler->deleteTransaction(item->event());
  delete item;
  emit numMessagesChanged(mMessageListView->childCount());
  return false;
 }
 bool IncomingDialog::incomeAdd(ScheduleItemIn *item)
 {
  IncidenceBase *incidence = ((ScheduleItemIn *)item)->event();
  if (incidence->type() == "Event" ) {
    Event *refr = static_cast<Event *>( incidence );
    mOutgoing->addMessage(refr,Scheduler::Refresh);
    mScheduler->deleteTransaction( incidence );
    delete item;
    emit numMessagesChanged(mMessageListView->childCount());
    return true;
  }
  else {
    kdDebug() << "IncomingDialog::incomeAdd - only Events are supportet yet" << endl;
    mScheduler->deleteTransaction( incidence );
    delete item;
    emit numMessagesChanged(mMessageListView->childCount());
    return false;
  }
 }
 bool IncomingDialog::incomeDefault(ScheduleItemIn *item)
 {
  if (mScheduler->acceptTransaction(item->event(),item->method(),item->status())) {
    delete item;
    emit numMessagesChanged(mMessageListView->childCount());
    return true;
  }
  else {
    KMessageBox::error(this,i18n("Unable to accept the IMIP-message. It may be a problem with the email addresses."));
    kdDebug() << "IncomingDialog::acceptMessage(): Error!" << endl;
    return false;
  }
  return false;
 }
 bool IncomingDialog::incomeRequest(ScheduleItemIn *item)
 {
  if (item->event()->type()=="FreeBusy") {
    //handel freebusy request
    IncidenceBase *inc = item->event();
    QDateTime start = inc->dtStart();
    QDateTime end = start.addDays(inc->duration()/86400);
    FreeBusy *freebusy = new FreeBusy(mCalendar, start, end);
    freebusy->setOrganizer(inc->organizer());
    Attendee *att = new Attendee(KOPrefs::instance()->fullName(),
                               KOPrefs::instance()->email());
    freebusy->addAttendee(att);
    kdDebug() << "calendarview: schedule_publish_freebusy: startDate: "
      << KGlobal::locale()->formatDateTime( start ) << " End Date: " 
      << KGlobal::locale()->formatDateTime( end ) << endl;
  
    if (mOutgoing->addMessage(freebusy,Scheduler::Reply)) {
      delete item;
      emit numMessagesChanged(mMessageListView->childCount());
      delete(freebusy);
      return true;
    }
    return false;     
  } else {
    return incomeDefault(item);
  }
  return false;
 }
 bool IncomingDialog::automaticAction(ScheduleItemIn *item)
 {
  bool autoAction = false;
  IncidenceBase *inc = item->event();
  Scheduler::Method method = item->method();
  if( inc->type()=="FreeBusy" ) {
    if ( method==Scheduler::Request ) {
      if ( KOPrefs::instance()->mIMIPAutoFreeBusy==KOPrefs::addressbookAuto ) {
        // reply freebusy information
        if ( checkOrganizerInAddressbook(inc->organizer()) ) {
          incomeRequest(item);
        }
      } else return false;
    } else {
      if ( method==Scheduler::Reply ) {
        if ( KOPrefs::instance()->mIMIPAutoFreeBusy==KOPrefs::addressbookAuto ) {
          // insert freebusy information
          //if ( checkAttendeesInAddressbook(inc) )
        } else return false;
      } else {
        if ( method==Scheduler::Publish) {
          if ( KOPrefs::instance()->mIMIPAutoFreeBusy==KOPrefs::addressbookAuto ) {
            // insert freebusy information
            //if ( checkOrganizerInAddressbook(inc->organizer()) )
          }
        } else return false;
      }
    }
  }
  if ( inc->type()=="Event" ) {
    if ( method==Scheduler::Request || method==Scheduler::Publish ) {
      if ( KOPrefs::instance()->mIMIPAutoInsertRequest==KOPrefs::addressbookAuto ) {
        // insert event
        if ( checkOrganizerInAddressbook(inc->organizer()) )
          autoAction = acceptMessage(item);
      } else return false;
    } else {
      if ( method==Scheduler::Reply ) {
        if ( KOPrefs::instance()->mIMIPAutoInsertReply==KOPrefs::addressbookAuto ) {
          //  update event information
          if ( checkAttendeesInAddressbook(inc) )
            autoAction = acceptMessage(item);
        } else return false;
      } else {
        if ( method==Scheduler::Refresh ) {
          if ( KOPrefs::instance()->mIMIPAutoRefresh==KOPrefs::addressbookAuto ) {
            // send refresh-information
            if ( checkAttendeesInAddressbook(inc) )
              autoAction = acceptMessage(item);
            else return false;
          } else return false;
        } else return false;
      }
    }
  }
  return autoAction;
 }
 bool IncomingDialog::checkOrganizerInAddressbook(QString organizer)
 {
  bool inBook = false;
 #ifndef KORG_NOKABC
  KABC::AddressBook *add_book = KABC::StdAddressBook::self();
  KABC::Addressee::List addressList;
  addressList = add_book->findByEmail(organizer);
  if ( addressList.size()>0 ) inBook = true;
 #endif
  return inBook;
 }
 bool IncomingDialog::checkAttendeesInAddressbook(IncidenceBase *inc)
 {
  bool inBook = false;
 #ifndef KORG_NOKABC
  KABC::AddressBook *add_book = KABC::StdAddressBook::self();
  KABC::Addressee::List addressList;
  QPtrList <Attendee> attendees;
  Attendee *att;
  attendees = inc->attendees();
  for (att=attendees.first();att;att=attendees.next()) {
    addressList = add_book->findByEmail(att->email());
    if (addressList.size()>0 ) inBook = true;
  }
 #endif
  return inBook;
 }
 //#include "incomingdialog.moc"
diff --git a/korganizer/korganizerE.pro b/korganizer/korganizerE.pro
index 4247838..d841193 100644
--- a/korganizer/korganizerE.pro
+++ b/korganizer/korganizerE.pro
@@ -1,155 +1,157 @@
        TEMPLATE= app
        CONFIG  += qt warn_on
        TARGET  = kopi
 OBJECTS_DIR = obj/$(PLATFORM)
 MOC_DIR = moc/$(PLATFORM)
 DESTDIR=$(QPEDIR)/bin
 INCLUDEPATH += $(KDEPIMDIR) $(KDEPIMDIR)/microkde $(KDEPIMDIR)/microkde/kdecore $(KDEPIMDIR)/microkde/kio/kfile $(KDEPIMDIR)/microkde/kio/kio $(KDEPIMDIR)/microkde/kdeui $(KDEPIMDIR)/qtcompat $(KDEPIMDIR)/libkdepim interfaces $(KDEPIMDIR)/kabc $(QPEDIR)/include
 DEFINES += KORG_NODND KORG_NOPLUGINS  KORG_NOARCHIVE KORG_NOMAIL
 DEFINES += KORG_NOPRINTER  KORG_NODCOP KORG_NOKALARMD KORG_NORESOURCEVIEW KORG_NOSPLITTER
 DEFINES += KORG_NOLVALTERNATION
 #KORG_NOKABC
 LIBS += -lmicrokdepim
 LIBS += -lmicrokcal
 LIBS += -lmicrokde
 LIBS += -lmicroqtcompat
-LIBS += -lmicrokabc
+#LIBS += -lmicrokabc
 #LIBS +=  $(QPEDIR)/lib/gammu
 #LIBS += -lmicrogammu
 #LIBS += -lbluetooth
 #LIBS += -lsdp
+LIBS += $(GCC3EXTRALIB1)
+LIBS += $(GCC3EXTRALIB2)
 LIBS += -lqpe
 LIBS += -ljpeg
 LIBS += $(QTOPIALIB)
 LIBS += -L$(QPEDIR)/lib
 
 INTERFACES =  kofilterview_base.ui 
 #filteredit_base.ui
 HEADERS = \
 wordsgerman.h \
 filteredit_base.h \
 alarmclient.h \
 calendarview.h \
 customlistviewitem.h \
 datenavigator.h \
 docprefs.h \
 filtereditdialog.h \
 incomingdialog.h \
 incomingdialog_base.h \
 interfaces/korganizer/baseview.h \
 interfaces/korganizer/calendarviewbase.h \
 journalentry.h \
 kdateedit.h \
 kdatenavigator.h \
 koagenda.h \
 koagendaitem.h \
 koagendaview.h \
 kocounterdialog.h \
 kodaymatrix.h \
 kodialogmanager.h \
 koeditordetails.h \
 koeditorgeneral.h \
 koeditorgeneralevent.h \
 koeditorgeneraltodo.h \
 koeditorrecurrence.h \
 koeventeditor.h \
 koeventpopupmenu.h \
 koeventview.h \
 koeventviewer.h \
 koeventviewerdialog.h \
 kofilterview.h \
 koglobals.h \
 koincidenceeditor.h \
 kojournalview.h \
 kolistview.h \
 kolocationbox.h \
 komonthview.h \
 koprefs.h \
 koprefsdialog.h \
 kotimespanview.h \
 kotodoeditor.h \
 kotodoview.h \
 kotodoviewitem.h \
 koviewmanager.h \
 kowhatsnextview.h \
 ktimeedit.h \
 lineview.h \
 mainwindow.h \
 navigatorbar.h \
 outgoingdialog.h \
 outgoingdialog_base.h \
 publishdialog.h \
 publishdialog_base.h \
 savetemplatedialog.h \
 searchdialog.h \
 simplealarmclient.h \
 statusdialog.h \
 timeline.h \
 timespanview.h \
 version.h \
 ../kalarmd/alarmdialog.h
 SOURCES = \
 filteredit_base.cpp \
 calendarview.cpp \
 datenavigator.cpp \
 docprefs.cpp \
 filtereditdialog.cpp \
 incomingdialog.cpp \
 incomingdialog_base.cpp \
 journalentry.cpp \
 kdatenavigator.cpp \
 koagenda.cpp \
 koagendaitem.cpp \
 koagendaview.cpp \
 kocounterdialog.cpp \
 kodaymatrix.cpp \
 kodialogmanager.cpp \
 koeditordetails.cpp \
 koeditorgeneral.cpp \
 koeditorgeneralevent.cpp \
 koeditorgeneraltodo.cpp \
 koeditorrecurrence.cpp \
 koeventeditor.cpp \
 koeventpopupmenu.cpp \
 koeventview.cpp \
 koeventviewer.cpp \
 koeventviewerdialog.cpp \
 kofilterview.cpp \
 koglobals.cpp \
 koincidenceeditor.cpp \
 kojournalview.cpp \
 kolistview.cpp \
 kolocationbox.cpp \
 komonthview.cpp \
 koprefs.cpp \
 koprefsdialog.cpp \
 kotimespanview.cpp \
 kotodoeditor.cpp \
 kotodoview.cpp \
 kotodoviewitem.cpp \
 koviewmanager.cpp \
 kowhatsnextview.cpp \
 ktimeedit.cpp \
 lineview.cpp \
 main.cpp \
 mainwindow.cpp \
 navigatorbar.cpp \
 outgoingdialog.cpp \
 outgoingdialog_base.cpp \
 publishdialog.cpp \
 publishdialog_base.cpp \
 savetemplatedialog.cpp \
 searchdialog.cpp \
 simplealarmclient.cpp \
 statusdialog.cpp \
 timeline.cpp \
 timespanview.cpp \
 ../kalarmd/alarmdialog.cpp
diff --git a/korganizer/publishdialog.cpp b/korganizer/publishdialog.cpp
index 4323b91..2ae6720 100644
--- a/korganizer/publishdialog.cpp
+++ b/korganizer/publishdialog.cpp
@@ -1,150 +1,151 @@
 /*
    This file is part of KOrganizer.
    Copyright (c) 2001 Cornelius Schumacher <schumacher@kde.org>
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 2 of the License, or
    (at your option) any later version.
    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
    GNU General Public License for more details.
    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
    As a special exception, permission is given to link this program
    with any edition of Qt, and distribute the resulting executable,
    without including the source code for Qt in the source distribution.
 */
 #include <qlineedit.h>
 #include <kdebug.h>
 #include <kglobal.h>
 #include <klocale.h>
 #ifndef KORG_NOKABC
-#include <kabc/addresseedialog.h>
+#define KORG_NOKABC
+//#include <kabc/addresseedialog.h>
 #endif
 #include "koprefs.h"
 #include "publishdialog.h"
 PublishDialog::PublishDialog(QWidget* parent, const char* name,
                               bool modal, WFlags fl)
    : PublishDialog_base(parent,name,modal,fl)
 {
  setCaption(i18n("Select Addresses"));
  mNameLineEdit->setEnabled(false);
  mEmailLineEdit->setEnabled(false);
  connect(mAddressListView,SIGNAL(selectionChanged(QListViewItem *)),
          SLOT(updateInput()));
 }
 PublishDialog::~PublishDialog()
 {
 }
 void PublishDialog::addAttendee(Attendee *attendee)
 {
  mNameLineEdit->setEnabled(true);
  mEmailLineEdit->setEnabled(true);
  QListViewItem *item = new QListViewItem(mAddressListView);
  item->setText(0,attendee->name());
  item->setText(1,attendee->email());
  mAddressListView->insertItem(item);
 }
 QString PublishDialog::addresses()
 {
  QString to = "";
  QListViewItem *item;
  int i, count;
  count = mAddressListView->childCount();
  for (i=0;i<count;i++) {
    item = mAddressListView->firstChild();
    mAddressListView->takeItem(item);
    to += item->text(1);
    if (i<count-1) {
      to += ", ";
    }
  }
  return to;
 }
 void PublishDialog::addItem()
 {
  mNameLineEdit->setEnabled(true);
  mEmailLineEdit->setEnabled(true);
  QListViewItem *item = new QListViewItem(mAddressListView);
  mAddressListView->insertItem(item);
  mAddressListView->setSelected(item,true);
  mNameLineEdit->setText(i18n("(EmptyName)"));
  mEmailLineEdit->setText(i18n("(EmptyEmail)"));
 }
 void PublishDialog::removeItem()
 {
  QListViewItem *item;
  item = mAddressListView->selectedItem();
  if (!item) return;
  mAddressListView->takeItem(item);
  item = mAddressListView->selectedItem();
  if (!item) {
    mNameLineEdit->setText("");
    mEmailLineEdit->setText("");
    mNameLineEdit->setEnabled(false);
    mEmailLineEdit->setEnabled(false);
  }
  if (mAddressListView->childCount() == 0) {
    mNameLineEdit->setEnabled(false);
    mEmailLineEdit->setEnabled(false);
  }
 }
 void PublishDialog::openAddressbook()
 {
 #ifndef KORG_NOKABC
  KABC::Addressee::List addressList;
  addressList = KABC::AddresseeDialog::getAddressees(this);
  //KABC::Addressee a = KABC::AddresseeDialog::getAddressee(this);
  KABC::Addressee a = addressList.first();
  if (!a.isEmpty()) {
    uint i;
    for (i=0;i<addressList.count();i++) {
      a = addressList[i];
      mNameLineEdit->setEnabled(true);
      mEmailLineEdit->setEnabled(true);
      QListViewItem *item = new QListViewItem(mAddressListView);
      mAddressListView->setSelected(item,true);
      mNameLineEdit->setText(a.realName());
      mEmailLineEdit->setText(a.preferredEmail());
      mAddressListView->insertItem(item);
    }
  }
 #endif
 }
 void PublishDialog::updateItem()
 {
  QListViewItem *item;
  item = mAddressListView->selectedItem();
  if (!item) return;
  item->setText(0,mNameLineEdit->text());
  item->setText(1,mEmailLineEdit->text());
 }
 void PublishDialog::updateInput()
 {
  QListViewItem *item;
  item = mAddressListView->selectedItem();
  if (!item) return;
  mNameLineEdit->setEnabled(true);
  mEmailLineEdit->setEnabled(true);
  QString mail = item->text(1);
  mNameLineEdit->setText(item->text(0));
  mEmailLineEdit->setText(mail);
 }
diff --git a/libkdepim/libkdepim.pro b/libkdepim/libkdepim.pro
index 060145e..f5de653 100644
--- a/libkdepim/libkdepim.pro
+++ b/libkdepim/libkdepim.pro
@@ -1,59 +1,57 @@
        TEMPLATE= lib
        CONFIG  = qt warn_on
 DEFINES +=KORG_NOKABC
 TARGET = microkdepim
 INCLUDEPATH += ../microkde ../microkde/kdecore ../microkde/kdeui . ..
 DESTDIR=../bin
 DEFINES +=  DESKTOP_VERSION
 include( ../variables.pri )
 unix : {
 OBJECTS_DIR = obj/unix
 MOC_DIR = moc/unix
 }
 win32: {
 DEFINES += _WIN32_
 OBJECTS_DIR = obj/win
 MOC_DIR = moc/win
 }
 INTERFACES = \
 HEADERS = \
 categoryeditdialog.h \
 categoryeditdialog_base.h \
 categoryselectdialog.h \
 categoryselectdialog_base.h \
 externalapphandler.h \
 kdateedit.h \
 kdatepicker.h \
 kinputdialog.h \
 kincidenceformatter.h \
 kpimprefs.h \
 kpimglobalprefs.h \
 kprefsdialog.h \
- addresseeview.h \
 ksyncprofile.h \
 ksyncprefsdialog.h \
 kcmconfigs/kcmkdepimconfig.h \
 kcmconfigs/kdepimconfigwidget.h
 SOURCES = \
 categoryeditdialog.cpp \
 categoryeditdialog_base.cpp \
 categoryselectdialog.cpp \
 categoryselectdialog_base.cpp \
 externalapphandler.cpp \
 kdateedit.cpp \
 kdatepicker.cpp \
 kinputdialog.cpp \
 kincidenceformatter.cpp \
 kpimprefs.cpp \
 kpimglobalprefs.cpp \
 kprefsdialog.cpp \
- addresseeview.cpp \
 ksyncprofile.cpp \
 ksyncprefsdialog.cpp \
 kcmconfigs/kcmkdepimconfig.cpp \
 kcmconfigs/kdepimconfigwidget.cpp
diff --git a/libkdepim/libkdepimE.pro b/libkdepim/libkdepimE.pro
index b455a3e..102d827 100644
--- a/libkdepim/libkdepimE.pro
+++ b/libkdepim/libkdepimE.pro
@@ -1,53 +1,51 @@
        TEMPLATE= lib
        CONFIG  += qt warn_on
 TARGET = microkdepim
 INCLUDEPATH += . $(KDEPIMDIR) $(KDEPIMDIR)/microkde $(KDEPIMDIR)/qtcompat $(KDEPIMDIR)/microkde/kdecore $(KDEPIMDIR)/microkde/kdeui $(QPEDIR)/include
 LIBS += -lmicrokde
 LIBS += -lmicrokcal
 LIBS += -L$(QPEDIR)/lib
 OBJECTS_DIR = obj/$(PLATFORM)
 MOC_DIR = moc/$(PLATFORM)
 DESTDIR=$(QPEDIR)/lib
 INTERFACES = \
 HEADERS = \
 categoryeditdialog.h \
 categoryeditdialog_base.h \
 categoryselectdialog.h \
 categoryselectdialog_base.h \
 externalapphandler.h \
 kdateedit.h \
 kdatepicker.h \
 kinputdialog.h \
 kincidenceformatter.h \
 kpimprefs.h \
 kpimglobalprefs.h \
 kprefsdialog.h \
- addresseeview.h \
 ksyncprofile.h \
 ksyncprefsdialog.h \
 kcmconfigs/kcmkdepimconfig.h \
 kcmconfigs/kdepimconfigwidget.h
 
 SOURCES = \
 categoryeditdialog.cpp \
 categoryeditdialog_base.cpp \
 categoryselectdialog.cpp \
 categoryselectdialog_base.cpp \
 externalapphandler.cpp \
 kdateedit.cpp \
 kinputdialog.cpp \
 kdatepicker.cpp \
 kincidenceformatter.cpp \
 kpimprefs.cpp \
 kpimglobalprefs.cpp \
 kprefsdialog.cpp \
- addresseeview.cpp \
 ksyncprofile.cpp \
 ksyncprefsdialog.cpp \
 kcmconfigs/kcmkdepimconfig.cpp \
 kcmconfigs/kdepimconfigwidget.cpp