6 files changed, 36 insertions, 41 deletions
diff --git a/kabc/addressee.cpp b/kabc/addressee.cpp
index 7f592e9..155ce24 100644
--- a/kabc/addressee.cpp
+++ b/kabc/addressee.cpp
@@ -1,246 +1,245 @@
 /*** Warning! This file has been generated by the script makeaddressee ***/
 /*
    This file is part of libkabc.
    Copyright (c) 2001 Cornelius Schumacher <schumacher@kde.org>
    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Library General Public
    License as published by the Free Software Foundation; either
    version 2 of the License, or (at your option) any later version.
    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Library General Public License for more details.
    You should have received a copy of the GNU Library General Public License
    along with this library; see the file COPYING.LIB.  If not, write to
    the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
    Boston, MA 02111-1307, USA.
 */
 /*
 Enhanced Version of the file for platform independent KDE tools.
 Copyright (c) 2004 Ulf Schenk
 $Id$
 */
 #include <kconfig.h>
 #include <ksharedptr.h>
 #include <kdebug.h>
 #include <kapplication.h>
 #include <klocale.h>
 #include <kidmanager.h>
 //US
 #include <kstandarddirs.h>
 #include <libkcal/syncdefines.h>
 //US #include "resource.h"
 #include "addressee.h"
 using namespace KABC;
 static bool matchBinaryPattern( int value, int pattern );
 static bool matchBinaryPatternA( int value, int pattern );
 static bool matchBinaryPatternP( int value, int pattern );
 struct Addressee::AddresseeData : public KShared
 {
  QString uid;
  QString name;
  QString formattedName;
-  QString defaultFormattedName;
  QString familyName;
  QString givenName;
  QString additionalName;
  QString prefix;
  QString suffix;
  QString nickName;
  QDateTime birthday;
  QString mailer;
  TimeZone timeZone;
  Geo geo;
  QString title;
  QString role;
  QString organization;
  QString note;
  QString productId;
  QDateTime revision;
  QString sortString;
  QString externalUID;
  QString originalExternalUID;
  KURL url;
  Secrecy secrecy;
  Picture logo;
  Picture photo;
  Sound sound;
  Agent agent;
  QString mExternalId;
  PhoneNumber::List phoneNumbers;
  Address::List addresses;
  Key::List keys;
  QStringList emails;
  QStringList categories;
  QStringList custom;
  int mTempSyncStat;
  Resource *resource;
  bool empty    :1;
  bool changed  :1;
  bool tagged   :1;
 };
 Addressee::Addressee()
 {
  mData = new AddresseeData;
  mData->empty = true;
  mData->changed = false;
  mData->resource = 0;
  mData->mExternalId = ":";
  mData->revision = QDateTime ( QDate( 2003,1,1));
  mData->mTempSyncStat =  SYNC_TEMPSTATE_INITIAL;
 }
 Addressee::~Addressee()
 {
 }
 Addressee::Addressee( const Addressee &a )
 {
  mData = a.mData;
 }
 Addressee &Addressee::operator=( const Addressee &a )
 {
  mData = a.mData;
  return (*this);
 }
 Addressee Addressee::copy()
 {
  Addressee a;
  *(a.mData) = *mData;
  return a;
 }
 void Addressee::detach()
 {
  if ( mData.count() == 1 ) return;
  *this = copy();
 }
 bool Addressee::operator==( const Addressee &a ) const
 {
  if ( uid() != a.uid() ) return false;
  if ( mData->name != a.mData->name ) return false;
  if ( mData->formattedName != a.mData->formattedName ) return false;
  if ( mData->familyName != a.mData->familyName ) return false;
  if ( mData->givenName != a.mData->givenName ) return false;
  if ( mData->additionalName != a.mData->additionalName ) return false;
  if ( mData->prefix != a.mData->prefix ) return false;
  if ( mData->suffix != a.mData->suffix ) return false;
  if ( mData->nickName != a.mData->nickName ) return false;
  if ( mData->birthday != a.mData->birthday ) return false;
  if ( mData->mailer != a.mData->mailer ) return false;
  if ( mData->timeZone != a.mData->timeZone ) return false;
  if ( mData->geo != a.mData->geo ) return false;
  if ( mData->title != a.mData->title ) return false;
  if ( mData->role != a.mData->role ) return false;
  if ( mData->organization != a.mData->organization ) return false;
  if ( mData->note != a.mData->note ) return false;
  if ( mData->productId != a.mData->productId ) return false;
  //if ( mData->revision != a.mData->revision ) return false;
  if ( mData->sortString != a.mData->sortString ) return false;
  if ( mData->secrecy != a.mData->secrecy ) return false;
  if ( mData->logo != a.mData->logo ) return false;
  if ( mData->photo != a.mData->photo ) return false;
  if ( mData->sound != a.mData->sound ) return false;
  if ( mData->agent != a.mData->agent ) return false;
  if ( ( mData->url.isValid() || a.mData->url.isValid() ) &&
       ( mData->url != a.mData->url ) ) return false;
  if ( mData->phoneNumbers != a.mData->phoneNumbers ) return false;
  if ( mData->addresses != a.mData->addresses ) return false;
  if ( mData->keys != a.mData->keys ) return false;
  if ( mData->emails != a.mData->emails ) return false;
  if ( mData->categories != a.mData->categories ) return false;
  if ( mData->custom != a.mData->custom ) return false;
  return true;
 }
 bool Addressee::operator!=( const Addressee &a ) const
 {
  return !( a == *this );
 }
 bool Addressee::isEmpty() const
 {
  return mData->empty;
 }
 ulong  Addressee::getCsum4List( const QStringList &  attList)
 {
    int max = attList.count();
    ulong cSum = 0;
    int j,k,i;
    int add;
    for ( i = 0; i < max ; ++i ) {
        QString s = attList[i];
        if ( ! s.isEmpty() ){
            j = s.length();
            for ( k = 0; k < j; ++k ) {
                int mul = k +1;
                add = s[k].unicode ();
                if ( k < 16 )
                    mul = mul * mul;
                int ii = i+1;
                add = add * mul *ii*ii*ii;
                cSum += add;
                //qDebug("csum: %d %d %d", i,k,cSum); 
            }
        }
            
    }
    //QString dump = attList.join(",");
    //qDebug("csum: %d %s", cSum,dump.latin1()); 
    
    return cSum;
 }
 void Addressee::computeCsum(const QString &dev)
 {
    QStringList l;
    //if ( !mData->name.isEmpty() ) l.append(mData->name);
    //if ( !mData->formattedName.isEmpty() ) l.append(mData->formattedName  );
    if ( !mData->familyName.isEmpty()  ) l.append( mData->familyName );
    if ( !mData->givenName.isEmpty() ) l.append(mData->givenName  );
    if ( !mData->additionalName.isEmpty()  ) l.append( mData->additionalName );
    if ( !mData->prefix.isEmpty()  ) l.append( mData->prefix );
    if ( !mData->suffix.isEmpty()  ) l.append( mData->suffix );
    if ( !mData->nickName.isEmpty()  ) l.append( mData->nickName );
    if ( mData->birthday.isValid()  ) l.append( mData->birthday.toString() );
    if ( !mData->mailer.isEmpty() ) l.append( mData->mailer );
    if ( mData->timeZone.isValid() ) l.append( mData->timeZone.asString() );
    if ( mData->geo.isValid() ) l.append( mData->geo.asString() );
    if ( !mData->title .isEmpty() ) l.append( mData->title );
    if ( !mData->role.isEmpty() ) l.append( mData->role );
    if ( !mData->organization.isEmpty() ) l.append( mData->organization ); 
    if ( !mData->note.isEmpty() ) l.append( mData->note ); 
    if ( !mData->productId.isEmpty() ) l.append(mData->productId ); 
    if ( !mData->sortString.isEmpty() ) l.append( mData->sortString ); 
    if ( mData->secrecy.isValid() ) l.append( mData->secrecy.asString()); 
    if ( !mData->logo.undefined() ) { 
        if ( !mData->logo.isIntern() )
            l.append( mData->logo.url() );
        else
            l.append( QString::number(mData->logo.data().width()* mData->logo.data().height()));
    } else {
        l.append( "nologo");
    }
    if ( !mData->photo.undefined() ) { 
        if ( !mData->photo.isIntern() )
            l.append( mData->photo.url() );
        else
            l.append( QString::number(mData->photo.data().width()* mData->photo.data().height()));
    } else {
@@ -559,411 +558,395 @@ void Addressee::simplifyEmails()
    if ( mData->emails.count() == 0 ) return ;
    QString email = mData->emails.first();
    detach();
    mData->emails.clear();
    mData->emails.append( email );
 }
 void Addressee::simplifyPhoneNumbers()
 {
    int max = 4;
    int inList = mData->phoneNumbers.count();
    KABC::PhoneNumber::List removeNumbers;
    KABC::PhoneNumber::List::Iterator phoneIter;
    if ( inList > max ) {
        // delete non-preferred numbers
        for ( phoneIter = mData->phoneNumbers.begin(); phoneIter != mData->phoneNumbers.end();
              ++phoneIter ) {
            if ( inList > max ) {
                if ( ! (( *phoneIter ).type() &  PhoneNumber::Pref )) {
                    removeNumbers.append( ( *phoneIter ) );
                    --inList;
                }
            } else
                break;
        }
        for ( phoneIter = removeNumbers.begin(); phoneIter != removeNumbers.end();
              ++phoneIter ) {
            removePhoneNumber(( *phoneIter ));
        }
        // delete preferred numbers
        if ( inList > max ) {
            for ( phoneIter = mData->phoneNumbers.begin(); phoneIter != mData->phoneNumbers.end();
                  ++phoneIter ) {
                if ( inList > max ) {
                        removeNumbers.append( ( *phoneIter ) );
                        --inList;
                } else
                    break;
            }
            for ( phoneIter = removeNumbers.begin(); phoneIter != removeNumbers.end();
                  ++phoneIter ) {
                removePhoneNumber(( *phoneIter ));
            }
        }
    }
    // remove non-numeric characters
    for ( phoneIter = mData->phoneNumbers.begin(); phoneIter != mData->phoneNumbers.end();
          ++phoneIter ) {
        if ( ! ( *phoneIter ).simplifyNumber() )
            removeNumbers.append( ( *phoneIter ) );
    }
    for ( phoneIter = removeNumbers.begin(); phoneIter != removeNumbers.end();
          ++phoneIter ) {
        removePhoneNumber(( *phoneIter ));
    }
 }
 void Addressee::simplifyPhoneNumberTypes()
 {
    KABC::PhoneNumber::List::Iterator phoneIter;
    for ( phoneIter = mData->phoneNumbers.begin(); phoneIter != mData->phoneNumbers.end();
          ++phoneIter )
        ( *phoneIter ).simplifyType();
 }
 void Addressee::removeID(const QString &prof)
 {
    detach();
    if ( prof.isEmpty() )
        mData->mExternalId = ":";
    else
        mData->mExternalId = KIdManager::removeId ( mData->mExternalId, prof);
    
 }
 void Addressee::setID( const QString & prof , const QString & id )
 {
    detach();
    mData->mExternalId = KIdManager::setId ( mData->mExternalId, prof, id );
    //qDebug("setID2 %s %s %s",mData->mExternalId.latin1(), prof.latin1(), id.latin1() );
 }
 void Addressee::setTempSyncStat( int id )
 {
    if ( mData->mTempSyncStat == id ) return;
    detach();
    mData->mTempSyncStat = id;
 }
 int Addressee::tempSyncStat() const
 {
    return mData->mTempSyncStat;
 }
 const QString Addressee::getID( const QString &  prof) const
 {
    return KIdManager::getId ( mData->mExternalId, prof ); 
 }
 void Addressee::setCsum( const QString & prof , const QString & id )
 {
    detach();
    //qDebug("setcsum1 %s %s %s",mData->mExternalId.latin1(), prof.latin1(), id.latin1() );
    mData->mExternalId = KIdManager::setCsum ( mData->mExternalId, prof, id );
    //qDebug("setcsum2 %s ",mData->mExternalId.latin1() );
 }
 const QString Addressee::getCsum( const QString &  prof) const 
 {
    return KIdManager::getCsum ( mData->mExternalId, prof ); 
 }
 void Addressee::setIDStr( const QString & s )
 { 
    detach();
    mData->mExternalId = s;
 }
 const QString Addressee::IDStr() const
 {
    return mData->mExternalId;
 }
 void Addressee::setExternalUID( const QString &id )
 {
  if ( id == mData->externalUID ) return;
  detach();
  mData->empty = false;
  mData->externalUID = id;
 }
 const QString Addressee::externalUID() const
 {
  return mData->externalUID;
 }
 void Addressee::setOriginalExternalUID( const QString &id )
 {
  if ( id == mData->originalExternalUID ) return;
  detach();
  mData->empty = false;
  //qDebug("*******Set orig uid %s ", id.latin1());
  mData->originalExternalUID = id;
 }
 QString Addressee::originalExternalUID() const
 {
  return mData->originalExternalUID;
 }
 void Addressee::setUid( const QString &id )
 {
  if ( id == mData->uid ) return;
  detach();
  //qDebug("****setuid %s ", id.latin1());
  mData->empty = false;
  mData->uid = id;
 }
 const QString Addressee::uid() const
 {
  if ( mData->uid.isEmpty() )
    mData->uid = KApplication::randomString( 10 );
  return mData->uid;
 }
 QString Addressee::uidLabel()
 {
  return i18n("Unique Identifier");
 }
 void Addressee::setName( const QString &name )
 {
  if ( name == mData->name ) return;
  detach();
  mData->empty = false;
  mData->name = name;
 }
 QString Addressee::name() const
 {
  return mData->name;
 }
 QString Addressee::nameLabel()
 {
  return i18n("Name");
 }
 void Addressee::setFormattedName( const QString &formattedName )
 {
  if ( formattedName == mData->formattedName ) return;
  detach();
  mData->empty = false;
  mData->formattedName = formattedName;
 }
-void Addressee::setDefaultFormattedName( const QString &formattedName )
-{
-  if ( formattedName == mData->defaultFormattedName ) return;
-  detach();
-  mData->empty = false;
-  mData->defaultFormattedName = formattedName;
-}
 QString Addressee::formattedName() const
 {
  return mData->formattedName;
 }
-QString Addressee::defaultFormattedName() const
-{
-  return mData->defaultFormattedName;
-}
 QString Addressee::formattedNameLabel()
 {
  return i18n("Formatted Name");
 }
-QString Addressee::defaultFormattedNameLabel()
-{
-  return i18n("Def.Formatted Name");
-}
 void Addressee::setFamilyName( const QString &familyName )
 {
  if ( familyName == mData->familyName ) return;
  detach();
  mData->empty = false;
  mData->familyName = familyName;
 }
 QString Addressee::familyName() const
 {
  return mData->familyName;
 }
 QString Addressee::familyNameLabel()
 {
  return i18n("Family Name");
 }
 void Addressee::setGivenName( const QString &givenName )
 {
  if ( givenName == mData->givenName ) return;
  detach();
  mData->empty = false;
  mData->givenName = givenName;
 }
 QString Addressee::givenName() const
 {
  return mData->givenName;
 }
 QString Addressee::givenNameLabel()
 {
  return i18n("Given Name");
 }
 void Addressee::setAdditionalName( const QString &additionalName )
 {
  if ( additionalName == mData->additionalName ) return;
  detach();
  mData->empty = false;
  mData->additionalName = additionalName;
 }
 QString Addressee::additionalName() const
 {
  return mData->additionalName;
 }
 QString Addressee::additionalNameLabel()
 {
  return i18n("Additional Names");
 }
 void Addressee::setPrefix( const QString &prefix )
 {
  if ( prefix == mData->prefix ) return;
  detach();
  mData->empty = false;
  mData->prefix = prefix;
 }
 QString Addressee::prefix() const
 {
  return mData->prefix;
 }
 QString Addressee::prefixLabel()
 {
  return i18n("Honorific Prefixes");
 }
 void Addressee::setSuffix( const QString &suffix )
 {
  if ( suffix == mData->suffix ) return;
  detach();
  mData->empty = false;
  mData->suffix = suffix;
 }
 QString Addressee::suffix() const
 {
  return mData->suffix;
 }
 QString Addressee::suffixLabel()
 {
  return i18n("Honorific Suffixes");
 }
 void Addressee::setNickName( const QString &nickName )
 {
  if ( nickName == mData->nickName ) return;
  detach();
  mData->empty = false;
  mData->nickName = nickName;
 }
 QString Addressee::nickName() const
 {
  return mData->nickName;
 }
 QString Addressee::nickNameLabel()
 {
  return i18n("Nick Name");
 }
 void Addressee::setBirthday( const QDateTime &birthday )
 {
  if ( birthday == mData->birthday ) return;
  detach();
  mData->empty = false;
  mData->birthday = birthday;
 }
 QDateTime Addressee::birthday() const
 {
  return mData->birthday;
 }
 QString Addressee::birthdayLabel()
 {
  return i18n("Birthday");
 }
 QString Addressee::homeAddressStreetLabel()
 {
  return i18n("Home Address Street");
 }
 QString Addressee::homeAddressLocalityLabel()
 {
  return i18n("Home Address Locality");
 }
 QString Addressee::homeAddressRegionLabel()
 {
  return i18n("Home Address Region");
 }
 QString Addressee::homeAddressPostalCodeLabel()
 {
  return i18n("Home Address Postal Code");
 }
 QString Addressee::homeAddressCountryLabel()
 {
  return i18n("Home Address Country");
 }
 QString Addressee::homeAddressLabelLabel()
 {
  return i18n("Home Address Label");
 }
 QString Addressee::businessAddressStreetLabel()
 {
  return i18n("Business Address Street");
 }
 QString Addressee::businessAddressLocalityLabel()
 {
  return i18n("Business Address Locality");
 }
 QString Addressee::businessAddressRegionLabel()
 {
  return i18n("Business Address Region");
 }
 QString Addressee::businessAddressPostalCodeLabel()
 {
  return i18n("Business Address Postal Code");
 }
diff --git a/kabc/addressee.h b/kabc/addressee.h
index 0d688f8..a2fbcf5 100644
--- a/kabc/addressee.h
+++ b/kabc/addressee.h
@@ -1,359 +1,356 @@
 /*** Warning! This file has been generated by the script makeaddressee ***/
 /*
    This file is part of libkabc.
    Copyright (c) 2001 Cornelius Schumacher <schumacher@kde.org>
    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Library General Public
    License as published by the Free Software Foundation; either
    version 2 of the License, or (at your option) any later version.
    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Library General Public License for more details.
    You should have received a copy of the GNU Library General Public License
    along with this library; see the file COPYING.LIB.  If not, write to
    the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
    Boston, MA 02111-1307, USA.
 */
 /*
 Enhanced Version of the file for platform independent KDE tools.
 Copyright (c) 2004 Ulf Schenk
 $Id$
 */
 #ifndef KABC_ADDRESSEE_H
 #define KABC_ADDRESSEE_H
 #include <qdatetime.h>
 #include <qstring.h>
 #include <qstringlist.h>
 #include <qvaluelist.h>
 #include <ksharedptr.h>
 #include <kurl.h>
 #include "address.h"
 #include "agent.h"
 #include "geo.h"
 #include "key.h"
 #include "phonenumber.h"
 #include "picture.h"
 #include "secrecy.h"
 #include "sound.h"
 #include "timezone.h"
 namespace KABC {
 class Resource;
 /**
  @short address book entry
  This class represents an entry in the address book.
  The data of this class is implicitly shared. You can pass this class by value.
  If you need the name of a field for presenting it to the user you should use
  the functions ending in Label(). They return a translated string which can be
  used as label for the corresponding field.
  About the name fields:
  givenName() is the first name and familyName() the last name. In some
  countries the family name comes first, that's the reason for the
  naming. formattedName() is the full name with the correct formatting.
  It is used as an override, when the correct formatting can't be generated
  from the other name fields automatically.
  realName() returns a fully formatted name(). It uses formattedName, if set,
  otherwise it constucts the name from the name fields. As fallback, if
  nothing else is set it uses name().
  name() is the NAME type of RFC2426. It can be used as internal name for the
  data enty, but shouldn't be used for displaying the data to the user.
 */
 class Addressee
 {
    friend QDataStream &operator<<( QDataStream &, const Addressee & );
    friend QDataStream &operator>>( QDataStream &, Addressee & );
  public:
    typedef QValueList<Addressee> List;
    /**
      Construct an empty address book entry.
     */
    Addressee();
    ~Addressee();
    Addressee( const Addressee & );
    Addressee &operator=( const Addressee & );
    bool operator==( const Addressee & ) const;
    bool operator!=( const Addressee & ) const;
    // sync stuff
    void setTempSyncStat(int id);
    int tempSyncStat() const;
    void setIDStr( const QString & );
    const QString IDStr() const;
    void setID( const QString &, const QString & );
    const QString  getID( const QString & ) const;
    void setCsum( const QString &, const QString & );
    const QString getCsum( const QString & ) const ;
    void removeID(const QString &);
    void computeCsum(const QString &dev);
    ulong getCsum4List( const QStringList &  attList);
    /**
      Return, if the address book entry is empty.
     */
    bool isEmpty() const;
    void setExternalUID( const QString &id );
    const QString externalUID() const;
    void setOriginalExternalUID( const QString &id );
    QString originalExternalUID() const;
    void mergeContact(  const Addressee& ad, bool isSubSet ); 
    void simplifyEmails();
    void simplifyAddresses();
    void simplifyPhoneNumbers();
    void simplifyPhoneNumberTypes();
    bool removeVoice();
    bool containsAdr(const Addressee& addr );
    
    /**
      Set unique identifier.
     */
    void setUid( const QString &uid );
    /**
      Return unique identifier.
     */
    const QString uid() const;
    /**
      Return translated label for uid field.
     */
    static QString uidLabel();
    /**
      Set name.
     */
    void setName( const QString &name );
    /**
      Return name.
     */
    QString name() const;
    /**
      Return translated label for name field.
     */
    static QString nameLabel();
    /**
      Set formatted name.
     */
    void setFormattedName( const QString &formattedName );
-    void setDefaultFormattedName( const QString &formattedName );
    /**
      Return formatted name.
     */
    QString formattedName() const;
-    QString defaultFormattedName() const;
    /**
      Return translated label for formattedName field.
     */
    static QString formattedNameLabel();
-    static QString defaultFormattedNameLabel();
    /**
      Set family name.
     */
    void setFamilyName( const QString &familyName );
    /**
      Return family name.
     */
    QString familyName() const;
    /**
      Return translated label for familyName field.
     */
    static QString familyNameLabel();
    /**
      Set given name.
     */
    void setGivenName( const QString &givenName );
    /**
      Return given name.
     */
    QString givenName() const;
    /**
      Return translated label for givenName field.
     */
    static QString givenNameLabel();
    /**
      Set additional names.
     */
    void setAdditionalName( const QString &additionalName );
    /**
      Return additional names.
     */
    QString additionalName() const;
    /**
      Return translated label for additionalName field.
     */
    static QString additionalNameLabel();
    /**
      Set honorific prefixes.
     */
    void setPrefix( const QString &prefix );
    /**
      Return honorific prefixes.
     */
    QString prefix() const;
    /**
      Return translated label for prefix field.
     */
    static QString prefixLabel();
    /**
      Set honorific suffixes.
     */
    void setSuffix( const QString &suffix );
    /**
      Return honorific suffixes.
     */
    QString suffix() const;
    /**
      Return translated label for suffix field.
     */
    static QString suffixLabel();
    /**
      Set nick name.
     */
    void setNickName( const QString &nickName );
    /**
      Return nick name.
     */
    QString nickName() const;
    /**
      Return translated label for nickName field.
     */
    static QString nickNameLabel();
    /**
      Set birthday.
     */
    void setBirthday( const QDateTime &birthday );
    /**
      Return birthday.
     */
    QDateTime birthday() const;
    /**
      Return translated label for birthday field.
     */
    static QString birthdayLabel();
    /**
      Return translated label for homeAddressStreet field.
     */
    static QString homeAddressStreetLabel();
    /**
      Return translated label for homeAddressLocality field.
     */
    static QString homeAddressLocalityLabel();
    /**
      Return translated label for homeAddressRegion field.
     */
    static QString homeAddressRegionLabel();
    /**
      Return translated label for homeAddressPostalCode field.
     */
    static QString homeAddressPostalCodeLabel();
    /**
      Return translated label for homeAddressCountry field.
     */
    static QString homeAddressCountryLabel();
    /**
      Return translated label for homeAddressLabel field.
     */
    static QString homeAddressLabelLabel();
    /**
      Return translated label for businessAddressStreet field.
     */
    static QString businessAddressStreetLabel();
    /**
      Return translated label for businessAddressLocality field.
     */
    static QString businessAddressLocalityLabel();
    /**
      Return translated label for businessAddressRegion field.
     */
    static QString businessAddressRegionLabel();
    /**
      Return translated label for businessAddressPostalCode field.
     */
    static QString businessAddressPostalCodeLabel();
    /**
      Return translated label for businessAddressCountry field.
     */
    static QString businessAddressCountryLabel();
    /**
      Return translated label for businessAddressLabel field.
     */
    static QString businessAddressLabelLabel();
    /**
      Return translated label for homePhone field.
     */
    static QString homePhoneLabel();
    /**
      Return translated label for businessPhone field.
     */
    static QString businessPhoneLabel();
    /**
      Return translated label for mobilePhone field.
     */
    static QString mobilePhoneLabel();
    static QString mobileWorkPhoneLabel();
    static QString mobileHomePhoneLabel();
    /**
      Return translated label for homeFax field.
     */
    static QString homeFaxLabel();
    /**
      Return translated label for businessFax field.
     */
    static QString businessFaxLabel();
    /**
      Return translated label for carPhone field.
     */
    static QString carPhoneLabel();
    /**
      Return translated label for isdn field.
     */
    static QString isdnLabel();
    /**
      Return translated label for pager field.
     */
diff --git a/kabc/field.cpp b/kabc/field.cpp
index 5c561c3..fd51026 100644
--- a/kabc/field.cpp
+++ b/kabc/field.cpp
@@ -1,596 +1,590 @@
 /*** Warning! This file has been generated by the script makeaddressee ***/
 /*
    This file is part of libkabc.
    Copyright (c) 2002 Cornelius Schumacher <schumacher@kde.org>
    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Library General Public
    License as published by the Free Software Foundation; either
    version 2 of the License, or (at your option) any later version.
    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Library General Public License for more details.
    You should have received a copy of the GNU Library General Public License
    along with this library; see the file COPYING.LIB.  If not, write to
    the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
    Boston, MA 02111-1307, USA.
 */
 /*
 Enhanced Version of the file for platform independent KDE tools.
 Copyright (c) 2004 Ulf Schenk
 $Id$
 */
 #include <klocale.h>
 #include <kconfig.h>
 #include <kconfigbase.h>
 #include <kglobal.h>
 #include "field.h"
 #include "resource.h"
 using namespace KABC;
 class Field::FieldImpl
 {
  public:
    FieldImpl( int fieldId, int category = 0,
               const QString &label = QString::null,
               const QString &key = QString::null,
               const QString &app = QString::null )
      : mFieldId( fieldId ), mCategory( category ), mLabel( label ),
        mKey( key ), mApp( app ) {}
  
    enum FieldId
    {
      CustomField,
      FormattedName,
      FamilyName,
      GivenName,
      AdditionalName,
      Prefix,
      Suffix,
      NickName,
      Birthday,
      Category,
      HomeAddressStreet,
      HomeAddressLocality,
      HomeAddressRegion,
      HomeAddressPostalCode,
      HomeAddressCountry,
      HomeAddressLabel,
      BusinessAddressStreet,
      BusinessAddressLocality,
      BusinessAddressRegion,
      BusinessAddressPostalCode,
      BusinessAddressCountry,
      BusinessAddressLabel,
      HomePhone,
      BusinessPhone,
      MobilePhone,
      HomeFax,
      BusinessFax,
      CarPhone,
      Isdn,
      Pager,
      Email,
      Mailer,
      Title,
      Role,
      Organization,
      Note,
      Url,
      Resource,
      Sip,
-      DefaultFormattedName,
      MobileWorkPhone,
      MobileHomePhone
    };
    int fieldId() { return mFieldId; }
    int category() { return mCategory; }
    
    QString label() { return mLabel; }
    QString key() { return mKey; }
    QString app() { return mApp; }
    
  private:
    int mFieldId;
    int mCategory;
    QString mLabel;
    QString mKey;
    QString mApp;
 };
 Field::List Field::mAllFields;
 Field::List Field::mDefaultFields;
 Field::List Field::mCustomFields;
 Field::Field( FieldImpl *impl )
 {
  mImpl = impl;
 }
 Field::~Field()
 {
  delete mImpl;
 }
 QString Field::label()
 {
  switch ( mImpl->fieldId() ) {
    case FieldImpl::FormattedName:
      return Addressee::formattedNameLabel();
-    case FieldImpl::DefaultFormattedName:
-      return Addressee::defaultFormattedNameLabel();
    case FieldImpl::FamilyName:
      return Addressee::familyNameLabel();
    case FieldImpl::GivenName:
      return Addressee::givenNameLabel();
    case FieldImpl::AdditionalName:
      return Addressee::additionalNameLabel();
    case FieldImpl::Prefix:
      return Addressee::prefixLabel();
    case FieldImpl::Suffix:
      return Addressee::suffixLabel();
    case FieldImpl::NickName:
      return Addressee::nickNameLabel();
    case FieldImpl::Birthday:
      return Addressee::birthdayLabel();
    case FieldImpl::HomeAddressStreet:
      return Addressee::homeAddressStreetLabel();
    case FieldImpl::HomeAddressLocality:
      return Addressee::homeAddressLocalityLabel();
    case FieldImpl::HomeAddressRegion:
      return Addressee::homeAddressRegionLabel();
    case FieldImpl::HomeAddressPostalCode:
      return Addressee::homeAddressPostalCodeLabel();
    case FieldImpl::HomeAddressCountry:
      return Addressee::homeAddressCountryLabel();
    case FieldImpl::HomeAddressLabel:
      return Addressee::homeAddressLabelLabel();
    case FieldImpl::BusinessAddressStreet:
      return Addressee::businessAddressStreetLabel();
    case FieldImpl::BusinessAddressLocality:
      return Addressee::businessAddressLocalityLabel();
    case FieldImpl::BusinessAddressRegion:
      return Addressee::businessAddressRegionLabel();
    case FieldImpl::BusinessAddressPostalCode:
      return Addressee::businessAddressPostalCodeLabel();
    case FieldImpl::BusinessAddressCountry:
      return Addressee::businessAddressCountryLabel();
    case FieldImpl::BusinessAddressLabel:
      return Addressee::businessAddressLabelLabel();
    case FieldImpl::HomePhone:
      return Addressee::homePhoneLabel();
    case FieldImpl::BusinessPhone:
      return Addressee::businessPhoneLabel();
    case FieldImpl::MobilePhone:
      return Addressee::mobilePhoneLabel();
    case FieldImpl::MobileHomePhone:
      return Addressee::mobileHomePhoneLabel();
    case FieldImpl::MobileWorkPhone:
      return Addressee::mobileWorkPhoneLabel();
    case FieldImpl::HomeFax:
      return Addressee::homeFaxLabel();
    case FieldImpl::BusinessFax:
      return Addressee::businessFaxLabel();
    case FieldImpl::CarPhone:
      return Addressee::carPhoneLabel();
    case FieldImpl::Isdn:
      return Addressee::isdnLabel();
    case FieldImpl::Pager:
      return Addressee::pagerLabel();
    case FieldImpl::Email:
      return Addressee::emailLabel();
    case FieldImpl::Mailer:
      return Addressee::mailerLabel();
    case FieldImpl::Title:
      return Addressee::titleLabel();
    case FieldImpl::Role:
      return Addressee::roleLabel();
    case FieldImpl::Organization:
      return Addressee::organizationLabel();
    case FieldImpl::Note:
      return Addressee::noteLabel();
    case FieldImpl::Url:
      return Addressee::urlLabel();
    case FieldImpl::Resource:
      return Addressee::resourceLabel();
    case FieldImpl::Category:
      return Addressee::categoryLabel();
    case FieldImpl::Sip:
      return Addressee::sipLabel();
    case FieldImpl::CustomField:
      return mImpl->label();
    default:
      return i18n("Unknown Field");
  }
 }
 int Field::category()
 {
  return mImpl->category();
 }
 QString Field::categoryLabel( int category )
 {
  switch ( category ) {
    case All:
      return i18n("All");
    case Frequent:
      return i18n("Frequent");
    case Address:
      return i18n("Address");
    case Email:
      return i18n("Email");
    case Personal:
      return i18n("Personal");
    case Organization:
      return i18n("Organization");
    case CustomCategory:
      return i18n("Custom");
    default:
      return i18n("Undefined");
  }
 }
 QString Field::value( const KABC::Addressee &a )
 {
  switch ( mImpl->fieldId() ) {
    case FieldImpl::FormattedName:
      return a.formattedName();
-    case FieldImpl::DefaultFormattedName:
-      return a.defaultFormattedName();
    case FieldImpl::FamilyName:
      return a.familyName();
    case FieldImpl::GivenName:
      return a.givenName();
    case FieldImpl::AdditionalName:
      return a.additionalName();
    case FieldImpl::Prefix:
      return a.prefix();
    case FieldImpl::Suffix:
      return a.suffix();
    case FieldImpl::NickName:
      return a.nickName();
    case FieldImpl::Mailer:
      return a.mailer();
    case FieldImpl::Title:
      return a.title();
    case FieldImpl::Role:
      return a.role();
    case FieldImpl::Organization:
      return a.organization();
    case FieldImpl::Note:
      return a.note();
    case FieldImpl::Email:
      return a.preferredEmail();
    case FieldImpl::Birthday:
      if ( a.birthday().isValid() ) {
 //the generated code had the following format: return a.birthday().date().toString( Qt::ISODate );
 // But Qt::IsoDate was not specified.
 //       QString _oldFormat = KGlobal::locale()->dateFormat();
 //       KGlobal::locale()->setDateFormat("%Y-%m-%d"); // = Qt::ISODate
       QString dt = KGlobal::locale()->formatDate(a.birthday().date(), false, KLocale::ISODate);
 //       KGlobal::locale()->setDateFormat(_oldFormat);
       return dt;
     }
     else
        return QString::null;
    case FieldImpl::Url:
      return a.url().prettyURL();
 //US    
    case FieldImpl::Resource:
      return a.resource()->resourceName();
    case FieldImpl::Category:
        return a.categories().join(",");
    case FieldImpl::HomePhone:
      return a.phoneNumber( PhoneNumber::Home ).number();
    case FieldImpl::BusinessPhone:
      return a.phoneNumber( PhoneNumber::Work ).number();
    case FieldImpl::MobilePhone:
      return a.phoneNumber( PhoneNumber::Cell ).number();
    case FieldImpl::MobileWorkPhone:
      return a.phoneNumber( PhoneNumber::Cell  | PhoneNumber::Work ).number();
    case FieldImpl::MobileHomePhone:
      return a.phoneNumber( PhoneNumber::Cell | PhoneNumber::Home  ).number();
    case FieldImpl::HomeFax:
      return a.phoneNumber( PhoneNumber::Home | PhoneNumber::Fax ).number();
    case FieldImpl::BusinessFax:
      return a.phoneNumber( PhoneNumber::Work | PhoneNumber::Fax ).number();
    case FieldImpl::CarPhone:
      return a.phoneNumber( PhoneNumber::Car ).number();
    case FieldImpl::Isdn:
      return a.phoneNumber( PhoneNumber::Isdn ).number();
    case FieldImpl::Pager:
      return a.phoneNumber( PhoneNumber::Pager ).number();
    case FieldImpl::Sip:
      return a.phoneNumber( PhoneNumber::Sip ).number();
    case FieldImpl::HomeAddressStreet:
      return a.address( Address::Home ).street();
    case FieldImpl::HomeAddressLocality:
      return a.address( Address::Home ).locality();
    case FieldImpl::HomeAddressRegion:
      return a.address( Address::Home ).region();
    case FieldImpl::HomeAddressPostalCode:
      return a.address( Address::Home ).postalCode();
    case FieldImpl::HomeAddressCountry:
      return a.address( Address::Home ).country();
    case FieldImpl::BusinessAddressStreet:
      return a.address( Address::Work ).street();
    case FieldImpl::BusinessAddressLocality:
      return a.address( Address::Work ).locality();
    case FieldImpl::BusinessAddressRegion:
      return a.address( Address::Work ).region();
    case FieldImpl::BusinessAddressPostalCode:
      return a.address( Address::Work ).postalCode();
    case FieldImpl::BusinessAddressCountry:
      return a.address( Address::Work ).country();
    case FieldImpl::CustomField:
      return a.custom( mImpl->app(), mImpl->key() );
    default:
      return QString::null;
  }
 }
 bool Field::setValue( KABC::Addressee &a, const QString &value )
 {
  switch ( mImpl->fieldId() ) {
    case FieldImpl::FormattedName:
      a.setFormattedName( value );
      return true;
    case FieldImpl::FamilyName:
      a.setFamilyName( value );
      return true;
    case FieldImpl::GivenName:
      a.setGivenName( value );
      return true;
    case FieldImpl::AdditionalName:
      a.setAdditionalName( value );
      return true;
    case FieldImpl::Prefix:
      a.setPrefix( value );
      return true;
    case FieldImpl::Suffix:
      a.setSuffix( value );
      return true;
    case FieldImpl::NickName:
      a.setNickName( value );
      return true;
    case FieldImpl::Mailer:
      a.setMailer( value );
      return true;
    case FieldImpl::Title:
      a.setTitle( value );
      return true;
    case FieldImpl::Role:
      a.setRole( value );
      return true;
    case FieldImpl::Organization:
      a.setOrganization( value );
      return true;
    case FieldImpl::Note:
      a.setNote( value );
      return true;
    case FieldImpl::Birthday:
 //US
 //the generated code had the following format: return a.setBirthday( QDate::fromString( value, Qt::ISODate ) );
 // But Qt::IsoDate and QDate::fromString was not specified. Do I have the wrong QT version ?
      {
      QDate dt = KGlobal::locale()->readDate( value, "%Y-%m-%d");  // = Qt::ISODate
      a.setBirthday(dt);
      }
      return true;
    case FieldImpl::CustomField:
      a.insertCustom( mImpl->app(), mImpl->key(), value );
 //US never copy the resourcename back to the adressee. 
    case FieldImpl::Resource:
    default:
      return false;
  }
 }
 bool Field::isCustom()
 {
  return mImpl->fieldId() == FieldImpl::CustomField;
 }
 Field::List Field::allFields()
 {
  if ( mAllFields.isEmpty() ) {
    createField( FieldImpl::FormattedName, Frequent );
-    createField( FieldImpl::DefaultFormattedName, Frequent );
    createField( FieldImpl::FamilyName, Frequent );
    createField( FieldImpl::GivenName, Frequent );
    createField( FieldImpl::AdditionalName );
    createField( FieldImpl::Prefix );
    createField( FieldImpl::Suffix );
    createField( FieldImpl::NickName, Personal );
    createField( FieldImpl::Birthday, Personal );
    createField( FieldImpl::Category );
    createField( FieldImpl::HomeAddressStreet, Address|Personal );
    createField( FieldImpl::HomeAddressLocality, Address|Personal );
    createField( FieldImpl::HomeAddressRegion, Address|Personal );
    createField( FieldImpl::HomeAddressPostalCode, Address|Personal );
    createField( FieldImpl::HomeAddressCountry, Address|Personal );
    createField( FieldImpl::HomeAddressLabel, Address|Personal );
    createField( FieldImpl::BusinessAddressStreet, Address|Organization );
    createField( FieldImpl::BusinessAddressLocality, Address|Organization );
    createField( FieldImpl::BusinessAddressRegion, Address|Organization );
    createField( FieldImpl::BusinessAddressPostalCode, Address|Organization );
    createField( FieldImpl::BusinessAddressCountry, Address|Organization );
    createField( FieldImpl::BusinessAddressLabel, Address|Organization );
    createField( FieldImpl::HomePhone, Personal|Frequent );
    createField( FieldImpl::BusinessPhone, Organization|Frequent );
    createField( FieldImpl::MobilePhone, Frequent );
    createField( FieldImpl::MobileHomePhone, Frequent );
    createField( FieldImpl::MobileWorkPhone, Frequent );
    createField( FieldImpl::HomeFax );
    createField( FieldImpl::BusinessFax );
    createField( FieldImpl::CarPhone );
    createField( FieldImpl::Isdn );
    createField( FieldImpl::Pager );
    createField( FieldImpl::Email, Email|Frequent );
    createField( FieldImpl::Mailer, Email );
    createField( FieldImpl::Title, Organization );
    createField( FieldImpl::Role, Organization );
    createField( FieldImpl::Organization, Organization );
    createField( FieldImpl::Note );
    createField( FieldImpl::Url );
    createField( FieldImpl::Resource );
    createField( FieldImpl::Sip );
  }
  return mAllFields;
 }
 Field::List Field::defaultFields()
 {
  if ( mDefaultFields.isEmpty() ) {
    createDefaultField( FieldImpl::GivenName );
    createDefaultField( FieldImpl::FamilyName );
    createDefaultField( FieldImpl::Email );
  }
  return mDefaultFields;
 }
 void Field::createField( int id, int category )
 {
  mAllFields.append( new Field( new FieldImpl( id, category ) ) );
 }
 void Field::createDefaultField( int id, int category )
 {
  mDefaultFields.append( new Field( new FieldImpl( id, category ) ) );
 }
 void Field::deleteFields()
 {
  Field::List::ConstIterator it;
  for( it = mAllFields.begin(); it != mAllFields.end(); ++it ) {
    delete (*it);
  }
  mAllFields.clear();
  for( it = mDefaultFields.begin(); it != mDefaultFields.end(); ++it ) {
    delete (*it);
  }
  mDefaultFields.clear();
  for( it = mCustomFields.begin(); it != mCustomFields.end(); ++it ) {
    delete (*it);
  }
  mCustomFields.clear();
 }
 void Field::saveFields( const QString &identifier,
                        const Field::List &fields )
 {
  KConfig *cfg = KGlobal::config();
  KConfigGroupSaver( cfg, "KABCFields" );
  saveFields( cfg, identifier, fields );
 }
 void Field::saveFields( KConfig *cfg, const QString &identifier,
                        const Field::List &fields )
 {
  QValueList<int> fieldIds;
 //US
 //  qDebug("Field::saveFields to %s %s", cfg->getFileName().latin1(), identifier.latin1());
    
  int custom = 0;
  Field::List::ConstIterator it;
  for( it = fields.begin(); it != fields.end(); ++it ) {
 //US  
 //  qDebug("Field::saveFields field:%i", (*it)->mImpl->fieldId());
    
    fieldIds.append( (*it)->mImpl->fieldId() );
    if( (*it)->isCustom() ) {
      QStringList customEntry;
      customEntry << (*it)->mImpl->label();
      customEntry << (*it)->mImpl->key();
      customEntry << (*it)->mImpl->app();
      cfg->writeEntry( "KABC_CustomEntry_" + identifier + "_" +
                       QString::number( custom++ ), customEntry );
    }
  }
  cfg->writeEntry( identifier, fieldIds );
 }
 Field::List Field::restoreFields( const QString &identifier )
 {
 //US
 //  qDebug("Field::restoreFields, identifier: %s", identifier.latin1());
  
  KConfig *cfg = KGlobal::config();
  KConfigGroupSaver( cfg, "KABCFields" );
  cfg->setGroup( "KABCFields" );
  
  Field::List l = restoreFields( cfg, identifier );
  return l;
 }
 Field::List Field::restoreFields( KConfig *cfg, const QString &identifier )
 {
  QValueList<int> fieldIds = cfg->readIntListEntry( identifier);
 //US
 //  qDebug("Field::restoreFields from %s, identifier: %s", cfg->getFileName().latin1(), identifier.latin1());
  
  Field::List fields;
  int custom = 0;
  QValueList<int>::ConstIterator it;
  for( it = fieldIds.begin(); it != fieldIds.end(); ++it ) {
    FieldImpl *f = 0;
    if ( (*it) == FieldImpl::CustomField ) {
      QStringList customEntry = cfg->readListEntry( "KABC_CustomEntry_" +
                                                 identifier + "_" +
                                                 QString::number( custom++ ) );
      f = new FieldImpl( *it, CustomCategory, customEntry[ 0 ],
                         customEntry[ 1 ], customEntry[ 2 ] );
    } else {
      f = new FieldImpl( *it );
    }
    fields.append( new Field( f ) );
  }
  
  return fields;
 }
 bool Field::equals( Field *field )
 {
  bool sameId = ( mImpl->fieldId() == field->mImpl->fieldId() );
  if ( !sameId ) return false;
  if ( mImpl->fieldId() != FieldImpl::CustomField ) return true;
  
  return mImpl->key() == field->mImpl->key();
 }
 Field *Field::createCustomField( const QString &label, int category,
                                 const QString &key, const QString &app )
 {
  Field *field = new Field( new FieldImpl( FieldImpl::CustomField,
                                           category | CustomCategory,
                                           label, key, app ) );
 //US
 //  qDebug("Field::createCustomField label %s", label.latin1() );
  
  mCustomFields.append( field );
  return field;
 }
diff --git a/kalarmd/simplealarmdaemonimpl.cpp b/kalarmd/simplealarmdaemonimpl.cpp
index b3da428..294ce7d 100644
--- a/kalarmd/simplealarmdaemonimpl.cpp
+++ b/kalarmd/simplealarmdaemonimpl.cpp
@@ -1,251 +1,251 @@
 /*
    This file is part of the KOrganizer alarm daemon.
    Copyright (c) 2002 Cornelius Schumacher <schumacher@kde.org>
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 2 of the License, or
    (at your option) any later version.
    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
    GNU General Public License for more details.
    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
    As a special exception, permission is given to link this program
    with any edition of Qt, and distribute the resulting executable,
    without including the source code for Qt in the source distribution.
 */
 #include "simplealarmdaemonimpl.h"
 #include "alarmdialog.h"
 #include <qpopupmenu.h>
 #include <qapp.h>
 #include <qdir.h>
 #include <qfile.h>
 #include <qhbox.h>
 #include <qtimer.h>
 #include <qfile.h>
 #include <qdatetime.h>
 #include <qpushbutton.h>
 #include <qlayout.h>
 #include <qlineedit.h>
 #include <qdialog.h>
 #define protected public
 #include <qspinbox.h>
 #undef protected 
 #include <qtextstream.h> 
 #include <qtopia/qcopenvelope_qws.h> 
 #include <qtopia/alarmserver.h> 
 #include <stdlib.h>
 #include <stdio.h>
 #include <unistd.h>
 SimpleAlarmDaemonImpl::SimpleAlarmDaemonImpl( QWidget *parent )
    : QLabel( parent )
 {
    mAlarmDialog = new AlarmDialog( 0 );
    mPopUp = new QPopupMenu( this );
    mPopUp->insertItem( "What's Next?", this, SLOT ( showWN() ) );
    mPopUp->insertItem( "Next Days!", this, SLOT ( showKO() ) );
    mPopUp->insertSeparator();
-    mPopUp->insertItem( "What's Todo?", this, SLOT ( showTodo() ) );
+    mPopUp->insertItem( "Todo List", this, SLOT ( showTodo() ) );
    mPopUp->insertSeparator();
    mPopUp->insertItem( "Addresses", this, SLOT ( showAdd() ) );
    mPopUp->insertSeparator();
    mPopUp->insertItem( "Edit Journal", this, SLOT ( writeJournal() ) );
    mPopUp->insertItem( "New Event", this, SLOT ( newEvent() ) );
    mPopUp->insertItem( "New Todo", this, SLOT ( newTodo() ) );
    mPopUp->insertItem( "New Mail", this, SLOT ( newMail() ) );
    mPopUp->insertSeparator();
    mPopUp->insertItem( "Multi Sync", this, SLOT ( ringSync() ) );
    mTimerPopUp = new QPopupMenu( this );
    QFont fon = mTimerPopUp->font();
    fon.setPointSize( fon.pointSize() *3/2 );
    mTimerPopUp->setFont( fon );
    mBeepPopUp = new QPopupMenu( this );   
    mSoundPopUp = new QPopupMenu( this );   
    mPausePopUp = new QPopupMenu( this );    
    QPopupMenu* savePopUp = new QPopupMenu( this ); 
    savePopUp->insertItem( "Save", 0 );   
    savePopUp->insertItem( "Load", 1 );   
    mSoundPopUp->insertItem( "Buzzer", 0 );   
    mSoundPopUp->insertItem( "Wav file", 1 ); 
    mPausePopUp->insertItem( " 1 sec", 1 );
    mPausePopUp->insertItem( " 2 sec", 2 );
    mPausePopUp->insertItem( " 3 sec", 3 );
    mPausePopUp->insertItem( " 5 sec", 5 );
    mPausePopUp->insertItem( "10 sec", 10 );
    mPausePopUp->insertItem( "30 sec", 30 );
    mPausePopUp->insertItem( " 1 min", 60 );
    mPausePopUp->insertItem( " 5 min", 300 );
    mPausePopUp->insertItem( "10 min", 600 );
    mSuspendPopUp = new QPopupMenu( this );
    mSuspendPopUp->insertItem( "Off", 0 ); 
    mSuspendPopUp->insertItem( " 1x", 1 );   
    mSuspendPopUp->insertItem( " 2x", 2 );   
    mSuspendPopUp->insertItem( " 3x", 3 );  
    mSuspendPopUp->insertItem( " 5x", 5 );  
    mSuspendPopUp->insertItem( "10x", 10 );  
    mSuspendPopUp->insertItem( "20x", 20 );  
    mSuspendPopUp->insertItem( "30x", 30 );    
    mBeepPopUp->insertItem( "Auto  suspend",mSuspendPopUp  );
    mBeepPopUp->insertItem( "Beep interval",mPausePopUp  );
    mBeepPopUp->insertItem( "Replay",mSoundPopUp  );      
    mBeepPopUp->insertItem( "Config",savePopUp  );        
    mBeepPopUp->insertItem( "300", 300 );      
    mBeepPopUp->insertItem( "180", 180 );         
    mBeepPopUp->insertItem( "60", 60 );       
    mBeepPopUp->insertItem( "30", 30 );    
    mBeepPopUp->insertItem( "10", 10 ); 
    mBeepPopUp->insertItem( "3", 3 );   
    mBeepPopUp->insertItem( "1", 1 );   
    mBeepPopUp->insertItem( "Off", 0 ); 
    mBeepPopUp->setCheckable( true );
    mPopUp->insertSeparator();
    mPopUp->insertItem( "Play beeps", mBeepPopUp );
    mPopUp->insertSeparator();
    mPopUp->insertItem( "Timer", mTimerPopUp );
    mPopUp->insertSeparator();
    mPopUp->insertItem( "Simulate", this, SLOT ( simulate() ) );
 
    mPopUp->resize( mPopUp->sizeHint()  );
    mPlayBeeps = 60;
    mBeepPopUp->setItemChecked ( mPlayBeeps, true );
    connect ( mBeepPopUp, SIGNAL( activated ( int )  ), this, SLOT (slotPlayBeep( int ) ) );
    connect ( mTimerPopUp, SIGNAL( activated ( int )  ), this, SLOT (confTimer( int ) ) );
    connect ( mTimerPopUp, SIGNAL(aboutToShow()  ), this, SLOT ( showTimer( ) ) ); 
    connect ( mSoundPopUp, SIGNAL( activated ( int )  ), this, SLOT (confSound( int ) ) );
    connect ( mPausePopUp, SIGNAL( activated ( int )  ), this, SLOT (confPause( int ) ) );
    connect ( mSuspendPopUp, SIGNAL( activated ( int )  ), this, SLOT (confSuspend( int ) ) );  
    connect ( savePopUp, SIGNAL( activated ( int )  ), this, SLOT (saveSlot( int ) ) );
    mTimerTime = 0;
    mCustomText = "Custom Text";
    mCustomMinutes = 7;
    mTimerPopupConf = 1;
    fillTimerPopUp();
    mPausePlay = 0;
    confPause( 1 );
    mSuspend = 0;
    confSuspend( 0 );
    if ( QApplication::desktop()->width() < 480 ) {
        wavAlarm = false;
        mSoundPopUp->setItemChecked ( 0, true );
    }
    else {
        wavAlarm = true;
        mSoundPopUp->setItemChecked ( 1, true );
    }
    saveSlot( 1 );
 }
 SimpleAlarmDaemonImpl::~SimpleAlarmDaemonImpl()
 {
    //delete mPopUp;
    delete mAlarmDialog;
 }
 void SimpleAlarmDaemonImpl::saveSlot( int load )
 {
    QString fileName = QDir::homeDirPath() +"/.kopialarmrc";
    //qDebug("save %d ", load );
    QFile file( fileName );
    if ( load ) {
        if( !QFile::exists(  fileName) )
            return;
         if (!file.open( IO_ReadOnly ) ) {
            return ;
        } 
         QString line;
         bool ok;
         int val;
         int len;
         while ( file.readLine( line, 1024 ) > 0 ) {
             //qDebug("read %s  ", line.latin1());
             len = line.length();
             if ( line.left(4 ) == "PPAU" ) {
                 val = line.mid( 4,len-5).toInt( &ok );
                 if ( ok ) {
                     confPause( val );
                 }
             }
             if ( line.left(4 ) == "SUCO" )  {
                 val = line.mid( 4,len-5).toInt( &ok );
                 if ( ok )
                     confSuspend ( val );
             }
             if ( line.left(4 ) == "WAAL" )  {
                 val = line.mid( 4,len-5).toInt( &ok );
                 if ( ok )
                     confSound( val );
             }
             if ( line.left(4 ) == "PLBE" )  {
                 val = line.mid( 4,len-5).toInt( &ok );
                 if ( ok )
                     slotPlayBeep( val );
             }
             if ( line.left(4 ) == "CUTE" ) {
                 mCustomText = line.mid( 5,len-6);
                 // qDebug("text ***%s*** ",mCustomText.latin1() );
             } 
             if ( line.left(4 ) == "CUMI" )  {
                 val = line.mid( 4,len-5).toInt( &ok );
                 if ( ok )
                     mCustomMinutes = val;
             }
             if ( line.left(4 ) == "SUTI" )  {
                 val = line.mid( 4,len-5).toInt( &ok );
                 if ( ok )
                     mAlarmDialog->setSuspendTime( val );;
             }
         }
         file.close();
    } else {
        if (!file.open( IO_WriteOnly ) ) {
            return;
        } 
        QString configString ;
        configString += "PPAU " + QString::number( mPausePlay ) + "\n";
        configString += "SUCO " + QString::number( mSuspend ) + "\n";
        configString += "WAAL " + QString::number( wavAlarm ) + "\n";
        configString += "PLBE " + QString::number( mPlayBeeps ) + "\n";
        configString += "CUTE " + mCustomText + "\n";
        configString += "CUMI " + QString::number( mCustomMinutes ) + "\n";
        configString += "SUTI " + QString::number( mAlarmDialog->getSuspendTime( )) + "\n";
        QTextStream ts( &file );
        ts << configString ;
        file.close();
    }
 }
 void  SimpleAlarmDaemonImpl::confSuspend( int num )
 {
    mSuspendPopUp->setItemChecked ( mSuspend,false );
    mSuspend = num;
    mSuspendPopUp->setItemChecked ( mSuspend,true );
 }
 void  SimpleAlarmDaemonImpl::confPause( int num )
 {
    mPausePopUp->setItemChecked ( mPausePlay,false );
    mPausePlay = num;
    mPausePopUp->setItemChecked ( mPausePlay,true );
 }
 void  SimpleAlarmDaemonImpl::confSound( int num )
 {
    if ( num == 0 ) {
        wavAlarm = false;
        mSoundPopUp->setItemChecked ( 0, true );
        mSoundPopUp->setItemChecked ( 1, false );
    } else {
        wavAlarm = true;
diff --git a/korganizer/koagendaitem.cpp b/korganizer/koagendaitem.cpp
index 23afe7a..e545ca8 100644
--- a/korganizer/koagendaitem.cpp
+++ b/korganizer/koagendaitem.cpp
@@ -254,525 +254,533 @@ bool KOAgendaItem::updateIcons(QPainter * p, bool horLayout)
        }
    }
  return ( yOff || xOff );
 }
 void KOAgendaItem::select(bool selected)
 {
    //qDebug("select %d %d",firstMultiItem(), nextMultiItem() );
    if (mSelected == selected) return;
    mSelected = selected;
    if ( ! isVisible() )
        return;
    if ( firstMultiItem() )
        firstMultiItem()->select( selected );
    if ( !firstMultiItem() && nextMultiItem() ) {
        KOAgendaItem *  placeItem = nextMultiItem();
        while ( placeItem ) { 
            placeItem->select( selected );
            placeItem = placeItem->nextMultiItem();
        }  
    }
    globalFlagBlockAgendaItemUpdate = 0;
    paintMe( selected );
    globalFlagBlockAgendaItemUpdate = 1;
    repaint( false );
 }
 /*
  The eventFilter has to filter the mouse events of the agenda item childs. The
  events are fed into the event handling method of KOAgendaItem. This allows the
  KOAgenda to handle the KOAgendaItems by using an eventFilter.
 */
 bool KOAgendaItem::eventFilter ( QObject *object, QEvent *e )
 {
    if (e->type() == QEvent::MouseButtonPress ||
        e->type() == QEvent::MouseButtonDblClick ||
        e->type() == QEvent::MouseButtonRelease ||
        e->type() == QEvent::MouseMove) {
        QMouseEvent *me = (QMouseEvent *)e;
        QPoint itemPos = this->mapFromGlobal(((QWidget *)object)->
                                             mapToGlobal(me->pos()));
        QMouseEvent returnEvent (e->type(),itemPos,me->button(),me->state());
        return event(&returnEvent);
    } else {
        return false;
    }
 }
 void KOAgendaItem::repaintMe( )
 { 
    paintMe ( mSelected );
 }
 void KOAgendaItem::paintMe( bool selected, QPainter* paint )
 {    
    if ( globalFlagBlockAgendaItemUpdate && ! selected)
      return;
    QPainter pa;
    
    if ( mSelected ) {
        pa.begin( paintPixSel() );
    } else {
        if ( mAllDay )
            pa.begin( paintPixAllday() );
        else
            pa.begin( paintPix() );
    }
    int x, yy, w,  h;
    float nfh = 7.0;
    x = pos().x(); w = width(); h = height ();
    if ( mAllDay )
        yy = y();
    else
        yy = mCellYTop * ( height() / cellHeight() );
    xPaintCoord= x;
    yPaintCoord = yy;
    wPaintCoord = width();
    hPaintCoord = height();
    //qDebug("paintMe %s %d %d %d %d",incidence()->summary().latin1(), x, yy, width(), height());
    if ( paint == 0 )
        paint = &pa;
    bool horLayout = ( w < h );
    int maxhei = mFontPixelSize+4;
    if (  horLayout )
        maxhei +=  AGENDA_ICON_SIZE -4;
    bool small = ( h < maxhei  );
    if ( ! small ) 
        paint->setFont(KOPrefs::instance()->mAgendaViewFont);
    else {
        QFont f =  KOPrefs::instance()->mAgendaViewFont;
        f.setBold( false );
        int fh = f.pointSize();
        nfh = (((float)height())/(float)(mFontPixelSize+4))*fh;
        if ( nfh < 6 )
            nfh = 6;
        f.setPointSize( nfh );
        paint->setFont(f);
    }
    paint->fillRect ( x, yy,  w, h, mBackgroundColor );
    static const  QPixmap completedPxmp = SmallIcon("greenhook16");
    static const QPixmap overduePxmp = SmallIcon("redcross16");
    if ( mIncidence->type() == "Todo" ) {
        Todo* tempTodo = static_cast<Todo*>(mIncidence);
        int xx = pos().x()+(width()-completedPxmp.width()-3 );
        int yyy =  yy+3;
        if ( tempTodo->isCompleted() )
            paint->drawPixmap ( xx, yyy, completedPxmp );
        else {
            paint->drawPixmap ( xx, yyy, overduePxmp );
            
        }
    }
    bool addIcon = false;
    if ( ! small || w > 3 * h || h > 3* w )
       addIcon =  updateIcons(  paint, horLayout );
    qDrawShadePanel (paint, x,  yy,  w,  h, mColorGroup, selected , 2, 0);
    //qDebug("draw rect %d %d %d %d ",x,  yy,  w,  h );
    if ( ! small ) {
        x += 3; yy += 3;w -= 6;  h-= 5;
    } else {
        x += 2; yy += 1;w -= 4;  h-= 4; 
        if ( nfh < 6.01 ) {
            yy -= 2;
            h += 4;
        }
        else
            if ( nfh < h -2 )
                ++yy;
    }
    int align;
 #ifndef DESKTOP_VERSION
    align = ( AlignLeft|WordBreak|AlignTop);
 #else
    align = ( AlignLeft|BreakAnywhere|WordBreak|AlignTop);
 #endif
    if (  addIcon  ) {
        if ( ! horLayout ) {
            x += AGENDA_ICON_SIZE+3;
            w -= (AGENDA_ICON_SIZE+3);
        }
        else {
            yy+= AGENDA_ICON_SIZE+2;
            h -=(AGENDA_ICON_SIZE+3);
        }
    } 
    int colsum = mBackgroundColor.red() + mBackgroundColor.green() + mBackgroundColor.blue();
    if ( colsum < 250 )
        paint->setPen ( white); 
    if ( x < 0 ) {
        w = w+x-3;
        x = 3;
        if ( w > parentWidget()->width() ){
            w = parentWidget()->width() - 6;
 #ifndef DESKTOP_VERSION
    align = ( AlignHCenter|WordBreak|AlignTop);
 #else
    align = ( AlignHCenter|BreakAnywhere|WordBreak|AlignTop);
 #endif
        }
    }
    QRect dr;
    if ( w + x > parentWidget()->width() )
        w = parentWidget()->width()-x;
     paint->drawText ( x, yy, w, h, align, mDisplayedText, -1, &dr );
     //qDebug("%d %d %d %d ",   x, yy, w, h );
     if ( mIncidence->cancelled() ){
         small = ( height() < 20  );
        
         if ( ! small ) {
             QFontMetrics fm ( paint->font() );
             paint->drawLine(dr.left(), yy+fm.height()/2, dr.right()-2, yy+fm.height()/2);
         }
     }
    pa.end();
 
 }
 void KOAgendaItem::resizePixmap( int w , int h )
 {
    paintPix()->resize( w, h ); 
    paintPixSel()->resize( w, h ); 
 }
 QPixmap * KOAgendaItem::paintPix()
 {
    static QPixmap* mPaintPix = 0;
-    if ( ! mPaintPix )
+    if ( ! mPaintPix ) {
-        mPaintPix = new QPixmap(1,1);
+        int w = QApplication::desktop()->width();
+        int h = QApplication::desktop()->height();
+        mPaintPix = new QPixmap(w,h);
+    }
    return mPaintPix ; 
 }
 QPixmap * KOAgendaItem::paintPixAllday()
 {
    static QPixmap* mPaintPixA = 0;
-    if ( ! mPaintPixA ) 
+    if ( ! mPaintPixA ) {
-        mPaintPixA = new QPixmap(1,1);
+        int w = QApplication::desktop()->width();
+        int h = QApplication::desktop()->height()/3;
+        mPaintPixA = new QPixmap(w,h);
+    }
    return mPaintPixA ; 
 }
 QPixmap * KOAgendaItem::paintPixSel()
 {
    static QPixmap* mPaintPixSel = 0;
-    if ( ! mPaintPixSel )
+    if ( ! mPaintPixSel ) {
-        mPaintPixSel = new QPixmap(1,1);
+        int w = QApplication::desktop()->width();
+        int h = QApplication::desktop()->height();
+        mPaintPixSel = new QPixmap(w,h);
+    }
    return mPaintPixSel ; 
 }
 void KOAgendaItem::paintEvent ( QPaintEvent *e )
 {  
    if ( globalFlagBlockAgendaItemPaint )
        return; 
    if ( globalFlagBlockAgenda > 0 &&  globalFlagBlockAgenda < 5 )
      return;
    int yy;
    if ( mAllDay )
        yy = y();
    else
        yy = mCellYTop * ( height() / cellHeight() );
    int xx = x();
  
    if ( xPaintCoord != xx || yPaintCoord != yy || 
         wPaintCoord != width() ||  hPaintCoord != height()) {
        xPaintCoord= xx;
        yPaintCoord = yy;
        wPaintCoord = width();
        hPaintCoord = height();
        globalFlagBlockAgendaItemUpdate = 0;
        paintMe( mSelected );
        //qDebug("calling paintMe ");
        globalFlagBlockAgendaItemUpdate = 1;
    }
    int rx, ry, rw, rh;
    rx =  e->rect().x();
    ry =  e->rect().y();
    rw =  e->rect().width();
    rh =  e->rect().height();
    //qDebug("   paintevent %s %d %d    %d  %d", mIncidence->summary().latin1(), x(), yy, width(), height()); 
    QPixmap* paintFrom ;
    if ( mSelected ) {
        paintFrom =  paintPixSel();
    } else {
        if ( mAllDay )
            paintFrom =  paintPixAllday();
        else
            paintFrom =  paintPix();
    }
    xx += rx;
    if ( xx < 0 ) {
        rw = rw + xx;
        rx -= xx;
        xx = 0;
        if ( rw <= 1  ) {
            //qDebug("KOAgendaItem::Width1 <= 1 (%d). Returning. %s",rw,mDisplayedText.latin1());
            return;
        }
    }
    if ( paintFrom->width() <   xx+rw ) {
        rw =  paintFrom->width() - xx;
        if ( rw <= 1 ) {
            //qDebug("KOAgendaItem::Width2 <= 1 (%d). Returning.%s ",rw,mDisplayedText.latin1() );
            return;
        }
    }
    //qDebug("%d %d %d %d %d  %d %d",rx, ry, paintFrom, xx ,yPaintCoord+ry, rw, rh);
    bitBlt (this, rx, ry, paintFrom, xx ,yPaintCoord+ry, rw, rh ,CopyROP); 
 }
 void KOAgendaItem::computeText()
 {
- 
    mDisplayedText =  mIncidence->summary();
    if ( (mIncidence->type() == "Todo") ) {
        if ( static_cast<Todo*>(mIncidence)->hasDueDate() ) {
            if ( static_cast<Todo*>(mIncidence)->dtDue().date() < QDate::currentDate() )
                mDisplayedText += i18n(" (") +KGlobal::locale()->formatDate((static_cast<Todo*>(mIncidence))->dtDue().date(), true)+")";
            else if ( !(mIncidence->doesFloat()))
                mDisplayedText += i18n(" (") +KGlobal::locale()->formatTime((static_cast<Todo*>(mIncidence))->dtDue().time())+")";
        } 
    } else {
        if ( !(mIncidence->doesFloat()) &&  KOPrefs::instance()->mShowTimeInAgenda)
-            mDisplayedText += ": " +KGlobal::locale()->formatTime((static_cast<Event*>(mIncidence))->dtStart().time()) + "-" + KGlobal::locale()->formatTime((static_cast<Event*>(mIncidence))->dtEnd().time()) ;
+            mDisplayedText += ": " +KGlobal::locale()->formatTime((static_cast<Event*>(mIncidence))->dtStart().time()) + " - " + KGlobal::locale()->formatTime((static_cast<Event*>(mIncidence))->dtEnd().time()) ;
        if (  mAllDay ) {
            if ( mIncidence->dtStart().date().addDays(3) < mIncidence->dtEnd().date() ) {
                mDisplayedText += ": " +KGlobal::locale()->formatDate((static_cast<Event*>(mIncidence))->dtStart().date(), true) + " - " + KGlobal::locale()->formatDate((static_cast<Event*>(mIncidence))->dtEnd().date(), true) ;
            }
        }
    }
    
    if ( !mIncidence->location().isEmpty() ) {
        if ( mAllDay )
            mDisplayedText += " (";
        else
            mDisplayedText += "\n(";
        mDisplayedText += mIncidence->location() +")";
    }
+#ifdef DESKTOP_VERSION
    QString tipText = mIncidence->summary();
    if ( !mIncidence->doesFloat() ) {
        if ( mIncidence->type() == "Event" ) {
            if ( (static_cast<Event*>(mIncidence))->isMultiDay() ) {
                tipText += "\n"+i18n("From: ")+mIncidence->dtStartStr();
                tipText += "\n"+i18n("To: ")+(static_cast<Event*>(mIncidence))->dtEndStr();
            }
            else {
                tipText += "\n"+i18n("Time: ")+mIncidence->dtStartTimeStr();
                tipText += " - "+(static_cast<Event*>(mIncidence))->dtEndTimeStr();
            }
        }
        else if ( mIncidence->type() == "Todo" ) {
            if (mIncidence->hasStartDate())
                tipText += "\n"+i18n("Start: ")+ (static_cast<Todo*>(mIncidence))->dtStartStr();
            if (((Todo*)mIncidence)->hasDueDate())
                tipText += "\n"+i18n("Due: ")+ (static_cast<Todo*>(mIncidence))->dtDueStr();
        }
    } else if ( mIncidence->type() == "Todo" ) {
            if (mIncidence->hasStartDate())
                tipText += "\n"+i18n("Start: ")+ (static_cast<Todo*>(mIncidence))->dtStartDateStr();
            if (((Todo*)mIncidence)->hasDueDate())
                tipText += "\n"+i18n("Due: ")+ (static_cast<Todo*>(mIncidence))->dtDueDateStr();
        }
    if (!mIncidence->location().isEmpty()) {
        tipText += "\n"+i18n("Location: ")+mIncidence->location();
    }
    QToolTip::add(this,tipText,toolTipGroup(),""); 
+#endif
 }
 void KOAgendaItem::updateItem()
 {  
    computeText();
     
    //qDebug("KOAgendaItem:: updateItem() %s %d %d ",incidence()->summary().latin1(), x(), y());
    paintMe( mSelected );
    repaint( false);
 }
  
 void KOAgendaItem::resizeEvent ( QResizeEvent *ev )
 {
    //qDebug("KOAgendaItem::resizeEvent %s ",  mIncidence->summary().latin1());
    paintMe( mSelected );
    repaint( false );
 } 
 /*
  Return height of item in units of agenda cells
 */
 int KOAgendaItem::cellHeight()
 {
    int ret = mCellYBottom - mCellYTop + 1;
    if ( ret <= 0 ) {
        ret = 1;
        mCellYBottom = 0;
        mCellYTop = 0;
    }
    return ret;
 }
 /*
  Return height of item in units of agenda cells
 */
 int KOAgendaItem::cellWidth()
 {
    return mCellXWidth - mCellX + 1;
 }
 void KOAgendaItem::setItemDate(QDate qd)
 {
  mDate = qd;
 }
 void KOAgendaItem::setCellXY(int X, int YTop, int YBottom)
 {
  mCellX = X;
  mCellYTop = YTop;
  mCellYBottom = YBottom;
 }
 void KOAgendaItem::setCellXWidth(int xwidth)
 {
  mCellXWidth = xwidth;
 }
 void KOAgendaItem::setCellX(int XLeft, int XRight)
 {
  mCellX = XLeft;
  mCellXWidth = XRight;
 }
 void KOAgendaItem::setCellY(int YTop, int YBottom)
 {
  mCellYTop = YTop;
  mCellYBottom = YBottom;
 }
 void KOAgendaItem::setSubCell(int subCell)
 {
  mSubCell = subCell;
 }
 void KOAgendaItem::setSubCells(int subCells)
 {
  mSubCells = subCells;
 }
 void KOAgendaItem::setMultiItem(KOAgendaItem *first,KOAgendaItem *next,
                                KOAgendaItem *last)
 {
  mFirstMultiItem = first;
  mNextMultiItem = next;
  mLastMultiItem = last;
 }
 void KOAgendaItem::startMove()
 {
  mStartCellX = mCellX;
  mStartCellXWidth = mCellXWidth;
  mStartCellYTop = mCellYTop;
  mStartCellYBottom = mCellYBottom;
 }
 void KOAgendaItem::resetMove()
 {
  mCellX = mStartCellX;
  mCellXWidth = mStartCellXWidth;
  mCellYTop = mStartCellYTop;
  mCellYBottom = mStartCellYBottom;
 }
 void KOAgendaItem::moveRelative(int dx, int dy)
 {
  int newX = cellX() + dx;
  int newXWidth = cellXWidth() + dx;
  int newYTop = cellYTop() + dy;
  int newYBottom = cellYBottom() + dy;
  setCellXY(newX,newYTop,newYBottom);
  setCellXWidth(newXWidth);
 }
 void KOAgendaItem::expandTop(int dy)
 {
  int newYTop = cellYTop() + dy;
  int newYBottom = cellYBottom();
  if (newYTop > newYBottom) newYTop = newYBottom;
  setCellY(newYTop, newYBottom);
 }
 void KOAgendaItem::expandBottom(int dy)
 {
  int newYTop = cellYTop();
  int newYBottom = cellYBottom() + dy;
  if (newYBottom < newYTop) newYBottom = newYTop;
  setCellY(newYTop, newYBottom);
 }
 void KOAgendaItem::expandLeft(int dx)
 {
  int newX = cellX() + dx;
  int newXWidth = cellXWidth();
  if (newX > newXWidth) newX = newXWidth;
  setCellX(newX,newXWidth);
 }
 void KOAgendaItem::expandRight(int dx)
 {
  int newX = cellX();
  int newXWidth = cellXWidth() + dx;
  if (newXWidth < newX) newXWidth = newX;
  setCellX(newX,newXWidth);
 }
 QToolTipGroup *KOAgendaItem::toolTipGroup()
 {
  if (!mToolTipGroup) mToolTipGroup = new QToolTipGroup(0);
  return mToolTipGroup;
 }
 void KOAgendaItem::dragEnterEvent( QDragEnterEvent *e )
 {
 #ifndef KORG_NODND
  if ( ICalDrag::canDecode( e ) || VCalDrag::canDecode( e ) ||
       !QTextDrag::canDecode( e ) ) {
    e->ignore();
    return;
  }
  e->accept();
 #endif
 }
 void KOAgendaItem::dropEvent( QDropEvent *e )
 {
 #ifndef KORG_NODND
  QString text;
  if(QTextDrag::decode(e,text))
  {
    kdDebug() << "Dropped : " << text << endl;
    QStringList emails = QStringList::split(",",text);
    for(QStringList::ConstIterator it = emails.begin();it!=emails.end();++it) {
      kdDebug() << " Email: " << (*it) << endl;
      int pos = (*it).find("<");
      QString name = (*it).left(pos);
      QString email = (*it).mid(pos);
      if (!email.isEmpty()) {
        mIncidence->addAttendee(new Attendee(name,email));
      }
    }
  }
 #endif
 }
 QPtrList<KOAgendaItem> KOAgendaItem::conflictItems()
 {
  return mConflictItems;
 }
 void KOAgendaItem::setConflictItems(QPtrList<KOAgendaItem> ci)
 {
  mConflictItems = ci;
diff --git a/korganizer/komonthview.cpp b/korganizer/komonthview.cpp
index 4dfb9df..65d6acf 100644
--- a/korganizer/komonthview.cpp
+++ b/korganizer/komonthview.cpp
@@ -452,560 +452,573 @@ int MonthViewItem::width(const QListBox *lb) const
        return 10;
    //qDebug("ret wid %d ", lb->width());
    return lb->width();
 }
 MonthViewCell::MonthViewCell( KOMonthView *parent,QWidget* par )
    : KNoScrollListBox( par ),
      mMonthView( parent )
 {
    //QVBoxLayout *topLayout = new QVBoxLayout( this );
    currentPalette = 0; 
    // mLabel = new QLabel( this );QPushButton 
    mLabel = new QPushButton( this );
    //mLabel->setFrameStyle( QFrame::Panel | QFrame::Plain );
    //mLabel->setLineWidth( 1 );
    //mLabel->setAlignment( AlignCenter );
    mLabel->setFlat( true );
    mLabel->setFocusPolicy(NoFocus); 
    //mItemList = new KNoScrollListBox( this );
    setMinimumSize( 10, 10 );
    setFrameStyle( QFrame::Panel | QFrame::Plain );
    setLineWidth( 1 );
    //topLayout->addWidget( mItemList );
    mLabel->raise();
    // QColor( 0,0,255 )    QColor( 160,1600,255 )
    mStandardPalette = palette();
    mStandardPalette.setColor(QColorGroup::Base, mStandardPalette.color( QPalette::Normal, QColorGroup::Background ) );
    enableScrollBars( false );
    updateConfig();
    //connect( mLabel, SIGNAL( clicked( )), SLOT( newEvent() ));
    connect( mLabel, SIGNAL( clicked( )), SLOT( showDay() ));
    connect( this , SIGNAL( doubleClicked( QListBoxItem *) ),
             SLOT( defaultAction( QListBoxItem * ) ) );
    connect( this, SIGNAL( rightButtonPressed( QListBoxItem *,
                                                    const QPoint &) ),
             SLOT( contextMenu( QListBoxItem * ) ) );
    connect( this, SIGNAL( highlighted( QListBoxItem *) ),
             SLOT( selection( QListBoxItem * ) ) );
   
    /* 
    connect( this, SIGNAL( clicked( QListBoxItem * ) ),
             SLOT( selection( QListBoxItem * ) ) ); 
    */
 }
 #ifdef DESKTOP_VERSION
 QToolTipGroup *MonthViewCell::toolTipGroup()
 {
    if (!mToolTipGroup) mToolTipGroup = new QToolTipGroup(0);
    return mToolTipGroup;
 }
 #endif
 
 void MonthViewCell::setDate( const QDate &date )
 {
    //  kdDebug() << "MonthViewCell::setDate(): " << date.toString() << endl;
    mDate = date;
 
    //resizeEvent( 0 );
 }
 QDate MonthViewCell::date() const
 {
    return mDate;
 }
 void MonthViewCell::setPrimary( bool primary )
 {
    mPrimary = primary;
    //setMyPalette();
 }
 void MonthViewCell::setMyPalette()
 {
   
    if ( mHoliday) {
        if ( currentPalette == 1 ) return;
        mLabel->setPalette( QPalette ( mHolidayPalette.color( QPalette::Normal,QColorGroup::Base),mHolidayPalette.color(QPalette::Normal,QColorGroup::Base )  ));
        setPalette( mHolidayPalette );
        //mLabel->setPalette( mHolidayPalette );
        currentPalette = 1;
    } else {
        if ( mPrimary ) {
            if ( currentPalette == 2 ) return;
            mLabel->setPalette( QPalette ( mPrimaryPalette.color( QPalette::Normal,QColorGroup::Base),mPrimaryPalette.color(QPalette::Normal,QColorGroup::Base )  ));
            //mLabel->setPalette( mPrimaryPalette );
            setPalette( mPrimaryPalette );
            currentPalette = 2;
        } else {
            if ( currentPalette == 3 ) return;
            setPalette( mNonPrimaryPalette );
             mLabel->setPalette( QPalette ( mNonPrimaryPalette.color( QPalette::Normal,QColorGroup::Base),mNonPrimaryPalette.color(QPalette::Normal,QColorGroup::Base )  ));
             //mLabel->setPalette( mNonPrimaryPalette );;
             currentPalette = 3;
        }
    }
    //QPalette pal = palette();
    
    //mLabel->setPalette( QPalette ( pal.color( QPalette::Normal,QColorGroup::Base),pal.color(QPalette::Normal,QColorGroup::Base )  ));
 }
 QPalette  MonthViewCell::getPalette ()
 {
    if ( !KOPrefs::instance()->mMonthViewUsesDayColors )
        return mStandardPalette;
    if ( mHoliday) {
        return mHolidayPalette ;
    } else {
        if ( mPrimary ) {
            return mPrimaryPalette ;
        } 
    }
    return mNonPrimaryPalette; 
 }
 bool MonthViewCell::isPrimary() const
 {
    return mPrimary;
 }
 void MonthViewCell::setHoliday( bool holiday )
 {
    mHoliday = holiday; 
    //setMyPalette();
 }
 void MonthViewCell::setHoliday( const QString &holiday )
 {
    mHolidayString = holiday;
    if ( !holiday.isEmpty() ) {
        setHoliday( true );
    }
 }
 void MonthViewCell::startUpdateCell()
 {
    mdayCount = 0;
    setFocusPolicy(NoFocus); 
    if ( !mMonthView->isUpdatePossible() )
        return;
    MonthViewItem *mitem = (MonthViewItem*) firstItem ();
    while ( mitem ) {
        mitem->setBlockRepaint( true );
        mitem = (MonthViewItem *)mitem->next();
    }
    if ( mAvailItemList.count() > 20 ) {
        mAvailItemList.setAutoDelete( true );
        mAvailItemList.clear();
        mAvailItemList.setAutoDelete( false );
    }
    /*    
          if ( !isVisible() ){
          return;
          }
    */
    // qDebug("MonthViewCell::updateCell() ");
    setPrimary( mDate.month()%2 );
    setHoliday( KOGlobals::self()->calendarSystem()->dayOfWeek(mDate) == KOGlobals::self()->calendarSystem()->weekDayOfPray() || ( mDate.dayOfWeek() == 6 ) && KOPrefs::instance()-> mExcludeSaturdays);
    if ( mDate == QDate::currentDate()  ) {
        setLineWidth( 3 );
    } else {
        setLineWidth( 1 );
    }
    MonthViewItem* CurrentAvailItem = (MonthViewItem*) firstItem ();
    //clear(); 
    while ( CurrentAvailItem ) {
            MonthViewItem *item = CurrentAvailItem;
            CurrentAvailItem = (MonthViewItem *)item->next();
            mAvailItemList.append( item ); 
            takeItem ( item );
    }
 #ifdef DESKTOP_VERSION
    QToolTip::remove(this); 
 #endif 
    mToolTip.clear(); 
    //qApp->processEvents();
 #if 0
    if ( !mHolidayString.isEmpty() ) {
        MonthViewItem *item = new MonthViewItem( 0, mDate, mHolidayString );
        item->setPalette( mHolidayPalette );
        insertItem( item );
        mToolTip.append ( mHolidayString ); 
    }
 #endif
 }
 int MonthViewCell::insertEvent(Event *event)
 {
+    bool useToolTips = true;
+#ifndef DEKSTOP_VERSION
+    useToolTips = false;
+#endif    
    QString mToolTipText;
    setFocusPolicy(WheelFocus); 
        if ( !(event->doesRecur() == Recurrence::rNone) ) {
            if ( !KOPrefs::instance()->mMonthDailyRecur && event->doesRecur() == Recurrence::rDaily )
                return mdayCount;
            else
                if ( !KOPrefs::instance()->mMonthWeeklyRecur && event->doesRecur() == Recurrence::rWeekly )
                    return mdayCount;
        }
        
        if ( event->isHoliday()) {
            setHoliday( true );
            if ( mDate.dayOfWeek() == 7 )
                setLineWidth( 3 );
        }
        QString text;
        int multiday = 0;// 1 = start, 2 = midddle, 3 = end day
        if (event->isMultiDay()) {
            QString prefix = "<->";multiday = 2; 
            QString time;
            if ( event->doesRecur() ) {
                if ( event->recursOn( mDate) ) {
                    prefix ="->" ;multiday = 1;
                }
                else {
                    int days =  event->dtStart().date().daysTo ( event->dtEnd().date() );
                    if ( event->recursOn( mDate.addDays( -days)) ) {
                        prefix ="<-" ;multiday = 3;
                    }
                } 
            } else {
                if (mDate == event->dtStart().date()) {
                    prefix ="->" ;multiday = 1;
                } else if (mDate == event->dtEnd().date()) {
                    prefix ="<-" ;multiday = 3;
                }
            }
            if ( !event->doesFloat() ) {
                if ( mDate == event->dtStart().date () )
                    time = KGlobal::locale()->formatTime(event->dtStart().time())+" ";
                else if ( mDate == event->dtEnd().date () )
                    time = KGlobal::locale()->formatTime(event->dtEnd().time())+" ";
            }
            text = time + event->summary();
-            mToolTipText += prefix + text;
+            if ( useToolTips )
+                mToolTipText += prefix + text;
        } else {
            if (event->doesFloat()) {
                text = event->summary();
-                mToolTipText += text;
+                if ( useToolTips )
+                    mToolTipText += text;
            }
            else {
                text = KGlobal::locale()->formatTime(event->dtStart().time());
                text += " " + event->summary();
-                mToolTipText +=  KGlobal::locale()->formatTime(event->dtStart().time()) +"-"+KGlobal::locale()->formatTime(event->dtEnd().time())+" " + event->summary();
+                if ( useToolTips )
+                    mToolTipText +=  KGlobal::locale()->formatTime(event->dtStart().time()) +"-"+KGlobal::locale()->formatTime(event->dtEnd().time())+" " + event->summary();
            }
        }
+        if ( useToolTips && ! event->location().isEmpty() ) {
+            mToolTipText += " (" + event->location() +")";
+        }
        MonthViewItem *item ;
        
        if ( mAvailItemList.count() ) {
            item = mAvailItemList.first();
            mAvailItemList.remove( item );
            item->recycle( event, mDate, text );
        } else {
            item = new MonthViewItem( event, mDate, text );
        }
        
        QPalette pal;
        if (KOPrefs::instance()->mMonthViewUsesCategoryColor) {    
            QStringList categories = event->categories();
            QString cat = categories.first();
            if ( KOPrefs::instance()->mMonthViewUsesForegroundColor ) {
                pal = getPalette();
                if (cat.isEmpty()) {
                    pal.setColor(QColorGroup::Foreground,KOPrefs::instance()->mEventColor);
                } else {
                    pal.setColor(QColorGroup::Foreground, *(KOPrefs::instance()->categoryColor(cat)));
                }
            } else {
                if (cat.isEmpty()) {
                    pal = QPalette(KOPrefs::instance()->mEventColor, KOPrefs::instance()->mEventColor);
                } else {
                    pal = QPalette(*(KOPrefs::instance()->categoryColor(cat)), *(KOPrefs::instance()->categoryColor(cat)));
                } 
            }
           
        } else {
            pal = mStandardPalette ;
        }
        item->setPalette( pal );
        item->setRecur( event->recurrence()->doesRecur() );
        item->setAlarm( event->isAlarmEnabled() && multiday < 2 );
        item->setMoreInfo( event->description().length() > 0  );
 #ifdef DESKTOP_VERSION
        Attendee *me = event->attendeeByMails(KOPrefs::instance()->mAdditionalMails,
                                              KOPrefs::instance()->email());
        if ( me != 0 ) {
            if ( me->status() == Attendee::NeedsAction && me->RSVP())
                item->setReply(true && multiday < 2);
            else
                item->setReply(false);
        } else
            item->setReply(false);
 #endif
        item->setMultiDay( multiday );
        if ( multiday ) {
            insertItem( item ,mdayCount);
            ++mdayCount;
        } else {
            uint i;
            int pos = mdayCount;
            for ( i = mdayCount; i < count();++i ) {
                QListBoxItem* it = this->item ( i );
                if ( text < it->text() ) {
                    pos = i;
                    break;
                }
                ++pos;
            }
            insertItem( item ,pos);
        }
-        mToolTip.append( mToolTipText );
+        if ( useToolTips )
+            mToolTip.append( mToolTipText );
        return mdayCount;
 }
 void MonthViewCell::insertTodo(Todo *todo)
 {
    setFocusPolicy(WheelFocus); 
      QString text;
        if (todo->hasDueDate()) {
            if (!todo->doesFloat()) {
                text += KGlobal::locale()->formatTime(todo->dtDue().time());
                text += " ";
            }
        }
        text += todo->summary();
        MonthViewItem *item ;
        if ( mAvailItemList.count() ) {
            item = mAvailItemList.first();
            mAvailItemList.remove( item );
            item->recycle( todo, mDate, text );
        } else {
            item = new MonthViewItem( todo, mDate, text );
        }
        //MonthViewItem *item = new MonthViewItem( todo, mDate, text );
        //item->setPalette( mStandardPalette );
        QPalette pal;
        if (KOPrefs::instance()->mMonthViewUsesCategoryColor) {    
            QStringList categories = todo->categories();
            QString cat = categories.first();
            if ( KOPrefs::instance()->mMonthViewUsesForegroundColor ) {
                pal = getPalette();
                if (cat.isEmpty()) {
                    pal.setColor(QColorGroup::Foreground,KOPrefs::instance()->mEventColor);
                } else {
                    pal.setColor(QColorGroup::Foreground, *(KOPrefs::instance()->categoryColor(cat)));
                }
            } else {
                if (cat.isEmpty()) {
                    pal = QPalette(KOPrefs::instance()->mEventColor, KOPrefs::instance()->mEventColor);
                } else {
                    pal = QPalette(*(KOPrefs::instance()->categoryColor(cat)), *(KOPrefs::instance()->categoryColor(cat)));
                } 
            }
           
        } else {
            pal = mStandardPalette ;
        }
        item->setPalette( pal );
        item->setRecur( todo->recurrence()->doesRecur() );
        item->setAlarm( todo->isAlarmEnabled() );
        item->setMoreInfo( todo->description().length() > 0  );
        insertItem( item , count());
+#ifdef DESKTOP_VERSION
        mToolTip.append( text ); 
+#endif
 }
 void MonthViewCell::repaintfinishUpdateCell()
 {
    MonthViewItem *mitem = (MonthViewItem*) firstItem ();
    while ( mitem ) {
        mitem->setBlockRepaint( false );
        updateItem ( mitem );
        mitem = (MonthViewItem *)mitem->next();
    }
 }
 void MonthViewCell::finishUpdateCell()
 {
   
    
 #ifdef DESKTOP_VERSION
    if (mToolTip.count() > 0 ) {
        mToolTip.sort();
        QToolTip::add(this,mToolTip.join("\n"),toolTipGroup(),"");
    }
 #endif
    //sort();
    //setMyPalette(); 
    setMyPalette();
  
    resizeEvent( 0 ); 
 }
 void MonthViewCell::updateCell()
 {
    //qDebug("MonthViewCell::updateCell() ");
    if ( !mMonthView->isUpdatePossible() )
        return;
    startUpdateCell();
    //mLabel->setMaximumWidth( width() - mItemList->lineWidth()*2);
    QPtrList<Event> events = mMonthView->calendar()->events( mDate, true );
    Event *event;
    for( event = events.first(); event; event = events.next() ) { // for event
        insertEvent(event);
    }
    // insert due todos
    QPtrList<Todo> todos = mMonthView->calendar()->todos( mDate );
    Todo *todo;
    for(todo = todos.first(); todo; todo = todos.next()) {
        insertTodo( todo );
    }
    finishUpdateCell();
    // if ( isVisible())
    //qApp->processEvents();
 }
 void MonthViewCell::updateConfig( bool bigFont ) // = false
 {
    if ( bigFont ) {
        QFont fo = KOPrefs::instance()->mMonthViewFont;
        int ps = fo.pointSize() + 2;
        if ( ps < 18 )
            ps += 2;
        fo.setPointSize( ps ); 
        setFont( fo );
    } else
        setFont( KOPrefs::instance()->mMonthViewFont );
    QFontMetrics fm( font() );
    mLabelSize = fm.size( 0, "30" ) + QSize( 4, 2 );
    mLabelBigSize = fm.size( 0, "Mag 30" ) + QSize( 2, 2 );
    mHolidayPalette = mStandardPalette;
    mPrimaryPalette = mStandardPalette;
    mNonPrimaryPalette = mStandardPalette;
    if ( KOPrefs::instance()->mMonthViewUsesDayColors ) {
        mHolidayPalette.setColor(QColorGroup::Base, KOPrefs::instance()->mMonthViewHolidayColor  );
        mHolidayPalette.setColor(QColorGroup::Background, KOPrefs::instance()->mMonthViewHolidayColor  );
        mHolidayPalette.setColor(QColorGroup::Foreground,  KOPrefs::instance()->mMonthViewHolidayColor.dark());
        mPrimaryPalette.setColor(QColorGroup::Foreground,KOPrefs::instance()->mMonthViewOddColor.dark());
        mPrimaryPalette.setColor(QColorGroup::Base,KOPrefs::instance()->mMonthViewOddColor);
        mPrimaryPalette.setColor(QColorGroup::Background,KOPrefs::instance()->mMonthViewOddColor);
        mNonPrimaryPalette.setColor(QColorGroup::Foreground,KOPrefs::instance()->mMonthViewEvenColor.dark());
        mNonPrimaryPalette.setColor(QColorGroup::Base,KOPrefs::instance()->mMonthViewEvenColor); 
        mNonPrimaryPalette.setColor(QColorGroup::Background,KOPrefs::instance()->mMonthViewEvenColor); 
    }
    //updateCell(); 
 }
 void MonthViewCell::enableScrollBars( bool enabled )
 {
    
    return;
    if ( enabled ) {
        QListBoxItem *fi =  firstItem ();
        if (fi ) {
            int ihei = fi->height( this );
            int hei = numRows ()  * ihei;
            if ( hei < height() - horizontalScrollBar()->height () ) {
                setVScrollBarMode(QScrollView::AlwaysOff);
            }
            else 
                setVScrollBarMode(QScrollView::Auto);
            if ( ihei *3 > height() ) {
                setHScrollBarMode(QScrollView::AlwaysOff);
            }
            else {
                setHScrollBarMode(QScrollView::Auto);
            }
        } else {
            setVScrollBarMode(QScrollView::Auto);
            setHScrollBarMode(QScrollView::Auto);
        }
    } else {
        setVScrollBarMode(QScrollView::AlwaysOff);
        setHScrollBarMode(QScrollView::AlwaysOff);
    }
 }
 Incidence *MonthViewCell::selectedIncidence()
 {
    int index = currentItem();
    if ( index < 0 ) return 0;
  
    MonthViewItem *mitem =
        static_cast<MonthViewItem *>( item( index ) );
    if ( !mitem ) return 0;
  
    return mitem->incidence();
 }
 QDate MonthViewCell::selectedIncidenceDate()
 {
    QDate qd;
    int index = currentItem();
    if ( index < 0 ) return qd;
  
    MonthViewItem *mitem =
        static_cast<MonthViewItem *>( item( index ) );
    if ( !mitem ) return qd;
  
    return mitem->incidenceDate();
 }
 void MonthViewCell::deselect()
 {
    clearSelection();
    enableScrollBars( false );
    // updateCell();
 }
 void MonthViewCell::select()
 {
    ;// updateCell();
 }
 void MonthViewCell::resizeEvent ( QResizeEvent * e )
 {
    if ( !mMonthView->isUpdatePossible() )
        return;
    //qDebug("++++++++++++++MonthViewCell::resizeEvent %d %d ", width(), height());
    deselect();
    mLabel->setMaximumHeight( height() - lineWidth()*2 );
    
    QString text;
    mLabel->setText( text );
    bool smallDisplay = QApplication::desktop()->width() < 320 && KOPrefs::instance()->mMonthViewSatSunTog;
    if ( KOPrefs::instance()->mMonthViewWeek || KOGlobals::self()->calendarSystem()->day( mDate ) == 1 || (mDate.dayOfWeek() == 7 && !smallDisplay ) || KOPrefs::instance()->mMonthShowShort) { 
        text = KOGlobals::self()->calendarSystem()->monthName( mDate, true ) + " ";
        mLabel->resize( mLabelBigSize  );
        text += QString::number( KOGlobals::self()->calendarSystem()->day(mDate) );
    } else {
        mLabel->resize( mLabelSize );
        text += QString::number( KOGlobals::self()->calendarSystem()->day(mDate) );
    }
    mLabel->setText( text );
    int size = height() - mLabel->height() - lineWidth()-1;
    //qDebug("LW %d ", lineWidth());
    if ( size > 0 )
        verticalScrollBar()->setMaximumHeight( size );
    size = width() - mLabel->width() -lineWidth()-1;
    if ( size > 0 )
        horizontalScrollBar()->setMaximumWidth( size );
    mLabel->move( width()-lineWidth() - mLabel->width(), height()-lineWidth() - mLabel->height() );
    //mLabel->setMaximumWidth( width() - mItemList->lineWidth()*2);
    // mItemList->resize ( width(), height () ); 
    if ( e )
        KNoScrollListBox::resizeEvent (  e );
 }
 void MonthViewCell::defaultAction( QListBoxItem *item )
 {
  
    if ( !item ) {
        QDateTime dt( date(), QTime( KOPrefs::instance()->mStartTime, 0 ) );