9 files changed, 29 insertions, 4 deletions
diff --git a/kabc/addressee.cpp b/kabc/addressee.cpp
index d484073..6b282e2 100644
--- a/kabc/addressee.cpp
+++ b/kabc/addressee.cpp
@@ -291,384 +291,388 @@ void Addressee::setPrefix( const QString &prefix )
  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");
 }
 QString Addressee::businessAddressCountryLabel()
 {
  return i18n("Business Address Country");
 }
 QString Addressee::businessAddressLabelLabel()
 {
  return i18n("Business Address Label");
 }
 QString Addressee::homePhoneLabel()
 {
  return i18n("Home Phone");
 }
 QString Addressee::businessPhoneLabel()
 {
  return i18n("Business Phone");
 }
 QString Addressee::mobilePhoneLabel()
 {
  return i18n("Mobile Phone");
 }
 QString Addressee::homeFaxLabel()
 {
  return i18n("Home Fax");
 }
 QString Addressee::businessFaxLabel()
 {
  return i18n("Business Fax");
 }
 QString Addressee::carPhoneLabel()
 {
  return i18n("Car Phone");
 }
 QString Addressee::isdnLabel()
 {
  return i18n("ISDN");
 }
 QString Addressee::pagerLabel()
 {
  return i18n("Pager");
 }
+QString Addressee::sipLabel()
+{
+  return i18n("SIP");
+}
 QString Addressee::emailLabel()
 {
  return i18n("Email Address");
 }
 void Addressee::setMailer( const QString &mailer )
 {
  if ( mailer == mData->mailer ) return;
  detach();
  mData->empty = false;
  mData->mailer = mailer;
 }
 QString Addressee::mailer() const
 {
  return mData->mailer;
 }
 QString Addressee::mailerLabel()
 {
  return i18n("Mail Client");
 }
 void Addressee::setTimeZone( const TimeZone &timeZone )
 {
  if ( timeZone == mData->timeZone ) return;
  detach();
  mData->empty = false;
  mData->timeZone = timeZone;
 }
 TimeZone Addressee::timeZone() const
 {
  return mData->timeZone;
 }
 QString Addressee::timeZoneLabel()
 {
  return i18n("Time Zone");
 }
 void Addressee::setGeo( const Geo &geo )
 {
  if ( geo == mData->geo ) return;
  detach();
  mData->empty = false;
  mData->geo = geo;
 }
 Geo Addressee::geo() const
 {
  return mData->geo;
 }
 QString Addressee::geoLabel()
 {
  return i18n("Geographic Position");
 }
 void Addressee::setTitle( const QString &title )
 {
  if ( title == mData->title ) return;
  detach();
  mData->empty = false;
  mData->title = title;
 }
 QString Addressee::title() const
 {
  return mData->title;
 }
 QString Addressee::titleLabel()
 {
  return i18n("Title");
 }
 void Addressee::setRole( const QString &role )
 {
  if ( role == mData->role ) return;
  detach();
  mData->empty = false;
  mData->role = role;
 }
 QString Addressee::role() const
 {
  return mData->role;
 }
 QString Addressee::roleLabel()
 {
  return i18n("Role");
 }
 void Addressee::setOrganization( const QString &organization )
 {
  if ( organization == mData->organization ) return;
  detach();
  mData->empty = false;
  mData->organization = organization;
 }
 QString Addressee::organization() const
 {
  return mData->organization;
 }
 QString Addressee::organizationLabel()
 {
  return i18n("Organization");
 }
 void Addressee::setNote( const QString &note )
 {
  if ( note == mData->note ) return;
  detach();
  mData->empty = false;
  mData->note = note;
 }
 QString Addressee::note() const
 {
  return mData->note;
 }
 QString Addressee::noteLabel()
 {
  return i18n("Note");
 }
 void Addressee::setProductId( const QString &productId )
 {
  if ( productId == mData->productId ) return;
  detach();
  mData->empty = false;
  mData->productId = productId;
 }
 QString Addressee::productId() const
 {
  return mData->productId;
 }
 QString Addressee::productIdLabel()
 {
  return i18n("Product Identifier");
 }
 void Addressee::setRevision( const QDateTime &revision )
 {
  if ( revision == mData->revision ) return;
  detach();
  mData->empty = false;
  mData->revision = revision;
 }
 QDateTime Addressee::revision() const
 {
  return mData->revision;
 }
 QString Addressee::revisionLabel()
 {
  return i18n("Revision Date");
 }
 void Addressee::setSortString( const QString &sortString )
 {
  if ( sortString == mData->sortString ) return;
  detach();
  mData->empty = false;
  mData->sortString = sortString;
 }
 QString Addressee::sortString() const
 {
  return mData->sortString;
 }
 QString Addressee::sortStringLabel()
