fixed some newline probs

4 files changed, 11 insertions, 10 deletions

diff --git a/kabc/vcard/ContentLine.cpp b/kabc/vcard/ContentLine.cpp
index f7e04a9..c368172 100644
--- a/kabc/vcard/ContentLine.cpp
+++ b/kabc/vcard/ContentLine.cpp
@@ -182,139 +182,140 @@ ContentLine::_parse()
 	}
 
 	vDebug("Group == " + group_);
 	vDebug("firstPart == " + firstPart);
 	vDebug("valuePart == " + valuePart);
 
 	// Now we have the group, the name and param list together and the value.
 
 	QStrList l;
 
 	RTokenise(firstPart, ";", l);
 
 	if (l.count() == 0) {// invalid - no name !
 		vDebug("No name for this content line !");
 		return;
 	}
 
 	name_ = l.at(0);
 
 	// Now we have the name, so the rest of 'l' is the params.
 	// Remove the name part.
 	l.remove(0u);
 
 	entityType_	= EntityNameToEntityType(name_);
 	paramType_	= EntityTypeToParamType(entityType_);
 
 	unsigned int i = 0;
 
 	// For each parameter, create a new parameter of the correct type.
 
 	QStrListIterator it(l);
 
 	for (; it.current(); ++it, i++) {
 
 		QCString str = *it;
 
 		split = str.find("=");
 		if (split < 0 ) {
 			vDebug("No '=' in paramter.");
 			continue;
 		}
 
 		QCString paraName = str.left(split);
 		QCString paraValue = str.mid(split + 1);
 
 		QStrList paraValues;
 		RTokenise(paraValue, ",", paraValues);
 
 		QStrListIterator it2( paraValues );
 
 		for(; it2.current(); ++it2) {
 
 			Param *p = new Param;
 			p->setName( paraName );
 			p->setValue( *it2 );
 
 			paramList_.append(p);
 		}
 	}
 
 	// Create a new value of the correct type.
 
 	valueType_ = EntityTypeToValueType(entityType_);
 
 //	kdDebug(5710) << "valueType: " << valueType_ << endl;
 
 	switch (valueType_) {
 
 		case ValueSound:	value_ = new SoundValue;	break;
 		case ValueAgent:	value_ = new AgentValue;	break;
 		case ValueAddress:	value_ = new AdrValue;		break;
 		case ValueTel:		value_ = new TelValue;		break;
 		case ValueTextBin:	value_ = new TextBinValue;	break;
 		case ValueOrg:		value_ = new OrgValue;		break;
 		case ValueN:		value_ = new NValue;		break;
 		case ValueUTC:		value_ = new UTCValue;		break;
 		case ValueURI:		value_ = new URIValue;		break;
 		case ValueClass:	value_ = new ClassValue;	break;
 		case ValueFloat:	value_ = new FloatValue;	break;
 		case ValueImage:	value_ = new ImageValue;	break;
 		case ValueDate:		value_ = new DateValue;		break;
 		case ValueTextList:	value_ = new TextListValue;	break;
 		case ValueGeo:		value_ = new GeoValue;		break;
 		case ValueText:
 		case ValueUnknown:
 		default:		value_ = new TextValue;		break;
 	}
 
 	*value_ = valuePart;
 }
 
 	void
 ContentLine::_assemble()
 {
 	vDebug("Assemble (argl) - my name is \"" + name_ + "\"");
 	strRep_.truncate(0);
 
 	QCString line;
 
 	if (!group_.isEmpty())
 		line += group_ + '.';
 
 	line += name_;
 
 	vDebug("Adding parameters");
 	ParamListIterator it(paramList_);
 
 	for (; it.current(); ++it)
 		line += ";" + it.current()->asString();
 
 	vDebug("Adding value");
 	if (value_ != 0)
 		line += ":" + value_->asString();
 	else
 		vDebug("No value");
 
 	// Quote newlines
 	line = line.replace( QRegExp( "\n" ), "\\n" );
 
 	// Fold lines longer than 72 chars
 	const int maxLen = 72;
 	uint cursor = 0;
 	while( line.length() > ( cursor + 1 ) * maxLen ) {
 		strRep_ += line.mid( cursor * maxLen, maxLen );
 		strRep_ += "\r\n ";
 		++cursor;
 	}
 	strRep_ += line.mid( cursor * maxLen );
+    //qDebug("ContentLine::_assemble()\n%s*****", strRep_.data());
 }
 
 	void
 ContentLine::clear()
 {
 	group_.truncate(0);
 	name_.truncate(0);
 	paramList_.clear();
         delete value_;
 	value_ = 0;
 }
