3 files changed, 18 insertions, 10 deletions

diff --git a/pwmanager/pwmanager/pwm.cpp b/pwmanager/pwmanager/pwm.cpp
index 9798e8e..b7b5307 100644
--- a/pwmanager/pwmanager/pwm.cpp
+++ b/pwmanager/pwmanager/pwm.cpp
@@ -1,122 +1,124 @@
 /***************************************************************************
  *                                                                         *
  *   copyright (C) 2003, 2004 by Michael Buesch                            *
  *   email: mbuesch@freenet.de                                             *
  *                                                                         *
  *   This program is free software; you can redistribute it and/or modify  *
  *   it under the terms of the GNU General Public License version 2        *
  *   as published by the Free Software Foundation.                         *
  *                                                                         *
  ***************************************************************************/
 
 /***************************************************************************
  * copyright (C) 2004 by Ulf Schenk
  * This file is originaly based on version 1.0.1 of pwmanager
  * and was modified to run on embedded devices that run microkde
  *
  * $Id$
  **************************************************************************/  
 
 #include <klocale.h>
 #include <klistview.h>
 #include <ktoolbar.h>
 #include <kfiledialog.h>
 #include <kiconloader.h>
 #include <kmessagebox.h>
 
+#include <qstatusbar.h>
+
 #ifndef PWM_EMBEDDED
 #include <kmenubar.h>
 #include <kstatusbar.h>
 #include <dcopclient.h>
 #include "configwndimpl.h"
 #include "configuration.h"
 #else
 #include <qmenubar.h>
 #include <qmessagebox.h>
 #include <pwmprefs.h>
 #include <kpimglobalprefs.h>
 #include <kcmconfigs/kcmpwmconfig.h>
 #include <kcmconfigs/kcmkdepimconfig.h>
 #include <kcmultidialog.h>
 #endif
 
 
 #ifndef DESKTOP_VERSION
 #include <qpe/global.h>
 #endif
 
 #include <qpixmap.h>
 #include <qcheckbox.h>
 #include <qspinbox.h>
 #include <qlineedit.h>
 #include <qfileinfo.h>
 #include <qclipboard.h>
 
 
 #include <stdio.h>
 
 #include "pwm.h"
 #include "pwminit.h"
 #include "pwmprint.h"
 #include "addentrywndimpl.h"
 #include "globalstuff.h"
 #include "findwndimpl.h"
 #include "csv.h"
 
 #ifdef CONFIG_KWALLETIF
 # include "kwalletif.h"
 # include "kwalletemu.h"
 #endif
 #ifdef CONFIG_KEYCARD
 # include "pwmkeycard.h"
 #endif
 
 
         #define DEFAULT_SIZE    (QSize(700, 400))
 
 // Button IDs for "file" popup menu
 enum {
         BUTTON_POPUP_FILE_NEW = 0,
         BUTTON_POPUP_FILE_OPEN,
         BUTTON_POPUP_FILE_CLOSE,
         BUTTON_POPUP_FILE_SAVE,
         BUTTON_POPUP_FILE_SAVEAS,
         BUTTON_POPUP_FILE_EXPORT,
         BUTTON_POPUP_FILE_IMPORT,
         BUTTON_POPUP_FILE_PRINT,
         BUTTON_POPUP_FILE_QUIT
 };
 // Button IDs for "manage" popup menu
 enum {
         BUTTON_POPUP_MANAGE_ADD = 0,
         BUTTON_POPUP_MANAGE_EDIT,
         BUTTON_POPUP_MANAGE_DEL,
         BUTTON_POPUP_MANAGE_CHANGEMP
 };
 // Button IDs for chipcard popup menu
 enum {
 #ifdef CONFIG_KEYCARD
         BUTTON_POPUP_CHIPCARD_GENNEW = 0,
         BUTTON_POPUP_CHIPCARD_DEL,
         BUTTON_POPUP_CHIPCARD_READID,
         BUTTON_POPUP_CHIPCARD_SAVEBACKUP,
         BUTTON_POPUP_CHIPCARD_REPLAYBACKUP
 #else // CONFIG_KEYCARD
         BUTTON_POPUP_CHIPCARD_NO = 0
 #endif // CONFIG_KEYCARD
 };
 // Button IDs for "view" popup menu
 enum {
         BUTTON_POPUP_VIEW_FIND = 0,
         BUTTON_POPUP_VIEW_LOCK,
         BUTTON_POPUP_VIEW_DEEPLOCK,
         BUTTON_POPUP_VIEW_UNLOCK
 };
 // Button IDs for "options" popup menu
 enum {
         BUTTON_POPUP_OPTIONS_CONFIG = 0
 };
 // Button IDs for "export" popup menu (in "file" popup menu)
 enum {
         BUTTON_POPUP_EXPORT_TEXT = 0,
         BUTTON_POPUP_EXPORT_GPASMAN,
@@ -1265,199 +1267,197 @@ exit_fail:
         return false;
 }
 
 void PwM::print_slot()
 {
         curDoc()->timer()->getLock(DocTimer::id_autoLockTimer);
 #ifndef PWM_EMBEDDED
         PwMPrint p(curDoc(), this);
         p.printNow();
 #else
         qDebug("PwM::print_slot , PRINTING IS NOT IMPLEMENTED");
 #endif
         curDoc()->timer()->putLock(DocTimer::id_autoLockTimer);
 }
 
 void PwM::genNewCard_slot()
 {
 #ifdef CONFIG_KEYCARD
         init->keycard()->genNewCard();
 #endif
 }
 
 void PwM::eraseCard_slot()
 {
 #ifdef CONFIG_KEYCARD
         init->keycard()->eraseCard();
 #endif
 }
 
 void PwM::readCardId_slot()
 {
 #ifdef CONFIG_KEYCARD
         init->keycard()->displayKey();
 #endif
 }
 
 void PwM::makeCardBackup_slot()
 {
 #ifdef CONFIG_KEYCARD
         init->keycard()->makeBackupImage();
 #endif
 }
 
 void PwM::replayCardBackup_slot()
 {
 #ifdef CONFIG_KEYCARD
         init->keycard()->replayBackupImage();
 #endif
 }
 
 void PwM::execLauncher_slot()
 {
         PWM_ASSERT(curDoc());
         if (curDoc()->isDeepLocked())
                 return;
         unsigned int curEntryIndex;
         if (!view->getCurEntryIndex(&curEntryIndex))
                 return;
         bool ret = curDoc()->execLauncher(view->getCurrentCategory(),
                                           curEntryIndex);
         if (ret)
                 showStatMsg(i18n("Executed the \"Launcher\"."));
         else
                 showStatMsg(i18n("ERROR: Couldn't execute the \"Launcher\"!"));
 }
 
 void PwM::goToURL_slot()
 {
         PWM_ASSERT(curDoc());
         if (curDoc()->isDeepLocked())
                 return;
         unsigned int curEntryIndex;
         if (!view->getCurEntryIndex(&curEntryIndex))
                 return;
         bool ret = curDoc()->goToURL(view->getCurrentCategory(),
                                      curEntryIndex);
         if (ret)
                 showStatMsg(i18n("started browser with current URL."));
         else
                 showStatMsg(i18n("ERROR: Couldn't start browser! Maybe invalid URL?"));
 }
 
 void PwM::copyToClipboard(const QString &s)
 {
         QClipboard *cb = QApplication::clipboard();
 #ifndef PWM_EMBEDDED
         if (cb->supportsSelection())
                 cb->setText(s, QClipboard::Selection);
         cb->setText(s, QClipboard::Clipboard);
 #else
         cb->setText(s);
 
 #endif
 
 }
 
