*** empty log message ***

9 files changed, 107 insertions, 31 deletions

diff --git a/pwmanager/pwmanager/pwmdoc.cpp b/pwmanager/pwmanager/pwmdoc.cpp
index 9fe4809..c167c2c 100644
--- a/pwmanager/pwmanager/pwmdoc.cpp
+++ b/pwmanager/pwmanager/pwmdoc.cpp
@@ -1,307 +1,309 @@
 /***************************************************************************
  *                                                                         *
  *   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 2.0 of pwmanager
  * and was modified to run on embedded devices that run microkde
  *
  * $Id$
  **************************************************************************/  
 
 #include "pwmdoc.h"
 #include "pwmview.h"
 #include "blowfish.h"
 #include "sha1.h"
 #include "globalstuff.h"
 #include "gpasmanfile.h"
 #include "serializer.h"
 #include "compressgzip.h"
 #include "compressbzip2.h"
 #include "randomizer.h"
 #include "pwminit.h"
 #ifndef PWM_EMBEDDED
 //US #include "libgryptif.h"
 #else
 #include "pwmprefs.h"
 #include "kglobal.h"
 #endif
 
 #ifdef CONFIG_KWALLETIF
 # include "kwalletemu.h"
 #endif // CONFIG_KWALLETIF
 
 #include <qdatetime.h>
 #include <qsize.h>
 #include <qfileinfo.h>
 #include <qfile.h>
 
+#define __USE_GNU
+#define _GNU_SOURCE
 #include <stdio.h>
 #include <stdlib.h>
 #include <errno.h>
 #include <string.h>
-#include <iostream>
+//US#include <iostream>
 #include <algorithm>
 #include <sys/types.h>
 #include <sys/stat.h>
 #include <unistd.h>
 #include <stdint.h>
 
 //TODO: reset to its normal value.
 #define META_CHECK_TIMER_INTERVAL	10/*300*/ /* sek */
 
 using namespace std;
 
 
 void PwMDocList::add(PwMDoc *doc, const string &id)
 {
 #ifdef PWM_DEBUG
 	// check for existance of object in debug mode only.
 	vector<listItem>::iterator begin = docList.begin(),
 				   end = docList.end(),
 				   i = begin;
 	while (i != end) {
 		if (i->doc == doc) {
 			BUG();
 			return;
 		}
 		++i;
 	}
 #endif
 	listItem newItem;
 	newItem.doc = doc;
 	newItem.docId = id;
 	docList.push_back(newItem);
 }
 
 void PwMDocList::edit(PwMDoc *doc, const string &newId)
 {
 	vector<listItem>::iterator begin = docList.begin(),
 				   end = docList.end(),
 				   i = begin;
 	while (i != end) {
 		if (i->doc == doc) {
 			i->docId = newId;
 			return;
 		}
 		++i;
 	}
 }
 
 void PwMDocList::del(PwMDoc *doc)
 {
 	vector<listItem>::iterator begin = docList.begin(),
 				   end = docList.end(),
 				   i = begin;
 	while (i != end) {
 		if (i->doc == doc) {
 			docList.erase(i);
 			return;
 		}
 		++i;
 	}
 }
 
 bool PwMDocList::find(const string &id, listItem *ret)
 {
 	vector<listItem>::iterator begin = docList.begin(),
 				   end = docList.end(),
 				   i = begin;
 	while (i != end) {
 		if (i->docId == id) {
 			if (ret)
 				*ret = *i;
 			return true;
 		}
 		++i;
 	}
 	return false;
 }
 
 
 
 DocTimer::DocTimer(PwMDoc *_doc)
  : doc (_doc)
  , mpwLock (0)
  , autoLockLock (0)
  , metaCheckLock (0)
 {
 	mpwTimer = new QTimer;
 	autoLockTimer = new QTimer;
 	metaCheckTimer = new QTimer;
 	connect(mpwTimer, SIGNAL(timeout()),
 		this, SLOT(mpwTimeout()));
 	connect(autoLockTimer, SIGNAL(timeout()),
 		this, SLOT(autoLockTimeout()));
 	connect(metaCheckTimer, SIGNAL(timeout()),
 		this, SLOT(metaCheckTimeout()));
 }
 
 DocTimer::~DocTimer()
 {
 	delete mpwTimer;
 	delete autoLockTimer;
 	delete metaCheckTimer;
 }
 
 void DocTimer::start(TimerIDs timer)
 {
 	switch (timer) {
 		case id_mpwTimer:
 			if (mpwTimer->isActive())
 				mpwTimer->stop();
 			doc->setDocStatFlag(DOC_STAT_UNLOCK_WITHOUT_PW);
 			mpwTimer->start(conf()->confGlobPwTimeout() * 1000, true);
 			break;
 		case id_autoLockTimer:
 			if (autoLockTimer->isActive())
 				autoLockTimer->stop();
 			if (conf()->confGlobLockTimeout() > 0)
 				autoLockTimer->start(conf()->confGlobLockTimeout() * 1000, true);
 			break;
 		case id_metaCheckTimer:
 			if (metaCheckTimer->isActive())
 				metaCheckTimer->stop();
 			metaCheckTimer->start(META_CHECK_TIMER_INTERVAL * 1000, true);
 			break;
 	}
 }
 
 void DocTimer::stop(TimerIDs timer)
 {
 	switch (timer) {
 		case id_mpwTimer:
 			mpwTimer->stop();
 			break;
 		case id_autoLockTimer:
 			autoLockTimer->stop();
 			break;
 		case id_metaCheckTimer:
 			metaCheckTimer->stop();
 			break;
 	}
 }
 
 void DocTimer::getLock(TimerIDs timer)
 {
 	switch (timer) {
 		case id_mpwTimer:
 			++mpwLock;
 			break;
 		case id_autoLockTimer:
 			++autoLockLock;
 			break;
 		case id_metaCheckTimer:
 			++metaCheckLock;
 			break;
 	}
 }
 
 void DocTimer::putLock(TimerIDs timer)
 {
 	switch (timer) {
 		case id_mpwTimer:
 			if (mpwLock)
 				--mpwLock;
 			break;
 		case id_autoLockTimer:
 			if (autoLockLock)
 				--autoLockLock;
 			break;
 		case id_metaCheckTimer:
 			if (metaCheckLock)
 				--metaCheckLock;
 			break;
 	}
 }
 
 void DocTimer::mpwTimeout()
 {
 	if (mpwLock) {
 		mpwTimer->start(1000, true);
 		return;
 	}
 	doc->unsetDocStatFlag(DOC_STAT_UNLOCK_WITHOUT_PW);
 }
 
 void DocTimer::autoLockTimeout()
 {
 	if (autoLockLock) {
 		autoLockTimer->start(1000, true);
 		return;
 	}
 	if (conf()->confGlobAutoDeepLock() &&
 	    doc->filename != QString::null &&
 	    doc->filename != "") {
 		doc->deepLock(true);
 	} else {
 		doc->lockAll(true);
 	}
 }
 
 void DocTimer::metaCheckTimeout()
 {
 	if (metaCheckLock) {
 		// check again in one second.
 		metaCheckTimer->start(1000, true);
 		return;
 	}
 	if (doc->isDeepLocked()) {
 		metaCheckTimer->start(META_CHECK_TIMER_INTERVAL * 1000, true);
 		return;
 	}
 	if (doc->isDocEmpty()) {
 		metaCheckTimer->start(META_CHECK_TIMER_INTERVAL * 1000, true);
 		return;
 	}
 #ifdef CONFIG_KWALLETIF
 	KWalletEmu *kwlEmu = doc->init->kwalletEmu();
 	if (kwlEmu)
 		kwlEmu->suspendDocSignals();
 #endif // CONFIG_KWALLETIF
 	/* We simply trigger all views to update their
 	 * displayed values. This way they have a chance
 	 * to get notified when some meta changes over time.
 	 * (for example an entry expired).
 	 * The _view_ is responsive for not updating its
 	 * contents if nothing really changed!
 	 */
 	emit doc->dataChanged(doc);
 #ifdef CONFIG_KWALLETIF
 	if (kwlEmu)
 		kwlEmu->resumeDocSignals();
 #endif // CONFIG_KWALLETIF
 	metaCheckTimer->start(META_CHECK_TIMER_INTERVAL * 1000, true);
 }
 
 
 
 PwMDocList PwMDoc::openDocList;
 unsigned int PwMDocList::unnamedDocCnt = 1;
 
 PwMDoc::PwMDoc(QObject *parent, const char *name)
  : PwMDocUi(parent, name)
  , dataChangedLock (0)
 {
 	deleted = false;
 	unnamedNum = 0;
 	getOpenDocList()->add(this, getTitle().latin1());
 	curDocStat = 0;
 	setMaxNumEntries();
 	_timer = new DocTimer(this);
 	timer()->start(DocTimer::id_mpwTimer);
 	timer()->start(DocTimer::id_autoLockTimer);
 	timer()->start(DocTimer::id_metaCheckTimer);
 	addCategory(DEFAULT_CATEGORY, 0, false);
 	listView = 0;
 	emit docCreated(this);
 }
 
