sync

4 files changed, 5 insertions, 5 deletions

diff --git a/pwmanager/pwmanager/pwm.cpp b/pwmanager/pwmanager/pwm.cpp
index e12dc49..8373850 100644
--- a/pwmanager/pwmanager/pwm.cpp
+++ b/pwmanager/pwmanager/pwm.cpp
@@ -800,800 +800,800 @@ void PwM::editPwd_slot3(const QString *category, const int *index,
 
 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_global_slot()
 {
   KPimPrefsGlobalDialog gc ( this );
     gc.exec();
 }
 void PwM::config_slot()
 {
   int oldStyle = conf()->confWndMainViewStyle();
 
 #if 0 
     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 );
 #endif
 
 
 
     KDialogBase * ConfigureDialog = new KDialogBase (  KDialogBase::Plain , i18n("Configure KA/Pi"), KDialogBase::Default |KDialogBase::Cancel | KDialogBase::Apply | KDialogBase::Ok, KDialogBase::Ok,0, "name", true, true);
 
     KCMPwmConfig* kabcfg = new KCMPwmConfig( ConfigureDialog , "KCMpwmConfig" );
     ConfigureDialog->setMainWidget( kabcfg );
     connect( ConfigureDialog, SIGNAL( applyClicked() ),
             kabcfg, SLOT( save() ) );
     connect( ConfigureDialog, SIGNAL( acceptClicked() ),
              kabcfg, SLOT( save() ) );
     connect( ConfigureDialog, SIGNAL( defaultClicked() ),
              kabcfg, SLOT( defaults() ) );
     //saveSettings();
     kabcfg->load();
 #ifndef DESKTOP_VERSION
     if ( QApplication::desktop()->height() <= 480 )
         ;// ConfigureDialog->hideButtons(); 
     ConfigureDialog->showMaximized();
 #endif
 
 
     if ( ConfigureDialog->exec() )
         KMessageBox::information( this,  i18n("Some changes are only\neffective after a restart!\n") );
     delete ConfigureDialog;
 
 
 
 	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)
 {
     //qDebug("PwM::closeEvent ");
     emit closed( this );
     return;
 	e->accept();
 }
 
 void PwM::docClosed(PwMDoc *doc)
 {
     //qDebug("PwM::docClosed ");
 	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\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\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\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?\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::exportToCsv()
 {
   PWM_ASSERT(curDoc());
   if (curDoc()->isDocEmpty()) {
     KMessageBox::information(this,
 			     i18n
 			     ("Sorry, there is nothing to export;\n"
 			      "please add some passwords first."),
 			     i18n("Nothing to Do"));
     return;
   }
 
   curDoc()->timer()->getLock(DocTimer::id_autoLockTimer);
   QString fn(KFileDialog::getSaveFileName("*.csv", i18n("*|CSV Text File"), this));
   if (fn.isEmpty()) {
     curDoc()->timer()->putLock(DocTimer::id_autoLockTimer);
     return;
   }
 
   Csv csv(this);
   if (!csv.exportData(fn, curDoc())) {
     curDoc()->timer()->putLock(DocTimer::id_autoLockTimer);
     showStatMsg(i18n("CSV file export failed."));
     return;
   }
   showStatMsg(i18n("Successfully exported data."));
   curDoc()->timer()->putLock(DocTimer::id_autoLockTimer);
 }
 
 bool PwM::importCsv()
 {
   Csv csv(this);
   if (!isVirgin()) {
     if (KMessageBox::questionYesNo(this,
        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->importCsv();
       if (!ok) {
 	newInstance->setForceQuit(true);
 	delete_and_null(newInstance);
       }
       return ok;
     }
   }
 
   QString filename = KFileDialog::getOpenFileName("*.csv", i18n("*|CSV Text File"), this);
   if (filename.isEmpty())
     return false;
   curDoc()->timer()->getLock(DocTimer::id_autoLockTimer);
   if (!csv.importData(filename, curDoc())) {
     curDoc()->timer()->putLock(DocTimer::id_autoLockTimer);
     showStatMsg(i18n("CSV file import failed."));
     return false;
   }
   curDoc()->timer()->putLock(DocTimer::id_autoLockTimer);
   KMessageBox::information(this,
 			   i18n("Successfully imported the CSV data\n"
       "into the current document."), i18n("Successfully Imported"));
   showStatMsg(i18n("Successfully imported"));
   setVirgin(false);
   return true;
 }
 
 
 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\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\n"
 					        "you have typed in.\n"
 					        "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)
 {
 #ifdef DESKTOP_VERSION
 	statusBar()->message(msg, STATUSBAR_MSG_TIMEOUT * 1000);
 #else
 	//qDebug("Statusbar : %s",msg.latin1());
     Global::statusMessage(msg);
 #endif
 }
 
 void PwM::focusInEvent(QFocusEvent *e)
 {
 	if (e->gotFocus()) {
 		emit gotFocus(this);
 	} else if (e->lostFocus()) {
 		emit lostFocus(this);
 	}
 }
 
 
 #ifdef PWM_EMBEDDED
 
 void PwM::category_slot()
 {
 	PwMDoc *doc = curDoc();
 	PWM_ASSERT(doc);
 	doc->timer()->getLock(DocTimer::id_autoLockTimer);
 
 	editCategoryWnd w(doc, this, "editcategory");
 /*
 	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);
 */
 	w.setCurrCategory(view->getCurrentCategory());
 
       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);
 }
 
 
 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)
+bool PwM::sync(KSyncManager* manager, QString filename, int mode,QString resource)
 {
   PWM_ASSERT(curDoc());
 
-  bool ret =  curDoc()->sync(manager, filename, mode);
+  bool ret =  curDoc()->sync(manager, filename, mode,resource);
 
   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;
 }
  
 void PwM::removeSyncInfo( QString syncProfile)
 {
     qDebug("PWM:removeSyncInfo for profile %s ", syncProfile.latin1());
     curDoc()->removeSyncInfo( syncProfile );
     //US curDoc()->removeSyncInfo sets the dirtyFlag.
 }
 
 #endif
 
 
 #ifndef PWM_EMBEDDED
 #include "pwm.moc"
 #endif
