utf8 kapi import fix

7 files changed, 67 insertions, 61 deletions

diff --git a/bin/kdepim/WhatsNew.txt b/bin/kdepim/WhatsNew.txt
index bc0c62a..97c8154 100644
--- a/bin/kdepim/WhatsNew.txt
+++ b/bin/kdepim/WhatsNew.txt
@@ -1,254 +1,256 @@
 Info about the changes in new versions of KDE-Pim/Pi
 
 ********** VERSION 2.0.26 ************
 
 And again fixed some bugs.
 Added two more fields to the KA/Pi view config:
 A "Mobile (home)" and a "Mobile (work)" field.
+Fixed utf8 import (e.g. for Japaneese text) in KA/Pi.
+
 
 ********** VERSION 2.0.25 ************
 
 And again fixed some bugs.
 
 ********** VERSION 2.0.24 ************
 
 Fixed again a lot of small bugs.
 Some performance optimizations in date navigator.
 Month view displays now multi days events on top of each cell, such that it is more likely that all multi days items of one event are in the same row.
 
 ********** VERSION 2.0.23 ************
 
 Fixed again a lot of small and strange  bugs, e.g. the missing toolbar of KA/Pi after a new installation.
 Fixed the (agenda) layout of KO/Pi on 5500er.
 Some usebility enhancements (e.g. reselection the current item of the todo view after some changes).
 
 ********** VERSION 2.0.22 ************
 
 KO/Pi:
 Fix for creating events/todos via the abgenda context menu.
 Added option to split toolbar to 3 toolbars.
 (Toolbar moving s disabled for this option due to a bug in Qt somewhere). 
 Added option to show one small filter-view-toolbar.
 Added a print option to the desktop version:
 Now you can print out the view of the "Event Viewer".
 That means you can print all data of one particular event/todo.
 Added scaling options to printout of Event Viewer and What'sNext View.
 Fixed some problems in the month view in "week start sunday" mode.
 KA/Pi:
 Added two more config options.
 Fixed resizing problem of address request dialog when orientation was switched. 
 Cleaned up the menu structure.
 Fixed some more problems.
 
 Fixed the annoying problem that scrolling continued after the key was released in KO/Pi Monthview and the KA/Pi views.
 
 And, this is a really cool option (Ben did suggest it):
 Now KO/Pi and KA/Pi can be run from a USB stick:
 All data is read from and written to the stick.
 You can enable this in the global configure option TAB with:
 Save using LOCAL storage.
 Just put KDE-Pim/Pi on a memory stick and you can access all your PIM data on every computer with Windows XP. It will work with the ME and Linux versions as well. I will put a memory stick version for teh next stable release online.
 
 ********** VERSION 2.0.21 ************
 
 Fixed another SMTP problem in OM/Pi.
 Some small changed in the new datenavigator in KO/Pi.
 Changed default setting for new filter in KA/Pi to "exclude categories".
 Changed the default font size for 640x480 display .
 Changed popup menu behaviour in agenda and list view.
 Fixed some layout problems of the date label size in the month view.
 Made month view update faster.
 Made first datenavigator repainting faster.
 Changed the title of the event/todo edit dialogs.
 Timelabels in agenga changed from 22:00 to 22 oo. ( the oo higher, of course).
 Many small usebility fixes in KO/Pi.
 Pressing the "Calendar" button on the Z switches now to the next view in KO/Pi.
 The set of possible "next views" are the views you have toolbar buttons for.
 
 Made alarm sound working on Linux.
 
 KO/Pi alarm applet changed:
 Made buttons in alarm dialog much bigger.
 Made setting of timer more user friendly by showing the actual timer fire time and making the buttons in the timer settings much bigger.
 The goal was it to make it possible to use a finger tip  ( and not the stylus ) on the touchscreen to adjust the settings.
 
 And because this version is realeased at Easter, I added an Easter-egg:
 With a new undocumented command you can get a message box about the next alarm.
 Good luck to find it!
 
 
 
 ********** VERSION 2.0.20 ************
 
 Two small fixes in OM/Pi.
 
 Better resizing of  the new datenavigator in KO/Pi.
 
 ********** VERSION 2.0.19 ************
 KO/Pi:
 Enhancements and bugfixes in the new datenavigator.
 Bugfix in this changelog:
 The datenavigator was changed in version 2.0.18, not the datepicker.
 
 ********** VERSION 2.0.18 ************
 KO/Pi:
 Fixed some minor problems.
 Cleaned up the KO/Pi config dialog.
 Fixed problem moving events in aganda view.
 Made datepicker scaleable, i.e. if the datenavigator shows now a 
 datenavigator matrix depending on its size.
 Birthdays are now displayed green in the datenavigator.
 What'sThis Help in datenavigator shows all events of the day. 
 
 OM/Pi:
 Updated the backend mail library to the latest version.
 Please backup your mail before using this version.
 
 ********** VERSION 2.0.17 ************
 
 KO/Pi:
 Tooltips in month view were not sorted. Fixed.
 Daylabel in agenda view ( for display of one day ) was too short. Fixed.
 Conflict display dialog for syncing was not on top of other windows. Fixed.
 Fixed some minor problems.
 
 Fixed an endless loop when importing vcs file with RESOURCES entry.
 
 ********** VERSION 2.0.16 ************
 OM/Pi:
 Fixed the SMTP account setting the option.
 Fixed something in mail sending.
 
 KO/Pi:
 Added possibility to export selected events/todos as vcal file.
 
 ********** VERSION 2.0.15 ************
 
 PwM/Pi:
 Added keyboard shorcuts for 
 - toggling summary view (space bar)
 - delete item (delete + backspace key)
 - add new item ( i + n key)
 Fixed length of info in the title.
 
 KO/Pi-KA/Pi:
 Changed "ME" menu bar entry to an icon.
 
 KO/Pi:
 Fixed two minor bugs in displaying todos.
 If in month view a cell is selected, the key shortcut "d" shows now that date.
 Added complete info for a todo in month view as an icon left of the text.
 Fixed problems of displaying data when "<" or ">" are used in summary/location/description.
 Fixed problem of search dialog size when switching displays. 
 Cancel key now closes date picker.
 Rearranged KO/Pi file menu structure.
 
 OM/Pi:
 Added to the SMTP account setting the option
 "No secure connection".
 You have to configure your SMTP accounts again, sorry.
 
 KA/Pi:
 Added support for importing quoted-printable.
 Support was added by Peter P.. Thanks, Peter!
 
 
 ********** VERSION 2.0.14 ************
 
 Made Passwordmanager PwM/Pi more userfriendly:
 Rearranged some toolbar icons, optimized setting of focus, fixed layout problems and more.
 Fixed bug in KO/Pi todo printing.
 Made Qtopia calendar import possible on desktop .
 
 ********** VERSION 2.0.13 ************
 
 Fixed a problem in the addressee select dialog and made it more user friendly by adding a minimize splitter.
 
 In the search dialog you can switch now the focus from search line edit to the list view by pressing key "arrow down".  
 
 OM/Pi:
 Fixed a refresh problem of outgoing/sent/sendfailed folders after sending mails.
 Added missing German translation.
 Added warning if path is specified in local folder settings of account config.
 
 ********** VERSION 2.0.12 ************
 
 KO/Pi:
 Fixed a bug in todo start/due date handling for non recurring todos with a start and due date.
 Fixed some layout problems in the KO/Pi agenda view when there were many conflicting itmes. 
 Fixed several problems of the keyboard focus in the desktop versions when opening the search dialog/event viewer.
 
 Fixed problem in pi-sync mode when wrong password was sent.
 
 OM/Pi:
 Fixed a crash when displaying mails with "Show mail as html" was checked in the config.
 Added a check before displaying the mail if the mail is in html format, if "Show mail as html" is enabled.
 
 ********** VERSION 2.0.11 ************
 
 Fixed some problems in pi-sync mode
 (e.g. details of events were not synced properly)
 
 ********** VERSION 2.0.10 ************
 
 KO/Pi:
 In the desktop versions the context menu in the search dialog was broken after introducing the What'sThis info for the list view.
 This is fixed.
 Changed the search dialog a bit to make it more user friendly.
 (E.g.: Removed message box about "no items found" and set key focus to search line edit after search).
 
 Added config option to hide the week number in KO/Pi toolbar.
 
 ********** VERSION 2.0.9 ************
 
 Made month view icons for multiday events a bit nicer.
 Some minor fixes in KO/Pi
 (e.g. go to today did not work for new week view properly).
 
 
 ********** VERSION 2.0.8 ************
 
 Fixed a problem in dependency info in the ipk files for the Zaurus.
 
 Added icon for the stealth new week view and made navigation more user friendly in monthview by adding a prev/next week button to the navigator bar.
 
 Added a "go today" button to the datepicker.
 
 Added "created" and "last modified" to event/todo viewer (and What'sThis viewer)
 and made it configureable to show these values.
 
 Fixed a problem for events (from external iCal files) that do have a duration but no end date.
 
 
 ********** VERSION 2.0.7 ************
 
 Added global application font settings 
 (for all KDE-Pim/Pi apps) to the general settings.
 
 Fixed a problem in OM/Pi when trying to login to some IMAP servers
 (like the IMAP server of Apple: mail.mac.com )
 
 Added recurring todos to KO/Pi.
 
 
 ********** VERSION 2.0.6 ************
 
 Stable release 2.0.6!
 
 Some bugfixes in the pi-sync mode.
 Added German translation for pi-sync mode.
 
 KO/Pi:
 Made the todolist using alternate background.
 
 Other minor fixes in KO/Pi.
 
 
 You can find the complete changelog 
 from version 1.7.7 to  2.0.5 
 in the source package or on 
 
 http://www.pi-sync.net/html/changelog.html
 
 
 
diff --git a/kabc/vcardparser/vcard.cpp b/kabc/vcardparser/vcard.cpp
index 24fd498..bc9f208 100644
--- a/kabc/vcardparser/vcard.cpp
+++ b/kabc/vcardparser/vcard.cpp
@@ -1,118 +1,118 @@
 /*
     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 "vcard.h"
 
 using namespace KABC;
 
 VCard::VCard()
 {
 }
 
 VCard::VCard( const VCard& vcard )
 {
   mLineMap = vcard.mLineMap;
 }
 
 VCard::~VCard()
 {
 }
 
 VCard& VCard::operator=( const VCard& vcard )
 {
   if ( &vcard == this )
     return *this;
 
   mLineMap = vcard.mLineMap;
 
   return *this;
 }
 
 void VCard::clear()
 {
   mLineMap.clear();
 }
 
 QStringList VCard::identifiers() const
 {
   //return mLineMap.keys();
 //PP re: US method QMap::keys() not available yet. SO collect the data manually
 
     QStringList result;
 
     QMap<QString, VCardLine::List>::ConstIterator it;
     for( it = mLineMap.begin(); it != mLineMap.end(); ++it ) {
       result << it.key().latin1();
     }
     return result;
 }
 
 void VCard::addLine( const VCardLine& line )
 {
   mLineMap[ line.identifier() ].append( line );
 }
 
 VCardLine::List VCard::lines( const QString& identifier ) const
 {
   LineMap::ConstIterator it = mLineMap.find( identifier );
   if ( it == mLineMap.end() )
     return VCardLine::List();
 
   return *it;
 }
 
 VCardLine VCard::line( const QString& identifier ) const
 {
   LineMap::ConstIterator it = mLineMap.find( identifier );
   if ( it == mLineMap.end() )
     return VCardLine();
 
   if ( (*it).isEmpty() )
     return VCardLine();
   else
     return (*it).first();
 }
 
 void VCard::setVersion( Version version )
 {
   mLineMap.remove( "VERSION" );
 
   VCardLine line;
   line.setIdentifier( "VERSION" );
   if ( version == v2_1 )
     line.setIdentifier( "2.1" );
   else if ( version == v3_0 )
     line.setIdentifier( "3.0" );
 
   mLineMap[ "VERSION" ].append( line );
 }
 
 VCard::Version VCard::version() const
 {
   LineMap::ConstIterator versionEntry = mLineMap.find( "VERSION" );
   if ( versionEntry == mLineMap.end() )
     return v3_0;
 
   VCardLine line = ( *versionEntry )[ 0 ];
-  if ( line.value() == "2.1" )
+  if ( line.valueString() == "2.1" )
     return v2_1;
   else
     return v3_0;
 }
diff --git a/kabc/vcardparser/vcardline.cpp b/kabc/vcardparser/vcardline.cpp
index 0972a35..8df2d32 100644
--- a/kabc/vcardparser/vcardline.cpp
+++ b/kabc/vcardparser/vcardline.cpp
@@ -1,171 +1,175 @@
 /*
     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 "vcardline.h"
 
 using namespace KABC;
 
 class VCardLine::VCardLinePrivate
 {
   public:
     QString mGroup;
 };
 
 VCardLine::VCardLine()
   : d( 0 )
 {
 }
 
 VCardLine::VCardLine( const QString &identifier )
   : d( 0 )
 {
   mIdentifier = identifier;
 }
 
 VCardLine::VCardLine( const QString &identifier, const QString &value )
   : d( 0 )
 {
   mIdentifier = identifier;
   mValue.assign( value.data(), value.length() );
 }
 
 VCardLine::VCardLine( const VCardLine& line )
   : d( 0 )
 {
   mParamMap = line.mParamMap;
   mValue = line.mValue;
   mIdentifier = line.mIdentifier;
 }
 
 VCardLine::~VCardLine()
 {
   delete d;
   d = 0;
 }
 
 VCardLine& VCardLine::operator=( const VCardLine& line )
 {
   if ( &line == this )
     return *this;
 
   mParamMap = line.mParamMap;
   mValue = line.mValue;
   mIdentifier = line.mIdentifier;
 
   return *this;
 }
 
 void VCardLine::setIdentifier( const QString& identifier )
 {
   mIdentifier = identifier;
 }
 
 QString VCardLine::identifier() const
 {
   return mIdentifier;
 }
 
-void VCardLine::setValue( const QString& value )
+void VCardLine::setValueString( const QString& value )
 {
-  mValue.duplicate( value.data(), value.length() );
+    setValueCString( value.utf8() );
+}
+void VCardLine::setValueCString( const QCString& value )
+{
+    mValue.duplicate(  value.data(), value.length() );
 }
 
-void VCardLine::setValue( const QByteArray& value )
+void VCardLine::setValueBytes( const QByteArray& value )
 {
   mValue = value;
 }
 
-QVariant VCardLine::value() const
+QString VCardLine::valueString() const
 {
-  return QVariant( QCString( mValue.data(), mValue.size()+1 ) );
+  return QString::fromUtf8( mValue.data(), mValue.size() );
 }
 
 QByteArray VCardLine::valueBytes() const
 {
   return mValue;
 }
 
 void VCardLine::setGroup( const QString& group )
 {
   if ( !d )
     d = new VCardLinePrivate();
 
   d->mGroup = group;
 }
 
 QString VCardLine::group() const
 {
   if ( d )
     return d->mGroup;
   else
     return QString();
 }
 
 bool VCardLine::hasGroup() const
 {
   if ( !d )
     return false;
   else
     return d->mGroup.isEmpty();
 }
 
 QStringList VCardLine::parameterList() const
 {
   //return mParamMap.keys();
 //US method QMap::keys() not available yet. SO collect the data manually
 //US    return mParamMap->keys();
 
     QStringList result;
 
     QMap<QString, QStringList>::ConstIterator it;
     for( it = mParamMap.begin(); it != mParamMap.end(); ++it ) {
       result << it.key().latin1();
     }
     return result;
 }
 
 void VCardLine::addParameter( const QString& param, const QString& value )
 {
   QStringList &list = mParamMap[ param ];
   if ( list.findIndex( value ) == -1 ) // not included yet
     list.append( value );
 }
 
 QStringList VCardLine::parameters( const QString& param ) const
 {
   ParamMap::ConstIterator it = mParamMap.find( param );
   if ( it == mParamMap.end() )
     return QStringList();
   else
     return *it;
 }
 
 QString VCardLine::parameter( const QString& param ) const
 {
   ParamMap::ConstIterator it = mParamMap.find( param );
   if ( it == mParamMap.end() )
     return QString::null;
   else {
     if ( (*it).isEmpty() )
       return QString::null;
     else
       return (*it).first();
   }
 }
diff --git a/kabc/vcardparser/vcardline.h b/kabc/vcardparser/vcardline.h
index 6e74b38..8dc9322 100644
--- a/kabc/vcardparser/vcardline.h
+++ b/kabc/vcardparser/vcardline.h
@@ -1,118 +1,119 @@
 /*
     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.
 */
 
 #ifndef VCARDLINE_H
 #define VCARDLINE_H
 
 #include <qstringlist.h>
 #include <qvaluelist.h>
 #include <qcstring.h>
 #include <qvariant.h>
 #include <qmap.h>
 #include <qstring.h>
 
 namespace KABC {
 
 class VCardLine
 {
   public:
     typedef QValueList<VCardLine> List;
     typedef QMap<QString, QStringList> ParamMap;
 
     VCardLine();
     VCardLine( const QString &identifier );
     VCardLine( const QString &identifier, const QString &value );
     VCardLine( const VCardLine& );
 
     ~VCardLine();
 
     VCardLine& operator=( const VCardLine& );
 
     /**
      * Sets the identifier of this line e.g. UID, FN, CLASS
      */
     void setIdentifier( const QString& identifier );
 
     /**
      * Returns the identifier of this line.
      */
     QString identifier() const;
 
     /**
      * Sets the value of of this line.
      */
-    void setValue( const QString& value );
-    void setValue( const QByteArray& value );
+    void setValueString( const QString& value );
+    void setValueCString( const QCString& value );
+    void setValueBytes( const QByteArray& value );
 
     /**
      * Returns the value of this line.
      */
-    QVariant value() const;
+    QString valueString() const;
     QByteArray valueBytes() const;
 
     /**
      * Sets the group the line belongs to.
      */
     void setGroup( const QString& group );
 
     /**
      * Returns the group the line belongs to.
      */
     QString group() const;
 
     /**
      * Returns whether the line belongs to a group.
      */
     bool hasGroup() const;
 
     /**
      * Returns all parameters.
      */
     QStringList parameterList() const;
 
     /**
      * Add a new parameter to the line.
      */
     void addParameter( const QString& param, const QString& value );
 
     /**
      * Returns the values of a special parameter.
      * You can get a list of all parameters with paramList().
      */
     QStringList parameters( const QString& param ) const;
 
     /**
      * Returns only the first value of a special parameter.
      * You can get a list of all parameters with paramList().
      */
     QString parameter( const QString& param ) const;
 
   private:
     ParamMap mParamMap;
     QString mIdentifier;
     QByteArray mValue;
 
     class VCardLinePrivate;
     VCardLinePrivate *d;
 };
 
 }
 
 #endif
diff --git a/kabc/vcardparser/vcardparser.cpp b/kabc/vcardparser/vcardparser.cpp
index 7fae011..11622a0 100644
--- a/kabc/vcardparser/vcardparser.cpp
+++ b/kabc/vcardparser/vcardparser.cpp
@@ -1,240 +1,240 @@
 /*
     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 )
 {
   static QRegExp sep( "[\x0d\x0a]" );
 
   VCard currentVCard;
   VCard::List vCardList;
   QString currentLine;
 
   const QStringList lines = QStringList::split( sep, text );
   QStringList::ConstIterator it;
 
   bool inVCard = false;
   QStringList::ConstIterator linesEnd( lines.end() );
   for ( it = lines.begin(); it != linesEnd; ++it ) {
 
     if ( (*it).isEmpty() ) // empty line
       continue;
 
     if ( (*it)[ 0 ] == ' ' || (*it)[ 0 ] == '\t' ) { // folded line => append to previous
       currentLine += QString( *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;
         const QString key = currentLine.left( colon ).stripWhiteSpace();
         QString value = currentLine.mid( colon + 1 );
 
         QStringList params = QStringList::split( ';', key );
 
         // check for group
         if ( params[0].find( '.' ) != -1 ) {
           const QStringList groupList = QStringList::split( '.', params[0] );
           vCardLine.setGroup( groupList[0] );
           vCardLine.setIdentifier( groupList[1] );
         } else
           vCardLine.setIdentifier( params[0] );
 
         if ( params.count() > 1 ) { // find all parameters
           QStringList::ConstIterator paramIt = params.begin();
           for ( ++paramIt; paramIt != params.end(); ++paramIt ) {
             QStringList pair = QStringList::split( '=', *paramIt );
             if ( pair.count() == 1 ) {
               // correct the fucking 2.1 'standard'
               if ( pair[0].lower() == "quoted-printable" ) {
                 pair[0] = "encoding";
                 pair[1] = "quoted-printable";
               } else if ( pair[0].lower() == "base64" ) {
                 pair[0] = "encoding";
                 pair[1] = "base64";
               } else {
                 pair.prepend( "type" );
               }
             }
             // This is pretty much a faster pair[1].contains( ',' )...
             if ( pair[1].find( ',' ) != -1 ) { // parameter in type=x,y,z format
               const QStringList args = QStringList::split( ',', pair[ 1 ] );
               QStringList::ConstIterator argIt;
               for ( argIt = args.begin(); argIt != args.end(); ++argIt )
                 vCardLine.addParameter( pair[0].lower(), *argIt );
             } else
               vCardLine.addParameter( pair[0].lower(), pair[1] );
           }
         }
 
         params = vCardLine.parameterList();
         if ( params.findIndex( "encoding" ) != -1 ) { // have to decode the data
           QByteArray input, output;
           if ( vCardLine.parameter( "encoding" ).lower() == "b" ||
                vCardLine.parameter( "encoding" ).lower() == "base64" ) {
             input = value.local8Bit();
             KCodecs::base64Decode( input, output );
           } else if ( vCardLine.parameter( "encoding" ).lower() == "quoted-printable" ) {
             // join any qp-folded lines
             while ( value.mid(value.length()-1,1) == "=" && it != linesEnd ) {
               value = value.remove( value.length()-1, 1 ) + (*it);
               ++it;
             }
             input = value.local8Bit();
             KCodecs::quotedPrintableDecode( input, output );
           }
 //PP our vcards are *supposed* to be in UTF-8
 //          if ( vCardLine.parameter( "charset" ).lower() == "utf-8" ) {
 //            vCardLine.setValue( QString::fromUtf8( output.data(), output.size() ) );
 //          } else
-            vCardLine.setValue( output );
+            vCardLine.setValueBytes( output );
 //PP our vcards are *supposed* to be in UTF-8
 //        } else if ( vCardLine.parameter( "charset" ).lower() == "utf-8" ) {
 //          vCardLine.setValue( QString::fromUtf8( value.ascii() ) );
         } else
-          vCardLine.setValue( value.replace( QRegExp("\\\\n"), "\n" ) );
+          vCardLine.setValueString( 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;
         currentLine = "";
         currentVCard.clear(); // flush vcard
         continue;
       }
 
       if ( (*it).lower().startsWith( "end:vcard" ) ) {
         inVCard = false;
         vCardList.append( currentVCard );
         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::ConstIterator valueIt;
 
   VCardLine::List lines;
   VCardLine::List::ConstIterator lineIt;
   VCard::List::ConstIterator cardIt;
 
   bool hasEncoding;
 
   // iterate over the cards
   VCard::List::ConstIterator listEnd( list.end() );
   for ( cardIt = list.begin(); cardIt != listEnd; ++cardIt ) {
     text.append( "BEGIN:VCARD\r\n" );
 
     idents = (*cardIt).identifiers();
     for ( identIt = idents.begin(); identIt != idents.end(); ++identIt ) {
       lines = (*cardIt).lines( (*identIt) );
 
       // iterate over the lines
       for ( lineIt = lines.begin(); lineIt != lines.end(); ++lineIt ) {
-        if ( !(*lineIt).value().asString().isEmpty() ) {
+        if ( !(*lineIt).valueString().isEmpty() ) {
           if ( (*lineIt).hasGroup() )
             textLine = (*lineIt).group() + "." + (*lineIt).identifier();
           else
             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;
             input = (*lineIt).valueBytes();
             if ( encodingType == "b" )
               KCodecs::base64Encode( input, output );
             else if ( encodingType == "quoted-printable" )
               KCodecs::quotedPrintableEncode( input, output );
             textLine.append( ":" + QString( output ) );
           } else
-            textLine.append( ":" + (*lineIt).value().asString().replace( QRegExp("\n"), "\\n" ) );
+            textLine.append( ":" + (*lineIt).valueString().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 0cf72c0..c3d92b6 100644
--- a/kabc/vcardparser/vcardtool.cpp
+++ b/kabc/vcardparser/vcardtool.cpp
@@ -1,869 +1,869 @@
 /*
     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 "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 );
 }
 
 VCardTool::~VCardTool()
 {
 }
 
 // TODO: make list a const&
 QString VCardTool::createVCards( Addressee::List list, VCard::Version version )
 {
   VCard::List vCardList;
   static const QRegExp semiExp(";");
 
   Addressee::List::ConstIterator addrIt;
   Addressee::List::ConstIterator listEnd( list.end() );
   for ( addrIt = list.begin(); addrIt != listEnd; ++addrIt ) {
     VCard card;
     QStringList::ConstIterator strIt;
 
     // ADR + LABEL
     const Address::List addresses = (*addrIt).addresses();
     for ( Address::List::ConstIterator it = addresses.begin(); it != addresses.end(); ++it ) {
       QStringList address;
 
       bool isEmpty = ( (*it).postOfficeBox().isEmpty() &&
                      (*it).extended().isEmpty() &&
                      (*it).street().isEmpty() &&
                      (*it).locality().isEmpty() &&
                      (*it).region().isEmpty() &&
                      (*it).postalCode().isEmpty() &&
                      (*it).country().isEmpty() );
 
       address.append( (*it).postOfficeBox().replace( semiExp, "\\;" ) );
       address.append( (*it).extended().replace( semiExp, "\\;" ) );
       address.append( (*it).street().replace( semiExp, "\\;" ) );
       address.append( (*it).locality().replace( semiExp, "\\;" ) );
       address.append( (*it).region().replace( semiExp, "\\;" ) );
       address.append( (*it).postalCode().replace( semiExp, "\\;" ) );
       address.append( (*it).country().replace( semiExp, "\\;" ) );
 
       VCardLine adrLine( "ADR", address.join( ";" ) );
       if ( version == VCard::v2_1 ) {
         adrLine.addParameter( "CHARSET", "UTF-8" );
         adrLine.addParameter( "ENCODING", "8BIT" );
       }
 
       VCardLine labelLine( "LABEL", (*it).label() );
       if ( version == VCard::v2_1 ) {
         labelLine.addParameter( "CHARSET", "UTF-8" );
         labelLine.addParameter( "ENCODING", "8BIT" );
       }
 
       bool hasLabel = !(*it).label().isEmpty();
       QMap<QString, int>::ConstIterator typeIt;
       for ( typeIt = mAddressTypeMap.begin(); typeIt != mAddressTypeMap.end(); ++typeIt ) {
         if ( typeIt.data() & (*it).type() ) {
           adrLine.addParameter( "TYPE", typeIt.key() );
           if ( hasLabel )
             labelLine.addParameter( "TYPE",  typeIt.key() );
         }
       }
 
       if ( !isEmpty )
         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 )
         (*catIt).replace( QRegExp(","), "\\," );
 
       VCardLine catLine( "CATEGORIES", categories.join( "," ) );
       if ( version == VCard::v2_1 ) {
         catLine.addParameter( "CHARSET", "UTF-8" );
         catLine.addParameter( "ENCODING", "8BIT" );
       }
 
       card.addLine( catLine );
     }
 
     // CLASS
     if ( version == VCard::v3_0 ) {
       card.addLine( createSecrecy( (*addrIt).secrecy() ) );
     }
 
     // EMAIL
     const QStringList emails = (*addrIt).emails();
     bool pref = true;
     for ( strIt = emails.begin(); strIt != emails.end(); ++strIt ) {
       VCardLine line( "EMAIL", *strIt );
       if ( version == VCard::v2_1 ) {
         line.addParameter( "CHARSET", "UTF-8" );
         line.addParameter( "ENCODING", "8BIT" );
       }
       if ( pref == true && emails.count() > 1 ) {
         line.addParameter( "TYPE", "PREF" );
         pref = false;
       }
       card.addLine( line );
     }
 
     // FN
     VCardLine fnLine( "FN", (*addrIt).formattedName() );
     if ( version == VCard::v2_1 ) {
       fnLine.addParameter( "CHARSET", "UTF-8" );
       fnLine.addParameter( "ENCODING", "8BIT" );
     }
     card.addLine( fnLine );
 
     // GEO
     Geo geo = (*addrIt).geo();
     if ( geo.isValid() ) {
       QString str;
       str.sprintf( "%.6f;%.6f", geo.latitude(), geo.longitude() );
       card.addLine( VCardLine( "GEO", str ) );
     }
 
     // KEY
     const 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
     VCardLine mailerLine( "MAILER", (*addrIt).mailer() );
     if ( version == VCard::v2_1 ) {
       mailerLine.addParameter( "CHARSET", "UTF-8" );
       mailerLine.addParameter( "ENCODING", "8BIT" );
     }
     card.addLine( mailerLine );
 
     // N
     QStringList name;
     name.append( (*addrIt).familyName().replace( semiExp, "\\;" ) );
     name.append( (*addrIt).givenName().replace( semiExp, "\\;" ) );
     name.append( (*addrIt).additionalName().replace( semiExp, "\\;" ) );
     name.append( (*addrIt).prefix().replace( semiExp, "\\;" ) );
     name.append( (*addrIt).suffix().replace( semiExp, "\\;" ) );
 
     VCardLine nLine( "N", name.join( ";" ) );
     if ( version == VCard::v2_1 ) {
       nLine.addParameter( "CHARSET", "UTF-8" );
       nLine.addParameter( "ENCODING", "8BIT" );
     }
     card.addLine( nLine );
 
     // NAME
     VCardLine nameLine( "NAME", (*addrIt).name() );
     if ( version == VCard::v2_1 ) {
       nameLine.addParameter( "CHARSET", "UTF-8" );
       nameLine.addParameter( "ENCODING", "8BIT" );
     }
     card.addLine( nameLine );
 
     // NICKNAME
     if ( version == VCard::v3_0 )
       card.addLine( VCardLine( "NICKNAME", (*addrIt).nickName() ) );
 
     // NOTE
     VCardLine noteLine( "NOTE", (*addrIt).note() );
     if ( version == VCard::v2_1 ) {
       noteLine.addParameter( "CHARSET", "UTF-8" );
       noteLine.addParameter( "ENCODING", "8BIT" );
     }
     card.addLine( noteLine );
 
     // ORG
     VCardLine orgLine( "ORG", (*addrIt).organization() );
     if ( version == VCard::v2_1 ) {
       orgLine.addParameter( "CHARSET", "UTF-8" );
       orgLine.addParameter( "ENCODING", "8BIT" );
     }
     card.addLine( orgLine );
 
     // 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
     VCardLine roleLine( "ROLE", (*addrIt).role() );
     if ( version == VCard::v2_1 ) {
       roleLine.addParameter( "CHARSET", "UTF-8" );
       roleLine.addParameter( "ENCODING", "8BIT" );
     }
     card.addLine( roleLine );
 
     // SORT-STRING
     if ( version == VCard::v3_0 )
       card.addLine( VCardLine( "SORT-STRING", (*addrIt).sortString() ) );
 
     // SOUND
     card.addLine( createSound( (*addrIt).sound() ) );
 
     // TEL
     const 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>::ConstIterator typeIt;
       for ( typeIt = mPhoneTypeMap.begin(); typeIt != mPhoneTypeMap.end(); ++typeIt ) {
         if ( typeIt.data() & (*phoneIt).type() )
           line.addParameter( "TYPE", typeIt.key() );
       }
 
       card.addLine( line );
     }
 
     // TITLE
     VCardLine titleLine( "TITLE", (*addrIt).title() );
     if ( version == VCard::v2_1 ) {
       titleLine.addParameter( "CHARSET", "UTF-8" );
       titleLine.addParameter( "ENCODING", "8BIT" );
     }
     card.addLine( titleLine );
 
     // TZ
     TimeZone timeZone = (*addrIt).timeZone();
     if ( timeZone.isValid() ) {
       QString str;
 
       int neg = 1;
       if ( timeZone.offset() < 0 )
         neg = -1;
 
       str.sprintf( "%c%02d:%02d", ( timeZone.offset() >= 0 ? '+' : '-' ),
                                   ( timeZone.offset() / 60 ) * neg,
                                   ( timeZone.offset() % 60 ) * neg );
 
       card.addLine( VCardLine( "TZ", str ) );
     }
 
     // UID
     card.addLine( VCardLine( "UID", (*addrIt).uid() ) );
 
     // URL
     card.addLine( VCardLine( "URL", (*addrIt).url().url() ) );
 
     // VERSION
     if ( version == VCard::v2_1 )
       card.addLine( VCardLine( "VERSION", "2.1" ) );
     if ( version == VCard::v3_0 )
       card.addLine( VCardLine( "VERSION", "3.0" ) );
 
     // X-
     const QStringList customs = (*addrIt).customs();
     for ( strIt = customs.begin(); strIt != customs.end(); ++strIt ) {
       QString identifier = "X-" + (*strIt).left( (*strIt).find( ":" ) );
       QString value = (*strIt).mid( (*strIt).find( ":" ) + 1 );
       if ( value.isEmpty() )
         continue;
 
       VCardLine line( identifier, value );
       if ( version == VCard::v2_1 ) {
         line.addParameter( "CHARSET", "UTF-8" );
         line.addParameter( "ENCODING", "8BIT" );
       }
       card.addLine( line );
     }
 
     vCardList.append( card );
   }
 
   return VCardParser::createVCards( vCardList );
 }
 
 Addressee::List VCardTool::parseVCards( const QString& vcard )
 {
   static const QChar semicolonSep( ';' );
   static const QChar commaSep( ',' );
   QString identifier;
 
   Addressee::List addrList;
   const VCard::List vCardList = VCardParser::parseVCards( vcard );
 
   VCard::List::ConstIterator cardIt;
   VCard::List::ConstIterator listEnd( vCardList.end() );
   for ( cardIt = vCardList.begin(); cardIt != listEnd; ++cardIt ) {
     Addressee addr;
 
     const QStringList idents = (*cardIt).identifiers();
     QStringList::ConstIterator identIt;
     QStringList::ConstIterator identEnd( idents.end() );
     for ( identIt = idents.begin(); identIt != identEnd; ++identIt ) {
       const VCardLine::List lines = (*cardIt).lines( (*identIt) );
       VCardLine::List::ConstIterator lineIt;
 
       // iterate over the lines
       for ( lineIt = lines.begin(); lineIt != lines.end(); ++lineIt ) {
         identifier = (*lineIt).identifier().lower();
         // ADR
         if ( identifier == "adr" ) {
           Address address;
-          const QStringList addrParts = splitString( semicolonSep, (*lineIt).value().asString() );
+          const QStringList addrParts = splitString( semicolonSep, (*lineIt).valueString() );
           if ( addrParts.count() > 0 )
             address.setPostOfficeBox( addrParts[ 0 ] );
           if ( addrParts.count() > 1 )
             address.setExtended( addrParts[ 1 ] );
           if ( addrParts.count() > 2 )
             address.setStreet( addrParts[ 2 ] );
           if ( addrParts.count() > 3 )
             address.setLocality( addrParts[ 3 ] );
           if ( addrParts.count() > 4 )
             address.setRegion( addrParts[ 4 ] );
           if ( addrParts.count() > 5 )
             address.setPostalCode( addrParts[ 5 ] );
           if ( addrParts.count() > 6 )
             address.setCountry( addrParts[ 6 ] );
 
           int type = 0;
 
           const QStringList types = (*lineIt).parameters( "type" );
           for ( QStringList::ConstIterator it = types.begin(); it != types.end(); ++it )
             type += mAddressTypeMap[ (*it).lower() ];
 
           address.setType( type );
           addr.insertAddress( address );
         }
 
         // AGENT
         else if ( identifier == "agent" )
           addr.setAgent( parseAgent( *lineIt ) );
 
         // BDAY
         else if ( identifier == "bday" )
-          addr.setBirthday( parseDateTime( (*lineIt).value().asString() ) );
+          addr.setBirthday( parseDateTime( (*lineIt).valueString() ) );
 
         // CATEGORIES
         else if ( identifier == "categories" ) {
-          const QStringList categories = splitString( commaSep, (*lineIt).value().asString() );
+          const QStringList categories = splitString( commaSep, (*lineIt).valueString() );
           addr.setCategories( categories );
         }
 
         // CLASS
         else if ( identifier == "class" )
           addr.setSecrecy( parseSecrecy( *lineIt ) );
 
         // EMAIL
         else if ( identifier == "email" ) {
           const QStringList types = (*lineIt).parameters( "type" );
-          addr.insertEmail( (*lineIt).value().asString(), types.findIndex( "PREF" ) != -1 );
+          addr.insertEmail( (*lineIt).valueString(), types.findIndex( "PREF" ) != -1 );
         }
 
         // FN
         else if ( identifier == "fn" )
-          addr.setFormattedName( (*lineIt).value().asString() );
+          addr.setFormattedName( (*lineIt).valueString() );
 
         // GEO
         else if ( identifier == "geo" ) {
           Geo geo;
 
-          const QStringList geoParts = QStringList::split( ';', (*lineIt).value().asString(), true );
+          const QStringList geoParts = QStringList::split( ';', (*lineIt).valueString(), true );
           geo.setLatitude( geoParts[ 0 ].toFloat() );
           geo.setLongitude( geoParts[ 1 ].toFloat() );
 
           addr.setGeo( geo );
         }
 
         // KEY
         else if ( identifier == "key" )
           addr.insertKey( parseKey( *lineIt ) );
 
         // LABEL
         else if ( identifier == "label" ) {
           int type = 0;
 
           const QStringList types = (*lineIt).parameters( "type" );
           for ( QStringList::ConstIterator it = types.begin(); it != types.end(); ++it )
             type += mAddressTypeMap[ (*it).lower() ];
 
           bool available = false;
           KABC::Address::List addressList = addr.addresses();
           KABC::Address::List::Iterator it;
           for ( it = addressList.begin(); it != addressList.end(); ++it ) {
             if ( (*it).type() == type ) {
-              (*it).setLabel( (*lineIt).value().asString() );
+              (*it).setLabel( (*lineIt).valueString() );
               addr.insertAddress( *it );
               available = true;
               break;
             }
           }
 
           if ( !available ) { // a standalone LABEL tag
             KABC::Address address( type );
-            address.setLabel( (*lineIt).value().asString() );
+            address.setLabel( (*lineIt).valueString() );
             addr.insertAddress( address );
           }
         }
 
         // LOGO
         else if ( identifier == "logo" )
           addr.setLogo( parsePicture( *lineIt ) );
 
         // MAILER
         else if ( identifier == "mailer" )
-          addr.setMailer( (*lineIt).value().asString() );
+          addr.setMailer( (*lineIt).valueString() );
 
         // N
         else if ( identifier == "n" ) {
-          const QStringList nameParts = splitString( semicolonSep, (*lineIt).value().asString() );
+          const QStringList nameParts = splitString( semicolonSep, (*lineIt).valueString() );
           if ( nameParts.count() > 0 )
             addr.setFamilyName( nameParts[ 0 ] );
           if ( nameParts.count() > 1 )
             addr.setGivenName( nameParts[ 1 ] );
           if ( nameParts.count() > 2 )
             addr.setAdditionalName( nameParts[ 2 ] );
           if ( nameParts.count() > 3 )
             addr.setPrefix( nameParts[ 3 ] );
           if ( nameParts.count() > 4 )
             addr.setSuffix( nameParts[ 4 ] );
         }
 
         // NAME
         else if ( identifier == "name" )
-          addr.setName( (*lineIt).value().asString() );
+          addr.setName( (*lineIt).valueString() );
 
         // NICKNAME
         else if ( identifier == "nickname" )
-          addr.setNickName( (*lineIt).value().asString() );
+          addr.setNickName( (*lineIt).valueString() );
 
         // NOTE
         else if ( identifier == "note" )
-          addr.setNote( (*lineIt).value().asString() );
+          addr.setNote( (*lineIt).valueString() );
 
         // ORGANIZATION
         else if ( identifier == "org" )
-          addr.setOrganization( (*lineIt).value().asString() );
+          addr.setOrganization( (*lineIt).valueString() );
 
         // PHOTO
         else if ( identifier == "photo" )
           addr.setPhoto( parsePicture( *lineIt ) );
 
         // PROID
         else if ( identifier == "prodid" )
-          addr.setProductId( (*lineIt).value().asString() );
+          addr.setProductId( (*lineIt).valueString() );
 
         // REV
         else if ( identifier == "rev" )
-          addr.setRevision( parseDateTime( (*lineIt).value().asString() ) );
+          addr.setRevision( parseDateTime( (*lineIt).valueString() ) );
 
         // ROLE
         else if ( identifier == "role" )
-          addr.setRole( (*lineIt).value().asString() );
+          addr.setRole( (*lineIt).valueString() );
 
         // SORT-STRING
         else if ( identifier == "sort-string" )
-          addr.setSortString( (*lineIt).value().asString() );
+          addr.setSortString( (*lineIt).valueString() );
 
         // SOUND
         else if ( identifier == "sound" )
           addr.setSound( parseSound( *lineIt ) );
 
         // TEL
         else if ( identifier == "tel" ) {
           PhoneNumber phone;
-          phone.setNumber( (*lineIt).value().asString() );
+          phone.setNumber( (*lineIt).valueString() );
 
           int type = 0;
 
           const QStringList types = (*lineIt).parameters( "type" );
           for ( QStringList::ConstIterator it = types.begin(); it != types.end(); ++it )
             type += mPhoneTypeMap[(*it).upper()];
 
           phone.setType( type );
 
           addr.insertPhoneNumber( phone );
         }
 
         // TITLE
         else if ( identifier == "title" )
-          addr.setTitle( (*lineIt).value().asString() );
+          addr.setTitle( (*lineIt).valueString() );
 
         // TZ
         else if ( identifier == "tz" ) {
           TimeZone tz;
-          const QString date = (*lineIt).value().asString();
+          const QString date = (*lineIt).valueString();
 
           int hours = date.mid( 1, 2).toInt();
           int minutes = date.mid( 4, 2 ).toInt();
           int offset = ( hours * 60 ) + minutes;
           offset = offset * ( date[ 0 ] == '+' ? 1 : -1 );
 
           tz.setOffset( offset );
           addr.setTimeZone( tz );
         }
 
         // UID
         else if ( identifier == "uid" )
-          addr.setUid( (*lineIt).value().asString() );
+          addr.setUid( (*lineIt).valueString() );
 
         // URL
         else if ( identifier == "url" )
-          addr.setUrl( KURL( (*lineIt).value().asString() ) );
+          addr.setUrl( KURL( (*lineIt).valueString() ) );
 
         // X-
         else if ( identifier.startsWith( "x-" ) ) {
           const QString key = (*lineIt).identifier().mid( 2 );
           int dash = key.find( "-" );
-          addr.insertCustom( key.left( dash ), key.mid( dash + 1 ), (*lineIt).value().asString() );
+          addr.insertCustom( key.left( dash ), key.mid( dash + 1 ), (*lineIt).valueString() );
         }
       }
     }
 
     addrList.append( addr );
   }
 
   return addrList;
 }
 
 QDateTime VCardTool::parseDateTime( const QString &str )
 {
   QDateTime dateTime;
 
   if ( str.find( '-' ) == -1 ) { // is base format (yyyymmdd)
     dateTime.setDate( QDate( str.left( 4 ).toInt(), str.mid( 4, 2 ).toInt(),
                              str.mid( 6, 2 ).toInt() ) );
 
     if ( str.find( 'T' ) ) // has time information yyyymmddThh:mm:ss
       dateTime.setTime( QTime( str.mid( 11, 2 ).toInt(), str.mid( 14, 2 ).toInt(),
                                str.mid( 17, 2 ).toInt() ) );
 
   } else { // is extended format yyyy-mm-dd
     dateTime.setDate( QDate( str.left( 4 ).toInt(), str.mid( 5, 2 ).toInt(),
                              str.mid( 8, 2 ).toInt() ) );
 
     if ( str.find( 'T' ) ) // has time information yyyy-mm-ddThh:mm:ss
       dateTime.setTime( QTime( str.mid( 11, 2 ).toInt(), str.mid( 14, 2 ).toInt(),
                                str.mid( 17, 2 ).toInt() ) );
   }
 
   return dateTime;
 }
 
 QString VCardTool::createDateTime( const QDateTime &dateTime )
 {
   QString str;
 
   if ( dateTime.date().isValid() ) {
     str.sprintf( "%4d-%02d-%02d", dateTime.date().year(), dateTime.date().month(),
                  dateTime.date().day() );
     if ( dateTime.time().isValid() ) {
       QString tmp;
       tmp.sprintf( "T%02d:%02d:%02dZ", dateTime.time().hour(), dateTime.time().minute(),
                    dateTime.time().second() );
       str += tmp;
     }
   }
 
   return str;
 }
 
 Picture VCardTool::parsePicture( const VCardLine &line )
 {
   Picture pic;
 
   const QStringList params = line.parameterList();
   if ( params.findIndex( "encoding" ) != -1 ) {
     QImage img;
     img.loadFromData( line.valueBytes() );
     pic.setData( img );
   } else if ( params.findIndex( "value" ) != -1 ) {
     if ( line.parameter( "value" ).lower() == "uri" )
-      pic.setUrl( line.value().asString() );
+      pic.setUrl( line.valueString() );
   }
 
   if ( params.findIndex( "type" ) != -1 )
     pic.setType( line.parameter( "type" ) );
 
   return pic;
 }
 
 VCardLine VCardTool::createPicture( const QString &identifier, const Picture &pic )
 {
   VCardLine line( identifier );
 
   if ( pic.isIntern() ) {
     if ( !pic.data().isNull() ) {
       QByteArray input;
       QDataStream s( input, IO_WriteOnly );
       s.setVersion( 4 );
       s << pic.data();
-      line.setValue( input );
+      line.setValueBytes( input );
       line.addParameter( "encoding", "b" );
       line.addParameter( "type", "image/png" );
     }
   } else if ( !pic.url().isEmpty() ) {
     QByteArray ba;
-    line.setValue( pic.url() );
+    line.setValueString( pic.url() );
     line.addParameter( "value", "URI" );
   }
 
   return line;
 }
 
 Sound VCardTool::parseSound( const VCardLine &line )
 {
   Sound snd;
 
   const QStringList params = line.parameterList();
   if ( params.findIndex( "encoding" ) != -1 )
     snd.setData( line.valueBytes() );
   else if ( params.findIndex( "value" ) != -1 ) {
     if ( line.parameter( "value" ).lower() == "uri" )
-      snd.setUrl( line.value().asString() );
+      snd.setUrl( line.valueString() );
   }
 
 /* TODO: support sound types
   if ( params.contains( "type" ) )
     snd.setType( line.parameter( "type" ) );
 */
 
   return snd;
 }
 
 VCardLine VCardTool::createSound( const Sound &snd )
 {
   VCardLine line( "SOUND" );
 
   if ( snd.isIntern() ) {
     if ( !snd.data().isEmpty() ) {
-      line.setValue( snd.data() );
+      line.setValueBytes( snd.data() );
       line.addParameter( "encoding", "b" );
       // TODO: need to store sound type!!!
     }
   } else if ( !snd.url().isEmpty() ) {
-    line.setValue( snd.url() );
+    line.setValueString( snd.url() );
     line.addParameter( "value", "URI" );
   }
 
   return line;
 }
 
 Key VCardTool::parseKey( const VCardLine &line )
 {
   Key key;
 
   const QStringList params = line.parameterList();
   if ( params.findIndex( "encoding" ) != -1 )
     key.setBinaryData( line.valueBytes() );
   else
-    key.setTextData( line.value().asString() );
+    key.setTextData( line.valueString() );
 
   if ( params.findIndex( "type" ) != -1 ) {
     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() ) {
-      line.setValue( key.binaryData() );
+      line.setValueBytes( key.binaryData() );
       line.addParameter( "encoding", "b" );
     }
   } else if ( !key.textData().isEmpty() )