@@ -901,520 +903,531 @@ PwMerror PwMDoc::writeDataHash(char dataHash, string *d, QFile *f)
 bool PwMDoc::backupFile(const QString &filePath)
 {
 	QFileInfo fi(filePath);
 	if (!fi.exists())
 		return true; // Yes, true is correct.
 	QString pathOnly(fi.dirPath(true));
 	QString nameOnly(fi.fileName());
 	QString backupPath = pathOnly
 			   + "/~"
 			   + nameOnly
 			   + ".backup";
 	return copyFile(filePath, backupPath);
 }
 
 bool PwMDoc::copyFile(const QString &src, const QString &dst)
 {
 	QFileInfo fi(src);
 	if (!fi.exists())
 		return false;
 	if (QFile::exists(dst)) {
 		if (!QFile::remove(dst))
 			return false;
 	}
 	QFile srcFd(src);
 	if (!srcFd.open(IO_ReadOnly))
 		return false;
 	QFile dstFd(dst);
 	if (!dstFd.open(IO_ReadWrite)) {
 		srcFd.close();
 		return false;
 	}
 	const int tmpBuf_size = 512;
 	char tmpBuf[tmpBuf_size];
 #ifndef PWM_EMBEDDED
 	Q_LONG bytesRead, bytesWritten;
 #else
 	long bytesRead, bytesWritten;
 #endif
 	while (!srcFd.atEnd()) {
 #ifndef PWM_EMBEDDED
 		bytesRead = srcFd.readBlock(tmpBuf,
 				  static_cast<Q_ULONG>(tmpBuf_size));
 #else
 		bytesRead = srcFd.readBlock(tmpBuf,
 				  (unsigned long)(tmpBuf_size));
 #endif
 		if (bytesRead == -1) {
 			srcFd.close();
 			dstFd.close();
 			return false;
 		}
 #ifndef PWM_EMBEDDED
 		bytesWritten = dstFd.writeBlock(tmpBuf,
 				     static_cast<Q_ULONG>(bytesRead));
 #else
 		bytesWritten = dstFd.writeBlock(tmpBuf,
 				     (unsigned long)(bytesRead));
 #endif
 		if (bytesWritten != bytesRead) {
 			srcFd.close();
 			dstFd.close();
 			return false;
 		}
 	}
 	srcFd.close();
 	dstFd.close();
 	return true;
 }
 
 PwMerror PwMDoc::addEntry(const QString &category, PwMDataItem *d,
 			  bool dontFlagDirty, bool updateMeta)
 {
 	PWM_ASSERT(d);
 	unsigned int cat = 0;
 
 	if (isDeepLocked()) {
 		PwMerror ret;
 		ret = deepLock(false);
 		if (ret != e_success)
 			return e_lock;
 	}
 
 	addCategory(category, &cat);
 
 	if (numEntries(category) >= maxEntries)
 		return e_maxAllowedEntr;
 
 	vector<unsigned int> foundPositions;
 	/* historically this was:
 	 *	const int searchIn = SEARCH_IN_DESC | SEARCH_IN_NAME |
 	 *			     SEARCH_IN_URL | SEARCH_IN_LAUNCHER;
 	 * But for now we only search in desc.
 	 * That's a tweak to be KWallet compatible. But it should not add
 	 * usability-drop onto PwManager, does it?
 	 * (And yes, "int" was a bug. Correct is "unsigned int")
 	 */
 	const unsigned int searchIn = SEARCH_IN_DESC;
 	findEntry(cat, *d, searchIn, &foundPositions, true);
 	if (foundPositions.size()) {
 		// DOH! We found this entry.
 		return e_entryExists;
 	}
 
 	d->listViewPos = -1;
 	d->lockStat = conf()->confGlobNewEntrLockStat();
 	if (updateMeta) {
 		d->meta.create = QDateTime::currentDateTime();
 		d->meta.update = d->meta.create;
 	}
 	dta[cat].d.push_back(*d);
 
 	delAllEmptyCat(true);
 
 	if (!dontFlagDirty)
 		flagDirty();
 	return e_success;
 }
 
 PwMerror PwMDoc::addCategory(const QString &category, unsigned int *categoryIndex,
 			     bool checkIfExist)
 {
 	if (isDeepLocked()) {
 		PwMerror ret;
 		ret = deepLock(false);
 		if (ret != e_success)
 			return e_lock;
 	}
 	if (checkIfExist) {
 		if (findCategory(category, categoryIndex))
 			return e_categoryExists;
 	}
 	PwMCategoryItem item;
 	item.name = category.latin1();
 	dta.push_back(item);
 	if (categoryIndex)
 		*categoryIndex = dta.size() - 1;
 	return e_success;
 }
 
 bool PwMDoc::delEntry(const QString &category, unsigned int index, bool dontFlagDirty)
 {
 	unsigned int cat = 0;
 
 	if (!findCategory(category, &cat)) {
 		BUG();
 		return false;
 	}
 
 	return delEntry(cat, index, dontFlagDirty);
 }
 
 bool PwMDoc::delEntry(unsigned int category, unsigned int index, bool dontFlagDirty)
 {
 	if (isDeepLocked())
 		return false;
 	if (index > dta[category].d.size() - 1)
 		return false;
 	getDataChangedLock();
 	if (!lockAt(category, index, false)) {
 		putDataChangedLock();
 		return false;
 	}
 	putDataChangedLock();
 	int lvPos = dta[category].d[index].listViewPos;
 
 	// delete entry
 	dta[category].d.erase(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 (!dontFlagDirty)
 		flagDirty();
 	return true;
 }
 
 bool PwMDoc::editEntry(const QString &oldCategory, const QString &newCategory,
 		       unsigned int index, PwMDataItem *d, bool updateMeta)
 {
 	PWM_ASSERT(d);
 	unsigned int oldCat = 0;
 
 	if (!findCategory(oldCategory, &oldCat)) {
 		BUG();
 		return false;
 	}
 
 	return editEntry(oldCat, newCategory, index, d, updateMeta);
 }
 
 bool PwMDoc::editEntry(unsigned int oldCategory, const QString &newCategory,
 		       unsigned int index, PwMDataItem *d, bool updateMeta)
 {
 	if (isDeepLocked())
 		return false;
 	if (updateMeta) {
 		d->meta.update = QDateTime::currentDateTime();
 		if (d->meta.create.isNull()) {
 			d->meta.create = d->meta.update;
 		}
 	}
 	if (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;
 	}
 	flagDirty();
 	return true;
 }
 
 unsigned int PwMDoc::numEntries(const QString &category)
 {
 	unsigned int cat = 0;
 
 	if (!findCategory(category, &cat)) {
 		BUG();
 		return 0;
 	}
 
 	return numEntries(cat);
 }
 
 bool PwMDoc::serializeDta(string *d)
 {
 	PWM_ASSERT(d);
 	Serializer ser;
 	if (!ser.serialize(dta))
 		return false;
 	d->assign(ser.getXml());
 	if (!d->size())
 		return false;
 	return true;
 }
 
 bool PwMDoc::deSerializeDta(const string *d, bool entriesLocked)
 {
 	PWM_ASSERT(d);
+#ifndef PWM_EMBEDDED
 	try {
+
 		Serializer ser(d->c_str());
 		ser.setDefaultLockStat(entriesLocked);
 		if (!ser.deSerialize(&dta))
 			return false;
 	} catch (PwMException) {
 		return false;
 	}
+#else
+	Serializer ser(d->c_str());
+	ser.setDefaultLockStat(entriesLocked);
+	if (!ser.deSerialize(&dta))
+	  return false;
+	else
+	  return false;
+#endif
+
 	emitDataChanged(this);
 	return true;
 }
 
 bool PwMDoc::getEntry(const QString &category, unsigned int index,
 		      PwMDataItem * d, bool unlockIfLocked)
 {
 	PWM_ASSERT(d);
 	unsigned int cat = 0;
 
 	if (!findCategory(category, &cat)) {
 		BUG();
 		return false;
 	}
 
 	return getEntry(cat, index, d, unlockIfLocked);
 }
 
 bool PwMDoc::getEntry(unsigned int category, unsigned int index,
 		      PwMDataItem *d, bool unlockIfLocked)
 {
 	if (index > dta[category].d.size() - 1)
 		return false;
 
 	bool locked = isLocked(category, index);
 	if (locked) {
 		/* this entry is locked. We don't return a password,
 		 * until it's unlocked by the user by inserting
 		 * chipcard or entering the mpw
 		 */
 		if (unlockIfLocked) {
 			if (!lockAt(category, index, false)) {
 				return false;
 			}
 			locked = false;
 		}
 	}
 
 	*d = dta[category].d[index];
 	if (locked)
 		d->pw = LOCKED_STRING.latin1();
 
 	return true;
 }
 
 PwMerror PwMDoc::getCommentByLvp(const QString &category, int listViewPos,
 				 string *foundComment)
 {
 	PWM_ASSERT(foundComment);
 	unsigned int cat = 0;
 
 	if (!findCategory(category, &cat))
 		return e_invalidArg;
 
 	unsigned int i, entries = numEntries(cat);
 	for (i = 0; i < entries; ++i) {
 		if (dta[cat].d[i].listViewPos == listViewPos) {
 			*foundComment = dta[cat].d[i].comment;
 			if (dta[cat].d[i].binary)
 				return e_binEntry;
 			return e_normalEntry;
 		}
 	}
 	BUG();
 	return e_generic;
 }
 
 bool PwMDoc::compressDta(string *d, char algo)
 {
 	PWM_ASSERT(d);
 	switch (algo) {
 		case PWM_COMPRESS_GZIP: {
 			CompressGzip comp;
 			return comp.compress(d);
 		} case PWM_COMPRESS_BZIP2: {
 			CompressBzip2 comp;
 			return comp.compress(d);
 		} case PWM_COMPRESS_NONE: {
 			return true;
 		} default: {
 			BUG();
 		}
 	}
 	return false;
 }
 
 bool PwMDoc::decompressDta(string *d, char algo)
 {
 	PWM_ASSERT(d);
 	switch (algo) {
 		case PWM_COMPRESS_GZIP: {
 			CompressGzip comp;
 			return comp.decompress(d);
 		} case PWM_COMPRESS_BZIP2: {
 			CompressBzip2 comp;
 			return comp.decompress(d);
 		} case PWM_COMPRESS_NONE: {
 			return true;
 		}
 	}
 	return false;
 }
 
 PwMerror PwMDoc::encrypt(string *d, const QString *pw, QFile *f, char algo)
 {
 	PWM_ASSERT(d);
 	PWM_ASSERT(pw);
 	PWM_ASSERT(f);
 
 	size_t encSize;
 	byte *encrypted = 0;
 
 	switch (algo) {
 	case PWM_CRYPT_BLOWFISH: {
 		Blowfish::padNull(d);
 		encSize = d->length();
 		encrypted = new byte[encSize];
 		Blowfish bf;
 		if (bf.bf_setkey((byte *) pw->latin1(), pw->length())) {
 			delete [] encrypted;
 			return e_weakPw;
 		}
 		bf.bf_encrypt((byte *) encrypted, (byte *) d->c_str(), encSize);
 		break;
 	}
 #ifndef PWM_EMBEDDED	
 	case PWM_CRYPT_AES128:
 		/*... fall through */
 	case PWM_CRYPT_AES192:
 	case PWM_CRYPT_AES256:
 	case PWM_CRYPT_3DES:
 	case PWM_CRYPT_TWOFISH:
 	case PWM_CRYPT_TWOFISH128: {
 		if (!LibGCryptIf::available())
 			return e_cryptNotImpl;
 		LibGCryptIf gc;
 		PwMerror err;
 		unsigned char *plain = new unsigned char[d->length() + 1024];
 		memcpy(plain, d->c_str(), d->length());
 		err = gc.encrypt(&encrypted,
 				 &encSize,
 				 plain,
 				 d->length(),
 				 reinterpret_cast<const unsigned char *>(pw->latin1()),
 				 pw->length(),
 				 algo);
 		delete [] plain;
 		if (err != e_success)
 			return e_cryptNotImpl;
 		break;
 	}
 #endif
 	default: {
 		delete_ifnot_null_array(encrypted);
 		return e_cryptNotImpl;
 	} }
 
 	// write encrypted data to file
 #ifndef PWM_EMBEDDED
 	if (f->writeBlock(reinterpret_cast<const char *>(encrypted),
 			  static_cast<Q_ULONG>(encSize))
 	    != static_cast<Q_LONG>(encSize)) {
 		delete_ifnot_null_array(encrypted);
 		return e_writeFile;
 	}
 #else
 	if (f->writeBlock((const char *)(encrypted),
 			  (unsigned long)(encSize))
 	    != (long)(encSize)) {
 		delete_ifnot_null_array(encrypted);
 		return e_writeFile;
 	}
 #endif
 	delete_ifnot_null_array(encrypted);
 	return e_success;
 }
 
 PwMerror PwMDoc::decrypt(string *d, unsigned int pos, const QString *pw,
 			 char algo, QFile *f)
 {
 	PWM_ASSERT(d);
 	PWM_ASSERT(pw);
 	PWM_ASSERT(f);
 
 	unsigned int cryptLen = f->size() - pos;
 	byte *encrypted = new byte[cryptLen];
 	byte *decrypted = new byte[cryptLen];
 
 	f->at(pos);
 #ifndef PWM_EMBEDDED
 	if (f->readBlock(reinterpret_cast<char *>(encrypted),
 			 static_cast<Q_ULONG>(cryptLen))
 	    != static_cast<Q_LONG>(cryptLen)) {
 		delete [] encrypted;
 		delete [] decrypted;
 		return e_readFile;
 	}
 #else
 	if (f->readBlock((char *)(encrypted),
 			 (unsigned long)(cryptLen))
 	    != (long)(cryptLen)) {
 		delete [] encrypted;
 		delete [] decrypted;
 		return e_readFile;
 	}
 #endif
 	switch (algo) {
 	case PWM_CRYPT_BLOWFISH: {
 		Blowfish bf;
 		bf.bf_setkey((byte *) pw->latin1(), pw->length());
 		bf.bf_decrypt(decrypted, encrypted, cryptLen);
 		break;
 	}
 #ifndef PWM_EMBEDDED
 	case PWM_CRYPT_AES128:
 		/*... fall through */
 	case PWM_CRYPT_AES192:
 	case PWM_CRYPT_AES256:
 	case PWM_CRYPT_3DES:
 	case PWM_CRYPT_TWOFISH:
 	case PWM_CRYPT_TWOFISH128: {
 		if (!LibGCryptIf::available())
 			return e_cryptNotImpl;
 		LibGCryptIf gc;
 		PwMerror err;
 		err = gc.decrypt(&decrypted,
 				 &cryptLen,
 				 encrypted,
 				 cryptLen,
 				 reinterpret_cast<const unsigned char *>(pw->latin1()),
 				 pw->length(),
 				 algo);
 		if (err != e_success) {
 			delete [] encrypted;
 			delete [] decrypted;
 			return e_cryptNotImpl;
 		}
 		break;
 	}
 #endif
 	default: {
 		delete [] encrypted;
 		delete [] decrypted;
 		return e_cryptNotImpl;
 	} }
 	delete [] encrypted;
 #ifndef PWM_EMBEDDED
 	d->assign(reinterpret_cast<const char *>(decrypted),
 		  static_cast<string::size_type>(cryptLen));
 #else
 	d->assign((const char *)(decrypted),
 		  (string::size_type)(cryptLen));
 #endif
 	delete [] decrypted;
 	if (algo == PWM_CRYPT_BLOWFISH) {
 		if (!Blowfish::unpadNull(d)) {
diff --git a/pwmanager/pwmanager/pwmprefs.cpp b/pwmanager/pwmanager/pwmprefs.cpp
index 5779ecc..d3847f6 100644
--- a/pwmanager/pwmanager/pwmprefs.cpp
+++ b/pwmanager/pwmanager/pwmprefs.cpp
@@ -1,299 +1,300 @@
 /*
     This file is part of PwManager/Pi
     Copyright (c) 2004 Ulf Schenk
 
     This program is free software; you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
     the Free Software Foundation; either version 2 of the License, or
     (at your option) any later version.
 
     This program is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
     GNU General Public License for more details.
 
     You should have received a copy of the GNU General Public License
     along with this program; if not, write to the Free Software
     Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 
     As a special exception, permission is given to link this program
     with any edition of Qt, and distribute the resulting executable,
     without including the source code for Qt in the source distribution.
 
     $Id$
 */
 
 
 #include <kconfig.h>
 #include <klocale.h>
 #include <kstaticdeleter.h>
 
 #include "pwmprefs.h"
 
 PWMPrefs *PWMPrefs::sInstance = 0;
 static KStaticDeleter<PWMPrefs> staticDeleter;
 
 PWMPrefs::PWMPrefs()
   : KPimPrefs("pwmanagerrc")
 {
   KPrefs::setCurrentGroup( "Global" );
 
   addItemString( "autoStart", &mAutoStart, "" );
   addItemString( "browserCommand", &mBrowserCommand, "" );
   addItemString( "xtermCommand", &mXTermCommand, CONF_DEFAULT_XTERMCOMMAND);
   addItemFont( "entryFont", &mEntryFont);
   addItemInt( "pwTimeout", &mPwTimeout, CONF_DEFAULT_PWTIMEOUT );
   addItemInt( "lockTimeout", &mLockTimeout, CONF_DEFAULT_LOCKTIMEOUT );
   addItemInt( "compression", &mCompression, CONF_DEFAULT_COMPRESSION );
   addItemInt( "filePermissions", &mFilePermissions, CONF_DEFAULT_FILEPERMISSIONS );
   addItemInt( "minimizeLock", &mMinimizeLock, CONF_DEFAULT_MINIMIZELOCK );
   addItemBool( "unlockOnOpen", &mUnlockOnOpen, CONF_DEFAULT_UNLOCKONOPEN );
   addItemBool( "tray", &mTray, CONF_DEFAULT_TRAY );
   addItemBool( "makeFileBackup", &mMakeFileBackup, CONF_DEFAULT_MAKEFILEBACKUP );
   addItemBool( "autostartDeepLocked", &mAutostartDeeplocked, CONF_DEFAULT_AUTOSTART_DEEPL );
   addItemBool( "autoDeepLock", &mAutoDeeplock, CONF_DEFAULT_AUTODEEPLOCK );
   addItemBool( "kwalletEmu", &mKWalletEmu, CONF_DEFAULT_KWALLETEMU );
   addItemBool( "newEntrLockStat", &mNewEntrLockStat, CONF_DEFAULT_NEWENTRLOCKSTAT );
 
   KPrefs::setCurrentGroup( "Wnd" );
 
   addItemSize( "MainWndSize", &mMainWndSize);
   addItemInt( "MainViewStyle", &mMainViewStyle, CONF_DEFAULT_MAINVIEWSTYLE );
   addItemBool( "autoMinimizeOnStart", &mAutoMinimizeOnStart, CONF_DEFAULT_AUTOMINIMIZE );
   addItemBool( "close", &mClose, CONF_DEFAULT_WNDCLOSE );
+  addItemIntList( "CommentSplitter", &mCommentSplitter );
 }
 
 PWMPrefs::~PWMPrefs()
 {
 }
 
 PWMPrefs *PWMPrefs::instance()
 {
   if ( !sInstance ) {
 #ifdef PWM_EMBEDDED
     sInstance = staticDeleter.setObject( new PWMPrefs() );
 #else  //PWM_EMBEDDED
     //US the following line has changed ???. Why
     staticDeleter.setObject( sInstance, new PWMPrefs() );
 #endif //KAB_EMBEDDED
     sInstance->readConfig();
   }
 
   return sInstance;
 }
 
     // US introduce a nonconst way to return the config object.
 KConfig* PWMPrefs::getConfig()
 {
     return config();
 }
 
 /*******************************************************************
  *  functions for reading the configuration settings
  *******************************************************************/
 
 QString PWMPrefs::confGlobAutoStart()
 {
   return mAutoStart;
 }
 
 QString PWMPrefs::confGlobBrowserCommand()
 {
   return mBrowserCommand;
 }
 
 QString PWMPrefs::confGlobXtermCommand()
 {
   return mXTermCommand;
 }
 
 QFont PWMPrefs::confGlobEntryFont()
 {
   return mEntryFont;
 }
 
 int PWMPrefs::confGlobPwTimeout()
 {
   return mPwTimeout;
 }
 
 int PWMPrefs::confGlobLockTimeout()
 {
   return mLockTimeout;
 }
 
 int PWMPrefs::confGlobCompression()
 {
   return mCompression;
 }
 
 int PWMPrefs::confGlobFilePermissions()
 {
   return mFilePermissions;
 }
 
 int PWMPrefs::confGlobMinimizeLock()
 {
   return mMinimizeLock;
 }
 
 bool PWMPrefs::confGlobUnlockOnOpen()
 {
   return mUnlockOnOpen;
 }
 
 bool PWMPrefs::confGlobTray()
 {
   return mTray;
 }
 
 bool PWMPrefs::confGlobMakeFileBackup()
 {
   return mMakeFileBackup;
 }
 
 bool PWMPrefs::confGlobAutostartDeepLocked()
 {
   return mAutostartDeeplocked;
 }
 
 bool PWMPrefs::confGlobAutoDeepLock()
 {
   return mAutoDeeplock;
 }
 
 bool PWMPrefs::confGlobKwalletEmu()
 {
   return mKWalletEmu;
 }
 
 bool PWMPrefs::confGlobNewEntrLockStat()
 {
   return mNewEntrLockStat;
 }
 
 QSize PWMPrefs::confWndMainWndSize()
 {
   return mMainWndSize;
 }
 
 int PWMPrefs::confWndMainViewStyle()
 {
   return mMainViewStyle;
 }
 
 bool PWMPrefs::confWndAutoMinimizeOnStart()
 {
   return mAutoMinimizeOnStart;
 }
 
 bool PWMPrefs::confWndClose()
 {
   return mClose;
 }
 
 /*******************************************************************
  *  functions for writing the configuration settings
  *******************************************************************/
 
 void PWMPrefs::confGlobAutoStart(const QString &e)
 {
   mAutoStart = e;
 }
 
 void PWMPrefs::confGlobBrowserCommand(const QString &e)
 {
   mBrowserCommand = e;
 }
 
 void PWMPrefs::confGlobXtermCommand(const QString &e)
 {
   mXTermCommand = e;
 }
 
 void PWMPrefs::confGlobEntryFont(const QFont &e)
 {
   mEntryFont = e;
 }
 
 void PWMPrefs::confGlobPwTimeout(int e)
 {
   mPwTimeout = e;
 }
 
 void PWMPrefs::confGlobLockTimeout(int e)
 {
   mLockTimeout = e;
 }
 
 void PWMPrefs::confGlobCompression(int e)
 {
   mCompression = e;
 }
 
 void PWMPrefs::confGlobFilePermissions(int e)
 {
   mFilePermissions = e;
 }
 
 void PWMPrefs::confGlobMinimizeLock(int e)
 {
   mMinimizeLock = e;
 }
 
 void PWMPrefs::confGlobUnlockOnOpen(bool e)
 {
   mUnlockOnOpen = e;
 }
 
 void PWMPrefs::confGlobTray(bool e)
 {
   mTray = e;
 }
 
 void PWMPrefs::confGlobMakeFileBackup(bool e)
 {
   mMakeFileBackup = e;
 }
 
 void PWMPrefs::confGlobAutostartDeepLocked(bool e)
 {
   mAutostartDeeplocked = e;
 }
 
 void PWMPrefs::confGlobAutoDeepLock(bool e)
 {
   mAutoDeeplock = e;
 }
 
 void PWMPrefs::confGlobKwalletEmu(bool e)
 {
   mKWalletEmu = e;
 }
 
 void PWMPrefs::confGlobNewEntrLockStat(bool e)
 {
   mNewEntrLockStat = e;
 }
 
 void PWMPrefs::confWndMainWndSize(const QSize &e)
 {
   mMainWndSize = e;
 }
 
 void PWMPrefs::confWndMainViewStyle(int e)
 {
   mMainViewStyle = e;
 }
 
 void PWMPrefs::confWndAutoMinimizeOnStart(bool e)
 {
   mAutoMinimizeOnStart = e;
 }
 
 void PWMPrefs::confWndClose(bool e)
 {
   mClose = e;
 }
 
 
diff --git a/pwmanager/pwmanager/pwmprefs.h b/pwmanager/pwmanager/pwmprefs.h
index bf7d8b1..6a89d10 100644
--- a/pwmanager/pwmanager/pwmprefs.h
+++ b/pwmanager/pwmanager/pwmprefs.h
@@ -1,146 +1,150 @@
 /*
     This file is part of PwManager/Pi
     Copyright (c) 2004 Ulf Schenk
 
     This program is free software; you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
     the Free Software Foundation; either version 2 of the License, or
     (at your option) any later version.
 
     This program is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
     GNU General Public License for more details.
 
     You should have received a copy of the GNU General Public License
     along with this program; if not, write to the Free Software
     Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 
     As a special exception, permission is given to link this program
     with any edition of Qt, and distribute the resulting executable,
     without including the source code for Qt in the source distribution.
 
     $Id$
 */
 
 #ifndef PWMPREFS_H
 #define PWMPREFS_H
 
 #include <qstringlist.h>
 #include <qsize.h>
 
 #include <kpimprefs.h>
 
 class KConfig;
 
 #define conf() PWMPrefs::instance()
 
 
 #define CONF_DEFAULT_PWTIMEOUT		10	/* 10 sec */
 #define CONF_DEFAULT_LOCKTIMEOUT	0	/* 0 == disable */
 #define CONF_DEFAULT_TRAY		true
 #define CONF_DEFAULT_UNLOCKONOPEN	false
 #define CONF_DEFAULT_MAINVIEWSTYLE	0
 #define CONF_DEFAULT_COMPRESSION	0x01	/* gzip */
 #define CONF_DEFAULT_AUTOMINIMIZE	false
 #define CONF_DEFAULT_BROWSERCOMMAND	""
 #define CONF_DEFAULT_XTERMCOMMAND	"konsole -e"
 #define CONF_DEFAULT_FILEPERMISSIONS	0600
 #define CONF_DEFAULT_MAKEFILEBACKUP	false
 #define CONF_DEFAULT_AUTOSTART_DEEPL	true
 #define CONF_DEFAULT_AUTODEEPLOCK	true
 #define CONF_DEFAULT_KWALLETEMU		true
 #define CONF_DEFAULT_MINIMIZELOCK	2	/* deep-lock */
 #define CONF_DEFAULT_NEWENTRLOCKSTAT	true	/* locked */
 #define CONF_DEFAULT_WNDCLOSE		true	/* don't minimize to tray */
 
 class PWMPrefs : public KPimPrefs
 {
   public:
     virtual ~PWMPrefs();
 
     static PWMPrefs *instance();
 
 public:
 	/* functions for reading the configuration settings */
 	/* GLOBAL */
 	QString confGlobAutoStart();
 	QString confGlobBrowserCommand();
 	QString confGlobXtermCommand();
 	QFont confGlobEntryFont();
 	int confGlobPwTimeout();
 	int confGlobLockTimeout();
 	int confGlobCompression();
 	int confGlobFilePermissions();
 	int confGlobMinimizeLock();
 	bool confGlobUnlockOnOpen();
 	bool confGlobTray();
 	bool confGlobMakeFileBackup();
 	bool confGlobAutostartDeepLocked();
 	bool confGlobAutoDeepLock();
 	bool confGlobKwalletEmu();
 	bool confGlobNewEntrLockStat();
 	/* WND */
 	QSize confWndMainWndSize();
 	int confWndMainViewStyle();
 	bool confWndAutoMinimizeOnStart();
 	bool confWndClose();
 
 public:
 	/* functions for writing the configuration settings */
 	/* GLOBAL */
 	void confGlobAutoStart(const QString &e);
 	void confGlobBrowserCommand(const QString &e);
 	void confGlobXtermCommand(const QString &e);
 	void confGlobEntryFont(const QFont &e);
 	void confGlobPwTimeout(int e);
 	void confGlobLockTimeout(int e);
 	void confGlobCompression(int e);
 	void confGlobFilePermissions(int e);
 	void confGlobMinimizeLock(int e);
 	void confGlobUnlockOnOpen(bool e);
 	void confGlobTray(bool e);
 	void confGlobMakeFileBackup(bool e);
 	void confGlobAutostartDeepLocked(bool e);
 	void confGlobAutoDeepLock(bool e);
 	void confGlobKwalletEmu(bool e);
 	void confGlobNewEntrLockStat(bool e);
 	/* WND */
 	void confWndMainWndSize(const QSize &e);
 	void confWndMainViewStyle(int e);
 	void confWndAutoMinimizeOnStart(bool e);
 	void confWndClose(bool e);
 
 
 
   QString mAutoStart;
   QString mBrowserCommand;
   QString mXTermCommand;
   QFont mEntryFont;
   int mPwTimeout;
   int mLockTimeout;
   int mCompression;
   int mFilePermissions;
   int mMinimizeLock;
   bool mUnlockOnOpen;
   bool mTray;
   bool mMakeFileBackup;
   bool mAutostartDeeplocked;
   bool mAutoDeeplock;
   bool mKWalletEmu;
   bool mNewEntrLockStat;
   QSize mMainWndSize;
   int mMainViewStyle;
   bool mAutoMinimizeOnStart;
   bool mClose;
 
+  //US ENH
+  QValueList<int> mCommentSplitter;
+
+
     // US introduce a nonconst way to return the config object.
     KConfig* getConfig();
 
   private:
     PWMPrefs();
 
     static PWMPrefs *sInstance;
 };
 
 #endif
diff --git a/pwmanager/pwmanager/pwmviewstyle.cpp b/pwmanager/pwmanager/pwmviewstyle.cpp
index 51d8f6c..9704615 100644
--- a/pwmanager/pwmanager/pwmviewstyle.cpp
+++ b/pwmanager/pwmanager/pwmviewstyle.cpp
@@ -1,217 +1,239 @@
 /***************************************************************************
  *                                                                         *
  *   copyright (C) 2004 by Michael Buesch                                  *
  *   email: mbuesch@freenet.de                                             *
  *                                                                         *
  *   This program is free software; you can redistribute it and/or modify  *
  *   it under the terms of the GNU General Public License version 2        *
  *   as published by the Free Software Foundation.                         *
  *                                                                         *
  ***************************************************************************/
 
 
 /***************************************************************************
  * copyright (C) 2004 by Ulf Schenk
  * This file is originaly based on version 1.0.1 of pwmanager
  * and was modified to run on embedded devices that run microkde
  *
  * $Id$
  **************************************************************************/  
 
 #include "pwmviewstyle.h"
 #include "pwmexception.h"
 #include "pwmviewstyle_0.h"
 #include "pwmviewstyle_1.h"
 #include "listviewpwm.h"
 #include "pwmview.h"
 #include "commentbox.h"
 #ifndef PWM_EMBEDDED
 #include "configuration.h"
 #else
 #include "pwmprefs.h"
 #endif
 
 PwMViewStyle::PwMViewStyle(QWidget *parent, const char *name)
  : QWidget(parent, name)
 {
 	curStyle = style_notset;
 	s0 = 0;
 	s1 = 0;
 }
 
 PwMViewStyle::~PwMViewStyle()
 {
-	//US ENH : load and store the size of the listviewcolumns
-	lv->saveLayout(conf()->getConfig(), "listview");
-	conf()->getConfig()->sync();
+	//US ENH : store the size of the listviewcolumns
+        switch (curStyle)
+	  {
+	  case style_0:
+	    s0->saveSettings(PWMPrefs::instance());
+	    break;
+	  case style_1:
+	    s1->saveSettings(PWMPrefs::instance());
+	    break;
+	  default:
+		BUG();
+	  }
+
+
+	PWMPrefs::instance()->getConfig()->sync();
 
 	delete_ifnot_null(s0);
 	delete_ifnot_null(s1);
 }
 
 void PwMViewStyle::initStyle(style_t style)
 {
 	printDebug(string("initializing style ") + tostr(style));
 	bool wasMaximized = v->isMaximized();
 	if (v->isVisible())
 		v->hide();
 	switch (style) {
 	case style_0:
 		delete_ifnot_null(s0);
 		delete_ifnot_null(s1);
 		s0 = new PwMViewStyle_0(v);
 		lv = s0->getLv();
 		commentBox = s0->getCommentBox();
 		break;
 	case style_1:
 		delete_ifnot_null(s0);
 		delete_ifnot_null(s1);
 		s1 = new PwMViewStyle_1(v);
 		lv = s1->getLv();
 		commentBox = s1->getCommentBox();
 		break;
 	default:
 		BUG();
 		return;
 	}
 	curStyle = style;
 	connect(lv, SIGNAL(pressed(QListViewItem *)),
 		v, SLOT(handleToggle(QListViewItem *)));
 	connect(lv, SIGNAL(rightButtonClicked(QListViewItem *, const QPoint &, int)),
 		v, SLOT(handleRightClick(QListViewItem *, const QPoint &, int)));
 	connect(lv, SIGNAL(clicked(QListViewItem *)),
 		v, SLOT(refreshCommentTextEdit(QListViewItem *)));
 	lv->addColumn(i18n("Description"), 180);
 	lv->addColumn(i18n("Username"), 150);
 	lv->addColumn(i18n("Password"), 150);
 	lv->addColumn(i18n("URL"), 180);
 	lv->addColumn(i18n("Launcher"), 120);
 	v->tmpReEnableSort();
 
-	//US ENH : load and store the size of the listviewcolumns
-	lv->restoreLayout(conf()->getConfig(), "listview");
+	//US ENH : load the size of the listviewcolumns
+	switch (style)
+	  {
+	  case style_0:
+	    s0->restoreSettings(PWMPrefs::instance());
+	    break;
+	  case style_1:
+	    s1->restoreSettings(PWMPrefs::instance());
+	    break;
+	  default:
+		BUG();
+	  }
 
 	resizeView(v->size());
 	v->updateView();
 	if (wasMaximized) {
 		v->showMaximized();
 	} else {
 		v->show();
 	}
 	connect(lv, SIGNAL(layoutChanged()),
 		v, SLOT(reorgLp()));
 }
 
 void PwMViewStyle::resizeView(const QSize &size)
 {
 	switch (curStyle) {
 	case style_0:
 		PWM_ASSERT(s0);
 		s0->resize(size);
 		return;
 	case style_1:
 		PWM_ASSERT(s1);
 		s1->resize(size);
 		return;
 	default:
 		BUG();
 	}
 }
 
 QString PwMViewStyle::getCurrentCategory()
 {
 	switch (curStyle) {
 	case style_0:
 		PWM_ASSERT(s0);
 		return s0->getCurrentCategory();
 	case style_1:
 		PWM_ASSERT(s1);
 		return s1->getCurrentCategory();
 	default:
 		BUG();
 	}
 	return "";
 }
 
 void PwMViewStyle::addCategory(const QString &cat)
 {
 	switch (curStyle) {
 	case style_0:
 		PWM_ASSERT(s0);
 		s0->addCategory(cat);
 		return;
 	case style_1:
 		PWM_ASSERT(s1);
 		s1->addCategory(cat);
 		return;
 	default:
 		BUG();
 	}
 }
 
 void PwMViewStyle::delCategory(const QString &cat)
 {
 	switch (curStyle) {
 	case style_0:
 		PWM_ASSERT(s0);
 		s0->delCategory(cat);
 		return;
 	case style_1:
 		PWM_ASSERT(s1);
 		s1->delCategory(cat);
 		return;
 	default:
 		BUG();
 	}
 }
 
 void PwMViewStyle::delAllCategories()
 {
 	switch (curStyle) {
 	case style_0:
 		PWM_ASSERT(s0);
 		s0->delAllCategories();
 		return;
 	case style_1:
 		PWM_ASSERT(s1);
 		s1->delAllCategories();
 		return;
 	default:
 		BUG();
 	}
 }
 
 void PwMViewStyle::selectCategory(const QString &cat)
 {
 	switch (curStyle) {
 	case style_0:
 		PWM_ASSERT(s0);
 		s0->selectCategory(cat);
 		return;
 	case style_1:
 		PWM_ASSERT(s1);
 		s1->selectCategory(cat);
 		return;
 	default:
 		BUG();
 	}
 }
 
 int PwMViewStyle::numCategories()
 {
 	switch (curStyle) {
 	case style_0:
 		PWM_ASSERT(s0);
 		return s0->numCategories();
 	case style_1:
 		PWM_ASSERT(s1);
 		return s1->numCategories();
 	default:
 		BUG();
 	}
 	return 0;
 }
 
 #ifndef PWM_EMBEDDED
 #include "pwmviewstyle.moc"
 #endif
diff --git a/pwmanager/pwmanager/pwmviewstyle_0.cpp b/pwmanager/pwmanager/pwmviewstyle_0.cpp
index 6d46ac6..7262684 100644
--- a/pwmanager/pwmanager/pwmviewstyle_0.cpp
+++ b/pwmanager/pwmanager/pwmviewstyle_0.cpp
@@ -1,93 +1,112 @@
 /***************************************************************************
  *                                                                         *
  *   copyright (C) 2004 by Michael Buesch                                  *
  *   email: mbuesch@freenet.de                                             *
  *                                                                         *
  *   This program is free software; you can redistribute it and/or modify  *
  *   it under the terms of the GNU General Public License version 2        *
  *   as published by the Free Software Foundation.                         *
  *                                                                         *
  ***************************************************************************/
 
 /***************************************************************************
  * copyright (C) 2004 by Ulf Schenk
  * This file is originaly based on version 1.0.1 of pwmanager
  * and was modified to run on embedded devices that run microkde
  *
  * $Id$
  **************************************************************************/  
 
 #include "pwmviewstyle_0.h"
 #include "pwmview.h"
 #include "listviewpwm.h"
 #include "commentbox.h"
 
 #include <klocale.h>
-
+#include "pwmprefs.h"
 
 PwMViewStyle_0::PwMViewStyle_0(PwMView *view)
  : QObject()
 {
 	vbox1 = new QVBox(view);
 	vbox1->setSpacing(3);
 	hbox1 = new QHBox(vbox1);
 	hbox1->setSpacing(10);
 	categoriesTitle = new QLabel(hbox1);
 	categoriesTitle->setText(i18n("Categories:"));
 	categoriesCombo = new QComboBox(hbox1);
 	renCatButton = new QPushButton(i18n("&Rename"), hbox1);
 	delCatButton = new QPushButton(i18n("&Delete"), hbox1);
 #ifndef PWM_EMBEDDED
 	splitter1 = new QSplitter(vbox1);
 	splitter1->setOrientation(Qt::Vertical);
 #else
 	splitter1 = new KDGanttMinimizeSplitter( Qt::Vertical, vbox1);
 	splitter1->setMinimizeDirection ( KDGanttMinimizeSplitter::Up );
 
 	//US  topLayout->addWidget(mMiniSplitter );
 #endif
 	lv = new ListViewPwM(splitter1);
 	commentBox = new CommentBox(splitter1);
 	// set sizes and styles
 	commentBox->resize(commentBox->size().width(), 60);
 	categoriesTitle->setAlignment(Qt::AlignVCenter | Qt::AlignRight);
 	// connections
 	connect(categoriesCombo, SIGNAL(activated(int)),
 		view, SLOT(shiftToView()));
 	connect(renCatButton, SIGNAL(clicked()),
 		view, SLOT(renCatButton_slot()));
 	connect(delCatButton, SIGNAL(clicked()),
 		view, SLOT(delCatButton_slot()));
 }
 
 PwMViewStyle_0::~PwMViewStyle_0()
 {
 	delete vbox1;
 }
 
 void PwMViewStyle_0::delCategory(const QString &cat)
 {
 	PWM_ASSERT(categoriesCombo);
 	int i, count = categoriesCombo->count();
 	for (i = 0; i < count; ++i) {
 		if (categoriesCombo->text(i) == cat) {
 			categoriesCombo->removeItem(i);
 			return;
 		}
 	}
 	BUG();
 }
 
 void PwMViewStyle_0::selectCategory(const QString &cat)
 {
 	PWM_ASSERT(categoriesCombo);
 	int i, count = categoriesCombo->count();
 	for (i = 0; i < count; ++i) {
 		if (categoriesCombo->text(i) == cat) {
 			categoriesCombo->setCurrentItem(i);
 			return;
 		}
 	}
 	// fall back to 0
 	categoriesCombo->setCurrentItem(0);
 }
+
+
+//US ENH: I need a place to load the view dependend settings. Eg. splittersize
+void PwMViewStyle_0::restoreSettings(PWMPrefs* prefs)
+{
+  //load and store the size of the listviewcolumns
+  lv->restoreLayout(prefs->getConfig(), "listview");
+  splitter1->setSizes( prefs->mCommentSplitter );
+
+}
+
+//US ENH: I need a place to load the view dependend settings. Eg. splittersize
+void PwMViewStyle_0::saveSettings(PWMPrefs* prefs)
+{
+  //store the size of the listviewcolumns
+  lv->saveLayout(prefs->getConfig(), "listview");
+  prefs->mCommentSplitter = splitter1->sizes();
+
+}
diff --git a/pwmanager/pwmanager/pwmviewstyle_0.h b/pwmanager/pwmanager/pwmviewstyle_0.h
index cc564c3..bd93c06 100644
--- a/pwmanager/pwmanager/pwmviewstyle_0.h
+++ b/pwmanager/pwmanager/pwmviewstyle_0.h
@@ -1,99 +1,105 @@
 /***************************************************************************
  *                                                                         *
  *   copyright (C) 2004 by Michael Buesch                                  *
  *   email: mbuesch@freenet.de                                             *
  *                                                                         *
  *   This program is free software; you can redistribute it and/or modify  *
  *   it under the terms of the GNU General Public License version 2        *
  *   as published by the Free Software Foundation.                         *
  *                                                                         *
  ***************************************************************************/
 
 /***************************************************************************
  * copyright (C) 2004 by Ulf Schenk
  * This file is originaly based on version 1.0.1 of pwmanager
  * and was modified to run on embedded devices that run microkde
  *
  * $Id$
  **************************************************************************/  
 
 #ifndef PWMVIEWSTYLE_0_H
 #define PWMVIEWSTYLE_0_H
 
 #include <qhbox.h>
 #include <qvbox.h>
 #include <qpushbutton.h>
 #ifndef PWM_EMBEDDED
 #include <qtextedit.h>
 #include <qsplitter.h>
 #else
 #include <qmultilineedit.h>
 #include <KDGanttMinimizeSplitter.h>
 #endif
 #include <qlabel.h>
 #include <qcombobox.h>
 
 class PwMView;
 class ListViewPwM;
 class CommentBox;
+class PWMPrefs;
 
 class PwMViewStyle_0 : public QObject
 {
 public:
 	PwMViewStyle_0(PwMView *view);
 	~PwMViewStyle_0();
 
 	ListViewPwM * getLv()
 			{ return lv; }
 	CommentBox * getCommentBox()
 			{ return commentBox; }
 
 	/** returns the currently selected category */
 	QString getCurrentCategory()
 			{ return categoriesCombo->currentText(); }
 	/** add Category to the view */
 	void addCategory(const QString &cat)
 			{ categoriesCombo->insertItem(cat); }
 	/** delete Category from view */
 	void delCategory(const QString &cat);
 	/** delete all categories from view */
 	void delAllCategories()
 			{ categoriesCombo->clear(); }
 	/** select the specified category */
 	void selectCategory(const QString &cat);
 	/** returns the number of categories in this view.
 	  * This value dosn't say anything about the number of
 	  * categories in the document.
 	  */
 	int numCategories()
 			{ return categoriesCombo->count(); }
 	/** resize the view */
 	void resize(const QSize &size)
 			{ vbox1->resize(size); }
 
+	//US ENH: I need a place to load the view dependend settings. Eg. splittersize
+	void restoreSettings(PWMPrefs* prefs);
+	void saveSettings(PWMPrefs* prefs);
+
+
 protected:
 	/** main list view */
 	ListViewPwM *lv;
 	/** categories combo-box */
 	QComboBox *categoriesCombo;
 	/** title string for the categories combo or list box */
 	QLabel *categoriesTitle;
 	/** hbox1 for widget style */
 	QHBox *hbox1;
 	/** vbox1 for widget style */
 	QVBox *vbox1;
 	/** splitter for commentTextEdit */
 #ifndef PWM_EMBEDDED	
 	QSplitter *splitter1;
 #else
 	KDGanttMinimizeSplitter * splitter1;
 #endif
 	/** push button to change the category name */
 	QPushButton *renCatButton;
 	/** push button to delete the category */
 	QPushButton *delCatButton;
 	/** comment box */
 	CommentBox *commentBox;
 };
 
 #endif
diff --git a/pwmanager/pwmanager/pwmviewstyle_1.cpp b/pwmanager/pwmanager/pwmviewstyle_1.cpp
index 4c24bc4..8b2d6d3 100644
--- a/pwmanager/pwmanager/pwmviewstyle_1.cpp
+++ b/pwmanager/pwmanager/pwmviewstyle_1.cpp
@@ -1,130 +1,150 @@
 /***************************************************************************
  *                                                                         *
  *   copyright (C) 2004 by Michael Buesch                                  *
  *   email: mbuesch@freenet.de                                             *
  *                                                                         *
  *   This program is free software; you can redistribute it and/or modify  *
  *   it under the terms of the GNU General Public License version 2        *
  *   as published by the Free Software Foundation.                         *
  *                                                                         *
  ***************************************************************************/
 
 /***************************************************************************
  * copyright (C) 2004 by Ulf Schenk
  * This file is originaly based on version 1.0.1 of pwmanager
  * and was modified to run on embedded devices that run microkde
  *
  * $Id$
  **************************************************************************/  
 
 #include "pwmviewstyle_1.h"
 #include "pwmview.h"
 #include "listviewpwm.h"
 #include "commentbox.h"
 
 #include <klocale.h>
+#include "pwmprefs.h"
 
 #define INITIAL_CATEGORIES_WIDTH	100
 
 PwMViewStyle_1::PwMViewStyle_1(PwMView *view)
  : QObject()
 {
 #ifndef PWM_EMBEDDED
 	splitter = new QSplitter(view);
 #else
 	splitter = new KDGanttMinimizeSplitter( Qt::Horizontal, view);
 	splitter->setMinimizeDirection ( KDGanttMinimizeSplitter::Right );
 
 	//US  topLayout->addWidget(mMiniSplitter );
 #endif
 
 	vbox1 = new QVBox(splitter);
 	categoriesTitle = new QLabel(vbox1);
 	categoriesList = new QListBox(vbox1);
 #ifndef PWM_EMBEDDED
 	splitter2 = new QSplitter(splitter);
 	splitter2->setOrientation(Qt::Vertical);
 #else
 	splitter2 = new KDGanttMinimizeSplitter( Qt::Vertical, splitter);
 	splitter2->setMinimizeDirection ( KDGanttMinimizeSplitter::Right );
 
 	//US  topLayout->addWidget(mMiniSplitter );
 #endif
 	lv = new ListViewPwM(splitter2);
 	commentBox = new CommentBox(splitter2);
 	// set sizes and styles
 	commentBox->resize(commentBox->size().width(), 60);
 	QValueList<int> sizes;
 #ifndef PWM_EMBEDDED
 	sizes.push_back(INITIAL_CATEGORIES_WIDTH);
 	sizes.push_back(view->height() - INITIAL_CATEGORIES_WIDTH);
 #else
 	sizes.append(INITIAL_CATEGORIES_WIDTH);
 	sizes.append(view->height() - INITIAL_CATEGORIES_WIDTH);
 #endif
 	splitter->setSizes(sizes);
 	categoriesTitle->setAlignment(Qt::AlignHCenter);
 #ifndef PWM_EMBEDDED
 	categoriesTitle->setFrameShape(QFrame::MenuBarPanel);
 #else
 	categoriesTitle->setFrameShape(QFrame::StyledPanel);
 #endif
 	categoriesTitle->setText(i18n("Categories:"));
 	catCtxMenu = new QPopupMenu(view);
 	catCtxMenu->insertItem(i18n("&Rename"),
 			       view, SLOT(renCatButton_slot()));
 	catCtxMenu->insertItem(i18n("&Delete"),
 			       view, SLOT(delCatButton_slot()));
 	// connections
 	connect(categoriesList, SIGNAL(highlighted(int)),
 		view, SLOT(shiftToView()));
 	connect(categoriesList,
 		SIGNAL(rightButtonClicked(QListBoxItem *, const QPoint &)),
 		this,
 		SLOT(catRightClick(QListBoxItem *, const QPoint &)));
 }
 
 PwMViewStyle_1::~PwMViewStyle_1()
 {
 	delete catCtxMenu;
 	delete splitter;
 }
 
 void PwMViewStyle_1::catRightClick(QListBoxItem *item, const QPoint &point)
 {
 	if (!item)
 		return;
 	catCtxMenu->move(point);
 	catCtxMenu->show();
 }
 
 void PwMViewStyle_1::delCategory(const QString &cat)
 {
 	PWM_ASSERT(categoriesList);
 	int i, count = categoriesList->count();
 	for (i = 0; i < count; ++i) {
 		if (categoriesList->text(i) == cat) {
 			categoriesList->removeItem(i);
 			return;
 		}
 	}
 	BUG();
 }
 
 void PwMViewStyle_1::selectCategory(const QString &cat)
 {
 	PWM_ASSERT(categoriesList);
 	int i, count = categoriesList->count();
 	for (i = 0; i < count; ++i) {
 		if (categoriesList->text(i) == cat) {
 			categoriesList->setCurrentItem(i);
 			return;
 		}
 	}
 	// fall back to 0
 	categoriesList->setCurrentItem(0);
 }
 
+//US ENH: I need a place to load the view dependend settings. Eg. splittersize
+void PwMViewStyle_1::restoreSettings(PWMPrefs* prefs)
+{
+  //load and store the size of the listviewcolumns
+  lv->restoreLayout(prefs->getConfig(), "listview");
+  splitter2->setSizes( prefs->mCommentSplitter );
+
+}
+
+//US ENH: I need a place to load the view dependend settings. Eg. splittersize
+void PwMViewStyle_1::saveSettings(PWMPrefs* prefs)
+{
+  //store the size of the listviewcolumns
+  lv->saveLayout(prefs->getConfig(), "listview");
+  prefs->mCommentSplitter = splitter2->sizes();
+
+}
+
+
 #ifndef PWM_EMBEDDED
 #include "pwmviewstyle_1.moc"
 #endif
diff --git a/pwmanager/pwmanager/pwmviewstyle_1.h b/pwmanager/pwmanager/pwmviewstyle_1.h
index a50f587..a7f100c 100644
--- a/pwmanager/pwmanager/pwmviewstyle_1.h
+++ b/pwmanager/pwmanager/pwmviewstyle_1.h
@@ -1,107 +1,112 @@
 /***************************************************************************
  *                                                                         *
  *   copyright (C) 2004 by Michael Buesch                                  *
  *   email: mbuesch@freenet.de                                             *
  *                                                                         *
  *   This program is free software; you can redistribute it and/or modify  *
  *   it under the terms of the GNU General Public License version 2        *
  *   as published by the Free Software Foundation.                         *
  *                                                                         *
  ***************************************************************************/
 
 /***************************************************************************
  * copyright (C) 2004 by Ulf Schenk
  * This file is originaly based on version 1.0.1 of pwmanager
  * and was modified to run on embedded devices that run microkde
  *
  * $Id$
  **************************************************************************/  
 
 #ifndef PWMVIEWSTYLE_1_H
 #define PWMVIEWSTYLE_1_H
 
 #include <qvbox.h>
 
 #ifndef PWM_EMBEDDED
 #include <qtextedit.h>
 #include <qsplitter.h>
 #else
 #include <qmultilineedit.h>
 #include <KDGanttMinimizeSplitter.h>
 #endif
 
 #include <qlabel.h>
 #include <qlistbox.h>
 #include <qpopupmenu.h>
 
 class PwMView;
 class ListViewPwM;
 class CommentBox;
+class PWMPrefs;
 
 class PwMViewStyle_1 : public QObject
 {
 	Q_OBJECT
 public:
 	PwMViewStyle_1(PwMView *view);
 	~PwMViewStyle_1();
 
 	ListViewPwM * getLv()
 			{ return lv; }
 	CommentBox * getCommentBox()
 			{ return commentBox; }
 
 	/** returns the currently selected category */
 	QString getCurrentCategory()
 			{ return categoriesList->currentText(); }
 	/** add Category to the view */
 	void addCategory(const QString &cat)
 			{ categoriesList->insertItem(cat); }
 	/** delete Category from view */
 	void delCategory(const QString &cat);
 	/** delete all categories from view */
 	void delAllCategories()
 			{ categoriesList->clear(); }
 	/** select the specified category */
 	void selectCategory(const QString &cat);
 	/** returns the number of categories in this view.
 	  * This value dosn't say anything about the number of
 	  * categories in the document.
 	  */
 	int numCategories()
 			{ return categoriesList->count(); }
 	/** resize the view */
 	void resize(const QSize &size)
 			{ splitter->resize(size); }
 
+	//US ENH: I need a place to load the view dependend settings. Eg. splittersize
+	void restoreSettings(PWMPrefs* prefs);
+	void saveSettings(PWMPrefs* prefs);
+
 protected slots:
 	/** user clicked right button in category list */
 	void catRightClick(QListBoxItem *item, const QPoint &point);
 
 protected:
 	/** main list view */
 	ListViewPwM *lv;
 #ifndef PWM_EMBEDDED
 	/** main splitter widget */
 	QSplitter *splitter;
 	/** commentTextEdit splitter */
 	QSplitter *splitter2;
 #else
 	/** main splitter widget */
 	KDGanttMinimizeSplitter *splitter;
 	/** commentTextEdit splitter */
 	KDGanttMinimizeSplitter *splitter2;
 #endif
 
 	/** categories list-box */
 	QListBox *categoriesList;
 	/** title string for the categories combo or list box */
 	QLabel *categoriesTitle;
 	/** hbox1 for widget style */
 	QVBox *vbox1;
 	/** text-edit to display the comment */
 	CommentBox *commentBox;
 	/** category list context menu */
 	QPopupMenu *catCtxMenu;
 };
 
 #endif
diff --git a/pwmanager/pwmanager/serializer.cpp b/pwmanager/pwmanager/serializer.cpp
index 9377e3d..a54ba8a 100644
--- a/pwmanager/pwmanager/serializer.cpp
+++ b/pwmanager/pwmanager/serializer.cpp
@@ -151,527 +151,513 @@ Serializer::Serializer(const QCString &buffer)
 Serializer::~Serializer()
 {
 	delete_ifnot_null(domDoc);
 }
 
 void Serializer::clear()
 {
 	delete_ifnot_null(domDoc);
 	domDoc = new QDomDocument;
 }
 
 bool Serializer::parseXml(const QCString &buffer)
 {
 	PWM_ASSERT(domDoc);
 #ifndef PWM_EMBEDDED
 	if (!domDoc->setContent(buffer, true))
 		return false;
 #else
 	if (!domDoc->setContent(buffer))
 		return false;
 #endif
 	if (!checkValid())
 		return false;
 	return true;
 }
 
 QCString Serializer::getXml()
 {
 	PWM_ASSERT(domDoc);
 
 #ifndef PWM_EMBEDDED
 #if defined(PWM_DEBUG) && SERIALIZER_DEBUG != 0
 	QCString tmp(domDoc->toCString(8));
 	printDebug("<BEGIN Serializer::getXml() dump>\n");
 	cout << tmp << endl;
 	printDebug("<END Serializer::getXml() dump>");
 #endif // DEBUG
 
 	QCString ret(domDoc->toCString(0));
 	ret.replace('\n', "");
 	return ret;
 #else
 
 #if defined(PWM_DEBUG) && SERIALIZER_DEBUG != 0
 	QCString tmp("        " + domDoc->toCString());
 	printDebug("<BEGIN Serializer::getXml() dump>\n");
 	qDebug(tmp);
 	cout << tmp << endl;
 	printDebug("<END Serializer::getXml() dump>");
 #endif // DEBUG
 
 	QCString ret(domDoc->toCString());
 	ret.replace(QRegExp("\n"), "");
 	return ret;
 
 #endif
 }
 
 bool Serializer::serialize(const vector<PwMCategoryItem> &dta)
 {
 	PWM_ASSERT(domDoc);
 	QDomElement root(genNewRoot());
 	QDomElement catNode(domDoc->createElement(CAT_ROOT_WR));
 	root.appendChild(catNode);
 	if (!addCategories(&catNode, dta))
 		return false;
 	return true;
 }
 
 bool Serializer::deSerialize(vector<PwMCategoryItem> *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)) {
 				return false;
 			}
 
 			/* NOTE: We can stop processing here, as we
 			 *       don't have more nodes in root, yet.
 			 */
 			return true;
 		}
 	}
 	return false;
 }
 
 bool Serializer::readCategories(const QDomNode &n,
 				vector<PwMCategoryItem> *dta)
 {
 	QDomNodeList nl(n.childNodes());
 	QDomNode cur;
 	QString name;
 	unsigned int numCat = nl.count(), i;
 	PwMCategoryItem curCat;
 	vector<PwMDataItem> curEntr;
 
 	if (!numCat) {
 		printDebug("Serializer::readCategories(): empty");
 		return false;
 	}
 	for (i = 0; i < numCat; ++i) {
 		cur = nl.item(i);
 		if (cur.nodeName().left(1) == CAT_PREFIX_NEW ||
 		    cur.nodeName().left(4) == CAT_PREFIX_OLD) {
 			name = cur.toElement().attribute(CAT_NAME_NEW);
 			if (name == QString::null)
 				name = cur.toElement().attribute(CAT_NAME_OLD);
 			PWM_ASSERT(name != QString::null);
 			PWM_ASSERT(name != "");
 			curCat.clear();
 			curCat.name = name.latin1();
 			if (!readEntries(cur, &curEntr)) {
 				dta->clear();
 				return false;
 			}
 			curCat.d = curEntr;
 			dta->push_back(curCat);
 		} else {
 			printDebug("Serializer::readCategories(): uh? not a category?");
 		}
 	}
 	return true;
 }
 
 bool Serializer::readEntries(const QDomNode &n,
 			     vector<PwMDataItem> *dta)
 {
 	QDomNodeList nl(n.childNodes());
 	QDomNode cur;
 	unsigned int numEntr = nl.count(), i;
 	PwMDataItem curEntr;
 
 	dta->clear();
 	for (i = 0; i < numEntr; ++i) {
 		cur = nl.item(i);
 		if (cur.nodeName().left(1) == ENTRY_PREFIX_NEW ||
 		    cur.nodeName().left(6) == ENTRY_PREFIX_OLD) {
 			if (!extractEntry(cur, &curEntr)) {
 				return false;
 			}
 			dta->push_back(curEntr);
 		} else {
 			printDebug("Serializer::readEntries(): hm? not an entry?");
 		}
 	}
 	return true;
 }
 
 bool Serializer::extractEntry(const QDomNode &n,
 			      PwMDataItem *dta)
 {
 	QDomNodeList nl(n.childNodes());
 	QDomNode cur, cdata;
 	unsigned int cnt = nl.count(), i;
 	QString name, text;
 
 	if (!cnt) {
 		printDebug("Serializer::extractEntry(): empty");
 		return false;
 	}
 	dta->clear();
 	for (i = 0; i < cnt; ++i) {
 		cur = nl.item(i);
 		name = cur.nodeName();
 		cdata = cur.firstChild();
 		if (unlikely(cdata.isCDATASection())) {
 			text = cdata.toCDATASection().data();
 		} else if (likely(cur.isElement())) {
 			text = cur.toElement().text();
 		} else {
 			printDebug("Serializer::extractEntry(): neither CDATA nor element.");
 			return false;
 		}
 		if (text == " ")
 			text = ""; // for backward compatibility.
 		if (name == ENTRY_DESC_NEW ||
 		    name == ENTRY_DESC_OLD) {
 			dta->desc = unescapeEntryData(text).latin1();
 		} else if (name == ENTRY_NAME_NEW ||
 			   name == ENTRY_NAME_OLD) {
 			dta->name = unescapeEntryData(text).latin1();
 		} else if (name == ENTRY_PW_NEW ||
 			   name == ENTRY_PW_OLD) {
 			dta->pw = unescapeEntryData(text).latin1();
 		} else if (name == ENTRY_COMMENT_NEW ||
 			   name == ENTRY_COMMENT_OLD) {
 			dta->comment = unescapeEntryData(text).latin1();
 		} else if (name == ENTRY_URL_NEW ||
 			   name == ENTRY_URL_OLD) {
 			dta->url = unescapeEntryData(text).latin1();
 		} else if (name == ENTRY_LAUNCHER_NEW ||
 			   name == ENTRY_LAUNCHER_OLD) {
 			dta->launcher = unescapeEntryData(text).latin1();
 		} else if (name == ENTRY_LVP_NEW ||
 			   name == ENTRY_LVP_OLD) {
 			dta->listViewPos = strtol(text.latin1(), 0, 10);
 		} else if (name == ENTRY_BIN_NEW) {
 			// ENTRY_BIN_NEW == ENTRY_BIN_OLD
 			if (text == "0") {
 				dta->binary = false;
 			} else {
 				dta->binary = true;
 			}
 		} else if (name == ENTRY_META_NEW) {
 			// ENTRY_META_NEW == ENTRY_META_OLD
 			if (!extractMeta(cur, &dta->meta))
 				return false;
 		} else {
 			printDebug(string("Serializer::extractEntry(): invalid: ")
 				   + name.latin1());
 		}
 	}
 	dta->lockStat = defaultLockStat;
 	return true;
 }
 
 bool Serializer::extractMeta(const QDomNode &n,
 			     PwMMetaData *dta)
 {
 	QDomNode cur(n.firstChild());
 	QString name, val;
 	while (!cur.isNull()) {
 		name = cur.nodeName();
 		val = cur.toElement().text();
 		if (val == "") {
 			cur = cur.nextSibling();
 			continue;
 		}
 #ifndef PWM_EMBEDDED
 		if (name == META_CREATE_DATE) {
 			dta->create = QDateTime::fromString(val, Qt::ISODate);
 		} else if (name == META_VALID_DATE) {
 			dta->valid = QDateTime::fromString(val, Qt::ISODate);
 		} else if (name == META_EXPIRE_DATE) {
 			dta->expire = QDateTime::fromString(val, Qt::ISODate);
 		} else if (name == META_UPDATE_DATE) {
 			dta->update = QDateTime::fromString(val, Qt::ISODate);
 		} else if (name == META_UPDATE_INT) {
 			dta->updateInt = strtoul(val.latin1(), 0, 10);
 		} else if (name == META_UNIQUEID) {
 			dta->uniqueid = unescapeEntryData(val).latin1();
 		} else {
 			printDebug(string("extractMeta(): invalid: ")
 				   + name.latin1());
 		}
 #else
 
-		QDateTime m_dt;
-
-		if ((name == META_CREATE_DATE) ||
-		    (name == META_VALID_DATE)  ||
-		    (name == META_EXPIRE_DATE) ||
-		    (name == META_UPDATE_DATE)) 
-		  {
-		    int pos = val.find("T");
-		    QString date = val.left(pos);
-		    QString time = val.mid(pos+1);
-		    qDebug("Serializer::extractMeta from %s to date=%s ,time=%s",val.latin1(), date.latin1(), time.latin1()  );
-		    bool ok1, ok2;
-
-		    QDate m_date = KGlobal::locale()->readDate(date, &ok1);
-		    QTime m_time = KGlobal::locale()->readTime(time, &ok2);
-		    if ((ok1 == false) || (ok2 == false))
-		      qDebug("Serializer::extractMeta invalid date or time !!!!!!!!!!!!!");
-		    m_dt.setDate(m_date);
-		    m_dt.setTime(m_time);
-		  }
 
+		bool ok = true;
 
 		if (name == META_CREATE_DATE) {
-			dta->create = m_dt;
+			dta->create = KGlobal::locale()->readDateTime(val, KLocale::ISODate, &ok);
 		} else if (name == META_VALID_DATE) {
-			dta->valid = m_dt;
+			dta->valid = KGlobal::locale()->readDateTime(val, KLocale::ISODate, &ok);
 		} else if (name == META_EXPIRE_DATE) {
-		  dta->expire = m_dt;
+		  dta->expire = KGlobal::locale()->readDateTime(val, KLocale::ISODate, &ok);
 		} else if (name == META_UPDATE_DATE) {
-		  dta->update = m_dt;
+		  dta->update = KGlobal::locale()->readDateTime(val, KLocale::ISODate, &ok);
 		} else if (name == META_UPDATE_INT) {
 			dta->updateInt = strtoul(val.latin1(), 0, 10);
 		} else if (name == META_UNIQUEID) {
 			dta->uniqueid = unescapeEntryData(val).latin1();
 		} else {
 			printDebug(string("extractMeta(): invalid: ")
 				   + name.latin1());
 		}
+
+		if (ok == false)
+		  qDebug("Serializer::extractMeta invalid date or time !!!!!!!!!!!!!");
+
+
 #endif
 		cur = cur.nextSibling();
 	}
 	return true;
 }
 
 bool Serializer::checkValid()
 {
 	PWM_ASSERT(domDoc);
 	QDomElement root(domDoc->documentElement());
 	if (root.nodeName() != ROOT_MAGIC_NEW &&
 	    root.nodeName() != ROOT_MAGIC_OLD) {
 		printDebug("Serializer: wrong magic");
 		return false;
 	}
 	if (root.attribute(VER_STR_NEW) != COMPAT_VER_NEW &&
 	    root.attribute(VER_STR_OLD) != COMPAT_VER_OLD) {
 		printDebug("Serializer: wrong version");
 		return false;
 	}
 	return true;
 }
 
 QDomElement Serializer::genNewRoot()
 {
 	PWM_ASSERT(domDoc);
 	QDomElement root(domDoc->createElement(ROOT_MAGIC_WR));
 	root.setAttribute(VER_STR_WR, COMPAT_VER_WR);
 	domDoc->appendChild(root);
 	return root;
 }
 
 bool Serializer::addCategories(QDomElement *e,
 			       const vector<PwMCategoryItem> &dta)
 {
 	unsigned int numCat = dta.size(), i;
 	QString curId, curName;
 	QDomElement curCat;
 
 	for (i = 0; i < numCat; ++i) {
 		curId = CAT_PREFIX_WR;
 		curId += tostr(i).c_str();
 		curName = dta[i].name.c_str();
 		curCat = domDoc->createElement(curId);
 		curCat.setAttribute(CAT_NAME_WR, curName);
 		if (!addEntries(&curCat, dta[i].d)) {
 			return false;
 		}
 		e->appendChild(curCat);
 	}
 	return true;
 }
 
 bool Serializer::addEntries(QDomElement *e,
 			    const vector<PwMDataItem> &dta)
 {
 	unsigned int numEntr = dta.size(), i;
 	QString curId;
 	QDomElement curEntr;
 
 	for (i = 0; i < numEntr; ++i) {
 		curId = ENTRY_PREFIX_WR;
 		curId += tostr(i).c_str();
 		curEntr = domDoc->createElement(curId);
 		if (!writeEntry(&curEntr, dta[i])) {
 			return false;
 		}
 		e->appendChild(curEntr);
 	}
 	return true;
 }
 
 bool Serializer::writeEntry(QDomElement *e,
 			    const PwMDataItem &_dta)
 {
 #if WRITE_CDATA_SEC != 0
 # define new_text(x)	domDoc->createCDATASection(x)
 	QDomCDATASection curText;
 #else
 # define new_text(x)	domDoc->createTextNode(x)
 	QDomText curText;
 #endif
 
 	QDomText plainText;
 	QDomElement tag;
 
 	// begin -- This is for compatibility with the old serializer
 	PwMDataItem dta = _dta;
 	if (!dta.desc.size())
 		dta.desc = " ";
 	if (!dta.name.size())
 		dta.name = " ";
 	if (!dta.pw.size())
 		dta.pw = " ";
 	if (!dta.comment.size())
 		dta.comment = " ";
 	if (!dta.url.size())
 		dta.url = " ";
 	if (!dta.launcher.size())
 		dta.launcher = " ";
 	// end -- This is for compatibility with the old serializer
 
 	tag = domDoc->createElement(ENTRY_DESC_WR);
 	curText = new_text(escapeEntryData(dta.desc.c_str()));
 	tag.appendChild(curText);
 	e->appendChild(tag);
 
 	tag = domDoc->createElement(ENTRY_NAME_WR);
 	curText = new_text(escapeEntryData(dta.name.c_str()));
 	tag.appendChild(curText);
 	e->appendChild(tag);
 
 	tag = domDoc->createElement(ENTRY_PW_WR);
 	curText = new_text(escapeEntryData(dta.pw.c_str()));
 	tag.appendChild(curText);
 	e->appendChild(tag);
 
 	tag = domDoc->createElement(ENTRY_COMMENT_WR);
 	curText = new_text(escapeEntryData(dta.comment.c_str()));
 	tag.appendChild(curText);
 	e->appendChild(tag);
 
 	tag = domDoc->createElement(ENTRY_URL_WR);
 	curText = new_text(escapeEntryData(dta.url.c_str()));
 	tag.appendChild(curText);
 	e->appendChild(tag);
 
 	tag = domDoc->createElement(ENTRY_LAUNCHER_WR);
 	curText = new_text(escapeEntryData(dta.launcher.c_str()));
 	tag.appendChild(curText);
 	e->appendChild(tag);
 
 	tag = domDoc->createElement(ENTRY_LVP_WR);
 	plainText = domDoc->createTextNode(tostr(dta.listViewPos).c_str());
 	tag.appendChild(plainText);
 	e->appendChild(tag);
 
 	tag = domDoc->createElement(ENTRY_BIN_WR);
 	if (dta.binary)
 		plainText = domDoc->createTextNode("1");
 	else
 		plainText = domDoc->createTextNode("0");
 	tag.appendChild(plainText);
 	e->appendChild(tag);
 
 	tag = domDoc->createElement(ENTRY_META_WR);
 	if (!writeMeta(&tag, dta.meta))
 		return false;
 	e->appendChild(tag);
 
 #undef new_text
 	return true;
 }
 
 bool Serializer::writeMeta(QDomElement *e,
 			   const PwMMetaData &dta)
 {
 	QDomText text;
 	QDomElement tag;
 
 	tag = domDoc->createElement(META_CREATE_DATE);
 #ifndef PWM_EMBEDDED
 	text = domDoc->createTextNode(dta.create.toString(Qt::ISODate));
 #else
 	text = domDoc->createTextNode(KGlobal::locale()->formatDateTime(dta.create,  KLocale::ISODate));
 #endif
 	tag.appendChild(text);
 	e->appendChild(tag);
 
 	tag = domDoc->createElement(META_VALID_DATE);
 #ifndef PWM_EMBEDDED
 	text = domDoc->createTextNode(dta.valid.toString(Qt::ISODate));
 #else
 	text = domDoc->createTextNode(KGlobal::locale()->formatDateTime(dta.valid,  KLocale::ISODate));
 #endif
 	tag.appendChild(text);
 	e->appendChild(tag);
 
 	tag = domDoc->createElement(META_EXPIRE_DATE);
 #ifndef PWM_EMBEDDED
 	text = domDoc->createTextNode(dta.expire.toString(Qt::ISODate));
 #else
 	text = domDoc->createTextNode(KGlobal::locale()->formatDateTime(dta.expire,  KLocale::ISODate));
 #endif
 	tag.appendChild(text);
 	e->appendChild(tag);
 
 	tag = domDoc->createElement(META_UPDATE_DATE);
 #ifndef PWM_EMBEDDED
 	text = domDoc->createTextNode(dta.update.toString(Qt::ISODate));
 #else
 	text = domDoc->createTextNode(KGlobal::locale()->formatDateTime(dta.update,  KLocale::ISODate));
 #endif
 	tag.appendChild(text);
 	e->appendChild(tag);
 
 	tag = domDoc->createElement(META_UPDATE_INT);
 	text = domDoc->createTextNode(tostr(dta.updateInt).c_str());
 	tag.appendChild(text);
 	e->appendChild(tag);
 
 	tag = domDoc->createElement(META_UNIQUEID);
 	text = domDoc->createTextNode(escapeEntryData(dta.uniqueid));
 	tag.appendChild(text);
 	e->appendChild(tag);
 
 #undef new_text
 	return true;
 }
 
 QString Serializer::escapeEntryData(QString dta)
 {
 #ifndef PWM_EMBEDDED
 	dta.replace('\n', "$>--endl--<$");
 	dta.replace("]]>", "||>");
 #else
 	dta.replace(QRegExp("\n"), "$>--endl--<$");
 	dta.replace(QRegExp("]]>"), "||>");
 #endif
 	return dta;
 }
 
 QString Serializer::unescapeEntryData(QString dta)
 {
 #ifndef PWM_EMBEDDED
 	dta.replace("$>--endl--<$", "\n");
 	dta.replace("||>", "]]>");
 #else
 	dta.replace(QRegExp("$>--endl--<$"), "\n");
 	dta.replace(QRegExp("||>"), "]]>");
 #endif
 	return dta;
 }