diff --git a/pwmanager/pwmanager/pwm.h b/pwmanager/pwmanager/pwm.h
index 2d1b854..c4bbb4e 100644
--- a/pwmanager/pwmanager/pwm.h
+++ b/pwmanager/pwmanager/pwm.h
@@ -1,300 +1,300 @@
 /***************************************************************************
  *                                                                         *
  *   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$
  **************************************************************************/  
 
 #ifndef __PWM_H
 #define __PWM_H
 
 
 #include <kpopupmenu.h>
 #include <klistview.h>
 #include <kmainwindow.h>
 
 #ifndef PWM_EMBEDDED
 #include <kwin.h>
 #include <kapp.h>
 #include <kdeversion.h>
 #else
 #include <ksyncmanager.h>
 #endif
 
 #include <kaction.h>
 
 #include <qglobal.h>
 
 #include "pwmview.h"
 #include "pwmexception.h"
 
 
 /** timeout for displaying a message on the status-bar (in seconds) */
 #define STATUSBAR_MSG_TIMEOUT	5
 
 
 class PwMInit;
 class KSyncManager;
 
 /** PwM is the base class of the project */
 #ifndef PWM_EMBEDDED
 //MOC_SKIP_BEGIN
 class PwM : public KMainWindow
 //MOC_SKIP_END
 #else
 class PwM : public KMainWindow, public KSyncInterface
 #endif
 {
 	Q_OBJECT
 public:
 	friend class PwMView;
 	/** construtor */
 	PwM(PwMInit *_init, PwMDoc *doc,
 	    bool virginity = true,
 	    QWidget* parent = 0, const char *name = 0);
 	/** destructor */
 	~PwM();
 
 	/** copy some text to the global clipboard */
 	static void copyToClipboard(const QString &s);
 
 	/** returns pointer to the view */
 	PwMView * curView()
 			{ return view; }
 	/** returns pointer to the currently using document. */
 	PwMDoc * curDoc()
 			{ return curView()->document(); }
 	/** open a new doc with the given filename */
 	PwMDoc * openDoc(QString filename, bool openDeepLocked = false);
 	/** show a message on the global status bar.
 	  * The message times out after some seconds.
 	  */
 	void showStatMsg(const QString &msg);
 	/** ask the user where to save the doc (if it has not been saved, yet)
 	  * and write the data to disk.
 	  */
 	bool save();
 	/** ask the user where to save the doc
 	  * and write the data to disk.
 	  */
 	bool saveAs();
 	/** force quit. Quit this window, always! Don't minimize it */
 	bool isForceQuit()
 			{ return forceQuit; }
 	/** set forceQuit */
 	void setForceQuit(bool force)
 			{ forceQuit = force; }
 	/** force minimize this window */
 	bool isForceMinimizeToTray()
 			{ return forceMinimizeToTray; }
 	/** set forceMinimizeToTray */
 	void setForceMinimizeToTray(bool force)
 			{ forceMinimizeToTray = force; }
 
 public slots:
 	/** file/new triggered */
 	void new_slot();
 	/** file/open triggered */
 //US ENH
 	void open_slot();
 	void open_slot(QString fn);
 	/** file/close triggered */
 	void close_slot();
 	/** file/quit triggered */
 	void quitButton_slot();
 	/** file/save triggered */
 	void save_slot();
 	/** file/saveAs triggered */
 	void saveAs_slot();
 	/** file/export/text triggered */
 	void exportToText();
 	/** file/export/gpasman triggered */
 	void exportToGpasman();
 	/** file/export/kwallet triggered */
 	void exportToKWallet();
 	/** file/export/csv triggered */
 	void exportToCsv();
 	/** file/import/text triggered */
 	bool importFromText();
 	/** file/import/gpasman triggered */
 	bool importFromGpasman();
 	/** file/import/kwallet triggered */
 	bool importKWallet();
 	/** file/import/csv triggered */
 	bool importCsv();
 	/** file/print triggered */
 	void print_slot();
 	/** manage/add triggered */
 	//US ENH : changed code to run with older MOC
 
 	void addPwd_slot();
 	void addPwd_slot1(QString *pw, PwMDoc *_doc);
 	/** manage/edit triggered */
 	//US ENH : changed code to run with older MOC
 	void editPwd_slot();
 	void editPwd_slot1(const QString *category);
 	void editPwd_slot3(const QString *category, const int *index ,PwMDoc *_doc );
 
 	/** manage/delete triggered */
 	void deletePwd_slot();
 	/** execute the "Launcher" entry */
 	void execLauncher_slot();
 	/** open browser with URL entry */
 	void goToURL_slot();
 	/** manage/changeMasterPwd triggered */
 	void changeMasterPwd_slot();
 	/** lock current document */
 	void lockWnd_slot();
 	/** deeplock current document */
 	void deepLockWnd_slot();
 	/** window/unlock triggered */
 	void unlockWnd_slot();
 	/** find item */
 	void find_slot();
 	/** configure clicked */
 	void config_slot();
 	void config_global_slot();
 	/** (de)activate the "change master pw" button in the menu-bar */
 	void activateMpButton(bool activate = true);
 	/** generate a new chipcard */
 	void genNewCard_slot();
 	/** completely erase the current card */
 	void eraseCard_slot();
 	/** returns the ID number of the current card */
 	void readCardId_slot();
 	/** make backup image of the current card */
 	void makeCardBackup_slot();
 	/** write backup image to current card */
 	void replayCardBackup_slot();
 
 #ifdef PWM_EMBEDDED
 	void category_slot();
 	void whatsnew_slot();
 	void showLicense_slot();
 	void faq_slot();
 	void createAboutData_slot();
 	void syncHowTo_slot();
 #endif
 
 protected:
 	/** is this window virgin? */
 	bool isVirgin()
 			{ return virgin; }
 	/** add/remove virginity */
 	void setVirgin(bool v);
 	/** initialize the menubar */
 	void initMenubar();
 	/** initialize the toolbar */
 	void initToolbar();
 	/** initialize the window-metrics */
 	void initMetrics();
 	/** close-event */
 	void closeEvent(QCloseEvent *e);
 	/** creates a new PwM-ListView and returns it */
 	PwMView * makeNewListView(PwMDoc *doc);
 	/** Window hide-event */
 	void hideEvent(QHideEvent *);
 	/** is this window minimized? */
 	bool isMinimized()
 		{
 #ifndef PWM_EMBEDDED
 		  #if KDE_VERSION >= KDE_MAKE_VERSION(3, 2, 0)
 			return KWin::windowInfo(winId()).isMinimized();
 		  #else // KDE_VERSION
 			return KWin::info(winId()).isIconified();
 		  #endif // KDE_VERSION
 #else
 			return false;
 #endif
 		}
 	/** window got the focus */
 	void focusInEvent(QFocusEvent *e);
 	/** update the caption string */
 	void updateCaption();
 #ifdef CONFIG_KWALLETIF
 	/** check if kwalletemu is enabled and ask the user what to do */
 	bool checkAndAskForKWalletEmu();
 #endif // CONFIG_KWALLETIF
 
 protected slots:
 	/** doc got closed */
 	void docClosed(PwMDoc *doc);
 
 signals:
 	/** window got closed (by user or someone else) */
 	void closed(PwM *wnd);
 	/** window got the focus (was brought to foreground) */
 	void gotFocus(PwM *wnd);
 	/** window lost the focus */
 	void lostFocus(PwM *wnd);
 
 protected:
 	/** pointer to the view active in this KMainWindow */
 	PwMView *view;
 	/** pointer to the init class */
 	PwMInit *init;
 	/** has this window already lost its virginity?
 	  * Means is there an open working document
 	  */
 	bool virgin;
 	/** "file" popup-menu */
 	KPopupMenu *filePopup;
 
 	/** "manage" popup-menu */
 	KPopupMenu *managePopup;
 #ifdef CONFIG_KEYCARD
 	/** "chipcard" popup-menu */
 	KPopupMenu *chipcardPopup;
 #endif // CONFIG_KEYCARD
 	/** "view" popup-menu */
 	KPopupMenu *viewPopup;
 	/** "options" popup-menu */
 	KPopupMenu *optionsPopup;
 	/** "help" popup-menu */
 	KPopupMenu *helpPopup;
 	/** "export" popup-menu */
 	KPopupMenu *exportPopup;
 	/** "import" popup-menu */
 	KPopupMenu *importPopup;
 	/** force quit this window? */
 	bool forceQuit;
 	/** force minimize this window to the tray */
 	bool forceMinimizeToTray;
 
 
 
 
  private:
 #ifdef PWM_EMBEDDED
     //this are the overwritten callbackmethods from the syncinterface
-    virtual bool sync(KSyncManager* manager, QString filename, int mode); 
+    virtual bool sync(KSyncManager* manager, QString filename, int mode,QString resource); 
     virtual void removeSyncInfo( QString syncProfile);
 
     // LR *******************************
     // sync stuff!
     QPopupMenu *syncPopup;
     KSyncManager* syncManager;
 #endif
 
 
 
 
 
 
 
 
 };
 
 #endif