+
 void PwM::showStatMsg(const QString &msg)
 {
-#ifndef PWM_EMBEDDED
-        KStatusBar *statBar = statusBar();
-        statBar->message(msg, STATUSBAR_MSG_TIMEOUT * 1000);
+#ifdef DESKTOP_VERSION
+        statusBar()->message(msg, STATUSBAR_MSG_TIMEOUT * 1000);
 #else
         qDebug("Statusbar : %s",msg.latin1());
-#ifndef DESKTOP_VERSION
     Global::statusMessage(msg);
 #endif
-#endif
 }
 
 void PwM::focusInEvent(QFocusEvent *e)
 {
         if (e->gotFocus()) {
                 emit gotFocus(this);
         } else if (e->lostFocus()) {
                 emit lostFocus(this);
         }
 }
 
 
 #ifdef PWM_EMBEDDED
 
 void PwM::whatsnew_slot()
 {
     KApplication::showFile( "KDE-Pim/Pi Version Info", "kdepim/WhatsNew.txt" );
 }
 
 void PwM::showLicense_slot()
 {
     KApplication::showLicence();
 }
 
 void PwM::faq_slot()
 {
   KApplication::showFile( "PWM/Pi FAQ", "kdepim/pwmanager/pwmanagerFAQ.txt" );
 }
 
 void PwM::syncHowTo_slot()
 {
     KApplication::showFile( "KDE-Pim/Pi Synchronization HowTo", "kdepim/SyncHowto.txt" );
 }
 
 
 void PwM::createAboutData_slot()
 {
   QString version;
 #include <../version>
     QMessageBox::about( this, "About PwManager/Pi",
                         "PwManager/Platform-independent\n"
                         "(PWM/Pi) " +version + " - " +
 #ifdef DESKTOP_VERSION
                         "Desktop Edition\n"
 #else
                         "PDA-Edition\n"
                         "for: Zaurus 5500 / 7x0 / 8x0\n"
 #endif
 
                         "(c) 2004 Ulf Schenk\n"
                         "(c) 2004 Lutz Rogowski\n"
                         "(c) 1997-2004, The KDE PIM Team\n"
 
         "(c) Michael Buesch - main programming\nand current maintainer\nmbuesch@freenet.de\n"
         "Matt Scifo - mscifo@o1.com\n"
         "Elias Probst - elias.probst@gmx.de\n"
         "George Staikos - staikos@kde.org\n"
         "Matthew Palmer - mjp16@uow.edu.au\n"
         "Olivier Sessink - gpasman@nl.linux.org\n"
         "The libgcrypt developers -\nBlowfish and SHA1 algorithms\nftp://ftp.gnupg.org/gcrypt/alpha/libgcrypt/\n"
         "Troy Engel - tengel@sonic.net\n"
         "Wickey - wickey@gmx.at\n"
         "Ian MacGregor - original documentation author.\n"
  );
 }
 
 
 //this are the overwritten callbackmethods from the syncinterface
 bool PwM::sync(KSyncManager* manager, QString filename, int mode)
 {
   PWM_ASSERT(curDoc());
 
   bool ret =  curDoc()->sync(manager, filename, mode);
 
   qDebug("PwM::sync save now: ret=%i", ret);
  
   if (ret == true) {
     //US BUG: what can we call here to update the view of the current doc?
     //mViewManager->refreshView();
 
     //US curDoc()->sync sets the dirtyFlag in case the sync was successfull.
     save();
   }
 
   return ret;
 }
 #endif
 
 
 #ifndef PWM_EMBEDDED
 #include "pwm.moc"
 #endif
