*** empty log message ***

9 files changed, 746 insertions, 109 deletions

diff --git a/pwmanager/pwmanager/pwmanagerE.pro b/pwmanager/pwmanager/pwmanagerE.pro
index 2558aca..95f5bf3 100644
--- a/pwmanager/pwmanager/pwmanagerE.pro
+++ b/pwmanager/pwmanager/pwmanagerE.pro
@@ -4,13 +4,13 @@ CONFIG		+= qt warn_on
 
 TARGET		= pwmpi
 OBJECTS_DIR = obj/$(PLATFORM)
 MOC_DIR = moc/$(PLATFORM)
 DESTDIR=$(QPEDIR)/bin
 
-INCLUDEPATH += . ../../qtcompat ../../qtcompat/xml ../../libkdepim ../../microkde ../../microkde/kdecore ../../microkde/kdeui ../../microkde/kutils $(QPEDIR)/include
+INCLUDEPATH += . ../../ ../../qtcompat ../../qtcompat/xml ../../libkdepim ../../microkde ../../microkde/kdecore ../../microkde/kdeui ../../microkde/kutils $(QPEDIR)/include
 DEFINES += PWM_EMBEDDED
 #enable this setting if you want debugoutput for pwmanager
 #DEFINES += CONFIG_DEBUG
 
 LIBS += -lmicrokde
 LIBS += -lmicroqtcompat
diff --git a/pwmanager/pwmanager/pwmdoc.cpp b/pwmanager/pwmanager/pwmdoc.cpp
index 82fc746..4e8a603 100644
--- a/pwmanager/pwmanager/pwmdoc.cpp
+++ b/pwmanager/pwmanager/pwmdoc.cpp
@@ -32,12 +32,16 @@
 //US #include "libgryptif.h"
 #else
 #include "pwmprefs.h"
 #include "kglobal.h"
 #endif
 
+#include <kmessagebox.h>
+#include <libkcal/syncdefines.h>
+
+
 #ifdef CONFIG_KWALLETIF
 # include "kwalletemu.h"
 #endif // CONFIG_KWALLETIF
 
 #include <qdatetime.h>
 #include <qsize.h>
@@ -1004,13 +1008,13 @@ PwMerror PwMDoc::addEntry(const QString &category, PwMDataItem *d,
 	d->listViewPos = -1;
 	d->lockStat = conf()->confGlobNewEntrLockStat();
 	if (updateMeta) {
 		d->meta.create = QDateTime::currentDateTime();
 		d->meta.update = d->meta.create;
 	}
-	dta[cat].d.push_back(*d);
+	dti.dta[cat].d.push_back(*d);
 
 	delAllEmptyCat(true);
 
 	if (!dontFlagDirty)
 		flagDirty();
 	return e_success;
@@ -1028,15 +1032,15 @@ PwMerror PwMDoc::addCategory(const QString &category, unsigned int *categoryInde
 	if (checkIfExist) {
 		if (findCategory(category, categoryIndex))
 			return e_categoryExists;
 	}
 	PwMCategoryItem item;
 	item.name = category.latin1();
-	dta.push_back(item);
+	dti.dta.push_back(item);
 	if (categoryIndex)
-		*categoryIndex = dta.size() - 1;
+		*categoryIndex = dti.dta.size() - 1;
 	return e_success;
 }
 
 bool PwMDoc::delEntry(const QString &category, unsigned int index, bool dontFlagDirty)
 {
 	unsigned int cat = 0;
@@ -1050,37 +1054,37 @@ bool PwMDoc::delEntry(const QString &category, unsigned int index, bool dontFlag
 }
 
 bool PwMDoc::delEntry(unsigned int category, unsigned int index, bool dontFlagDirty)
 {
 	if (isDeepLocked())
 		return false;
-	if (index > dta[category].d.size() - 1)
+	if (index > dti.dta[category].d.size() - 1)
 		return false;
 	getDataChangedLock();
 	if (!lockAt(category, index, false)) {
 		putDataChangedLock();
 		return false;
 	}
 	putDataChangedLock();
-	int lvPos = dta[category].d[index].listViewPos;
+	int lvPos = dti.dta[category].d[index].listViewPos;
 
 	// delete entry
-	dta[category].d.erase(dta[category].d.begin() + index);
+	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 (dta[category].d[i].listViewPos > lvPos)
-			--dta[category].d[i].listViewPos;
+		if (dti.dta[category].d[i].listViewPos > lvPos)
+			--dti.dta[category].d[i].listViewPos;
 	}
 
 	if (!dontFlagDirty)
 		flagDirty();
 	return true;
 }
@@ -1107,24 +1111,24 @@ bool PwMDoc::editEntry(unsigned int oldCategory, const QString &newCategory,
 	if (updateMeta) {
 		d->meta.update = QDateTime::currentDateTime();
 		if (d->meta.create.isNull()) {
 			d->meta.create = d->meta.update;
 		}
 	}
-	if (dta[oldCategory].name != newCategory.latin1()) {
+	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 = dta[oldCategory].d[index].rev + 1; // increment revision counter.
-		dta[oldCategory].d[index] = *d;
+		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)
@@ -1140,13 +1144,13 @@ unsigned int PwMDoc::numEntries(const QString &category)
 }
 
 bool PwMDoc::serializeDta(string *d)
 {
 	PWM_ASSERT(d);
 	Serializer ser;
-	if (!ser.serialize(dta))
+	if (!ser.serialize(dti))
 		return false;
 	d->assign(ser.getXml());
 	if (!d->size())
 		return false;
 	return true;
 }
@@ -1156,21 +1160,21 @@ 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(&dta))
+		if (!ser.deSerialize(&dti))
 			return false;
 	} catch (PwMException) {
 		return false;
 	}
 #else
 	Serializer ser(d->c_str());
 	ser.setDefaultLockStat(entriesLocked);
-	if (!ser.deSerialize(&dta))
+	if (!ser.deSerialize(&dti))
 	  return false;
 #endif
 
 	emitDataChanged(this);
 	return true;
 }