diff --git a/kabc/addressee.h b/kabc/addressee.h
index 393d1cc..27782f9 100644
--- a/kabc/addressee.h
+++ b/kabc/addressee.h
@@ -144,384 +144,389 @@ class Addressee
    /**
      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();
    /**
      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.
     */
    static QString pagerLabel();
    /**
+      Return translated label for sip field.
+     */
+    static QString sipLabel();
+    /**
      Return translated label for email field.
     */
    static QString emailLabel();
    /**
      Set mail client.
     */
    void setMailer( const QString &mailer );
    /**
      Return mail client.
     */
    QString mailer() const;
    /**
      Return translated label for mailer field.
     */
    static QString mailerLabel();
    /**
      Set time zone.
     */
    void setTimeZone( const TimeZone &timeZone );
    /**
      Return time zone.
     */
    TimeZone timeZone() const;
    /**
      Return translated label for timeZone field.
     */
    static QString timeZoneLabel();
    /**
      Set geographic position.
     */
    void setGeo( const Geo &geo );
    /**
      Return geographic position.
     */
    Geo geo() const;
    /**
      Return translated label for geo field.
     */
    static QString geoLabel();
    /**
      Set title.
     */
    void setTitle( const QString &title );
    /**
      Return title.
     */
    QString title() const;
    /**
      Return translated label for title field.
     */
    static QString titleLabel();
    /**
      Set role.
     */
    void setRole( const QString &role );
    /**
      Return role.
     */
    QString role() const;
    /**
      Return translated label for role field.
     */
    static QString roleLabel();
    /**
      Set organization.
     */
    void setOrganization( const QString &organization );
    /**
      Return organization.
     */
    QString organization() const;
    /**
      Return translated label for organization field.
     */
    static QString organizationLabel();
    /**
      Set note.
     */
    void setNote( const QString &note );
    /**
      Return note.
     */
    QString note() const;
    /**
      Return translated label for note field.
     */
    static QString noteLabel();
    /**
      Set product identifier.
     */
    void setProductId( const QString &productId );
    /**
      Return product identifier.
     */
    QString productId() const;
    /**
      Return translated label for productId field.
     */
    static QString productIdLabel();
    /**
      Set revision date.
     */
    void setRevision( const QDateTime &revision );
    /**
      Return revision date.
     */
    QDateTime revision() const;
    /**
      Return translated label for revision field.
     */
    static QString revisionLabel();
    /**
      Set sort string.
     */
    void setSortString( const QString &sortString );
    /**
      Return sort string.
     */
    QString sortString() const;
    /**
      Return translated label for sortString field.
     */
    static QString sortStringLabel();
    /**
      Set URL.
     */
    void setUrl( const KURL &url );
    /**
      Return URL.
     */
    KURL url() const;
    /**
      Return translated label for url field.
     */
    static QString urlLabel();
    /**
      Set security class.
     */
    void setSecrecy( const Secrecy &secrecy );
    /**
      Return security class.
     */
    Secrecy secrecy() const;
    /**
      Return translated label for secrecy field.
     */
    static QString secrecyLabel();
    /**
      Set logo.
     */
    void setLogo( const Picture &logo );
    /**
      Return logo.
     */
    Picture logo() const;
    /**
      Return translated label for logo field.
     */
    static QString logoLabel();
    /**
      Set photo.
     */
    void setPhoto( const Picture &photo );
    /**
      Return photo.
     */
    Picture photo() const;
    /**
      Return translated label for photo field.
     */
    static QString photoLabel();
    /**
      Set sound.
     */
    void setSound( const Sound &sound );
    /**
      Return sound.
diff --git a/kabc/field.cpp b/kabc/field.cpp
index e27970e..d95cd19 100644
--- a/kabc/field.cpp
+++ b/kabc/field.cpp
@@ -1,566 +1,572 @@
 /*** 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,
      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
+      Resource,
+      Sip
    };
    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::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::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::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::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::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::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::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::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::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/kabc/phonenumber.cpp b/kabc/phonenumber.cpp
index 4ad608d..7aeb2ee 100644
--- a/kabc/phonenumber.cpp
+++ b/kabc/phonenumber.cpp
@@ -1,200 +1,202 @@
 /*
    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 <kapplication.h>
 #include <klocale.h>
 #include "phonenumber.h"
 using namespace KABC;
 PhoneNumber::PhoneNumber() :
  mType( Home )
 {
  init();
 }
 PhoneNumber::PhoneNumber( const QString &number, int type ) :
  mType( type ), mNumber( number )
 {
  init();
 }
 PhoneNumber::~PhoneNumber()
 {
 }
 void PhoneNumber::init()
 {
  mId = KApplication::randomString( 8 );
 }
 bool PhoneNumber::operator==( const PhoneNumber &p ) const
 {
  if ( mNumber != p.mNumber ) return false;
  if ( mType != p.mType ) return false;
  
  return true;
 }
 bool PhoneNumber::operator!=( const PhoneNumber &p ) const
 {
  return !( p == *this );
 }
 void PhoneNumber::setId( const QString &id )
 {
  mId = id;
 }
 QString PhoneNumber::id() const
 {
  return mId;
 }
 void PhoneNumber::setNumber( const QString &number )
 {
  mNumber = number;
 }
 QString PhoneNumber::number() const
 {
  return mNumber;
 }
 void PhoneNumber::setType( int type )
 {
  mType = type;
 }
 int PhoneNumber::type() const
 {
  return mType;
 }
 QString PhoneNumber::typeLabel() const
 {
  QString label;
  bool first = true;
  TypeList list = typeList();
  TypeList::Iterator it;
  for ( it = list.begin(); it != list.end(); ++it ) {
    if ( ( type() & (*it) ) && ( (*it) != Pref ) ) {
      label.append( ( first ? "" : "/" ) + typeLabel( *it ) );
      if ( first )
        first = false;
    }
  }
  return label;
 }
 QString PhoneNumber::label() const
 {
  return typeLabel( type() );
 }
 PhoneNumber::TypeList PhoneNumber::typeList()
 {
  TypeList list;
  
  list << Home << Work << Msg << Pref << Voice << Fax << Cell << Video
-       << Bbs << Modem << Car << Isdn << Pcs << Pager;
+       << Bbs << Modem << Car << Isdn << Pcs << Pager << Sip;
  return list;
 }
 QString PhoneNumber::label( int type )
 {
  return typeLabel( type );
 }
 QString PhoneNumber::typeLabel( int type )
 {
  QString typeString;
  
  if ((type & Home) == Home)
    typeString += i18n("Home");
  else if ((type & Work) == Work)
    typeString += i18n("Work");
   
  if (!typeString.isEmpty())
    typeString += " ";
      
  if ((type & Cell) == Cell)
    typeString += i18n("Mobile");
  else if ((type & Fax) == Fax)
    typeString += i18n("Fax");
  else if ((type & Msg) == Msg)
    typeString += i18n("Messenger");
  else if ((type & Voice) == Voice) {
 // add nothing in case of the Voice flag
 //    typeString += i18n("Voice");
  }
  else if ((type & Video) == Video)
    typeString += i18n("Video");
  else if ((type & Bbs) == Bbs)
    typeString += i18n("Mailbox");
  else if ((type & Modem) == Modem)
    typeString += i18n("Modem");
  else if ((type & Car) == Car)
    typeString += i18n("Car");
  else if ((type & Isdn) == Isdn)
    typeString += i18n("ISDN");
  else if ((type & Pcs) == Pcs)
    typeString += i18n("PCS");
  else if ((type & Pager) == Pager)
    typeString += i18n("Pager");
+  else if ((type & Sip) == Sip)
+    typeString += i18n("SIP");
    
  // add the prefered flag    
  if (!typeString.isEmpty())
    typeString += " ";
  if ((type & Pref) == Pref)
    typeString += i18n("(p)");
  //if we still have no match, return "other"        
  if (typeString.isEmpty())
    return i18n("Other");
    
    
  return typeString;
 }
 QDataStream &KABC::operator<<( QDataStream &s, const PhoneNumber &phone )
 {
    return s << phone.mId << phone.mType << phone.mNumber;
 }
 QDataStream &KABC::operator>>( QDataStream &s, PhoneNumber &phone )
 {
    s >> phone.mId >> phone.mType >> phone.mNumber;
    return s;
 }
diff --git a/kabc/phonenumber.h b/kabc/phonenumber.h
index 6a9c8cb..1df344f 100644
--- a/kabc/phonenumber.h
+++ b/kabc/phonenumber.h
@@ -1,165 +1,166 @@
 /*
    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_PHONENUMBER_H
 #define KABC_PHONENUMBER_H
 #include <qvaluelist.h>
 #include <qstring.h>
 namespace KABC {
 /**
  @short Phonenumber information.
  
  This class provides phone number information. A phone number is classified by
  a type. The following types are available, it's possible to use multiple types
  @ref Types for a number by combining them through a logical or.
 */
 class PhoneNumber
 {
    friend QDataStream &operator<<( QDataStream &, const PhoneNumber & );
    friend QDataStream &operator>>( QDataStream &, PhoneNumber & );
  public:
    typedef QValueList<PhoneNumber> List;
    typedef QValueList<int> TypeList;
    /**
      @li @p Home -  Home number
      @li @p Work -  Office number
      @li @p Msg -   Messaging
      @li @p Pref -  Preferred number
      @li @p Voice - Voice
      @li @p Fax -   Fax machine
      @li @p Cell -  Cell phone
      @li @p Video - Video phone
      @li @p Bbs -   Mailbox
      @li @p Modem - Modem
      @li @p Car -   Car phone
      @li @p Isdn -  ISDN connection
      @li @p Pcs -   Personal Communication Service
      @li @p Pager - Pager
+      @li @p SIP   - VoIP
    */
    enum Types { Home = 1, Work = 2, Msg = 4, Pref = 8, Voice = 16, Fax = 32,
           Cell = 64, Video = 128, Bbs = 256, Modem = 512, Car = 1024,
-           Isdn = 2048, Pcs = 4096, Pager = 8192 };
+           Isdn = 2048, Pcs = 4096, Pager = 8192, Sip = 16384 };
    /**
      Create an empty phone number object.
    */  
    PhoneNumber();
    /**
      Create a phonenumber object.
     
      @param number Number
      @param type   Type as defined in enum. Multiple types can be
                    specified by combining them by a logical or.
    */
    PhoneNumber( const QString &number, int type = Home );
    /**
      Destructor.
    */
    ~PhoneNumber();
    
    bool operator==( const PhoneNumber & ) const;
    bool operator!=( const PhoneNumber & ) const;
    
    /**
      Sets the unique identifier.
    */
    void setId( const QString &id );
    /**
      Returns the unique identifier.
    */
    QString id() const;
    
    /**
      Sets the number.
    */
    void setNumber( const QString & );
    /**
      Returns the number.
    */
    QString number() const;
    
    /**
      Sets the type. Multiple types can be specified by combining them by
      a logical or.
    */
    void setType( int );
    /**
      Returns the type. Can be a multiple types combined by a logical or.
    */
    int type() const;
    /**
      Returns a translated string of all types the address has.
    */
    QString typeLabel() const;
    /**
      Returns the translated label for phone number depending on its type.
    */
    QString label() const;
    /**
      Returns a list of all available types
    */
    static TypeList typeList();
    /**
      Returns the translated label for phone number type.
    */
    static QString typeLabel( int type );
    /**
      Returns the translated label for phone number type.
      @obsolete
    */
    static QString label( int type );
  private:
    void init();
  
    QString mId;
  
    int mType;
    QString mNumber;
 };
 QDataStream &operator<<( QDataStream &, const PhoneNumber & );
 QDataStream &operator>>( QDataStream &, PhoneNumber & );
 }
 #endif
