fixed desktop descape bug. added statusbar to embedded and desktop

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,218 +1,220 @@
 /***************************************************************************
  *                                                                         *
  *   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,
         BUTTON_POPUP_EXPORT_CSV
 #ifdef CONFIG_KWALLETIF
         ,BUTTON_POPUP_EXPORT_KWALLET
 #endif
 };
 // Button IDs for "import" popup menu (in "file" popup menu)
 enum {
         BUTTON_POPUP_IMPORT_TEXT = 0,
         BUTTON_POPUP_IMPORT_GPASMAN,
         BUTTON_POPUP_IMPORT_CSV
 #ifdef CONFIG_KWALLETIF
         ,BUTTON_POPUP_IMPORT_KWALLET
 #endif
 };
 
 #ifdef PWM_EMBEDDED
 // Button IDs for "help" popup menu
 enum {
         BUTTON_POPUP_HELP_LICENSE = 0,
         BUTTON_POPUP_HELP_FAQ,
         BUTTON_POPUP_HELP_ABOUT,
         BUTTON_POPUP_HELP_SYNC,
         BUTTON_POPUP_HELP_WHATSNEW
 };
 #endif
 
 // Button IDs for toolbar
 enum {
         BUTTON_TOOL_NEW = 0,
         BUTTON_TOOL_OPEN,
         BUTTON_TOOL_SAVE,
         BUTTON_TOOL_SAVEAS,
         BUTTON_TOOL_PRINT,
         BUTTON_TOOL_ADD,
         BUTTON_TOOL_EDIT,
         BUTTON_TOOL_DEL,
         BUTTON_TOOL_FIND,
         BUTTON_TOOL_LOCK,
         BUTTON_TOOL_DEEPLOCK,
         BUTTON_TOOL_UNLOCK
 };
 
 
 PwM::PwM(PwMInit *_init, PwMDoc *doc,
          bool virginity,
          QWidget *parent, const char *name)
  : KMainWindow(parent, "HALLO")
  , forceQuit (false)
  , forceMinimizeToTray (false)
 {
     virgin = !virginity;
         init = _init;
         connect(doc, SIGNAL(docClosed(PwMDoc *)),
                 this, SLOT(docClosed(PwMDoc *)));
         initMenubar();
         initToolbar();
         initMetrics();
         setVirgin(virginity);
         setFocusPolicy(QWidget::WheelFocus);
 #ifndef PWM_EMBEDDED
         statusBar()->show();
 #endif
         view = makeNewListView(doc);
         setCentralWidget(view);
         updateCaption();
         showStatMsg(i18n("Ready."));
 }
 
 PwM::~PwM()
 {
   //qDebug("PwM::~PwM()");
         disconnect(curDoc(), SIGNAL(docClosed(PwMDoc *)),
                    this, SLOT(docClosed(PwMDoc *)));
         conf()->confWndMainWndSize(size());
         emit closed(this);
         //qDebug("PwM::~PwM() emited closed(this)");
         delete view;
 }
 
 void PwM::initMenubar()
 {
   KIconLoader* picons;
 #ifndef PWM_EMBEDDED
         KIconLoader icons;
         picons = &icons;
 #else
         picons = KGlobal::iconLoader();
 
 
         syncPopup = new KPopupMenu(this);
         
         syncManager = new KSyncManager((QWidget*)this, (KSyncInterface*)this, KSyncManager::PWMPI, PWMPrefs::instance(), syncPopup);
         syncManager->setBlockSave(false);
 
         connect ( syncPopup, SIGNAL( activated ( int )  ), syncManager, SLOT (slotSyncMenu( int ) ) );
         syncManager->fillSyncMenu();
@@ -1169,295 +1171,293 @@ bool PwM::importFromGpasman()
                                                 "correctness of the password in the Gpasman\n"
                                                 "file-format. But I think this\n"
                                                 "password ist wrong.\n"
                                                 "Do you want to continue nevertheless?"),
                                                i18n("password error"))
                     == KMessageBox::No) {
                         goto cancelImport;
                 }
         } else if (ret != e_success) {
                 KMessageBox::error(this,
                                    i18n("Could not import file!\n"
                                         "Do you have permission to read this file?"),
                                    i18n("import failed"));
                 goto cancelImport;
         }
         setVirgin(false);
         curDoc()->timer()->putLock(DocTimer::id_autoLockTimer);
         return true;
 
 cancelImport:
         curDoc()->timer()->putLock(DocTimer::id_autoLockTimer);
         return false;
 }
 
 #ifdef CONFIG_KWALLETIF
 bool PwM::checkAndAskForKWalletEmu()
 {
         if (init->kwalletEmu()) {
                 /* KWallet emulation is enabled. We can't import/export
                  * data from/to it, while emulation is active.
                  */
                 if (KMessageBox::questionYesNo(this,
                                                i18n("KWallet emulation is enabled.\n"
                                                     "You can't import or export data from/to "
                                                     "the original KWallet, while the emulation "
                                                     "is active.\n"
                                                     "Do you want to tempoarly disable the KWallet emulation?"),
                                                i18n("Tempoarly disable KWallet emulation?"))
                     == KMessageBox::Yes) {
                         init->initKWalletEmu(true);
                         PWM_ASSERT(!init->kwalletEmu());
                         return true;
                 }
                 return false;
         }
         return true;
 }
 #endif // CONFIG_KWALLETIF
 
 bool PwM::importKWallet()
 {
 #ifdef CONFIG_KWALLETIF
         if (!checkAndAskForKWalletEmu())
                 return false;
         KWalletIf walletIf(this);
         if (!isVirgin()) {
                 if (KMessageBox::questionYesNo(this,
                                                i18n("Do you want to import the data "
                                                     "into the current document? (If you "
                                                     "select \"no\", a new document will be "
                                                     "opened.)"),
                                                i18n("import into this document?"))
                     == KMessageBox::No) {
                         // import the data to a new window.
                         PwM *newInstance = init->createMainWnd();
                         bool ok = newInstance->importKWallet();
                         if (!ok) {
                                 newInstance->setForceQuit(true);
                                 delete_and_null(newInstance);
                                 goto exit_fail;
                         } else {
                                 goto exit_ok;
                         }
                 }
         }
         curDoc()->timer()->getLock(DocTimer::id_autoLockTimer);
         if (!walletIf.kwalletImport(curDoc())) {
                 curDoc()->timer()->putLock(DocTimer::id_autoLockTimer);
                 showStatMsg(i18n("KWallet import failed"));
                 goto exit_fail;
         }
         KMessageBox::information(this,
                                  i18n("Successfully imported the KWallet data "
                                       "into the current document."),
                                  i18n("successfully imported"));
         showStatMsg(i18n("successfully imported"));
         setVirgin(false);
         curDoc()->timer()->putLock(DocTimer::id_autoLockTimer);
 
 exit_ok:
         init->initKWalletEmu();
         return true;
 
 exit_fail:
         init->initKWalletEmu();
 #endif // CONFIG_KWALLETIF
         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
@@ -190,278 +190,278 @@ void PwMDocUi::rootAlertMsgBox()
 }
 
 void PwMDocUi::cantDeeplock_notSavedMsgBox()
 {
         KMessageBox::error(currentView,
                            i18n("Can't deep-lock, because the document\n"
                                 "hasn't been saved, yet. Please save\n"
                                 "to a file and try again."),
                            i18n("not saved, yet"));
 }
 
 void PwMDocUi::gpmPwLenErrMsgBox()
 {
         KMessageBox::error(currentView,
                            i18n("GPasman does not support passwords\n"
                                 "shorter than 4 characters! Please try\n"
                                 "again with a longer password."),
                            i18n("password too short"));
 }
 
 int PwMDocUi::dirtyAskSave(const QString &docTitle)
 {
         int ret;
 #ifndef PWM_EMBEDDED
         ret = KMessageBox::questionYesNoCancel(currentView,
                                                i18n("The list \"") +
                                                docTitle +
                                                i18n
                                                ("\" has been modified.\n"
                                                 "Do you want to save it?"),
                                                i18n("save?"));
         if (ret == KMessageBox::Yes) {
                 return 0;
         } else if (ret == KMessageBox::No) {
                 return 1;
         }
 #else
         ret = KMessageBox::warningYesNoCancel(currentView,
                                                i18n("The list \"") +
                                                docTitle +
                                                i18n
                                                ("\"\nhas been modified.\n"
                                                 "Do you want to save it?"),
                                                i18n("save?"));
         if (ret == KMessageBox::Yes) {
                 return 0;
         } else if (ret == KMessageBox::No) {
                 return 1;
         }
 
 #endif
 
         // cancel
         return -1;
 }
 
 bool PwMDocUi::saveDocUi(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;
         }
         PwMerror ret = doc->saveDoc(conf()->confGlobCompression());
         if (ret == e_filename) {
                 doc->timer()->putLock(DocTimer::id_autoLockTimer);
                 return saveAsDocUi(doc);
         } else if (ret == e_weakPw) {
                 KMessageBox::error(currentView,
                                    i18n("Error: This is a weak password.\n"
                                         "Please select another password."),
                                    i18n("weak password"));
                 doc->timer()->putLock(DocTimer::id_autoLockTimer);
                 return false;
         } else if (ret == e_fileBackup) {
                 KMessageBox::error(currentView,
                                    i18n("Error: Couldn't make backup-file!"),
                                    i18n("backup failed"));
                 doc->timer()->putLock(DocTimer::id_autoLockTimer);
                 return false;
         } else 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::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
