removed dead code

2 files changed, 27 insertions, 28 deletions

diff --git a/pwmanager/pwmanager/pwm.cpp b/pwmanager/pwmanager/pwm.cpp
index c511661..66d26d6 100644
--- a/pwmanager/pwmanager/pwm.cpp
+++ b/pwmanager/pwmanager/pwm.cpp
@@ -473,867 +473,867 @@ void PwM::hideEvent(QHideEvent *)
         }
 }
 
 void PwM::setVirgin(bool v)
 {
         if (virgin == v)
                 return;
         virgin = v;
         filePopup->setItemEnabled(BUTTON_POPUP_FILE_SAVE, !v);
         filePopup->setItemEnabled(BUTTON_POPUP_FILE_SAVEAS, !v);
         filePopup->setItemEnabled(BUTTON_POPUP_FILE_EXPORT, !v);
         filePopup->setItemEnabled(BUTTON_POPUP_FILE_PRINT, !v);
         managePopup->setItemEnabled(BUTTON_POPUP_MANAGE_EDIT, !v);
         managePopup->setItemEnabled(BUTTON_POPUP_MANAGE_DEL, !v);
         managePopup->setItemEnabled(BUTTON_POPUP_MANAGE_CHANGEMP, !v);
         viewPopup->setItemEnabled(BUTTON_POPUP_VIEW_LOCK, !v);
         viewPopup->setItemEnabled(BUTTON_POPUP_VIEW_DEEPLOCK, !v);
         viewPopup->setItemEnabled(BUTTON_POPUP_VIEW_UNLOCK, !v);
         viewPopup->setItemEnabled(BUTTON_POPUP_VIEW_FIND, !v);
         toolBar()->setItemEnabled(BUTTON_TOOL_SAVE, !v);
         toolBar()->setItemEnabled(BUTTON_TOOL_SAVEAS, !v);
         toolBar()->setItemEnabled(BUTTON_TOOL_PRINT, !v);
         toolBar()->setItemEnabled(BUTTON_TOOL_EDIT, !v);
         toolBar()->setItemEnabled(BUTTON_TOOL_DEL, !v);
         toolBar()->setItemEnabled(BUTTON_TOOL_LOCK, !v);
         toolBar()->setItemEnabled(BUTTON_TOOL_DEEPLOCK, !v);
         toolBar()->setItemEnabled(BUTTON_TOOL_UNLOCK, !v);
         toolBar()->setItemEnabled(BUTTON_TOOL_FIND, !v);
 }
 
 void PwM::new_slot()
 {
         init->createMainWnd();
 }
 
 //US ENH
 void PwM::open_slot()
 {
         open_slot("");
 }
 
 void PwM::open_slot(QString fn)
 {
         openDoc(fn);
 }
 
 PwMDoc * PwM::openDoc(QString filename, bool openDeepLocked)
 {
         if (!isVirgin()) {
                 // open the document in a new window.
                 PwM *newInstance = init->createMainWnd();
                 PwMDoc *newDoc = newInstance->openDoc(filename, openDeepLocked);
                 if (!newDoc) {
                         newInstance->setForceQuit(true);
                         delete_and_null(newInstance);
                 }
                 return newDoc;
         }
 
         if (!curDoc()->openDocUi(curDoc(), filename, openDeepLocked))
                 return 0;
         showStatMsg(i18n("Successfully opened file."));
         updateCaption();
         setVirgin(false);
         return curDoc();
 }
 
 PwMView * PwM::makeNewListView(PwMDoc *doc)
 {
         PwMView *ret = new PwMView(this, this, doc);
         ret->setFont(conf()->confGlobEntryFont());
         ret->show();
         return ret;
 }
 
 void PwM::close_slot()
 {
         close();
 }
 
 void PwM::quitButton_slot()
 {
         init->shutdownApp(0);
 }
 
 void PwM::save_slot()
 {
         save();
 }
 
 bool PwM::save()
 {
         if (!curDoc()->saveDocUi(curDoc()))
                 return false;
         showStatMsg(i18n("Successfully saved data."));
         updateCaption();
         return true;
 }
 
 void PwM::saveAs_slot()
 {
         saveAs();
 }
 
 bool PwM::saveAs()
 {
         if (!curDoc()->saveAsDocUi(curDoc()))
                 return false;
         showStatMsg(i18n("Successfully saved data."));
         updateCaption();
         return true;
 }
 
 //US ENH : changed code to run with older MOC
 void PwM::addPwd_slot()
 {
   addPwd_slot1(0, 0);
 }
 
 void PwM::addPwd_slot1(QString *pw, PwMDoc *_doc)
 {
         PwMDoc *doc;
         if (_doc) {
                 doc = _doc;
         } else {
                 doc = curDoc();
         }
         PWM_ASSERT(doc);
         doc->timer()->getLock(DocTimer::id_autoLockTimer);
 #ifndef PWM_EMBEDDED
         AddEntryWndImpl w;
 #else
         AddEntryWndImpl w(this, "addentrywndimpl");
 #endif
 
         vector<string> catList;
         doc->getCategoryList(&catList);
         unsigned i, size = catList.size();
         for (i = 0; i < size; ++i) {
                 w.addCategory(catList[i].c_str());
         }
         w.setCurrCategory(view->getCurrentCategory());
         if (pw)
                 w.pwLineEdit->setText(*pw);
 
       tryAgain:
         if (w.exec() == 1) 
           {
                 PwMDataItem d;
 
                 //US BUG: to initialize all values of curEntr with meaningfulldata,
                 // we call clear on it. Reason: Metadata will be uninitialized otherwise.
                 // another option would be to create a constructor for PwMDataItem
                 d.clear(true);
 
                 d.desc = w.getDescription().latin1();
                 d.name = w.getUsername().latin1();
                 d.pw = w.getPassword().latin1();
                 d.comment = w.getComment().latin1();
                 d.url = w.getUrl().latin1();
                 d.launcher = w.getLauncher().latin1();
                 PwMerror ret = doc->addEntry(w.getCategory(), &d);
                 if (ret == e_entryExists) {
                         KMessageBox::error(this,
                                            i18n
                                            ("An entry with this \"Description\",\n"
                                             "does already exist.\n"
                                             "Please select another description."),
                                            i18n("entry already exists."));
                         goto tryAgain;
                 } else if (ret == e_maxAllowedEntr) {
                         KMessageBox::error(this, i18n("The maximum possible number of\nentries"
                                                       "has been reached.\nYou can't add more entries."),
                                                  i18n("maximum number of entries"));
                         doc->timer()->putLock(DocTimer::id_autoLockTimer);
                         return;
                 }
         }
         setVirgin(false);
         doc->timer()->putLock(DocTimer::id_autoLockTimer);
 }
 
 //US ENH : changed code to run with older MOC
 void PwM::editPwd_slot()
 {
   editPwd_slot3(0,0,0);
 }
 
 void PwM::editPwd_slot1(const QString *category)
 {
   editPwd_slot3(category, 0, 0);
 }
 
 void PwM::editPwd_slot3(const QString *category, const int *index,
                        PwMDoc *_doc)
 {
         PwMDoc *doc;
         if (_doc) {
                 doc = _doc;
         } else {
                 doc = curDoc();
         }
         PWM_ASSERT(doc);
         if (doc->isDocEmpty())
                 return;
         if (doc->isDeepLocked())
                 return;
         doc->timer()->getLock(DocTimer::id_autoLockTimer);
         unsigned int curEntryIndex;
         if (index) {
                 curEntryIndex = *index;
         } else {
                 if (!(view->getCurEntryIndex(&curEntryIndex))) {
                         printDebug("couldn't get index. Maybe we have a binary entry here.");
                         doc->timer()->putLock(DocTimer::id_autoLockTimer);
                         return;
                 }
         }
         QString curCategory;
         if (category) {
                 curCategory = *category;
         } else {
                 curCategory = view->getCurrentCategory();
         }
         PwMDataItem currItem;
         if (!doc->getEntry(curCategory, curEntryIndex, &currItem, true)) {
                 doc->timer()->putLock(DocTimer::id_autoLockTimer);
                 return;
         }
         BUG_ON(currItem.binary);
 
         AddEntryWndImpl w;
         vector<string> catList;
         doc->getCategoryList(&catList);
         unsigned i, size = catList.size();
         for (i = 0; i < size; ++i) {
                 w.addCategory(catList[i].c_str());
         }
         w.setCurrCategory(curCategory);
         w.setDescription(currItem.desc.c_str());
         w.setUsername(currItem.name.c_str());
         w.setPassword(currItem.pw.c_str());
         w.setUrl(currItem.url.c_str());
         w.setLauncher(currItem.launcher.c_str());
         w.setComment(currItem.comment.c_str());
         if (w.exec() == 1) {
                 currItem.desc = w.getDescription().latin1();
                 currItem.name = w.getUsername().latin1();
                 currItem.pw = w.getPassword().latin1();
                 currItem.comment = w.getComment().latin1();
                 currItem.url = w.getUrl().latin1();
                 currItem.launcher = w.getLauncher().latin1();
                 if (!doc->editEntry(curCategory, w.getCategory(),
                                          curEntryIndex, &currItem)) {
                         KMessageBox::error(this,
                                            i18n("Couldn't edit the entry.\n"
-                                                "Maybe you changed the category and "
-                                                "this entry is already present in the new "
+                                                "Maybe you changed the category and\n"
+                                                "this entry is already present\nin the new "
                                                 "category?"),
                                            i18n("couldn't edit entry."));
                         doc->timer()->putLock(DocTimer::id_autoLockTimer);
                         return;
                 }
         }
         doc->timer()->putLock(DocTimer::id_autoLockTimer);
 }
 
 void PwM::deletePwd_slot()
 {
         PWM_ASSERT(curDoc());
         if (curDoc()->isDocEmpty())
                 return;
         if (curDoc()->isDeepLocked())
                 return;
         curDoc()->timer()->getLock(DocTimer::id_autoLockTimer);
         unsigned int curEntryIndex = 0;
         if (!(view->getCurEntryIndex(&curEntryIndex))) {
                 printDebug("couldn't get index");
                 curDoc()->timer()->putLock(DocTimer::id_autoLockTimer);
                 return;
         }
 
         PwMDataItem currItem;
         QString curCategory = view->getCurrentCategory();
         if (!curDoc()->getEntry(curCategory, curEntryIndex, &currItem)) {
                 printDebug("couldn't get entry");
                 curDoc()->timer()->putLock(DocTimer::id_autoLockTimer);
                 return;
         }
         if (KMessageBox::
             questionYesNo(this,
                           i18n
                           ("Do you really want to delete\nthe selected entry") +
                           " \n\"" + QString(currItem.desc.c_str())
                           + "\" ?", i18n("delete?"))
             == KMessageBox::Yes) {
 
                 curDoc()->delEntry(curCategory, curEntryIndex);
         }
         curDoc()->timer()->putLock(DocTimer::id_autoLockTimer);
 }
 
 void PwM::changeMasterPwd_slot()
 {
         PWM_ASSERT(curDoc());
         curDoc()->changeCurrentPw();
 }
 
 void PwM::lockWnd_slot()
 {
         PWM_ASSERT(curDoc());
         curDoc()->lockAll(true);
 }
 
 void PwM::deepLockWnd_slot()
 {
         PWM_ASSERT(curDoc());
         curDoc()->deepLock();
 }
 
 void PwM::unlockWnd_slot()
 {
         PWM_ASSERT(curDoc());
         curDoc()->lockAll(false);
 }
 
 void PwM::config_slot()
 {
   int oldStyle = conf()->confWndMainViewStyle();
 #ifdef PWM_EMBEDDED  
     KCMultiDialog*  ConfigureDialog = new KCMultiDialog( "PIM", this ,"pwmconfigdialog", true );
 
     KCMPwmConfig* pwmcfg = new KCMPwmConfig( ConfigureDialog->getNewVBoxPage(i18n( "PwManager")) , "KCMPwmConfig" );
     ConfigureDialog->addModule(pwmcfg );
 
     KCMKdePimConfig* kdelibcfg = new KCMKdePimConfig( ConfigureDialog->getNewVBoxPage(i18n( "Global")) , "KCMKdeLibConfig" );
     ConfigureDialog->addModule(kdelibcfg );
 
 #ifndef DESKTOP_VERSION
     ConfigureDialog->showMaximized();
 #endif
     if ( ConfigureDialog->exec() )
         KMessageBox::information( this,  i18n("Some changes are only\neffective after a restart!\n") );
     delete ConfigureDialog;
 
 #else //PWM_EMBEDDED
         // display the configuration window (modal mode)
         if (!conf()->showConfWnd(this))
                 return;
 #endif
 
         int newStyle = conf()->confWndMainViewStyle();
         // reinitialize tray
         init->initTray();
         // reinitialize KWallet emulation
         init->initKWalletEmu();
 
         PwMDocList *_dl = PwMDoc::getOpenDocList();
         const vector<PwMDocList::listItem> *dl = _dl->getList();
         vector<PwMDocList::listItem>::const_iterator i = dl->begin(),
                                                      end = dl->end();
         PwMDoc *doc;
         while (i != end) {
                 doc = (*i).doc;
                 // unlock-without-mpw timeout
                 doc->timer()->start(DocTimer::id_mpwTimer);
                 // auto-lock timeout
                 doc->timer()->start(DocTimer::id_autoLockTimer);
                 ++i;
         }
 
         const QValueList<PwM *> *ml = init->mainWndList();
 #ifndef PWM_EMBEDDED
         QValueList<PwM *>::const_iterator i2 = ml->begin(),
                                           end2 = ml->end();
 #else
         QValueList<PwM *>::ConstIterator i2 = ml->begin(),
                                           end2 = ml->end();
 #endif
         PwM *pwm;
         while (i2 != end2) {
                 pwm = *i2;
                 // reinitialize the window style.
                 if (oldStyle != newStyle)
                         pwm->curView()->initStyle(newStyle);
                 // set the new font
                 pwm->curView()->setFont(conf()->confGlobEntryFont());
                 ++i2;
         }
 }
 
 void PwM::activateMpButton(bool activate)
 {
         managePopup->setItemEnabled(BUTTON_POPUP_MANAGE_CHANGEMP, activate);
 }
 
 void PwM::closeEvent(QCloseEvent *e)
 {
         e->accept();
 }
 
 void PwM::docClosed(PwMDoc *doc)
 {
         PARAM_UNUSED(doc);
         PWM_ASSERT(doc == curDoc());
         close();
 }
 
 void PwM::find_slot()
 {
         PWM_ASSERT(curDoc());
         if (curDoc()->isDocEmpty())
                 return;
         if (curDoc()->isDeepLocked())
                 return;
         curDoc()->timer()->getLock(DocTimer::id_autoLockTimer);
         FindWndImpl findWnd(view);
         findWnd.exec();
         curDoc()->timer()->putLock(DocTimer::id_autoLockTimer);
 }
 
 void PwM::exportToText()
 {
         PWM_ASSERT(curDoc());
         if (curDoc()->isDocEmpty()) {
                 KMessageBox::information(this,
                                          i18n
                                          ("Sorry, there's nothing to export.\n"
                                           "Please first add some passwords."),
                                          i18n("nothing to do"));
                 return;
         }
         curDoc()->timer()->getLock(DocTimer::id_autoLockTimer);
         QString fn(KFileDialog::getSaveFileName(QString::null,
                                                 i18n("*|plain-text file"),
                                                 this));
         if (fn == "") {
                 curDoc()->timer()->putLock(DocTimer::id_autoLockTimer);
                 return;
         }
 
         PwMerror ret = curDoc()->exportToText(&fn);
         if (ret != e_success) {
                 KMessageBox::error(this,
                                    i18n("Error: Couldn't write to file.\n"
-                                        "Please check if you have permission to write "
+                                        "Please check if you have permission to write\n"
                                         "to the file in that directory."),
                                    i18n("error while writing"));
         } else
                 showStatMsg(i18n("Successfully exported data."));
         curDoc()->timer()->putLock(DocTimer::id_autoLockTimer);
 }
 
 bool PwM::importFromText()
 {
         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 "
+                                               i18n("Do you want to import the data\n"
+                                                    "into the current document? (If you\n"
+                                                    "select \"no\", a new document will be\n"
                                                     "opened.)"),
                                                i18n("import into this document?"))
                     == KMessageBox::No) {
                         // import the data to a new window.
                         PwM *newInstance = init->createMainWnd();
                         bool ok = newInstance->importFromText();
                         if (!ok) {
                                 newInstance->setForceQuit(true);
                                 delete_and_null(newInstance);
                         }
                         return ok;
                 }
         }
 
         curDoc()->timer()->getLock(DocTimer::id_autoLockTimer);
         PwMerror ret;
         QString path(KFileDialog::getOpenFileName(QString::null,
                                                   i18n("*|PWM-exported text file"),
                                                   this));
         if (path == "")
                 goto cancelImport;
 
         ret = curDoc()->importFromText(&path, 0);
         if (ret == e_fileFormat) {
                 KMessageBox::error(this,
                                    i18n("Could not read file-format.\n"
-                                        "This seems to be _not_ a valid file "
+                                        "This seems to be _not_ a valid file\n"
                                         "exported by PwM."),
                                    i18n("invalid file-format"));
                 goto cancelImport;
         } else if (ret == e_invalidArg) {
                 BUG();
                 goto cancelImport;
         } else if (ret != e_success) {
                 KMessageBox::error(this,
                                    i18n("Could not import file!\n"
-                                        "Do you have permission to read this file? "
+                                        "Do you have permission to read this file?\n"
                                         "Do you have enough free memory?"),
                                    i18n("import failed"));
                 goto cancelImport;
         }
         setVirgin(false);
         curDoc()->timer()->putLock(DocTimer::id_autoLockTimer);
         return true;
 
 cancelImport:
         curDoc()->timer()->putLock(DocTimer::id_autoLockTimer);
         return false;
 }
 
 void PwM::exportToGpasman()
 {
         PWM_ASSERT(curDoc());
         if (curDoc()->isDocEmpty()) {
                 KMessageBox::information(this,
                                          i18n
                                          ("Sorry, there's nothing to export.\n"
                                           "Please first add some passwords."),
                                          i18n("nothing to do"));
                 return;
         }
         curDoc()->timer()->getLock(DocTimer::id_autoLockTimer);
         QString fn(KFileDialog::getSaveFileName(QString::null,
                                                 i18n("*|Gpasman or Kpasman file"),
                                                 this));
         if (fn == "") {
                 curDoc()->timer()->putLock(DocTimer::id_autoLockTimer);
                 return;
         }
 
         PwMerror ret = curDoc()->exportToGpasman(&fn);
         if (ret != e_success) {
                 if (ret == e_noPw) {
                         curDoc()->timer()->putLock(DocTimer::id_autoLockTimer);
                         return;
                 }
                 KMessageBox::error(this,
                                    i18n("Error: Couldn't write to file.\n"
                                         "Please check if you have permission to write "
                                         "to the file in that directory."),
                                    i18n("error while writing"));
         } else
                 showStatMsg(i18n("Successfully exported data."));
         curDoc()->timer()->putLock(DocTimer::id_autoLockTimer);
 }
 
 void PwM::exportToKWallet()
 {
 #ifdef CONFIG_KWALLETIF
         if (!checkAndAskForKWalletEmu())
                 return;
         PWM_ASSERT(curDoc());
         if (curDoc()->isDocEmpty()) {
                 KMessageBox::information(this,
                                          i18n
                                          ("Sorry, there's nothing to export.\n"
                                           "Please first add some passwords."),
                                          i18n("nothing to do"));
                 init->initKWalletEmu();
                 return;
         }
         curDoc()->timer()->getLock(DocTimer::id_autoLockTimer);
         KWalletIf walletIf(this);
         if (walletIf.kwalletExport(curDoc())) {
                 KMessageBox::information(this,
                                          i18n("Successfully exported the data of the current "
                                               "document to KWallet."),
                                          i18n("Successfully exported data."));
                 showStatMsg(i18n("Successfully exported data."));
         }
         init->initKWalletEmu();
         curDoc()->timer()->putLock(DocTimer::id_autoLockTimer);
 #endif // CONFIG_KWALLETIF
 }
 
 bool PwM::importFromGpasman()
 {
         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 "
+                                               i18n("Do you want to import the data\n"
+                                                    "into the current document? (If you\n"
+                                                    "select \"no\", a new document will be\n"
                                                     "opened.)"),
                                                i18n("import into this document?"))
                     == KMessageBox::No) {
                         // import the data to a new window.
                         PwM *newInstance = init->createMainWnd();
                         bool ok = newInstance->importFromGpasman();
                         if (!ok) {
                                 newInstance->setForceQuit(true);
                                 delete_and_null(newInstance);
                         }
                         return ok;
                 }
         }
 
         curDoc()->timer()->getLock(DocTimer::id_autoLockTimer);
         PwMerror ret;
         QString path(KFileDialog::getOpenFileName(QString::null,
                                                   i18n("*|Gpasman or Kpasman file"), this));
         if (path == "")
                 goto cancelImport;
         ret = curDoc()->importFromGpasman(&path);
         if (ret == e_wrongPw) {
                 if (KMessageBox::questionYesNo(this,
                                                 i18n
-                                               ("This is probably the wrong master-password"
+                                               ("This is probably the wrong master-password\n"
                                                 "you have typed in.\n"
-                                                "There is no real way to determine the "
-                                                "correctness of the password in the Gpasman "
-                                                "file-format. But I think this "
+                                                "There is no real way to determine the\n"
+                                                "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);
 #else
         qDebug("Statusbar : %s",msg.latin1());
 #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"
diff --git a/pwmanager/pwmanager/pwmdoc.cpp b/pwmanager/pwmanager/pwmdoc.cpp
index 8869f3a..86b6273 100644
--- a/pwmanager/pwmanager/pwmdoc.cpp
+++ b/pwmanager/pwmanager/pwmdoc.cpp
@@ -1011,537 +1011,543 @@ PwMerror PwMDoc::addEntry(const QString &category, PwMDataItem *d,
          * But for now we only search in desc.
          * That's a tweak to be KWallet compatible. But it should not add
          * usability-drop onto PwManager, does it?
          * (And yes, "int" was a bug. Correct is "unsigned int")
          */
         const unsigned int searchIn = SEARCH_IN_DESC;
         findEntry(cat, *d, searchIn, &foundPositions, true);
         if (foundPositions.size()) {
                 // DOH! We found this entry.
                 return e_entryExists;
         }
 
         d->listViewPos = -1;
         d->lockStat = conf()->confGlobNewEntrLockStat();
         if (updateMeta) {
                 d->meta.create = QDateTime::currentDateTime();
                 d->meta.update = d->meta.create;
         }
         dti.dta[cat].d.push_back(*d);
 
         delAllEmptyCat(true);
 
         if (!dontFlagDirty)
                 flagDirty();
         return e_success;
 }
 
 PwMerror PwMDoc::addCategory(const QString &category, unsigned int *categoryIndex,
                              bool checkIfExist)
 {
         if (isDeepLocked()) {
                 PwMerror ret;
                 ret = deepLock(false);
                 if (ret != e_success)
                         return e_lock;
         }
         if (checkIfExist) {
                 if (findCategory(category, categoryIndex))
                         return e_categoryExists;
         }
         PwMCategoryItem item;
         item.name = category.latin1();
         dti.dta.push_back(item);
         if (categoryIndex)
                 *categoryIndex = dti.dta.size() - 1;
         return e_success;
 }
 
 bool PwMDoc::delEntry(const QString &category, unsigned int index, bool dontFlagDirty)
 {
         unsigned int cat = 0;
 
         if (!findCategory(category, &cat)) {
                 BUG();
                 return false;
         }
 
         return delEntry(cat, index, dontFlagDirty);
 }
 
 bool PwMDoc::delEntry(unsigned int category, unsigned int index, bool dontFlagDirty)
 {
         if (isDeepLocked())
                 return false;
         if (index > dti.dta[category].d.size() - 1)
                 return false;
         getDataChangedLock();
         if (!lockAt(category, index, false)) {
                 putDataChangedLock();
                 return false;
         }
         putDataChangedLock();
         int lvPos = dti.dta[category].d[index].listViewPos;
 
         // delete entry
         dti.dta[category].d.erase(dti.dta[category].d.begin() + index);
 
         unsigned int i, entries = numEntries(category);
         if (!entries) {
                 // no more entries in this category, so
                 // we can delete it, too.
                 BUG_ON(!delCategory(category));
                 // delCategory() flags it dirty, so we need not to do so.
                 return true;
         }
         for (i = 0; i < entries; ++i) {
                 // decrement all listViewPositions that are greater than the deleted.
                 if (dti.dta[category].d[i].listViewPos > lvPos)
                         --dti.dta[category].d[i].listViewPos;
         }
 
         if (!dontFlagDirty)
                 flagDirty();
         return true;
 }
 
 bool PwMDoc::editEntry(const QString &oldCategory, const QString &newCategory,
                        unsigned int index, PwMDataItem *d, bool updateMeta)
 {
         PWM_ASSERT(d);
         unsigned int oldCat = 0;
 
         if (!findCategory(oldCategory, &oldCat)) {
                 BUG();
                 return false;
         }
 
         return editEntry(oldCat, newCategory, index, d, updateMeta);
 }
 
 bool PwMDoc::editEntry(unsigned int oldCategory, const QString &newCategory,
                        unsigned int index, PwMDataItem *d, bool updateMeta)
 {
         if (isDeepLocked())
                 return false;
         if (updateMeta) {
                 d->meta.update = QDateTime::currentDateTime();
                 if (d->meta.create.isNull()) {
                         d->meta.create = d->meta.update;
                 }
         }
         if (dti.dta[oldCategory].name != newCategory.latin1()) {
                 // the user changed the category.
                 PwMerror ret;
                 d->rev = 0;
                 ret = addEntry(newCategory, d, true, false);
                 if (ret != e_success)
                         return false;
                 if (!delEntry(oldCategory, index, true))
                         return false;
         } else {
                 d->rev = dti.dta[oldCategory].d[index].rev + 1; // increment revision counter.
                 dti.dta[oldCategory].d[index] = *d;
         }
         flagDirty();
         return true;
 }
 
 unsigned int PwMDoc::numEntries(const QString &category)
 {
         unsigned int cat = 0;
 
         if (!findCategory(category, &cat)) {
                 BUG();
                 return 0;
         }
 
         return numEntries(cat);
 }
 
 bool PwMDoc::serializeDta(string *d)
 {
         PWM_ASSERT(d);
         Serializer ser;
         if (!ser.serialize(dti))
                 return false;
         d->assign(ser.getXml());
         if (!d->size())
                 return false;
         return true;
 }
 
 bool PwMDoc::deSerializeDta(const string *d, bool entriesLocked)
 {
         PWM_ASSERT(d);
 #ifndef PWM_EMBEDDED
         try {
 
                 Serializer ser(d->c_str());
                 ser.setDefaultLockStat(entriesLocked);
                 if (!ser.deSerialize(&dti))
                         return false;
         } catch (PwMException) {
                 return false;
         }
 #else
         Serializer ser(d->c_str());
         ser.setDefaultLockStat(entriesLocked);
         if (!ser.deSerialize(&dti))
           return false;
 #endif
 
         emitDataChanged(this);
         return true;
 }
 
 bool PwMDoc::getEntry(const QString &category, unsigned int index,
                       PwMDataItem * d, bool unlockIfLocked)
 {
         PWM_ASSERT(d);
         unsigned int cat = 0;
 
         if (!findCategory(category, &cat)) {
                 BUG();
                 return false;
         }
 
         return getEntry(cat, index, d, unlockIfLocked);
 }
 
 bool PwMDoc::getEntry(unsigned int category, unsigned int index,
                       PwMDataItem *d, bool unlockIfLocked)
 {
         if (index > dti.dta[category].d.size() - 1)
                 return false;
 
         bool locked = isLocked(category, index);
         if (locked) {
                 /* this entry is locked. We don't return a password,
                  * until it's unlocked by the user by inserting
                  * chipcard or entering the mpw
                  */
                 if (unlockIfLocked) {
                         if (!lockAt(category, index, false)) {
                                 return false;
                         }
                         locked = false;
                 }
         }
 
         *d = dti.dta[category].d[index];
         if (locked)
                 d->pw = LOCKED_STRING.latin1();
 
         return true;
 }
 
 PwMerror PwMDoc::getCommentByLvp(const QString &category, int listViewPos,
                                  string *foundComment)
 {
         PWM_ASSERT(foundComment);
         unsigned int cat = 0;
 
         if (!findCategory(category, &cat))
                 return e_invalidArg;
 
         unsigned int i, entries = numEntries(cat);
         for (i = 0; i < entries; ++i) {
                 if (dti.dta[cat].d[i].listViewPos == listViewPos) {
                         *foundComment = dti.dta[cat].d[i].comment;
                         if (dti.dta[cat].d[i].binary)
                                 return e_binEntry;
                         return e_normalEntry;
                 }
         }
         BUG();
         return e_generic;
 }
 
 bool PwMDoc::compressDta(string *d, char algo)
 {
         PWM_ASSERT(d);
         switch (algo) {
                 case PWM_COMPRESS_GZIP: {
                         CompressGzip comp;
                         return comp.compress(d);
-                                /*US    } case PWM_COMPRESS_BZIP2: {
+                }
+#ifndef PWM_EMBEDDED 
+                case PWM_COMPRESS_BZIP2: {
                         CompressBzip2 comp;
                         return comp.compress(d);
-*/
-                } case PWM_COMPRESS_NONE: {
+                }
+#endif
+                case PWM_COMPRESS_NONE: {
                         return true;
                 } default: {
                         BUG();
                 }
         }
         return false;
 }
 
 bool PwMDoc::decompressDta(string *d, char algo)
 {
         PWM_ASSERT(d);
         switch (algo) {
                 case PWM_COMPRESS_GZIP: {
                         CompressGzip comp;
                         return comp.decompress(d);
-                                /*US    } case PWM_COMPRESS_BZIP2: {
+                }
+#ifndef PWM_EMBEDDED 
+                case PWM_COMPRESS_BZIP2: {
                         CompressBzip2 comp;
                         return comp.decompress(d);
-                        */
-                } case PWM_COMPRESS_NONE: {
+                }
+#endif
+                case PWM_COMPRESS_NONE: {
                         return true;
                 }
         }
         return false;
 }
 
 PwMerror PwMDoc::encrypt(string *d, const QString *pw, QFile *f, char algo)
 {
         PWM_ASSERT(d);
         PWM_ASSERT(pw);
         PWM_ASSERT(f);
 
         size_t encSize;
         byte *encrypted = 0;
 
         switch (algo) {
         case PWM_CRYPT_BLOWFISH: {
                 Blowfish::padNull(d);
                 encSize = d->length();
                 encrypted = new byte[encSize];
                 Blowfish bf;
                 if (bf.bf_setkey((byte *) pw->latin1(), pw->length())) {
                         delete [] encrypted;
                         return e_weakPw;
                 }
                 bf.bf_encrypt((byte *) encrypted, (byte *) d->c_str(), encSize);
                 break;
         }
         case PWM_CRYPT_AES128:
                 /*... fall through */
         case PWM_CRYPT_AES192:
         case PWM_CRYPT_AES256:
         case PWM_CRYPT_3DES:
         case PWM_CRYPT_TWOFISH:
         case PWM_CRYPT_TWOFISH128: {
                 if (!LibGCryptIf::available())
                         return e_cryptNotImpl;
                 LibGCryptIf gc;
                 PwMerror err;
                 unsigned char *plain = new unsigned char[d->length() + 1024];
                 memcpy(plain, d->c_str(), d->length());
                 err = gc.encrypt(&encrypted,
                                  &encSize,
                                  plain,
                                  d->length(),
                                  reinterpret_cast<const unsigned char *>(pw->latin1()),
                                  pw->length(),
                                  algo);
                 delete [] plain;
                 if (err != e_success)
                         return e_cryptNotImpl;
                 break;
         }
         default: {
                 delete_ifnot_null_array(encrypted);
                 return e_cryptNotImpl;
         } }
 
         // write encrypted data to file
         if (f->writeBlock(reinterpret_cast<const char *>(encrypted),
                           static_cast<Q_ULONG>(encSize))
             != static_cast<Q_LONG>(encSize)) {
                 delete_ifnot_null_array(encrypted);
                 return e_writeFile;
         }
         delete_ifnot_null_array(encrypted);
         return e_success;
 }
 
 PwMerror PwMDoc::decrypt(string *d, unsigned int pos, const QString *pw,
                          char algo, QFile *f)
 {
         PWM_ASSERT(d);
         PWM_ASSERT(pw);
         PWM_ASSERT(f);
 
         unsigned int cryptLen = f->size() - pos;
         byte *encrypted = new byte[cryptLen];
         byte *decrypted = new byte[cryptLen];
 
         f->at(pos);
 #ifndef PWM_EMBEDDED
         if (f->readBlock(reinterpret_cast<char *>(encrypted),
                          static_cast<Q_ULONG>(cryptLen))
             != static_cast<Q_LONG>(cryptLen)) {
                 delete [] encrypted;
                 delete [] decrypted;
                 return e_readFile;
         }
 #else
         if (f->readBlock((char *)(encrypted),
                          (unsigned long)(cryptLen))
             != (long)(cryptLen)) {
                 delete [] encrypted;
                 delete [] decrypted;
                 return e_readFile;
         }
 #endif
         switch (algo) {
         case PWM_CRYPT_BLOWFISH: {
                 Blowfish bf;
                 bf.bf_setkey((byte *) pw->latin1(), pw->length());
                 bf.bf_decrypt(decrypted, encrypted, cryptLen);
                 break;
         }
         case PWM_CRYPT_AES128:
                 /*... fall through */
         case PWM_CRYPT_AES192:
         case PWM_CRYPT_AES256:
         case PWM_CRYPT_3DES:
         case PWM_CRYPT_TWOFISH:
         case PWM_CRYPT_TWOFISH128: {
                 if (!LibGCryptIf::available())
                         return e_cryptNotImpl;
                 LibGCryptIf gc;
                 PwMerror err;
                 err = gc.decrypt(&decrypted,
                                  &cryptLen,
                                  encrypted,
                                  cryptLen,
                                  reinterpret_cast<const unsigned char *>(pw->latin1()),
                                  pw->length(),
                                  algo);
                 if (err != e_success) {
                         delete [] encrypted;
                         delete [] decrypted;
                         return e_cryptNotImpl;
                 }
                 break;
         }
         default: {
                 delete [] encrypted;
                 delete [] decrypted;
                 return e_cryptNotImpl;
         } }
         delete [] encrypted;
 #ifndef PWM_EMBEDDED
         d->assign(reinterpret_cast<const char *>(decrypted),
                   static_cast<string::size_type>(cryptLen));
 #else
         d->assign((const char *)(decrypted),
                   (string::size_type)(cryptLen));
 #endif
         delete [] decrypted;
         if (algo == PWM_CRYPT_BLOWFISH) {
                 if (!Blowfish::unpadNull(d)) {
                         BUG();
                         return e_readFile;
                 }
         }
         return e_success;
 }
 
 PwMerror PwMDoc::checkDataHash(char dataHashType, const string *dataHash,
                                const string *dataStream)
 {
         PWM_ASSERT(dataHash);
         PWM_ASSERT(dataStream);
         switch(dataHashType) {
         case PWM_HASH_SHA1: {
                 Sha1 hash;
                 hash.sha1_write((byte*)dataStream->c_str(), dataStream->length());
                 string ret = hash.sha1_read();
                 if (ret != *dataHash)
                         return e_fileCorrupt;
                 break;
         }
         case PWM_HASH_SHA256:
                 /*... fall through */
         case PWM_HASH_SHA384:
         case PWM_HASH_SHA512:
         case PWM_HASH_MD5:
         case PWM_HASH_RMD160:
         case PWM_HASH_TIGER: {
                 if (!LibGCryptIf::available())
                         return e_hashNotImpl;
                 LibGCryptIf gc;
                 PwMerror err;
                 unsigned char *buf;
                 size_t hashLen;
                 err = gc.hash(&buf,
                               &hashLen,
                               reinterpret_cast<const unsigned char *>(dataStream->c_str()),
                               dataStream->length(),
                               dataHashType);
                 if (err != e_success)
                         return e_hashNotImpl;
                 string calcHash(reinterpret_cast<const char *>(buf),
                                 static_cast<string::size_type>(hashLen));
                 delete [] buf;
                 if (calcHash != *dataHash)
                         return e_fileCorrupt;
                 break;
         }
         default:
                 return e_hashNotImpl;
         }
         return e_success;
 }
 
 bool PwMDoc::lockAt(unsigned int category, unsigned int index,
                     bool lock)
 {
         if (index >= numEntries(category)) {
                 BUG();
                 return false;
         }
         if (lock == dti.dta[category].d[index].lockStat)
                 return true;
 
         if (!lock && currentPw != "") {
                 // "unlocking" and "password is already set"
                 if (!getDocStatFlag(DOC_STAT_UNLOCK_WITHOUT_PW)) {
                         // unlocking without pw not allowed
                         QString pw;
                         pw = requestMpw(getDocStatFlag(DOC_STAT_USE_CHIPCARD));
                         if (pw != "") {
                                 if (pw != currentPw) {
                                         wrongMpwMsgBox(getDocStatFlag(DOC_STAT_USE_CHIPCARD));
                                         return false;
                                 } else {
                                         timer()->start(DocTimer::id_mpwTimer);
                                 }
                         } else {
                                 return false;
                         }
                 } else {
                         timer()->start(DocTimer::id_mpwTimer);
                 }
         }
 
         dti.dta[category].d[index].lockStat = lock;
         dti.dta[category].d[index].rev++; // increment revision counter.
 
         emitDataChanged(this);
         if (!lock)
                 timer()->start(DocTimer::id_autoLockTimer);
 
         return true;
 
 }
 
 bool PwMDoc::lockAt(const QString &category,unsigned int index,
                     bool lock)
 {
         unsigned int cat = 0;
 
         if (!findCategory(category, &cat)) {
                 BUG();
                 return false;
         }
 
         return lockAt(cat, index, lock);
 }
 
 bool PwMDoc::lockAll(bool lock)
@@ -2870,611 +2876,604 @@ void PwMDoc::ensureLvp()
         //US ENH BUG: when using syncronizing, this way of sorting
         //is not sufficient, because there might be empty spaces
         // at the beginning. But the old algorythm only can add elements
         //to the end.The result are crashes because of list overflows
         //we need something to fill all gaps.
         vector<PwMDataItem*> sorted;
         vector< PwMDataItem*>::iterator sortedBegin,
                                         sortedEnd,
                                         sortedI;
         vector<PwMCategoryItem>::iterator catBegin = dti.dta.begin(),
                                           catEnd = dti.dta.end(),
                                           catI = catBegin;
         vector<PwMDataItem>::iterator entrBegin, entrEnd, entrI;
         int lvpTop, tmpLvp;
 
         //qDebug("collect:"); 
 
         while (catI != catEnd) {
                 lvpTop = -1;
                 sorted.clear();
 
                 entrBegin = catI->d.begin();
                 entrEnd = catI->d.end();
                 entrI = entrBegin;
 
                 //US: we use the stl sort algorythm to sort all elements in the order 
                 //of its listViewPos (in the order 1,2,2,3,5,...,x,-1, -1, -1
                 while (entrI != entrEnd) {
                   //qDebug("found: %s, pos=%i", (*entrI).desc.c_str(), (*entrI).listViewPos);
                   sorted.push_back((PwMDataItem*)&(*entrI));
                   ++entrI;
                 }
 
                 sortedBegin = sorted.begin();
                 sortedEnd = sorted.end();
 
                 sort(sortedBegin, sortedEnd, PwMDataItemListViewPosSort());
 
                         //      qDebug("resort:"); 
                 //now we have all sorted in a collection
                 //Now start with the sorted and reset listviewpos.
                 sortedBegin = sorted.begin();
                 sortedEnd = sorted.end();
                 sortedI = sortedBegin;
 
                 while (sortedI != sortedEnd) {
                           //      qDebug("reset defined: %s, from pos=%i to pos=%i", (*sortedI)->desc.c_str(), (*sortedI)->listViewPos, lvpTop+1);
                   (*sortedI)->listViewPos = ++lvpTop;
                   ++sortedI;
                 }
 
                 /*/debug
                 entrBegin = catI->d.begin();
                 entrEnd = catI->d.end();
                 entrI = entrBegin;
 
                 while (entrI != entrEnd) {
                   qDebug("check: %s, pos=%i", (*entrI).desc.c_str(), (*entrI).listViewPos);
                   ++entrI;
                 }
                 */
 
                 ++catI;
         }
 }
 
 QString PwMDoc::getTitle()
 {
         /* NOTE: We have to ensure, that the returned title
          *       is unique and not reused somewhere else while
          *       this document is valid (open).
          */
         QString title(getFilename());
 
         //US ENH: The whole filename on PDAs is too long. So use only the last characters
         if (QApplication::desktop()->width() < 640)
         {
           if (title.length() > 30)
             title = "..." + title.right(30);
 
         }
 
 
         if (title.isEmpty()) {
                 if (unnamedNum == 0) {
                         unnamedNum = PwMDocList::getNewUnnamedNumber();
                         PWM_ASSERT(unnamedNum != 0);
                 }
                 title = DEFAULT_TITLE;
                 title += " ";
                 title += tostr(unnamedNum).c_str();
         }
         return title;
 }
 
 bool PwMDoc::tryDelete()
 {
         if (deleted)
                 return true;
         int ret;
         if (isDirty()) {
                 ret = dirtyAskSave(getTitle());
                 if (ret == 0) { // save to disk
                         if (!saveDocUi(this))
                                 goto out_ignore;
                 } else if (ret == 1) { // don't save and delete
                         goto out_accept;
                 } else { // cancel operation
                         goto out_ignore;
                 }
         }
 out_accept:
         deleted = true;
         delete this;
         return true;
 out_ignore:
         return false;
 }
 
 
 
 #ifdef PWM_EMBEDDED
 //US ENH: this is the magic function that syncronizes the this doc with the remote doc
 //US it could have been defined as static, but I did not want to. 
 PwMerror PwMDoc::syncronize(KSyncManager* manager, PwMDoc* syncLocal , PwMDoc* syncRemote, int mode )
 {
   int addedPasswordsLocal = 0;
   int addedPasswordsRemote = 0;
   int deletedPasswordsRemote = 0;
   int deletedPasswordsLocal = 0;
   int changedLocal = 0;
   int changedRemote = 0;
 
   PwMSyncItem* syncItemLocal;
   PwMSyncItem* syncItemRemote;
 
   QString mCurrentSyncName = manager->getCurrentSyncName();
   QString mCurrentSyncDevice = manager->getCurrentSyncDevice();
 
   bool fullDateRange = false;
   int take;
   //    local->resetTempSyncStat();
   QDateTime mLastSync = QDateTime::currentDateTime();
   QDateTime modifiedSync = mLastSync;
 
   unsigned int index;
   //Step 1. Find syncinfo in Local file and create if not existent.
   bool found = syncLocal->findSyncData(mCurrentSyncDevice, &index);
   if (found == false)
     {
       PwMSyncItem newSyncItemLocal;
       newSyncItemLocal.syncName = mCurrentSyncDevice.latin1();
       newSyncItemLocal.lastSyncDate = mLastSync;
       syncLocal->addSyncDataEntry(&newSyncItemLocal, true);
       found = syncLocal->findSyncData(mCurrentSyncDevice, &index);
       if (found == false) {
         qDebug("PwMDoc::syncronize : newly created local sync data could not be found");
         return e_syncError;
       }
             }
 
   syncItemLocal = syncLocal->getSyncDataEntry(index); 
   qDebug("Last Sync Local %s ", syncItemLocal->lastSyncDate.toString().latin1());
 
   //Step 2. Find syncinfo in remote file and create if not existent.
   found = syncRemote->findSyncData(mCurrentSyncName, &index);
   if (found == false)
     {
       qDebug("FULLDATE 1");
       fullDateRange = true;
       PwMSyncItem newSyncItemRemote;
       newSyncItemRemote.syncName = mCurrentSyncName.latin1();
       newSyncItemRemote.lastSyncDate = mLastSync;
       syncRemote->addSyncDataEntry(&newSyncItemRemote, true);
       found = syncRemote->findSyncData(mCurrentSyncName, &index);
       if (found == false) {
         qDebug("PwMDoc::syncronize : newly created remote sync data could not be found");
         return e_syncError;
       }
     }
   
   syncItemRemote = syncRemote->getSyncDataEntry(index); 
   qDebug("Last Sync Remote %s ", syncItemRemote->lastSyncDate.toString().latin1());
   //and remove the found entry here. We will reenter it later again.
   //US  syncRemote->delSyncDataEntry(index, true);
 
 
   if ( syncItemLocal->lastSyncDate == mLastSync ) {
     qDebug("FULLDATE 2");
     fullDateRange = true;
   }
   
   if ( ! fullDateRange  ) {
         if ( syncItemLocal->lastSyncDate != syncItemRemote->lastSyncDate ) {
             
             fullDateRange = true;
             qDebug("FULLDATE 3 %s %s", syncItemLocal->lastSyncDate.toString().latin1() , syncItemRemote->lastSyncDate.toString().latin1() );
         } 
     }
     // fullDateRange = true; // debug only!
     if ( fullDateRange )
         mLastSync = QDateTime::currentDateTime().addDays( -100*365);
     else
         mLastSync = syncItemLocal->lastSyncDate;
 
 
     qDebug("*************************** ");
     qDebug("mLastSync %s ",mLastSync.toString().latin1() );
     QStringList er = syncRemote->getIDEntryList(); 
     PwMDataItem* inRemote ;//= er.first();
     PwMDataItem* inLocal;
     unsigned int catLocal, indexLocal;
     unsigned int catRemote, indexRemote;
 
     QString uid;
     manager->showProgressBar(0, i18n("Syncing - close to abort!"), er.count());
 
     int modulo = (er.count()/10)+1;
     unsigned int incCounter = 0;
     while ( incCounter < er.count()) {
         if (manager->isProgressBarCanceled())
             return e_syncError;
         if ( incCounter % modulo == 0 )
           manager->showProgressBar(incCounter);
 
         uid = er[ incCounter ]; 
         qDebug("sync uid %s from remote file", uid.latin1());
 
         qApp->processEvents();
 
             inLocal = syncLocal->findEntryByID( uid, &catLocal, &indexLocal );
             inRemote = syncRemote->findEntryByID( uid, &catRemote, &indexRemote );
             PWM_ASSERT(inRemote);
             if ( inLocal != 0 ) { // maybe conflict - same uid in both files
                 if ( (take = takePwMDataItem( inLocal, inRemote, mLastSync, mode, fullDateRange) ) ) {
                     qDebug("take %d %s ", take, inLocal->desc.c_str());
                     if ( take == 3 )
                         return e_syncError;
                     if ( take == 1  ) {// take local
                         int oldlistpos = inRemote->listViewPos;
                         (*inRemote) = (*inLocal);
                         inRemote->listViewPos = oldlistpos;
                         ++changedRemote;
                     } else { // take == 2  take remote
                         int oldlistpos = inLocal->listViewPos;
                         (*inLocal) = (*inRemote);
                         inLocal->listViewPos = oldlistpos;
                         ++changedLocal;
                     }
                 }
             } else { //  no conflict
                     if ( inRemote->meta.update > mLastSync || mode == 5 ) {
                         inRemote->meta.update = modifiedSync;
 
                         //first check if we have a matching category in the local file
                         const string* remotecat = syncRemote->getCategory(catRemote);
-                        //US                        syncRemote->insertAddressee( inRemote, false );
-                        //US                        syncLocal->insertAddressee( inRemote, false );
                         syncLocal->addEntry(remotecat->c_str(), inRemote, true, false);
 
                         ++addedPasswordsLocal;
                     } else {
                         // pending checkExternSyncAddressee(addresseeRSyncSharp, inR);
                         syncRemote->delEntry(catRemote, indexRemote, true);
-                        //USsyncRemote->removeAddressee( inRemote );
                         ++deletedPasswordsRemote; 
                     }
             }
 
         ++incCounter;
     }
 
 
     er.clear();
     QStringList el = syncLocal->getIDEntryList(); 
     modulo = (el.count()/10)+1;
 
     manager->showProgressBar(0, i18n("Add / remove addressees"), el.count());
     incCounter = 0;
     while ( incCounter < el.count()) {
         qApp->processEvents();
         if (manager->isProgressBarCanceled())
             return e_syncError;
         if ( incCounter % modulo == 0 )
           manager->showProgressBar(incCounter);
         uid = el[ incCounter ]; 
         qDebug("sync uid %s from local file", uid.latin1());
 
         inLocal = syncLocal->findEntryByID( uid, &catLocal, &indexLocal );
         inRemote = syncRemote->findEntryByID( uid, &catRemote, &indexRemote );
         PWM_ASSERT(inLocal);
 
         if ( inRemote == 0 ) { 
                 if ( inLocal->meta.update < mLastSync && mode != 4 ) {
                     // pending checkExternSyncAddressee(addresseeLSyncSharp, inL);
                     syncLocal->delEntry(catLocal, indexLocal, true);
-                        //USsyncLocal->removeAddressee( inLocal );
                     ++deletedPasswordsLocal; 
                 } else {
                     if ( ! manager->mWriteBackExistingOnly ) {
                         ++addedPasswordsRemote; 
                         inLocal->meta.update = modifiedSync;
 
                         //first check if we have a matching category in the remote file
                         const string* localcat = syncLocal->getCategory(catLocal);
 
-                        //USsyncLocal->insertAddressee( inLocal, false );
                         PwMDataItem newEntry;
                         newEntry = *inLocal; 
                         inRemote = &newEntry;
         
                         //USsyncRemote->insertAddressee( inRemote, false );
                         syncRemote->addEntry(localcat->c_str(), inRemote, true, false);
 
                     }
                 }
 
         }
         ++incCounter;
     }
     el.clear();
     manager->hideProgressBar();
 
     // Now write the info back into the sync data space of the files
 
     mLastSync = QDateTime::currentDateTime().addSecs( 1 );
     // get rid of micro seconds
     QTime t =  mLastSync.time();
     mLastSync.setTime( QTime (t.hour (), t.minute (), t.second () )  );
 
    
     syncItemLocal->lastSyncDate = mLastSync;
     syncItemRemote->lastSyncDate = mLastSync;
 
     QString mes;
     mes .sprintf(  i18n("Synchronization summary:\n\n %d items added to local\n %d items added to remote\n %d items updated on local\n %d items updated on remote\n %d items deleted on local\n %d items deleted on remote\n"),addedPasswordsLocal, addedPasswordsRemote, changedLocal, changedRemote, deletedPasswordsLocal, deletedPasswordsRemote ); 
     if ( manager->mShowSyncSummary ) {
         KMessageBox::information(0, mes, i18n("PWM/Pi Synchronization") );
     }
     qDebug( mes );
   return e_success;
 }
 
 
 int PwMDoc::takePwMDataItem( PwMDataItem* local,  PwMDataItem* remote, QDateTime lastSync, int mode , bool full )
 {
     // 0 equal
     // 1 take local
     // 2 take remote
     // 3 cancel 
     QDateTime localMod = local->meta.update;
     QDateTime remoteMod = remote->meta.update;
 
-    //US    QString mCurrentSyncDevice = syncManager->getCurrentSyncDevice();
-
      if ( localMod == remoteMod )
        return 0;
         
     qDebug(" %d %d conflict on %s %s ", mode, full, local->desc.c_str(), remote->desc.c_str() );
 
     //qDebug("%s %d  %s %d", local->lastModified().toString().latin1() , localMod, remote->lastModified().toString().latin1(), remoteMod);  
     //qDebug("%d %d %d %d ", local->lastModified().time().second(), local->lastModified().time().msec(),  remote->lastModified().time().second(), remote->lastModified().time().msec() );
     //full = true; //debug only
     if ( full ) {
       bool equ = ( (*local) == (*remote) );
         if ( equ ) {
           //qDebug("equal ");
             if ( mode < SYNC_PREF_FORCE_LOCAL )
                 return 0;
               
         }//else //debug only
           //qDebug("not equal %s %s ", local->desc.c_str(), remote->desc.c_str());
     }
     
     int result;
     bool localIsNew;
     //qDebug("%s -- %s mLastCalendarSync %s lastsync %s --- local %s remote %s ",local->summary().latin1(), remote->summary().latin1(),mLastCalendarSync.toString().latin1() ,lastSync.toString().latin1()  ,  local->lastModified().toString().latin1() , remote->lastModified().toString().latin1()  );
 
     if ( full && mode < SYNC_PREF_NEWEST )
         mode = SYNC_PREF_ASK;
 
     switch( mode ) {
     case SYNC_PREF_LOCAL:
         if ( lastSync > remoteMod )
             return 1;
         if ( lastSync > localMod )
             return 2;
         return 1;
         break;
     case SYNC_PREF_REMOTE:
         if ( lastSync > remoteMod )
             return 1;
         if ( lastSync > localMod )
             return 2;
         return 2;
         break;
     case SYNC_PREF_NEWEST:
         if ( localMod > remoteMod )
             return 1;
         else
             return 2;
         break;
     case SYNC_PREF_ASK: 
         //qDebug("lsy %s  ---  lo %s  --- re %s ", lastSync.toString().latin1(), localMod.toString().latin1(), remoteMod.toString().latin1()  );
         if ( lastSync > remoteMod )
             return 1;
         if ( lastSync > localMod )
             return 2;
         localIsNew = localMod >= remoteMod;
         //qDebug("conflict! ************************************** ");
         {
           PwMDataItemChooser acd ( *local,*remote, localIsNew , 0/*this*/ );
             result = acd.executeD(localIsNew);
             return result;
         }
         break;
     case SYNC_PREF_FORCE_LOCAL:
         return 1;
         break;
     case SYNC_PREF_FORCE_REMOTE:
         return 2;
         break;
        
     default:
         // SYNC_PREF_TAKE_BOTH not implemented
         break;
     }
     return 0;
 }
 
 
 
 
 //this are the overwritten callbackmethods from the syncinterface
 bool PwMDoc::sync(KSyncManager* manager, QString filename, int mode)
 {
   QString mCurrentSyncDevice = manager->getCurrentSyncDevice();
 
   //1) unlock local file first if necessary (ask for password)
   if (this->isDeepLocked()) {
     PwMerror ret = this->deepLock(false);
     if (ret != e_success)
       return false;
   }
 
   //2)  construct and open a new doc on the stack(automatic cleanup of remote file).
   PwMDoc syncTarget(this, "synctarget");
   PwMDoc* pSyncTarget = &syncTarget;
 
 
   PwMerror err = pSyncTarget->openDoc(&filename, 1 /*== open with all entries locked*/);
 
   if (err == e_alreadyOpen) {
     PwMDocList::listItem li;
     if (getOpenDocList()->find(filename.latin1(), &li))
       pSyncTarget = li.doc;
     else {
       qDebug("PwmDoc::sync: sync failed. Error %i while opening file %s",err, filename.latin1());
       return false;
     }
   }
   else if (err != e_success) {
     qDebug("PwmDoc::sync: sync failed. Error %i while opening file %s",err, filename.latin1());
     return false;
   }
 
   qDebug("PWM file loaded %s,sync mode %d",filename.latin1(), mode );
 
 
   //3) unlock remote file first if necessary (ask for password)
   if (pSyncTarget->isDeepLocked()) {
     PwMerror ret = pSyncTarget->deepLock(false);
     if (ret != e_success)
       return false;
   }
 
   
   err = syncronize(manager, this, pSyncTarget, mode );
 
   if (err == e_success) {
             if ( manager->mWriteBackFile ){
       qDebug("Saving remote PWManager file");
       err = pSyncTarget->saveDoc(conf()->confGlobCompression());
       if (err != e_success) {
         qDebug("PwmDoc::sync: Sync failed. Error %i while storing file %s",err, filename.latin1());
         return false;
       }
     }
 
     flagDirty();
     return true;
   }
   else {
     return false;
   }
 }
 
 #endif
 
 
 bool PwMDoc::findSyncData(const QString &syncname, unsigned int *index)
 {
         vector<PwMSyncItem>::iterator i = dti.syncDta.begin(), 
                                       end = dti.syncDta.end();
 
         while (i != end) {
                 if ((*i).syncName == syncname.latin1()) {
                         if (index) {
                                 *index = i - dti.syncDta.begin();
                         }
                         return true;
                 }
                 ++i;
         }
         return false;
 };
 
 /** add new syncdataentry */
 PwMerror PwMDoc::addSyncDataEntry(PwMSyncItem *d, bool dontFlagDirty)
 {
         PWM_ASSERT(d);
 
         if (isDeepLocked()) {
                 PwMerror ret;
                 ret = deepLock(false);
                 if (ret != e_success)
                         return e_lock;
         }
         unsigned int index;
 
         const QString tmp = d->syncName.c_str();
         bool exists = findSyncData(d->syncName.c_str(), &index);
 
         if (exists == true) {
                 // DOH! We found this entry.
                 return e_entryExists;
         }
 
         dti.syncDta.push_back(*d);
 
         if (!dontFlagDirty)
                 flagDirty();
         return e_success;
 }
 
 
 
 /** delete syncdata entry */
 bool PwMDoc::delSyncDataEntry(unsigned int index, bool dontFlagDirty)
 {
         if (isDeepLocked())
                 return false;
         if (index > dti.syncDta.size() - 1)
                 return false;
 
         // delete entry
         dti.syncDta.erase(dti.syncDta.begin() + index);
 
         if (!dontFlagDirty)
                 flagDirty();
         return true;
 }
 
 
 PwMDataItem* PwMDoc::findEntryByID(const QString &uid, unsigned int *category, unsigned int *index)
 {
   vector<PwMCategoryItem>::iterator catcounter = dti.dta.begin(),
                                   catend = dti.dta.end();
 
   vector<PwMDataItem>::iterator entrBegin, entrEnd, entrI;
 
   while (catcounter != catend) {
     entrBegin = catcounter->d.begin();
     entrEnd = catcounter->d.end();
     entrI = entrBegin;
     while (entrI != entrEnd) {
       if ((*entrI).meta.uniqueid == uid.latin1()) {
         if (category)
           *category = catcounter - dti.dta.begin();
         if (index)
           *index = entrI - entrBegin;
 
         return &(*entrI);
       }
       ++entrI;
     }
     ++catcounter;
   }
 
   return 0;
 }
 
 QStringList PwMDoc::getIDEntryList()
 {
   QStringList results;
 
   vector<PwMCategoryItem>::iterator catcounter = dti.dta.begin(),
                                   catend = dti.dta.end();
 
   vector<PwMDataItem>::iterator entrBegin, entrEnd, entrI;
 
   while (catcounter != catend) {
     entrBegin = catcounter->d.begin();
     entrEnd = catcounter->d.end();
     entrI = entrBegin;
     while (entrI != entrEnd) {
       results.append( (*entrI).meta.uniqueid.c_str() );
       ++entrI;
     }
     ++catcounter;
   }