diff --git a/pwmanager/pwmanager/pwmdoc.cpp b/pwmanager/pwmanager/pwmdoc.cpp
index 1f3c58b..b58d7e2 100644
--- a/pwmanager/pwmanager/pwmdoc.cpp
+++ b/pwmanager/pwmanager/pwmdoc.cpp
@@ -2679,956 +2679,956 @@ PwMerror PwMDoc::importText_PwM(const QString *file)
 			if ((ret = getline(&ch_tmp, &ch_tmp_size, f)) == -1)
 				goto formatError;
 			if (!textExtractEntry_PwM(ch_tmp, ret, &currItem.launcher))
 				goto formatError;
 
 			currItem.lockStat = true;
 			currItem.listViewPos = -1;
 			addEntry(curCat.c_str(), &currItem, true);
 			++entriesRead;
 		} while (1);
 	} while (1);
 	if (!entriesRead)
 		goto formatError;
 
 	free(ch_tmp);
 	fclose(f);
 	flagDirty();
 	return e_success;
 
       formatError:
 	free(ch_tmp);
 	fclose(f);
 	return e_fileFormat;
 #else
 	PWM_ASSERT(file);
 	QFile f(file->latin1());
 	int tmp;
 	ssize_t ret;
 	string curCat;
 	unsigned int entriesRead = 0;
 	PwMDataItem currItem;
 	bool res = f.open(IO_ReadOnly);
 	if (res == false)
 	  return e_openFile;
 
 	unsigned int ch_tmp_size = 1024;
 	char *ch_tmp = (char*)malloc(ch_tmp_size);
 	if (!ch_tmp) {
 		f.close();
 		return e_outOfMem;
 	}
 
 	// - check header
 	if (f.readLine(ch_tmp, ch_tmp_size) == -1) // skip first line.
 		goto formatError;
 
 	//US read fileversion first, then check if ok.
 	if (f.readLine(ch_tmp, ch_tmp_size) == -1)
 		goto formatError;
 
 	// check version-string and return version in "ch_tmp".
 	//US 	if (fscanf(f, "PwM v%s", ch_tmp) != 1) {
 	//US		// header not recognized as PwM generated header
 	//US		goto formatError;
 	//US	}
 	//US set filepointer behind version-string-line previously checked
 	//US if (f.readLine(ch_tmp, ch_tmp_size) == -1)
 	//US		goto formatError;
 	// skip next line containing the build-date
 	if (f.readLine(ch_tmp, ch_tmp_size) == -1)
 		goto formatError;
 	// read header termination line
 	if (f.readLine(ch_tmp, ch_tmp_size) == -1)
 		goto formatError;
 	if (strcmp(ch_tmp, "==============================\n"))
 		goto formatError;
 
 	// - read entries
 	do {
 		// find beginning of next category
 		do {
 			tmp = f.getch();
 		} while (tmp == '\n' && tmp != EOF);
 		if (tmp == EOF)
 			break;
 
 		// decrement filepos by one
 		f.at(f.at()-1);
 		// read cat-name
 		if (f.readLine(ch_tmp, ch_tmp_size) == -1)
 			goto formatError;
 		// check cat-name format
 		if (memcmp(ch_tmp, "== Category: ", 13) != 0)
 			goto formatError;
 		if (memcmp(ch_tmp + (strlen(ch_tmp) - 1 - 3), " ==", 3) != 0)
 			goto formatError;
 		// copy cat-name
 		curCat.assign(ch_tmp + 13, strlen(ch_tmp) - 1 - 16);
 
 		do {
 			// find beginning of next entry
 			do {
 				tmp = f.getch();
 			} while (tmp == '\n' && tmp != EOF && tmp != '=');
 			if (tmp == EOF)
 				break;
 			if (tmp == '=') {
 			        f.at(f.at()-1);
 				break;
 			}
 			// decrement filepos by one
 		        f.at(f.at()-1);
 			// read desc-line
 			if (f.readLine(ch_tmp, ch_tmp_size) == -1)
 				goto formatError;
 			// check desc-line format
 			if (memcmp(ch_tmp, "-- ", 3) != 0)
 				goto formatError;
 			if (memcmp(ch_tmp + (strlen(ch_tmp) - 1 - 3), " --", 3) != 0)
 				goto formatError;
 			// add desc-line
 			currItem.desc.assign(ch_tmp + 3, strlen(ch_tmp) - 1 - 6);
 
 			// read username-line
 			if ((ret = f.readLine(ch_tmp, ch_tmp_size)) == -1)
 				goto formatError;
 			if (!textExtractEntry_PwM(ch_tmp, ret, &currItem.name))
 				goto formatError;
 
 			// read pw-line
 			if ((ret = f.readLine(ch_tmp, ch_tmp_size)) == -1)
 				goto formatError;
 			if (!textExtractEntry_PwM(ch_tmp, ret, &currItem.pw))
 				goto formatError;
 
 			// read comment-line
 			if ((ret = f.readLine(ch_tmp, ch_tmp_size)) == -1)
 				goto formatError;
 			if (!textExtractEntry_PwM(ch_tmp, ret, &currItem.comment))
 				goto formatError;
 
 			// read URL-line
 			if ((ret = f.readLine(ch_tmp, ch_tmp_size)) == -1)
 				goto formatError;
 			if (!textExtractEntry_PwM(ch_tmp, ret, &currItem.url))
 				goto formatError;
 
 			// read launcher-line
 			if ((ret = f.readLine(ch_tmp, ch_tmp_size)) == -1)
 				goto formatError;
 			if (!textExtractEntry_PwM(ch_tmp, ret, &currItem.launcher))
 				goto formatError;
 
 			currItem.lockStat = true;
 			currItem.listViewPos = -1;
 			addEntry(curCat.c_str(), &currItem, true);
 			++entriesRead;
 		} while (1);
 	} while (1);
 	if (!entriesRead)
 		goto formatError;
 
 	free(ch_tmp);
 	f.close();
 	flagDirty();
 	return e_success;
 
       formatError:
 	free(ch_tmp);
 	f.close();
 	return e_fileFormat;
 
 #endif
 
 }
 
 bool PwMDoc::textExtractEntry_PwM(const char *in, ssize_t in_size, string *out)
 {
 	PWM_ASSERT(in && out);
 	ssize_t i = 0, len = in_size - 1;
 	while (i < len) {
 		if (in[i] == ':')
 			break;
 		++i;
 	}
 	i += 2;
 	*out = "";
 	out->append(in + i, in_size - i - 1);
 	return true;
 }
 
 PwMerror PwMDoc::exportToGpasman(const QString *file)
 {
 	PWM_ASSERT(file);
 	GpasmanFile gp;
 	int ret;
 
 	if (!unlockAll_tempoary())
 		return e_lock;
 
 	QString gpmPassword;
 	while (1) {
 		gpmPassword = requestNewMpw(0);
 		if (gpmPassword == "") {
 			unlockAll_tempoary(true);
 			return e_noPw;
 		}
 		if (gpmPassword.length() < 4) {
 			gpmPwLenErrMsgBox();
 		} else {
 			break;
 		}
 	}
 
 	ret = gp.save_init(file->latin1(), gpmPassword.latin1());
 	if (ret != 1) {
 		unlockAll_tempoary(true);
 		return e_accessFile;
 	}
 
 	char *entry[4];
 	unsigned int numCat = numCategories(), i;
 	unsigned int numEntr, j;
 	int descLen, nameLen, pwLen, commentLen;
 	for (i = 0; i < numCat; ++i) {
 		numEntr = numEntries(i);
 		for (j = 0; j < numEntr; ++j) {
 			descLen = dti.dta[i].d[j].desc.length();
 			nameLen = dti.dta[i].d[j].name.length();
 			pwLen = dti.dta[i].d[j].pw.length();
 			commentLen = dti.dta[i].d[j].comment.length();
 			entry[0] = new char[descLen + 1];
 			entry[1] = new char[nameLen + 1];
 			entry[2] = new char[pwLen + 1];
 			entry[3] = new char[commentLen + 1];
 			strcpy(entry[0], descLen == 0 ? " " : dti.dta[i].d[j].desc.c_str());
 			strcpy(entry[1], nameLen == 0 ? " " : dti.dta[i].d[j].name.c_str());
 			strcpy(entry[2], pwLen == 0 ? " " : dti.dta[i].d[j].pw.c_str());
 			strcpy(entry[3], commentLen == 0 ? " " : dti.dta[i].d[j].comment.c_str());
 			entry[0][descLen == 0 ? descLen + 1 : descLen] = '\0';
 			entry[1][nameLen == 0 ? nameLen + 1 : nameLen] = '\0';
 			entry[2][pwLen == 0 ? pwLen + 1 : pwLen] = '\0';
 			entry[3][commentLen == 0 ? commentLen + 1 : commentLen] = '\0';
 
 			ret = gp.save_entry(entry);
 			if (ret == -1){
 				delete [] entry[0];
 				delete [] entry[1];
 				delete [] entry[2];
 				delete [] entry[3];
 				gp.save_finalize();
 				unlockAll_tempoary(true);
 				return e_writeFile;
 			}
 
 			delete [] entry[0];
 			delete [] entry[1];
 			delete [] entry[2];
 			delete [] entry[3];
 		}
 	}
 	unlockAll_tempoary(true);
 	if (gp.save_finalize() == -1)
 		return e_writeFile;
 
 	return e_success;
 }
 
 PwMerror PwMDoc::importFromGpasman(const QString *file)
 {
 	PWM_ASSERT(file);
 	QString pw = requestMpw(false);
 	if (pw == "")
 		return e_noPw;
 	GpasmanFile gp;
 	int ret, i;
 	PwMerror ret2;
 	char *entry[4];
 	PwMDataItem tmpData;
 	ret = gp.load_init(file->latin1(), pw.latin1());
 	if (ret != 1)
 		return e_accessFile;
 
 	do {
 		ret = gp.load_entry(entry);
 		if(ret != 1)
 			break;
 		tmpData.desc = entry[0];
 		tmpData.name = entry[1];
 		tmpData.pw = entry[2];
 		tmpData.comment = entry[3];
 		tmpData.lockStat = true;
 		tmpData.listViewPos = -1;
 		ret2 = addEntry(DEFAULT_CATEGORY, &tmpData, true);
 		for (i = 0; i < 4; ++i)
          		free(entry[i]);
 		if (ret2 == e_maxAllowedEntr) {
 			gp.load_finalize();
 			return e_maxAllowedEntr;
 		}
 	} while (1);
 	gp.load_finalize();
 	if (isDocEmpty())
 		return e_wrongPw; // we assume this.
 
 	flagDirty();
 	return e_success;
 }
 
 
 //US: we use the stl sort algorythm to sort all elements in the order 
 //of its listViewPos (in the order 1,2,3,5,...,x,-1, -1, -1
 struct PwMDataItemListViewPosSort
 {
   bool operator()(PwMDataItem* rpStart, PwMDataItem* rpEnd)
   {
     //qDebug("pwMDoc::PwMDataItemListViewPosSort()");
     if ((rpEnd)->listViewPos < 0)
 	return false;
     else
       return (rpStart)->listViewPos < (rpEnd)->listViewPos;
   }
 };
 
 void PwMDoc::ensureLvp()
 {
 	if (isDocEmpty())
 		return;
 
 	//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 mSyncLauncher = true;
 
   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
 		        inRemote->syncItem(*inLocal, mSyncLauncher);
                         ++changedRemote;
                     } else { // take == 2  take remote
 		        inLocal->syncItem(*inRemote, mSyncLauncher);
                         ++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);
 			syncLocal->addEntry(remotecat->c_str(), inRemote, true, false);
 
                         ++addedPasswordsLocal;
                     } else {
                         // pending checkExternSyncAddressee(addresseeRSyncSharp, inR);
 		        syncRemote->delEntry(catRemote, indexRemote, true);
                         ++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);
                     ++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);
 
                         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;
 
      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;
 }
 
 void PwMDoc::removeSyncInfo( QString syncProfile)
 {
     bool res, found;
     unsigned int count, i;
     if ( syncProfile.isEmpty() ) {
       count = numSyncDataEntries();
       for (i = count; count > 0; count-- ) {
 	res = delSyncDataEntry(i-1, false);
 	if (res == false) {
 	  qDebug("PwMDoc::removeSyncInfo: could not remove syncprofile");
 	}
       }
     } else { 
       found = findSyncData(syncProfile, &count);
       if (found == true)
 	{
 	  res = delSyncDataEntry(count, false);
 	  if (res == false) {
 	    qDebug("PwMDoc::removeSyncInfo: could not remove %s", syncProfile.latin1());
 
 	  }
 	}	
     }
 }
 
 
 //this are the overwritten callbackmethods from the syncinterface