diff --git a/kabc/vcardformatimpl.cpp b/kabc/vcardformatimpl.cpp
index ede5773..c31af46 100644
--- a/kabc/vcardformatimpl.cpp
+++ b/kabc/vcardformatimpl.cpp
@@ -723,260 +723,260 @@ void VCardFormatImpl::addKeyValue( VCARD::VCard *vcard, const Key &key )
   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;
   TextValue *v = (TextValue *)cl->value();
 
   ParamList params = cl->paramList();
   ParamListIterator it( params );
   for( ; it.current(); ++it ) {
     if ( (*it)->name() == "VALUE" && (*it)->value() == "uri" )
       isIntern = false;
   }
 
   if ( isIntern ) {
     QString vstr = QString::fromUtf8( v->asString() );
     qDebug("VCardFormatImpl::addAgentValue please verify if replace is correct");
 /*US
     vstr.replace( "\\n", "\r\n" );
     vstr.replace( "\\:", ":" );
     vstr.replace( "\\,", "," );
     vstr.replace( "\\;", ";" );
 */
-    vstr.replace( QRegExp("\\n"), "\r\n" );
-    vstr.replace( QRegExp("\\:"), ":" );
-    vstr.replace( QRegExp("\\,"), "," );
-    vstr.replace( QRegExp("\\;"), ";" );
+    vstr.replace( QRegExp("\\\\n"), "\r\n" );
+    vstr.replace( QRegExp("\\\\:"), ":" );
+    vstr.replace( QRegExp("\\\\,"), "," );
+    vstr.replace( QRegExp("\\\\;"), ";" );
 
     Addressee *addr = new Addressee;
     readFromString( vstr, *addr );
     agent.setAddressee( addr );
   } else {
     agent.setUrl( QString::fromUtf8( v->asString() ) );
   }
 
   return agent;
 }
 
 void VCardFormatImpl::addPictureValue( VCARD::VCard *vcard, VCARD::EntityType type, const Picture &pic, const Addressee &addr, bool intern )
 {
   ContentLine cl;
   cl.setName( EntityTypeToParamName( type ) );
 
   if ( pic.isIntern() && pic.data().isNull() )
     return;
 
   if ( !pic.isIntern() && pic.url().isEmpty() )
     return;
 
   ParamList params;
   if ( pic.isIntern() ) {
     QImage img = pic.data();
     if ( intern ) { // only for vCard export we really write the data inline
       QByteArray data;
       QDataStream s( data, IO_WriteOnly );
       s.setVersion( 4 ); // to produce valid png files
       s << img;
       cl.setValue( new TextValue( KCodecs::base64Encode( data ) ) );
 
     } else { // save picture in cache
       QString dir;
       if ( type == EntityPhoto )
         dir = "photos";
       if ( type == EntityLogo )
         dir = "logos";
 
       img.save( locateLocal( "data", "kabc/" + dir + "/" + addr.uid() ), pic.type().utf8() );
       cl.setValue( new TextValue( "<dummy>" ) );
     }
     params.append( new Param( "ENCODING", "b" ) );
     if ( !pic.type().isEmpty() )
       params.append( new Param( "TYPE", pic.type().utf8() ) );
   } else {
 
     cl.setValue( new TextValue( pic.url().utf8() ) );
     params.append( new Param( "VALUE", "uri" ) );
   }
 
   cl.setParamList( params );
   vcard->add( cl );
 }
 
 Picture VCardFormatImpl::readPictureValue( VCARD::ContentLine *cl, VCARD::EntityType type, const Addressee &addr )
 {
   Picture pic;
   bool isInline = false;
   QString picType;
   TextValue *v = (TextValue *)cl->value();
 
   ParamList params = cl->paramList();
   ParamListIterator it( params );
   for( ; it.current(); ++it ) {
     if ( (*it)->name() == "ENCODING" && (*it)->value() == "b" )
       isInline = true;
     if ( (*it)->name() == "TYPE" && !(*it)->value().isEmpty() )
       picType = QString::fromUtf8( (*it)->value() );
   }
 
   if ( isInline ) {
     QImage img;
     if ( v->asString() == "<dummy>" ) { // no picture inline stored => picture is in cache
       QString dir;
       if ( type == EntityPhoto )
         dir = "photos";
       if ( type == EntityLogo )
         dir = "logos";
 
       img.load( locateLocal( "data", "kabc/" + dir + "/" + addr.uid() ) );
     } else {
       QByteArray data;
       KCodecs::base64Decode( v->asString(), data );
       img.loadFromData( data );
     }
     pic.setData( img );
     pic.setType( picType );
   } else {
     pic.setUrl( QString::fromUtf8( v->asString() ) );
   }
 
   return pic;
 }
 
 void VCardFormatImpl::addSoundValue( VCARD::VCard *vcard, const Sound &sound, const Addressee &addr, bool intern )
 {
   ContentLine cl;
   cl.setName( EntityTypeToParamName( EntitySound ) );
 
   if ( sound.isIntern() && sound.data().isNull() )
     return;
 
   if ( !sound.isIntern() && sound.url().isEmpty() )
     return;
 
   ParamList params;
   if ( sound.isIntern() ) {
     QByteArray data = sound.data();
     if ( intern ) { // only for vCard export we really write the data inline
         cl.setValue( new TextValue( KCodecs::base64Encode( data ) ) );
     } else { // save sound in cache
       QFile file( locateLocal( "data", "kabc/sounds/" + addr.uid() ) );
       if ( file.open( IO_WriteOnly ) ) {
         file.writeBlock( data );
       }
       cl.setValue( new TextValue( "<dummy>" ) );
     }
     params.append( new Param( "ENCODING", "b" ) );
   } else {
     cl.setValue( new TextValue( sound.url().utf8() ) );
     params.append( new Param( "VALUE", "uri" ) );
   }
 
   cl.setParamList( params );
   vcard->add( cl );
 }
 
