2 files changed, 16 insertions, 0 deletions

diff --git a/kabc/vcardformatimpl.cpp b/kabc/vcardformatimpl.cpp
index 1bf2cde..ede5773 100644
--- a/kabc/vcardformatimpl.cpp
+++ b/kabc/vcardformatimpl.cpp
@@ -1,466 +1,477 @@
 /*
     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 <qfile.h>
 #include <qregexp.h>
 
 #include <kdebug.h>
 #include <kmdcodec.h>
 #include <kstandarddirs.h>
 #include <ktempfile.h>
 
 #include <VCard.h>
 
 #include "addressbook.h"
 #include "vcardformatimpl.h"
 
 using namespace KABC;
 using namespace VCARD;
 
+int VCardFormatImpl::debug = -1;
+
+VCardFormatImpl::VCardFormatImpl()
+{
+  debug = (getenv("KABC_DEBUG") != 0);
+}
+
 bool VCardFormatImpl::load( Addressee &addressee, QFile *file )
 {
   kdDebug(5700) << "VCardFormat::load()" << endl;
 
   QByteArray fdata = file->readAll();
   QCString data(fdata.data(), fdata.size()+1);
 
   VCardEntity e( data );
 
   VCardListIterator it( e.cardList() );
 
   if ( it.current() ) {
 //US    VCard v(*it.current());
 //US    loadAddressee( addressee, v );
     loadAddressee( addressee, it.current() );
     return true;
   }
 
   return false;
 }
 
 bool VCardFormatImpl::loadAll( AddressBook *addressBook, Resource *resource, QFile *file )
 {
   kdDebug(5700) << "VCardFormat::loadAll()" << endl;
 
   QByteArray fdata = file->readAll();
   QCString data(fdata.data(), fdata.size()+1);
 
   VCardEntity e( data );
 
   VCardListIterator it( e.cardList() );
 
   for (; it.current(); ++it) {
 //US    VCard v(*it.current());
     Addressee addressee;
 //US    loadAddressee( addressee, v );
     loadAddressee( addressee, it.current() );
     addressee.setResource( resource );
     addressBook->insertAddressee( addressee );
+    if (debug == true)
+      {
+        printf("address %s loaded successfully\n", addressee.formattedName().latin1());
+      } 
   }
 
   return true;
 }
 
 void VCardFormatImpl::save( const Addressee &addressee, QFile *file )
 {
   VCardEntity vcards;
   VCardList vcardlist;
   vcardlist.setAutoDelete( true );
 
   VCard *v = new VCard;
 
   saveAddressee( addressee, v, false );
 
   vcardlist.append( v );
   vcards.setCardList( vcardlist );
 
   QCString vcardData = vcards.asString();
   file->writeBlock( (const char*)vcardData, vcardData.length() );
 }
 
 void VCardFormatImpl::saveAll( AddressBook *ab, Resource *resource, QFile *file )
 {
   VCardEntity vcards;
   VCardList vcardlist;
   vcardlist.setAutoDelete( true );
 
   AddressBook::Iterator it;
   for ( it = ab->begin(); it != ab->end(); ++it ) {
     if ( (*it).resource() == resource ) {
       VCard *v = new VCard;
       saveAddressee( (*it), v, false );
       (*it).setChanged( false );
       vcardlist.append( v );
     }
   }
 
   vcards.setCardList( vcardlist );
 
   QCString vcardData = vcards.asString();
   file->writeBlock( (const char*)vcardData, vcardData.length() );
 }
 
 bool VCardFormatImpl::loadAddressee( Addressee& addressee, VCard *v )
 {
   QPtrList<ContentLine> contentLines = v->contentLineList();
   ContentLine *cl;
 
   for( cl = contentLines.first(); cl; cl = contentLines.next() ) {
     QCString n = cl->name();
     if ( n.left( 2 ) == "X-" ) {
       n = n.mid( 2 );
       int posDash = n.find( "-" );
       addressee.insertCustom( QString::fromUtf8( n.left( posDash ) ),
                         QString::fromUtf8( n.mid( posDash + 1 ) ),
                         QString::fromUtf8( cl->value()->asString() ) );
         continue;
     }
 
     EntityType type = cl->entityType();
     switch( type ) {
 
       case EntityUID:
         addressee.setUid( readTextValue( cl ) );
         break;
 
       case EntityEmail:
         addressee.insertEmail( readTextValue( cl ) );
         break;
 
       case EntityName:
         addressee.setName( readTextValue( cl ) );
         break;
 
       case EntityFullName:
         addressee.setFormattedName( readTextValue( cl ) );
         break;
 
       case EntityURL:
         addressee.setUrl( KURL( readTextValue( cl ) ) );
         break;
 
       case EntityNickname:
         addressee.setNickName( readTextValue( cl ) );
         break;
 
       case EntityLabel:
         // not yet supported by kabc
         break;
 
       case EntityMailer:
         addressee.setMailer( readTextValue( cl ) );
         break;
 
       case EntityTitle:
         addressee.setTitle( readTextValue( cl ) );
         break;
 
       case EntityRole:
         addressee.setRole( readTextValue( cl ) );
         break;
 
       case EntityOrganisation:
         addressee.setOrganization( readTextValue( cl ) );
         break;
 
       case EntityNote:
         addressee.setNote( readTextValue( cl ) );
         break;
 
       case EntityProductID:
         addressee.setProductId( readTextValue( cl ) );
         break;
 
       case EntitySortString:
         addressee.setSortString( readTextValue( cl ) );
         break;
 
       case EntityN:
         readNValue( cl, addressee );
         break;
 
       case EntityAddress:
         addressee.insertAddress( readAddressValue( cl ) );
         break;
 
       case EntityTelephone:
         addressee.insertPhoneNumber( readTelephoneValue( cl ) );
         break;
 
       case EntityCategories:
         addressee.setCategories( QStringList::split( ",", readTextValue( cl ) ) );
         break;
 
       case EntityBirthday:
         addressee.setBirthday( readDateValue( cl ) );
         break;
 
       case EntityRevision:
         addressee.setRevision( readDateTimeValue( cl ) );
         break;
 
       case EntityGeo:
         addressee.setGeo( readGeoValue( cl ) );
         break;
 
       case EntityTimeZone:
         addressee.setTimeZone( readUTCValue( cl ) );
         break;
 
       case EntityVersion:
         break;
 
       case EntityClass:
         addressee.setSecrecy( readClassValue( cl ) );
         break;
 
       case EntityKey:
         addressee.insertKey( readKeyValue( cl ) );
         break;
 
       case EntityPhoto:
         addressee.setPhoto( readPictureValue( cl, EntityPhoto, addressee ) );
         break;
 
       case EntityLogo:
         addressee.setLogo( readPictureValue( cl, EntityLogo, addressee ) );
         break;
 
       case EntityAgent:
         addressee.setAgent( readAgentValue( cl ) );
         break;
 
       case EntitySound:
         addressee.setSound( readSoundValue( cl, addressee ) );
         break;
 
       default:
         kdDebug(5700) << "VCardFormat::load(): Unsupported entity: "
                     << int( type ) << ": " << cl->asString() << endl;
         qDebug("VCardFormat::load(): Unsupported entity: %i: %s ", int(type), (const char*)cl->asString());
         break;
     }
   }
 
   for( cl = contentLines.first(); cl; cl = contentLines.next() ) {
     EntityType type = cl->entityType();
     if ( type == EntityLabel ) {
       int type = readAddressParam( cl );
       Address address = addressee.address( type );
       if ( address.isEmpty() )
         address.setType( type );
 
       address.setLabel( QString::fromUtf8( cl->value()->asString() ) );
       addressee.insertAddress( address );
     }
   }
 
   return true;
 }
 
 void VCardFormatImpl::saveAddressee( const Addressee &addressee, VCard *v, bool intern )
 {
 //US   ContentLine cl;
 //US  QString value;
 
   addTextValue( v, EntityName, addressee.name() );
   addTextValue( v, EntityUID, addressee.uid() );
   addTextValue( v, EntityFullName, addressee.formattedName() );
 
   QStringList emails = addressee.emails();
   QStringList::ConstIterator it4;
   for( it4 = emails.begin(); it4 != emails.end(); ++it4 ) {
     addTextValue( v, EntityEmail, *it4 );
   }
 
   QStringList customs = addressee.customs();
   QStringList::ConstIterator it5;
   for( it5 = customs.begin(); it5 != customs.end(); ++it5 ) {
     addCustomValue( v, *it5 );
   }
 
   addTextValue( v, EntityURL, addressee.url().url() );
 
   addNValue( v, addressee );
 
   addTextValue( v, EntityNickname, addressee.nickName() );
   addTextValue( v, EntityMailer, addressee.mailer() );
   addTextValue( v, EntityTitle, addressee.title() );
   addTextValue( v, EntityRole, addressee.role() );
   addTextValue( v, EntityOrganisation, addressee.organization() );
   addTextValue( v, EntityNote, addressee.note() );
   addTextValue( v, EntityProductID, addressee.productId() );
   addTextValue( v, EntitySortString, addressee.sortString() );
 
   Address::List addresses = addressee.addresses();
   Address::List::ConstIterator it3;
   for( it3 = addresses.begin(); it3 != addresses.end(); ++it3 ) {
     addAddressValue( v, *it3 );
     addLabelValue( v, *it3 );
   }
 
   PhoneNumber::List phoneNumbers = addressee.phoneNumbers();
   PhoneNumber::List::ConstIterator it2;
   for( it2 = phoneNumbers.begin(); it2 != phoneNumbers.end(); ++it2 ) {
     addTelephoneValue( v, *it2 );
   }
 
   Key::List keys = addressee.keys();
   Key::List::ConstIterator it6;
   for( it6 = keys.begin(); it6 != keys.end(); ++it6 ) {
     addKeyValue( v, *it6 );
   }
 
   addTextValue( v, EntityCategories, addressee.categories().join(",") );
 
   addDateValue( v, EntityBirthday, addressee.birthday().date() );
   addDateTimeValue( v, EntityRevision, addressee.revision() );
   addGeoValue( v, addressee.geo() );
   addUTCValue( v, addressee.timeZone() );
 
   addClassValue( v, addressee.secrecy() );
 
   addPictureValue( v, EntityPhoto, addressee.photo(), addressee, intern );
   addPictureValue( v, EntityLogo, addressee.logo(), addressee, intern );
 
   addAgentValue( v, addressee.agent() );
 
   addSoundValue( v, addressee.sound(), addressee, intern );
 }
 
 void VCardFormatImpl::addCustomValue( VCard *v, const QString &txt )
 {
   if ( txt.isEmpty() ) return;
 
   ContentLine cl;
   cl.setName( "X-" + txt.left( txt.find( ":" ) ).utf8() );
   QString value = txt.mid( txt.find( ":" ) + 1 );
   if ( value.isEmpty() )
     return;
   cl.setValue( new TextValue( value.utf8() ) );
   v->add(cl);
 }
 
 void VCardFormatImpl::addTextValue( VCard *v, EntityType type, const QString &txt )
 {
   if ( txt.isEmpty() ) return;
 
   ContentLine cl;
   cl.setName( EntityTypeToParamName( type ) );
   cl.setValue( new TextValue( txt.utf8() ) );
   v->add(cl);
 }
 
 void VCardFormatImpl::addDateValue( VCard *vcard, EntityType type,
                                     const QDate &date )
 {
   if ( !date.isValid() ) return;
 
   ContentLine cl;
   cl.setName( EntityTypeToParamName( type ) );
 
   DateValue *v = new DateValue( date );
   cl.setValue( v );
   vcard->add(cl);
 }
 
 void VCardFormatImpl::addDateTimeValue( VCard *vcard, EntityType type,
                                     const QDateTime &dateTime )
 {
   if ( !dateTime.isValid() ) return;
 
   ContentLine cl;
   cl.setName( EntityTypeToParamName( type ) );
 
   DateValue *v = new DateValue( dateTime );
   cl.setValue( v );
   vcard->add(cl);
 }
 
 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);
 }
diff --git a/kabc/vcardformatimpl.h b/kabc/vcardformatimpl.h
index fa3d55f..4821047 100644
--- a/kabc/vcardformatimpl.h
+++ b/kabc/vcardformatimpl.h
@@ -1,112 +1,117 @@
 /*
     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_VCARDFORMATIMPL_H
 #define KABC_VCARDFORMATIMPL_H
 
 #include <qstring.h>
 #include <qfile.h>
 
 #include "address.h"
 #include "addressee.h"
 
 #include <VCard.h>
 
 namespace KABC {
 
 class AddressBook;
 
 /**
   @short Implementation of vCard backend for address book.
 
   This class implements reading and writing of address book information using
   the vCard format. It requires the vCard lib from kdepim.
 */
 class VCardFormatImpl
 {
   public:
+    VCardFormatImpl();
+
     bool load( Addressee &, QFile *file );
     bool loadAll( AddressBook *, Resource *, QFile *file );
     void save( const Addressee &, QFile *file );
     void saveAll( AddressBook *, Resource *, QFile *file );
 
     bool readFromString( const QString &vcard, Addressee &addr );
     bool writeToString( const Addressee &addressee, QString &vcard );
 
   protected:
     bool loadAddressee( Addressee &, VCARD::VCard * );
     void saveAddressee( const Addressee &, VCARD::VCard *, bool intern );
 
     void addTextValue (VCARD::VCard *, VCARD::EntityType, const QString & );
     QString readTextValue( VCARD::ContentLine * );
 
     void addDateValue( VCARD::VCard *, VCARD::EntityType, const QDate & );
     QDate readDateValue( VCARD::ContentLine * );
 
     void addDateTimeValue( VCARD::VCard *, VCARD::EntityType, const QDateTime & );
     QDateTime readDateTimeValue( VCARD::ContentLine * );
 
     void addAddressValue( VCARD::VCard *, const Address & );
     Address readAddressValue( VCARD::ContentLine * );
 
     void addLabelValue( VCARD::VCard *, const Address & );
 
     void addTelephoneValue( VCARD::VCard *, const PhoneNumber & );
     PhoneNumber readTelephoneValue( VCARD::ContentLine * );
 
     void addNValue( VCARD::VCard *, const Addressee & );
     void readNValue( VCARD::ContentLine *, Addressee & );
 
     void addCustomValue( VCARD::VCard *, const QString & );
 
     void addAddressParam( VCARD::ContentLine *, int );
     int readAddressParam( VCARD::ContentLine * );
 
     void addGeoValue( VCARD::VCard *, const Geo & );
     Geo readGeoValue( VCARD::ContentLine * );
 
     void addUTCValue( VCARD::VCard *, const TimeZone & );
     TimeZone readUTCValue( VCARD::ContentLine * );
 
     void addClassValue( VCARD::VCard *, const Secrecy & );
     Secrecy readClassValue( VCARD::ContentLine * );
 
     void addKeyValue( VCARD::VCard *, const Key & );
     Key readKeyValue( VCARD::ContentLine * );
 
     void addPictureValue( VCARD::VCard *, VCARD::EntityType, const Picture &, const Addressee &, bool );
     Picture readPictureValue( VCARD::ContentLine *, VCARD::EntityType, const Addressee &addr );
 
     void addSoundValue( VCARD::VCard *, const Sound &, const Addressee &, bool );
     Sound readSoundValue( VCARD::ContentLine *, const Addressee &addr );
 
     void addAgentValue( VCARD::VCard *, const Agent & );
     Agent readAgentValue( VCARD::ContentLine * );
+
+ private:
+    static int debug;
 };
 
 }
 #endif