vcardformatimpl.cpp Source File (kabc Library)

| # kabc Library API Documentation
Overview | Class Hierarchy | Classes | Classes (annotated) | Members | Source Files

# vcardformatimpl.cpp

    00001 /*
    00002     This file is part of libkabc.
    00003     Copyright (c) 2001 Cornelius Schumacher <schumacher@kde.org>
    00004
    00005     This library is free software; you can redistribute it and/or
    00006     modify it under the terms of the GNU Library General Public
    00007     License as published by the Free Software Foundation; either
    00008     version 2 of the License, or (at your option) any later version.
    00009
    00010     This library is distributed in the hope that it will be useful,
    00011     but WITHOUT ANY WARRANTY; without even the implied warranty of
    00012     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    00013     Library General Public License for more details.
    00014
    00015     You should have received a copy of the GNU Library General Public License
    00016     along with this library; see the file COPYING.LIB.  If not, write to
    00017     the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
    00018     Boston, MA 02111-1307, USA.
    00019 */
    00020 #include <qfile.h>
    00021 #include <qregexp.h>
    00022
    00023 #include <kdebug.h>
    00024 #include <kmdcodec.h>
    00025 #include <kstandarddirs.h>
    00026 #include <ktempfile.h>
    00027
    00028 #include <VCard.h>
    00029
    00030 #include "addressbook.h"
    00031 #include "vcardformatimpl.h"
    00032
    00033 using namespace KABC;
    00034 using namespace VCARD;
    00035
    00036 bool VCardFormatImpl::load( Addressee &addressee, QFile *file )
    00037 {
    00038   kdDebug(5700) << "VCardFormat::load()" << endl;
    00039
    00040   QByteArray fdata = file->readAll();
    00041   QCString data(fdata.data(), fdata.size()+1);
    00042
    00043   VCardEntity e( data );
    00044
    00045   VCardListIterator it( e.cardList() );
    00046
    00047   if ( it.current() ) {
    00048     VCard v(*it.current());
    00049     loadAddressee( addressee, v );
    00050     return true;
    00051   }
    00052
    00053   return false;
    00054 }
    00055
    00056 bool VCardFormatImpl::loadAll( AddressBook *addressBook, Resource *resource, QFile *file )
    00057 {
    00058   kdDebug(5700) << "VCardFormat::loadAll()" << endl;
    00059
    00060   QByteArray fdata = file->readAll();
    00061   QCString data(fdata.data(), fdata.size()+1);
    00062
    00063   VCardEntity e( data );
    00064
    00065   VCardListIterator it( e.cardList() );
    00066
    00067   for (; it.current(); ++it) {
    00068     VCard v(*it.current());
    00069     Addressee addressee;
    00070     loadAddressee( addressee, v );
    00071     addressee.setResource( resource );
    00072     addressBook->insertAddressee( addressee );
    00073   }
    00074
    00075   return true;
    00076 }
    00077
    00078 void VCardFormatImpl::save( const Addressee &addressee, QFile *file )
    00079 {
    00080   VCardEntity vcards;
    00081   VCardList vcardlist;
    00082   vcardlist.setAutoDelete( true );
    00083
    00084   VCard *v = new VCard;
    00085
    00086   saveAddressee( addressee, v, false );
    00087
    00088   vcardlist.append( v );
    00089   vcards.setCardList( vcardlist );
    00090
    00091   QCString vcardData = vcards.asString();
    00092   file->writeBlock( (const char*)vcardData, vcardData.length() );
    00093 }
    00094
    00095 void VCardFormatImpl::saveAll( AddressBook *ab, Resource *resource, QFile *file )
    00096 {
    00097   VCardEntity vcards;
    00098   VCardList vcardlist;
    00099   vcardlist.setAutoDelete( true );
    00100
    00101   AddressBook::Iterator it;
    00102   for ( it = ab->begin(); it != ab->end(); ++it ) {
    00103     if ( (*it).resource() == resource ) {
    00104       VCard *v = new VCard;
    00105       saveAddressee( (*it), v, false );
    00106       (*it).setChanged( false );
    00107       vcardlist.append( v );
    00108     }
    00109   }
    00110
    00111   vcards.setCardList( vcardlist );
    00112
    00113   QCString vcardData = vcards.asString();
    00114   file->writeBlock( (const char*)vcardData, vcardData.length() );
    00115 }
    00116
    00117 bool VCardFormatImpl::loadAddressee( Addressee& addressee, VCard &v )
    00118 {
    00119   QPtrList<ContentLine> contentLines = v.contentLineList();
    00120   ContentLine *cl;
    00121
    00122   for( cl = contentLines.first(); cl; cl = contentLines.next() ) {
    00123     QCString n = cl->name();
    00124     if ( n.left( 2 ) == "X-" ) {
    00125       n = n.mid( 2 );
    00126       int posDash = n.find( "-" );
    00127       addressee.insertCustom( QString::fromUtf8( n.left( posDash ) ),
    00128                         QString::fromUtf8( n.mid( posDash + 1 ) ),
    00129                         QString::fromUtf8( cl->value()->asString() ) );
    00130         continue;
    00131     }
    00132
    00133     EntityType type = cl->entityType();
    00134     switch( type ) {
    00135
    00136       case EntityUID:
    00137         addressee.setUid( readTextValue( cl ) );
    00138         break;
    00139
    00140       case EntityEmail:
    00141         addressee.insertEmail( readTextValue( cl ) );
    00142         break;
    00143
    00144       case EntityName:
    00145         addressee.setName( readTextValue( cl ) );
    00146         break;
    00147
    00148       case EntityFullName:
    00149         addressee.setFormattedName( readTextValue( cl ) );
    00150         break;
    00151
    00152       case EntityURL:
    00153         addressee.setUrl( KURL( readTextValue( cl ) ) );
    00154         break;
    00155
    00156       case EntityNickname:
    00157         addressee.setNickName( readTextValue( cl ) );
    00158         break;
    00159
    00160       case EntityLabel:
    00161         // not yet supported by kabc
    00162         break;
    00163
    00164       case EntityMailer:
    00165         addressee.setMailer( readTextValue( cl ) );
    00166         break;
    00167
    00168       case EntityTitle:
    00169         addressee.setTitle( readTextValue( cl ) );
    00170         break;
    00171
    00172       case EntityRole:
    00173         addressee.setRole( readTextValue( cl ) );
    00174         break;
    00175
    00176       case EntityOrganisation:
    00177         addressee.setOrganization( readTextValue( cl ) );
    00178         break;
    00179
    00180       case EntityNote:
    00181         addressee.setNote( readTextValue( cl ) );
    00182         break;
    00183
    00184       case EntityProductID:
    00185         addressee.setProductId( readTextValue( cl ) );
    00186         break;
    00187
    00188       case EntitySortString:
    00189         addressee.setSortString( readTextValue( cl ) );
    00190         break;
    00191
    00192       case EntityN:
    00193         readNValue( cl, addressee );
    00194         break;
    00195
    00196       case EntityAddress:
    00197         addressee.insertAddress( readAddressValue( cl ) );
    00198         break;
    00199
    00200       case EntityTelephone:
    00201         addressee.insertPhoneNumber( readTelephoneValue( cl ) );
    00202         break;
    00203
    00204       case EntityCategories:
    00205         addressee.setCategories( QStringList::split( ",", readTextValue( cl ) ) );
    00206         break;
    00207
    00208       case EntityBirthday:
    00209         addressee.setBirthday( readDateValue( cl ) );
    00210         break;
    00211
    00212       case EntityRevision:
    00213         addressee.setRevision( readDateTimeValue( cl ) );
    00214         break;
    00215
    00216       case EntityGeo:
    00217         addressee.setGeo( readGeoValue( cl ) );
    00218         break;
    00219
    00220       case EntityTimeZone:
    00221         addressee.setTimeZone( readUTCValue( cl ) );
    00222         break;
    00223
    00224       case EntityVersion:
    00225         break;
    00226
    00227       case EntityClass:
    00228         addressee.setSecrecy( readClassValue( cl ) );
    00229         break;
    00230
    00231       case EntityKey:
    00232         addressee.insertKey( readKeyValue( cl ) );
    00233         break;
    00234
    00235       case EntityPhoto:
    00236         addressee.setPhoto( readPictureValue( cl, EntityPhoto, addressee ) );
    00237         break;
    00238
    00239       case EntityLogo:
    00240         addressee.setLogo( readPictureValue( cl, EntityLogo, addressee ) );
    00241         break;
    00242
    00243       case EntityAgent:
    00244         addressee.setAgent( readAgentValue( cl ) );
    00245         break;
    00246
    00247       case EntitySound:
    00248         addressee.setSound( readSoundValue( cl, addressee ) );
    00249         break;
    00250
    00251       default:
    00252         kdDebug(5700) << "VCardFormat::load(): Unsupported entity: "
    00253                     << int( type ) << ": " << cl->asString() << endl;
    00254         break;
    00255     }
    00256   }
    00257
    00258   for( cl = contentLines.first(); cl; cl = contentLines.next() ) {
    00259     EntityType type = cl->entityType();
    00260     if ( type == EntityLabel ) {
    00261       int type = readAddressParam( cl );
    00262       Address address = addressee.address( type );
    00263       if ( address.isEmpty() )
    00264         address.setType( type );
    00265
    00266       address.setLabel( QString::fromUtf8( cl->value()->asString() ) );
    00267       addressee.insertAddress( address );
    00268     }
    00269   }
    00270
    00271   return true;
    00272 }
    00273
    00274 void VCardFormatImpl::saveAddressee( const Addressee &addressee, VCard *v, bool intern )
    00275 {
    00276   ContentLine cl;
    00277   QString value;
    00278
    00279   addTextValue( v, EntityName, addressee.name() );
    00280   addTextValue( v, EntityUID, addressee.uid() );
    00281   addTextValue( v, EntityFullName, addressee.formattedName() );
    00282
    00283   QStringList emails = addressee.emails();
    00284   QStringList::ConstIterator it4;
    00285   for( it4 = emails.begin(); it4 != emails.end(); ++it4 ) {
    00286     addTextValue( v, EntityEmail, *it4 );
    00287   }
    00288
    00289   QStringList customs = addressee.customs();
    00290   QStringList::ConstIterator it5;
    00291   for( it5 = customs.begin(); it5 != customs.end(); ++it5 ) {
    00292     addCustomValue( v, *it5 );
    00293   }
    00294
    00295   addTextValue( v, EntityURL, addressee.url().url() );
    00296
    00297   addNValue( v, addressee );
    00298
    00299   addTextValue( v, EntityNickname, addressee.nickName() );
    00300   addTextValue( v, EntityMailer, addressee.mailer() );
    00301   addTextValue( v, EntityTitle, addressee.title() );
    00302   addTextValue( v, EntityRole, addressee.role() );
    00303   addTextValue( v, EntityOrganisation, addressee.organization() );
    00304   addTextValue( v, EntityNote, addressee.note() );
    00305   addTextValue( v, EntityProductID, addressee.productId() );
    00306   addTextValue( v, EntitySortString, addressee.sortString() );
    00307
    00308   Address::List addresses = addressee.addresses();
    00309   Address::List::ConstIterator it3;
    00310   for( it3 = addresses.begin(); it3 != addresses.end(); ++it3 ) {
    00311     addAddressValue( v, *it3 );
    00312     addLabelValue( v, *it3 );
    00313   }
    00314
    00315   PhoneNumber::List phoneNumbers = addressee.phoneNumbers();
    00316   PhoneNumber::List::ConstIterator it2;
    00317   for( it2 = phoneNumbers.begin(); it2 != phoneNumbers.end(); ++it2 ) {
    00318     addTelephoneValue( v, *it2 );
    00319   }
    00320
    00321   Key::List keys = addressee.keys();
    00322   Key::List::ConstIterator it6;
    00323   for( it6 = keys.begin(); it6 != keys.end(); ++it6 ) {
    00324     addKeyValue( v, *it6 );
    00325   }
    00326
    00327   addTextValue( v, EntityCategories, addressee.categories().join(",") );
    00328
    00329   addDateValue( v, EntityBirthday, addressee.birthday().date() );
    00330   addDateTimeValue( v, EntityRevision, addressee.revision() );
    00331   addGeoValue( v, addressee.geo() );
    00332   addUTCValue( v, addressee.timeZone() );
    00333
    00334   addClassValue( v, addressee.secrecy() );
    00335
    00336   addPictureValue( v, EntityPhoto, addressee.photo(), addressee, intern );
    00337   addPictureValue( v, EntityLogo, addressee.logo(), addressee, intern );
    00338
    00339   addAgentValue( v, addressee.agent() );
    00340
    00341   addSoundValue( v, addressee.sound(), addressee, intern );
    00342 }
    00343
    00344 void VCardFormatImpl::addCustomValue( VCard *v, const QString &txt )
    00345 {
    00346   if ( txt.isEmpty() ) return;
    00347
    00348   ContentLine cl;
    00349   cl.setName( "X-" + txt.left( txt.find( ":" ) ).utf8() );
    00350   QString value = txt.mid( txt.find( ":" ) + 1 );
    00351   if ( value.isEmpty() )
    00352     return;
    00353   cl.setValue( new TextValue( value.utf8() ) );
    00354   v->add(cl);
    00355 }
    00356
    00357 void VCardFormatImpl::addTextValue( VCard *v, EntityType type, const QString &txt )
    00358 {
    00359   if ( txt.isEmpty() ) return;
    00360
    00361   ContentLine cl;
    00362   cl.setName( EntityTypeToParamName( type ) );
    00363   cl.setValue( new TextValue( txt.utf8() ) );
    00364   v->add(cl);
    00365 }
    00366
    00367 void VCardFormatImpl::addDateValue( VCard *vcard, EntityType type,
    00368                                     const QDate &date )
    00369 {
    00370   if ( !date.isValid() ) return;
    00371
    00372   ContentLine cl;
    00373   cl.setName( EntityTypeToParamName( type ) );
    00374
    00375   DateValue *v = new DateValue( date );
    00376   cl.setValue( v );
    00377   vcard->add(cl);
    00378 }
    00379
    00380 void VCardFormatImpl::addDateTimeValue( VCard *vcard, EntityType type,
    00381                                     const QDateTime &dateTime )
    00382 {
    00383   if ( !dateTime.isValid() ) return;
    00384
    00385   ContentLine cl;
    00386   cl.setName( EntityTypeToParamName( type ) );
    00387
    00388   DateValue *v = new DateValue( dateTime );
    00389   cl.setValue( v );
    00390   vcard->add(cl);
    00391 }
    00392
    00393 void VCardFormatImpl::addAddressValue( VCard *vcard, const Address &a )
    00394 {
    00395   if ( a.isEmpty() )
    00396     return;
    00397
    00398   ContentLine cl;
    00399   cl.setName( EntityTypeToParamName( EntityAddress ) );
    00400
    00401   AdrValue *v = new AdrValue;
    00402   v->setPOBox( a.postOfficeBox().utf8() );
    00403   v->setExtAddress( a.extended().utf8() );
    00404   v->setStreet( a.street().utf8() );
    00405   v->setLocality( a.locality().utf8() );
    00406   v->setRegion( a.region().utf8() );
    00407   v->setPostCode( a.postalCode().utf8() );
    00408   v->setCountryName( a.country().utf8() );
    00409   cl.setValue( v );
    00410
    00411   addAddressParam( &cl, a.type() );
    00412
    00413   vcard->add( cl );
    00414 }
    00415
    00416 void VCardFormatImpl::addLabelValue( VCard *vcard, const Address &a )
    00417 {
    00418   if ( a.label().isEmpty() ) return;
    00419
    00420   ContentLine cl;
    00421   cl.setName( EntityTypeToParamName( EntityLabel ) );
    00422   cl.setValue( new TextValue( a.label().utf8() ) );
    00423
    00424   addAddressParam( &cl, a.type() );
    00425
    00426   vcard->add( cl );
    00427 }
    00428
    00429 void VCardFormatImpl::addAddressParam( ContentLine *cl, int type )
    00430 {
    00431   ParamList params;
    00432   if ( type & Address::Dom ) params.append( new Param( "TYPE", "dom" ) );
    00433   if ( type & Address::Intl ) params.append( new Param( "TYPE", "intl" ) );
    00434   if ( type & Address::Parcel ) params.append( new Param( "TYPE", "parcel" ) );
    00435   if ( type & Address::Postal ) params.append( new Param( "TYPE", "postal" ) );
    00436   if ( type & Address::Work ) params.append( new Param( "TYPE", "work" ) );
    00437   if ( type & Address::Home ) params.append( new Param( "TYPE", "home" ) );
    00438   if ( type & Address::Pref ) params.append( new Param( "TYPE", "pref" ) );
    00439   cl->setParamList( params );
    00440 }
    00441
    00442 void VCardFormatImpl::addGeoValue( VCard *vcard, const Geo &geo )
    00443 {
    00444   if ( !geo.isValid() ) return;
    00445
    00446   ContentLine cl;
    00447   cl.setName( EntityTypeToParamName( EntityGeo ) );
    00448
    00449   GeoValue *v = new GeoValue;
    00450   v->setLatitude( geo.latitude() );
    00451   v->setLongitude( geo.longitude() );
    00452
    00453   cl.setValue( v );
    00454   vcard->add(cl);
    00455 }
    00456
    00457 void VCardFormatImpl::addUTCValue( VCard *vcard, const TimeZone &tz )
    00458 {
    00459   if ( !tz.isValid() ) return;
    00460
    00461   ContentLine cl;
    00462   cl.setName( EntityTypeToParamName( EntityTimeZone ) );
    00463
    00464   UTCValue *v = new UTCValue;
    00465
    00466   v->setPositive( tz.offset() >= 0 );
    00467   v->setHour( (tz.offset() / 60) * ( tz.offset() >= 0 ? 1 : -1 ) );
    00468   v->setMinute( (tz.offset() % 60) * ( tz.offset() >= 0 ? 1 : -1 ) );
    00469
    00470   cl.setValue( v );
    00471   vcard->add(cl);
    00472 }
    00473
    00474 void VCardFormatImpl::addClassValue( VCard *vcard, const Secrecy &secrecy )
    00475 {
    00476   ContentLine cl;
    00477   cl.setName( EntityTypeToParamName( EntityClass ) );
    00478
    00479   ClassValue *v = new ClassValue;
    00480   switch ( secrecy.type() ) {
    00481     case Secrecy::Public:
    00482       v->setType( (int)ClassValue::Public );
    00483       break;
    00484     case Secrecy::Private:
    00485       v->setType( (int)ClassValue::Private );
    00486       break;
    00487     case Secrecy::Confidential:
    00488       v->setType( (int)ClassValue::Confidential );
    00489       break;
    00490   }
    00491
    00492   cl.setValue( v );
    00493   vcard->add(cl);
    00494 }
    00495
    00496
    00497 Address VCardFormatImpl::readAddressValue( ContentLine *cl )
    00498 {
    00499   Address a;
    00500   AdrValue *v = (AdrValue *)cl->value();
    00501   a.setPostOfficeBox( QString::fromUtf8( v->poBox() ) );
    00502   a.setExtended( QString::fromUtf8( v->extAddress() ) );
    00503   a.setStreet( QString::fromUtf8( v->street() ) );
    00504   a.setLocality( QString::fromUtf8( v->locality() ) );
    00505   a.setRegion( QString::fromUtf8( v->region() ) );
    00506   a.setPostalCode( QString::fromUtf8( v->postCode() ) );
    00507   a.setCountry( QString::fromUtf8( v->countryName() ) );
    00508
    00509   a.setType( readAddressParam( cl ) );
    00510
    00511   return a;
    00512 }
    00513
    00514 int VCardFormatImpl::readAddressParam( ContentLine *cl )
    00515 {
    00516   int type = 0;
    00517   ParamList params = cl->paramList();
    00518   ParamListIterator it( params );
    00519   for( ; it.current(); ++it ) {
    00520     if ( (*it)->name() == "TYPE" ) {
    00521       if ( (*it)->value() == "dom" ) type |= Address::Dom;
    00522       else if ( (*it)->value() == "intl" ) type |= Address::Intl;
    00523       else if ( (*it)->value() == "parcel" ) type |= Address::Parcel;
    00524       else if ( (*it)->value() == "postal" ) type |= Address::Postal;
    00525       else if ( (*it)->value() == "work" ) type |= Address::Work;
    00526       else if ( (*it)->value() == "home" ) type |= Address::Home;
    00527       else if ( (*it)->value() == "pref" ) type |= Address::Pref;
    00528     }
    00529   }
    00530   return type;
    00531 }
    00532
    00533 void VCardFormatImpl::addNValue( VCard *vcard, const Addressee &a )
    00534 {
    00535   ContentLine cl;
    00536   cl.setName(EntityTypeToParamName( EntityN ) );
    00537   NValue *v = new NValue;
    00538   v->setFamily( a.familyName().utf8() );
    00539   v->setGiven( a.givenName().utf8() );
    00540   v->setMiddle( a.additionalName().utf8() );
    00541   v->setPrefix( a.prefix().utf8() );
    00542   v->setSuffix( a.suffix().utf8() );
    00543
    00544   cl.setValue( v );
    00545   vcard->add(cl);
    00546 }
    00547
    00548 void VCardFormatImpl::readNValue( ContentLine *cl, Addressee &a )
    00549 {
    00550   NValue *v = (NValue *)cl->value();
    00551   a.setFamilyName( QString::fromUtf8( v->family() ) );
    00552   a.setGivenName( QString::fromUtf8( v->given() ) );
    00553   a.setAdditionalName( QString::fromUtf8( v->middle() ) );
    00554   a.setPrefix( QString::fromUtf8( v->prefix() ) );
    00555   a.setSuffix( QString::fromUtf8( v->suffix() ) );
    00556 }
    00557
    00558 void VCardFormatImpl::addTelephoneValue( VCard *v, const PhoneNumber &p )
    00559 {
    00560   if ( p.number().isEmpty() )
    00561     return;
    00562
    00563   ContentLine cl;
    00564   cl.setName(EntityTypeToParamName(EntityTelephone));
    00565   cl.setValue(new TelValue( p.number().utf8() ));
    00566
    00567   ParamList params;
    00568   if( p.type() & PhoneNumber::Home ) params.append( new Param( "TYPE", "home" ) );
    00569   if( p.type() & PhoneNumber::Work ) params.append( new Param( "TYPE", "work" ) );
    00570   if( p.type() & PhoneNumber::Msg ) params.append( new Param( "TYPE", "msg" ) );
    00571   if( p.type() & PhoneNumber::Pref ) params.append( new Param( "TYPE", "pref" ) );
    00572   if( p.type() & PhoneNumber::Voice ) params.append( new Param( "TYPE", "voice" ) );
    00573   if( p.type() & PhoneNumber::Fax ) params.append( new Param( "TYPE", "fax" ) );
    00574   if( p.type() & PhoneNumber::Cell ) params.append( new Param( "TYPE", "cell" ) );
    00575   if( p.type() & PhoneNumber::Video ) params.append( new Param( "TYPE", "video" ) );
    00576   if( p.type() & PhoneNumber::Bbs ) params.append( new Param( "TYPE", "bbs" ) );
    00577   if( p.type() & PhoneNumber::Modem ) params.append( new Param( "TYPE", "modem" ) );
    00578   if( p.type() & PhoneNumber::Car ) params.append( new Param( "TYPE", "car" ) );
    00579   if( p.type() & PhoneNumber::Isdn ) params.append( new Param( "TYPE", "isdn" ) );
    00580   if( p.type() & PhoneNumber::Pcs ) params.append( new Param( "TYPE", "pcs" ) );
    00581   if( p.type() & PhoneNumber::Pager ) params.append( new Param( "TYPE", "pager" ) );
    00582   cl.setParamList( params );
    00583
    00584   v->add(cl);
    00585 }
    00586
    00587 PhoneNumber VCardFormatImpl::readTelephoneValue( ContentLine *cl )
    00588 {
    00589   PhoneNumber p;
    00590   TelValue *value = (TelValue *)cl->value();
    00591   p.setNumber( QString::fromUtf8( value->asString() ) );
    00592
    00593   int type = 0;
    00594   ParamList params = cl->paramList();
    00595   ParamListIterator it( params );
    00596   for( ; it.current(); ++it ) {
    00597     if ( (*it)->name() == "TYPE" ) {
    00598       if ( (*it)->value() == "home" ) type |= PhoneNumber::Home;
    00599       else if ( (*it)->value() == "work" ) type |= PhoneNumber::Work;
    00600       else if ( (*it)->value() == "msg" ) type |= PhoneNumber::Msg;
    00601       else if ( (*it)->value() == "pref" ) type |= PhoneNumber::Pref;
    00602       else if ( (*it)->value() == "voice" ) type |= PhoneNumber::Voice;
    00603       else if ( (*it)->value() == "fax" ) type |= PhoneNumber::Fax;
    00604       else if ( (*it)->value() == "cell" ) type |= PhoneNumber::Cell;
    00605       else if ( (*it)->value() == "video" ) type |= PhoneNumber::Video;
    00606       else if ( (*it)->value() == "bbs" ) type |= PhoneNumber::Bbs;
    00607       else if ( (*it)->value() == "modem" ) type |= PhoneNumber::Modem;
    00608       else if ( (*it)->value() == "car" ) type |= PhoneNumber::Car;
    00609       else if ( (*it)->value() == "isdn" ) type |= PhoneNumber::Isdn;
    00610       else if ( (*it)->value() == "pcs" ) type |= PhoneNumber::Pcs;
    00611       else if ( (*it)->value() == "pager" ) type |= PhoneNumber::Pager;
    00612     }
    00613   }
    00614   p.setType( type );
    00615
    00616   return p;
    00617 }
    00618
    00619 QString VCardFormatImpl::readTextValue( ContentLine *cl )
    00620 {
    00621   VCARD::Value *value = cl->value();
    00622   if ( value ) {
    00623     return QString::fromUtf8( value->asString() );
    00624   } else {
    00625     kdDebug(5700) << "No value: " << cl->asString() << endl;
    00626     return QString::null;
    00627   }
    00628 }
    00629
    00630 QDate VCardFormatImpl::readDateValue( ContentLine *cl )
    00631 {
    00632   DateValue *dateValue = (DateValue *)cl->value();
    00633   if ( dateValue )
    00634     return dateValue->qdate();
    00635   else
    00636     return QDate();
    00637 }
    00638
    00639 QDateTime VCardFormatImpl::readDateTimeValue( ContentLine *cl )
    00640 {
    00641   DateValue *dateValue = (DateValue *)cl->value();
    00642   if ( dateValue )
    00643     return dateValue->qdt();
    00644   else
    00645     return QDateTime();
    00646 }
    00647
    00648 Geo VCardFormatImpl::readGeoValue( ContentLine *cl )
    00649 {
    00650   GeoValue *geoValue = (GeoValue *)cl->value();
    00651   if ( geoValue ) {
    00652     Geo geo( geoValue->latitude(), geoValue->longitude() );
    00653     return geo;
    00654   } else
    00655     return Geo();
    00656 }
    00657
    00658 TimeZone VCardFormatImpl::readUTCValue( ContentLine *cl )
    00659 {
    00660   UTCValue *utcValue = (UTCValue *)cl->value();
    00661   if ( utcValue ) {
    00662     TimeZone tz;
    00663     tz.setOffset(((utcValue->hour()*60)+utcValue->minute())*(utcValue->positive() ? 1 : -1));
    00664     return tz;
    00665   } else
    00666     return TimeZone();
    00667 }
    00668
    00669 Secrecy VCardFormatImpl::readClassValue( ContentLine *cl )
    00670 {
    00671   ClassValue *classValue = (ClassValue *)cl->value();
    00672   if ( classValue ) {
    00673     Secrecy secrecy;
    00674     switch ( classValue->type() ) {
    00675       case ClassValue::Public:
    00676         secrecy.setType( Secrecy::Public );
    00677         break;
    00678       case ClassValue::Private:
    00679         secrecy.setType( Secrecy::Private );
    00680         break;
    00681       case ClassValue::Confidential:
    00682         secrecy.setType( Secrecy::Confidential );
    00683         break;
    00684     }
    00685
    00686     return secrecy;
    00687   } else
    00688     return Secrecy();
    00689 }
    00690
    00691 void VCardFormatImpl::addKeyValue( VCARD::VCard *vcard, const Key &key )
    00692 {
    00693   ContentLine cl;
    00694   cl.setName( EntityTypeToParamName( EntityKey ) );
    00695
    00696   ParamList params;
    00697   if ( key.isBinary() ) {
    00698     cl.setValue( new TextValue( KCodecs::base64Encode( key.binaryData() ) ) );
    00699     params.append( new Param( "ENCODING", "b" ) );
    00700   } else {
    00701     cl.setValue( new TextValue( key.textData().utf8() ) );
    00702   }
    00703
    00704   switch ( key.type() ) {
    00705     case Key::X509:
    00706       params.append( new Param( "TYPE", "X509" ) );
    00707       break;
    00708     case Key::PGP:
    00709       params.append( new Param( "TYPE", "PGP" ) );
    00710       break;
    00711     case Key::Custom:
    00712       params.append( new Param( "TYPE", key.customTypeString().utf8() ) );
    00713       break;
    00714   }
    00715
    00716   cl.setParamList( params );
    00717   vcard->add( cl );
    00718 }
    00719
    00720 Key VCardFormatImpl::readKeyValue( VCARD::ContentLine *cl )
    00721 {
    00722   Key key;
    00723   bool isBinary = false;
    00724   TextValue *v = (TextValue *)cl->value();
    00725
    00726   ParamList params = cl->paramList();
    00727   ParamListIterator it( params );
    00728   for( ; it.current(); ++it ) {
    00729     if ( (*it)->name() == "ENCODING" && (*it)->value() == "b" )
    00730       isBinary = true;
    00731     if ( (*it)->name() == "TYPE" ) {
    00732       if ( (*it)->value().isEmpty() )
    00733         continue;
    00734       if ( (*it)->value() == "X509" )
    00735         key.setType( Key::X509 );
    00736       else if ( (*it)->value() == "PGP" )
    00737         key.setType( Key::PGP );
    00738       else {
    00739         key.setType( Key::Custom );
    00740         key.setCustomTypeString( QString::fromUtf8( (*it)->value() ) );
    00741       }
    00742     }
    00743   }
    00744
    00745
    00746   if ( isBinary ) {
    00747     QByteArray data;
    00748     KCodecs::base64Decode( v->asString().stripWhiteSpace(), data );
    00749     key.setBinaryData( data );
    00750   } else {
    00751     key.setTextData( QString::fromUtf8( v->asString() ) );
    00752   }
    00753
    00754   return key;
    00755 }
    00756
    00757
    00758 void VCardFormatImpl::addAgentValue( VCARD::VCard *vcard, const Agent &agent )
    00759 {
    00760   if ( agent.isIntern() && !agent.addressee() )
    00761     return;
    00762
    00763   if ( !agent.isIntern() && agent.url().isEmpty() )
    00764     return;
    00765
    00766   ContentLine cl;
    00767   cl.setName( EntityTypeToParamName( EntityAgent ) );
    00768
    00769   ParamList params;
    00770   if ( agent.isIntern() ) {
    00771     QString vstr;
    00772     Addressee *addr = agent.addressee();
    00773     if ( addr ) {
    00774       writeToString( (*addr), vstr );
    00775       vstr.replace( QRegExp(":"), "\\:" );
    00776       vstr.replace( QRegExp(","), "\\," );
    00777       vstr.replace( QRegExp(";"), "\\;" );
    00778       vstr.replace( QRegExp("\r\n"), "\\n" );
    00779       cl.setValue( new TextValue( vstr.utf8() ) );
    00780     } else
    00781       return;
    00782   } else {
    00783     cl.setValue( new TextValue( agent.url().utf8() ) );
    00784     params.append( new Param( "VALUE", "uri" ) );
    00785   }
    00786
    00787   cl.setParamList( params );
    00788   vcard->add( cl );
    00789 }
    00790
    00791 Agent VCardFormatImpl::readAgentValue( VCARD::ContentLine *cl )
    00792 {
    00793   Agent agent;
    00794   bool isIntern = true;
    00795   TextValue *v = (TextValue *)cl->value();
    00796
    00797   ParamList params = cl->paramList();
    00798   ParamListIterator it( params );
    00799   for( ; it.current(); ++it ) {
    00800     if ( (*it)->name() == "VALUE" && (*it)->value() == "uri" )
    00801       isIntern = false;
    00802   }
    00803
    00804   if ( isIntern ) {
    00805     QString vstr = QString::fromUtf8( v->asString() );
    00806     vstr.replace( QRegExp("\\\\n"), "\r\n" );
    00807     vstr.replace( QRegExp("\\\\:"), ":" );
    00808     vstr.replace( QRegExp("\\\\,"), "," );
    00809     vstr.replace( QRegExp("\\\\;"), ";" );
    00810     kdDebug() << "oldAgent=" << vstr << endl;
    00811     Addressee *addr = new Addressee;
    00812     readFromString( vstr, *addr );
    00813     agent.setAddressee( addr );
    00814   } else {
    00815     agent.setUrl( QString::fromUtf8( v->asString() ) );
    00816   }
    00817
    00818   return agent;
    00819 }
    00820
    00821 void VCardFormatImpl::addPictureValue( VCARD::VCard *vcard, VCARD::EntityType type, const Picture &pic, const Addressee &addr, bool intern )
    00822 {
    00823   ContentLine cl;
    00824   cl.setName( EntityTypeToParamName( type ) );
    00825
    00826   if ( pic.isIntern() && pic.data().isNull() )
    00827     return;
    00828
    00829   if ( !pic.isIntern() && pic.url().isEmpty() )
    00830     return;
    00831
    00832   ParamList params;
    00833   if ( pic.isIntern() ) {
    00834     QImage img = pic.data();
    00835     if ( intern ) { // only for vCard export we really write the data inline
    00836       /*
    00837        * Since QImage can't export it's data as QByteArray we have to save it
    00838        * to file first and reread it again.
    00839        */
    00840       KTempFile tmpFile;
    00841       img.save( tmpFile.name(), pic.type().utf8() );
    00842       QFile file( tmpFile.name() );
    00843       if ( file.open( IO_ReadOnly ) ) {
    00844         QByteArray data = file.readAll();
    00845         cl.setValue( new TextValue( KCodecs::base64Encode( data ) ) );
    00846         file.close();
    00847       }
    00848
    00849       tmpFile.unlink();
    00850     } else { // save picture in cache
    00851       QString dir;
    00852       if ( type == EntityPhoto )
    00853         dir = "photos";
    00854       if ( type == EntityLogo )
    00855         dir = "logos";
    00856
    00857       img.save( locateLocal( "data", "kabc/" + dir + "/" + addr.uid() ), pic.type().utf8() );
    00858       cl.setValue( new TextValue( "<dummy>" ) );
    00859     }
    00860     params.append( new Param( "ENCODING", "b" ) );
    00861     if ( !pic.type().isEmpty() )
    00862       params.append( new Param( "TYPE", pic.type().utf8() ) );
    00863   } else {
    00864     cl.setValue( new TextValue( pic.url().utf8() ) );
    00865     params.append( new Param( "VALUE", "uri" ) );
    00866   }
    00867
    00868   cl.setParamList( params );
    00869   vcard->add( cl );
    00870 }
    00871
    00872 Picture VCardFormatImpl::readPictureValue( VCARD::ContentLine *cl, VCARD::EntityType type, const Addressee &addr )
    00873 {
    00874   Picture pic;
    00875   bool isInline = false;
    00876   QString picType;
    00877   TextValue *v = (TextValue *)cl->value();
    00878
    00879   ParamList params = cl->paramList();
    00880   ParamListIterator it( params );
    00881   for( ; it.current(); ++it ) {
    00882     if ( (*it)->name() == "ENCODING" && (*it)->value() == "b" )
    00883       isInline = true;
    00884     if ( (*it)->name() == "TYPE" && !(*it)->value().isEmpty() )
    00885       picType = QString::fromUtf8( (*it)->value() );
    00886   }
    00887
    00888   if ( isInline ) {
    00889     QImage img;
    00890     if ( v->asString() == "<dummy>" ) { // no picture inline stored => picture is in cache
    00891       QString dir;
    00892       if ( type == EntityPhoto )
    00893         dir = "photos";
    00894       if ( type == EntityLogo )
    00895         dir = "logos";
    00896
    00897       img.load( locateLocal( "data", "kabc/" + dir + "/" + addr.uid() ) );
    00898     } else {
    00899       QByteArray data;
    00900       KCodecs::base64Decode( v->asString(), data );
    00901       img.loadFromData( data );
    00902     }
    00903     pic.setData( img );
    00904     pic.setType( picType );
    00905   } else {
    00906     pic.setUrl( QString::fromUtf8( v->asString() ) );
    00907   }
    00908
    00909   return pic;
    00910 }
    00911
    00912 void VCardFormatImpl::addSoundValue( VCARD::VCard *vcard, const Sound &sound, const Addressee &addr, bool intern )
    00913 {
    00914   ContentLine cl;
    00915   cl.setName( EntityTypeToParamName( EntitySound ) );
    00916
    00917   if ( sound.isIntern() && sound.data().isNull() )
    00918     return;
    00919
    00920   if ( !sound.isIntern() && sound.url().isEmpty() )
    00921     return;
    00922
    00923   ParamList params;
    00924   if ( sound.isIntern() ) {
    00925     QByteArray data = sound.data();
    00926     if ( intern ) { // only for vCard export we really write the data inline
    00927         cl.setValue( new TextValue( KCodecs::base64Encode( data ) ) );
    00928     } else { // save sound in cache
    00929       QFile file( locateLocal( "data", "kabc/sounds/" + addr.uid() ) );
    00930       if ( file.open( IO_WriteOnly ) ) {
    00931         file.writeBlock( data );
    00932       }
    00933       cl.setValue( new TextValue( "<dummy>" ) );
    00934     }
    00935     params.append( new Param( "ENCODING", "b" ) );
    00936   } else {
    00937     cl.setValue( new TextValue( sound.url().utf8() ) );
    00938     params.append( new Param( "VALUE", "uri" ) );
    00939   }
    00940
    00941   cl.setParamList( params );
    00942   vcard->add( cl );
    00943 }
    00944
    00945 Sound VCardFormatImpl::readSoundValue( VCARD::ContentLine *cl, const Addressee &addr )
    00946 {
    00947   Sound sound;
    00948   bool isInline = false;
    00949   TextValue *v = (TextValue *)cl->value();
    00950
    00951   ParamList params = cl->paramList();
    00952   ParamListIterator it( params );
    00953   for( ; it.current(); ++it ) {
    00954     if ( (*it)->name() == "ENCODING" && (*it)->value() == "b" )
    00955       isInline = true;
    00956   }
    00957
    00958   if ( isInline ) {
    00959     QByteArray data;
    00960     if ( v->asString() == "<dummy>" ) { // no sound inline stored => sound is in cache
    00961       QFile file( locateLocal( "data", "kabc/sounds/" + addr.uid() ) );
    00962       if ( file.open( IO_ReadOnly ) ) {
    00963         data = file.readAll();
    00964         file.close();
    00965       }
    00966     } else {
    00967       KCodecs::base64Decode( v->asString(), data );
    00968     }
    00969     sound.setData( data );
    00970   } else {
    00971     sound.setUrl( QString::fromUtf8( v->asString() ) );
    00972   }
    00973
    00974   return sound;
    00975 }
    00976
    00977 bool VCardFormatImpl::readFromString( const QString &vcard, Addressee &addressee )
    00978 {
    00979   VCardEntity e( vcard.utf8() );
    00980   VCardListIterator it( e.cardList() );
    00981
    00982   if ( it.current() ) {
    00983     VCard v(*it.current());
    00984     loadAddressee( addressee, v );
    00985     return true;
    00986   }
    00987
    00988   return false;
    00989 }
    00990
    00991 bool VCardFormatImpl::writeToString( const Addressee &addressee, QString &vcard )
    00992 {
    00993   VCardEntity vcards;
    00994   VCardList vcardlist;
    00995   vcardlist.setAutoDelete( true );
    00996
    00997   VCard *v = new VCard;
    00998
    00999   saveAddressee( addressee, v, true );
    01000
    01001   vcardlist.append( v );
    01002   vcards.setCardList( vcardlist );
    01003   vcard = QString::fromUtf8( vcards.asString() );
    01004
    01005   return true;
    01006 }

This file is part of the documentation for kdelibs Version 3.1.5.
Documentation copyright © 1996-2002 the KDE developers.
Generated on Wed Jan 28 13:29:24 2004 by doxygen 1.3.4 written by Dimitri van Heesch, © 1997-2001