diff --git a/kabc/vcard21parser.cpp b/kabc/vcard21parser.cpp
index b02aac4..277de22 100644
--- a/kabc/vcard21parser.cpp
+++ b/kabc/vcard21parser.cpp
@@ -1,495 +1,498 @@
 /*
    This file is part of libkabc.
    Copyright (c) 2001 Mark Westcott <mark@houseoffish.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 <qmap.h>
 #include <qregexp.h>
 #include <kmdcodec.h>
 #include "vcard21parser.h"
 #include "vcardconverter.h"
 using namespace KABC;
 bool VCardLineX::isValid() const
 {
  // Invalid: if it is "begin:vcard" or "end:vcard"
  if ( name == VCARD_BEGIN_N || name == VCARD_END_N )
    return false;
  if ( name[0] == 'x' && name[1] == '-' ) // A custom x- line
    return true;
  // This is long but it makes it a bit faster (and saves me from using
  // a tree which is probably the ideal situation, but a bit memory heavy)
  switch( name[0] ) {
    case 'a':
      if ( name == VCARD_ADR && qualified &&
                   (qualifiers.contains(VCARD_ADR_DOM)    ||
                    qualifiers.contains(VCARD_ADR_INTL)   ||
                    qualifiers.contains(VCARD_ADR_POSTAL) ||
                    qualifiers.contains(VCARD_ADR_HOME)   ||
                    qualifiers.contains(VCARD_ADR_WORK)   ||
                    qualifiers.contains(VCARD_ADR_PREF)
         ) )
        return true;
      if ( name == VCARD_AGENT )
        return true;
      break;
    case 'b':
      if ( name == VCARD_BDAY )
        return true;
      break;
    case 'c':
      if ( name == VCARD_CATEGORIES )
        return true;
      if ( name == VCARD_CLASS && qualified &&
                   (qualifiers.contains(VCARD_CLASS_PUBLIC)      ||
                    qualifiers.contains(VCARD_CLASS_PRIVATE)     ||
                    qualifiers.contains(VCARD_CLASS_CONFIDENTIAL)
         ) )
        return true;
      break;
    case 'e':
      if ( name == VCARD_EMAIL && qualified &&
                  (qualifiers.contains(VCARD_EMAIL_INTERNET) ||
                   qualifiers.contains(VCARD_EMAIL_PREF)     ||
                   qualifiers.contains(VCARD_EMAIL_X400)
         ) )
        return true;
      break;
    case 'f':
      if ( name == VCARD_FN )
        return true;
      break;
    case 'g':
      if ( name == VCARD_GEO )
        return true;
      break;
    case 'k':
      if ( name == VCARD_KEY && qualified &&
                   (qualifiers.contains(VCARD_KEY_X509) ||
                    qualifiers.contains(VCARD_KEY_PGP)
         ) )
        return true;
      break;
    case 'l':
      if ( name == VCARD_LABEL )
        return true;
      if ( name == VCARD_LOGO )
        return true;
      break;
    case 'm':
      if ( name == VCARD_MAILER )
        return true;
      break;
    case 'n':
      if ( name == VCARD_N )
        return true;
      if ( name == VCARD_NAME )
        return true;
      if ( name == VCARD_NICKNAME )
        return true;
      if ( name == VCARD_NOTE )
        return true;
      break;
    case 'o':
      if ( name == VCARD_ORG )
        return true;
      break;
    case 'p':
      if ( name == VCARD_PHOTO )
        return true;
      if ( name == VCARD_PROFILE )
        return true;
      if ( name == VCARD_PRODID )
        return true;
      break;
    case 'r':
      if ( name == VCARD_ROLE )
        return true;
      if ( name == VCARD_REV )
        return true;
      break;
    case 's':
      if ( name == VCARD_SOURCE )
        return true;
      if ( name == VCARD_SOUND )
        return true;
      break;
    case 't':
      if ( name == VCARD_TEL && qualified &&
                   (qualifiers.contains(VCARD_TEL_HOME)  ||
                    qualifiers.contains(VCARD_TEL_WORK)  ||
                    qualifiers.contains(VCARD_TEL_PREF)  ||
                    qualifiers.contains(VCARD_TEL_VOICE) ||
                    qualifiers.contains(VCARD_TEL_FAX)   ||
                    qualifiers.contains(VCARD_TEL_MSG)   ||
                    qualifiers.contains(VCARD_TEL_CELL)  ||
                    qualifiers.contains(VCARD_TEL_PAGER) ||
                    qualifiers.contains(VCARD_TEL_BBS)   ||
                    qualifiers.contains(VCARD_TEL_MODEM) ||
                    qualifiers.contains(VCARD_TEL_CAR)   ||
                    qualifiers.contains(VCARD_TEL_ISDN)  ||
                    qualifiers.contains(VCARD_TEL_VIDEO) ||
-                    qualifiers.contains(VCARD_TEL_PCS)
+                    qualifiers.contains(VCARD_TEL_PCS)   ||
+                    qualifiers.contains(VCARD_TEL_SIP)
         ) )
        return true;
      if ( name == VCARD_TZ )
        return true;
      if ( name == VCARD_TITLE )
        return true;
      break;
    case 'u':
      if ( name == VCARD_URL )
        return true;
      if ( name == VCARD_UID )
        return true;
      break;
    case 'v':
      if ( name == VCARD_VERSION )
        return true;
      break;
    default:
      break;
  }
  return false;
 }
 VCard21Parser::VCard21Parser()
 {
 }
 VCard21Parser::~VCard21Parser()
 {
 }
 void VCard21Parser::readFromString(KABC::AddressBook *addressbook, const QString &data)
 {
  KABC::Addressee mAddressee = readFromString(data);
  addressbook->insertAddressee(mAddressee);
 }
 KABC::Addressee VCard21Parser::readFromString( const QString &data)
 {
  KABC::Addressee addressee;
  VCard21ParserImpl *mVCard = VCard21ParserImpl::parseVCard(data);
  QString tmpStr;
  // Check if parsing failed
  if (mVCard == 0)
  {
     kdDebug() << "Parsing failed" << endl;
     return addressee;
  }
  //set the addressees name and formated name
  QStringList tmpList = mVCard->getValues(VCARD_N);
  QString formattedName = "";
  if (tmpList.count() > 0)
    addressee.setFamilyName(tmpList[0]);
  if (tmpList.count() > 1)
    addressee.setGivenName(tmpList[1]);
  if (tmpList.count() > 2)
    addressee.setAdditionalName(tmpList[2]);
  if (tmpList.count() > 3)
    addressee.setPrefix(tmpList[3]);
  if (tmpList.count() > 4)
    addressee.setSuffix(tmpList[4]);
  tmpStr = (mVCard->getValue(VCARD_FN));
  if (!tmpStr.isEmpty())
    addressee.setFormattedName(tmpStr);
  //set the addressee's nick name
  tmpStr = mVCard->getValue(VCARD_NICKNAME);
  addressee.setNickName(tmpStr);
  //set the addressee's organisation
  tmpStr = mVCard->getValue(VCARD_ORG);
  addressee.setOrganization(tmpStr);
  //set the addressee's title
  tmpStr = mVCard->getValue(VCARD_TITLE);
  addressee.setTitle(tmpStr);
  //set the addressee's email - we can only deal with two.  The preferenced one and one other.
  tmpStr = mVCard->getValue(VCARD_EMAIL, VCARD_EMAIL_INTERNET);
  addressee.insertEmail(tmpStr, false);
  tmpStr = mVCard->getValue(VCARD_EMAIL,VCARD_EMAIL_PREF);
  addressee.insertEmail(tmpStr, true);
  //set the addressee's url
  tmpStr = mVCard->getValue(VCARD_URL);
  if (tmpStr.isEmpty()) tmpStr = mVCard->getValue(VCARD_URL, VCARD_ADR_WORK);
  if (tmpStr.isEmpty()) tmpStr = mVCard->getValue(VCARD_URL, VCARD_ADR_HOME);
  if (!tmpStr.isEmpty()) {
    addressee.setUrl(KURL(tmpStr));
  }
  //set the addressee's birthday
  tmpStr = mVCard->getValue(VCARD_BDAY);
  addressee.setBirthday(VCardStringToDate(tmpStr));
  //set the addressee's phone numbers
  for ( QValueListIterator<VCardLineX> i = mVCard->_vcdata->begin();i != mVCard->_vcdata->end(); ++i ) {
    if ( (*i).name == VCARD_TEL ) {
      int type = 0;
      if ( (*i).qualified ) {
        if ( (*i).qualifiers.contains( VCARD_TEL_HOME ) )
          type |= PhoneNumber::Home;
        if ( (*i).qualifiers.contains( VCARD_TEL_WORK ) )
          type |= PhoneNumber::Work;
        if ( (*i).qualifiers.contains( VCARD_TEL_PREF ) )
          type |= PhoneNumber::Pref;
        // if ( (*i).qualifiers.contains( VCARD_TEL_VOICE ) )
        //  type |= PhoneNumber::Voice;
        if ( (*i).qualifiers.contains( VCARD_TEL_FAX ) )
          type |= PhoneNumber::Fax;
        if ( (*i).qualifiers.contains( VCARD_TEL_MSG ) )
          type |= PhoneNumber::Msg;
        if ( (*i).qualifiers.contains( VCARD_TEL_CELL ) )
          type |= PhoneNumber::Cell;
        if ( (*i).qualifiers.contains( VCARD_TEL_PAGER ) )
          type |= PhoneNumber::Pager;
        if ( (*i).qualifiers.contains( VCARD_TEL_BBS ) )
          type |= PhoneNumber::Bbs;
        if ( (*i).qualifiers.contains( VCARD_TEL_MODEM ) )
          type |= PhoneNumber::Modem;
        if ( (*i).qualifiers.contains( VCARD_TEL_CAR ) )
          type |= PhoneNumber::Car;
        if ( (*i).qualifiers.contains( VCARD_TEL_ISDN ) )
          type |= PhoneNumber::Isdn;
        if ( (*i).qualifiers.contains( VCARD_TEL_VIDEO ) )
          type |= PhoneNumber::Video;
        if ( (*i).qualifiers.contains( VCARD_TEL_PCS ) )
          type |= PhoneNumber::Pcs;
+        if ( (*i).qualifiers.contains( VCARD_TEL_SIP ) )
+          type |= PhoneNumber::Sip;
      }
      addressee.insertPhoneNumber( PhoneNumber( (*i).parameters[ 0 ], type ) );
    }
  }
  //set the addressee's addresses
  for ( QValueListIterator<VCardLineX> i = mVCard->_vcdata->begin();i != mVCard->_vcdata->end(); ++i ) {
    if ( (*i).name == VCARD_ADR ) {
      int type = 0;
      if ( (*i).qualified ) {
        if ( (*i).qualifiers.contains( VCARD_ADR_DOM ) )
          type |= Address::Dom;
        if ( (*i).qualifiers.contains( VCARD_ADR_INTL ) )
          type |= Address::Intl;
        if ( (*i).qualifiers.contains( VCARD_ADR_POSTAL ) )
          type |= Address::Postal;
        if ( (*i).qualifiers.contains( VCARD_ADR_PARCEL ) )
          type |= Address::Parcel;
        if ( (*i).qualifiers.contains( VCARD_ADR_HOME ) )
          type |= Address::Home;
        if ( (*i).qualifiers.contains( VCARD_ADR_WORK ) )
          type |= Address::Work;
        if ( (*i).qualifiers.contains( VCARD_ADR_PREF ) )
          type |= Address::Pref;
      }
      addressee.insertAddress( readAddressFromQStringList( (*i).parameters, type ) );
    }
  }
  //set the addressee's delivery label
  tmpStr = mVCard->getValue(VCARD_LABEL);
  if (!tmpStr.isEmpty()) {
 qDebug("VCard21Parser::readFromString please verify if replace is correct");
 //US    tmpStr.replace("\r\n","\n");
    tmpStr.replace( QRegExp("\r\n"), "\n" );   
    Address tmpAddress;
    tmpAddress.setLabel(tmpStr);
    addressee.insertAddress(tmpAddress);
  }
  //set the addressee's notes
  tmpStr = mVCard->getValue(VCARD_NOTE);
 qDebug("VCard21Parser::readFromString please verify if correct");
 //US    tmpStr.replace("\r\n","\n");
  tmpStr.replace( QRegExp("\r\n"), "\n" );   
  addressee.setNote(tmpStr);
  //set the addressee's timezone
  tmpStr = mVCard->getValue(VCARD_TZ);
  TimeZone tmpZone(tmpStr.toInt());
  addressee.setTimeZone(tmpZone);
  //set the addressee's geographical position
  tmpList = mVCard->getValues(VCARD_GEO);
  if (tmpList.count()==2)
  {
    tmpStr = tmpList[0];
    float glat = tmpStr.toFloat();
    tmpStr = tmpList[1];
    float glong = tmpStr.toFloat();
    Geo tmpGeo(glat,glong);
    addressee.setGeo(tmpGeo);
  }
  //set the last revision date
  tmpStr = mVCard->getValue(VCARD_REV);
  addressee.setRevision(VCardStringToDate(tmpStr));
  //set the role of the addressee
  tmpStr = mVCard->getValue(VCARD_ROLE);
  addressee.setRole(tmpStr);
  return addressee;
 }
 KABC::Address VCard21Parser::readAddressFromQStringList ( const QStringList &data, const int type )
 {
  KABC::Address mAddress;
  mAddress.setType( type );
  if ( data.count() > 0 )
    mAddress.setPostOfficeBox( data[0] );
  if ( data.count() > 1 )
    mAddress.setExtended( data[1] );
  if ( data.count() > 2 )
    mAddress.setStreet( data[2] );
  if ( data.count() > 3 )
    mAddress.setLocality( data[3] );
  if ( data.count() > 4 )
    mAddress.setRegion( data[4] );
  if ( data.count() > 5 )
    mAddress.setPostalCode( data[5] );
  if ( data.count() > 6 )
    mAddress.setCountry( data[6] );
  return mAddress;
 }
 VCard21ParserImpl *VCard21ParserImpl::parseVCard( const QString& vc, int *err )
 {
  int _err = 0;
  int _state = VC_STATE_BEGIN;
  QValueList<VCardLineX> *_vcdata;
  QValueList<QString> lines;
  _vcdata = new QValueList<VCardLineX>;
  lines = QStringList::split( QRegExp( "[\x0d\x0a]" ), vc );
  // for each line in the vCard
  for ( QStringList::Iterator j = lines.begin(); j != lines.end(); ++j ) {
    VCardLineX _vcl;
    // take spaces off the end - ugly but necessary hack
    for ( int g = (*j).length()-1; g > 0 && (*j)[g].isSpace(); --g )
      (*j)[g] = 0;
    // first token:
    //   verify state, update if necessary
    if ( _state & VC_STATE_BEGIN) {
      if ( !qstricmp( (*j).latin1(), VCARD_BEGIN ) ) {
        _state = VC_STATE_BODY;
        continue;
      } else {
        _err = VC_ERR_NO_BEGIN;
        break;
      }
    } else if ( _state & VC_STATE_BODY ) {
      if ( !qstricmp( (*j).latin1(), VCARD_END ) ) {
        _state |= VC_STATE_END;
        break;
      }
      // split into two tokens
      int colon = (*j).find( ':' );
      if ( colon < 0 ) {
        _err = VC_ERR_INVALID_LINE;
        break;
      }
      QString key = (*j).left( colon );
      QString value = (*j).mid( colon + 1 );
      // check for qualifiers and
      // set name, qualified, qualifier(s)
      QStringList keyTokens = QStringList::split( ';', key );
      bool qp = false, first_pass = true;
      bool b64 = false;
      if ( keyTokens.count() > 0 ) {
        _vcl.qualified = false;
        _vcl.name = keyTokens[ 0 ].lower();
        for ( QStringList::Iterator z = keyTokens.begin(); z != keyTokens.end(); ++z ) {
          QString zz = (*z).lower();
          if ( zz == VCARD_QUOTED_PRINTABLE || zz == VCARD_ENCODING_QUOTED_PRINTABLE ) {
            qp = true;
          } else if ( zz == VCARD_BASE64 ) {
            b64 = true;
          } else if ( !first_pass ) {
            _vcl.qualified = true;
            _vcl.qualifiers.append( zz );
          }
          first_pass = false;
        }
      } else {
        _err = VC_ERR_INVALID_LINE;
      }
      if ( _err != 0 )
        break;
      if ( _vcl.name == VCARD_VERSION )
        _state |= VC_STATE_HAVE_VERSION;
      if ( _vcl.name == VCARD_N || _vcl.name == VCARD_FN )
        _state |= VC_STATE_HAVE_N;
      // second token:
      //    split into tokens by ;
      //    add to parameters vector
      if ( b64 ) {
        if ( value.at( value.length() - 1 ) != '=' )
          do {
            value += *( ++j );
          } while ( (*j).at( (*j).length() - 1 ) != '=' );
      } else {
        if ( qp ) { // join any split lines
diff --git a/kabc/vcard21parser.h b/kabc/vcard21parser.h
index 24b0eb2..77e69b6 100644
--- a/kabc/vcard21parser.h
+++ b/kabc/vcard21parser.h
@@ -1,225 +1,226 @@
 /*
    This file is part of libkabc.
    Copyright (c) 2002 Mark Westcott <mark@houseoffish.org>
    Copyright (c) 2000 George Staikos <staikos@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_VCARD21FORMAT_H
 #define KABC_VCARD21FORMAT_H
 #include <qdatetime.h>
 #include <kdebug.h>
 #include <qregexp.h>
 #include <qstring.h>
 #include <kurl.h>
 #include <qvaluelist.h>
 #include "addressee.h"
 #include "addressbook.h"
 #include "phonenumber.h"
 #define VCARD_BEGIN          "begin:vcard"
 #define VCARD_END            "end:vcard"
 #define VCARD_BEGIN_N        "begin"
 #define VCARD_END_N          "end"
 #define VCARD_VERSION        "version"
 #define VCARD_FN             "fn"
 #define VCARD_N              "n"
 // optional
 #define VCARD_NAME           "name"
 #define VCARD_NICKNAME       "nickname"
 #define VCARD_PHOTO          "photo"
 #define VCARD_BDAY           "bday"
 #define VCARD_ADR            "adr"
 // types
 #define VCARD_ADR_DOM      "dom"
 #define VCARD_ADR_INTL     "intl"
 #define VCARD_ADR_POSTAL   "postal"
 #define VCARD_ADR_PARCEL   "parcel"
 #define VCARD_ADR_HOME     "home"
 #define VCARD_ADR_WORK     "work"
 #define VCARD_ADR_PREF     "pref"
 // values
 #define VCARD_ADR_POBOX    "PO Box"
 #define VCARD_ADR_EXTADR   "Extended Address"
 #define VCARD_ADR_STREET   "Street"
 #define VCARD_ADR_LOCALITY "Locality"
 #define VCARD_ADR_REGION   "Region"
 #define VCARD_ADR_POSTCODE "Postal Code"
 #define VCARD_ADR_COUNTRY  "Country Name"
 #define VCARD_LABEL          "label"
 #define VCARD_PROFILE        "profile"
 #define VCARD_SOURCE         "source"
 #define VCARD_TEL            "tel"
 // types
 #define VCARD_TEL_HOME     "home"
 #define VCARD_TEL_WORK     "work"
 #define VCARD_TEL_PREF     "pref"
 #define VCARD_TEL_VOICE    "voice"
 #define VCARD_TEL_FAX      "fax"
 #define VCARD_TEL_MSG      "msg"
 #define VCARD_TEL_CELL     "cell"
 #define VCARD_TEL_PAGER    "pager"
 #define VCARD_TEL_BBS      "bbs"
 #define VCARD_TEL_MODEM    "modem"
 #define VCARD_TEL_CAR      "car"
 #define VCARD_TEL_ISDN     "isdn"
 #define VCARD_TEL_VIDEO    "video"
 #define VCARD_TEL_PCS      "pcs"
+#define VCARD_TEL_SIP      "sip"
 #define VCARD_EMAIL        "email"
 // types
 #define VCARD_EMAIL_PREF    "pref"
 #define VCARD_EMAIL_INTERNET "internet"
 #define VCARD_EMAIL_X400   "x400"
 #define VCARD_TZ             "tz"
 #define VCARD_GEO            "geo"
 #define VCARD_MAILER         "mailer"
 #define VCARD_TITLE          "title"
 #define VCARD_ROLE           "role"
 #define VCARD_LOGO           "logo"
 #define VCARD_AGENT          "agent"
 #define VCARD_ORG            "org"
 #define VCARD_CATEGORIES     "categories"
 #define VCARD_NOTE           "note"
 #define VCARD_PRODID         "prodid"
 #define VCARD_REV            "rev"
 #define VCARD_SOUND          "sound"
 #define VCARD_UID            "uid"
 #define VCARD_URL            "url"
 #define VCARD_CLASS          "class"
 #define VCARD_CLASS_PUBLIC "public"
 #define VCARD_CLASS_PRIVATE "private"
 #define VCARD_CLASS_CONFIDENTIAL "confidential"
 #define VCARD_KEY            "key"
 // types
 #define VCARD_KEY_X509     "x509"
 #define VCARD_KEY_PGP      "pgp"
 #define VCARD_QUOTED_PRINTABLE "quoted-printable"
 // this one is a temporary hack until we support TYPE=VALUE
 #define VCARD_ENCODING_QUOTED_PRINTABLE "encoding=quoted-printable"
 #define VCARD_BASE64           "base64"
 #define VC_STATE_BEGIN          1
 #define VC_STATE_BODY           2
 #define VC_STATE_END            4
 #define VC_STATE_HAVE_N         8
 #define VC_STATE_HAVE_VERSION  16
 #define VC_ERR_NO_BEGIN            1
 #define VC_ERR_NO_END              2
 #define VC_ERR_INVALID_LINE        3
 #define VC_ERR_INTERNAL            4
 #define VC_ERR_INVALID_NAME        5
 #define VC_ERR_MISSING_MANDATORY   6
 namespace KABC {
 class AddressBook;
 class VCard21Parser
 {
 public:
  /**
   * Constructor.
   */
  VCard21Parser();
  /**
   * Destructor.
   */
  virtual ~VCard21Parser();
  /**
   * Parses a string in vcard2.1 format and saves the single addressees
   * to the address book.
   *
   * @param ab  The address book.
   * @param str The vcard string.
   */
  void readFromString( KABC::AddressBook *ab, const QString &str );
  /**
   * FIXME: we need a writeToString method
   * QString writeToString (KABC::AddressBook *);
   */
  /**
   * Parses a string in vcard2.1 format and returns the inherent addressee.
   */
  KABC::Addressee readFromString( const QString &data);
  /**
   * Helper method to store a address.
   *
   * @param data  A string list, that is filled with 'street', 'house number' ...
   * @param type  The type of the returned address.
   */
  static KABC::Address readAddressFromQStringList (const QStringList &data, const int type);
 };
 }
 /**
 * @short Helper class
 */
 class VCardLineX
 {
 public:
  QString name;
  bool qualified;
  QValueList<QString> qualifiers;
  QValueList<QString> parameters;
  bool isValid() const;
 };
 /**
 * @short Helper class
 */
 class VCard21ParserImpl
 {
  friend class VCardLineX;
 public:
  VCard21ParserImpl() {  };
  virtual ~VCard21ParserImpl() {  };
  static VCard21ParserImpl *parseVCard(const QString& vc, int *err = NULL);
  QString getValue(const QString& name, const QString& qualifier);
  QString getValue(const QString& name);
  QStringList getValues(const QString& name, const QString& qualifier);
  QStringList getValues(const QString& name);
  QValueList<VCardLineX> *_vcdata;
 private:
  VCard21ParserImpl (QValueList<VCardLineX> *_vcd);
 };
 #endif