@@ -1189,13 +1193,13 @@ bool PwMDoc::getEntry(const QString &category, unsigned int index,
 	return getEntry(cat, index, d, unlockIfLocked);
 }
 
 bool PwMDoc::getEntry(unsigned int category, unsigned int index,
 		      PwMDataItem *d, bool unlockIfLocked)
 {
-	if (index > dta[category].d.size() - 1)
+	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
@@ -1206,13 +1210,13 @@ bool PwMDoc::getEntry(unsigned int category, unsigned int index,
 				return false;
 			}
 			locked = false;
 		}
 	}
 
-	*d = dta[category].d[index];
+	*d = dti.dta[category].d[index];
 	if (locked)
 		d->pw = LOCKED_STRING.latin1();
 
 	return true;
 }
 
@@ -1224,15 +1228,15 @@ PwMerror PwMDoc::getCommentByLvp(const QString &category, int listViewPos,
 
 	if (!findCategory(category, &cat))
 		return e_invalidArg;
 
 	unsigned int i, entries = numEntries(cat);
 	for (i = 0; i < entries; ++i) {
-		if (dta[cat].d[i].listViewPos == listViewPos) {
-			*foundComment = dta[cat].d[i].comment;
-			if (dta[cat].d[i].binary)
+		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;
@@ -1487,13 +1491,13 @@ bool PwMDoc::lockAt(unsigned int category, unsigned int index,
 		    bool lock)
 {
 	if (index >= numEntries(category)) {
 		BUG();
 		return false;
 	}
-	if (lock == dta[category].d[index].lockStat)
+	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
@@ -1511,14 +1515,14 @@ bool PwMDoc::lockAt(unsigned int category, unsigned int index,
 			}
 		} else {
 			timer()->start(DocTimer::id_mpwTimer);
 		}
 	}
 
-	dta[category].d[index].lockStat = lock;
-	dta[category].d[index].rev++; // increment revision counter.
+	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;
@@ -1568,14 +1572,14 @@ bool PwMDoc::lockAll(bool lock)
 			}
 		} else {
 			timer()->start(DocTimer::id_mpwTimer);
 		}
 	}
 
-	vector<PwMCategoryItem>::iterator catBegin = dta.begin(),
-					  catEnd = dta.end(),
+	vector<PwMCategoryItem>::iterator catBegin = dti.dta.begin(),
+					  catEnd = dti.dta.end(),
 					  catI = catBegin;
 	vector<PwMDataItem>::iterator entrBegin, entrEnd, entrI;
 	while (catI != catEnd) {
 		entrBegin = catI->d.begin();
 		entrEnd = catI->d.end();
 		entrI = entrBegin;
@@ -1642,14 +1646,14 @@ bool PwMDoc::unlockAll_tempoary(bool revert)
 				 */
 				BUG();
 				delete_and_null(oldLockStates);
 				timer()->start(DocTimer::id_autoLockTimer);
 				return false;
 			}
-			vector<PwMCategoryItem>::iterator catBegin = dta.begin(),
-							  catEnd = dta.end(),
+			vector<PwMCategoryItem>::iterator catBegin = dti.dta.begin(),
+							  catEnd = dti.dta.end(),
 							  catI = catBegin;
 			vector<PwMDataItem>::iterator entrBegin, entrEnd, entrI;
 			vector< vector<bool> >::iterator oldCatStatI = oldLockStates->begin();
 			vector<bool>::iterator oldEntrStatBegin,
 					       oldEntrStatEnd,
 					       oldEntrStatI;
@@ -1726,14 +1730,14 @@ bool PwMDoc::unlockAll_tempoary(bool revert)
 				}
 			}
 			wasDeepLocked = true;
 			mustUnlock = true;
 		} else {
 			// first check if it's needed to unlock some entries
-			vector<PwMCategoryItem>::iterator catBegin = dta.begin(),
-							  catEnd = dta.end(),
+			vector<PwMCategoryItem>::iterator catBegin = dti.dta.begin(),
+							  catEnd = dti.dta.end(),
 							  catI = catBegin;
 			vector<PwMDataItem>::iterator entrBegin, entrEnd, entrI;
 			while (catI != catEnd) {
 				entrBegin = catI->d.begin();
 				entrEnd = catI->d.end();
 				entrI = entrBegin;
@@ -1772,14 +1776,14 @@ bool PwMDoc::unlockAll_tempoary(bool revert)
 				}
 			}
 		}
 		timer()->stop(DocTimer::id_autoLockTimer);
 		oldLockStates = new vector< vector<bool> >;
 		vector<bool> tmp_vec;