-    line.setValue( key.textData() );
+    line.setValueString( 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" )
+  if ( line.valueString().lower() == "public" )
     secrecy.setType( Secrecy::Public );
-  if ( line.value().asString().lower() == "private" )
+  if ( line.valueString().lower() == "private" )
     secrecy.setType( Secrecy::Private );
-  if ( line.value().asString().lower() == "confidential" )
+  if ( line.valueString().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" );
+    line.setValueString( "PUBLIC" );
   else if ( type == Secrecy::Private )
-    line.setValue( "PRIVATE" );
+    line.setValueString( "PRIVATE" );
   else if ( type == Secrecy::Confidential )
-    line.setValue( "CONFIDENTIAL" );
+    line.setValueString( "CONFIDENTIAL" );
 
   return line;
 }
 
 Agent VCardTool::parseAgent( const VCardLine &line )
 {
   Agent agent;
 
   const QStringList params = line.parameterList();
   if ( params.findIndex( "value" ) != -1 ) {
     if ( line.parameter( "value" ).lower() == "uri" )
-      agent.setUrl( line.value().asString() );
+      agent.setUrl( line.valueString() );
   } else {
-    QString str = line.value().asString();
+    QString str = line.valueString();
     str.replace( QRegExp("\\\\n"), "\r\n" );
     str.replace( QRegExp("\\\\N"), "\r\n" );
     str.replace( QRegExp("\\\\;"), ";" );
     str.replace( QRegExp("\\\\:"), ":" );
     str.replace( QRegExp("\\\\,"), "," );
 
     const 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 );
       str.replace( QRegExp("\\r\\n"), "\\n" );
       str.replace( QRegExp(";"), "\\;" );
       str.replace( QRegExp(":"), "\\:" );
       str.replace( QRegExp(","), "\\," );
-      line.setValue( str );
+      line.setValueString( str );
     }
   } else if ( !agent.url().isEmpty() ) {
-    line.setValue( agent.url() );
+    line.setValueString( 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;
 }
diff --git a/kaddressbook/views/cardview.cpp b/kaddressbook/views/cardview.cpp
index 84d3116..b6e053f 100644
--- a/kaddressbook/views/cardview.cpp
+++ b/kaddressbook/views/cardview.cpp
@@ -1,1751 +1,1750 @@
 /*
     This file is part of KAddressBook.
     Copyright (c) 2002 Mike Pilone <mpilone@slac.com>
 
     This program is free software; you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
     the Free Software Foundation; either version 2 of the License, or
     (at your option) any later version.
 
     This program is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
     GNU General Public License for more details.
 
     You should have received a copy of the GNU General Public License
     along with this program; if not, write to the Free Software
     Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 
     As a special exception, permission is given to link this program
     with any edition of Qt, and distribute the resulting executable,
     without including the source code for Qt in the source distribution.
 */
 
 //BEGIN Includes
 #include "cardview.h"
 
 #include <limits.h>
 
 #include <qpainter.h>
 #include <qtimer.h>
 #include <qdatetime.h>
 #include <qlabel.h>
 #include <qstyle.h>
 #include <qcursor.h>
 #include <qtooltip.h>
 #include <qapplication.h>
 
 #include "kabprefs.h"
 #include <kdebug.h>
 #include <kglobalsettings.h>
 //END includes
 
 #define MIN_ITEM_WIDTH 80
 
 //BEGIN Helpers
 //////////////////////////////////////
 // CardViewTip
 class CardViewTip : public QLabel {
   public:
     CardViewTip(QWidget *parent=0, const char *name=0) : QLabel( parent, name )
     {
       setPalette( QToolTip::palette() );
       setFrameStyle( Panel|Plain );
       setMidLineWidth(0);
       setIndent(1);
     }
 
     ~CardViewTip() {};
   protected:
     void leaveEvent( QEvent * )
     {
       hide();
     }
 };
 
 //////////////////////////////////////
 // CardViewItemList
 
 
 //
 // Warning: make sure you use findRef() instead of find() to find an
 //          item! Only the pointer value is unique in the list.
 //
 class CardViewItemList : public QPtrList<CardViewItem>
 {
   protected:
     virtual int compareItems(QPtrCollection::Item item1,
                              QPtrCollection::Item item2)
     {
       CardViewItem *cItem1 = (CardViewItem*)item1;
       CardViewItem *cItem2 = (CardViewItem*)item2;
 
       if ( cItem1 == cItem2 )
           return 0;
 
       if ((cItem1 == 0) || (cItem2 == 0))
           return cItem1 ? -1 : 1;
 
       if (cItem1->caption() < cItem2->caption())
         return -1;
 
       else if (cItem1->caption() > cItem2->caption())
         return 1;
 
       return 0;
     }
 
   private:
     /*int find( const CardViewItem * )
     {
       qDebug("DON'T USE CardViewItemList::find( item )! Use findRef( item )!");
     }*/
 };
 
 //////////////////////////////////////
 // CardViewSeparator
 class CardViewSeparator
 {
   friend class CardView;
 
   public:
     CardViewSeparator(CardView *view)
       : mView(view)
     {
       mRect = QRect(0, 0, view->separatorWidth(), 0);
     }
 
     ~CardViewSeparator() {}
 
     void paintSeparator(QPainter *p, QColorGroup &cg)
     {
       p->fillRect(0, 0, mRect.width(), mRect.height(),
                   cg.brush(QColorGroup::Button));
     }
 
     void repaintSeparator()
     {
       mView->repaintContents(mRect);
     }
 
   private:
     CardView *mView;
     QRect mRect;
 };
 
 //END Helpers
 
 //BEGIN Private Data
 
 class CardViewPrivate
 {
   public:
     CardViewPrivate()
      : mSelectionMode( CardView::Multi ),
        mDrawCardBorder( true ),
        mDrawFieldLabels( true ),
        mDrawSeparators( true),
        mSepWidth( 2 ),
        mShowEmptyFields( false ),
        mLayoutDirty( true ),
        mLastClickOnItem( false ),
        mItemMargin( 0 ),
        mItemSpacing( 10 ),
        mItemWidth( 200 ),
        mMaxFieldLines( INT_MAX ),
        mCurrentItem( 0L ),
        mLastClickPos( QPoint(0, 0) ),
        mResizeAnchor(0),
        mRubberBandAnchor( 0 ),
        mCompText( QString::null )
     {};
 
     CardViewItemList mItemList;
     QPtrList<CardViewSeparator> mSeparatorList;
     QFontMetrics *mFm;
     QFontMetrics *mBFm;         // bold font
     QFont mHeaderFont;           // custom header font
     CardView::SelectionMode mSelectionMode;
     bool mDrawCardBorder;
     bool mDrawFieldLabels;
     bool mDrawSeparators;
     int mSepWidth;
     bool mShowEmptyFields;
     bool mLayoutDirty;
     bool mLastClickOnItem;
     uint mItemMargin;           // internal margin in items
     uint mItemSpacing;          // spacing between items, column seperators and border
     int mItemWidth;             // width of all items
     uint mMaxFieldLines;        // Max lines to dispaly pr field
     CardViewItem *mCurrentItem;
     QPoint mLastClickPos;
     QTimer *mTimer;             // times out if mouse rests for more than 500 msecs
     CardViewTip *mTip;          // passed to the item under a resting cursor to display full text
     bool mOnSeparator;          // set/reset on mouse movement
     // for resizing by dragging the separators
     int mResizeAnchor;          // uint, ulong? the mouse down separator left
     int mRubberBandAnchor;      // for erasing rubber bands
     // data used for resizing.
     // as they are beeded by each mouse move while resizing, we store them here,
     // saving 8 calculations in each mouse move.
     int colspace;               // amount of space between items pr column
     uint first;                 // the first col to anchor at for painting rubber bands
     int firstX;                 // X position of first in pixel
     int pressed;                // the colummn that was pressed on at resizing start
     int span;                   // pressed - first
     // key completion
     QString mCompText;          // current completion string
     QDateTime mCompUpdated;     // ...was updated at this time
 };
 
 class CardViewItemPrivate
 {
   public:
     CardViewItemPrivate() :
         mSelected( false ),
         x( 0 ),
         y( 0 ){};
         
 
     QString mCaption;
     QPtrList< CardViewItem::Field > mFieldList;
     bool mSelected;
     int x;                      // horizontal position, set by the view
     int y;                      // vertical position, set by the view
     int maxLabelWidth;          // the width of the widest label, according to the view font.
     int hcache;                 // height cache
 };
 //END Private Data
 
 //BEGIN CardViewItem
 
 CardViewItem::CardViewItem(CardView *parent, QString caption)
   : d(new CardViewItemPrivate()), mView(parent)
 {
   d->mCaption = caption;
 
   initialize();
 }
 
 CardViewItem::~CardViewItem()
 {
   // Remove ourself from the view
   if (mView != 0)
     mView->takeItem(this);
 
   delete d;
   d = 0;
 }
 
 void CardViewItem::initialize()
 {
   d->mSelected = false;
   d->mFieldList.setAutoDelete(true);
   d->maxLabelWidth = 0;
   d->hcache=0;
 
   //calcRect();
 
  // Add ourself to the view
   if (mView != 0)
     mView->insertItem(this);
 }
 
 void CardViewItem::paintCard(QPainter *p, QColorGroup &cg)
 {
 
   if (!mView)
     return;
 
   QPen pen;
   QBrush brush;
   QFontMetrics fm = *(mView->d->mFm);
   QFontMetrics bFm = *(mView->d->mBFm);
   bool drawLabels = mView->d->mDrawFieldLabels;
   bool drawBorder = mView->d->mDrawCardBorder;
   int mg = mView->itemMargin();
   int w = mView->itemWidth() - (mg*2);
   int h = height() - (mg*2);
   const int colonWidth( fm.width(":") );
   int labelXPos = 2 + mg;
   int labelWidth = QMIN( w/2 - 4 - mg, d->maxLabelWidth + colonWidth + 4 );
   int valueXPos = labelWidth + 4 + mg;
   int valueWidth = w - labelWidth - 4 - mg;
 
   p->setFont( mView->font() );
   labelWidth -= colonWidth; // extra space for the colon
 
   if (!drawLabels)
   {
     valueXPos = labelXPos;
     valueWidth = w - 4;
   }
 
   // Draw a simple box
   if (isSelected())
     pen = QPen(cg.highlight(), 1);
   else
     pen = QPen(cg.button(), 1);
   p->setPen(pen);
 
   // Draw the border - this is only draw if the user asks for it.
   if (drawBorder)
     p->drawRect( mg, mg, w, h );
 
   // set the proper pen color for the caption box
   if (isSelected())
     brush = cg.brush(QColorGroup::Highlight);
   else
     brush = cg.brush(QColorGroup::Button);
 
   p->fillRect(mg, mg, w, 4 + bFm.height(), brush);
 
   // Now paint the caption
   p->save();
   QFont bFont = mView->headerFont();
   //bFont.setBold(true);
   p->setFont(bFont);
   if (isSelected())
     p->setPen(cg.highlightedText());
   else
     p->setPen(cg.buttonText());
   p->drawText(2+mg, 2+mg + bFm.ascent()/*bFm.height()*//*-bFm.descent()*//*-bFm.leading()*/, trimString(d->mCaption, w-4, bFm));
   p->restore();
 
   // Go through the fields and draw them
   QPtrListIterator< CardViewItem::Field > iter(d->mFieldList);
   QString label, value;
   int yPos = mg + 4 + bFm.height()/* + 1*/ + fm.height(); // why the + 1 ??? (anders)
   p->setPen(cg.text());
 
   int fh = fm.height();
   int cln( 0 );
   QString tmp;
   int maxLines = mView->maxFieldLines();
   for (iter.toFirst(); iter.current(); ++iter)
   {
     value = (*iter)->second;
     if ( value.isEmpty() && ! mView->d->mShowEmptyFields )
       continue;
 
     if (drawLabels)
     {
       label = trimString((*iter)->first, labelWidth, fm);
       p->drawText(labelXPos, yPos, label + ":");
     }
 /* US original     
     for (cln=0; cln <= maxLines; cln++)
     {
       tmp = value.section('\n',cln,cln);
       if ( !tmp.isEmpty() ) p->drawText( valueXPos, yPos + cln*fh, trimString( tmp, valueWidth, fm ) );
       else break;
     }
 */
 
 //US new implementation
     QStringList strlst = QStringList::split('\n', value, true);
 
     for (cln=0; cln <= maxLines && cln <= (int)strlst.count(); cln++)
     {
         tmp = strlst[cln];
         
         if ( !tmp.isEmpty() )
           p->drawText( valueXPos, yPos + cln*fh, trimString( tmp, valueWidth, fm ) );
         else
           break;
         
     }
     
     if ( cln == 0 ) cln = 1;
     yPos += cln * fh + 2;
   }    
   
   // if we are the current item and the view has focus, draw focus rect
   if ( mView->currentItem() == this && mView->hasFocus() )
   {
 /*US  
     mView->style().drawPrimitive( QStyle::PE_FocusRect, p,
         QRect(0, 0, mView->itemWidth(), h+(2*mg)), cg,
         QStyle::Style_FocusAtBorder,
         QStyleOption( isSelected() ? cg.highlight() : cg.base() ) );
 */        
         
       const QColor pHighl = isSelected() ? cg.highlight() : cg.base();
       const QRect r(0, 0, mView->itemWidth(), h+(2*mg));
 #ifndef DESKTOP_VERSION
       mView->style().drawFocusRect(p, r, cg, &pHighl, true);
 #endif
    }
 }
 
 const QString &CardViewItem::caption() const
 {
   return d->mCaption;
 }
 
 
 int CardViewItem::height( bool allowCache ) const
 {
   // use cache
   if ( allowCache && d->hcache )
     return d->hcache;
 
   // Base height:
   //  2 for line width
   //  2 for top caption pad
   //  2 for bottom caption pad
   //   2 pad for the end
   // + 2 times the advised margin
   int baseHeight = 8 + ( 2 * mView->itemMargin() );
 
   //  size of font for each field
   //  2 pad for each field
 
   // anders: if the view does not show empty fields, check for value
   bool sef = mView->showEmptyFields();
   int fh = mView->d->mFm->height();//lineSpacing(); // font height
   //int sp = QMAX( 0, 2- mView->d->mFm->leading() ); // field spacing NOTE make a property
   int fieldHeight = 0;
   int lines;
   int maxLines( mView->maxFieldLines() );
   QPtrListIterator< CardViewItem::Field > iter(d->mFieldList);
   for (iter.toFirst(); iter.current(); ++iter)
   {
     if ( !sef && (*iter)->second.isEmpty() )
       continue;
     lines = QMIN( (*iter)->second.contains('\n') + 1, maxLines );
     fieldHeight += ( lines * fh ) + 2;//sp;
   }
 
   // height of caption font (bold)
   fieldHeight += mView->d->mBFm->height();
   d->hcache = baseHeight + fieldHeight;
   return d->hcache;
 }
 
 bool CardViewItem::isSelected() const
 {
   return d->mSelected;
 }
 
 void CardViewItem::setSelected(bool selected)
 {
   d->mSelected = selected;
 }
 
 void CardViewItem::insertField(const QString &label, const QString &value)
 {
   CardViewItem::Field *f = new CardViewItem::Field(label, value);
   d->mFieldList.append(f);
   d->hcache=0;
 
   if (mView)
   {
     mView->setLayoutDirty(true);
     d->maxLabelWidth = QMAX( mView->d->mFm->width( label ), d->maxLabelWidth );
   }
 }
 
 void CardViewItem::removeField(const QString &label)
 {
   CardViewItem::Field *f;
 
   QPtrListIterator< CardViewItem::Field > iter(d->mFieldList);
   for (iter.toFirst(); iter.current(); ++iter)
   {
     f = *iter;
     if (f->first == label)
       break;
   }
 
   if (*iter)
     d->mFieldList.remove(*iter);
   d->hcache = 0;
 
   if (mView)
     mView->setLayoutDirty(true);
 }
 
 void CardViewItem::clearFields()
 {
   d->mFieldList.clear();
   d->hcache = 0;
 
   if (mView)
     mView->setLayoutDirty(true);
 }
 
 QString CardViewItem::trimString(const QString &text, int width,
                                  QFontMetrics &fm)
 {
   if (fm.width(text) <= width)
     return text;
 
   QString dots = "...";
   int dotWidth = fm.width(dots);
   QString trimmed;
   int charNum = 0;
 
   while (fm.width(trimmed) + dotWidth < width)
   {
     trimmed += text[charNum];
     charNum++;
   }
 
   // Now trim the last char, since it put the width over the top
   trimmed = trimmed.left(trimmed.length()-1);
   trimmed += dots;
 
   return trimmed;
 }
 
 CardViewItem *CardViewItem::nextItem()
 {
   CardViewItem *item = 0;
 
   if (mView)
     item = mView->itemAfter(this);
 
   return item;
 }
 
 void CardViewItem::repaintCard()
 {
   if (mView)
     mView->repaintItem(this);
 }
 
 void CardViewItem::setCaption(const QString &caption)
 {
   d->mCaption = caption;
   repaintCard();
 }
 
 QString CardViewItem::fieldValue(const QString &label)
 {
   QPtrListIterator< CardViewItem::Field > iter(d->mFieldList);
   for (iter.toFirst(); iter.current(); ++iter)
     if ((*iter)->first == label)
         return (*iter)->second;
 
   return QString();
 }
 
 
 void CardViewItem::showFullString( const QPoint &itempos, CardViewTip *tip )
 {
   bool trimmed( false );
   QString s;
   int mrg = mView->itemMargin();
   int y = mView->d->mBFm->height() + 6 + mrg;
   int w = mView->itemWidth() - (2*mrg);
   int lw;
   bool drawLabels = mView->drawFieldLabels();
   bool isLabel = drawLabels && itempos.x() < w/2 ? true : false;
 
   if ( itempos.y() < y )
   {
     if ( itempos.y() < 8 + mrg || itempos.y() > y - 4 )
       return;
     // this is the caption
     s = caption();
     trimmed = mView->d->mBFm->width( s ) > w - 4;
     y = 2 + mrg;
     lw = 0;
     isLabel=true;
   } else {
     // find the field
     Field *f = fieldAt( itempos );
     if ( !f || ( !mView->showEmptyFields() && f->second.isEmpty() ) )
       return;
 
     // y position:
     // header font height + 4px hader margin + 2px leading + item margin
     // + actual field index * (fontheight + 2px leading)
     int maxLines = mView->maxFieldLines();
     bool se = mView->showEmptyFields();
     int fh = mView->d->mFm->height();
 //    {
     Field *_f;
     for (_f = d->mFieldList.first(); _f != f; _f = d->mFieldList.next())
       if ( se || ! _f->second.isEmpty() )
         y += ( QMIN(_f->second.contains('\n')+1, maxLines) * fh ) + 2;
 //    }
     if ( isLabel && itempos.y() > y + fh )
       return;
     // label or data?
     s = isLabel ? f->first : f->second;
     // trimmed?
     int colonWidth = mView->d->mFm->width(":");
     lw = drawLabels ?         // label width
       QMIN( w/2 - 4 - mrg, d->maxLabelWidth + colonWidth + 4 ) :
       0;
     int mw = isLabel ? lw - colonWidth : w - lw - (mrg*2); // max width for string
     if ( isLabel )
     {
       trimmed = mView->d->mFm->width( s ) > mw - colonWidth;
     } else {
       QRect r( mView->d->mFm->boundingRect( 0, 0, INT_MAX, INT_MAX, Qt::AlignTop|Qt::AlignLeft, s ) );
       trimmed = r.width() > mw || r.height()/fh >  QMIN(s.contains('\n') + 1, maxLines);
     }
   }
   if ( trimmed )
   {
     tip->setFont( (isLabel && !lw) ? mView->headerFont() : mView->font() ); // if condition is true, a header
     tip->setText( s );
     tip->adjustSize();
     // find a proper position
     int lx;
     lx = isLabel || !drawLabels ? mrg : lw + mrg + 2 /*-1*/;
     QPoint pnt(mView->contentsToViewport( QPoint(d->x, d->y) ));
     pnt += QPoint(lx, y);
     if ( pnt.x() < 0 )
       pnt.setX( 0 );
     if ( pnt.x() + tip->width() > mView->visibleWidth() )
       pnt.setX( mView->visibleWidth() - tip->width() );
     if ( pnt.y() + tip->height() > mView->visibleHeight() )
       pnt.setY( QMAX( 0, mView->visibleHeight() - tip->height() ) );
     // show
     tip->move( pnt );
     tip->show();
   }
 }
 
 CardViewItem::Field *CardViewItem::fieldAt( const QPoint & itempos ) const
 {
   int ypos = mView->d->mBFm->height() + 7 + mView->d->mItemMargin;
   int iy = itempos.y();
   // skip below caption
   if ( iy <= ypos )
     return 0;
   // try find a field
   bool showEmpty = mView->showEmptyFields();
   int fh = mView->d->mFm->height();
   int maxLines = mView->maxFieldLines();
   Field *f;
   for ( f = d->mFieldList.first(); f; f = d->mFieldList.next() )
   {
     if ( showEmpty || !f->second.isEmpty() )
       ypos += ( QMIN( f->second.contains('\n')+1, maxLines ) *fh)+2;
     if ( iy <= ypos )
       break;
   }
   return f ? f : 0;
 }
 //END CardViewItem
 
 //BEGIN CardView
 
 CardView::CardView(QWidget *parent, const char *name)
   : QScrollView(parent, name),
     d(new CardViewPrivate())
 {
     mFlagKeyPressed = false;
     mFlagBlockKeyPressed = false;
   d->mItemList.setAutoDelete(true);
   d->mSeparatorList.setAutoDelete(true);
 
   QFont f = font();
   d->mFm = new QFontMetrics(f);
   f.setBold(true);
   d->mHeaderFont = f;
   d->mBFm = new QFontMetrics(f);
   d->mTip = ( new CardViewTip( viewport() ) ),
   d->mTip->hide();
   d->mTimer = ( new QTimer(this, "mouseTimer") ),
 
   viewport()->setMouseTracking( true );
   viewport()->setFocusProxy(this);
   viewport()->setFocusPolicy(WheelFocus);
   viewport()->setBackgroundMode(PaletteBase);
 
   connect( d->mTimer, SIGNAL(timeout()), this, SLOT(tryShowFullText()) );
 
 //US  setBackgroundMode(PaletteBackground, PaletteBase);
   setBackgroundMode(PaletteBackground);
 
   // no reason for a vertical scrollbar
   setVScrollBarMode(AlwaysOff);
 }
 
 CardView::~CardView()
 {
     delete d->mFm;
     delete d->mBFm;
     delete d;
     d = 0;
 }
 
 void CardView::insertItem(CardViewItem *item)
 {
   d->mItemList.inSort(item);
   setLayoutDirty(true);
 }
 
 void CardView::takeItem(CardViewItem *item)
 {
   if ( d->mCurrentItem == item )
     d->mCurrentItem = item->nextItem();
   d->mItemList.take(d->mItemList.findRef(item));
 
   setLayoutDirty(true);
 }
 
 void CardView::clear()
 {
   d->mItemList.clear();
 
   setLayoutDirty(true);
 }
 
 CardViewItem *CardView::currentItem()
 {
   if ( ! d->mCurrentItem && d->mItemList.count() )
     d->mCurrentItem = d->mItemList.first();
   return d->mCurrentItem;
 }
 
 void CardView::setCurrentItem( CardViewItem *item )
 {
   if ( !item )
     return;
   else if ( item->cardView() != this )
   {
     kdDebug(5720)<<"CardView::setCurrentItem: Item ("<<item<<") not owned! Backing out.."<<endl;
     return;
   }
   else if ( item == currentItem() )
   {
     return;
   }
 
   if ( d->mSelectionMode == Single )
   {
     setSelected( item, true );
   }
   else
   {
     CardViewItem *it = d->mCurrentItem;
     d->mCurrentItem = item;
     if ( it )
       it->repaintCard();
     item->repaintCard();
   }
   if ( ! d->mOnSeparator )
     ensureItemVisible( item );
   emit currentChanged( item );
 }
 
 CardViewItem *CardView::itemAt(const QPoint &viewPos)
 {
   CardViewItem *item = 0;
   QPtrListIterator<CardViewItem> iter(d->mItemList);
   bool found = false;
   for (iter.toFirst(); iter.current() && !found; ++iter)
   {
     item = *iter;
     //if (item->d->mRect.contains(viewPos))
     if (QRect(item->d->x, item->d->y, d->mItemWidth, item->height()).contains(viewPos))
       found = true;
   }
 
   if (found)
     return item;
 
   return 0;
 }
 
 QRect CardView::itemRect(const CardViewItem *item)
 {
   //return item->d->mRect;
   return QRect(item->d->x, item->d->y, d->mItemWidth, item->height());
 }
 
 void CardView::ensureItemVisible(const CardViewItem *item)
 {
   ensureVisible(item->d->x                , item->d->y, d->mItemSpacing, 0);
   ensureVisible(item->d->x + d->mItemWidth, item->d->y, d->mItemSpacing, 0);
 }
 
 void CardView::repaintItem(const CardViewItem *item)
 {
   //repaintContents(item->d->mRect);
   repaintContents(  QRect(item->d->x, item->d->y, d->mItemWidth, item->height()) );
 }
 
 void CardView::setSelectionMode(CardView::SelectionMode mode)
 {
   selectAll(false);
 
   d->mSelectionMode = mode;
 }
 
 CardView::SelectionMode CardView::selectionMode() const
 {
   return d->mSelectionMode;
 }
 
 void CardView::selectAll(bool state)
 {
   QPtrListIterator<CardViewItem> iter(d->mItemList);
   if (!state)
   {
     for (iter.toFirst(); iter.current(); ++iter)
     {
       if ((*iter)->isSelected())
       {
         (*iter)->setSelected(false);
         (*iter)->repaintCard();
       }
     }
     //emit selectionChanged();  // WARNING FIXME
     emit selectionChanged(0);
   }
   else if (d->mSelectionMode != CardView::Single)
   {
     for (iter.toFirst(); iter.current(); ++iter)
     {
       (*iter)->setSelected(true);
     }
 
     if (d->mItemList.count() > 0)
     {
       // emit, since there must have been at least one selected
       emit selectionChanged();
       //repaint();//???
       viewport()->update();
     }
   }
 }
 
 void CardView::setSelected(CardViewItem *item, bool selected)
 {
   if ((item == 0) || (item->isSelected() == selected))
     return;
 
   if ( selected && d->mCurrentItem != item )
   {
     CardViewItem *it = d->mCurrentItem;
     d->mCurrentItem = item;
     if ( it )
       it->repaintCard();
   }
 
   if (d->mSelectionMode == CardView::Single)
   {
     bool b = signalsBlocked();
     blockSignals(true);
     selectAll(false);
     blockSignals(b);
 
     if (selected)
     {
       item->setSelected(selected);
       item->repaintCard();
       emit selectionChanged();
       emit selectionChanged(item);
     }
     else
     {
       emit selectionChanged();
       emit selectionChanged(0);
     }
   }
   else if (d->mSelectionMode == CardView::Multi)
   {
     item->setSelected(selected);
     item->repaintCard();
     emit selectionChanged();
   }
   else if (d->mSelectionMode == CardView::Extended)
   {
     bool b = signalsBlocked();
     blockSignals(true);
     selectAll(false);
     blockSignals(b);
 
     item->setSelected(selected);
     item->repaintCard();
     emit selectionChanged();
   }
 }
 
 bool CardView::isSelected(CardViewItem *item) const
 {
   return (item && item->isSelected());
 }
 
 CardViewItem *CardView::selectedItem() const
 {
   // find the first selected item
   QPtrListIterator<CardViewItem> iter(d->mItemList);
   for (iter.toFirst(); iter.current(); ++iter)
   {
     if ((*iter)->isSelected())
       return *iter;
   }
 
   return 0;
 }
 
 CardViewItem *CardView::firstItem() const
 {
   return d->mItemList.first();
 }
 
 int CardView::childCount() const
 {
   return d->mItemList.count();
 }
 /*US
 CardViewItem *CardView::findItem(const QString &text, const QString &label,
                                  Qt::StringComparisonMode compare)
 {
   // IF the text is empty, we will return null, since empty text will
   // match anything!
   if (text.isEmpty())
     return 0;
 
   QPtrListIterator<CardViewItem> iter(d->mItemList);
   if (compare & Qt::BeginsWith)
   {
     QString value;
     for (iter.toFirst(); iter.current(); ++iter)
     {
       value = (*iter)->fieldValue(label).upper();
       if (value.startsWith(text.upper()))
         return *iter;
     }
   }
   else
   {
     kdDebug(5720) << "CardView::findItem: search method not implemented" << endl;
   }
 
   return 0;
 }
 */
 
 uint CardView::columnWidth()
 {
   return d->mDrawSeparators ?
     d->mItemWidth + ( 2 * d->mItemSpacing ) + d->mSepWidth :
     d->mItemWidth + d->mItemSpacing;
 }
 
 void CardView::drawContents(QPainter *p, int clipx, int clipy,
                             int clipw, int cliph)
 {
-  QScrollView::drawContents(p, clipx, clipy, clipw, cliph);
-
+    //QScrollView::drawContents(p, clipx, clipy, clipw, cliph);
  if (d->mLayoutDirty)
    calcLayout();
 
   //kdDebug() << "CardView::drawContents: " << clipx << ", " << clipy
   //          << ", " << clipw << ", " << cliph << endl;
 
   QColorGroup cg = viewport()->palette().active(); // allow setting costum colors in the viewport pale
-
+  int cX, cY;
+  contentsToViewport ( clipx, clipy, cX, cY ); 
   QRect clipRect(clipx, clipy, clipw, cliph);
   QRect cardRect;
   QRect sepRect;
   CardViewItem *item;
   CardViewSeparator *sep;
-
   // make sure the viewport is a pure background
-  viewport()->erase(clipRect);
+  viewport()->erase( QRect ( cX, cY , clipw, cliph ) );
 
   // Now tell the cards to draw, if they are in the clip region
   QPtrListIterator<CardViewItem> iter(d->mItemList);
   for (iter.toFirst(); iter.current(); ++iter)
   {
     item = *iter;
     cardRect.setRect( item->d->x, item->d->y, d->mItemWidth, item->height() );
 
     if (clipRect.intersects(cardRect) || clipRect.contains(cardRect))
     {
       //kdDebug() << "\trepainting card at: " << cardRect.x() << ", "
       //          << cardRect.y() << endl;
 
       // Tell the card to paint
       p->save();
       p->translate(cardRect.x(), cardRect.y());
       item->paintCard(p, cg);
       p->restore();
     }
   }
 
   // Followed by the separators if they are in the clip region
   QPtrListIterator<CardViewSeparator> sepIter(d->mSeparatorList);
   for (sepIter.toFirst(); sepIter.current(); ++sepIter)
   {
     sep = *sepIter;
     sepRect = sep->mRect;
 
     if (clipRect.intersects(sepRect) || clipRect.contains(sepRect))
     {
       p->save();
       p->translate(sepRect.x(), sepRect.y());
       sep->paintSeparator(p, cg);
       p->restore();
     }
   }
 }
 
 void CardView::resizeEvent(QResizeEvent *e)
 {
   QScrollView::resizeEvent(e);
 
   setLayoutDirty(true);
 }
 
 void CardView::calcLayout()
 {
   //kdDebug() << "CardView::calcLayout:" << endl;
 
   // Start in the upper left corner and layout all the
   // cars using their height and width
   int maxWidth = 0;
   int maxHeight = 0;
   int xPos = 0;
   int yPos = 0;
   int cardSpacing = d->mItemSpacing;
 
   // delete the old separators
   d->mSeparatorList.clear();
 
   QPtrListIterator<CardViewItem> iter(d->mItemList);
   CardViewItem *item = 0;
   CardViewSeparator *sep = 0;
   xPos += cardSpacing;
 
   for (iter.toFirst(); iter.current(); ++iter)
   {
     item = *iter;
 
     yPos += cardSpacing;
 
     if (yPos + item->height() + cardSpacing >= height() - horizontalScrollBar()->height())
     {
       maxHeight = QMAX(maxHeight, yPos);
 
       // Drawing in this column would be greater than the height
       // of the scroll view, so move to next column
       yPos = cardSpacing;
       xPos += cardSpacing + maxWidth;
       if (d->mDrawSeparators)
       {
         // Create a separator since the user asked
         sep = new CardViewSeparator(this);
         sep->mRect.moveTopLeft(QPoint(xPos, yPos+d->mItemMargin));
         xPos += d->mSepWidth + cardSpacing;
         d->mSeparatorList.append(sep);
       }
 
       maxWidth = 0;
     }
 
     item->d->x = xPos;
     item->d->y = yPos;
 
     yPos += item->height();
     maxWidth = QMAX(maxWidth, d->mItemWidth);
   }
 
   xPos += maxWidth;
   resizeContents( xPos + cardSpacing, maxHeight );
 
   // Update the height of all the separators now that we know the
   // max height of a column
   QPtrListIterator<CardViewSeparator> sepIter(d->mSeparatorList);
   for (sepIter.toFirst(); sepIter.current(); ++sepIter)
   {
     (*sepIter)->mRect.setHeight(maxHeight - 2*cardSpacing - 2*d->mItemMargin);
   }
 
   d->mLayoutDirty = false;
 }
 
 CardViewItem *CardView::itemAfter(CardViewItem *item)
 {
   /*int pos = */d->mItemList.findRef(item);
   return d->mItemList.next();//at(pos+1);
 }
 
 uint CardView::itemMargin()
 {
   return d->mItemMargin;
 }
 
 void CardView::setItemMargin( uint margin )
 {
   if ( margin == d->mItemMargin )
     return;
 
   d->mItemMargin = margin;
   setLayoutDirty( true );
 }
 
 uint CardView::itemSpacing()
 {
   return d->mItemSpacing;
 }
 
 void CardView::setItemSpacing( uint spacing )
 {
   if ( spacing == d->mItemSpacing )
     return;
 
   d->mItemSpacing = spacing;
   setLayoutDirty( true );
 }
 
 void CardView::contentsMousePressEvent(QMouseEvent *e)
 {
   QScrollView::contentsMousePressEvent(e);
 
   QPoint pos = e->pos();
   d->mLastClickPos = pos;
 
   CardViewItem *item = itemAt(pos);
 
   if (item == 0)
   {
     d->mLastClickOnItem = false;
     if ( d->mOnSeparator)
     {
       d->mResizeAnchor = e->x()+contentsX();
       d->colspace = (2*d->mItemSpacing) /*+ (2*d->mItemMargin)*/;
       int ccw = d->mItemWidth + d->colspace + d->mSepWidth;
       d->first = (contentsX()+d->mSepWidth)/ccw;
       d->pressed = (d->mResizeAnchor+d->mSepWidth)/ccw;
       d->span = d->pressed - d->first;
       d->firstX = d->first * ccw;
       if ( d->firstX ) d->firstX -= d->mSepWidth;            // (no sep in col 0)
     }
     else
     {
       selectAll(false);
     }
     return;
   }
 
   d->mLastClickOnItem = true;
 
   CardViewItem *other = d->mCurrentItem;
   setCurrentItem( item );
 
   // Always emit the selection
   emit clicked(item);
 
   // Check the selection type and update accordingly
   if (d->mSelectionMode == CardView::Single)
   {
     // make sure it isn't already selected
     if (item->isSelected())
       return;
 
     bool b = signalsBlocked();
     blockSignals(true);
     selectAll(false);
     blockSignals(b);
 
     item->setSelected(true);
     item->repaintCard();
     emit selectionChanged(item);
   }
 
   else if (d->mSelectionMode == CardView::Multi)
   {
     // toggle the selection
     item->setSelected(!item->isSelected());
     item->repaintCard();
     emit selectionChanged();
   }
 
   else if (d->mSelectionMode == CardView::Extended)
   {
     if ((e->button() & Qt::LeftButton) &&
              (e->state() & Qt::ShiftButton))
     {
       if ( item == other ) return;
 
       bool s = ! item->isSelected();
 
       if ( s && ! (e->state() & ControlButton) )
       {
         bool b = signalsBlocked();
         blockSignals(true);
         selectAll(false);
         blockSignals(b);
       }
 
       int from, to, a, b;
       a = d->mItemList.findRef( item );
       b = d->mItemList.findRef( other );
       from = a < b ? a : b;
       to = a > b ? a : b;
       //kdDebug()<<"selecting items "<<from<<" - "<<to<<" ( "<<s<<" )"<<endl;
       CardViewItem *aItem;
       for ( ; from <= to; from++ )
       {
         aItem = d->mItemList.at( from );
         aItem->setSelected( s );
         repaintItem( aItem );
       }
       emit selectionChanged();
     }
     else if ((e->button() & Qt::LeftButton) &&
         (e->state() & Qt::ControlButton))
     {
       item->setSelected(!item->isSelected());
       item->repaintCard();
       emit selectionChanged();
     }
 
     else if (e->button() & Qt::LeftButton)
     {
       bool b = signalsBlocked();
       blockSignals(true);
       selectAll(false);
       blockSignals(b);
 
       item->setSelected(true);
       item->repaintCard();
       emit selectionChanged();
     }
   }
 
 }
 
 void CardView::contentsMouseReleaseEvent(QMouseEvent *e)
 {
   QScrollView::contentsMouseReleaseEvent(e);
 
   if ( d->mResizeAnchor )
   {
     // finish the resizing:
         unsetCursor();
     // hide rubber bands
     int newiw = d->mItemWidth - ((d->mResizeAnchor - d->mRubberBandAnchor)/d->span);
     drawRubberBands( 0 );
     // we should move to reflect the new position if we are scrolled.
     if ( contentsX() )
     {
       int newX = QMAX( 0, ( d->pressed * ( newiw + d->colspace + d->mSepWidth ) ) - e->x() );
       setContentsPos( newX, contentsY() );
     }
     // set new item width
     setItemWidth( newiw );
     // reset anchors
     d->mResizeAnchor = 0;
     d->mRubberBandAnchor = 0;
     return;
   }
 
   // If there are accel keys, we will not emit signals
   if ((e->state() & Qt::ShiftButton) || (e->state() & Qt::ControlButton))
     return;
 
   // Get the item at this position
   CardViewItem *item = itemAt(e->pos());
 
   if (item && KABPrefs::instance()->mHonorSingleClick)
   {
     emit executed(item);
   }
 }
 
 void CardView::contentsMouseDoubleClickEvent(QMouseEvent *e)
 {
   QScrollView::contentsMouseDoubleClickEvent(e);
 
   CardViewItem *item = itemAt(e->pos());
 
   if (item)
   {
     d->mCurrentItem = item;
   }
 
   if (item && !KABPrefs::instance()->mHonorSingleClick)
   {
       emit executed(item);
   } else
       emit doubleClicked(item);
 }
 
 void CardView::contentsMouseMoveEvent( QMouseEvent *e )
 {
   // resizing
   if ( d->mResizeAnchor )
   {
     int x = e->x();
     if ( x != d->mRubberBandAnchor )
       drawRubberBands( x );
       return;
   }
         
   if (d->mLastClickOnItem && (e->state() & Qt::LeftButton) &&
      ((e->pos() - d->mLastClickPos).manhattanLength() > 4)) {
           
      startDrag();
          return;
   }
 
   d->mTimer->start( 500 );
 
   // see if we are over a separator
   // only if we actually have them painted?
   if ( d->mDrawSeparators  )
   {
     int colcontentw = d->mItemWidth + (2*d->mItemSpacing);
     int colw = colcontentw + d->mSepWidth;
     int m = e->x()%colw;
     if ( m >= colcontentw && m > 0 )
     {
       setCursor( SplitVCursor ); // Why does this fail sometimes?
       d->mOnSeparator = true;
     }
     else
     {
       setCursor( ArrowCursor );
       d->mOnSeparator = false;
     }
   }
 }
 
 void CardView::enterEvent( QEvent * )
 {
   d->mTimer->start( 500 );
 }
 
 void CardView::leaveEvent( QEvent * )
 {
   d->mTimer->stop();
   if (d->mOnSeparator)
   {
     d->mOnSeparator = false;
     setCursor( ArrowCursor );
    }
 }
 
 void CardView::focusInEvent( QFocusEvent * )
 {
   if (!d->mCurrentItem && d->mItemList.count() )
   {
     setCurrentItem( d->mItemList.first() );
   }
   else if ( d->mCurrentItem )
   {
     d->mCurrentItem->repaintCard();
   }
 }
 
 void CardView::focusOutEvent( QFocusEvent * )
 {
   if (d->mCurrentItem)
     d->mCurrentItem->repaintCard();
 }
 
 void CardView::keyPressEvent( QKeyEvent *e )
 {
   if ( ! ( childCount() && d->mCurrentItem ) )
   {
     e->ignore();
     return;
   }
   if ( mFlagBlockKeyPressed )
       return;
   qApp->processEvents();
   if ( e->isAutoRepeat() && !mFlagKeyPressed ) {
       e->accept();
       return;
   } 
   if (! e->isAutoRepeat() )
       mFlagKeyPressed = true;
   uint pos = d->mItemList.findRef( d->mCurrentItem );
   CardViewItem *aItem = 0L; // item that gets the focus
   CardViewItem *old = d->mCurrentItem;
 
   switch ( e->key() )
   {
     case Key_Up:
     if ( pos > 0 )
     {
       aItem = d->mItemList.at( pos - 1 );
       setCurrentItem( aItem );
     }
     break;
     case Key_Down:
     if ( pos < d->mItemList.count() - 1 )
     {
       aItem = d->mItemList.at( pos + 1 );
       setCurrentItem( aItem );
     }
     break;
     case Key_Left:
     {
       // look for an item in the previous/next column, starting from
       // the vertical middle of the current item.
       // FIXME use nice calculatd measures!!!
       QPoint aPoint( d->mCurrentItem->d->x, d->mCurrentItem->d->y );
       aPoint -= QPoint( 30,-(d->mCurrentItem->height()/2) );
       aItem = itemAt( aPoint );
       // maybe we hit some space below an item
       while ( !aItem && aPoint.y() > 27 )
       {
         aPoint -= QPoint( 0, 16 );
         aItem = itemAt( aPoint );
       }
       if ( aItem )
         setCurrentItem( aItem );
     }
     break;
     case Key_Right:
     {
       // FIXME use nice calculated measures!!!
       QPoint aPoint( d->mCurrentItem->d->x + d->mItemWidth, d->mCurrentItem->d->y );
       aPoint += QPoint( 30,(d->mCurrentItem->height()/2) );
       aItem = itemAt( aPoint );
       while ( !aItem && aPoint.y() > 27 )
       {
         aPoint -= QPoint( 0, 16 );
         aItem = itemAt( aPoint );
       }
       if ( aItem )
         setCurrentItem( aItem );
     }
     break;
     case Key_Home:
     aItem = d->mItemList.first();
     setCurrentItem( aItem );
     break;
     case Key_End:
     aItem = d->mItemList.last();
     setCurrentItem( aItem );
     break;
     case Key_Prior: // PageUp
     {
       // QListView: "Make the item above the top visible and current"
       // TODO if contentsY(), pick the top item of the leftmost visible column
       if ( contentsX() <= 0 )
         return;
       int cw = columnWidth();
       int theCol = ( QMAX( 0, ( contentsX()/cw) * cw ) ) + d->mItemSpacing;
       aItem = itemAt( QPoint( theCol + 1, d->mItemSpacing + 1 ) );
       if ( aItem )
         setCurrentItem( aItem );
     }
     break;
     case Key_Next:  // PageDown
     {
       // QListView: "Make the item below the bottom visible and current"
       // find the first not fully visible column.
       // TODO: consider if a partly visible (or even hidden) item at the
       //       bottom of the rightmost column exists
       int cw = columnWidth();
       int theCol = ( (( contentsX() + visibleWidth() )/cw) * cw ) + d->mItemSpacing + 1;
       // if separators are on, we may need to we may be one column further right if only the spacing/sep is hidden
       if ( d->mDrawSeparators && cw - (( contentsX() + visibleWidth() )%cw) <= int( d->mItemSpacing + d->mSepWidth ) )
         theCol += cw;
 
       // make sure this is not too far right
       while ( theCol > contentsWidth() )
         theCol -= columnWidth();
 
       aItem = itemAt( QPoint( theCol, d->mItemSpacing + 1 ) );
 
       if ( aItem )
         setCurrentItem( aItem );
     }
     break;
     case Key_Space:
     setSelected( d->mCurrentItem, !d->mCurrentItem->isSelected() );
     emit selectionChanged();
     break;
     case Key_Return:
     case Key_Enter: 
         {
             emit returnPressed( d->mCurrentItem );
             emit executed( d->mCurrentItem );
         }
     break;
     default:
     if ( (e->state() & ControlButton) && e->key() == Key_A )
     {
       // select all
       selectAll( true );
       break;
     }
     // if we have a string, do autosearch
     else if ( ! e->text().isEmpty() && e->text()[0].isPrint() )
     {
 
     }
     break;
   }
   // handle selection
   if ( aItem )
   {
     if ( d->mSelectionMode == CardView::Extended )
     {
       if ( (e->state() & ShiftButton) )
       {
         // shift button: toggle range
         // if control button is pressed, leave all items
         // and toggle selection current->old current
         // otherwise, ??????
         bool s = ! aItem->isSelected();
         int from, to, a, b;
         a = d->mItemList.findRef( aItem );
         b = d->mItemList.findRef( old );
         from = a < b ? a : b;
         to = a > b ? a : b;
 
         if ( to - from > 1 )
         {
           bool b = signalsBlocked();
           blockSignals(true);
           selectAll(false);
           blockSignals(b);
         }
 
         //kdDebug()<<"selecting items "<<from<<" - "<<to<<" ( "<<s<<" )"<<endl;
         CardViewItem *item;
         for ( ; from <= to; from++ )
         {
           item = d->mItemList.at( from );
           item->setSelected( s );
           repaintItem( item );
         }
         emit selectionChanged();
       }
       else if ( (e->state() & ControlButton) )
       {
         // control button: do nothing
       }
       else
       {
         // no button: move selection to this item
         bool b = signalsBlocked();
         blockSignals(true);
         selectAll(false);
         blockSignals(b);
 
         setSelected( aItem, true );
         emit selectionChanged();
       }
     }
   }
 }
 
 void CardView::contentsWheelEvent( QWheelEvent * e )
 {
   scrollBy(2*e->delta()/-3, 0);
 }
 
 void CardView::setLayoutDirty(bool dirty)
 {
   if (d->mLayoutDirty != dirty)
   {
     d->mLayoutDirty = dirty;
     repaint();
   }
 }
 
 void CardView::setDrawCardBorder(bool enabled)
 {
   if (enabled != d->mDrawCardBorder)
   {
     d->mDrawCardBorder = enabled;
     repaint();
   }
 }
 
 bool CardView::drawCardBorder() const
 {
   return d->mDrawCardBorder;
 }
 
 void CardView::setDrawColSeparators(bool enabled)
 {
   if (enabled != d->mDrawSeparators)
   {
     d->mDrawSeparators = enabled;
     setLayoutDirty(true);
   }
 }
 
 bool CardView::drawColSeparators() const
 {
   return d->mDrawSeparators;
 }
 
 void CardView::setDrawFieldLabels(bool enabled)
 {
   if (enabled != d->mDrawFieldLabels)
   {
     d->mDrawFieldLabels = enabled;
     repaint();
   }
 }
 
 bool CardView::drawFieldLabels() const
 {
   return d->mDrawFieldLabels;
 }
 
 void CardView::setShowEmptyFields(bool show)
 {
   if (show != d->mShowEmptyFields)
   {
     d->mShowEmptyFields = show;
     setLayoutDirty(true);
   }
 }
 
 bool CardView::showEmptyFields() const
 {
   return d->mShowEmptyFields;
 }
 
 void CardView::startDrag()
 {
   // The default implementation is a no-op. It must be
   // reimplemented in a subclass to be useful
 }
 void CardView::tryShowFullText()
 {
   d->mTimer->stop();
   // if we have an item
   QPoint cpos = viewportToContents( viewport()->mapFromGlobal( QCursor::pos() ) );
   CardViewItem *item = itemAt( cpos );
   if ( item )
   {
     // query it for a value to display
     //QString s = item ? item->caption() : "(no item)";
     //kdDebug()<<"MOUSE REST: "<<s<<endl;
     QPoint ipos = cpos - itemRect( item ).topLeft();
     item->showFullString( ipos, d->mTip );
   }
 }
 
 void CardView::drawRubberBands( int pos )
 {
   if ( pos && ((pos-d->firstX)/d->span) - d->colspace - d->mSepWidth < MIN_ITEM_WIDTH ) return;
 
   int tmpcw = (d->mRubberBandAnchor-d->firstX)/d->span;
   int x = d->firstX + tmpcw - d->mSepWidth - contentsX();
   int h = visibleHeight();
 
   QPainter p( viewport() );
   p.setRasterOp( XorROP );
   p.setPen( gray );
   p.setBrush( gray );
   uint n = d->first;
   // erase
   if ( d->mRubberBandAnchor )
     do {
       p.drawRect( x, 0, 2, h );
       x += tmpcw;
       n++;
     } while ( x < visibleWidth() && n < d->mSeparatorList.count() );
   // paint new
   if ( ! pos ) return;
   tmpcw = (pos - d->firstX)/d->span;
   n = d->first;
   x = d->firstX + tmpcw - d->mSepWidth - contentsX();
   do {
       p.drawRect( x, 0, 2, h );
       x += tmpcw;
       n++;
   } while ( x < visibleWidth() && n < d->mSeparatorList.count() );
   d->mRubberBandAnchor = pos;
 }
 
 
 int CardView::itemWidth() const
 {
   return d->mItemWidth;
 }
 
 void CardView::setItemWidth( int w )
 {
   if ( w == d->mItemWidth )
     return;
   if ( w < MIN_ITEM_WIDTH )
     w = MIN_ITEM_WIDTH;
   d->mItemWidth = w;
   setLayoutDirty( true );
 #ifndef KAB_EMBEDDED  
   updateContents();
 #else //KAB_EMBEDDED  
 //US  updateContents( d->contentsX(), d->contentsY(), visibleWidth(), visibleHeight() );
 qDebug("CardView::setItemWidth has to be verified");  
   updateContents( contentsX(), contentsY(), visibleWidth(), visibleHeight() );
 #endif //KAB_EMBEDDED  
 }
 
 void CardView::setHeaderFont( const QFont &fnt )
 {
   d->mHeaderFont = fnt;
   delete d->mBFm;
   d->mBFm = new QFontMetrics( fnt );
 }
 
 QFont CardView::headerFont() const
 {
   return d->mHeaderFont;
 }
 
 void CardView::setFont( const QFont &fnt )
 {
   QScrollView::setFont( fnt );
   delete d->mFm;
   d->mFm = new QFontMetrics( fnt );
 }
 
 int CardView::separatorWidth()
 {
   return d->mSepWidth;
 }
 
 void CardView::setSeparatorWidth( int width )
 {
   d->mSepWidth = width;
   setLayoutDirty( true ); // hmm, actually I could just adjust the x'es...
 }
 
 int CardView::maxFieldLines() const
 {
   return d->mMaxFieldLines;
 }
 
 void CardView::setMaxFieldLines( int howmany )
 {
   d->mMaxFieldLines = howmany ? howmany : INT_MAX;
   // FIXME update, forcing the items to recalc height!!
 }
 
 void CardView::keyReleaseEvent ( QKeyEvent * e )
 {
     if ( mFlagBlockKeyPressed )
         return;
    if ( !e->isAutoRepeat() ) {
         mFlagBlockKeyPressed = true;
         qApp->processEvents();
         mFlagBlockKeyPressed = false;
         mFlagKeyPressed = false;
    }
    QScrollView::keyReleaseEvent ( e );
 }
 
 
 
 
 
 //END Cardview
 
 #ifndef KAB_EMBEDDED
 #include "cardview.moc"
 #endif //KAB_EMBEDDED