diff --git a/pwmanager/pwmanager/pwmdocui.cpp b/pwmanager/pwmanager/pwmdocui.cpp
index 6ddb6f5..71b4a8d 100644
--- a/pwmanager/pwmanager/pwmdocui.cpp
+++ b/pwmanager/pwmanager/pwmdocui.cpp
@@ -286,182 +286,182 @@ bool PwMDocUi::saveDocUi(PwMDoc *doc)
                                    i18n("error while writing"));
                 doc->timer()->putLock(DocTimer::id_autoLockTimer);
                 return false;
         }
         doc->timer()->putLock(DocTimer::id_autoLockTimer);
         return true;
 }
 
 bool PwMDocUi::saveAsDocUi(PwMDoc *doc)
 {
         PWM_ASSERT(doc);
         doc->timer()->getLock(DocTimer::id_autoLockTimer);
         if (doc->isDocEmpty()) {
                 KMessageBox::information(currentView,
                                          i18n
                                          ("Sorry, there's nothing to save.\n"
                                           "Please first add some passwords."),
                                          i18n("nothing to do"));
                 doc->timer()->putLock(DocTimer::id_autoLockTimer);
                 return true;
         }
 #ifndef PWM_EMBEDDED
         QString fn(KFileDialog::getSaveFileName(QString::null,
                                                 i18n("*.pwm|PwManager Password file"),
                                                 currentView));
 #else
         QString fn = locateLocal( "data", KGlobal::getAppName() + "/*.pwm" );
         fn = KFileDialog::getSaveFileName(fn,
                                                 i18n("password filename(*.pwm)"),
                                                 currentView);
 
 #endif
         if (fn == "") {
                 doc->timer()->putLock(DocTimer::id_autoLockTimer);
                 return false;
         }
         if (fn.right(4) != ".pwm")
                 fn += ".pwm";
 
         PwMerror ret = doc->saveDoc(conf()->confGlobCompression(), &fn);
         if (ret == e_noPw ||
             ret == e_wrongPw ||
             ret == e_openFile) {
           doc->timer()->putLock(DocTimer::id_autoLockTimer);
           return false;
         } else if (ret != e_success) {
                 KMessageBox::error(currentView,
                                    i18n("Error: Couldn't write to file.\n"
                                         "Please check if you have permission to\n"
                                         "write to the file in that directory."),
                                    i18n("error while writing"));
                 doc->timer()->putLock(DocTimer::id_autoLockTimer);
                 return false;
         }
         doc->timer()->putLock(DocTimer::id_autoLockTimer);
         return true;
 }
 
 bool PwMDocUi::openDocUi(PwMDoc *doc,
                          QString filename,
                          bool openDeepLocked)
 {
         if (filename.isEmpty())
           {
 #ifndef PWM_EMBEDDED
                 filename = KFileDialog::getOpenFileName(QString::null,
                                                         i18n("*.pwm|PwManager Password file\n"
                                                              "*|All files"), getCurrentView());
 #else
                 filename = locateLocal( "data", KGlobal::getAppName() + "/*.pwm");
                 filename = KFileDialog::getOpenFileName(filename,
                                                         i18n("password filename(*.pwm)"), getCurrentView());
 #endif
           }
         if (filename.isEmpty())
                 goto cancelOpen;
         PwMerror ret;
         while (true) {
                 int lockStat = -1;
                 if (openDeepLocked) {
                         lockStat = 2;
                 } else {
                         if (conf()->confGlobUnlockOnOpen()) {
                                 lockStat = 0;
                         } else {
                                 lockStat = 1;
                         }
                 }
                 ret = doc->openDoc(&filename, lockStat);
                         //qDebug("pwmdocui::OpenDocui %i", ret);        
                 if (ret != e_success) {
                         if (ret == e_readFile || ret == e_openFile) {
                                 KMessageBox::error(getCurrentView(),
                                                    i18n("Could not read file!")
                                                    + "\n"
                                                    + filename,
-                                                   i18n("file error"));
+                                                   i18n("File error"));
                                 goto cancelOpen;
                         }
                         if (ret == e_alreadyOpen) {
                                 KMessageBox::error(getCurrentView(),
                                                    i18n("This file is already open."),
-                                                   i18n("already open"));
+                                                   i18n("Already open"));
                                 goto cancelOpen;
                         }
                         if (ret == e_fileVer) {
                                 KMessageBox::error(getCurrentView(),
                                                    i18n
                                                    ("File-version is not supported!\n"
                                                     "Did you create this file with an\nolder or newer version of PwM?"),
                                                    i18n
-                                                   ("incompatible version"));
+                                                   ("Incompatible version"));
                                 goto cancelOpen;
                         }
                         if (ret == e_wrongPw) {
                                 continue;
                         }
                         if (ret == e_noPw) {
                                 goto cancelOpen;
                         }
                         if (ret == e_fileFormat) {
                                 KMessageBox::error(getCurrentView(),
                                                    i18n
                                                    ("Sorry, this file has not been recognized\n"
                                                     "as a PwM Password file.\n"
                                                     "Probably you have selected the wrong file."),
                                                    i18n
-                                                   ("no PwM password-file"));
+                                                   ("No PwM password-file"));
                                 goto cancelOpen;
                         }
                         if (ret == e_fileCorrupt) {
                                 KMessageBox::error(getCurrentView(),
                                                    i18n
                                                    ("File corrupt!\n"
                                                     "Maybe the media, you stored this file on,\n"
                                                     "had bad sectors?"),
                                                    i18n
-                                                   ("checksum error"));
+                                                   ("Checksum error"));
                                 goto cancelOpen;
                         }
                 }
                 break;
         }
         return true;
 
       cancelOpen:
         return false;
 }
 
 QString PwMDocUi::string_defaultCategory()
 {
         return i18n("Default");
 }
 
 QString PwMDocUi::string_locked()
 {
         return i18n("<LOCKED>");
 }
 
 QString PwMDocUi::string_deepLockedShort()
 {
         return i18n("DEEP-LOCKED");
 }
 
 QString PwMDocUi::string_deepLockedLong()
 {
         return i18n("This file is DEEP-LOCKED!\n"
                     "That means all data has been encrypted\n"
                     "and written out to the file. If you want\n"
                     "to see the entries, please UNLOCK the file.\n"
                     "While unlocking, you will be prompted for the\n"
                     "master-password or the key-card.");
 }
 
 QString PwMDocUi::string_defaultTitle()
 {
         return i18n("Untitled");
 }
 
 #ifndef PWM_EMBEDDED
 #include "pwmdocui.moc"
 #endif