-		vector<PwMCategoryItem>::iterator catBegin = dta.begin(),
-						  catEnd = dta.end(),
+		vector<PwMCategoryItem>::iterator catBegin = dti.dta.begin(),
+						  catEnd = dti.dta.end(),
 						  catI = catBegin;
 		vector<PwMDataItem>::iterator entrBegin, entrEnd, entrI;
 		while (catI != catEnd) {
 			entrBegin = catI->d.begin();
 			entrEnd = catI->d.end();
 			entrI = entrBegin;
@@ -1857,16 +1861,16 @@ void PwMDoc::_deepUnlock()
 {
 	deepLock(false);
 }
 
 void PwMDoc::clearDoc()
 {
-	dta.clear();
+	dti.clear();
 	PwMCategoryItem d;
 	d.name = DEFAULT_CATEGORY.latin1();
-	dta.push_back(d);
+	dti.dta.push_back(d);
 	currentPw = "";
 	unsetDocStatFlag(DOC_STAT_UNLOCK_WITHOUT_PW);
 }
 
 void PwMDoc::changeCurrentPw()
 {
@@ -1895,13 +1899,13 @@ void PwMDoc::setListViewPos(const QString &category, unsigned int index,
 	setListViewPos(cat, index, pos);
 }
 
 void PwMDoc::setListViewPos(unsigned int category, unsigned int index,
 			    int pos)
 {
-	dta[category].d[index].listViewPos = pos;
+	dti.dta[category].d[index].listViewPos = pos;
 
 /* FIXME workaround: don't flag dirty, because this function sometimes
  * get's called when it shouldn't. It's because PwMView assumes
  * the user resorted the UI on behalf of signal layoutChanged().
  * This is somewhat broken and incorrect, but I've no other
  * solution for now.
@@ -1915,13 +1919,13 @@ int PwMDoc::getListViewPos(const QString &category, unsigned int index)
 
 	if (!findCategory(category, &cat)) {
 		BUG();
 		return -1;
 	}
 
-	return dta[cat].d[index].listViewPos;
+	return dti.dta[cat].d[index].listViewPos;
 }
 
 void PwMDoc::findEntry(unsigned int category, PwMDataItem find, unsigned int searchIn,
 		       vector<unsigned int> *foundPositions, bool breakAfterFound,
 		       bool caseSensitive, bool exactWordMatch, bool sortByLvp)
 {
@@ -1929,50 +1933,50 @@ void PwMDoc::findEntry(unsigned int category, PwMDataItem find, unsigned int sea
 	PWM_ASSERT(searchIn);
 	foundPositions->clear();
 
 	unsigned int i, entries = numEntries(category);
 	for (i = 0; i < entries; ++i) {
 		if (searchIn & SEARCH_IN_DESC) {
-			if (!compareString(find.desc, dta[category].d[i].desc,
+			if (!compareString(find.desc, dti.dta[category].d[i].desc,
 					  caseSensitive, exactWordMatch)) {
 				continue;
 			}
 		}
 		if (searchIn & SEARCH_IN_NAME) {
-			if (!compareString(find.name, dta[category].d[i].name,
+			if (!compareString(find.name, dti.dta[category].d[i].name,
 					  caseSensitive, exactWordMatch)) {
 				continue;
 			}
 		}
 		if (searchIn & SEARCH_IN_PW) {
 			bool wasLocked = isLocked(category, i);
 			getDataChangedLock();
 			lockAt(category, i, false);
-			if (!compareString(find.pw, dta[category].d[i].pw,
+			if (!compareString(find.pw, dti.dta[category].d[i].pw,
 					  caseSensitive, exactWordMatch)) {
 				lockAt(category, i, wasLocked);
 				putDataChangedLock();
 				continue;
 			}
 			lockAt(category, i, wasLocked);
 			putDataChangedLock();
 		}
 		if (searchIn & SEARCH_IN_COMMENT) {
-			if (!compareString(find.comment, dta[category].d[i].comment,
+			if (!compareString(find.comment, dti.dta[category].d[i].comment,
 					  caseSensitive, exactWordMatch)) {
 				continue;
 			}
 		}
 		if (searchIn & SEARCH_IN_URL) {
-			if (!compareString(find.url, dta[category].d[i].url,
+			if (!compareString(find.url, dti.dta[category].d[i].url,
 					  caseSensitive, exactWordMatch)) {
 				continue;
 			}
 		}
 		if (searchIn & SEARCH_IN_LAUNCHER) {
-			if (!compareString(find.launcher, dta[category].d[i].launcher,
+			if (!compareString(find.launcher, dti.dta[category].d[i].launcher,
 					  caseSensitive, exactWordMatch)) {
 				continue;
 			}
 		}
 
 		// all selected "searchIn" matched.
@@ -1986,13 +1990,13 @@ void PwMDoc::findEntry(unsigned int category, PwMDataItem find, unsigned int sea
 			     unsigned int /* lvp-pos */> > tmp_vec;
 		
 		unsigned int i, items = foundPositions->size();
 		pair<unsigned int, unsigned int> tmp_pair;
 		for (i = 0; i < items; ++i) {
 			tmp_pair.first = (*foundPositions)[i];
-			tmp_pair.second = dta[category].d[(*foundPositions)[i]].listViewPos;
+			tmp_pair.second = dti.dta[category].d[(*foundPositions)[i]].listViewPos;
 			tmp_vec.push_back(tmp_pair);
 		}
 		sort(tmp_vec.begin(), tmp_vec.end(), dta_lvp_greater());
 		foundPositions->clear();
 		for (i = 0; i < items; ++i) {
 			foundPositions->push_back(tmp_vec[i].first);
@@ -2029,18 +2033,18 @@ bool PwMDoc::compareString(const string &s1, const string &s2, bool caseSensitiv
 		return true;
 	return false;
 }
 
 bool PwMDoc::findCategory(const QString &name, unsigned int *index)
 {
-	vector<PwMCategoryItem>::iterator i = dta.begin(),
-					  end = dta.end();
+	vector<PwMCategoryItem>::iterator i = dti.dta.begin(),
+					  end = dti.dta.end();
 	while (i != end) {
 		if ((*i).name == name.latin1()) {
 			if (index) {
-				*index = i - dta.begin();
+				*index = i - dti.dta.begin();
 			}
 			return true;
 		}
 		++i;
 	}
 	return false;
@@ -2059,13 +2063,13 @@ bool PwMDoc::renameCategory(const QString &category, const QString &newName)
 bool PwMDoc::renameCategory(unsigned int category, const QString &newName,
 			    bool dontFlagDirty)
 {
 	if (category > numCategories() - 1)
 		return false;
 
-	dta[category].name = newName.latin1();
+	dti.dta[category].name = newName.latin1();
 	if (!dontFlagDirty)
 		flagDirty();
 
 	return true;
 }
 
@@ -2084,27 +2088,27 @@ bool PwMDoc::delCategory(unsigned int category, bool dontFlagDirty)
 	if (category > numCategories() - 1)
 		return false;
 
 	// We don't delete it, if it is the last existing
 	// category! Instead we rename it to "Default".
 	if (numCategories() > 1) {
-		dta.erase(dta.begin() + category);
+		dti.dta.erase(dti.dta.begin() + category);
 	} else {
 		renameCategory(category, DEFAULT_CATEGORY, dontFlagDirty);
 		return true;
 	}
 	if (!dontFlagDirty)
 		flagDirty();
 
 	return true;
 }
 
 void PwMDoc::delAllEmptyCat(bool dontFlagDirty)
 {
-	vector<PwMCategoryItem>::iterator begin = dta.begin(),
-					  end = dta.end(),
+	vector<PwMCategoryItem>::iterator begin = dti.dta.begin(),
+					  end = dti.dta.end(),
 					  i = begin;
 	while (i != end) {
 		if (i->d.empty()) {
 			delCategory(begin - i, dontFlagDirty);
 		}
 		++i;
@@ -2112,26 +2116,26 @@ void PwMDoc::delAllEmptyCat(bool dontFlagDirty)
 }
 
 void PwMDoc::getCategoryList(vector<string> *list)
 {
 	PWM_ASSERT(list);
 	list->clear();
-	vector<PwMCategoryItem>::iterator i = dta.begin(),
-					  end = dta.end();
+	vector<PwMCategoryItem>::iterator i = dti.dta.begin(),
+					  end = dti.dta.end();
 	while (i != end) {
 		list->push_back(i->name);
 		++i;
 	}
 }
 
 void PwMDoc::getCategoryList(QStringList *list)
 {
 	PWM_ASSERT(list);
 	list->clear();
-	vector<PwMCategoryItem>::iterator i = dta.begin(),
-					  end = dta.end();
+	vector<PwMCategoryItem>::iterator i = dti.dta.begin(),
+					  end = dti.dta.end();
 	while (i != end) {
 #ifndef PWM_EMBEDDED
 		list->push_back(i->name.c_str());
 #else
 		list->append(i->name.c_str());
 #endif
@@ -2162,27 +2166,27 @@ void PwMDoc::getEntryList(const QString &category, vector<string> *list)
 }
 
 void PwMDoc::getEntryList(unsigned int category, vector<string> *list)
 {
 	PWM_ASSERT(list);
 	list->clear();
-	vector<PwMDataItem>::iterator begin = dta[category].d.begin(),
-				      end = dta[category].d.end(),
+	vector<PwMDataItem>::iterator begin = dti.dta[category].d.begin(),
+				      end = dti.dta[category].d.end(),
 				      i = begin;
 	while (i != end) {
 		list->push_back(i->desc);
 		++i;
 	}
 }
 
 void PwMDoc::getEntryList(unsigned int category, QStringList *list)
 {
 	PWM_ASSERT(list);
 	list->clear();
-	vector<PwMDataItem>::iterator begin = dta[category].d.begin(),
-				      end = dta[category].d.end(),
+	vector<PwMDataItem>::iterator begin = dti.dta[category].d.begin(),
+				      end = dti.dta[category].d.end(),
 				      i = begin;
 	while (i != end) {
 #ifndef PWM_EMBEDDED
 		list->push_back(i->desc.c_str());
 #else
 		list->append(i->desc.c_str());
@@ -2204,35 +2208,35 @@ bool PwMDoc::execLauncher(const QString &category, unsigned int entryIndex)
 bool PwMDoc::execLauncher(unsigned int category, unsigned int entryIndex)
 {
 	if (geteuid() == 0) {
 		rootAlertMsgBox();
 		return false;
 	}
-	QString command(dta[category].d[entryIndex].launcher.c_str());
+	QString command(dti.dta[category].d[entryIndex].launcher.c_str());
 	bool wasLocked = isLocked(category, entryIndex);
 
 	if (command.find("$p") != -1) {
 		/* the user requested the password to be included
 		 * into the command. We have to ask for the password,
 		 * if it's locked. We do that by unlocking the entry
 		 */
 		if (!lockAt(category, entryIndex, false))
 			return false;
 	}
 #ifndef PWM_EMBEDDED
-	command.replace("$d", dta[category].d[entryIndex].desc.c_str());
-	command.replace("$n", dta[category].d[entryIndex].name.c_str());
-	command.replace("$p", dta[category].d[entryIndex].pw.c_str());
-	command.replace("$u", dta[category].d[entryIndex].url.c_str());
-	command.replace("$c", dta[category].d[entryIndex].comment.c_str());
+	command.replace("$d", dti.dta[category].d[entryIndex].desc.c_str());
+	command.replace("$n", dti.dta[category].d[entryIndex].name.c_str());
+	command.replace("$p", dti.dta[category].d[entryIndex].pw.c_str());
+	command.replace("$u", dti.dta[category].d[entryIndex].url.c_str());
+	command.replace("$c", dti.dta[category].d[entryIndex].comment.c_str());
 #else
-	command.replace(QRegExp("$d"), dta[category].d[entryIndex].desc.c_str());
-	command.replace(QRegExp("$n"), dta[category].d[entryIndex].name.c_str());
-	command.replace(QRegExp("$p"), dta[category].d[entryIndex].pw.c_str());
-	command.replace(QRegExp("$u"), dta[category].d[entryIndex].url.c_str());
-	command.replace(QRegExp("$c"), dta[category].d[entryIndex].comment.c_str());
+	command.replace(QRegExp("$d"), dti.dta[category].d[entryIndex].desc.c_str());
+	command.replace(QRegExp("$n"), dti.dta[category].d[entryIndex].name.c_str());
+	command.replace(QRegExp("$p"), dti.dta[category].d[entryIndex].pw.c_str());
+	command.replace(QRegExp("$u"), dti.dta[category].d[entryIndex].url.c_str());
+	command.replace(QRegExp("$c"), dti.dta[category].d[entryIndex].comment.c_str());
 #endif
 	command.append(" &");
 
 	QString customXterm(conf()->confGlobXtermCommand());
 	if (!customXterm.isEmpty())
 		command = customXterm + " " + command;
@@ -2256,13 +2260,13 @@ bool PwMDoc::goToURL(const QString &category, unsigned int entryIndex)
 bool PwMDoc::goToURL(unsigned int category, unsigned int entryIndex)
 {
 	if (geteuid() == 0) {
 		rootAlertMsgBox();
 		return false;
 	}
-	QString url(dta[category].d[entryIndex].url.c_str());
+	QString url(dti.dta[category].d[entryIndex].url.c_str());
 	if (url.isEmpty())
 		return false;
 
 	QString customBrowser(conf()->confGlobBrowserCommand());
 	if (!customBrowser.isEmpty()) {
 		browserProc.clearArguments();
@@ -2347,13 +2351,13 @@ PwMerror PwMDoc::exportToText(const QString *file)
 	unsigned int j, numEnt;
 	string exp;
 	for (i = 0; i < numCat; ++i) {
 		numEnt = numEntries(i);
 
 		exp = "\n== Category: ";
-		exp += dta[i].name;
+		exp += dti.dta[i].name;
 		exp += " ==\n";
 #ifndef PWM_EMBEDDED
 		if (f.writeBlock(exp.c_str(), exp.length()) != (Q_LONG)exp.length()) {
 				unlockAll_tempoary(true);
 				f.close();
 				return e_writeFile;
@@ -2364,33 +2368,33 @@ PwMerror PwMDoc::exportToText(const QString *file)
 				f.close();
 				return e_writeFile;
 		}
 #endif
 		for (j = 0; j < numEnt; ++j) {
 			exp = "\n-- ";
-			exp += dta[i].d[j].desc;
+			exp += dti.dta[i].d[j].desc;
 			exp += " --\n";
 
 			exp += i18n("Username: ").latin1();
-			exp += dta[i].d[j].name;
+			exp += dti.dta[i].d[j].name;
 			exp += "\n";
 
 			exp += i18n("Password: ").latin1();
-			exp += dta[i].d[j].pw;
+			exp += dti.dta[i].d[j].pw;
 			exp += "\n";
 
 			exp += i18n("Comment: ").latin1();
-			exp += dta[i].d[j].comment;
+			exp += dti.dta[i].d[j].comment;
 			exp += "\n";
 
 			exp += i18n("URL: ").latin1();
-			exp += dta[i].d[j].url;
+			exp += dti.dta[i].d[j].url;
 			exp += "\n";
 
 			exp += i18n("Launcher: ").latin1();
-			exp += dta[i].d[j].launcher;
+			exp += dti.dta[i].d[j].launcher;
 			exp += "\n";
 
 #ifndef PWM_EMBEDDED
 			if (f.writeBlock(exp.c_str(), exp.length()) != (Q_LONG)exp.length()) {
 				unlockAll_tempoary(true);
 				f.close();
@@ -2417,13 +2421,13 @@ PwMerror PwMDoc::importFromText(const QString *file, int format)
 	if (format == 0)
 		return importText_PwM(file);
 	else if (format == -1) {
 		// probe for all formats
 		if (importText_PwM(file) == e_success)
 			return e_success;
-		dta.clear();
+		dti.clear();
 		emitDataChanged(this);
 		// add next format here...
 		return e_fileFormat;
 	}
 	return e_invalidArg;
 }
@@ -2611,24 +2615,24 @@ PwMerror PwMDoc::exportToGpasman(const QString *file)
 	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 = dta[i].d[j].desc.length();
-			nameLen = dta[i].d[j].name.length();
-			pwLen = dta[i].d[j].pw.length();
-			commentLen = dta[i].d[j].comment.length();
+			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 ? " " : dta[i].d[j].desc.c_str());
-			strcpy(entry[1], nameLen == 0 ? " " : dta[i].d[j].name.c_str());
-			strcpy(entry[2], pwLen == 0 ? " " : dta[i].d[j].pw.c_str());
-			strcpy(entry[3], commentLen == 0 ? " " : dta[i].d[j].comment.c_str());
+			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);
@@ -2702,14 +2706,14 @@ void PwMDoc::ensureLvp()
 		return;
 
 	vector< vector<PwMDataItem>::iterator > undefined;
 	vector< vector<PwMDataItem>::iterator >::iterator undefBegin,
 							  undefEnd,
 							  undefI;
-	vector<PwMCategoryItem>::iterator catBegin = dta.begin(),
-					  catEnd = dta.end(),
+	vector<PwMCategoryItem>::iterator catBegin = dti.dta.begin(),
+					  catEnd = dti.dta.end(),
 					  catI = catBegin;
 	vector<PwMDataItem>::iterator entrBegin, entrEnd, entrI;
 	int lvpTop, tmpLvp;
 
 	while (catI != catEnd) {
 		lvpTop = -1;
@@ -2782,37 +2786,311 @@ out_ignore:
 }
 
 
 
 #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 )
 {
-  bool syncOK = true;
   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;
+      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 %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;
+      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); 
+  //and remove the found entry here. We will reenter it later again.
+  syncRemote->delSyncDataEntry(index, true);
 
 
+  if ( syncItemLocal->lastSyncDate == mLastSync ) {
+    qDebug("FULLDATE 2");
+    fullDateRange = true;
+  }
+  
+  if ( ! fullDateRange  ) {
+        if ( syncItemLocal->lastSyncDate != syncItemRemote->lastSyncDate ) {
+            
+            // qDebug("set fulldate to true %s %s" ,addresseeLSync->dtStart().toString().latin1(), addresseeRSync->dtStart().toString().latin1() ); 
+            //qDebug("%d %d %d %d ", addresseeLSync->dtStart().time().second(), addresseeLSync->dtStart().time().msec() , addresseeRSync->dtStart().time().second(), addresseeRSync->dtStart().time().msec());
+            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("mLastAddressbookSync %s ",mLastAddressbookSync.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 ]; 
+        qApp->processEvents();
+
+            inLocal = syncLocal->findEntryByID( uid, &catLocal, &indexLocal );
+            inRemote = syncRemote->findEntryByID( uid, &catRemote, &indexRemote );
+            if ( inLocal != 0 ) { // maybe conflict - same uid in both files
+                if ( (take = takePwMDataItem( inLocal, inRemote, mLastSync, mode, fullDateRange) ) ) {
+                    //qDebug("take %d %s ", take, inL.summary().latin1());
+                    if ( take == 3 )
+                        return e_syncError;
+                    if ( take == 1  ) {// take local
+		        //US                        syncRemote->removeAddressee( inRemote );
+                        (*inRemote) = (*inLocal);
+			//US                        syncRemote->insertAddressee(  inRemote , false);
+                        ++changedRemote;
+                    } else { // take == 2  take remote
+		      //US                        syncLocal->removeAddressee( inLocal );
+                        (*inLocal) = (*inRemote);
+			//US                        syncLocal->insertAddressee(  inLocal , false );
+                        ++changedLocal;
+                    }
+                }
+            } else { //  no conflict
+                    if ( inRemote->meta.update > mLastSync || mode == 5 ) {
+                        inRemote->meta.update = modifiedSync;
+			//US                        syncRemote->insertAddressee( inRemote, false );
+			//US                        syncLocal->insertAddressee( inRemote, false );
+			syncLocal->addEntry("newcategory", 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 ]; 
+
+        inLocal = syncLocal->findEntryByID( uid, &catLocal, &indexLocal );
+        inRemote = syncRemote->findEntryByID( uid, &catRemote, &indexRemote );
+        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 ( ! PWMPrefs::instance()->mWriteBackExistingOnly ) {
+                        ++addedPasswordsRemote; 
+                        inLocal->meta.update = modifiedSync;
+                        //USsyncLocal->insertAddressee( inLocal, false );
+                        (*inRemote) = (*inLocal);
+                        //USsyncRemote->insertAddressee( inRemote, false );
+			syncRemote->addEntry("newcategory", 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;
 
+    //    addresseeRSync.setRole( i18n("!Remote from: ")+mCurrentSyncName ) ;
+    //    addresseeLSync.setRole(i18n("!Local from: ") + mCurrentSyncName  );
 
+    syncRemote->addSyncDataEntry( syncItemRemote, false );
+    syncLocal->addSyncDataEntry( syncItemLocal, false );
+    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 ( PWMPrefs::instance()->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 = true;//US ( (*local) == (*remote) );
+        if ( equ ) {
+            //qDebug("equal ");
+            if ( mode < SYNC_PREF_FORCE_LOCAL )
+                return 0;
+              
+        }//else //debug only
+        //qDebug("not equal %s %s ", local->summary().latin1(), remote->summary().latin1());
+    }
+    
+    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();
 
@@ -2858,19 +3136,131 @@ bool PwMDoc::sync_isModified()
   return isDirty();
 }
 
 //called by the syncmanager to indicate that the work has to be saved.
 void PwMDoc::sync_save()
 {
-  PwMerror ret = saveDoc(conf()->confGlobCompression());
+  saveDoc(conf()->confGlobCompression());
 }
-
 #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 );
+      ++entrI;
+    }
+    ++catcounter;
+  }
+
+  return results;
+}
 
 
 
 
 
 #ifndef PWM_EMBEDDED
diff --git a/pwmanager/pwmanager/pwmdoc.h b/pwmanager/pwmanager/pwmdoc.h
index ea4d687..91277f6 100644
--- a/pwmanager/pwmanager/pwmdoc.h
+++ b/pwmanager/pwmanager/pwmdoc.h
@@ -203,12 +203,13 @@ struct PwMDataItem
 		lockStat = true;
 		listViewPos = -1;
 		binary = false;
 		if (clearMeta)
 			meta.clear();
 	}
+
 };
 
 struct PwMCategoryItem
 {
 	/** all PwMDataItems (all passwords) within this category */
 	vector<PwMDataItem>	d;
@@ -219,12 +220,37 @@ struct PwMCategoryItem
 	{
 		d.clear();
 		name = "";
 	}
 };
 
+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)
@@ -437,19 +463,20 @@ public:
 		       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 dta[category].d.size(); }
+			{ return dti.dta[category].d.size(); }
 	/** returns number of categories */
 	unsigned int numCategories()
-			{ return dta.size(); }
+			{ return dti.dta.size(); }
 	/** returns the name of the category at "index" */
 	const string* getCategory(unsigned int index)
-			{ return (&(dta[index].name)); }
+			{ 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,
@@ -469,13 +496,13 @@ public:
 		    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 dta[category].d[index].lockStat; }
+			{ 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.
@@ -571,19 +598,19 @@ public:
 			{ ++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 dta[category].d[index].rev; }
+			{ 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 &(dta[category].d[index].meta); }
+			{ 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 dta[category].d[index].binary; }
+			{ return dti.dta[category].d[index].binary; }
 
 public slots:
 	/** wrapper for PwMTray */
 	void _deepUnlock();
 
 signals:
@@ -610,14 +637,16 @@ public:
 				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 */
-	vector<PwMCategoryItem> dta;
+	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;
@@ -704,21 +733,46 @@ protected:
 
  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);
 
 	//called by the syncmanager to indicate that the work has to be marked as dirty.
 	virtual void sync_setModified();
 	//called by the syncmanager to ask if the dirty flag is set.
 	virtual bool sync_isModified();
 	//called by the syncmanager to indicate that the work has to be saved.
 	virtual void sync_save();
+
 #endif
+ 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);
+
+	PwMDataItem* findEntryByID(const QString &uid, unsigned int *category, unsigned int *index);
+
+	QStringList getIDEntryList(); 
 
 };
 
 #endif
diff --git a/pwmanager/pwmanager/pwmdocui.cpp b/pwmanager/pwmanager/pwmdocui.cpp
index 5e675fc..41afa6a 100644
--- a/pwmanager/pwmanager/pwmdocui.cpp
+++ b/pwmanager/pwmanager/pwmdocui.cpp
@@ -273,13 +273,13 @@ bool PwMDocUi::saveDocUi(PwMDoc *doc)
 				   i18n("backup failed"));
 		doc->timer()->putLock(DocTimer::id_autoLockTimer);
 		return false;
 	} else if (ret != e_success) {
 		KMessageBox::error(currentView,
 				   i18n("Error: Couldn't write to file.\n"
-					"Please check if you have permission to "
+					"Please check if you have permission to\n"
 					"write to the file in that directory."),
 				   i18n("error while writing"));
 		doc->timer()->putLock(DocTimer::id_autoLockTimer);
 		return false;
 	}
 	doc->timer()->putLock(DocTimer::id_autoLockTimer);
diff --git a/pwmanager/pwmanager/pwmexception.h b/pwmanager/pwmanager/pwmexception.h
index c8a8c0f..301ebd7 100644
--- a/pwmanager/pwmanager/pwmexception.h
+++ b/pwmanager/pwmanager/pwmexception.h
@@ -156,12 +156,13 @@ enum PwMerror {
 	e_outOfMem,
 	e_lock,			// error while (un)locking
 	e_docNotSaved,		// doc wasn't saved to a file, yet.
 	e_docIsEmpty,
 	e_binEntry,
 	e_normalEntry,
+	e_syncError,
 
 	e_generic
 };
 
 /** can be used for general exception faults */
 class PwMException
diff --git a/pwmanager/pwmanager/pwmview.cpp b/pwmanager/pwmanager/pwmview.cpp
index d192119..e23ce25 100644
--- a/pwmanager/pwmanager/pwmview.cpp
+++ b/pwmanager/pwmanager/pwmview.cpp
@@ -32,12 +32,13 @@
 #include <kmessagebox.h>
 #include <klocale.h>
 
 #include <qlineedit.h>
 #include <qpoint.h>
 #include <qapplication.h>
+#include <qlayout.h>
 
 //US ENH: wouldn't it be a good idea if we could use this consts everywhere else.
 //US ENH: for examle in listviewpwm.cpp
 //US ENH: Because of that I transfer them into the headerfile.
 /*
 #define COLUMN_DESC		0
@@ -452,9 +453,72 @@ void PwMView::copyCommentToClip()
 		return;
 	PwMDataItem d;
 	document()->getEntry(getCurrentCategory(), curIndex, &d);
 	PwM::copyToClipboard(d.comment.c_str());
 }
 
+
+
+
+PwMDataItemChooser::PwMDataItemChooser( PwMDataItem loc, PwMDataItem rem, bool takeloc, QWidget *parent, const char *name ) : KDialogBase(parent,name,
+                true ,i18n("Conflict! Please choose Entry!"),Ok|User1|Close,Close, false)
+{
+    findButton( Close )->setText( i18n("Cancel Sync"));
+    findButton( Ok )->setText( i18n("Remote"));
+    findButton( User1 )->setText( i18n("Local"));
+    QWidget* topframe = new QWidget( this );
+    setMainWidget( topframe );
+    QBoxLayout* bl;
+    if ( QApplication::desktop()->width() < 640 ) {
+        bl = new QVBoxLayout( topframe  );
+    } else {
+        bl = new QHBoxLayout( topframe  );
+    }
+    QVBox* subframe = new QVBox( topframe );
+    bl->addWidget(subframe  );
+    QLabel* lab = new QLabel( i18n("Local Entry"), subframe ); 
+    if ( takeloc )
+        lab->setBackgroundColor(Qt::green.light() );
+    //    AddresseeView * av = new AddresseeView( subframe );
+    //    av->setAddressee( loc );
+    subframe = new QVBox( topframe );
+    bl->addWidget(subframe  );
+    lab = new QLabel( i18n("Remote Entry"), subframe  ); 
+    if ( !takeloc )
+        lab->setBackgroundColor(Qt::green.light() );
+    //    av = new AddresseeView( subframe );
+    //    av->setAddressee( rem );
+    QObject::connect(findButton( Ok ),SIGNAL(clicked()),this, SLOT(slot_remote())); 
+    QObject::connect(this,SIGNAL(user1Clicked()),this, SLOT(slot_local())); 
+#ifndef DESKTOP_VERSION
+    showMaximized();
+#else
+    resize ( 640, 400 );
+#endif
+}
+
+int PwMDataItemChooser::executeD( bool local )
+{
+    mSyncResult = 3; 
+    if ( local ) 
+        findButton( User1 )->setFocus();
+    else 
+        findButton( Ok )->setFocus();
+    exec();
+    return mSyncResult;  
+}
+void PwMDataItemChooser::slot_remote()
+{
+    mSyncResult = 2;
+    accept();
+}
+void PwMDataItemChooser::slot_local()
+{
+    mSyncResult = 1;
+    accept();
+}
+
+
+
 #ifndef PWM_EMBEDDED
 #include "pwmview.moc"
 #endif
diff --git a/pwmanager/pwmanager/pwmview.h b/pwmanager/pwmanager/pwmview.h
index 5a326d3..75cce51 100644
--- a/pwmanager/pwmanager/pwmview.h
+++ b/pwmanager/pwmanager/pwmview.h
@@ -33,12 +33,13 @@
 #include "listviewpwm.h"
 #include "pwmdoc.h"
 #include "pwmviewstyle.h"
 
 #include <kconfig.h>
 #include <klocale.h>
+#include <kdialogbase.h>
 
 #include <qevent.h>
 #include <qfont.h>
 #include <qobject.h>
 
 #include <vector>
@@ -144,7 +145,28 @@ private:
 	/** document */
 	PwMDoc *doc;
 	/** pointer to the main class "PwM" */
 	PwM *mainClass;
 };
 
+
+//US ENH we need this chooser when syncing results in a conflict
+class PwMDataItemChooser : public KDialogBase
+{
+    Q_OBJECT
+
+  public:
+    PwMDataItemChooser( PwMDataItem loc, PwMDataItem rem, bool takeloc, QWidget *parent = 0, const char *name = 0 );
+
+    int executeD( bool local );
+
+  private:
+    int mSyncResult;
+
+  private slots:
+    void slot_remote();
+    void slot_local();
+
+};
+
+
 #endif
diff --git a/pwmanager/pwmanager/serializer.cpp b/pwmanager/pwmanager/serializer.cpp
index a54ba8a..f615082 100644
--- a/pwmanager/pwmanager/serializer.cpp
+++ b/pwmanager/pwmanager/serializer.cpp
@@ -38,12 +38,16 @@
 #define META_VALID_DATE		"v"
 #define META_EXPIRE_DATE	"e"
 #define META_UPDATE_DATE	"u"
 #define META_UPDATE_INT		"i"
 //US ENH : uniqueid
 #define META_UNIQUEID "n" 
+#define SYNC_ROOT "s" 
+#define SYNC_TARGET_PREFIX "t" 
+#define SYNC_TARGET_NAME "n" 
+
 
 /* This is compatibility stuff.
  * The names of the entries have changed and here are the
  * new and old ones
  */
 #define ROOT_MAGIC_OLD		"PwM-xml-dat"
@@ -203,47 +207,59 @@ QCString Serializer::getXml()
 	ret.replace(QRegExp("\n"), "");
 	return ret;
 
 #endif
 }
 
-bool Serializer::serialize(const vector<PwMCategoryItem> &dta)
+bool Serializer::serialize(PwMItem &dta)
 {
 	PWM_ASSERT(domDoc);
 	QDomElement root(genNewRoot());
 	QDomElement catNode(domDoc->createElement(CAT_ROOT_WR));
-	root.appendChild(catNode);
-	if (!addCategories(&catNode, dta))
+	QDomElement syncNode(domDoc->createElement(SYNC_ROOT));
+	if (!addSyncData(&syncNode, dta.syncDta))
 		return false;
+	root.appendChild(syncNode);
+	if (!addCategories(&catNode, dta.dta))
+		return false;
+	root.appendChild(catNode);
 	return true;
 }
 
-bool Serializer::deSerialize(vector<PwMCategoryItem> *dta)
+bool Serializer::deSerialize(PwMItem *dta)
 {
 	PWM_ASSERT(domDoc);
 	PWM_ASSERT(dta);
 	QDomElement root(domDoc->documentElement());
 	QDomNode n;
 
 	dta->clear();
 	for (n = root.firstChild(); !n.isNull(); n = n.nextSibling()) {
 		// find <categories> ... </categories>
 		//      <c>          ... </c>
 		if (n.nodeName() == CAT_ROOT_NEW ||
 		    n.nodeName() == CAT_ROOT_OLD) {
-			if (!readCategories(n, dta)) {
+			if (!readCategories(n, &(dta->dta))) {
 				return false;
 			}
+			continue;
+		}
+		else if (n.nodeName() == SYNC_ROOT) {
+			if (!readSyncData(n, &(dta->syncDta))) {
+				return false;
+			}
+			continue;
+		}
 
 			/* NOTE: We can stop processing here, as we
 			 *       don't have more nodes in root, yet.
 			 */
-			return true;
-		}
+			return false;
+
 	}
-	return false;
+	return true;
 }
 
 bool Serializer::readCategories(const QDomNode &n,
 				vector<PwMCategoryItem> *dta)
 {
 	QDomNodeList nl(n.childNodes());
@@ -658,6 +674,83 @@ QString Serializer::unescapeEntryData(QString dta)
 #else
 	dta.replace(QRegExp("$>--endl--<$"), "\n");
 	dta.replace(QRegExp("||>"), "]]>");
 #endif
 	return dta;
 }
+
+
+//US ENH: the following methods are getting used to write/read sync entries
+/** read the syncentries in the node "n" */
+bool Serializer::readSyncData(const QDomNode &n, vector<PwMSyncItem> *dta)
+{
+	QDomNodeList nl(n.childNodes());
+	QDomNode cur;
+	
+	QString devicename, val;
+	unsigned int numSync  = nl.count(), i;
+	PwMSyncItem curSync;
+	bool ok = true;
+
+	if (!numSync) {
+	  //no sync entries is a possible result 
+		printDebug("Serializer::readSyncData(): empty");
+		return true;
+	}
+	for (i = 0; i < numSync; ++i) {
+		cur = nl.item(i);
+		if (cur.nodeName().left(1) == SYNC_TARGET_PREFIX) {
+			devicename = cur.toElement().attribute(SYNC_TARGET_NAME);
+			val = cur.toElement().text();
+
+			if ((val == "") || (devicename == QString::null)) {
+			  printDebug("Serializer::readSyncData(): empty synctarget name or syncdate");
+			  continue;
+			}
+
+			curSync.syncName = devicename;
+#ifndef PWM_EMBEDDED
+			curSync.lastSyncDate = QDateTime::fromString(val, Qt::ISODate);
+#else
+			curSync.lastSyncDate = KGlobal::locale()->readDateTime(val, KLocale::ISODate, &ok);
+			if (ok == false)
+			  qDebug("Serializer::readSyncData(): could not parse syncdate:%s",val.latin1());
+
+#endif
+			dta->push_back(curSync);
+		}
+	}
+	return true;
+
+}
+
+
+
+bool Serializer::addSyncData(QDomElement *e,
+			       const vector<PwMSyncItem> &dta)
+{
+	unsigned int numSync = dta.size(), i;
+	QString curId, curDeviceName;
+	QDomElement curSync, curSyncDate;
+	QDomText text;
+
+	for (i = 0; i < numSync; ++i) {
+		curId = SYNC_TARGET_PREFIX;
+		curId += tostr(i).c_str();
+		curDeviceName = dta[i].syncName.c_str();
+		curSync = domDoc->createElement(curId);
+		curSync.setAttribute(SYNC_TARGET_NAME, curDeviceName);
+
+#ifndef PWM_EMBEDDED
+		text = domDoc->createTextNode(dta[i].lastSyncDate.toString(Qt::ISODate));
+#else
+		text = domDoc->createTextNode(KGlobal::locale()->formatDateTime(dta[i].lastSyncDate,  KLocale::ISODate));
+#endif
+		curSyncDate.appendChild(text);
+		curSync.appendChild(curSyncDate);
+
+		e->appendChild(curSync);
+
+	}
+	return true;
+}
+
diff --git a/pwmanager/pwmanager/serializer.h b/pwmanager/pwmanager/serializer.h
index 245fcee..ee61b94 100644
--- a/pwmanager/pwmanager/serializer.h
+++ b/pwmanager/pwmanager/serializer.h
@@ -48,15 +48,16 @@ public:
 	void clear();
 	/** parse the given data buffer */
 	bool parseXml(const QCString &buffer);
 	/** returns the current XML data */
 	QCString getXml();
 	/** serialize "dta" and store it as XML data */
-	bool serialize(const vector<PwMCategoryItem> &dta);
+	//US ENH: we need to serialize and deserialize not only categories, but also synctargets
+	bool serialize(PwMItem &dta);
 	/** deserialize the (parsed) XML data and store it in "dta" */
-	bool deSerialize(vector<PwMCategoryItem> *dta);
+	bool deSerialize(PwMItem *dta);
 	/** sets the initial default lockStat we should assign */
 	void setDefaultLockStat(bool stat)
 			{ defaultLockStat = stat; }
 
 protected:
 	/** main data holder */
@@ -94,9 +95,21 @@ protected:
 	bool writeMeta(QDomElement *e,
 		       const PwMMetaData &dta);
 	/** escape illegal characters out of the given entry data string */
 	QString escapeEntryData(QString dta);
 	/** un-escape illegal characters out of the given entry data string */
 	QString unescapeEntryData(QString dta);
+
+
+
+	//US ENH: the following methods are getting used to write/read sync entries
+	/** read the syncentries in the node "n" */
+	bool readSyncData(const QDomNode &n,
+			    vector<PwMSyncItem> *dta);
+
+	/** add new syncentries to the XML data stream in e */
+	bool addSyncData(QDomElement *e,
+			   const vector<PwMSyncItem> &dta);
+
 };
 
 #endif // __SERIALIZER_H