diff --git a/kabc/vcardformatimpl.cpp b/kabc/vcardformatimpl.cpp
index bffaa64..2d6eb3d 100644
--- a/kabc/vcardformatimpl.cpp
+++ b/kabc/vcardformatimpl.cpp
@@ -402,416 +402,418 @@ void VCardFormatImpl::addDateTimeValue( VCard *vcard, EntityType type,
 void VCardFormatImpl::addAddressValue( VCard *vcard, const Address &a )
 {
  if ( a.isEmpty() )
    return;
  ContentLine cl;
  cl.setName( EntityTypeToParamName( EntityAddress ) );
  AdrValue *v = new AdrValue;
  v->setPOBox( a.postOfficeBox().utf8() );
  v->setExtAddress( a.extended().utf8() );
  v->setStreet( a.street().utf8() );
  v->setLocality( a.locality().utf8() );
  v->setRegion( a.region().utf8() );
  v->setPostCode( a.postalCode().utf8() );
  v->setCountryName( a.country().utf8() );
  cl.setValue( v );
  addAddressParam( &cl, a.type() );
  vcard->add( cl );
 }
 void VCardFormatImpl::addLabelValue( VCard *vcard, const Address &a )
 {
  if ( a.label().isEmpty() ) return;
  ContentLine cl;
  cl.setName( EntityTypeToParamName( EntityLabel ) );
  cl.setValue( new TextValue( a.label().utf8() ) );
  addAddressParam( &cl, a.type() );
  vcard->add( cl );
 }
 void VCardFormatImpl::addAddressParam( ContentLine *cl, int type )
 {
  ParamList params;
  if ( type & Address::Dom ) params.append( new Param( "TYPE", "dom" ) );
  if ( type & Address::Intl ) params.append( new Param( "TYPE", "intl" ) );
  if ( type & Address::Parcel ) params.append( new Param( "TYPE", "parcel" ) );
  if ( type & Address::Postal ) params.append( new Param( "TYPE", "postal" ) );
  if ( type & Address::Work ) params.append( new Param( "TYPE", "work" ) );
  if ( type & Address::Home ) params.append( new Param( "TYPE", "home" ) );
  if ( type & Address::Pref ) params.append( new Param( "TYPE", "pref" ) );
  cl->setParamList( params );
 }
 void VCardFormatImpl::addGeoValue( VCard *vcard, const Geo &geo )
 {
  if ( !geo.isValid() ) return;
  ContentLine cl;
  cl.setName( EntityTypeToParamName( EntityGeo ) );
  GeoValue *v = new GeoValue;
  v->setLatitude( geo.latitude() );
  v->setLongitude( geo.longitude() );
  cl.setValue( v );
  vcard->add(cl);
 }
 void VCardFormatImpl::addUTCValue( VCard *vcard, const TimeZone &tz )
 {
  if ( !tz.isValid() ) return;
  ContentLine cl;
  cl.setName( EntityTypeToParamName( EntityTimeZone ) );
  UTCValue *v = new UTCValue;
  v->setPositive( tz.offset() >= 0 );
  v->setHour( (tz.offset() / 60) * ( tz.offset() >= 0 ? 1 : -1 ) );
  v->setMinute( (tz.offset() % 60) * ( tz.offset() >= 0 ? 1 : -1 ) );
  cl.setValue( v );
  vcard->add(cl);
 }
 void VCardFormatImpl::addClassValue( VCard *vcard, const Secrecy &secrecy )
 {
  ContentLine cl;
  cl.setName( EntityTypeToParamName( EntityClass ) );
  ClassValue *v = new ClassValue;
  switch ( secrecy.type() ) {
    case Secrecy::Public:
      v->setType( (int)ClassValue::Public );
      break;
    case Secrecy::Private:
      v->setType( (int)ClassValue::Private );
      break;
    case Secrecy::Confidential:
      v->setType( (int)ClassValue::Confidential );
      break;
  }
  cl.setValue( v );
  vcard->add(cl);
 }
 Address VCardFormatImpl::readAddressValue( ContentLine *cl )
 {
  Address a;
  AdrValue *v = (AdrValue *)cl->value();
  a.setPostOfficeBox( QString::fromUtf8( v->poBox() ) );
  a.setExtended( QString::fromUtf8( v->extAddress() ) );
  a.setStreet( QString::fromUtf8( v->street() ) );
  a.setLocality( QString::fromUtf8( v->locality() ) );
  a.setRegion( QString::fromUtf8( v->region() ) );
  a.setPostalCode( QString::fromUtf8( v->postCode() ) );
  a.setCountry( QString::fromUtf8( v->countryName() ) );
  a.setType( readAddressParam( cl ) );
  return a;
 }
 int VCardFormatImpl::readAddressParam( ContentLine *cl )
 {
  int type = 0;
  ParamList params = cl->paramList();
  ParamListIterator it( params );
  QCString tmpStr;
  for( ; it.current(); ++it ) {
    if ( (*it)->name().upper() == "TYPE" ) {
      tmpStr = (*it)->value().lower();
      if ( tmpStr == "dom" ) type |= Address::Dom;
      else if ( tmpStr == "intl" ) type |= Address::Intl;
      else if ( tmpStr == "parcel" ) type |= Address::Parcel;
      else if ( tmpStr == "postal" ) type |= Address::Postal;
      else if ( tmpStr == "work" ) type |= Address::Work;
      else if ( tmpStr == "home" ) type |= Address::Home;
      else if ( tmpStr == "pref" ) type |= Address::Pref;
    }
  }
  return type;
 }
 void VCardFormatImpl::addNValue( VCard *vcard, const Addressee &a )
 {
  ContentLine cl;
  cl.setName(EntityTypeToParamName( EntityN ) );
  NValue *v = new NValue;
  v->setFamily( a.familyName().utf8() );
  v->setGiven( a.givenName().utf8() );
  v->setMiddle( a.additionalName().utf8() );
  v->setPrefix( a.prefix().utf8() );
  v->setSuffix( a.suffix().utf8() );
  cl.setValue( v );
  vcard->add(cl);
 }
 void VCardFormatImpl::readNValue( ContentLine *cl, Addressee &a )
 {
  NValue *v = (NValue *)cl->value();
  a.setFamilyName( QString::fromUtf8( v->family() ) );
  a.setGivenName( QString::fromUtf8( v->given() ) );
  a.setAdditionalName( QString::fromUtf8( v->middle() ) );
  a.setPrefix( QString::fromUtf8( v->prefix() ) );
  a.setSuffix( QString::fromUtf8( v->suffix() ) );
 }
 void VCardFormatImpl::addTelephoneValue( VCard *v, const PhoneNumber &p )
 {
  if ( p.number().isEmpty() )
    return;
  ContentLine cl;
  cl.setName(EntityTypeToParamName(EntityTelephone));
  cl.setValue(new TelValue( p.number().utf8() ));
  ParamList params;
  if( p.type() & PhoneNumber::Home ) params.append( new Param( "TYPE", "home" ) );
  if( p.type() & PhoneNumber::Work ) params.append( new Param( "TYPE", "work" ) );
  if( p.type() & PhoneNumber::Msg ) params.append( new Param( "TYPE", "msg" ) );
  if( p.type() & PhoneNumber::Pref ) params.append( new Param( "TYPE", "pref" ) );
  if( p.type() & PhoneNumber::Voice ) params.append( new Param( "TYPE", "voice" ) );
  if( p.type() & PhoneNumber::Fax ) params.append( new Param( "TYPE", "fax" ) );
  if( p.type() & PhoneNumber::Cell ) params.append( new Param( "TYPE", "cell" ) );
  if( p.type() & PhoneNumber::Video ) params.append( new Param( "TYPE", "video" ) );
  if( p.type() & PhoneNumber::Bbs ) params.append( new Param( "TYPE", "bbs" ) );
  if( p.type() & PhoneNumber::Modem ) params.append( new Param( "TYPE", "modem" ) );
  if( p.type() & PhoneNumber::Car ) params.append( new Param( "TYPE", "car" ) );
  if( p.type() & PhoneNumber::Isdn ) params.append( new Param( "TYPE", "isdn" ) );
  if( p.type() & PhoneNumber::Pcs ) params.append( new Param( "TYPE", "pcs" ) );
  if( p.type() & PhoneNumber::Pager ) params.append( new Param( "TYPE", "pager" ) );
+  if( p.type() & PhoneNumber::Sip ) params.append( new Param( "TYPE", "sip" ) );
  cl.setParamList( params );
  v->add(cl);
 }
 PhoneNumber VCardFormatImpl::readTelephoneValue( ContentLine *cl )
 {
  PhoneNumber p;
  TelValue *value = (TelValue *)cl->value();
  p.setNumber( QString::fromUtf8( value->asString() ) );
  int type = 0;
  ParamList params = cl->paramList();
  ParamListIterator it( params );
  QCString tmpStr;
  for( ; it.current(); ++it ) {
    if ( (*it)->name() == "TYPE" ) {
      tmpStr = (*it)->value().lower();
      if ( tmpStr == "home" ) type |= PhoneNumber::Home;
      else if ( tmpStr == "work" ) type |= PhoneNumber::Work;
      else if ( tmpStr == "msg" ) type |= PhoneNumber::Msg;
      else if ( tmpStr == "pref" ) type |= PhoneNumber::Pref;
      else if ( tmpStr == "voice" ) type |= PhoneNumber::Voice;
      else if ( tmpStr == "fax" ) type |= PhoneNumber::Fax;
      else if ( tmpStr == "cell" ) type |= PhoneNumber::Cell;
      else if ( tmpStr == "video" ) type |= PhoneNumber::Video;
      else if ( tmpStr == "bbs" ) type |= PhoneNumber::Bbs;
      else if ( tmpStr == "modem" ) type |= PhoneNumber::Modem;
      else if ( tmpStr == "car" ) type |= PhoneNumber::Car;
      else if ( tmpStr == "isdn" ) type |= PhoneNumber::Isdn;
      else if ( tmpStr == "pcs" ) type |= PhoneNumber::Pcs;
      else if ( tmpStr == "pager" ) type |= PhoneNumber::Pager;
+      else if ( tmpStr == "sip" ) type |= PhoneNumber::Sip;
    }
  }
  p.setType( type );
  return p;
 }
 QString VCardFormatImpl::readTextValue( ContentLine *cl )
 {
  VCARD::Value *value = cl->value();
  if ( value ) {
    return QString::fromUtf8( value->asString() );
  } else {
    kdDebug(5700) << "No value: " << cl->asString() << endl;
    return QString::null;
  }
 }
 QDate VCardFormatImpl::readDateValue( ContentLine *cl )
 {
  DateValue *dateValue = (DateValue *)cl->value();
  if ( dateValue )
    return dateValue->qdate();
  else
    return QDate();
 }
 QDateTime VCardFormatImpl::readDateTimeValue( ContentLine *cl )
 {
  DateValue *dateValue = (DateValue *)cl->value();
  if ( dateValue )
    return dateValue->qdt();
  else
    return QDateTime();
 }
 Geo VCardFormatImpl::readGeoValue( ContentLine *cl )
 {
  GeoValue *geoValue = (GeoValue *)cl->value();
  if ( geoValue ) {
    Geo geo( geoValue->latitude(), geoValue->longitude() );
    return geo;
  } else
    return Geo();
 }
 TimeZone VCardFormatImpl::readUTCValue( ContentLine *cl )
 {
  UTCValue *utcValue = (UTCValue *)cl->value();
  if ( utcValue ) {
    TimeZone tz;
    tz.setOffset(((utcValue->hour()*60)+utcValue->minute())*(utcValue->positive() ? 1 : -1));
    return tz;
  } else
    return TimeZone();
 }
 Secrecy VCardFormatImpl::readClassValue( ContentLine *cl )
 {
  ClassValue *classValue = (ClassValue *)cl->value();
  if ( classValue ) {
    Secrecy secrecy;
    switch ( classValue->type() ) {
      case ClassValue::Public:
        secrecy.setType( Secrecy::Public );
        break;
      case ClassValue::Private:
        secrecy.setType( Secrecy::Private );
        break;
      case ClassValue::Confidential:
        secrecy.setType( Secrecy::Confidential );
        break;
    }
    return secrecy;
  } else
    return Secrecy();
 }
 void VCardFormatImpl::addKeyValue( VCARD::VCard *vcard, const Key &key )
 {
  ContentLine cl;
  cl.setName( EntityTypeToParamName( EntityKey ) );
  ParamList params;
  if ( key.isBinary() ) {
    cl.setValue( new TextValue( KCodecs::base64Encode( key.binaryData() ) ) );
    params.append( new Param( "ENCODING", "b" ) );
  } else {
    cl.setValue( new TextValue( key.textData().utf8() ) );
  }
  switch ( key.type() ) {
    case Key::X509:
      params.append( new Param( "TYPE", "X509" ) );
      break;
    case Key::PGP:
      params.append( new Param( "TYPE", "PGP" ) );
      break;
    case Key::Custom:
      params.append( new Param( "TYPE", key.customTypeString().utf8() ) );
      break;
  }
  cl.setParamList( params );
  vcard->add( cl );
 }
 Key VCardFormatImpl::readKeyValue( VCARD::ContentLine *cl )
 {
  Key key;
  bool isBinary = false;
  TextValue *v = (TextValue *)cl->value();
  ParamList params = cl->paramList();
  ParamListIterator it( params );
  for( ; it.current(); ++it ) {
    if ( (*it)->name() == "ENCODING" && (*it)->value() == "b" )
      isBinary = true;
    if ( (*it)->name() == "TYPE" ) {
      if ( (*it)->value().isEmpty() )
        continue;
      if ( (*it)->value() == "X509" )
        key.setType( Key::X509 );
      else if ( (*it)->value() == "PGP" )
        key.setType( Key::PGP );
      else {
        key.setType( Key::Custom );
        key.setCustomTypeString( QString::fromUtf8( (*it)->value() ) );
      }
    }
  }
  if ( isBinary ) {
    QByteArray data;
    KCodecs::base64Decode( v->asString().stripWhiteSpace(), data );
    key.setBinaryData( data );
  } else {
    key.setTextData( QString::fromUtf8( v->asString() ) );
  }
  return key;
 }
 void VCardFormatImpl::addAgentValue( VCARD::VCard *vcard, const Agent &agent )
 {
  if ( agent.isIntern() && !agent.addressee() )
    return;
  if ( !agent.isIntern() && agent.url().isEmpty() )
    return;
  ContentLine cl;
  cl.setName( EntityTypeToParamName( EntityAgent ) );
  ParamList params;
  if ( agent.isIntern() ) {
    QString vstr;
    Addressee *addr = agent.addressee();
    if ( addr ) {
      writeToString( (*addr), vstr );
      qDebug("VCardFormatImpl::addAgentValue please verify if replace is correct");
 /*US
      vstr.replace( ":", "\\:" );
      vstr.replace( ",", "\\," );
      vstr.replace( ";", "\\;" );
      vstr.replace( "\r\n", "\\n" );
 */
      vstr.replace( QRegExp(":"), "\\:" );
      vstr.replace( QRegExp(","), "\\," );
      vstr.replace( QRegExp(";"), "\\;" );
      vstr.replace( QRegExp("\r\n"), "\\n" );
      cl.setValue( new TextValue( vstr.utf8() ) );
    } else
      return;
  } else {
    cl.setValue( new TextValue( agent.url().utf8() ) );
    params.append( new Param( "VALUE", "uri" ) );
  }
  cl.setParamList( params );
  vcard->add( cl );
 }
 Agent VCardFormatImpl::readAgentValue( VCARD::ContentLine *cl )
 {
  Agent agent;
  bool isIntern = true;
diff --git a/kabc/vcardparser/vcardtool.cpp b/kabc/vcardparser/vcardtool.cpp
index 71f29d7..3fb212e 100644
--- a/kabc/vcardparser/vcardtool.cpp
+++ b/kabc/vcardparser/vcardtool.cpp
@@ -1,251 +1,252 @@
 /*
    This file is part of libkabc.
    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 <qdatastream.h>
 #include <qstring.h>
 #include <qregexp.h>
 #include <kmdcodec.h>
 #include "agent.h"
 #include "key.h"
 #include "picture.h"
 #include "secrecy.h"
 #include "sound.h"
 #include "vcardtool.h"
 using namespace KABC;
 VCardTool::VCardTool()
 {
  mAddressTypeMap.insert( "dom", Address::Dom );
  mAddressTypeMap.insert( "intl", Address::Intl );
  mAddressTypeMap.insert( "postal", Address::Postal );
  mAddressTypeMap.insert( "parcel", Address::Parcel );
  mAddressTypeMap.insert( "home", Address::Home );
  mAddressTypeMap.insert( "work", Address::Work );
  mAddressTypeMap.insert( "pref", Address::Pref );
  mPhoneTypeMap.insert( "HOME", PhoneNumber::Home );
  mPhoneTypeMap.insert( "WORK", PhoneNumber::Work );
  mPhoneTypeMap.insert( "MSG", PhoneNumber::Msg );
  mPhoneTypeMap.insert( "PREF", PhoneNumber::Pref );
  mPhoneTypeMap.insert( "VOICE", PhoneNumber::Voice );
  mPhoneTypeMap.insert( "FAX", PhoneNumber::Fax );
  mPhoneTypeMap.insert( "CELL", PhoneNumber::Cell );
  mPhoneTypeMap.insert( "VIDEO", PhoneNumber::Video );
  mPhoneTypeMap.insert( "BBS", PhoneNumber::Bbs );
  mPhoneTypeMap.insert( "MODEM", PhoneNumber::Modem );
  mPhoneTypeMap.insert( "CAR", PhoneNumber::Car );
  mPhoneTypeMap.insert( "ISDN", PhoneNumber::Isdn );
  mPhoneTypeMap.insert( "PCS", PhoneNumber::Pcs );
  mPhoneTypeMap.insert( "PAGER", PhoneNumber::Pager );
+  mPhoneTypeMap.insert( "SIP", PhoneNumber::Sip );
 }
 VCardTool::~VCardTool()
 {
 }
 QString VCardTool::createVCards( Addressee::List list, VCard::Version version )
 {
  VCard::List vCardList;
  Addressee::List::Iterator addrIt;
  for ( addrIt = list.begin(); addrIt != list.end(); ++addrIt ) {
    VCard card;
    QStringList::ConstIterator strIt;
    // ADR + LABEL
    Address::List addresses = (*addrIt).addresses();
    for ( Address::List::Iterator it = addresses.begin(); it != addresses.end(); ++it ) {
      QStringList address;
 /*US       
      address.append( (*it).postOfficeBox().replace( ';', "\\;" ) );
      address.append( (*it).extended().replace( ';', "\\;" ) );
      address.append( (*it).street().replace( ';', "\\;" ) );
      address.append( (*it).locality().replace( ';', "\\;" ) );
      address.append( (*it).region().replace( ';', "\\;" ) );
      address.append( (*it).postalCode().replace( ';', "\\;" ) );
      address.append( (*it).country().replace( ';', "\\;" ) );
 */
 //US using the old implementation instead
      //qDebug("VCardTool::createVCards has to be verified");
      address.append( (*it).postOfficeBox().replace(  QRegExp(";"), "\\;" ) );
      address.append( (*it).extended().replace( QRegExp(";"), "\\;" ) );
      address.append(  (*it).street().replace( QRegExp(";"), "\\;" ) );
      address.append( (*it).locality().replace( QRegExp(";"), "\\;" ) );
      address.append( (*it).region().replace( QRegExp(";"), "\\;" ) );
      address.append( (*it).postalCode().replace( QRegExp(";"), "\\;" ) );
      address.append( (*it).country().replace( QRegExp(";"), "\\;" ) );
      VCardLine adrLine( "ADR", address.join( ";" ) );
      VCardLine labelLine( "LABEL", (*it).label() );
      bool hasLabel = !(*it).label().isEmpty();
      QMap<QString, int>::Iterator typeIt;
      for ( typeIt = mAddressTypeMap.begin(); typeIt != mAddressTypeMap.end(); ++typeIt ) {
        if ( typeIt.data() & (*it).type() ) {
          if ( version == VCard::v3_0 ) {
            adrLine.addParameter( "TYPE", typeIt.key().lower() );
          }
          else {
            adrLine.addParameter( "TYPE", typeIt.key() );
          }
          if ( hasLabel ) {
            if ( version == VCard::v3_0 ) {
              labelLine.addParameter( "TYPE",  typeIt.key().lower() );
            }          
            else {
              labelLine.addParameter( "TYPE",  typeIt.key() );
            }
          }
        }
      }
      card.addLine( adrLine );
      if ( hasLabel )
        card.addLine( labelLine );
    }
    // AGENT
    card.addLine( createAgent( version, (*addrIt).agent() ) );
    // BDAY
    card.addLine( VCardLine( "BDAY", createDateTime( (*addrIt).birthday() ) ) );
    // CATEGORIES
    if ( version == VCard::v3_0 ) {
      QStringList categories = (*addrIt).categories();
      QStringList::Iterator catIt;
      for ( catIt = categories.begin(); catIt != categories.end(); ++catIt )
      {
 //US using the old implementation instead
          // qDebug("VCardTool::createVCards has to be verified");
 //US        (*catIt).replace( ',', "\\," );
        (*catIt).replace( QRegExp(","), "\\," );
      }
      card.addLine( VCardLine( "CATEGORIES", categories.join( "," ) ) );
    }
    // CLASS
    if ( version == VCard::v3_0 ) {
      card.addLine( createSecrecy( (*addrIt).secrecy() ) );
    }
    
    // EMAIL
    QStringList emails = (*addrIt).emails();
    bool pref = true;
    for ( strIt = emails.begin(); strIt != emails.end(); ++strIt ) {
      VCardLine line( "EMAIL", *strIt );
      if ( pref == true ) {
        line.addParameter( "TYPE", "PREF" );
        pref = false;
      }
      card.addLine( line );
    }
    // FN
    card.addLine( VCardLine( "FN", (*addrIt).formattedName() ) );
    // GEO
    Geo geo = (*addrIt).geo();
    if ( geo.isValid() ) {
      QString str;
      str.sprintf( "%.6f;%.6f", geo.latitude(), geo.longitude() );
      card.addLine( VCardLine( "GEO", str ) );
    }
    // KEY
    Key::List keys = (*addrIt).keys();
    Key::List::ConstIterator keyIt;
    for ( keyIt = keys.begin(); keyIt != keys.end(); ++keyIt )
      card.addLine( createKey( *keyIt ) );
    // LOGO
    card.addLine( createPicture( "LOGO", (*addrIt).logo() ) );
    // MAILER
    card.addLine( VCardLine( "MAILER", (*addrIt).mailer() ) );
    // N
    QStringList name;
 //US using the old implementation instead
    //qDebug("VCardTool::createVCards has to be verified");
 /*US    
    name.append( (*addrIt).familyName().replace( ';', "\\;" ) );
    name.append( (*addrIt).givenName().replace( ';', "\\;" ) );
    name.append( (*addrIt).additionalName().replace( ';', "\\;" ) );
    name.append( (*addrIt).prefix().replace( ';', "\\;" ) );
    name.append( (*addrIt).suffix().replace( ';', "\\;" ) );
 */    
    name.append( (*addrIt).familyName().replace( QRegExp(";"), "\\;" ) );
    name.append( (*addrIt).givenName().replace( QRegExp(";"), "\\;" ) );
    name.append( (*addrIt).additionalName().replace( QRegExp(";"), "\\;" ) );
    name.append( (*addrIt).prefix().replace( QRegExp(";"), "\\;" ) );
    name.append( (*addrIt).suffix().replace( QRegExp(";"), "\\;" ) );
    if ( !name.join( "" ).isEmpty() )
      card.addLine( VCardLine( "N", name.join( ";" ) ) );
    // NICKNAME
    if ( version == VCard::v3_0 )
      card.addLine( VCardLine( "NICKNAME", (*addrIt).nickName() ) );
    // NOTE
    card.addLine( VCardLine( "NOTE", (*addrIt).note() ) );
    // ORG
    card.addLine( VCardLine( "ORG", (*addrIt).organization() ) );
    // PHOTO
    card.addLine( createPicture( "PHOTO", (*addrIt).photo() ) );
    // PROID
    if ( version == VCard::v3_0 )
      card.addLine( VCardLine( "PRODID", (*addrIt).productId() ) );
    // REV
    card.addLine( VCardLine( "REV", createDateTime( (*addrIt).revision() ) ) );
    // ROLE
    card.addLine( VCardLine( "ROLE", (*addrIt).role() ) );
    // SORT-STRING
    if ( version == VCard::v3_0 )
      card.addLine( VCardLine( "SORT-STRING", (*addrIt).sortString() ) );
    // SOUND
    card.addLine( createSound( (*addrIt).sound() ) );
    // TEL
    PhoneNumber::List phoneNumbers = (*addrIt).phoneNumbers();
    PhoneNumber::List::ConstIterator phoneIt;
    for ( phoneIt = phoneNumbers.begin(); phoneIt != phoneNumbers.end(); ++phoneIt ) {
      VCardLine line( "TEL", (*phoneIt).number() );
      QMap<QString, int>::Iterator typeIt;
      for ( typeIt = mPhoneTypeMap.begin(); typeIt != mPhoneTypeMap.end(); ++typeIt ) {
        if ( typeIt.data() & (*phoneIt).type() )
          if ( version == VCard::v3_0 )
            line.addParameter( "TYPE", typeIt.key().lower() );
          else
            line.addParameter( "TYPE", typeIt.key() );
      }