diff --git a/pwmanager/pwmanager/serializer.cpp b/pwmanager/pwmanager/serializer.cpp
index ed0f754..5753c1d 100644
--- a/pwmanager/pwmanager/serializer.cpp
+++ b/pwmanager/pwmanager/serializer.cpp
@@ -72,383 +72,386 @@
         #define COMPAT_VER_NEW  "2"
         #define CAT_ROOT_NEW    "c"
         #define CAT_PREFIX_NEW  "c"
         #define CAT_NAME_NEW    "n"
         #define ENTRY_PREFIX_NEW"e"
         #define ENTRY_DESC_NEW  "d"
         #define ENTRY_NAME_NEW  "n"
         #define ENTRY_PW_NEW    "p"
         #define ENTRY_COMMENT_NEW"c"
         #define ENTRY_URL_NEW   "u"
         #define ENTRY_LAUNCHER_NEW"l"
         #define ENTRY_LVP_NEW   "v"
         #define ENTRY_BIN_NEW   ENTRY_BIN_OLD
         #define ENTRY_META_NEW  ENTRY_META_OLD
 
 #if USE_OLD_TAGS != 0
         # define ROOT_MAGIC_WR  ROOT_MAGIC_OLD
         # define VER_STR_WR     VER_STR_OLD
         # define COMPAT_VER_WR  COMPAT_VER_OLD
         # define CAT_ROOT_WR    CAT_ROOT_OLD
         # define CAT_PREFIX_WR  CAT_PREFIX_OLD
         # define CAT_NAME_WR    CAT_NAME_OLD
         # define ENTRY_PREFIX_WRENTRY_PREFIX_OLD
         # define ENTRY_DESC_WR  ENTRY_DESC_OLD
         # define ENTRY_NAME_WR  ENTRY_NAME_OLD
         # define ENTRY_PW_WR    ENTRY_PW_OLD
         # define ENTRY_COMMENT_WRENTRY_COMMENT_OLD
         # define ENTRY_URL_WR   ENTRY_URL_OLD
         # define ENTRY_LAUNCHER_WRENTRY_LAUNCHER_OLD
         # define ENTRY_LVP_WR   ENTRY_LVP_OLD
         # define ENTRY_BIN_WR   ENTRY_BIN_OLD
         # define ENTRY_META_WR  ENTRY_META_OLD
 #else
         # define ROOT_MAGIC_WR  ROOT_MAGIC_NEW
         # define VER_STR_WR     VER_STR_NEW
         # define COMPAT_VER_WR  COMPAT_VER_NEW
         # define CAT_ROOT_WR    CAT_ROOT_NEW
         # define CAT_PREFIX_WR  CAT_PREFIX_NEW
         # define CAT_NAME_WR    CAT_NAME_NEW
         # define ENTRY_PREFIX_WRENTRY_PREFIX_NEW
         # define ENTRY_DESC_WR  ENTRY_DESC_NEW
         # define ENTRY_NAME_WR  ENTRY_NAME_NEW
         # define ENTRY_PW_WR    ENTRY_PW_NEW
         # define ENTRY_COMMENT_WRENTRY_COMMENT_NEW
         # define ENTRY_URL_WR   ENTRY_URL_NEW
         # define ENTRY_LAUNCHER_WRENTRY_LAUNCHER_NEW
         # define ENTRY_LVP_WR   ENTRY_LVP_NEW
         # define ENTRY_BIN_WR   ENTRY_BIN_NEW
         # define ENTRY_META_WR  ENTRY_META_NEW
 #endif
 
 
 Serializer::Serializer()
 {
         defaultLockStat = true;
 //US BUG: I needed to specify a document name. Otherwise impl will not be created for serializing
 #ifndef PWM_EMBEDDED
         domDoc = new QDomDocument;
 #else
         domDoc = new QDomDocument("mydoc");
 #endif
 }
 
 Serializer::Serializer(const QCString &buffer)
 {
         defaultLockStat = true;
 //US BUG: I needed to specify a document name. Otherwise impl will not be created for serializing
 #ifndef PWM_EMBEDDED
         domDoc = new QDomDocument;
 #else
         domDoc = new QDomDocument("mydoc");
 #endif
 
         if (!parseXml(buffer)) {
                 delete domDoc;
 #ifndef PWM_EMBEDDED
                 throw PwMException(PwMException::EX_PARSE);
 #else
                 qDebug("Serializer::Serializer : Parse Exception ");
 #endif
         }
 }
 
 Serializer::~Serializer()
 {
         delete_ifnot_null(domDoc);
 }
 
 void Serializer::clear()
 {
         delete_ifnot_null(domDoc);
         domDoc = new QDomDocument;
 }
 
 bool Serializer::parseXml(const QCString &buffer)
 {
+    //abort();
+    //qDebug("parse %s ", buffer.data());
         PWM_ASSERT(domDoc);
 #ifndef PWM_EMBEDDED
         if (!domDoc->setContent(buffer, true))
                 return false;
 #else
 #ifdef DESKTOP_VERSION
         if (!domDoc->setContent(buffer, true))
 #else
         if (!domDoc->setContent(buffer))
 #endif
                 return false;
 #endif
         if (!checkValid())
                 return false;
         return true;
 }
 
 QCString Serializer::getXml()
 {
         PWM_ASSERT(domDoc);
 
 #ifndef PWM_EMBEDDED
 #if defined(PWM_DEBUG) && SERIALIZER_DEBUG != 0
         QCString tmp(domDoc->toCString(8));
         printDebug("<BEGIN Serializer::getXml() dump>\n");
         cout << tmp << endl;
         printDebug("<END Serializer::getXml() dump>");
 #endif // DEBUG
 
         QCString ret(domDoc->toCString(0));
         ret.replace('\n', "");
         return ret;
 #else
 
 #if defined(PWM_DEBUG) && SERIALIZER_DEBUG != 0
         QCString tmp("        " + domDoc->toCString());
         printDebug("<BEGIN Serializer::getXml() dump>\n");
         qDebug(tmp);
         cout << tmp << endl;
         printDebug("<END Serializer::getXml() dump>");
 #endif // DEBUG
 
         QCString ret(domDoc->toCString());
         ret.replace(QRegExp("\n"), "");
         return ret;
 
 #endif
 }
 
 bool Serializer::serialize(PwMItem &dta)
 {
         PWM_ASSERT(domDoc);
         QDomElement root(genNewRoot());
         QDomElement catNode(domDoc->createElement(CAT_ROOT_WR));
         QDomElement syncNode(domDoc->createElement(SYNC_ROOT));
         if (!addSyncData(&syncNode, dta.syncDta))
                 return false;
         root.appendChild(syncNode);
         if (!addCategories(&catNode, dta.dta))
                 return false;
         root.appendChild(catNode);
         return true;
 }
 
 bool Serializer::deSerialize(PwMItem *dta)
 {
         PWM_ASSERT(domDoc);
         PWM_ASSERT(dta);
         QDomElement root(domDoc->documentElement());
         QDomNode n;
 
         dta->clear();
         for (n = root.firstChild(); !n.isNull(); n = n.nextSibling()) {
                 // find <categories> ... </categories>
                 //      <c>          ... </c>
                 if (n.nodeName() == CAT_ROOT_NEW ||
                     n.nodeName() == CAT_ROOT_OLD) {
                         if (!readCategories(n, &(dta->dta))) {
                                 return false;
                         }
                         continue;
                 }
                 else if (n.nodeName() == SYNC_ROOT) {
                         if (!readSyncData(n, &(dta->syncDta))) {
                                 return false;
                         }
                         continue;
                 }
 
                         /* NOTE: We can stop processing here, as we
                          *       don't have more nodes in root, yet.
                          */
                         return false;
 
         }
         return true;
 }
 
 bool Serializer::readCategories(const QDomNode &n,
                                 vector<PwMCategoryItem> *dta)
 {
         QDomNodeList nl(n.childNodes());
         QDomNode cur;
         QString name;
         unsigned int numCat = nl.count(), i;
         PwMCategoryItem curCat;
         vector<PwMDataItem> curEntr;
 
         if (!numCat) {
                 printDebug("Serializer::readCategories(): empty");
                 return false;
         }
         for (i = 0; i < numCat; ++i) {
                 cur = nl.item(i);
                 if (cur.nodeName().left(1) == CAT_PREFIX_NEW ||
                     cur.nodeName().left(4) == CAT_PREFIX_OLD) {
                         name = cur.toElement().attribute(CAT_NAME_NEW);
                         if (name == QString::null)
                                 name = cur.toElement().attribute(CAT_NAME_OLD);
                         PWM_ASSERT(name != QString::null);
                         PWM_ASSERT(name != "");
                         curCat.clear();
                         curCat.name = name.latin1();
                         if (!readEntries(cur, &curEntr)) {
                                 dta->clear();
                                 return false;
                         }
                         curCat.d = curEntr;
                         dta->push_back(curCat);
                 } else {
                         printDebug("Serializer::readCategories(): uh? not a category?");
                 }
         }
         return true;
 }
 
 bool Serializer::readEntries(const QDomNode &n,
                              vector<PwMDataItem> *dta)
 {
         QDomNodeList nl(n.childNodes());
         QDomNode cur;
         unsigned int numEntr = nl.count(), i;
         PwMDataItem curEntr;
         //US BUG: to initialize all values of curEntr with meaningfulldata,
         // we call clear on it. Reason: Information in the file we will read might be incomplete.
         // e.g. the metadata is missing.
         curEntr.clear(true);
 
         dta->clear();
         for (i = 0; i < numEntr; ++i) {
                 cur = nl.item(i);
                 if (cur.nodeName().left(1) == ENTRY_PREFIX_NEW ||
                     cur.nodeName().left(6) == ENTRY_PREFIX_OLD) {
                         if (!extractEntry(cur, &curEntr)) {
                                 return false;
                         }
                         dta->push_back(curEntr);
                 } else {
                         printDebug("Serializer::readEntries(): hm? not an entry?");
                 }
         }
         return true;
 }
 
 bool Serializer::extractEntry(const QDomNode &n,
                               PwMDataItem *dta)
 {
         QDomNodeList nl(n.childNodes());
         QDomNode cur, cdata;
         unsigned int cnt = nl.count(), i;
         QString name, text;
 
         if (!cnt) {
                 printDebug("Serializer::extractEntry(): empty");
                 return false;
         }
         dta->clear();
         for (i = 0; i < cnt; ++i) {
                 cur = nl.item(i);
                 name = cur.nodeName();
                 cdata = cur.firstChild();
                 if (unlikely(cdata.isCDATASection())) {
                         text = cdata.toCDATASection().data();
                 } else if (likely(cur.isElement())) {
                         text = cur.toElement().text();
                 } else {
                         printDebug("Serializer::extractEntry(): neither CDATA nor element.");
                         return false;
                 }
                 if (text == " ")
                         text = ""; // for backward compatibility.
+        //qDebug("entry %s ",unescapeEntryData(text).latin1());
                 if (name == ENTRY_DESC_NEW ||
                     name == ENTRY_DESC_OLD) {
                         dta->desc = unescapeEntryData(text).latin1();
                 } else if (name == ENTRY_NAME_NEW ||
                            name == ENTRY_NAME_OLD) {
                         dta->name = unescapeEntryData(text).latin1();
                 } else if (name == ENTRY_PW_NEW ||
                            name == ENTRY_PW_OLD) {
                         dta->pw = unescapeEntryData(text).latin1();
                 } else if (name == ENTRY_COMMENT_NEW ||
                            name == ENTRY_COMMENT_OLD) {
                         dta->comment = unescapeEntryData(text).latin1();
                 } else if (name == ENTRY_URL_NEW ||
                            name == ENTRY_URL_OLD) {
                         dta->url = unescapeEntryData(text).latin1();
                 } else if (name == ENTRY_LAUNCHER_NEW ||
                            name == ENTRY_LAUNCHER_OLD) {
                         dta->launcher = unescapeEntryData(text).latin1();
                 } else if (name == ENTRY_LVP_NEW ||
                            name == ENTRY_LVP_OLD) {
                         dta->listViewPos = strtol(text.latin1(), 0, 10);
                 } else if (name == ENTRY_BIN_NEW) {
                         // ENTRY_BIN_NEW == ENTRY_BIN_OLD
                         if (text == "0") {
                                 dta->binary = false;
                         } else {
                                 dta->binary = true;
                         }
                 } else if (name == ENTRY_META_NEW) {
                         // ENTRY_META_NEW == ENTRY_META_OLD
                         if (!extractMeta(cur, &dta->meta))
                                 return false;
                 } else {
                         printDebug(string("Serializer::extractEntry(): invalid: ")
                                    + name.latin1());
                 }
         }
         dta->lockStat = defaultLockStat;
         return true;
 }
 
 bool Serializer::extractMeta(const QDomNode &n,
                              PwMMetaData *dta)
 {
         QDomNode cur(n.firstChild());
         QString name, val;
         while (!cur.isNull()) {
                 name = cur.nodeName();
                 val = cur.toElement().text();
                 if (val == "") {
                         cur = cur.nextSibling();
                         continue;
                 }
 
                 //US BUG: The transformation of an empty date into an ISO date and back is different on different systems/compilers. 
                 //because of that it is possible that here some values are not set, which means they are null.
                 //US ENH: at the same moment we need backwardcompatibility. So older versions might have stored invalid dates.
 
                 QDateTime dtval; //dtval should be invalid by definition.
 
                 if ((name == META_CREATE_DATE) ||
                     (name == META_VALID_DATE) ||
                     (name == META_EXPIRE_DATE) ||
                     (name == META_UPDATE_DATE))
                 {
                   //qDebug("Serializer::extractMeta:: val:%s, empty:%i, length:%i",val.utf8(), val.isEmpty(), val.length());
 
 #ifndef PWM_EMBEDDED
                   dtval = QDateTime::fromString(val, Qt::ISODate);
 #else
                   bool ok;
                   dtval = KGlobal::locale()->readDateTime(val, KLocale::ISODate, &ok);
                     
                   if (ok == false)
                     qDebug("Serializer::extractMeta invalid date or time !!!!!!!!!!!!!");
 #endif
 
                   //if the parsed data is wrong, dtval should be invalid at this time.
 
                 }
 
                 if (name == META_CREATE_DATE) {
                         dta->create = dtval;
                 } else if (name == META_VALID_DATE) {
                         dta->valid = dtval;
                 } else if (name == META_EXPIRE_DATE) {
                         dta->expire = dtval;
                 } else if (name == META_UPDATE_DATE) {
                         dta->update = dtval;
                 } else if (name == META_UPDATE_INT) {
                         dta->updateInt = strtoul(val.latin1(), 0, 10);
                 } else if (name == META_UNIQUEID) {
                         dta->uniqueid = unescapeEntryData(val).latin1();
                 } else {
                         printDebug(string("extractMeta(): invalid: ")
                                    + name.latin1());
@@ -608,177 +611,182 @@ bool Serializer::writeEntry(QDomElement *e,
 }
 
 bool Serializer::writeMeta(QDomElement *e,
                            const PwMMetaData &dta)
 {
         QDomText text;
         QDomElement tag;
 
         //US BUG!!!: The transformation of an empty date into an ISO date is different on different systems/compilers.
         //So do not transform an empty value at all.
         if (dta.create.isValid())
         {
           tag = domDoc->createElement(META_CREATE_DATE);
 #ifndef PWM_EMBEDDED
           text = domDoc->createTextNode(dta.create.toString(Qt::ISODate));
 #else
           text = domDoc->createTextNode(KGlobal::locale()->formatDateTime(dta.create,  KLocale::ISODate));
 #endif
           tag.appendChild(text);
           e->appendChild(tag);
         }
 
         //US BUG!!!: The transformation of an empty date into an ISO date is different on different systems/compilers. 
         //So do not transform an empty value at all.
         if (dta.valid.isValid())
         {
           tag = domDoc->createElement(META_VALID_DATE);
 #ifndef PWM_EMBEDDED
           text = domDoc->createTextNode(dta.valid.toString(Qt::ISODate));
 #else
           text = domDoc->createTextNode(KGlobal::locale()->formatDateTime(dta.valid,  KLocale::ISODate));
 #endif
           tag.appendChild(text);
           e->appendChild(tag);
         }
 
         //US BUG!!!: The transformation of an empty date into an ISO date is different on different systems/compilers. 
         //So do not transform an empty value at all.
         if (dta.expire.isValid())
         {
           tag = domDoc->createElement(META_EXPIRE_DATE);
 #ifndef PWM_EMBEDDED
           text = domDoc->createTextNode(dta.expire.toString(Qt::ISODate));
 #else
           text = domDoc->createTextNode(KGlobal::locale()->formatDateTime(dta.expire,  KLocale::ISODate));
 #endif
           tag.appendChild(text);
           e->appendChild(tag);
         }
 
         //US BUG!!!: The transformation of an empty date into an ISO date is different on different systems/compilers. 
         //So do not transform an empty value at all.
         if (dta.update.isValid())
         {
           tag = domDoc->createElement(META_UPDATE_DATE);
 #ifndef PWM_EMBEDDED
           text = domDoc->createTextNode(dta.update.toString(Qt::ISODate));
 #else
           text = domDoc->createTextNode(KGlobal::locale()->formatDateTime(dta.update,  KLocale::ISODate));
 #endif
           tag.appendChild(text);
           e->appendChild(tag);
         }
 
         tag = domDoc->createElement(META_UPDATE_INT);
         text = domDoc->createTextNode(tostr(dta.updateInt).c_str());
         tag.appendChild(text);
         e->appendChild(tag);
 
         tag = domDoc->createElement(META_UNIQUEID);
         text = domDoc->createTextNode(escapeEntryData(dta.uniqueid.c_str()));
         tag.appendChild(text);
         e->appendChild(tag);
 
 #undef new_text
         return true;
 }
 
 QString Serializer::escapeEntryData(QString dta)
 {
 #ifndef PWM_EMBEDDED
         dta.replace('\n', "$>--endl--<$");
         dta.replace("]]>", "||>");
 #else
         dta.replace(QRegExp("\n"), "$>--endl--<$");
         dta.replace(QRegExp("]]>"), "||>");
 #endif
         return dta;
 }
 
 QString Serializer::unescapeEntryData(QString dta)
 {
 #ifndef PWM_EMBEDDED
         dta.replace("$>--endl--<$", "\n");
         dta.replace("||>", "]]>");
 #else
+#ifdef DESKTOP_VERSION
+        dta.replace("$>--endl--<$", "\n");
+        dta.replace("||>", "]]>");
+#else
         dta.replace(QRegExp("\\$>--endl--<\\$"), "\n");
         dta.replace(QRegExp("||>"), "]]>");
 #endif
+#endif
         return dta;
 }
 
 
 //US ENH: the following methods are getting used to write/read sync entries
 /** read the syncentries in the node "n" */
 bool Serializer::readSyncData(const QDomNode &n, vector<PwMSyncItem> *dta)
 {
         QDomNodeList nl(n.childNodes());
         QDomNode cur;
         
         QString devicename, val;
         unsigned int numSync  = nl.count(), i;
         PwMSyncItem curSync;
         bool ok = true;
 
         if (!numSync) {
           //no sync entries is a possible result 
                 printDebug("Serializer::readSyncData(): empty");
                 return true;
         }
         for (i = 0; i < numSync; ++i) {
                 cur = nl.item(i);
                 if (cur.nodeName().left(1) == SYNC_TARGET_PREFIX) {
                         devicename = cur.toElement().attribute(SYNC_TARGET_NAME);
                         val = cur.toElement().text();
 
                         if ((val == "") || (devicename == QString::null)) {
                           printDebug("Serializer::readSyncData(): empty synctarget name or syncdate");
                           continue;
                         }
 
                         curSync.syncName = devicename.latin1();
 #ifndef PWM_EMBEDDED
                         curSync.lastSyncDate = QDateTime::fromString(val, Qt::ISODate);
 #else
                         curSync.lastSyncDate = KGlobal::locale()->readDateTime(val, KLocale::ISODate, &ok);
                         if (ok == false)
                           qDebug("Serializer::readSyncData(): could not parse syncdate:%s",val.latin1());
 
 #endif
                         dta->push_back(curSync);
                 }
         }
         return true;
 
 }
 
 
 
 bool Serializer::addSyncData(QDomElement *e,
                                const vector<PwMSyncItem> &dta)
 {
         unsigned int numSync = dta.size(), i;
         QString curId, curDeviceName;
         QDomElement curSync;
         QDomText text;
 
         for (i = 0; i < numSync; ++i) {
                 curId = SYNC_TARGET_PREFIX;
                 curId += tostr(i).c_str();
                 curDeviceName = dta[i].syncName.c_str();
                 curSync = domDoc->createElement(curId);
                 curSync.setAttribute(SYNC_TARGET_NAME, curDeviceName);
 
 #ifndef PWM_EMBEDDED
                 text = domDoc->createTextNode(dta[i].lastSyncDate.toString(Qt::ISODate));
 #else
                 text = domDoc->createTextNode(KGlobal::locale()->formatDateTime(dta[i].lastSyncDate,  KLocale::ISODate));
 #endif
                 curSync.appendChild(text);
 
                 e->appendChild(curSync);
 
         }
         return true;
 }