-bool PwMDoc::sync(KSyncManager* manager, QString filename, int mode)
+bool PwMDoc::sync(KSyncManager* manager, QString filename, int mode, QString resource)
 {
   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;
   }
 
   return results;
 }
 
 
 
 
 
 #ifndef PWM_EMBEDDED
 #include "pwmdoc.moc"
 #endif
diff --git a/pwmanager/pwmanager/pwmdoc.h b/pwmanager/pwmanager/pwmdoc.h
index 45dd729..144831f 100644
--- a/pwmanager/pwmanager/pwmdoc.h
+++ b/pwmanager/pwmanager/pwmdoc.h
@@ -31,803 +31,803 @@
 #define PWM_HASH_MD5		(static_cast<char>(0x05))
 #define PWM_HASH_RMD160		(static_cast<char>(0x06))
 #define PWM_HASH_TIGER		(static_cast<char>(0x07))
 
 #define PWM_CRYPT_BLOWFISH	(static_cast<char>(0x01))
 #define PWM_CRYPT_AES128	(static_cast<char>(0x02))
 #define PWM_CRYPT_AES192	(static_cast<char>(0x03))
 #define PWM_CRYPT_AES256	(static_cast<char>(0x04))
 #define PWM_CRYPT_3DES		(static_cast<char>(0x05))
 #define PWM_CRYPT_TWOFISH	(static_cast<char>(0x06))
 #define PWM_CRYPT_TWOFISH128	(static_cast<char>(0x07))
 
 #define PWM_COMPRESS_NONE	(static_cast<char>(0x00))
 #define PWM_COMPRESS_GZIP	(static_cast<char>(0x01))
 #define PWM_COMPRESS_BZIP2	(static_cast<char>(0x02))
 
 #define DEFAULT_MAX_ENTRIES	(~(static_cast<unsigned int>(0)))
 #define FILE_ID_HEADER  	"PWM_PASSWORD_FILE"
 
 
 #include "pwmexception.h"
 #include "pwmdocui.h"
 
 #include <qobject.h>
 #include <qtimer.h>
 #include <qdatetime.h>
 
 #include <kprocess.h>
 
 #ifndef PWM_EMBEDDED
 #include "configuration.h"
 #else
 #include <kapplication.h>
 #include <ksyncmanager.h>
 #endif
 
 #include <string>
 #include <vector>
 #include <utility>
 
 using std::vector;
 using std::string;
 using std::pair;
 
 /* used in findEntry() function */
 #define SEARCH_IN_DESC		(1)
 #define SEARCH_IN_NAME		(1 << 1)
 #define SEARCH_IN_PW		(1 << 2)
 #define SEARCH_IN_COMMENT	(1 << 3)
 #define SEARCH_IN_URL		(1 << 4)
 #define SEARCH_IN_LAUNCHER	(1 << 5)
 #define SEARCH_IN_ALL		(SEARCH_IN_DESC	| SEARCH_IN_NAME	|  \
 				 SEARCH_IN_PW	| SEARCH_IN_COMMENT	|  \
 				 SEARCH_IN_URL	| SEARCH_IN_LAUNCHER)
 
 /** document deeplocked. Data is out for lunch to disk */
 #define DOC_STAT_DEEPLOCKED		(1)
 /** encrypted document on disk is dirty. data has to go to disk. */
 #define DOC_STAT_DISK_DIRTY		(1 << 1)
 /** we are using a chipcard to encrypt the data */
 #define DOC_STAT_USE_CHIPCARD		(1 << 2)
 /** use "currentPw" to unlock. (This flag is set/unset by a timer) */
 #define DOC_STAT_UNLOCK_WITHOUT_PW	(1 << 3)
 
 class PwMDoc;
 class PwMView;
 class QFile;
 
 /* meta data for a PwMDataItem */
 struct PwMMetaData
 {
 	PwMMetaData()
 	 : updateInt (0)
 		{ }
 	/** creation date of the PwMDataItem to which
 	  * this meta data belongs.
 	  */
 	QDateTime	create;
 	/** becomes valid on this date */
 	QDateTime	valid;
 	/** expire date */
 	QDateTime	expire;
 	/** update date (last updated at this date) */
 	QDateTime	update;
 	/** update interval (in minutes). Time since the
 	  * last update to remind the user to update the item.
 	  * 0 disables.
 	  */
 	unsigned long updateInt;
  
 	//US ENH: enhancements of the filestructure
 	/* each entry gets a unique id assigned  */
 	string  uniqueid;
 
 
 	void clear()
 		{
 			create = QDateTime();
 			expire = QDateTime();
 			update = QDateTime();
 			updateInt = 0;
 			uniqueid = KApplication::randomString(8).latin1();
 		}
 
 	inline bool isValid() const
 		{
 			if (valid.isNull())
 				return true;
 			return (valid < QDateTime::currentDateTime());
 		}
 	inline bool isExpired() const
 		{
 			if (expire.isNull())
 				return false;
 			return (expire < QDateTime::currentDateTime());
 		}
 	inline bool isUpdateIntOver() const
 		{
 			if (updateInt == 0 ||
 			    update.isNull())
 				return false;
 			QDateTime d(update);
 			return (d.addSecs(updateInt * 60) < QDateTime::currentDateTime());
 		}
 };
 
 struct PwMDataItem
 {
 	PwMDataItem()
 	 : lockStat (true)
 	 , listViewPos (-1)
 	 , binary (false)
 	 , rev (0)
 		{ }
 
 	/** password description */
 	string	desc;
 	/** user-name */
 	string	name;
 	/** the password itself */
 	string	pw;
 	/** some comment */
 	string	comment;
 	/** an URL string */
 	string	url;
 	/** launcher. Can be executed as a system() command */
 	string	launcher;
 	/** locking status. If locked (true), pw is not emitted through getEntry() */
 	bool	lockStat;
 	/** position of this item in main "list-view"
 	  * If -1, the position is not yet specified and should be appended to the list
 	  */
 	int	listViewPos;
 	/** does this entry contain binary data? */
 	bool binary;
 	/** meta data for this data item. */
 	PwMMetaData meta;
 	/** data revision counter. This counter can be used
 	  * to easily, efficiently determine if this data item
 	  * has changed since some time.
 	  * This counter is incremented on every update.
 	  */
 	unsigned int rev;
 
 	void clear(bool clearMeta = true)
 	{
 		/* NOTE: Don't use .clear() here to be
 		 *       backward compatible with gcc-2 (Debian Woody)
 		 */
 		desc = "";
 		name = "";
 		pw = "";
 		comment = "";
 		url = "";
 		launcher = "";
 		lockStat = true;
 		listViewPos = -1;
 		binary = false;
 		if (clearMeta)
 			meta.clear();
 	}
   //US ENH: we need this operator to compare two items if we have no unique ids
   //available. Generaly this happens before the first sync
 
 	bool PwMDataItem::operator==( const PwMDataItem &a ) const
 	{
 	  //qDebug("oper==%s", a.desc.c_str());
 	  if ( desc != a.desc ) return false;
 	  if ( name != a.name ) return false;
 	  if ( pw != a.pw ) return false;
 	  if ( comment != a.comment ) return false;
 	  if ( url != a.url ) return false;
 	  if ( launcher != a.launcher ) return false;
 	  //all other field will not be checked.
 	  return true;
 	}
 
   //US ENH: this sync method actually copies all values from the parameter like the =operator
   //does with two exceptions: listViewPos will not be changed, and the launcher only if required.
   bool PwMDataItem::syncItem(const PwMDataItem &a, bool syncLauncher=true )
   {
     desc = a.desc;
     name = a.name;
     pw = a.pw;
     comment = a.comment;
     url = a.url;
     if (syncLauncher == true)
       launcher = a.launcher;
     meta = a.meta;
     binary = a.binary;
     lockStat = a.lockStat;
     rev = a.rev;
 
     return true;
   }
 
 };
 
 struct PwMCategoryItem
 {
 	/** all PwMDataItems (all passwords) within this category */
 	vector<PwMDataItem>	d;
 	/** category name/description */
 	string			name;
 
 	//US ENH: enhancements of the filestructure
 	/* each category stores the text for description,name and password */
 	string  desc_text;
 	string  name_text;
 	string  pw_text;
  
 	void clear()
 	{
 		d.clear();
 		name = "";
 		desc_text = "Description";
 		name_text = "Username";
 		pw_text = "Password";
 	}
 };
 
 struct PwMSyncItem
 {
   string syncName;
   QDateTime lastSyncDate;
   
   void clear()
 	{
 		lastSyncDate = QDateTime();
 		syncName = "";
 	}
 };
 
 struct PwMItem
 {
   vector<PwMCategoryItem> dta;
   vector<PwMSyncItem> syncDta;
 
   void clear()
 	{
 		dta.clear();
 		syncDta.clear(); 
 	}
 };
 
 
 /** "Function Object" for sort()ing PwMDataItem::listViewPos */
 class dta_lvp_greater
 {
 public:
 	bool operator() (const pair<unsigned int, unsigned int> &d1,
 			 const pair<unsigned int, unsigned int> &d2)
 	{
 		return d1.second > d2.second;
 	}
 };
 
 /** list of PwMDoc documents and it's IDs */
 class PwMDocList
 {
 public:
 	struct listItem
 	{
 		/** document filename (known as ID, here) */
 		string docId;
 		/** pointer to the document class */
 		PwMDoc *doc;
 	};
 
 	PwMDocList() {}
 
 	/** add a new item to the list */
 	void add(PwMDoc *doc, const string &id);
 	/** changes the contents of an existing item */
 	void edit(PwMDoc *doc, const string &newId);
 	/** remove the given item */
 	void del(PwMDoc *doc);
 	/** get the item at index */
 	listItem getAt(int index)
 			{ return docList[index]; }
 	/** find an entry with this id */
 	bool find(const string &id, listItem *ret = 0);
 	/** returns a copy of the list */
 	const vector<listItem>* getList() const
 			{ return &docList; }
 
 
 	/** returns a new unique number to extend the name of
 	  * an unnamed document.
 	  */
 	static unsigned int getNewUnnamedNumber()
 			{ return unnamedDocCnt++; }
 
 protected:
 	/* Hm, I think we shouldn't really use a "list" here, should we?
 	 * So I decided to actually use a vector.
 	 */
 	vector<listItem> docList;
 	/** This value is used to get a new number for yet unnamed
 	  * documents. It is incremented on every request. So it's
 	  * theoretically possible to overflow it, but... :)
 	  */
 	static unsigned int unnamedDocCnt;
 };
 
 /** implements timers for the document */
 class DocTimer : public QObject
 {
 	Q_OBJECT
 public:
 	enum TimerIDs
 	{
 		id_mpwTimer,
 		id_autoLockTimer,
 		id_metaCheckTimer
 	};
 
 public:
 	DocTimer(PwMDoc *_doc);
 	~DocTimer();
 
 	/** start the timer */
 	void start(TimerIDs timer);
 	/** stop the timer */
 	void stop(TimerIDs timer);
 	/** get the lock for a timer.
 	  * This lock is a recursive lock. When a lock is
 	  * held, the timer will be stopped and timeout is
 	  * guaranteed to not happen
 	  */
 	void getLock(TimerIDs timer);
 	/** put a recursive timer lock */
 	void putLock(TimerIDs timer);
 
 protected slots:
 	/** timeout slot for the mpw timer */
 	void mpwTimeout();
 	/** timeout slot for the autoLock timer */
 	void autoLockTimeout();
 	/** timeout slot for the metaCheck timer */
 	void metaCheckTimeout();
 
 protected:
 	/** pointer to the document associated with this timer. */
 	PwMDoc *doc;
 	/** timer object for mpw timer */
 	QTimer *mpwTimer;
 	/** timer object for the autoLock timer */
 	QTimer *autoLockTimer;
 	/** timer object for the metaCheck timer */
 	QTimer *metaCheckTimer;
 	/** lock counter for the mpw timer */
 	unsigned int mpwLock;
 	/** lock counter for the autoLock timer */
 	unsigned int autoLockLock;
 	/** lock counter for the metaCheck timer */
 	unsigned int metaCheckLock;
 };
 
 /** Document class for PwM */
 //US ENH: derived from KSyncInterfaces, to get called by PwM when a sync is required.
 // But PwMDoc is handling the sync by itself.
 class PwMDoc : public PwMDocUi, public KSyncInterface
 
 {
 	Q_OBJECT
 	friend class DocTimer;
 
 public:
 	/** construtor */
 	PwMDoc(QObject* parent = 0, const char *name = 0);
 	/** destructor */
 	~PwMDoc();
 
 	/** returns a pointer to a list of all open documents */
 	static PwMDocList* getOpenDocList()
 			{ return &openDocList; }
 
 	/** flag document dirty. dta changed */
 	void flagDirty()
 		{
 			setDocStatFlag(DOC_STAT_DISK_DIRTY);
 			emitDataChanged(this);
 		}
 	/** modified? */
 	bool isDirty()
 			{ return getDocStatFlag(DOC_STAT_DISK_DIRTY); }
 	/** save document to disk */
 	PwMerror saveDoc(char compress, const QString *file = 0);
 	/** read document from file.
 	  * "openLocked is must be set to either of these values:
 	  *  0 == open with all entries unlocked
 	  *  1 == open with all entries locked
 	  *  2 == open deep-locked
 	  */
 	PwMerror openDoc(const QString *file, int openLocked);
 	/** export document to ascii-textfile */
 	PwMerror exportToText(const QString *file);
 	/** export document to gpasman / kpasman file */
 	PwMerror exportToGpasman(const QString *file);
 	/** import document from ascii-textfile */
 	PwMerror importFromText(const QString *file, int format = -1);
 	/** import document from gpasman / kpasman file */
 	PwMerror importFromGpasman(const QString *file);
 	/** add new entry */
 	PwMerror addEntry(const QString &category, PwMDataItem *d,
 			  bool dontFlagDirty = false, bool updateMeta = true);
 	/** add new category. This function doesn't flag the document dirty! */
 	PwMerror addCategory(const QString &category, unsigned int *categoryIndex,
 			     bool checkIfExist = true);
 	/** rename an existing category */
 	bool renameCategory(const QString &category, const QString &newName);
 	/** rename an existing category */
 	bool renameCategory(unsigned int category, const QString &newName,
 			    bool dontFlagDirty = false);
 	/** delete an existing category */
 	bool delCategory(const QString &category);
 	/** delete an existing category */
 	bool delCategory(unsigned int category, bool dontFlagDirty = false);
 	/** returns a list of all category-names */
 	void getCategoryList(vector<string> *list);
 	/** returns a list of all category-names */
 	void getCategoryList(QStringList *list);
 	/** returns a list of all entry-descs in the given category */
 	void getEntryList(const QString &category, QStringList *list);
 	/** returns a list of all entry-descs in the given category */
 	void getEntryList(const QString &category, vector<string> *list);
 	/** returns a list of all entry-descs in the given category */
 	void getEntryList(unsigned int category, vector<string> *list);
 	/** returns a list of all entry-descs in the given category */
 	void getEntryList(unsigned int category, QStringList *list);
 	/** delete entry */
 	bool delEntry(const QString &category, unsigned int index, bool dontFlagDirty = false);
 	/** delete entry */
 	bool delEntry(unsigned int category, unsigned int index, bool dontFlagDirty = false);
 	/** edit entry */
 	bool editEntry(const QString &oldCategory, const QString &newCategory,
 		       unsigned int index, PwMDataItem *d, bool updateMeta = true);
 	/** edit entry */
 	bool editEntry(unsigned int oldCategory, const QString &newCategory,
 		       unsigned int index, PwMDataItem *d, bool updateMeta = true);
 	/** finds the category with the "name" and return it's index */
 	bool findCategory(const QString &name, unsigned int *index);
 	/** search for an entry "find" and check while searching only for
 	  * the data-fields specified by "searchIn". To set the "searchIn"
 	  * value, we may use one or more of the SEARCH_IN_* defines at
 	  * the top of this header-file. It returns the positions of all
 	  * matched entries in "foundPositions". If "breakAfterFound" is true,
 	  * the function terminates after the first occurence of the entry
 	  * and doesn't go on searching. So foundPositions->size() is never
 	  * > 1 if breakAfterFound is true.
 	  */
 	void findEntry(unsigned int category, PwMDataItem find, unsigned int searchIn,
 		       vector<unsigned int> *foundPositions, bool breakAfterFound = false,
 		       bool caseSensitive = true, bool exactWordMatch = true,
 		       bool sortByLvp = false);
 	/** see the above funtion. This function allows to set the category by name. */
 	void findEntry(const QString &category, PwMDataItem find, unsigned int searchIn,
 		       vector<unsigned int> *foundPositions, bool breakAfterFound = false,
 		       bool caseSensitive = true, bool exactWordMatch = true,
 		       bool sortByLvp = false);
 	/** returns number of entries */
 	unsigned int numEntries(const QString &category);
 	unsigned int numEntries(unsigned int category)
 			{ return dti.dta[category].d.size(); }
 	/** returns number of categories */
 	unsigned int numCategories()
 			{ return dti.dta.size(); }
 	/** returns the name of the category at "index" */
 	const string* getCategory(unsigned int index)
 			{ return (&(dti.dta[index].name)); }
 
 	/** returns the data of item at "index".
 	  * It unlocks the entry if it's locked and unlockIfLocked is true.
 	  * If the entry is locked, but unlockIfLocked is false, it'll not return
 	  * the pw.
 	  */
 	bool getEntry(const QString &category, unsigned int index,
 		      PwMDataItem *d, bool unlockIfLocked = false);
 	bool getEntry(unsigned int category, unsigned int index,
 		      PwMDataItem *d, bool unlockIfLocked = false);
 	/** returns the comment-string by looking at the category
 	  * and the listViewPos
 	  */
 	PwMerror getCommentByLvp(const QString &category, int listViewPos,
 				 string *foundComment);
 	PwMerror getCommentByLvp_long(const QString &category, int listViewPos,
 				 string *foundComment);
 	/** checks if a password is already available. (currentPw) */
 	bool isPwAvailable()
 			{ return (currentPw != ""); }
 	/** un/lock entry at "index". If needed, ask for password. */
 	bool lockAt(const QString &category, unsigned int index,
 		    bool lock = true);
 	bool lockAt(unsigned int category, unsigned int index,
 		    bool lock = true);
 	/** returns the lock-status at "index" */
 	bool isLocked(const QString &category, unsigned int index);
 	bool isLocked(unsigned int category, unsigned int index)
 			{ return dti.dta[category].d[index].lockStat; }
 	/** returns the deeplock status */
 	bool isDeepLocked()
 			{ return getDocStatFlag(DOC_STAT_DEEPLOCKED); }
 	/** (un)lock all entries */
 	bool lockAll(bool lock);
 	/** unlocks all entries tempoarly.
 	  * 1st NOTE: Be very careful with this function! :)
 	  * 2nd NOTE: After you have called unlockAll_Tempoary(); ,
 	  *           please DON'T forget to call unlockAll_Tempoary(true);
 	  *           _before_ the user (or someone else) is able to change
 	  *           the document!
 	  * 3rd NOTE: Please DON'T change "dta" while the data is tempoary
 	  *           unlocked! This will cause corruption.
 	  */
 	bool unlockAll_tempoary(bool revert = false);
 	/** deep-(un)locks the document.
 	  * deep-locking writes all data to the file, deletes all data
 	  * in memory, but doesn't close the document.
 	  * deep-locking is only available, if the user previously saved
 	  * the doc to a file (with a password).
 	  * If "saveToFile" is false, it does NOT write the data to the file!
 	  */
 	PwMerror deepLock(bool lock = true, bool saveToFile = true);
 	/** is unlockable without pw? */
 	bool unlockWoPw()
 			{ return getDocStatFlag(DOC_STAT_UNLOCK_WITHOUT_PW); }
 	/** get the "currentPassword" */
 	const QString& getCurrentPw()
 			{ return currentPw; }
 	/** open a window and request the user to change the mpw */
 	void changeCurrentPw();
 	/** set the "listViewPos" variable of "dta" */
 	void setListViewPos(const QString &category, unsigned int index,
 			    int pos);
 	/** set the "listViewPos" variable of "dta" */
 	void setListViewPos(unsigned int category, unsigned int index,
 			    int pos);
 	/** get the "listViewPos" variable of "dta" */
 	int getListViewPos(const QString &category, unsigned int index);
 	/** set the maximum number of entries allowed */
 	void setMaxNumEntries(unsigned int num = DEFAULT_MAX_ENTRIES)
 			{ maxEntries = num; }
 	/** get the maximum number of entries allowed */
 	unsigned int getMaxNumEntries()
 			{ return maxEntries; }
 	/** ensure all listViewPos of all dta items are set. (are ! -1).
 	  * If there are some undefined entries, add them to the end of
 	  * the listViewPos(itions). */
 	void ensureLvp();
 	/** execute the "launcher" of this entry */
 	bool execLauncher(const QString &category, unsigned int entryIndex);
 	/** see above */
 	bool execLauncher(unsigned int category, unsigned int entryIndex);
 	/** open a browser with the URL-section of the given entry */
 	bool goToURL(const QString &category, unsigned int entryIndex);
 	/** see above */
 	bool goToURL(unsigned int category, unsigned int entryIndex);
 	/** returns true if there is no entry present in the document.
 	  * Note: The "default" Category is present everytime, so
 	  *       it's checked for it's entries.
 	  */
 	bool isDocEmpty()
 		{
 			if (numCategories() > 1)
 				return false;
 			if (numEntries(0))
 				return false;
 			return true;
 		}
 	/** returns the filename of this doc */
 	const QString& getFilename()
 			{ return filename; }
 	/** returns the title of the doc */
 	QString getTitle();
 	/** sets the list-view-pointer hold in the doc */
 	void setListViewPointer(PwMView *_listView)
 			{ listView = _listView; }
 	/** returns the list-view-pointer */
 	PwMView * getListViewPointer()
 			{ return listView; }
 	/** try to delete the doc. The user may be asked to save
 	  * the data. The user may cancel the whole operation.
 	  * false is returned, then.
 	  */
 	bool tryDelete();
 	/** is the doc deleted? (with tryDelete() ) */
 	bool isDeleted()
 			{ return deleted; }
 	/** returns the document timer object */
 	DocTimer * timer()
 			{ return _timer; }
 	/** get a lock on the dataChanged signal.
 	  * If someone is holding a lock, the signal is not emitted.
 	  */
 	void getDataChangedLock()
 			{ ++dataChangedLock; }
 	/** put the dataChanged lock */
 	void putDataChangedLock()
 			{ --dataChangedLock; }
 	/** returns the revision count of the item at cat/index */
 	unsigned int getEntryRevCnt(unsigned int category, unsigned int index)
 			{ return dti.dta[category].d[index].rev; }
 	/** returns a const pointer to the entries meta */
 	const PwMMetaData * getEntryMeta(unsigned int category, unsigned int index)
 			{ return &(dti.dta[category].d[index].meta); }
 	/** is the entry at "category" "index" a binary entry? */
 	bool isBinEntry(unsigned int category, unsigned int index)
 			{ return dti.dta[category].d[index].binary; }
 
 public slots:
 	/** wrapper for PwMTray */
 	void _deepUnlock();
 
 signals:
 	/** the data of the document has changed and must be updated
 	  * in all views.
 	  * NOTE: use emitDataChanged(PwMDoc *document) to emit this signal!
 	  */
 	void dataChanged(PwMDoc *document);
 	/** the document class is going to close. This signal may be
 	  * used to nofify all views, that the user closed the document,
 	  * so the views can go down, too.
 	  */
 	void docClosed(PwMDoc *document);
 	/** somebody just opened the document */
 	void docOpened(PwMDoc *document);
 	/** this document object just got created */
 	void docCreated(PwMDoc *document);
 
 public:
 	/** emit the dataChanged signal after checking for a lock */
 	void emitDataChanged(PwMDoc *document)
 		{
 			if (!dataChangedLock)
 				emit dataChanged(document);
 		}
 
 protected:
 	/** current file for this doc */
 	QString filename;
 //US ENH: we need a place where we keep the syncentries. So I invented
 // struct PwMItem, that has a vector of PwMCategoryItem and vector of PwMSyncItem 
 	/** holds all data */
 	PwMItem dti;
 	/** maximum number of entries */
 	unsigned int maxEntries;
 	/** currently used password to encrypt data */
 	QString currentPw;
 	/** current global document status flags */
 	unsigned int curDocStat;
 	/** browser process for goToURL() */
 	KProcess browserProc;
 	/** pointer to the list-view, using this document.
 	  * As there can only be one list-view per doc, we
 	  * don't need a list here.
 	  */
 	PwMView *listView;
 	/** unnamedNum is used to store the "unnamed counter"
 	  * for this document, while it's unnamed. If it's 0,
 	  * we have to get a new unique one.
 	  */
 	unsigned int unnamedNum;
 	/** is this doc going to be deleted (executing in destructor context) */
 	bool deleted;
 	/** document timer */
 	DocTimer *_timer;
 	/** lock counter for the "dataChanged" signal */
 	unsigned int dataChangedLock;
 
 	/** list of all open documents */
 	static PwMDocList openDocList;
 
 protected:
 	/** serialize "dta" and return it in "d". */
 	bool serializeDta(string *d);
 	/** de-serialize "d" and overwrite "dta" */
 	bool deSerializeDta(const string *d, bool entriesLocked);
 	/** write header to file */
 	PwMerror writeFileHeader(char keyHash, char dataHash, char crypt, char compress,
 				 QString *pw, QFile *f);
 	/** write data-hash to file */
 	PwMerror writeDataHash(char dataHash, string *d, QFile *f);
 	/** check header. Read header info and verify key-hash and filever.
 	  * returns length of header in "headerLength" */
 	PwMerror checkHeader(char *cryptAlgo, QString *pw, char *compress,
 			     unsigned int *headerLength, char *dataHashType,
 			     string *dataHash, QFile *f);
 	/** check the data-hash */
 	PwMerror checkDataHash(char dataHashType, const string *dataHash, const string *dataStream);
 	/** encrypt data "d" and write to "filename" */
 	PwMerror encrypt(string *d, const QString *pw, QFile *f, char algo,
 				 char _hashalgo //US BUG: pass _hashalgo because we need it in hashPassphrase
 );
 	/** read data from file beginning at "pos", decrypt and return it */
 	PwMerror decrypt(string *d, unsigned int pos, const QString *pw, char algo, 
 		 char _hashalgo, //US BUG: pass _hashalgo because we need it in hashPassphrase
 QFile *f);
 	/** compress the data */
 	bool compressDta(string *d, char algo);
 	/** uncompress the data */
 	bool decompressDta(string *d, char algo);
 	/** internal import function for a text-file generated by PwM.
 	  * If this is not a valid PwM-exported file, it returns e_fileFormat */
 	PwMerror importText_PwM(const QString *file);
 	/** PwM-text-import helper function to extract the name/pw/comment out
 	  * of one entry-line */
 	bool textExtractEntry_PwM(const char *in, ssize_t in_size, string *out);
 	/** compare two strings */
 	bool compareString(const string &s1, const string &s2, bool caseSensitive,
 			   bool exactWordMatch);
 	/** clears all document-data */
 	void clearDoc();
 	/** delete all empty categories */
 	void delAllEmptyCat(bool dontFlagDirty);
 	/** set a document status flag */
 	void setDocStatFlag(unsigned int statFlag)
 			{ curDocStat |= statFlag; }
 	/** unset a document status flag */
 	void unsetDocStatFlag(unsigned int statFlag)
 			{ curDocStat &= ~statFlag; }
 	/** get a document status flag */
 	bool getDocStatFlag(unsigned int statFlag) const
 			{ return (curDocStat & statFlag); }
 	/** set the "currentPassword" */
 	void setCurrentPw(const QString &pw)
 		{
 			currentPw = pw;
 			setDocStatFlag(DOC_STAT_DISK_DIRTY);
 		}
 	/** make a backup-copy of the given file */
 	bool backupFile(const QString &filePath);
 	/** copy a file from src to dst */
 	bool copyFile(const QString &src, const QString &dst);
 
 
  public:
 #ifdef PWM_EMBEDDED
 	//US ENH: this is the magic function that syncronizes the local doc with the remote doc.
 	PwMerror syncronize(KSyncManager* manager, PwMDoc* syncLocal, PwMDoc* syncRemote, int mode );
 
 	//takePwMDataItem returns the following values
 	// 0 equal
 	// 1 take local
 	// 2 take remote
 	// 3 cancel 
 	int takePwMDataItem( PwMDataItem* local,  PwMDataItem* remote, QDateTime lastSync, int mode , bool full );
 
 	//the following methods are the overwritten callbackmethods from the syncinterface
-	virtual bool sync(KSyncManager* manager, QString filename, int mode);
+	virtual bool sync(KSyncManager* manager, QString filename, int mode, QString resource);
     virtual void removeSyncInfo( QString syncProfile);
 
 #endif
 	//US ENH: helpermethods to return a whole category entry
 	/** returns a pointer to the categoryitem */
 	PwMCategoryItem* getCategoryEntry(unsigned int index)
 			{ return &(dti.dta[index]); }
 
  private:
 	//US ENH: helpermethods to access the sync data for a certain syncname.
 	// It returns the syncdatas index
 	bool findSyncData(const QString &syncname, unsigned int *index);
 
 	/** add new syncdataentry */
 	PwMerror addSyncDataEntry(PwMSyncItem *d, bool dontFlagDirty = false);
 
 	/** returns a pointer to the syncdata */
 	PwMSyncItem* getSyncDataEntry(unsigned int index)
 			{ return &(dti.syncDta[index]); }
 
 	/** delete entry */
 	bool delSyncDataEntry(unsigned int index, bool dontFlagDirty = false);
 
 	/** returns number of categories */
 	unsigned int numSyncDataEntries()
 			{ return dti.syncDta.size(); }
 
 	PwMDataItem* findEntryByID(const QString &uid, unsigned int *category, unsigned int *index);
 
 	QStringList getIDEntryList(); 
 
 };
 
 #endif