diff --git a/kabc/vcardparser/vcardparser.cpp b/kabc/vcardparser/vcardparser.cpp
index 9ea084d..bec2a0c 100644
--- a/kabc/vcardparser/vcardparser.cpp
+++ b/kabc/vcardparser/vcardparser.cpp
@@ -1,233 +1,233 @@
 /*
     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 <qregexp.h>
 
 #include <kmdcodec.h>
 
 #include "vcardparser.h"
 
 #define FOLD_WIDTH 75
 
 using namespace KABC;
 
 VCardParser::VCardParser()
 {
 }
 
 VCardParser::~VCardParser()
 {
 }
 
 VCard::List VCardParser::parseVCards( const QString& text )
 {
   VCard currentVCard;
   VCard::List vCardList;
   QString currentLine;
 
   QStringList lines = QStringList::split( QRegExp( "[\x0d\x0a]" ), text );
   QStringList::Iterator it;
 
   bool inVCard = false;
   for ( it = lines.begin(); it != lines.end(); ++it ) {
 
     if ( (*it).isEmpty() ) // empty line
       continue;
 
     if ( (*it)[ 0 ] == ' ' || (*it)[ 0 ] == '\t' ) { // folded line => append to previous
       currentLine += (*it).remove( 0, 1 );
       continue;
     } else {
       if ( inVCard && !currentLine.isEmpty() ) { // now parse the line
         int colon = currentLine.find( ':' );
         if ( colon == -1 ) { // invalid line
           currentLine = (*it);
           continue;
         }
 
         VCardLine vCardLine;
         QString key = currentLine.left( colon ).stripWhiteSpace();
         QString value = currentLine.mid( colon + 1 );
 
         QStringList params = QStringList::split( ';', key );
         vCardLine.setIdentifier( params[0] );
         if ( params.count() > 1 ) { // find all parameters
           for ( uint i = 1; i < params.count(); ++i ) {
             QStringList pair = QStringList::split( '=', params[i] );
 //US            if ( pair.size() == 1 ) {
             if ( pair.count() == 1 ) {
                 pair.prepend( "type" );
             }
             if ( pair[1].contains( ',' ) ) { // parameter in type=x,y,z format
               QStringList args = QStringList::split( ',', pair[ 1 ] );
               for ( uint j = 0; j < args.count(); ++j )
                 vCardLine.addParameter( pair[0].lower(), args[j] );
             } else
               vCardLine.addParameter( pair[0].lower(), pair[1] );
           }
         }
 
         params = vCardLine.parameterList();
         if ( params.contains( "encoding" ) ) { // have to decode the data
 #if 0
           QByteArray input, output;
           input = value.local8Bit();
           if ( vCardLine.parameter( "encoding" ).lower() == "b" )
             KCodecs::base64Decode( input, output );
           else if ( vCardLine.parameter( "encoding" ).lower() == "quoted-printable" )
             KCodecs::quotedPrintableDecode( input, output );
 
           //qDebug("VCardParser::parseVCards has to be verified");
           //US I am not sure if this is correct
           //US          vCardLine.setValue( output );
           QCString cs(output);
           qDebug("len1 %d len2 %d ",input.size(), output.size( ));
 #endif
           QCString cs = value.local8Bit();
           qDebug("****************************************** ");
           qDebug("************* WARNING ******************** ");
           qDebug("****************************************** ");
           qDebug("Make sure, the decoding is done after");
           qDebug("QVariant conversion!");
           qDebug("Insert Line DECODING OKAY, where this is implemented");
           // use for decoding the above code!
           vCardLine.setValue( cs );
         } else {
         
             //qDebug("VCardParser::parseVCards has to be verified");
 //US          vCardLine.setValue( value.replace( "\\n", "\n" ) );
-          vCardLine.setValue( value.replace( QRegExp("\\n"), "\n" ) );
+          vCardLine.setValue( value.replace( QRegExp("\\\\n"), "\n" ) );
         }
 
         currentVCard.addLine( vCardLine );
       }
       // we do not save the start and end tag as vcardline
       if ( (*it).lower().startsWith( "begin:vcard" ) ) {
         inVCard = true;
         //qDebug("VCardParser::parseVCards has to be verified");
 //US        currentLine.setLength( 0 );
         currentLine = "";
         currentVCard.clear(); // flush vcard
         continue;
       }
 
       if ( (*it).lower().startsWith( "end:vcard" ) ) {
         inVCard = false;
         vCardList.append( currentVCard );
         //qDebug("VCardParser::parseVCards has to be verified");
 //US        currentLine.setLength( 0 );
         currentLine = "";
         currentVCard.clear(); // flush vcard
         continue;
       }
 
       currentLine = (*it);
     }
   }
 
   return vCardList;
 }
 
 QString VCardParser::createVCards( const VCard::List& list )
 {
   QString text;
   QString textLine;
   QString encodingType;
   QStringList idents;
   QStringList params;
   QStringList values;
   QStringList::ConstIterator identIt;
   QStringList::Iterator paramIt;
   QStringList::Iterator valueIt;
 
   VCardLine::List lines;
   VCardLine::List::Iterator lineIt;
   VCard::List::ConstIterator cardIt;
 
   bool hasEncoding;
 
   
   // iterate over the cards
   for ( cardIt = list.begin(); cardIt != list.end(); ++cardIt ) {
     text.append( "BEGIN:VCARD\r\n" );
 
     idents = (*cardIt).identifiers();
     for ( identIt = idents.begin(); identIt != idents.end(); ++identIt ) {
       VCard card = (*cardIt);
       lines = card.lines( (*identIt) );
 
       // iterate over the lines
       for ( lineIt = lines.begin(); lineIt != lines.end(); ++lineIt ) {
         if ( !(*lineIt).value().asString().isEmpty() ) {
           textLine = (*lineIt).identifier();
 
           params = (*lineIt).parameterList();
           hasEncoding = false;
           if ( params.count() > 0 ) { // we have parameters
             for ( paramIt = params.begin(); paramIt != params.end(); ++paramIt ) {
               if ( (*paramIt) == "encoding" ) {
                 hasEncoding = true;
                 encodingType = (*lineIt).parameter( "encoding" ).lower();
               }
 
               values = (*lineIt).parameters( *paramIt );
               for ( valueIt = values.begin(); valueIt != values.end(); ++valueIt ) {
                 textLine.append( ";" + (*paramIt).upper() );
                 if ( !(*valueIt).isEmpty() )
                   textLine.append( "=" + (*valueIt) );
               }
             }
           }
 
           if ( hasEncoding ) { // have to encode the data
             QByteArray input, output;
             
     qDebug("VCardParser::createVCards has to be verified");
 //US            input = (*lineIt).value().toByteArray();
 
 //US I am not sure if this is correct    
             QCString cs ((*lineIt).value().toCString());
             input = cs;
             
             if ( encodingType == "b" )
               KCodecs::base64Encode( input, output );
             else if ( encodingType == "quoted-printable" )
               KCodecs::quotedPrintableEncode( input, output );
             textLine.append( ":" + QString( output ) );
           } else {
     qDebug("VCardParser::createVCards has to be verified");
 //US            textLine.append( ":" + (*lineIt).value().asString().replace( "\n", "\\n" ) );
             textLine.append( ":" + (*lineIt).value().asString().replace( QRegExp("\n"), "\\n" ) );
           }
           if ( textLine.length() > FOLD_WIDTH ) { // we have to fold the line
             for ( uint i = 0; i <= ( textLine.length() / FOLD_WIDTH ); ++i )
               text.append( ( i == 0 ? "" : " " ) + textLine.mid( i * FOLD_WIDTH, FOLD_WIDTH ) + "\r\n" );
           } else
             text.append( textLine + "\r\n" );
         }
       }
     }
 
     text.append( "END:VCARD\r\n" );
     text.append( "\r\n" );
   }
 
   return text;
 }
diff --git a/kabc/vcardparser/vcardtool.cpp b/kabc/vcardparser/vcardtool.cpp
index 3fb212e..d1f823b 100644
--- a/kabc/vcardparser/vcardtool.cpp
+++ b/kabc/vcardparser/vcardtool.cpp
@@ -687,212 +687,212 @@ VCardLine VCardTool::createSound( const Sound &snd )
     if ( !snd.data().isEmpty() ) {
     qDebug("VCardTool::createSound has to be verified");
 //US      line.setValue( snd.data() );
 
 //US I am not sure if this is correct    
       QCString cs(snd.data());
       line.setValue( cs );
       
       
       line.addParameter( "encoding", "b" );
       // TODO: need to store sound type!!!
     }
   } else if ( !snd.url().isEmpty() ) {
     line.setValue( snd.url() );
     line.addParameter( "value", "URI" );
   }
 
   return line;
 }
 
 Key VCardTool::parseKey( const VCardLine &line )
 {
   Key key;
 
   QStringList params = line.parameterList();
   if ( params.contains( "encoding" ) ) {
     qDebug("VCardTool::parseKey has to be verified");
 //US    key.setBinaryData( line.value().asByteArray() );
 
 //US I am not sure if this is correct    
       QCString cs( line.value().asCString() );
       key.setBinaryData( cs );
   }
   else
     key.setTextData( line.value().asString() );
 
   if ( params.contains( "type" ) ) {
     if ( line.parameter( "type" ).lower() == "x509" )
       key.setType( Key::X509 );
     else if ( line.parameter( "type" ).lower() == "pgp" )
       key.setType( Key::PGP );
     else {
       key.setType( Key::Custom );
       key.setCustomTypeString( line.parameter( "type" ) );
     }
   }
 
   return key;
 }
 
 VCardLine VCardTool::createKey( const Key &key )
 {
   VCardLine line( "KEY" );
 
   if ( key.isBinary() ) {
     if ( !key.binaryData().isEmpty() ) {
     qDebug("VCardTool::createKey has to be verified");
 //US      line.setValue( key.binaryData() );
 //US I am not sure if this is correct    
     QCString cs(key.binaryData());
     line.setValue( cs );
       
       
       line.addParameter( "encoding", "b" );
     }
   } else if ( !key.textData().isEmpty() )
     line.setValue( key.textData() );
 
   if ( key.type() == Key::X509 )
     line.addParameter( "type", "X509" );
   else if ( key.type() == Key::PGP )
     line.addParameter( "type", "PGP" );
   else if ( key.type() == Key::Custom )
     line.addParameter( "type", key.customTypeString() );
 
   return line;
 }
 
 Secrecy VCardTool::parseSecrecy( const VCardLine &line )
 {
   Secrecy secrecy;
 
   if ( line.value().asString().lower() == "public" )
     secrecy.setType( Secrecy::Public );
   if ( line.value().asString().lower() == "private" )
     secrecy.setType( Secrecy::Private );
   if ( line.value().asString().lower() == "confidential" )
     secrecy.setType( Secrecy::Confidential );
 
   return secrecy;
 }
 
 VCardLine VCardTool::createSecrecy( const Secrecy &secrecy )
 {
   VCardLine line( "CLASS" );
 
   int type = secrecy.type();
 
   if ( type == Secrecy::Public )
     line.setValue( "PUBLIC" );
   else if ( type == Secrecy::Private )
     line.setValue( "PRIVATE" );
   else if ( type == Secrecy::Confidential )
     line.setValue( "CONFIDENTIAL" );
 
   return line;
 }
 
 Agent VCardTool::parseAgent( const VCardLine &line )
 {
   Agent agent;
 
   QStringList params = line.parameterList();
   if ( params.contains( "value" ) ) {
     if ( line.parameter( "value" ).lower() == "uri" )
       agent.setUrl( line.value().asString() );
   } else {
     QString str = line.value().asString();
     
 //US using the old implementation instead
     qDebug("VCardTool::parseAgent has to be verified");
 /*US    
     str.replace( "\\n", "\r\n" );
     str.replace( "\\N", "\r\n" );
     str.replace( "\\;", ";" );
     str.replace( "\\:", ":" );
     str.replace( "\\,", "," );
 */