@@ -1,784 +1,792 @@
 /***************************************************************************
  *                                                                         *
  *   copyright (C) 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.1 of pwmanager
  * and was modified to run on embedded devices that run microkde
  *
  * $Id$
  **************************************************************************/  
 
 #include "serializer.h"
 #include "pwmexception.h"
 
 #ifdef PWM_EMBEDDED
 #include <kglobal.h>
 #include <klocale.h>
 #endif
 
 /* enable/disable serializer debugging (0/1) */
         #define SERIALIZER_DEBUG0
 /* use the old xml tags for writing (0/1) */
         #define USE_OLD_TAGS    0
 /* write a CDATA section (0/1) */
         #define WRITE_CDATA_SEC         0
 
 
         #define META_CREATE_DATE"c"
         #define META_VALID_DATE         "v"
         #define META_EXPIRE_DATE"e"
         #define META_UPDATE_DATE"u"
         #define META_UPDATE_INT         "i"
 //US ENH : uniqueid
 #define META_UNIQUEID "n" 
 #define SYNC_ROOT "s" 
 #define SYNC_TARGET_PREFIX "t" 
 #define SYNC_TARGET_NAME "n" 
 
 
 /* This is compatibility stuff.
  * The names of the entries have changed and here are the
  * new and old ones
  */
         #define ROOT_MAGIC_OLD  "PwM-xml-dat"
         #define VER_STR_OLD     "ver"
         #define COMPAT_VER_OLD  "0x02"
         #define CAT_ROOT_OLD    "categories"
         #define CAT_PREFIX_OLD  "cat_"
         #define CAT_NAME_OLD    "name"
         #define ENTRY_PREFIX_OLD"entry_"
         #define ENTRY_DESC_OLD  "desc"
         #define ENTRY_NAME_OLD  "name"
         #define ENTRY_PW_OLD    "pw"
         #define ENTRY_COMMENT_OLD"comment"
         #define ENTRY_URL_OLD   "url"
         #define ENTRY_LAUNCHER_OLD"launcher"
         #define ENTRY_LVP_OLD   "listViewPos"
         #define ENTRY_BIN_OLD   "b"
         #define ENTRY_META_OLD  "m"
 
         #define ROOT_MAGIC_NEW  "P"
         #define VER_STR_NEW     "v"
         #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());
                 }
 
                 cur = cur.nextSibling();
         }
         return true;
 }
 
 bool Serializer::checkValid()
 {
         PWM_ASSERT(domDoc);
         QDomElement root(domDoc->documentElement());
         if (root.nodeName() != ROOT_MAGIC_NEW &&
             root.nodeName() != ROOT_MAGIC_OLD) {
                 printDebug("Serializer: wrong magic");
                 return false;
         }
         if (root.attribute(VER_STR_NEW) != COMPAT_VER_NEW &&
             root.attribute(VER_STR_OLD) != COMPAT_VER_OLD) {
                 printDebug("Serializer: wrong version");
                 return false;
         }
         return true;
 }
 
 QDomElement Serializer::genNewRoot()
 {
         PWM_ASSERT(domDoc);
         QDomElement root(domDoc->createElement(ROOT_MAGIC_WR));
         root.setAttribute(VER_STR_WR, COMPAT_VER_WR);
         domDoc->appendChild(root);
         return root;
 }
 
 bool Serializer::addCategories(QDomElement *e,
                                const vector<PwMCategoryItem> &dta)
 {
         unsigned int numCat = dta.size(), i;
         QString curId, curName;
         QDomElement curCat;
 
         for (i = 0; i < numCat; ++i) {
                 curId = CAT_PREFIX_WR;
                 curId += tostr(i).c_str();
                 curName = dta[i].name.c_str();
                 curCat = domDoc->createElement(curId);
                 curCat.setAttribute(CAT_NAME_WR, curName);
                 if (!addEntries(&curCat, dta[i].d)) {
                         return false;
                 }
                 e->appendChild(curCat);
         }
         return true;
 }
 
 bool Serializer::addEntries(QDomElement *e,
                             const vector<PwMDataItem> &dta)
 {
         unsigned int numEntr = dta.size(), i;
         QString curId;
         QDomElement curEntr;
 
         for (i = 0; i < numEntr; ++i) {
                 curId = ENTRY_PREFIX_WR;
                 curId += tostr(i).c_str();
                 curEntr = domDoc->createElement(curId);
                 if (!writeEntry(&curEntr, dta[i])) {
                         return false;
                 }
                 e->appendChild(curEntr);
         }
         return true;
 }
 
 bool Serializer::writeEntry(QDomElement *e,
                             const PwMDataItem &_dta)
 {
 #if WRITE_CDATA_SEC != 0
         # define new_text(x)domDoc->createCDATASection(x)
         QDomCDATASection curText;
 #else
         # define new_text(x)domDoc->createTextNode(x)
         QDomText curText;
 #endif
 
         QDomText plainText;
         QDomElement tag;
 
         // begin -- This is for compatibility with the old serializer
         PwMDataItem dta = _dta;
         if (!dta.desc.size())
                 dta.desc = " ";
         if (!dta.name.size())
                 dta.name = " ";
         if (!dta.pw.size())
                 dta.pw = " ";
         if (!dta.comment.size())
                 dta.comment = " ";
         if (!dta.url.size())
                 dta.url = " ";
         if (!dta.launcher.size())
                 dta.launcher = " ";
         // end -- This is for compatibility with the old serializer
 
         tag = domDoc->createElement(ENTRY_DESC_WR);
         curText = new_text(escapeEntryData(dta.desc.c_str()));
         tag.appendChild(curText);
         e->appendChild(tag);
 
         tag = domDoc->createElement(ENTRY_NAME_WR);
         curText = new_text(escapeEntryData(dta.name.c_str()));
         tag.appendChild(curText);
         e->appendChild(tag);
 
         tag = domDoc->createElement(ENTRY_PW_WR);
         curText = new_text(escapeEntryData(dta.pw.c_str()));
         tag.appendChild(curText);
         e->appendChild(tag);
 
         tag = domDoc->createElement(ENTRY_COMMENT_WR);
         curText = new_text(escapeEntryData(dta.comment.c_str()));
         tag.appendChild(curText);
         e->appendChild(tag);
 
         tag = domDoc->createElement(ENTRY_URL_WR);
         curText = new_text(escapeEntryData(dta.url.c_str()));
         tag.appendChild(curText);
         e->appendChild(tag);
 
         tag = domDoc->createElement(ENTRY_LAUNCHER_WR);
         curText = new_text(escapeEntryData(dta.launcher.c_str()));
         tag.appendChild(curText);
         e->appendChild(tag);
 
         tag = domDoc->createElement(ENTRY_LVP_WR);
         plainText = domDoc->createTextNode(tostr(dta.listViewPos).c_str());
         tag.appendChild(plainText);
         e->appendChild(tag);
 
         tag = domDoc->createElement(ENTRY_BIN_WR);
         if (dta.binary)
                 plainText = domDoc->createTextNode("1");
         else
                 plainText = domDoc->createTextNode("0");
         tag.appendChild(plainText);
         e->appendChild(tag);
 
         tag = domDoc->createElement(ENTRY_META_WR);
         if (!writeMeta(&tag, dta.meta))
                 return false;
         e->appendChild(tag);
 
 #undef new_text
         return true;
 }
 
 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;
 }