1 files changed, 7 insertions, 2 deletions

diff --git a/noncore/apps/keyz-cfg/cfgfile.cpp b/noncore/apps/keyz-cfg/cfgfile.cpp
index 81d1ee1..be7150e 100644
--- a/noncore/apps/keyz-cfg/cfgfile.cpp
+++ b/noncore/apps/keyz-cfg/cfgfile.cpp
@@ -1,344 +1,349 @@
 #include "cfgfile.h"
 
 /* OPIE */
 #include <opie2/odebug.h>
 using namespace Opie::Core;
 
 /* QT */
 #include <qmessagebox.h>
 
 // CfgEntry implementation
 CfgEntry::CfgEntry() {
 }
 
 CfgEntry::CfgEntry(const QString& f, const QString& l):
 	file(f), label(l) {
 }
 
 const QString& CfgEntry::getFile() const {
 	return file;
 }
 
 void CfgEntry::setFile(const QString& f) {
 	file = f;
 }
 
 const QString& CfgEntry::getLabel() const {
 	return label;
 }
 
 void CfgEntry::setLabel(const QString& f) {
 	label = f;
 }
 
 // CfgFile implementation
 CfgFile::CfgFile():ardelay(400), arperiod(80) {
 }
 
 CfgFile::~CfgFile() {
 }
 
 QList<CfgEntry>& CfgFile::getEntries() {
 	return entries;
 }
 
 bool CfgFile::replaceEntry(const QString& file, const QString& label, int index) {
 	deleteEntry(file);
 
 	CfgEntry* entry = new CfgEntry(file, label);
 	if (index >= 0) {
 		entries.insert(index, entry);
 	} else {
 		entries.append(entry);
 	}
 
 	return true;
 }
 
 bool CfgFile::deleteEntry(const QString& file) {
 	for(int i = 0; i < (int) entries.count(); i++) {
 		CfgEntry* entry = entries.at(i);
 		if (entry->getFile() == file) {
 			entries.remove(i);
 			return true;
 		}
 	}
 	return false;
 }
 
 int CfgFile::getAutorepeatDelay() const {
 	return ardelay;
 }
 
 void CfgFile::setAutorepeatDelay(int n) {
 	ardelay = n;
 }
 
 int CfgFile::getAutorepeatPeriod() const {
 	return arperiod;
 }
 
 void CfgFile::setAutorepeatPeriod(int n) {
 	arperiod = n;
 }
 
 // CfgParser implementation
 CfgParser::CfgParser() {
 }
 
 bool CfgParser::load(QString file, CfgFile& cfg) {
 	QFile f(file);
 	QXmlInputSource is(f);
 	QXmlSimpleReader reader;
 	CfgHandler p(*this);
 	
 	reader.setErrorHandler(this);
 	reader.setContentHandler(&p);
 
 	err = "";
 	ardelay = -1;
 	arperiod = -1;
 	reader.parse(is);
 
 	if (!err.isEmpty()) {
 		odebug << err << oendl; 
 		return false;
 	}
 
 	QMap<QString, QString>::Iterator fit, lit;
 	for(uint i = 0; i < includeList.count(); i++) {
 		QString file = *includeList.at(i);
 		fit = includes.find(file);
 		QString prefix = fit.data();
 		QString label = "";
 
 		odebug << "include: file=" + fit.key() + ", prefix=" + fit.data() << oendl; 
 		lit = labels.find(prefix+":*");
 		if (lit != labels.end()) {
 			label = lit.data();
 		}
 
 		cfg.replaceEntry(file, label);
 	}
 
 	if (ardelay != -1) {
 		cfg.setAutorepeatDelay(ardelay);
 	}
 
 	if (arperiod != -1) {
 		cfg.setAutorepeatPeriod(arperiod);
 	}
 
 	return true;
 }
 
 bool CfgParser::save(QString file, CfgFile& cfg) {
 	FILE* f = fopen((const char*) file.local8Bit(), "w");
+    if (!f) {
+        oerr << "Could not write config file!" << oendl;
+        return false;
+    }
 
 	fprintf(f, "<keymap autorepeat-delay=\"%d\" autorepeat-period=\"%d\" "
 		"author=\"keyzcfg\">\n", cfg.getAutorepeatDelay(), 
 		cfg.getAutorepeatPeriod());
 
 	QList<CfgEntry>& entries = cfg.getEntries();
 	int n;
 
 	for(n=0; n < (int) entries.count(); n++) {
 		CfgEntry* entry = entries.at(n);
 		QString l = entry->getLabel();
-		if (!l.isEmpty()) {
+        if (l.isEmpty()) {
+            l = entry->getFile();
+        }
 			fprintf(f, "\t<label name=\"%s\" state=\"km%d:*\"/>\n", 
 				(const char*) l.utf8(), n);
 		}
-	}
 
 	for(n=0; n < (int) entries.count(); n++) {
 		CfgEntry* entry = entries.at(n);
 		fprintf(f, "\t<include file=\"%s\" prefix=\"km%d\"/>\n",
 			(const char*) entry->getFile().utf8(), n);
 	}
 
 	int k = n-1;
 	char* states[] = { "LShift", "LShift-Caps", "LShift-Num",
 		"LShift-Num-Caps", 0};
 
 	for(n=0; n < (int) entries.count(); n++) {
 		QString nstate = "km" + QString::number(n+1);
 		if (n == k) {
 			nstate = "km" + QString::number(0);
 		}
 
 		for(int i = 0; states[i] != 0; i++) {
 			fprintf(f, "\t<state name=\"km%d:%s\">\n",
 				n, states[i]);
 			fprintf(f, "\t\t<map keycode=\"Middle\" pressed=\"true\">\n");
 			fprintf(f, "\t\t\t<next-state name=\"%s:%s\"/>\n", 
 				(const char*) nstate.utf8(), states[i]);
 			fprintf(f, "\t\t</map>\n\t</state>\n\n");
 		}
 	}
 
 	fprintf(f, "\t<state name=\"km0:Normal\" default=\"true\"/>\n");
 
 	fprintf(f, "</keymap>");
 	fclose(f);
 	return true;
 }
 
 CfgParser::~CfgParser() {
 }
 
 int CfgParser::getAutorepeatDelay() const {
 	return ardelay;
 }
 
 void CfgParser::setAutorepeatDelay(int n) {
 	ardelay = n;
 }
 
 int CfgParser::getAutorepeatPeriod() const {
 	return arperiod;
 }
 
 void CfgParser::setAutorepeatPeriod(int n) {
 	arperiod = n;
 }
 
 void CfgParser::addLabel(const QString& name, const QString& state) {
 	labels.insert(state, name);
 	labelList.append(&labels.find(state).data());
 }
 
 void CfgParser::addFile(const QString& file, const QString& prefix) {
 	includes.insert(file, prefix);
 	includeList.append(&includes.find(file).key());
 }
 
 QString CfgParser::errorString() {
 	return err;
 }
 
 bool CfgParser::warning(const QXmlParseException& e) {
 	QString tmp;
 
 	tmp.sprintf("%d: warning: %s\n", e.lineNumber(), 
 		(const char*) e.message().utf8());
 
 	err += tmp;
 
 	return true;
 }
 
 bool CfgParser::error(const QXmlParseException& e) {
 	QString tmp;
 
 	tmp.sprintf("%d: error: %s\n", e.lineNumber(), 
 		(const char*) e.message().utf8());
 
 	err += tmp;
 
 	return true;
 }
 
 bool CfgParser::fatalError(const QXmlParseException& e) {
 	QString tmp;
 
 	tmp.sprintf("%d: fatal error: %s\n", e.lineNumber(), 
 		(const char*) e.message().utf8());
 
 	err += tmp;
 
 	return false;
 }
 
 // CfgHandler implementation
 CfgHandler::CfgHandler(CfgParser& c):cfg(c) {
 }
 
 CfgHandler::~CfgHandler() {
 }
 
 bool CfgHandler::startKeymapElement(int ard, int arp, const QString& author) {
 	if (author != "keyzcfg") {
 		bool ret;
 		ret = QMessageBox::warning(0, "keyz configurator", 
 			"Your zkb.xml doesn't seem created by keyz configurator.\n"
 			"By using keyz configurator you may loose your current "
 			"configuration\n Do you want to continue\n\n",
 			"Yes", "No", 0, 0, 1);
 
 		if (ret != 0) {
 			err = "cancelled by user";
 			return false;
 		}
 	}
 
 	if (ard != -1) {
 		cfg.setAutorepeatDelay(ard);
 	}
 
 	if (arp != -1) {
 		cfg.setAutorepeatPeriod(arp);
 	}
 
 	return true;
 }
 
 bool CfgHandler::startIncludeElement(const QString& file, 
 	const QString& pref) {
 
 	cfg.addFile(file, pref);
 	return true;
 }
 
 bool CfgHandler::startLabelElement(const QString& label, 
 	const QString& state) {
 
 	cfg.addLabel(label, state);
 	return true;
 }
 
 bool CfgHandler::startStateElement(const QString&, const QString&, bool) {
 
 	return true;
 }
 
 bool CfgHandler::startMapElement(int, bool) {
 	return true;
 }
 
 bool CfgHandler::startEventElement(int, int, int, bool, bool) {
 	return true;
 }
 
 bool CfgHandler::startNextStateElement(const QString&) {
 	return true;
 }
 
 
 bool CfgHandler::endKeymapElement() {
 	return true;
 }
 
 bool CfgHandler::endIncludeElement() {
 	return true;
 }
 
 bool CfgHandler::endLabelElement() {
 	return true;
 }
 
 bool CfgHandler::endStateElement() {
 	return true;
 }
 
 bool CfgHandler::endMapElement() {
 	return true;
 }
 
 bool CfgHandler::endEventElement() {
 	return true;
 }
 
 bool CfgHandler::endNextStateElement() {
 	return true;
 }