-    str.replace( QRegExp("\\n") , "\r\n" );
-    str.replace( QRegExp("\\N") , "\r\n" );
-    str.replace( QRegExp("\\;") , ";" );
-    str.replace( QRegExp("\\:") , ":" );
-    str.replace( QRegExp("\\,") , "," );
+    str.replace( QRegExp("\\\\n") , "\r\n" );
+    str.replace( QRegExp("\\\\N") , "\r\n" );
+    str.replace( QRegExp("\\\\;") , ";" );
+    str.replace( QRegExp("\\\\:") , ":" );
+    str.replace( QRegExp("\\\\,") , "," );
     
     Addressee::List list = parseVCards( str );
     if ( list.count() > 0 ) {
       Addressee *addr = new Addressee;
       *addr = list[ 0 ];
       agent.setAddressee( addr );
     }
   }
 
   return agent;
 }
 
 VCardLine VCardTool::createAgent( VCard::Version version, const Agent &agent )
 {
   VCardLine line( "AGENT" );
 
   if ( agent.isIntern() ) {
     if ( agent.addressee() != 0 ) {
       Addressee::List list;
       list.append( *agent.addressee() );
 
       QString str = createVCards( list, version );
       
 //US using the old implementation instead
     qDebug("VCardTool::createAgent has to be verified");
 /*US    
       str.replace( "\r\n", "\\n" );
       str.replace( ";", "\\;" );
       str.replace( ":", "\\:" );
       str.replace( ",", "\\," );
 */      
       str.replace( QRegExp("\r\n"), "\\n" );
       str.replace( QRegExp(";"), "\\;" );
       str.replace( QRegExp(":"), "\\:" );
       str.replace( QRegExp(","), "\\," );
       line.setValue( str );
     }
   } else if ( !agent.url().isEmpty() ) {
     line.setValue( agent.url() );
     line.addParameter( "value", "URI" );
   }
 
   return line;
 }
 
 QStringList VCardTool::splitString( const QChar &sep, const QString &str )
 {
   QStringList list;
   QString value( str );
 
   int start = 0;
   int pos = value.find( sep, start );
 
   while ( pos != -1 ) {
     if ( value[ pos - 1 ] != '\\' ) {
       if ( pos > start && pos <= (int)value.length() )
         list << value.mid( start, pos - start );
       else
         list << QString::null;
 
       start = pos + 1;
       pos = value.find( sep, start );
     } else {
       if ( pos != 0 ) {
         value.replace( pos - 1, 2, sep );
         pos = value.find( sep, pos );
       } else    
         pos = value.find( sep, pos + 1 );
     }
   }
 
   int l = value.length() - 1;
   if ( value.mid( start, l - start + 1 ).length() > 0 )
     list << value.mid( start, l - start + 1 );
   else
     list << QString::null;
 
   return list;
 }