other keymapping tool - not working this moment, I have to check it out

- the reason is that the config file is somewhat easier to understand than
from zkbapplet and has a nice config tool.
Please don't put it into any repositories this moment.

83 files changed, 8164 insertions, 0 deletions

diff --git a/noncore/applets/keyhelper/config.in b/noncore/applets/keyhelper/config.in
new file mode 100644
index 0000000..5bba19a
--- a/dev/null
+++ b/noncore/applets/keyhelper/config.in
@@ -0,0 +1,4 @@
+  config KEYHELPER
+    boolean "keyhelper applet (Config keyboard layout on the fly)"
+    default "n"
+    depends ( LIBQPE || LIBQPE-X11 ) && LIBOPIE2CORE
diff --git a/noncore/applets/keyhelper/keyhelper.pro b/noncore/applets/keyhelper/keyhelper.pro
new file mode 100644
index 0000000..483845d
--- a/dev/null
+++ b/noncore/applets/keyhelper/keyhelper.pro
@@ -0,0 +1,2 @@
+TEMPLATE    = subdirs
+SUBDIRS     = keyhelperapplet keyhelperconf
diff --git a/noncore/applets/keyhelper/keyhelperapplet/anylnk/AnyLnk.cpp b/noncore/applets/keyhelper/keyhelperapplet/anylnk/AnyLnk.cpp
new file mode 100644
index 0000000..3c2298e
--- a/dev/null
+++ b/noncore/applets/keyhelper/keyhelperapplet/anylnk/AnyLnk.cpp
@@ -0,0 +1,94 @@
+#include "AnyLnk.h"
+#include "KHUtil.h"
+
+void AnyLnk::loadPixmap()
+{
+	if(m_params.count() >= 3){
+		QString& str = m_params[2];
+		QImage image = Resource::loadImage(str);
+		if(image.isNull() == false){
+			const QSize& size = AppLnkManager::getIconSize();
+			m_pixmap.convertFromImage(
+				image.smoothScale(size.width(), size.height()) );
+		}	
+	}
+}
+
+void AnyLnk::parseText()
+{
+	if(m_params.count() >= 2){
+		QString& str = m_params[1];
+		if(str != QString::null && str.length() > 0){
+			replaceKeyword(str);
+			replaceDate(str);
+		}
+	}
+}
+
+void AnyLnk::replaceText(QString& str, const QString& s1, const QString& s2)
+{
+	int index = 0;
+	int idx;
+	int len = s1.length();
+	idx = str.find(s1, index);
+	for(;;){
+		idx = str.find(s1, index);
+		if(idx < 0) break;
+		str.replace(idx, len, s2);
+		index = idx;
+	}
+}
+
+void AnyLnk::replaceDate(QString& str)
+{
+	time_t t;
+	struct tm lct;
+	char buf[4096];
+	int nLen;
+	QString group;
+
+	t = ::time(NULL);
+	::localtime_r(&t, &lct);
+
+	ConfigEx& cfg = ConfigEx::getInstance("keyhelper");
+	group = cfg.getGroup();
+	cfg.setGroup("Global");
+	QString charset = cfg.readEntry("SystemCharSet", "eucJP");
+	if(charset.length() == 0){
+		charset = "eucJP";
+	}
+	cfg.setGroup(group);
+
+	QTextCodec* codec = QTextCodec::codecForName(charset);
+	if(codec == NULL){
+		codec = QTextCodec::codecForLocale();
+	}
+	QTextDecoder* decoder = codec->makeDecoder();
+	QTextEncoder* encoder = codec->makeEncoder();
+	nLen = str.length();
+	QCString localeString = encoder->fromUnicode(str, nLen);
+
+	memset(buf, '\0', sizeof(buf));
+	int n = ::strftime(buf, sizeof(buf), localeString, &lct);
+	if(n > 0){
+		str = decoder->toUnicode(buf, n);
+	}
+	delete decoder;
+	delete encoder;
+}
+
+void AnyLnk::replaceKeyword(QString& str)
+{
+	QString txt;
+	/* clipboard text */
+	QClipboard* cb = QApplication::clipboard();
+	if(cb == NULL){
+		txt == "";
+	} else {
+		txt = cb->text();
+	}
+	replaceText(str, "%clipboard%", txt);
+	/* current app */
+	txt = KHUtil::currentApp();
+	replaceText(str, "%currentapp%", txt);
+}
diff --git a/noncore/applets/keyhelper/keyhelperapplet/anylnk/AnyLnk.h b/noncore/applets/keyhelper/keyhelperapplet/anylnk/AnyLnk.h
new file mode 100644
index 0000000..9853942
--- a/dev/null
+++ b/noncore/applets/keyhelper/keyhelperapplet/anylnk/AnyLnk.h
@@ -0,0 +1,45 @@
+#ifndef _ANYLNK_H_
+#define _ANYLNK_H_
+
+#include <time.h>
+
+#include <qstring.h>
+#include <qstringlist.h>
+#include <qpixmap.h>
+#include <qimage.h>
+#include <qclipboard.h>
+#include <qtextcodec.h>
+
+#include <qpe/qpeapplication.h>
+#include <qpe/resource.h>
+
+#include "AppLnkManager.h"
+#include "ConfigEx.h"
+
+class AnyLnk
+{
+public:
+	AnyLnk(){}
+	AnyLnk(const QStringList& params){
+		m_params = params;
+		loadPixmap();
+	}
+	virtual ~AnyLnk(){
+	}
+	virtual bool isValid() = 0;
+	virtual void execute() = 0;
+	virtual QString name() = 0;
+	virtual const QPixmap& pixmap() = 0;
+
+protected:
+	QStringList m_params;
+	QPixmap m_pixmap;
+
+	virtual void loadPixmap();
+	virtual void parseText();
+	virtual void replaceText(QString& str, const QString& s1, const QString& s2);
+	virtual void replaceDate(QString& str);
+	virtual void replaceKeyword(QString& str);
+};
+
+#endif /* _ANYLNK_H_ */
diff --git a/noncore/applets/keyhelper/keyhelperapplet/anylnk/AppLnkManager.cpp b/noncore/applets/keyhelper/keyhelperapplet/anylnk/AppLnkManager.cpp
new file mode 100644
index 0000000..5e244a4
--- a/dev/null
+++ b/noncore/applets/keyhelper/keyhelperapplet/anylnk/AppLnkManager.cpp
@@ -0,0 +1,5 @@
+#include "AppLnkManager.h"
+
+AppLnkSet* AppLnkManager::m_pLnkSet = NULL;
+QSize AppLnkManager::m_oIconSize;
+bool AppLnkManager::m_notfound = true;
diff --git a/noncore/applets/keyhelper/keyhelperapplet/anylnk/AppLnkManager.h b/noncore/applets/keyhelper/keyhelperapplet/anylnk/AppLnkManager.h
new file mode 100644
index 0000000..8446578
--- a/dev/null
+++ b/noncore/applets/keyhelper/keyhelperapplet/anylnk/AppLnkManager.h
@@ -0,0 +1,56 @@
+#ifndef _APPLNK_MANAGER_H_
+#define _APPLNK_MANAGER_H_
+
+#include <qsize.h>
+
+#include <qpe/applnk.h>
+#include <qpe/mimetype.h>
+
+class AppLnkManager
+{
+public:
+	AppLnkManager(){
+	}
+	~AppLnkManager(){
+		if(m_pLnkSet) delete m_pLnkSet;
+	}
+	static void init(bool force=false){
+		if(m_notfound || force){
+			if(m_pLnkSet){
+				delete m_pLnkSet;
+			}
+			qDebug("AppLnkManager::init()");
+			m_pLnkSet = new AppLnkSet(MimeType::appsFolderName());
+			m_notfound = false;
+		}
+	}
+	static AppLnkSet* getInstance(){
+		if(m_pLnkSet == NULL){
+			init(true);
+		}
+		return(m_pLnkSet);
+	}
+	static const QSize& getIconSize(){
+		if(m_oIconSize.isValid()){
+			return(m_oIconSize);
+		}
+		const QList<AppLnk>& lnkList = getInstance()->children();
+		QListIterator<AppLnk> it(lnkList);
+		for(; it.current(); ++it){
+			if((*it)->pixmap().isNull() == false){
+				m_oIconSize = (*it)->pixmap().size();
+				break;
+			}
+		}
+		return(m_oIconSize);
+	}
+	static void notfound(){
+		m_notfound = true;
+	}
+private:
+	static bool m_notfound;
+	static AppLnkSet* m_pLnkSet;
+	static QSize m_oIconSize;
+};
+
+#endif /* _APPLNK_MANAGER_H_ */
diff --git a/noncore/applets/keyhelper/keyhelperapplet/anylnk/AppLnkWrapper.cpp b/noncore/applets/keyhelper/keyhelperapplet/anylnk/AppLnkWrapper.cpp
new file mode 100644
index 0000000..1c3dbfe
--- a/dev/null
+++ b/noncore/applets/keyhelper/keyhelperapplet/anylnk/AppLnkWrapper.cpp
@@ -0,0 +1,43 @@
+#ifndef _APPLNK_WRAPPER_H_
+#define _APPLNK_WRAPPER_H_
+
+#include <qpe/qpeapplication.h>
+#include <qpe/applnk.h>
+#include "AnyLnk.h"
+
+class AppLnkWrapper : public AnyLnk
+{
+public:
+	AppLnkWrapper(){}
+	AppLnkWrapper(const QStringList& params)
+		: AnyLnk(params)
+	{
+		m_pLnk = new AppLnk(QPEApplication::qpeDir()
+			+ "apps/" + m_params[0] + ".desktop");
+	}
+	virtual ~AppLnkWrapper(){
+		delete m_pLnk;
+	}
+
+	virtual bool isValid() {
+		return(m_pLnk->isValid());
+	}
+	virtual void execute(){
+		parseText();
+		m_pLnk->execute(m_params[1]);
+	}
+	virtual QString name() {
+		return(m_pLnk->name());
+	}
+	virtual const QPixmap& pixmap(){
+		if(m_pixmap.isNull()){
+			return(m_pLnk->pixmap());
+		} else {
+			return(m_pixmap);
+		}
+	}
+protected:
+	AppLnk* m_pLnk;
+};
+
+#endif /* _APPLNK_WRAPPER_H_ */
\ No newline at end of file
diff --git a/noncore/applets/keyhelper/keyhelperapplet/anylnk/AppLnkWrapper.h b/noncore/applets/keyhelper/keyhelperapplet/anylnk/AppLnkWrapper.h
new file mode 100644
index 0000000..6907dbe
--- a/dev/null
+++ b/noncore/applets/keyhelper/keyhelperapplet/anylnk/AppLnkWrapper.h
@@ -0,0 +1,44 @@
+#ifndef _APPLNK_WRAPPER_H_
+#define _APPLNK_WRAPPER_H_
+
+#include <qpe/qpeapplication.h>
+#include <qpe/applnk.h>
+#include "AnyLnk.h"
+
+class AppLnkWrapper : public AnyLnk
+{
+public:
+	AppLnkWrapper(){}
+	AppLnkWrapper(const QStringList& params)
+		: AnyLnk(params)
+	{
+		m_pLnk = new AppLnk(QPEApplication::qpeDir()
+			+ "apps/" + m_params[0] + ".desktop");
+	}
+	virtual ~AppLnkWrapper(){
+		delete m_pLnk;
+	}
+
+	virtual bool isValid() {
+		return(m_pLnk->isValid());
+	}
+	virtual void execute(){
+		parseText();
+		m_pLnk->execute(m_params[1]);
+	}
+	virtual QString name() {
+		return(m_pLnk->name());
+	}
+	virtual const QPixmap& pixmap(){
+		if(m_pixmap.isNull()){
+			return(m_pLnk->pixmap());
+		} else {
+			return(m_pixmap);
+		}
+	}
+protected:
+	AppLnk* m_pLnk;
+};
+
+#endif /* _APPLNK_WRAPPER_H_ */
+
diff --git a/noncore/applets/keyhelper/keyhelperapplet/anylnk/DocLnkWrapper.h b/noncore/applets/keyhelper/keyhelperapplet/anylnk/DocLnkWrapper.h
new file mode 100644
index 0000000..d6f2be5
--- a/dev/null
+++ b/noncore/applets/keyhelper/keyhelperapplet/anylnk/DocLnkWrapper.h
@@ -0,0 +1,47 @@
+#ifndef _DOCLNK_WRAPPER_H_
+#define _DOCLNK_WRAPPER_H_
+
+#include <qpe/applnk.h>
+#include "AnyLnk.h"
+
+class DocLnkWrapper : public AnyLnk
+{
+public:
+	DocLnkWrapper(){}
+	DocLnkWrapper(const QStringList& params)
+		: AnyLnk(params)
+	{
+		m_pLnk = new DocLnk(m_params[0], false);
+	}
+	virtual ~DocLnkWrapper(){
+		delete m_pLnk;
+	}
+
+	virtual bool isValid() {
+		if(m_pLnk->exec().length() > 0){
+			return(true);
+		} else {
+			return(false);
+		}
+	}
+	virtual void execute(){
+		parseText();
+		m_pLnk->execute(m_params[1]);
+	}
+	virtual QString name() {
+		return(m_pLnk->name());
+	}
+	virtual const QPixmap& pixmap(){
+		if(m_pixmap.isNull()){
+			return(m_pLnk->pixmap());
+		} else {
+			return(m_pixmap);
+		}
+	}
+protected:
+	DocLnk* m_pLnk;
+};
+
+#endif /* _DOCLNK_WRAPPER_H_ */
+
+
diff --git a/noncore/applets/keyhelper/keyhelperapplet/anylnk/ExecLnk.h b/noncore/applets/keyhelper/keyhelperapplet/anylnk/ExecLnk.h
new file mode 100644
index 0000000..7e595df
--- a/dev/null
+++ b/noncore/applets/keyhelper/keyhelperapplet/anylnk/ExecLnk.h
@@ -0,0 +1,38 @@
+#ifndef _EXECLNK_H_
+#define _EXECLNK_H_
+
+#include <qpe/qpeapplication.h>
+
+#include "AnyLnk.h"
+#include "ProcessInvoker.h"
+
+class ExecLnk : public AnyLnk
+{
+public:
+	ExecLnk(){}
+	ExecLnk(const QStringList& params)
+		: AnyLnk(params){}
+	virtual ~ExecLnk() {
+	}
+
+	virtual bool isValid() {
+		return(true);
+	}
+	virtual void execute() {
+		parseText();
+		ProcessInvoker& pi = ProcessInvoker::getInstance();
+		pi.setArguments(m_params[1]);
+		pi.setNotify();
+		pi.run();
+	}
+	virtual QString name() {
+		return("exec");
+	}
+	virtual const QPixmap& pixmap() {
+		return(m_pixmap);
+	}
+protected:
+};
+
+#endif /* _EXECLNK_H_ */
+
diff --git a/noncore/applets/keyhelper/keyhelperapplet/anylnk/LnkWrapper.cpp b/noncore/applets/keyhelper/keyhelperapplet/anylnk/LnkWrapper.cpp
new file mode 100644
index 0000000..39806e5
--- a/dev/null
+++ b/noncore/applets/keyhelper/keyhelperapplet/anylnk/LnkWrapper.cpp
@@ -0,0 +1,32 @@
+#include "LnkWrapper.h"
+
+LnkWrapper::LnkWrapper(const QStringList& params)
+{
+	if(params[0][0] == '/'){
+		qDebug("create DocLnk instance");
+		m_pLnk = new DocLnkWrapper(params);
+	} else if(params[0] == "@exec"){
+		qDebug("create ExecLnk instance");
+		m_pLnk = new ExecLnk(params);
+	} else if(params[0] == "@qcop"){
+		qDebug("create QCopLnk instance");
+		m_pLnk = new QCopLnk(params);
+	} else if(params[0] == "@text"){
+		qDebug("create TextLnk instance");
+		m_pLnk = new TextLnk(params);
+	} else if(params[0] == "@menu"){
+		qDebug("create MenuLnk instance");
+		m_pLnk = new MenuLnk(params);
+	} else {
+		qDebug("create AppLnk instance");
+		m_pLnk = new AppLnkWrapper(params);
+	}
+}
+
+LnkWrapper::~LnkWrapper()
+{
+	if(m_pLnk){
+		delete m_pLnk;
+	}
+}
+
diff --git a/noncore/applets/keyhelper/keyhelperapplet/anylnk/LnkWrapper.h b/noncore/applets/keyhelper/keyhelperapplet/anylnk/LnkWrapper.h
new file mode 100644
index 0000000..6b9536b
--- a/dev/null
+++ b/noncore/applets/keyhelper/keyhelperapplet/anylnk/LnkWrapper.h
@@ -0,0 +1,33 @@
+#ifndef _LNK_WRAPPER_H_
+#define _LNK_WRAPPER_H_
+
+#include <qstring.h>
+#include <qstringlist.h>
+
+#include <qpe/applnk.h>
+
+#include "AppLnkWrapper.h"
+#include "DocLnkWrapper.h"
+#include "ExecLnk.h"
+#include "QCopLnk.h"
+#include "TextLnk.h"
+#include "MenuLnk.h"
+
+class LnkWrapper
+{
+public:
+	LnkWrapper(const QStringList& params);
+	virtual ~LnkWrapper();
+
+	bool isValid(){
+		return(m_pLnk && m_pLnk->isValid());
+	}
+	AnyLnk& instance(){
+		return(*m_pLnk);
+	}
+private:
+	AnyLnk* m_pLnk;
+};
+
+#endif /* _LNK_WRAPPER_H_ */
+
diff --git a/noncore/applets/keyhelper/keyhelperapplet/anylnk/MenuLnk.h b/noncore/applets/keyhelper/keyhelperapplet/anylnk/MenuLnk.h
new file mode 100644
index 0000000..19f75d6
--- a/dev/null
+++ b/noncore/applets/keyhelper/keyhelperapplet/anylnk/MenuLnk.h
@@ -0,0 +1,41 @@
+#ifndef _MENULNK_H_
+#define _MENULNK_H_
+
+#include <qpe/qpeapplication.h>
+
+#include "AnyLnk.h"
+#include "ConfigEx.h"
+
+class MenuLnk : public AnyLnk
+{
+public:
+	MenuLnk(){}
+	MenuLnk(const QStringList& params)
+		: AnyLnk(params){}
+	virtual ~MenuLnk() {
+	}
+
+	virtual bool isValid() {
+		ConfigEx& cfg = ConfigEx::getInstance("keyhelper");
+		QString group = cfg.getGroup();
+		cfg.setGroup(name());
+		bool valid = (cfg.getKeys().isEmpty() == false);
+		cfg.setGroup(group);
+		return(valid);
+	}
+	virtual void execute() {
+	}
+	virtual QString name() {
+		QString group;
+		group = m_params[1];
+		group[0] = group[0].upper();
+		return(group);
+	}
+	virtual const QPixmap& pixmap() {
+		return(m_pixmap);
+	}
+protected:
+};
+
+#endif /* _MENULNK_H_ */
+
diff --git a/noncore/applets/keyhelper/keyhelperapplet/anylnk/ProcessInvoker.cpp b/noncore/applets/keyhelper/keyhelperapplet/anylnk/ProcessInvoker.cpp
new file mode 100644
index 0000000..09605bd
--- a/dev/null
+++ b/noncore/applets/keyhelper/keyhelperapplet/anylnk/ProcessInvoker.cpp
@@ -0,0 +1,424 @@
+#include "ProcessInvoker.h"
+
+static ProcessInvoker* g_this;
+/* ------------------------------------------------------------------------ */
+/*	static functions														*/
+/* ------------------------------------------------------------------------ */
+
+static Sigfunc* setSignalHandler(int signo, Sigfunc* handler)
+{
+	struct sigaction act,oact;
+
+	act.sa_handler = handler;
+	::sigemptyset(&act.sa_mask);
+	act.sa_flags = 0;
+#ifdef	SA_RESTART
+	act.sa_flags |= SA_RESTART;
+#endif
+	if(::sigaction(signo, &act, &oact) < 0){
+		return(NULL);
+	}
+	return(oact.sa_handler);
+}
+
+static void childHandler(int /*signo*/)
+{
+	pid_t pid;
+	int status;
+	while((pid = ::waitpid(-1, &status, WNOHANG)) > 0){
+		if(pid == g_this->m_child){
+			g_this->notifyFinish(status);
+		}
+	}
+}
+
+/* ------------------------------------------------------------------------ */
+/*	ProcessInvoker Class : parent process									*/
+/* ------------------------------------------------------------------------ */
+ProcessInvoker::ProcessInvoker()
+{
+	g_this = this;
+	m_isRunning = false;
+	m_child = 0;
+	m_defChildHandler = SIG_DFL;
+	m_pTimer = new QTimer(this);
+	m_stdfd[0] = m_stdfd[1] = -1;
+	m_errfd[0] = m_errfd[1] = -1;
+	connect(m_pTimer, SIGNAL(timeout()),
+		this, SLOT(readOutputs()));
+}
+
+ProcessInvoker::~ProcessInvoker()
+{
+	qDebug("ProcessInvoker::~ProcessInvoker()");
+}
+
+bool ProcessInvoker::openPipe()
+{
+	if(m_stdfd[0] >= 0) closePipe(m_stdfd, 0);
+	if(m_stdfd[1] >= 0) closePipe(m_stdfd, 1);
+	if(::pipe(m_stdfd) < 0){
+		return(false);
+	}
+	if(m_errfd[0] >= 0) closePipe(m_errfd, 0);
+	if(m_errfd[1] >= 0) closePipe(m_errfd, 1);
+	if(::pipe(m_errfd) < 0){
+		closePipe(m_stdfd);
+		return(false);
+	}
+	m_maxfdp1 = m_stdfd[0];
+	if(m_errfd[0] > m_maxfdp1){
+		m_maxfdp1 = m_errfd[0];
+	}
+	m_maxfdp1++;
+	return(true);
+}
+
+void ProcessInvoker::closePipe(int fd[], int n)
+{
+	if(fd == NULL){
+		closePipe(m_stdfd, n);
+		closePipe(m_errfd, n);
+	} else {
+		if(n != 1 && fd[0] >= 0){
+			::close(fd[0]);
+			fd[0] = -1;
+		}
+		if(n != 0 && fd[1] >= 0){
+			::close(fd[1]);
+			fd[1] = -1;
+		}
+	}
+}
+
+void ProcessInvoker::setRunning(int pid)
+{
+	m_child = pid;
+	m_isRunning = true;
+}
+
+bool ProcessInvoker::run(const QString& args)
+{
+	//setArguments(KHUtil::parseArgs(args));
+	setArguments(StringParser::split(' ', args));
+	return(run());
+}
+
+bool ProcessInvoker::run()
+{
+	if(m_isRunning){
+		return(false);
+	}
+	m_isRunning = true;
+	if(m_arguments.isEmpty()){
+		m_isRunning = false;
+		return(false);
+	}
+	if(m_arguments[0][0] != '/'){
+		m_isRunning = false;
+		return(false);
+	}
+
+	for(QStringList::Iterator it=m_arguments.begin();
+			it!=m_arguments.end(); ++it){
+		qDebug("arguments[%s]", (*it).ascii());
+	}
+
+	/* open pipe */
+	if(openPipe() == false){
+		m_isRunning = false;
+		return(false);
+	}
+
+	/* signal handler reset */
+	m_defChildHandler = setSignalHandler(SIGCHLD, SIG_DFL);
+
+	m_child = ::fork();
+	if(m_child < 0){
+		/* fork error */
+		closePipe();
+		setSignalHandler(SIGCHLD, m_defChildHandler);
+		m_isRunning = false;
+		return(false);
+	} else if(m_child == 0){
+		/* child process */
+		qDebug("child process[%d]", ::getpid());
+		m_child = ::getpid();
+		//setSignalHandler(SIGCHLD, SIG_DFL);
+		workerProc();
+		/* no return */
+	}
+	/* close pipe(write) */
+	closePipe(NULL, 1);
+#if 0
+	m_pTimer = new QTimer(this);
+	connect(m_pTimer, SIGNAL(timeout()),
+		this, SLOT(readOutputs()));
+#endif
+	m_pTimer->start(500);
+	{
+		emit start(m_child, m_arguments);
+		QCopEnvelope e(SC_CHANNEL, "start(int,QStringList)");
+		e << m_child << m_arguments;
+		if(m_isNotify){
+			int idx = m_arguments[0].findRev('/');
+			notifyStatus(m_arguments[0].mid(idx+1), m_child);
+		}
+	}
+	int status;
+	if(::waitpid(-1, &status, WNOHANG) > 0){
+		qDebug("finish");
+		notifyFinish(status);
+	} else {
+		/* signal handler set */
+		setSignalHandler(SIGCHLD, childHandler);
+	}
+	return(true);
+}
+
+void ProcessInvoker::terminate()
+{
+	if(m_isRunning && m_child > 0){
+		terminate(m_child);
+	}
+}
+
+void ProcessInvoker::terminate(pid_t pid)
+{
+	::kill(pid, SIGTERM);
+}
+
+void ProcessInvoker::kill()
+{
+	if(m_isRunning && m_child > 0){
+		kill(m_child);
+	}
+}
+
+void ProcessInvoker::kill(pid_t pid)
+{
+	::kill(pid, SIGKILL);
+}
+
+#if 0
+const QStringList ProcessInvoker::parseArgs(const QString& arguments)
+{
+	QString str;
+	QStringList args;
+	char quote = 0;
+	char c;
+	for(unsigned int i=0; i<arguments.length(); i++){
+		c = arguments[i];
+		switch(c){
+		case '\"':
+			if(quote == 0){
+				quote = c;
+			} else if(quote == '\"'){
+				if(str.length() > 0){
+					args.append(str);
+				}
+				str = "";
+				quote = 0;
+			} else {
+				str += c;
+			}
+			break;
+		case '\'':
+			if(quote == 0){
+				quote = c;
+			} else if(quote == '\''){
+				if(str.length() > 0){
+					args.append(str);
+				}
+				str = "";
+				quote = 0;
+			} else {
+				str += c;
+			}
+			break;
+		case ' ':
+			if(quote == 0){
+				if(str.length() > 0){
+					args.append(str);
+					str = "";
+				}
+			} else {
+				str += c;
+			}
+			break;
+		default:
+			str += c;
+			break;
+		}
+	}
+	if(str.length() > 0){
+		args.append(str);
+	}
+	return(args);
+}
+#endif
+
+void ProcessInvoker::readOutputs()
+{
+	struct timeval tmval;
+	tmval.tv_sec = 0;
+	tmval.tv_usec = 0;
+	fd_set rset;
+
+	QByteArray stdBuf, errBuf, resBuf;
+	QDataStream stdStream(stdBuf, IO_WriteOnly);
+	QDataStream errStream(errBuf, IO_WriteOnly);
+
+	int iRet;
+	bool running;
+	char buf[PIPE_BUF+1];
+	while(true){
+		running = false;
+		FD_ZERO(&rset);
+		if(m_stdfd[0] >= 0){
+			FD_SET(m_stdfd[0], &rset);
+			running = true;
+		}
+		if(m_errfd[0] >= 0){
+			FD_SET(m_errfd[0], &rset);
+			running = true;
+		}
+		if(running == false){
+			m_pTimer->stop();
+			//delete m_pTimer;
+			break;
+		}
+
+		if((iRet = ::select(m_maxfdp1, &rset, NULL, NULL, &tmval)) <= 0){
+			qDebug("select[%d]", iRet);
+			break;
+		}
+
+		if(m_stdfd[0] >= 0 && FD_ISSET(m_stdfd[0], &rset)){
+			int n = ::read(m_stdfd[0], buf, PIPE_BUF);
+			if(n > 0){
+				stdStream.writeRawBytes(buf, n);
+			} else {
+				qDebug("stdout close");
+				closePipe(m_stdfd, 0);
+			}
+		}
+		if(m_errfd[0] >= 0 && FD_ISSET(m_errfd[0], &rset)){
+			int n = ::read(m_errfd[0], buf, PIPE_BUF);
+			if(n > 0){
+				errStream.writeRawBytes(buf, n);
+			} else {
+				qDebug("stderr close");
+				closePipe(m_errfd, 0);
+			}
+		}
+	}
+
+	if(stdBuf.size() > 0){
+		QCopEnvelope e(SC_CHANNEL, "stdout(int,QByteArray)");
+		e << m_child << stdBuf;
+	}
+	if(errBuf.size() > 0){
+		QCopEnvelope e(SC_CHANNEL, "stderr(int,QByteArray)");
+		e << m_child << errBuf;
+	}
+	if(running == false){
+		QCopEnvelope e(SC_CHANNEL, "close(int)");
+		e << m_child;
+	}
+}
+
+#if 0
+void ProcessInvoker::waitFinish()
+{
+	int status;
+	if(::waitpid(m_child, &status, 0) > 0){
+		notifyFinish(status);
+	} else {
+		notifyFinish(0, false);
+	}
+}
+#endif
+
+void ProcessInvoker::notifyFinish(int status, bool success)
+{
+	bool stopped = false;
+	QString result;
+	int code;
+	if(success){
+		if(WIFEXITED(status)){
+			code = WEXITSTATUS(status);
+			if(code == 127){
+				result = "error";
+			} else {
+				result = "exit";
+			}
+		} else if(WIFSIGNALED(status)){
+			result = "terminated";
+			code = WTERMSIG(status);
+		} else if(WIFSTOPPED(status)){
+			result = "stopped";
+			code = WSTOPSIG(status);
+			stopped = true;
+		} else {
+			/* ¤³¤ì¤Ï̵¤¤¤Ï¤º? */
+			result = "error";
+			code = -2;
+			qWarning("ProcessInvoker: unknown status");
+		}		
+	} else {
+		result = "error";
+		code = -1;
+		qWarning("ProcessInvoker: wait error");
+	}
+	emit finish(result, code);
+	QCopEnvelope e(SC_CHANNEL, "finish(int,QString,int)");
+	e << m_child << result << code;
+	if(m_isNotify){
+		notifyStatus(result, code);
+		setNotify(false);
+	}
+	if(stopped == false){
+		setSignalHandler(SIGCHLD, m_defChildHandler);
+		m_isRunning = false;
+	}
+}
+
+void ProcessInvoker::notifyStatus(const QString& result, int code)
+{
+	QString message = QString::number(code);
+	message.append(":");
+	message.append(result);
+	Global::statusMessage(message);
+}
+
+/* ------------------------------------------------------------------------ */
+/*	ProcessInvoker Class : child process									*/
+/* ------------------------------------------------------------------------ */
+void ProcessInvoker::workerProc()
+{
+	closePipe(m_stdfd, 0);
+	closePipe(m_errfd, 0);
+	if(m_stdfd[1] != STDOUT_FILENO){
+		::dup2(m_stdfd[1], STDOUT_FILENO);
+		closePipe(m_stdfd, 1);
+	}
+	if(m_errfd[1] != STDERR_FILENO){
+		::dup2(m_errfd[1], STDERR_FILENO);
+		closePipe(m_errfd, 1);
+	}
+
+	QCString* arglist = new QCString[m_arguments.count()+1];
+	const char** argv = new const char*[m_arguments.count()+1];
+	unsigned int i;
+	for(i=0; i<m_arguments.count(); i++){
+		//arglist[i] = m_arguments[i].local8Bit();
+		arglist[i] = m_arguments[i];
+		argv[i] = arglist[i];
+	}
+	argv[i] = 0;
+	::execv(argv[0], (char*const*)argv);
+	delete[] arglist;
+	delete[] argv;
+	::_exit(127);
+}
diff --git a/noncore/applets/keyhelper/keyhelperapplet/anylnk/ProcessInvoker.h b/noncore/applets/keyhelper/keyhelperapplet/anylnk/ProcessInvoker.h
new file mode 100644
index 0000000..1f53cd6
--- a/dev/null
+++ b/noncore/applets/keyhelper/keyhelperapplet/anylnk/ProcessInvoker.h
@@ -0,0 +1,114 @@
+#ifndef _PROCESS_INVOKER_H_
+#define _PROCESS_INVOKER_H_
+
+#include <qobject.h>
+#include <sys/wait.h>
+#include <sys/types.h>
+#include <sys/time.h>
+#include <signal.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <errno.h>
+
+#include <qtimer.h>
+#include <qdatastream.h>
+#include <qcstring.h>
+#include <qpe/qcopenvelope_qws.h>
+#include <qpe/global.h>
+//#include "KHUtil.h"
+#include "StringParser.h"
+
+typedef void Sigfunc(int);
+
+#define	SC_CHANNEL	"QPE/ShellCommander"
+
+/* Sigleton Object */
+class ProcessInvoker : public QObject
+{
+	Q_OBJECT
+public:
+	static ProcessInvoker& getInstance()
+	{
+		static ProcessInvoker instance;
+		return(instance);
+	}
+
+	bool run();
+	bool run(const QString& args);
+	void terminate();
+	void terminate(pid_t pid);
+	void kill();
+	void kill(pid_t pid);
+	void setCommand(const QString& command){
+		m_arguments.clear();
+		addArgument(command);
+	}
+	void setArguments(const QStringList& arglist){
+		m_arguments = arglist;
+	}
+	void setArguments(const QString& arguments){
+		//setArguments(KHUtil::parseArgs(arguments));
+		setArguments(StringParser::split(' ', arguments));
+	}
+	void addArgument(const QString& argument){
+		m_arguments.append(argument);
+	}
+	void addArguments(const QString& arguments){
+		QStringList arglist;
+		//arglist = KHUtil::parseArgs(arguments);
+		arglist = StringParser::split(' ', arguments);
+		addArguments(arglist);
+	}
+	void addArguments(const QStringList& arglist){
+		for(QStringList::ConstIterator it=arglist.begin();
+				it!=arglist.end(); ++it){
+			addArgument(*it);
+		}
+	}
+	//const QStringList parseArgs(const QString& arguments);
+	void setRunning(int pid);
+	void setNotify(bool enable=true){
+		m_isNotify = enable;
+	}
+
+	bool isRunning(){
+		return(m_isRunning);
+	}
+	void notifyFinish(int status, bool success=true);
+
+	pid_t m_child;
+
+	friend class Dummy; /* for compile warning */
+signals:
+	void start(int, QStringList);
+	void finish(QString,int);
+private:
+	ProcessInvoker();
+	ProcessInvoker(const ProcessInvoker&);
+	ProcessInvoker& operator=(const ProcessInvoker&);
+	~ProcessInvoker();
+
+	class Dummy{}; /* for compile warning */
+
+	QTimer* m_pTimer;
+	QStringList m_arguments;
+
+	bool m_isRunning;
+	bool m_isNotify;
+
+	Sigfunc* m_defChildHandler;
+
+	int m_stdfd[2];
+	int m_errfd[2];
+	int m_maxfdp1;
+
+	bool openPipe();
+	void closePipe(int fd[] = NULL, int n = 2);
+	void notifyStatus(const QString& result, int code);
+
+	void workerProc();
+private slots:
+	void readOutputs();
+};
+
+#endif /* _PROCESS_INVOKER_H_ */
diff --git a/noncore/applets/keyhelper/keyhelperapplet/anylnk/QCopLnk.cpp b/noncore/applets/keyhelper/keyhelperapplet/anylnk/QCopLnk.cpp
new file mode 100644
index 0000000..991bf87
--- a/dev/null
+++ b/noncore/applets/keyhelper/keyhelperapplet/anylnk/QCopLnk.cpp
@@ -0,0 +1,63 @@
+#include "QCopLnk.h"
+#include "StringParser.h"
+
+void QCopLnk::execute()
+{
+	parseText();
+	//QStringList argList = KHUtil::parseArgs(m_params[1]);
+	QStringList argList = StringParser::split(' ', m_params[1]);
+	if(argList.count() < 2){
+		return;
+	}
+	QStringList paramList =
+		QStringList::split(QRegExp("[(),]"), argList[1]);
+	if(argList.count() < paramList.count()+1){
+		return;
+	}
+	paramList.remove(paramList.begin());
+	if(paramList.count() == 0){
+		/* send qcop message */
+		QCopEnvelope env(argList[0].latin1(), argList[1].latin1());
+	} else {
+		QCopEnvelope* e = NULL;
+		QStringList::Iterator it=paramList.end();
+		for(unsigned int index = 2; index<argList.count(); index++){
+			if(it == paramList.end()){
+				if(argList.count() - index < paramList.count()){
+					break;
+				}
+				/* initialize */
+				it = paramList.begin();
+				e = new QCopEnvelope(
+					argList[0].latin1(), argList[1].latin1());
+			}
+			QString arg = argList[index];
+			if(*it == "QString"){
+				*e << arg;
+			} else if(*it == "int"){
+				*e << arg.toInt();
+			} else if(*it == "bool"){
+				QString s = arg.lower();
+				int on;
+				if(s == "true"){
+					on = TRUE;
+				} else if(s == "false"){
+					on = FALSE;
+				} else {
+					on = s.toInt();
+				}
+				*e << on;
+			}
+			++it;
+			if(it == paramList.end()){
+				/* send qcop message */
+				delete e;
+				if(argList.count() - index >= paramList.count()){
+					e = new QCopEnvelope(
+						argList[0].latin1(), argList[1].latin1());
+					it = paramList.begin();
+				}
+			}
+		}
+	}
+}
diff --git a/noncore/applets/keyhelper/keyhelperapplet/anylnk/QCopLnk.h b/noncore/applets/keyhelper/keyhelperapplet/anylnk/QCopLnk.h
new file mode 100644
index 0000000..f994149
--- a/dev/null
+++ b/noncore/applets/keyhelper/keyhelperapplet/anylnk/QCopLnk.h
@@ -0,0 +1,34 @@
+#ifndef _QCOPLNK_H_
+#define _QCOPLNK_H_
+
+#include <qpe/qpeapplication.h>
+#include <qpe/qcopenvelope_qws.h>
+
+#include "AnyLnk.h"
+#include "KHUtil.h"
+
+class QCopLnk : public AnyLnk
+{
+public:
+	QCopLnk(){}
+	QCopLnk(const QStringList& params)
+		: AnyLnk(params){}
+	virtual ~QCopLnk() {
+	}
+
+	virtual bool isValid() {
+		return(true);
+	}
+	virtual QString name() {
+		return("qcop");
+	}
+	virtual const QPixmap& pixmap() {
+		return(m_pixmap);
+	}
+
+	virtual void execute();
+protected:
+};
+
+#endif /* _QCOPLNK_H_ */
+
diff --git a/noncore/applets/keyhelper/keyhelperapplet/anylnk/TextLnk.cpp b/noncore/applets/keyhelper/keyhelperapplet/anylnk/TextLnk.cpp
new file mode 100644
index 0000000..abb432c
--- a/dev/null
+++ b/noncore/applets/keyhelper/keyhelperapplet/anylnk/TextLnk.cpp
@@ -0,0 +1,34 @@
+#include "TextLnk.h"
+
+void TextLnk::execute()
+{
+	QClipboard* cb = QApplication::clipboard();
+	parseText();
+	cb->setText(m_params[1]);
+	QWSServer::sendKeyEvent('V'-'@',Qt::Key_V, Qt::ControlButton,
+		true, false);
+	QWSServer::sendKeyEvent('V'-'@',Qt::Key_V, Qt::ControlButton,
+		false, false);
+}
+
+void TextLnk::parse(QString& str)
+{
+	replace(str, "\\\\", "\\");
+	replace(str, "\\n", "\n");
+	replace(str, "\\r", "\r");
+	replace(str, "\\t", "\t");
+}
+
+void TextLnk::replace(QString& str, const QString& s1, const QString& s2)
+{
+	int index = 0;
+	int idx;
+	int len = s1.length();
+	idx = str.find(s1, index);
+	for(;;){
+		idx = str.find(s1, index);
+		if(idx < 0) break;
+		str.replace(idx, len, s2);
+		index = idx;
+	}
+}
diff --git a/noncore/applets/keyhelper/keyhelperapplet/anylnk/TextLnk.h b/noncore/applets/keyhelper/keyhelperapplet/anylnk/TextLnk.h
new file mode 100644
index 0000000..3ae13c5
--- a/dev/null
+++ b/noncore/applets/keyhelper/keyhelperapplet/anylnk/TextLnk.h
@@ -0,0 +1,38 @@
+#ifndef _PASTELNK_H_
+#define _PASTELNK_H_
+
+#include <qwindowsystem_qws.h>
+
+#include <qpe/qpeapplication.h>
+#include <qclipboard.h>
+#include <qregexp.h>
+
+#include "AnyLnk.h"
+
+class TextLnk : public AnyLnk
+{
+public:
+	TextLnk(){}
+	TextLnk(const QStringList& params)
+		: AnyLnk(params){}
+	virtual ~TextLnk() {
+	}
+
+	virtual bool isValid() {
+		return(true);
+	}
+	virtual QString name() {
+		return("text");
+	}
+	virtual const QPixmap& pixmap() {
+		return(m_pixmap);
+	}
+
+	virtual void execute();
+protected:
+	virtual void parse(QString& str);
+	virtual void replace(QString& str, const QString& s1, const QString& s2);
+};
+
+#endif /* _PASTELNK_H_ */
+
diff --git a/noncore/applets/keyhelper/keyhelperapplet/applet/KeyHelper.cpp b/noncore/applets/keyhelper/keyhelperapplet/applet/KeyHelper.cpp
new file mode 100644
index 0000000..4afdc1f
--- a/dev/null
+++ b/noncore/applets/keyhelper/keyhelperapplet/applet/KeyHelper.cpp
@@ -0,0 +1,112 @@
+#include "KeyHelper.h"
+#include <opie2/okeyfilter.h>
+
+KeyHelper::KeyHelper()
+{
+    qDebug("KeyHelper::KeyHelper()");
+    load();
+
+    m_oAction.setKeyModifiers(&m_oModifiers);
+    m_oAction.setKeyMappings(&m_oMappings);
+    m_oAction.setKeyExtensions(&m_oExtensions);
+    m_oAction.setKeyRepeater(&m_oRepeater);
+    m_oExtensions.setKeyModifiers(&m_oModifiers);
+}
+
+KeyHelper::~KeyHelper()
+{
+    unset();
+    qDebug("KeyHelper::~KeyHelper()");
+}
+
+bool KeyHelper::filter(int unicode, int keycode, int modifiers,
+        bool isPress, bool autoRepeat)
+{
+    m_oAction.setAction(unicode, keycode, modifiers,
+        isPress, autoRepeat);
+    return(m_oAction.doAction());
+}
+
+void KeyHelper::unset()
+{
+    Opie::Core::OKeyFilter::inst()->remHandler(this);;
+}
+
+void KeyHelper::set()
+{
+    Opie::Core::OKeyFilter::inst()->addHandler(this);
+    m_oModifiers.resetStates();
+}
+
+void KeyHelper::enable()
+{
+    m_oAction.enable();
+}
+
+void KeyHelper::disable()
+{
+    m_oAction.disable();
+    m_oRepeater.stop();
+}
+
+bool KeyHelper::load(const QString& file)
+{
+    KeycfgReader oReader;
+    oReader.setKeyModifiers(&m_oModifiers);
+    oReader.setKeyMappings(&m_oMappings);
+    oReader.setKeyExtensions(&m_oExtensions);
+    oReader.setKeyRepeater(&m_oRepeater);
+
+    bool success;
+    if(file.length() == 0){
+        success = oReader.load();
+    } else if(file[0] == '/'){
+        success = oReader.load(file);
+    } else {
+        //QString filepath = QString(::getenv("HOME")) + "/Settings/" + file;
+        QString filepath = QDir::homeDirPath() + "/Settings/" + file;
+        success = oReader.load(filepath);
+    }
+    if(success == false){
+        qDebug("config xml load error");
+        setDefault();
+    }
+    return(success);
+}
+
+bool KeyHelper::reload(const QString& file)
+{
+    m_oModifiers.reset();
+    m_oMappings.reset();
+    m_oExtensions.reset();
+    m_oRepeater.reset();
+
+    return(load(file));
+}
+
+void KeyHelper::setDefault()
+{
+    /* default settings */
+    m_oExtensions.assign("switch", Qt::Key_F12,
+        m_oModifiers.getMask("Shift"), KeyNames::getCode("Shift"));
+    m_oExtensions.assign("select", Qt::Key_F11,
+        m_oModifiers.getMask("Shift"), KeyNames::getCode("Shift"));
+}
+
+void KeyHelper::statistics()
+{
+    m_oModifiers.statistics();
+    m_oMappings.statistics();
+    m_oExtensions.statistics();
+    m_oRepeater.statistics();
+}
+
+void KeyHelper::dumpkeymap()
+{
+    const QWSServer::KeyMap* m = QWSServer::keyMap();
+    qWarning("KeyHelper::dumpkeymap()");
+    while(m->key_code != 0){
+        qWarning(" [%04x][%04x][%04x][%04x]", m->key_code, m->unicode, m->shift_unicode, m->ctrl_unicode);
+        m++;
+    }
+}
diff --git a/noncore/applets/keyhelper/keyhelperapplet/applet/KeyHelper.h b/noncore/applets/keyhelper/keyhelperapplet/applet/KeyHelper.h
new file mode 100644
index 0000000..aabb6eb
--- a/dev/null
+++ b/noncore/applets/keyhelper/keyhelperapplet/applet/KeyHelper.h
@@ -0,0 +1,42 @@
+#ifndef _KEY_HELPER_H_
+#define _KEY_HELPER_H_
+
+#include <qdir.h>
+#include <qwindowsystem_qws.h>
+#include "KeyNames.h"
+#include "KeyMappings.h"
+#include "KeyModifiers.h"
+#include "KeyExtensions.h"
+#include "KeyRepeater.h"
+#include "KeyAction.h"
+#include "KeycfgReader.h"
+
+class KeyHelper : public QWSServer::KeyboardFilter
+{
+public:
+    KeyHelper();
+    virtual ~KeyHelper();
+    bool filter(int unicode, int keycode, int modifiers,
+            bool isPress, bool autoRepeat);
+
+    void enable();
+    void disable();
+    void set();
+    void unset();
+    void statistics();
+    void dumpkeymap();
+    bool reload(const QString& file=QString::null);
+private:
+    friend class KeyHelperWidget;
+
+    bool load(const QString& file=QString::null);
+    void setDefault();
+
+    KeyAction m_oAction;
+    KeyMappings m_oMappings;
+    KeyModifiers m_oModifiers;
+    KeyExtensions m_oExtensions;
+    KeyRepeater m_oRepeater;
+};
+
+#endif /* _KEY_HELPER_H_ */
diff --git a/noncore/applets/keyhelper/keyhelperapplet/applet/KeyHelperApplet.cpp b/noncore/applets/keyhelper/keyhelperapplet/applet/KeyHelperApplet.cpp
new file mode 100644
index 0000000..28304d7
--- a/dev/null
+++ b/noncore/applets/keyhelper/keyhelperapplet/applet/KeyHelperApplet.cpp
@@ -0,0 +1,65 @@
+#include "KeyHelperApplet.h"
+#include "KeyHelperWidget.h"
+
+#if 0
+KeyHelperApplet::KeyHelperApplet()
+    : widget(0), ref(0)
+{
+    qDebug("KeyHelperApplet::KeyHelperApplet()");
+}
+
+KeyHelperApplet::~KeyHelperApplet()
+{
+    qDebug("KeyHelperApplet::~KeyHelperApplet()");
+    delete widget;
+}
+
+QWidget* KeyHelperApplet::applet(QWidget* parent)
+{
+    if(!widget){
+        widget = new KeyHelperWidget(parent);
+    }
+    return(widget);
+}
+
+int KeyHelperApplet::position() const
+{
+    return(6);
+}
+
+QRESULT KeyHelperApplet::queryInterface(const QUuid& uuid,
+    QUnknownInterface** iface)
+{
+    *iface = 0;
+
+    if(QFile::exists("/tmp/disable-keyhelper")
+        || QFile::exists("/mnt/card/disable-keyhelper")
+        || QFile::exists("/mnt/cf/disable-keyhelper")){
+        return QS_FALSE;
+    }
+
+    if(uuid == IID_QUnknown){
+        *iface = this;
+    } else if(uuid == IID_TaskbarApplet){
+        *iface = this;
+    }
+
+    if(*iface){
+        (*iface)->addRef();
+    }
+    return QS_OK;
+}
+
+Q_EXPORT_INTERFACE()
+{
+    Q_CREATE_INSTANCE(KeyHelperApplet)
+}
+
+#else
+#include <opie2/otaskbarapplet.h>
+
+using namespace Opie::Ui;
+
+EXPORT_OPIE_APPLET_v1( KeyHelperWidget )
+
+#endif
diff --git a/noncore/applets/keyhelper/keyhelperapplet/applet/KeyHelperApplet.h b/noncore/applets/keyhelper/keyhelperapplet/applet/KeyHelperApplet.h
new file mode 100644
index 0000000..ef164dc
--- a/dev/null
+++ b/noncore/applets/keyhelper/keyhelperapplet/applet/KeyHelperApplet.h
@@ -0,0 +1,26 @@
+#ifndef _KEY_HELPER_APPLET_H_
+#define _KEY_HELPER_APPLET_H_
+
+#if 0
+#include <qpe/taskbarappletinterface.h>
+#include "KeyHelperWidget.h"
+
+class KeyHelperApplet : public TaskbarAppletInterface
+{
+public:
+    KeyHelperApplet();
+    virtual ~KeyHelperApplet();
+
+    QRESULT queryInterface(const QUuid&, QUnknownInterface**);
+    Q_REFCOUNT
+
+    virtual QWidget* applet(QWidget* parent);
+    virtual int position() const;
+private:
+    KeyHelperWidget* widget;
+    ulong ref;
+};
+
+#endif
+
+#endif /* _KEY_HELPER_APPLET_H_ */
diff --git a/noncore/applets/keyhelper/keyhelperapplet/applet/KeyHelperWidget.cpp b/noncore/applets/keyhelper/keyhelperapplet/applet/KeyHelperWidget.cpp
new file mode 100644
index 0000000..7beb511
--- a/dev/null
+++ b/noncore/applets/keyhelper/keyhelperapplet/applet/KeyHelperWidget.cpp
@@ -0,0 +1,490 @@
+#include "KeyHelperWidget.h"
+#include "QSafeDataStream.h"
+#include "KHUtil.h"
+
+QWidget* g_Widget = NULL;
+int g_level = 0;
+
+static const char* _version_ = "1.2.2";
+
+KeyHelperWidget::KeyHelperWidget(QWidget* parent, const char* name)
+    : QLabel(parent, name),disabled(Resource::loadPixmap("zkb-disabled"))
+{
+    qDebug("KeyHelperWidget::KeyHelperWidget()");
+    g_Widget = this;
+    m_defHandler = NULL;
+    //m_reset = false;
+    m_reset = true;
+    m_useFilter = false;
+    m_pHelper = NULL;
+    m_status = false;
+
+    //unset();
+    initDebugLevel();
+
+    m_pHelper = new KeyHelper();
+
+    //qApp->installEventFilter(this);
+
+    connect(qwsServer,
+        SIGNAL(windowEvent(QWSWindow*, QWSServer::WindowEvent)),
+        this,
+        SLOT(windowEvent(QWSWindow*, QWSServer::WindowEvent)));
+
+    m_pChannel = new QCopChannel("QPE/KeyHelper", this);
+    connect(m_pChannel, SIGNAL(received(const QCString&, const QByteArray&)),
+        this, SLOT(receiveMessage(const QCString&, const QByteArray&)));
+    m_pSysChannel = new QCopChannel("QPE/System", this);
+    connect(m_pSysChannel, SIGNAL(received(const QCString&, const QByteArray&)),
+        this, SLOT(sysMessage(const QCString&, const QByteArray&)));
+
+    //AppLnkManager::init();
+    setFixedWidth ( AppLnk::smallIconSize()  );
+    setFixedHeight ( AppLnk::smallIconSize()  );
+    setPixmap(disabled);
+    init();
+}
+
+KeyHelperWidget::~KeyHelperWidget()
+{
+    qDebug("KeyHelperWidget::~KeyHelperWidget()");
+    disconnect(qwsServer,
+        SIGNAL(windowEvent(QWSWindow*, QWSServer::WindowEvent)),
+        this,
+        SLOT(windowEvent(QWSWindow*, QWSServer::WindowEvent)));
+    disconnect(m_pChannel, SIGNAL(received(const QCString&, const QByteArray&)),
+        this, SLOT(receiveMessage(const QCString&, const QByteArray&)));
+    unset();
+    if (m_pHelper) delete m_pHelper;
+    if (m_pChannel) delete m_pChannel;
+    if (m_pSysChannel) delete m_pSysChannel;
+    m_pHelper = NULL;
+    setDebugLevel(0);
+}
+
+void KeyHelperWidget::mouseReleaseEvent(QMouseEvent*)
+{
+    ConfigEx::getInstance("keyhelper").setConfig("keyhelper");
+}
+
+void KeyHelperWidget::receiveMessage(
+        const QCString& msg, const QByteArray& data)
+{
+    if(m_pHelper == NULL){
+        return;
+    }
+    QSafeDataStream stream(data, IO_ReadOnly);
+    if(msg == "event(int,int,int,int,int)"){
+        int unicode;
+        int keycode;
+        int modifiers;
+        int isPress;
+        int autoRepeat;
+        stream >> unicode >> keycode >> modifiers >> isPress >> autoRepeat;
+        doEvent(unicode, keycode, modifiers, isPress, autoRepeat);
+    } else if(msg == "event(QString,int)"){
+        QString key;
+        int isPress;
+        stream >> key >> isPress;
+        doEvent(key, isPress);
+    } else if(msg == "enable()"){
+        enable();
+    } else if(msg == "disable()"){
+        disable();
+    } else if(msg == "pause()"){
+        pause();
+    } else if(msg == "restart()"){
+        restart();
+    } else if(msg == "reload()"){
+        m_xmlfile = QString::null;
+        doReload();
+    } else if(msg == "reload(QString)"){
+        stream >> m_xmlfile;
+        doReload(false);
+    } else if(msg == "version()"){
+        version();
+    } else if(msg == "repeater(int)"){
+        int mode;
+        stream >> mode;
+        m_pHelper->m_oRepeater.setMode(mode);
+    } else if(msg == "hook(QString)"){
+        QString s;
+        stream >> s;
+        m_pHelper->m_oAction.setHook(s.local8Bit());
+    } else if(msg == "unhook()"){
+        m_pHelper->m_oAction.setHook("");
+    } else if(msg == "config()"){
+        ConfigEx::getInstance("keyhelper").setConfig("keyhelper");
+    } else if(msg == "config(QString)"){
+        QString name;
+        stream >> name;
+        if(name == QString::null){
+            ConfigEx::getInstance("keyhelper").setConfig("keyhelper");
+        } else {
+            ConfigEx::getInstance("keyhelper").setConfig(name);
+        }
+    } else if(msg == "capture(int)"){
+        int enable;
+        stream >> enable;
+        m_pHelper->m_oAction.setCapture(enable);
+    } else if(msg == "statistics()"){
+        int level = g_level;
+        if(level == 0){
+            setDebugLevel(1);
+        }
+        m_pHelper->statistics();
+        if(level == 0){
+            setDebugLevel(0);
+        }
+    } else if(msg == "dumpkeymap()"){
+        int level = g_level;
+        if(level == 0){
+            setDebugLevel(1);
+        }
+        m_pHelper->dumpkeymap();
+        if(level == 0){
+            setDebugLevel(0);
+        }
+    } else if(msg == "debug(int)"){
+        int level;
+        stream >> level;
+        setDebugLevel(level);
+    }
+}
+
+void KeyHelperWidget::doReload(bool showstatus)
+{
+    ConfigEx& cfg = ConfigEx::getInstance("keyhelper");
+    QString oldgroup = cfg.getGroup();
+    cfg.setGroup("Global");
+    m_status = false;
+    if(showstatus && (cfg.readNumEntry("ShowStatusOnReload", 1) == 1)){
+        m_status = true;
+        version();
+        QCopEnvelope("QPE/System", "busy()");
+    }
+    cfg.setGroup(oldgroup);
+    QTimer::singleShot(0, this, SLOT(reload()));
+}
+
+void KeyHelperWidget::doEvent(int unicode, int keycode, int modifiers, int isPress, int autoRepeat)
+{
+    if(isPress == 0 || isPress == 1){
+        m_pHelper->m_oAction.setAction(unicode, keycode, modifiers, isPress, autoRepeat);
+        m_pHelper->m_oAction.doAction();
+    } else {
+        /* press & release */
+        m_pHelper->m_oAction.setAction(unicode, keycode, modifiers, 1, autoRepeat);
+        m_pHelper->m_oAction.doAction();
+        m_pHelper->m_oAction.setAction(unicode, keycode, modifiers, 0, autoRepeat);
+        m_pHelper->m_oAction.doAction();
+    }
+}
+
+void KeyHelperWidget::doEvent(const QString& key, int isPress)
+{
+    int unicode,keycode;
+    int modifiers = 0;
+    int pos;
+    QString keyname = key;
+    pos = keyname.find("+SHIFT", 0, FALSE);
+    if(pos > 0){
+        modifiers |= Qt::ShiftButton;
+        keyname.remove(pos, 6);
+    }
+    pos = keyname.find("+CTRL", 0, FALSE);
+    if(pos > 0){
+        modifiers |= Qt::ControlButton;
+        keyname.remove(pos, 5);
+    }
+    pos = keyname.find("+ALT", 0, FALSE);
+    if(pos > 0){
+        modifiers |= Qt::AltButton;
+        keyname.remove(pos, 4);
+    }
+    if(keyname.length() > 1){
+        unicode = 0xffff;
+        keycode = KeyNames::getCode(keyname);
+        /* get unicode */
+        const QWSServer::KeyMap* m;
+        for(m=QWSServer::keyMap(); m->key_code != 0; m++){
+            if(m->key_code == keycode){
+                if(modifiers & Qt::ControlButton){
+                    unicode = m->ctrl_unicode;
+                } else if(modifiers & Qt::ShiftButton){
+                    unicode = m->shift_unicode;
+                } else {
+                    unicode = m->unicode;
+                }
+                break;
+            }
+        }
+    } else {
+        const QWSServer::KeyMap* m;
+        keycode = 0;
+        unicode = keyname[0].unicode();
+        /* check unicode */
+        for(m=QWSServer::keyMap(); keycode == 0 && m->key_code != 0; m++){
+            if(m->unicode == unicode){
+                keycode = m->key_code;
+                break;
+            }
+        }
+        /* check shift_unicode */
+        for(m=QWSServer::keyMap(); keycode == 0 && m->key_code != 0; m++){
+            if(m->shift_unicode == unicode){
+                keycode = m->key_code;
+                modifiers |= Qt::ShiftButton;
+                break;
+            }
+        }
+        /* check ctrl_unicode */
+        for(m=QWSServer::keyMap(); keycode == 0 && m->key_code != 0; m++){
+            if(m->ctrl_unicode == unicode){
+                keycode = m->key_code;
+                modifiers |= Qt::ControlButton;
+                break;
+            }
+        }
+    }
+    doEvent(unicode, keycode, modifiers, isPress, 0);
+}
+
+void KeyHelperWidget::sysMessage(
+        const QCString& msg, const QByteArray& data)
+{
+    QSafeDataStream stream(data, IO_ReadOnly);
+    if(msg == "linkChanged(QString)"){
+        ConfigEx& cfg = ConfigEx::getInstance("keyhelper");
+        QString oldgroup = cfg.getGroup();
+        if(cfg.readNumEntry("DetectLinkChange", 1) == 1){
+            AppLnkManager::init(true);
+            reload();
+        }
+        cfg.setGroup(oldgroup);
+    }
+}
+
+void MsgHandler(QtMsgType type, const char* msg)
+{
+    switch(type){
+    case QtDebugMsg:
+        if(g_level >= 2){
+            syslog(LOG_LOCAL5|LOG_DEBUG,
+                "<2>%s", msg);
+        }
+        break;
+    case QtWarningMsg:
+        if(g_level >= 1){
+            syslog(LOG_LOCAL5|LOG_DEBUG,
+                "<1>%s", msg);
+        }
+        break;
+    default:
+        break;
+    }
+}
+
+void KeyHelperWidget::initDebugLevel()
+{
+    ConfigEx& cfg = ConfigEx::getInstance("keyhelper");
+    cfg.setGroup("Global");
+
+    int level = cfg.readNumEntry("DebugLevel", 0);
+    setDebugLevel(level);
+}
+
+void KeyHelperWidget::setDebugLevel(int level)
+{
+#ifdef QT_QWS_EBX
+    static bool noDebug = true;
+    g_level = level;
+    if(g_level > 0){
+        if(noDebug){
+            m_defHandler = qInstallMsgHandler(MsgHandler);
+            noDebug = false;
+        }
+    } else {
+        qInstallMsgHandler(m_defHandler);
+        noDebug = true;
+    }
+#endif
+}
+
+void KeyHelperWidget::enable()
+{
+    m_enable = true;
+    m_pHelper->enable();
+    //set();
+    QTimer::singleShot(0, this, SLOT(set()));
+}
+
+void KeyHelperWidget::disable()
+{
+    m_enable = false;
+    m_pHelper->disable();
+    unset();
+}
+
+void KeyHelperWidget::pause()
+{
+    m_saved = m_enable;
+    disable();
+}
+
+void KeyHelperWidget::restart()
+{
+    if(m_saved){
+        enable();
+    }
+}
+
+void KeyHelperWidget::reload()
+{
+    disable();
+    ConfigEx& cfg = ConfigEx::getInstance("keyhelper");
+    cfg.reload();
+    if(m_pHelper->reload(m_xmlfile) == false){
+        if(m_status){
+            Global::statusMessage("KeyHelper: Load Error");
+        }
+    }
+    init();
+    if(m_status){
+        QCopEnvelope e("QPE/System", "notBusy(QString)");
+        const QString app = KHUtil::currentApp();
+        e << app;
+        m_status = false;
+    }
+}
+
+void KeyHelperWidget::version()
+{
+    QString ver = "KeyHelper ";
+    ver.append(_version_);
+    Global::statusMessage(ver);
+}
+
+void KeyHelperWidget::init()
+{
+    AppLnkManager::init();
+#if 0
+    if(m_pHelper == NULL){
+        m_pHelper = new KeyHelper();
+    }
+#endif
+    loadUseFilterApps();
+    enable();
+}
+
+void KeyHelperWidget::set()
+{
+    if(m_pHelper != NULL && m_enable == true && m_useFilter == false){
+        qWarning("KeyHelperWidget::set()");
+        m_pHelper->set();
+    }
+}
+
+void KeyHelperWidget::unset()
+{
+    m_pHelper->unset();
+}
+
+void KeyHelperWidget::loadUseFilterApps()
+{
+    ConfigEx& cfg = ConfigEx::getInstance("keyhelper");
+
+    cfg.setGroup("Global");
+    m_apps = cfg.readListEntry("UseFilterApps", ',');
+
+    if(m_apps.isEmpty()){
+        /* default */
+        m_apps.append("CRIM");
+        m_apps.append("Jpn50Pad");
+        m_apps.append("JpnKtnPad");
+        m_apps.append("JpnNumPad");
+        m_apps.append("JpnSymPad");
+        m_apps.append("Keyboard");
+        m_apps.append("IMWidget");  /* IMKit */
+        m_apps.append("POBox");     /* QPOBox */
+    }
+}
+
+#if 0
+void KeyHelperWidget::windowEvent(QWSWindow* w, QWSServer::WindowEvent e)
+{
+    if(m_apps.contains(w->name())){
+        switch(e){
+        case QWSServer::Hide:
+        case QWSServer::Destroy:
+            m_useFilter = false;
+            //m_reset = true;
+            QTimer::singleShot(0, this, SLOT(set()));
+            break;
+        case QWSServer::Create:
+        case QWSServer::Raise:
+        case QWSServer::Show:
+            m_useFilter = true;
+            //m_reset = false;
+            m_reset = true;
+            break;
+        default:
+            break;
+        }
+    } else if(w->client()->identity() != NULL && w->name() != NULL){
+        switch(e){
+#if 0
+        case QWSServer::Create:
+        case QWSServer::Hide:
+            if(m_useFilter == false && m_reset){
+                m_reset = false;
+                set();
+                //QTimer::singleShot(0, this, SLOT(set()));
+            }
+            break;
+#else
+        case QWSServer::Hide:
+        case QWSServer::Destroy:
+            //if(m_useFilter == false && m_reset){
+            if(m_reset){
+                m_reset = false;
+                set();
+                //QTimer::singleShot(0, this, SLOT(set()));
+            }
+            break;
+        case QWSServer::Create:
+        case QWSServer::Raise:
+        case QWSServer::Show:
+            m_reset = true;
+            break;
+#endif
+        default:
+#if 0
+            if(m_reset == true){
+                m_reset = false;
+                set();
+            }
+#endif
+            break;
+        }
+    }
+    if(w->name() != NULL){
+        qWarning("[%s][%s][%x][%s]",
+            w->name().latin1(),
+            w->caption().latin1(),
+            e,
+            w->client()->identity().latin1());
+    }
+}
+
+#endif
+
+bool KeyHelperWidget::eventFilter(QObject* o, QEvent* e)
+{
+    return QWidget::eventFilter(o, e);
+}
+
+int KeyHelperWidget::position()
+{
+    return 3;
+}
diff --git a/noncore/applets/keyhelper/keyhelperapplet/applet/KeyHelperWidget.h b/noncore/applets/keyhelper/keyhelperapplet/applet/KeyHelperWidget.h
new file mode 100644
index 0000000..4798c5c
--- a/dev/null
+++ b/noncore/applets/keyhelper/keyhelperapplet/applet/KeyHelperWidget.h
@@ -0,0 +1,75 @@
+#ifndef _KEY_HELPER_WIDGET_H_
+#define _KEY_HELPER_WIDGET_H_
+
+#include <qwidget.h>
+#include <qlabel.h>
+#include <qpixmap.h>
+#include <qtimer.h>
+#include <qaccel.h>
+#include <opie2/otaskbarapplet.h>
+#include <opie2/okeyfilter.h>
+
+#include <qpe/qcopenvelope_qws.h>
+#include <qpe/qpeapplication.h>
+#include <qpe/global.h>
+#include <qpe/resource.h>
+#include "KeyHelper.h"
+#include "AppLnkManager.h"
+#include "ConfigEx.h"
+
+#include <syslog.h>
+
+Q_EXPORT void MsgHandler(QtMsgType type, const char* msg);
+
+class KeyHelperWidget : public QLabel
+{
+    Q_OBJECT
+public:
+    KeyHelperWidget(QWidget* parent = 0, const char* name=0);
+    ~KeyHelperWidget();
+    static int position();
+
+    virtual bool eventFilter(QObject* o, QEvent* e);
+
+public slots:
+    //void windowEvent(QWSWindow* w, QWSServer::WindowEvent e);
+protected:
+    QCopChannel* m_pChannel;
+    QCopChannel* m_pSysChannel;
+    QPixmap disabled;
+
+protected slots:
+    void receiveMessage(const QCString& msg, const QByteArray& data);
+    void sysMessage(const QCString& msg, const QByteArray& data);
+    void reload();
+    void set();
+    void unset();
+    void init();
+    void mouseReleaseEvent(QMouseEvent*);
+
+private:
+    void loadUseFilterApps();
+    void enable();
+    void disable();
+    void pause();
+    void restart();
+    void version();
+    void setDebugLevel(int level);
+    void initDebugLevel();
+
+    bool m_reset;
+    bool m_useFilter;
+    bool m_status;
+    QString m_xmlfile;
+    msg_handler m_defHandler;
+    bool m_enable;
+    bool m_saved;
+    QStringList m_apps;
+    KeyHelper* m_pHelper;
+private slots:
+    void doReload(bool showstatus=true);
+    void doEvent(int,int,int,int,int);
+    void doEvent(const QString&, int);
+};
+
+#endif /* _KEY_HELPER_WIDGET_H_ */
diff --git a/noncore/applets/keyhelper/keyhelperapplet/applet/QSafeDataStream.cpp b/noncore/applets/keyhelper/keyhelperapplet/applet/QSafeDataStream.cpp
new file mode 100644
index 0000000..69ba562
--- a/dev/null
+++ b/noncore/applets/keyhelper/keyhelperapplet/applet/QSafeDataStream.cpp
@@ -0,0 +1,203 @@
+#include "QSafeDataStream.h"
+
+#include <qstring.h>
+#include <qstringlist.h>
+#include <qdatetime.h>
+
+QSafeDataStream &QSafeDataStream::operator>>( Q_INT8 &i )
+{
+	if(atEnd()){
+		i = 0;
+		return *this;
+	} else {
+		return (QSafeDataStream&)QDataStream::operator>>(i);
+	}
+}
+
+QSafeDataStream &QSafeDataStream::operator>>( Q_UINT8 &i )
+{
+	if(atEnd()){
+		i = 0;
+		return *this;
+	} else {
+		return (QSafeDataStream&)QDataStream::operator>>(i);
+	}
+}
+
+QSafeDataStream &QSafeDataStream::operator>>( Q_INT16 &i )
+{
+	if(atEnd()){
+		i = 0;
+		return *this;
+	} else {
+		return (QSafeDataStream&)QDataStream::operator>>(i);
+	}
+}
+
+QSafeDataStream &QSafeDataStream::operator>>( Q_UINT16 &i )
+{
+	if(atEnd()){
+		i = 0;
+		return *this;
+	} else {
+		return (QSafeDataStream&)QDataStream::operator>>(i);
+	}
+}
+
+QSafeDataStream &QSafeDataStream::operator>>( Q_INT32 &i )
+{
+	if(atEnd()){
+		i = 0;
+		return *this;
+	} else {
+		return (QSafeDataStream&)QDataStream::operator>>(i);
+	}
+}
+
+QSafeDataStream &QSafeDataStream::operator>>( Q_UINT32 &i )
+{
+	if(atEnd()){
+		i = 0;
+		return *this;
+	} else {
+		return (QSafeDataStream&)QDataStream::operator>>(i);
+	}
+}
+
+QSafeDataStream &QSafeDataStream::operator>>( Q_INT64 &i )
+{
+	if(atEnd()){
+		i = 0;
+		return *this;
+	} else {
+		return (QSafeDataStream&)QDataStream::operator>>(i);
+	}
+}
+
+QSafeDataStream &QSafeDataStream::operator>>( Q_UINT64 &i )
+{
+	if(atEnd()){
+		i = 0;
+		return *this;
+	} else {
+		return (QSafeDataStream&)QDataStream::operator>>(i);
+	}
+}
+
+
+QSafeDataStream &QSafeDataStream::operator>>( float &f )
+{
+	if(atEnd()){
+		f = 0;
+		return *this;
+	} else {
+		return (QSafeDataStream&)QDataStream::operator>>(f);
+	}
+}
+
+QSafeDataStream &QSafeDataStream::operator>>( double &f )
+{
+	if(atEnd()){
+		f = 0;
+		return *this;
+	} else {
+		return (QSafeDataStream&)QDataStream::operator>>(f);
+	}
+}
+
+QSafeDataStream &QSafeDataStream::operator>>( char *&str )
+{
+	if(atEnd()){
+		str = 0;
+		return *this;
+	} else {
+		return (QSafeDataStream&)QDataStream::operator>>(str);
+	}
+}
+
+QSafeDataStream &QSafeDataStream::readBytes( char *&s, uint &len )
+{
+	if(atEnd()){
+		s = 0;
+		len = 0;
+		return *this;
+	} else {
+		return (QSafeDataStream&)QDataStream::readBytes(s, len);
+	}
+}
+
+QSafeDataStream &QSafeDataStream::readRawBytes( char *s, uint len )
+{
+	if(atEnd()){
+		return *this;
+	} else {
+		return (QSafeDataStream&)QDataStream::readRawBytes(s, len);
+	}
+}
+
+QSafeDataStream &QSafeDataStream::operator>>( QString& s )
+{
+	if(atEnd()){
+		s = QString::null;
+		return *this;
+	} else {
+		return (QSafeDataStream&)(*((QDataStream*)this) >> s);
+	}
+}
+
+QSafeDataStream &QSafeDataStream::operator>>( QStringList& list )
+{
+	if(atEnd()){
+		list.clear();
+		return *this;
+	} else {
+		return (QSafeDataStream&)(*((QDataStream*)this) >> list);
+	}
+}
+
+QSafeDataStream &QSafeDataStream::operator>>( QByteArray& a )
+{
+	if(atEnd()){
+		a.resize(0);
+		return *this;
+	} else {
+		return (QSafeDataStream&)(*((QDataStream*)this) >> a);
+	}
+}
+
+QSafeDataStream &QSafeDataStream::operator>>( QCString& s )
+{
+	if(atEnd()){
+		s.resize(0);
+		return *this;
+	} else {
+		return (QSafeDataStream&)(*((QDataStream*)this) >> s);
+	}
+}
+
+QSafeDataStream &QSafeDataStream::operator>>( QDate& d )
+{
+	if(atEnd()){
+		return *this;
+	} else {
+		return (QSafeDataStream&)(*((QDataStream*)this) >> d);
+	}
+}
+
+QSafeDataStream &QSafeDataStream::operator>>( QTime& t )
+{
+	if(atEnd()){
+		return *this;
+	} else {
+		return (QSafeDataStream&)(*((QDataStream*)this) >> t);
+	}
+}
+
+QSafeDataStream &QSafeDataStream::operator>>( QDateTime& dt )
+{
+	if(atEnd()){
+		return *this;
+	} else {
+		return (QSafeDataStream&)(*((QDataStream*)this) >> dt);
+	}
+}
diff --git a/noncore/applets/keyhelper/keyhelperapplet/applet/QSafeDataStream.h b/noncore/applets/keyhelper/keyhelperapplet/applet/QSafeDataStream.h
new file mode 100644
index 0000000..2152b23
--- a/dev/null
+++ b/noncore/applets/keyhelper/keyhelperapplet/applet/QSafeDataStream.h
@@ -0,0 +1,51 @@
+#ifndef _QSAFEDATASTREAM_H_
+#define _QSAFEDATASTREAM_H_
+
+#include <qdatastream.h>
+
+class QString;
+class QStringList;
+class QCString;
+class QDate;
+class QTime;
+class QDateTime;
+
+class QSafeDataStream : public QDataStream
+{
+public:
+	/* constructors */
+	QSafeDataStream()
+		: QDataStream() {}
+	QSafeDataStream(QIODevice* d)
+		: QDataStream(d) {}
+	QSafeDataStream(QByteArray a, int mode)
+		: QDataStream(a, mode) {}
+
+    /* read functions */
+    QSafeDataStream &operator>>( Q_INT8 &i );
+    QSafeDataStream &operator>>( Q_UINT8 &i );
+    QSafeDataStream &operator>>( Q_INT16 &i );
+    QSafeDataStream &operator>>( Q_UINT16 &i );
+    QSafeDataStream &operator>>( Q_INT32 &i );
+    QSafeDataStream &operator>>( Q_UINT32 &i );
+    QSafeDataStream &operator>>( Q_INT64 &i );
+    QSafeDataStream &operator>>( Q_UINT64 &i );
+
+    QSafeDataStream &operator>>( float &f );
+    QSafeDataStream &operator>>( double &f );
+    QSafeDataStream &operator>>( char *&str );
+
+    QSafeDataStream &readBytes( char *&, uint &len );
+    QSafeDataStream &readRawBytes( char *, uint len );
+
+    QSafeDataStream &operator>>( QString& s );
+	QSafeDataStream &operator>>( QStringList& list );
+	QSafeDataStream &operator>>( QByteArray& a );
+	QSafeDataStream &operator>>( QCString& s );
+	QSafeDataStream &operator>>( QDate& d );
+	QSafeDataStream &operator>>( QTime& t );
+	QSafeDataStream &operator>>( QDateTime& dt );
+
+};
+
+#endif /* _QSAFEDATASTREAM_H_ */
diff --git a/noncore/applets/keyhelper/keyhelperapplet/config/ExtensionsHandler.cpp b/noncore/applets/keyhelper/keyhelperapplet/config/ExtensionsHandler.cpp
new file mode 100644
index 0000000..84bb375
--- a/dev/null
+++ b/noncore/applets/keyhelper/keyhelperapplet/config/ExtensionsHandler.cpp
@@ -0,0 +1,80 @@
+#include "ExtensionsHandler.h"
+
+void ExtensionsHandler::dispose(QXmlReader* parser, QXmlContentHandler* parent)
+{
+	m_parser = parser;
+	m_parent = parent;
+	m_parser->setContentHandler(this);
+}
+
+bool ExtensionsHandler::startElement(const QString& /* namespaceURI */,
+	const QString& localName,
+	const QString& /* qName */,
+	const QXmlAttributes& attr)
+{
+	if(localName == "define"){
+		/* ÊÑ¿ô½é´ü²½ */
+		m_kind = QString::null;
+		m_code = -1;
+		//m_mask = 0;
+		m_modlist.clear();
+		for(int i=0; i<attr.length(); i++){
+			if(attr.localName(i).lower() == "key"){
+				/* keyname */
+				if(attr.value(i) == "All"){
+					m_code = 0;
+				} else {
+					m_code = KeyNames::getCode(attr.value(i));
+				}
+			} else if(attr.localName(i).lower() == "code"){
+				/* keycode */
+				m_code = KHUtil::hex2int(attr.value(i).lower());
+			} else if(attr.localName(i).lower() == "kind"){
+				/* extension kind */
+				m_kind = attr.value(i);
+			}
+		}
+	} else if(localName == "modifier"){
+		/* modifier keys */
+		for(int i=0; i<attr.length(); i++){
+			if(attr.value(i).lower() == "on"){
+				m_modlist.append(attr.localName(i));
+				//m_mask |= m_pModifiers->getMask(attr.localName(i));
+			}
+		}
+	}
+	return(true);
+}
+
+bool ExtensionsHandler::endElement(const QString& /* namespaceURI */,
+	const QString& localName,
+	const QString& /* qName */)
+{
+	if(localName == "define"){
+#if 0
+		if(m_kind != QString::null
+			&& (m_code > 0 || m_modlist.isEmpty() == false)){
+#else
+		if(m_kind != QString::null && m_code >= 0){
+#endif
+			/* assign extension */
+			int keymask = 0;
+			QValueList<int> modcodes;
+			for(QStringList::Iterator it=m_modlist.begin();
+					it!=m_modlist.end(); ++it){
+				keymask |= m_pModifiers->getMask(*it);
+				qDebug("mask[%s][%x][%s]", m_kind.latin1(), keymask, (*it).latin1());
+				int code = KeyNames::getCode(*it);
+				if(code > 0){
+					modcodes.append(code);
+				}
+			}
+			m_pExtensions->assign(m_kind, m_code, keymask, modcodes);
+		}
+	} else if(localName == "extensions"){
+		m_pExtensions->init();
+		/* return parent */
+		m_parser->setContentHandler(m_parent);
+	}
+	return(true);
+}
diff --git a/noncore/applets/keyhelper/keyhelperapplet/config/ExtensionsHandler.h b/noncore/applets/keyhelper/keyhelperapplet/config/ExtensionsHandler.h
new file mode 100644
index 0000000..cc2422b
--- a/dev/null
+++ b/noncore/applets/keyhelper/keyhelperapplet/config/ExtensionsHandler.h
@@ -0,0 +1,48 @@
+#ifndef _EXTENSIONS_HANDLER_H_
+#define _EXTENSIONS_HANDLER_H_
+
+#include <qstring.h>
+#include <qstringlist.h>
+#include <qvaluelist.h>
+#include <qxml.h>
+#include "KeyModifiers.h"
+#include "KeyExtensions.h"
+#include "KeyNames.h"
+#include "KHUtil.h"
+
+class ExtensionsHandler : public QXmlDefaultHandler
+{
+public:
+	void dispose(QXmlReader* parser, QXmlContentHandler* parent);
+
+	void setKeyModifiers(KeyModifiers* mod)
+	{
+		m_pModifiers = mod;
+	}
+	void setKeyExtensions(KeyExtensions* ext)
+	{
+		m_pExtensions = ext;
+	}
+
+	bool startElement(const QString& namespaceURI,
+		const QString& localName,
+		const QString& qName,
+		const QXmlAttributes& atts);
+	bool endElement(const QString& namespaceURI,
+		const QString& localName,
+		const QString& qName);
+private:
+	QXmlContentHandler* m_parent;
+	QXmlReader* m_parser;
+
+	KeyModifiers* m_pModifiers;
+	KeyExtensions* m_pExtensions;
+
+	QString m_kind;
+	int m_code;
+	QStringList m_modlist;
+	//int m_mask;
+
+};
+
+#endif /* _EXTENSIONS_HANDLER_H_ */
diff --git a/noncore/applets/keyhelper/keyhelperapplet/config/KeycfgErrorHandler.cpp b/noncore/applets/keyhelper/keyhelperapplet/config/KeycfgErrorHandler.cpp
new file mode 100644
index 0000000..e1faf18
--- a/dev/null
+++ b/noncore/applets/keyhelper/keyhelperapplet/config/KeycfgErrorHandler.cpp
@@ -0,0 +1,38 @@
+#include "KeycfgErrorHandler.h"
+
+void KeycfgErrorHandler::setErrorString(const QString& header,
+	const QXmlParseException& exception)
+{
+	m_errstr = header;
+	m_errstr.append(": ");
+	m_errstr.append(exception.message());
+	m_errstr.append(" [");
+	m_errstr.append(QString::number(exception.lineNumber()));
+	m_errstr.append(", ");
+	m_errstr.append(QString::number(exception.columnNumber()));
+	m_errstr.append("]");
+	qWarning(m_errstr.latin1());
+}
+
+bool KeycfgErrorHandler::warning(const QXmlParseException& exception)
+{
+	setErrorString("warning", exception);
+	return(true);
+}
+
+bool KeycfgErrorHandler::error(const QXmlParseException& exception)
+{
+	setErrorString("error", exception);
+	return(false);
+}
+
+bool KeycfgErrorHandler::fatalError(const QXmlParseException& exception)
+{
+	setErrorString("fatal", exception);
+	return(false);
+}
+
+QString KeycfgErrorHandler::errorString()
+{
+	return(m_errstr);
+}
diff --git a/noncore/applets/keyhelper/keyhelperapplet/config/KeycfgErrorHandler.h b/noncore/applets/keyhelper/keyhelperapplet/config/KeycfgErrorHandler.h
new file mode 100644
index 0000000..61e7e70
--- a/dev/null
+++ b/noncore/applets/keyhelper/keyhelperapplet/config/KeycfgErrorHandler.h
@@ -0,0 +1,23 @@
+#ifndef _KEYCFG_ERROR_HANDLER_H_
+#define _KEYCFG_ERROR_HANDLER_H_
+
+#include <qstring.h>
+#include <qxml.h>
+
+class KeycfgErrorHandler : public QXmlErrorHandler
+{
+public:
+	KeycfgErrorHandler(){}
+	virtual ~KeycfgErrorHandler(){}
+
+	bool warning(const QXmlParseException& exception);
+	bool error(const QXmlParseException& exception);
+	bool fatalError(const QXmlParseException& exception);
+	QString errorString();
+private:
+	void setErrorString(const QString& header,
+		const QXmlParseException& exception);
+	QString m_errstr;
+};
+
+#endif /* _KEYCFG_ERROR_HANDLER_H_ */
diff --git a/noncore/applets/keyhelper/keyhelperapplet/config/KeycfgHandler.cpp b/noncore/applets/keyhelper/keyhelperapplet/config/KeycfgHandler.cpp
new file mode 100644
index 0000000..a342e36
--- a/dev/null
+++ b/noncore/applets/keyhelper/keyhelperapplet/config/KeycfgHandler.cpp
@@ -0,0 +1,43 @@
+#include "KeycfgHandler.h"
+
+KeycfgHandler::KeycfgHandler(QXmlReader* parser)
+	: QXmlDefaultHandler()
+{
+	m_parser = parser;
+	m_pModHandler = new ModifiersHandler();
+	m_pMapHandler = new MappingsHandler();
+	m_pExtHandler = new ExtensionsHandler();
+	m_pRepHandler = new RepeaterHandler();
+}
+
+KeycfgHandler::~KeycfgHandler()
+{
+	delete m_pModHandler;
+	delete m_pMapHandler;
+	delete m_pExtHandler;
+	delete m_pRepHandler;
+}
+
+bool KeycfgHandler::startElement(const QString& /* namespaceURI */,
+	const QString& localName,
+	const QString& /* qName */,
+	const QXmlAttributes& /* attr */)
+{
+	if(localName == "modifiers"){
+		m_pModHandler->setKeyModifiers(m_pModifiers);
+		m_pModHandler->setKeyMappings(m_pMappings);
+		m_pModHandler->dispose(m_parser, this);
+	} else if(localName == "mappings"){
+		m_pMapHandler->setKeyModifiers(m_pModifiers);
+		m_pMapHandler->setKeyMappings(m_pMappings);
+		m_pMapHandler->dispose(m_parser, this);
+	} else if(localName == "extensions"){
+		m_pExtHandler->setKeyModifiers(m_pModifiers);
+		m_pExtHandler->setKeyExtensions(m_pExtensions);
+		m_pExtHandler->dispose(m_parser, this);
+	} else if(localName == "repeater"){
+		m_pRepHandler->setKeyRepeater(m_pRepeater);
+		m_pRepHandler->dispose(m_parser, this);
+	}
+	return(true);
+}
diff --git a/noncore/applets/keyhelper/keyhelperapplet/config/KeycfgHandler.h b/noncore/applets/keyhelper/keyhelperapplet/config/KeycfgHandler.h
new file mode 100644
index 0000000..9ddded3
--- a/dev/null
+++ b/noncore/applets/keyhelper/keyhelperapplet/config/KeycfgHandler.h
@@ -0,0 +1,56 @@
+#ifndef _KEYCFG_HANDLER_H_
+#define _KEYCFG_HANDLER_H_
+
+#include <qxml.h>
+#include <qstring.h>
+#include "ModifiersHandler.h"
+#include "MappingsHandler.h"
+#include "ExtensionsHandler.h"
+#include "RepeaterHandler.h"
+
+class KeycfgHandler : public QXmlDefaultHandler
+{
+public:
+	KeycfgHandler(QXmlReader* parser);
+	~KeycfgHandler();
+
+	void dispose(QXmlReader* parser, QXmlContentHandler* parent);
+	
+	void setKeyModifiers(KeyModifiers* mod)
+	{
+		m_pModifiers = mod;
+	}
+	void setKeyMappings(KeyMappings* map)
+	{
+		m_pMappings = map;
+	}
+	void setKeyExtensions(KeyExtensions* ext)
+	{
+		m_pExtensions = ext;
+	}
+	void setKeyRepeater(KeyRepeater* rep)
+	{
+		m_pRepeater = rep;
+	}
+
+
+	bool startElement(const QString& namespaceURI,
+		const QString& localName,
+		const QString& qName,
+		const QXmlAttributes& atts);
+private:
+	QXmlContentHandler* m_parent;
+	QXmlReader* m_parser;
+
+	ModifiersHandler* m_pModHandler;
+	MappingsHandler* m_pMapHandler;
+	ExtensionsHandler* m_pExtHandler;
+	RepeaterHandler* m_pRepHandler;
+
+	KeyModifiers* m_pModifiers;
+	KeyMappings* m_pMappings;
+	KeyExtensions* m_pExtensions;
+	KeyRepeater* m_pRepeater;
+};
+
+#endif /* _KEYCFG_HANDLER_H_ */
diff --git a/noncore/applets/keyhelper/keyhelperapplet/config/KeycfgReader.cpp b/noncore/applets/keyhelper/keyhelperapplet/config/KeycfgReader.cpp
new file mode 100644
index 0000000..44b4b2f
--- a/dev/null
+++ b/noncore/applets/keyhelper/keyhelperapplet/config/KeycfgReader.cpp
@@ -0,0 +1,70 @@
+#include "KeycfgReader.h"
+
+KeycfgReader::KeycfgReader()
+{
+	qDebug("KeycfgReader::KeycfgReader()");
+}
+
+KeycfgReader::~KeycfgReader()
+{
+	qDebug("KeycfgReader::~KeycfgReader()");
+}
+
+bool KeycfgReader::load()
+{
+	QString file;
+	ConfigEx& cfg = ConfigEx::getInstance("keyhelper");
+
+	cfg.setGroup("Global");
+
+	file = cfg.readEntry("XmlFile");
+	if(file.length() == 0 || !QFile::exists(file)){
+		/* default */
+		file = QDir::homeDirPath() + "/Settings/keyhelper.xml";
+	}
+	return(load(file));
+}
+
+bool KeycfgReader::load(const QString& path)
+{
+	bool success = false;
+
+	KeyNames::reset();
+
+	QXmlSimpleReader parser;
+	KeycfgHandler handler(&parser);
+	KeycfgErrorHandler errhandler;
+	QFile file(path);
+
+	qWarning("KeycfgReader::load()[%s]", path.latin1());
+
+	if(file.exists()){
+		QXmlInputSource source(file);
+
+		handler.setKeyModifiers(m_pModifiers);
+		handler.setKeyMappings(m_pMappings);
+		handler.setKeyExtensions(m_pExtensions);
+		handler.setKeyRepeater(m_pRepeater);
+
+		parser.setContentHandler(&handler);
+		parser.setErrorHandler(&errhandler);
+		success = parser.parse(source);
+
+		file.close();
+	}
+
+	if(success){
+		m_pModifiers->statistics();
+		m_pMappings->statistics();
+		m_pExtensions->statistics();
+		m_pRepeater->statistics();
+	} else {
+		m_pModifiers->reset();
+		m_pMappings->reset();
+		m_pExtensions->reset();
+		m_pRepeater->reset();
+	}
+	KeyNames::clearCode();
+
+	return(success);
+}
diff --git a/noncore/applets/keyhelper/keyhelperapplet/config/KeycfgReader.h b/noncore/applets/keyhelper/keyhelperapplet/config/KeycfgReader.h
new file mode 100644
index 0000000..8624a01
--- a/dev/null
+++ b/noncore/applets/keyhelper/keyhelperapplet/config/KeycfgReader.h
@@ -0,0 +1,46 @@
+#ifndef _KEYCFG_READER_H_
+#define _KEYCFG_READER_H_
+
+#include <stdlib.h>
+#include <qxml.h>
+#include <qstring.h>
+#include <qdir.h>
+#include "KeycfgHandler.h"
+#include "KeycfgErrorHandler.h"
+#include "KeyNames.h"
+#include "ConfigEx.h"
+
+class KeycfgReader
+{
+public:
+	KeycfgReader();
+	~KeycfgReader();
+
+	bool load();
+	bool load(const QString& path);
+
+	inline void setKeyModifiers(KeyModifiers* mod)
+	{
+		m_pModifiers = mod;
+	}
+	inline void setKeyMappings(KeyMappings* map)
+	{
+		m_pMappings = map;
+	}
+	inline void setKeyExtensions(KeyExtensions* ext)
+	{
+		m_pExtensions = ext;
+	}
+	inline void setKeyRepeater(KeyRepeater* rep)
+	{
+		m_pRepeater = rep;
+	}
+
+private:
+	KeyModifiers* m_pModifiers;
+	KeyMappings* m_pMappings;
+	KeyExtensions* m_pExtensions;
+	KeyRepeater* m_pRepeater;
+};
+
+#endif /* _KEYCFG_READER_H_ */
diff --git a/noncore/applets/keyhelper/keyhelperapplet/config/MappingsHandler.cpp b/noncore/applets/keyhelper/keyhelperapplet/config/MappingsHandler.cpp
new file mode 100644
index 0000000..3680fbf
--- a/dev/null
+++ b/noncore/applets/keyhelper/keyhelperapplet/config/MappingsHandler.cpp
@@ -0,0 +1,102 @@
+#include "MappingsHandler.h"
+
+void MappingsHandler::dispose(QXmlReader* parser, QXmlContentHandler* parent)
+{
+	m_parser = parser;
+	m_parent = parent;
+	m_parser->setContentHandler(this);
+}
+
+bool MappingsHandler::startElement(const QString& /* namespaceURI */,
+	const QString& localName,
+	const QString& /* qName */,
+	const QXmlAttributes& attr)
+{
+	if(localName == "define"){
+		/* ÊÑ¿ô½é´ü²½ */
+		m_code = 0;
+		m_mask = 0;
+		m_mapcode = 0;
+		m_unicode = 0;
+		m_mapmodifiers.clear();
+		m_mapunicodes.clear();
+		for(int i=0; i<attr.length(); i++){
+			if(attr.localName(i).lower() == "key"){
+				/* keyname */
+				m_code = KeyNames::getCode(attr.value(i));
+			} else if(attr.localName(i).lower() == "code"){
+				/* keycode */
+				m_code = KHUtil::hex2int(attr.value(i).lower());
+			}
+		}
+	} else if(localName == "modifier"){
+		/* modifier keys */
+		for(int i=0; i<attr.length(); i++){
+			if(attr.value(i).lower() == "on"){
+				m_mask |= m_pModifiers->getMask(attr.localName(i));
+			}
+		}
+	} else if(localName == "map"){
+		/* mapping key */
+		for(int i=0; i<attr.length(); i++){
+			if(attr.localName(i).lower() == "key"){
+				/* keyname */
+				m_mapcode = KeyNames::getCode(attr.value(i));
+			} else if(attr.localName(i).lower() == "code"){
+				/* keycode */
+				m_mapcode = KHUtil::hex2int(attr.value(i).lower());
+			}
+		}
+	} else if(localName == "map_modifier"){
+		/* mapping modifiers */
+		for(int i=0; i<attr.length(); i++){
+			m_mapmodifiers[attr.localName(i)] = attr.value(i);
+		}
+	} else if(localName == "map_unicode"){
+		/* mapping unicodes */
+		for(int i=0; i<attr.length(); i++){
+			if(attr.localName(i).lower() == "char"){
+				/* unicode char */
+				m_unicode = attr.value(i)[0].unicode();
+			} else if(attr.localName(i).lower() == "code"){
+				/* unicode code */
+				m_unicode = KHUtil::hex2int(attr.value(i).lower());
+			} else {
+				m_mapunicodes[attr.localName(i)] = attr.value(i);
+			}
+		}
+	}
+	return(true);
+}
+
+bool MappingsHandler::endElement(const QString& /* namespaceURI */,
+	const QString& localName,
+	const QString& /* qName */)
+{
+	if(localName == "define"){
+		if(m_code > 0){
+			/* assign mapping */
+			m_pMappings->assign(m_code, m_mask, m_mapcode);
+
+			for(QMap<QString,QString>::Iterator it=m_mapmodifiers.begin();
+					it!=m_mapmodifiers.end(); ++it){
+				/* assign mapping modifier state */
+				m_pMappings->assignModifier(it.key(), it.data());
+			}
+
+			if(m_unicode > 0){
+				m_pMappings->assignUnicode(m_unicode);
+			} else {
+				for(QMap<QString,QString>::Iterator it=m_mapunicodes.begin();
+						it!=m_mapunicodes.end(); ++it){
+					/* assign mapping unicode */
+					m_pMappings->assignUnicode(it.key(), it.data());
+				}
+			}
+		}
+	} else if(localName == "mappings"){
+		/* return parent */
+		m_parser->setContentHandler(m_parent);
+	}
+	return(true);
+}
diff --git a/noncore/applets/keyhelper/keyhelperapplet/config/MappingsHandler.h b/noncore/applets/keyhelper/keyhelperapplet/config/MappingsHandler.h
new file mode 100644
index 0000000..d899ea2
--- a/dev/null
+++ b/noncore/applets/keyhelper/keyhelperapplet/config/MappingsHandler.h
@@ -0,0 +1,48 @@
+#ifndef _MAPPINGS_HANDLER_H_
+#define _MAPPINGS_HANDLER_H_
+
+#include <qxml.h>
+#include <qstring.h>
+#include <qmap.h>
+#include "KeyModifiers.h"
+#include "KeyMappings.h"
+#include "KeyNames.h"
+#include "KHUtil.h"
+
+class MappingsHandler : public QXmlDefaultHandler
+{
+public:
+	void dispose(QXmlReader* parser, QXmlContentHandler* parent);
+	
+	void setKeyModifiers(KeyModifiers* mod)
+	{
+		m_pModifiers = mod;
+	}
+	void setKeyMappings(KeyMappings* map)
+	{
+		m_pMappings = map;
+	}
+
+	bool startElement(const QString& namespaceURI,
+		const QString& localName,
+		const QString& qName,
+		const QXmlAttributes& atts);
+	bool endElement(const QString& namespaceURI,
+		const QString& localName,
+		const QString& qName);
+private:
+	QXmlContentHandler* m_parent;
+	QXmlReader* m_parser;
+
+	KeyModifiers* m_pModifiers;
+	KeyMappings* m_pMappings;
+
+	int m_code;
+	int m_mask;
+	int m_mapcode;
+	int m_unicode;
+	QMap<QString,QString> m_mapmodifiers;
+	QMap<QString,QString> m_mapunicodes;
+};
+
+#endif /* _MAPPINGS_HANDLER_H_ */
diff --git a/noncore/applets/keyhelper/keyhelperapplet/config/ModifiersHandler.cpp b/noncore/applets/keyhelper/keyhelperapplet/config/ModifiersHandler.cpp
new file mode 100644
index 0000000..b2cde92
--- a/dev/null
+++ b/noncore/applets/keyhelper/keyhelperapplet/config/ModifiersHandler.cpp
@@ -0,0 +1,99 @@
+#include "ModifiersHandler.h"
+
+void ModifiersHandler::dispose(QXmlReader* parser, QXmlContentHandler* parent)
+{
+	m_parser = parser;
+	m_parent = parent;
+	m_parser->setContentHandler(this);
+}
+
+bool ModifiersHandler::startElement(const QString& /* namespaceURI */,
+	const QString& localName,
+	const QString& /* qName */,
+	const QXmlAttributes& attr)
+{
+	if(localName == "define"){
+		/* ÊÑ¿ô½é´ü²½ */
+		m_type = QString::null;
+		m_code = 0;
+		m_mask = 0;
+		m_release.clear();
+		m_toggle = false;
+		m_mapping = false;
+		for(int i=0; i<attr.length(); i++){
+			if(attr.localName(i).lower() == "key"){
+				/* keyname */
+				m_code = KeyNames::getCode(attr.value(i));
+			} else if(attr.localName(i).lower() == "code"){
+				/* keycode */
+				m_code = KHUtil::hex2int(attr.value(i).lower());
+			} else if(attr.localName(i).lower() == "type"){
+				/* modifier type */
+				m_type = attr.value(i);
+			} else if(attr.localName(i).lower() == "mapping"){
+				/* auto mapping */
+				if(attr.value(i).lower() == "true"){
+					m_mapping = true;
+				}
+			} else if(attr.localName(i).lower() == "toggle"){
+				/* toggle mode */
+				if(attr.value(i).lower() == "true"){
+					m_toggle = true;
+				}
+			}
+		}
+	} else if(localName == "modifier"){
+		/* modifier keys */
+		for(int i=0; i<attr.length(); i++){
+			if(attr.value(i).lower() == "on"){
+				m_mask |= m_pModifiers->getMask(attr.localName(i));
+			}
+		}
+	} else if(localName == "release"){
+		/* release keys */
+		int code = 0;
+		for(int i=0; i<attr.length(); i++){
+			if(attr.localName(i) == "key"){
+				/* keyname */
+				code = KeyNames::getCode(attr.value(i));
+			} else if(attr.localName(i) == "code"){
+				/* keycode */
+				code = KHUtil::hex2int(attr.value(i).lower());
+			}
+		}
+		if(code > 0){
+			m_release.append(code);
+		}
+	}
+	return(true);
+}
+
+bool ModifiersHandler::endElement(const QString& /* namespaceURI */,
+	const QString& localName,
+	const QString& /* qName */)
+{
+	if(localName == "define"){
+		if(m_type != QString::null && m_code > 0){
+			/* assign modifier */
+			m_pModifiers->assign(m_type, m_code, m_mask, m_toggle);
+			for(QValueList<int>::Iterator it=m_release.begin();
+					it!=m_release.end(); ++it){
+				/* assign modifier release keys */
+				m_pModifiers->assignRelease(*it);
+			}
+			int code = KeyNames::getCode(m_type);
+			if(code <= 0){
+				qDebug("setCode[%s][%x]", m_type.latin1(), m_code);
+				KeyNames::setCode(m_type, m_code);
+			}
+			if(m_mapping){
+				/* auto mapping */
+				m_pMappings->assign(m_code, m_mask, code, 0);
+			}
+		}
+	} else if(localName == "modifiers"){
+		/* return parent */
+		m_parser->setContentHandler(m_parent);
+	}
+	return(true);
+}
diff --git a/noncore/applets/keyhelper/keyhelperapplet/config/ModifiersHandler.h b/noncore/applets/keyhelper/keyhelperapplet/config/ModifiersHandler.h
new file mode 100644
index 0000000..e2d8785
--- a/dev/null
+++ b/noncore/applets/keyhelper/keyhelperapplet/config/ModifiersHandler.h
@@ -0,0 +1,48 @@
+#ifndef _MODIFIERS_HANDLER_H_
+#define _MODIFIERS_HANDLER_H_
+
+#include <qstring.h>
+#include <qvaluelist.h>
+#include <qxml.h>
+#include "KeyModifiers.h"
+#include "KeyMappings.h"
+#include "KeyNames.h"
+#include "KHUtil.h"
+
+class ModifiersHandler : public QXmlDefaultHandler
+{
+public:
+	void dispose(QXmlReader* parser, QXmlContentHandler* parent);
+
+	void setKeyModifiers(KeyModifiers* mod)
+	{
+		m_pModifiers = mod;
+	}
+	void setKeyMappings(KeyMappings* map)
+	{
+		m_pMappings = map;
+	}
+
+	bool startElement(const QString& namespaceURI,
+		const QString& localName,
+		const QString& qName,
+		const QXmlAttributes& atts);
+	bool endElement(const QString& namespaceURI,
+		const QString& localName,
+		const QString& qName);
+private:
+	QXmlContentHandler* m_parent;
+	QXmlReader* m_parser;
+
+	KeyModifiers* m_pModifiers;
+	KeyMappings* m_pMappings;
+
+	QString m_type;
+	int m_code;
+	int m_mask;
+	QValueList<int> m_release;
+	bool m_mapping;
+	bool m_toggle;
+};
+
+#endif /* _MODIFIERS_HANDLER_H_ */
diff --git a/noncore/applets/keyhelper/keyhelperapplet/config/RepeaterHandler.cpp b/noncore/applets/keyhelper/keyhelperapplet/config/RepeaterHandler.cpp
new file mode 100644
index 0000000..aeae761
--- a/dev/null
+++ b/noncore/applets/keyhelper/keyhelperapplet/config/RepeaterHandler.cpp
@@ -0,0 +1,76 @@
+#include "RepeaterHandler.h"
+
+void RepeaterHandler::dispose(QXmlReader* parser, QXmlContentHandler* parent)
+{
+	m_parser = parser;
+	m_parent = parent;
+	m_parser->setContentHandler(this);
+}
+
+bool RepeaterHandler::startElement(const QString& /* namespaceURI */,
+	const QString& localName,
+	const QString& /* qName */,
+	const QXmlAttributes& attr)
+{
+	if(localName == "repeat"){
+		for(int i=0; i<attr.length(); i++){
+			if(attr.localName(i).lower() == "delay"){
+				bool ok;
+				int delay = attr.value(i).toInt(&ok);
+				if(ok){
+					m_pRepeater->setDelay(delay);
+				}
+			} else if(attr.localName(i).lower() == "period"){
+				bool ok;
+				int period = attr.value(i).toInt(&ok);
+				if(ok){
+					m_pRepeater->setPeriod(period);
+				}
+			} else if(attr.localName(i).lower() == "mode"){
+				/* default mode */
+				bool ok;
+				int mode = attr.value(i).toInt(&ok);
+				if(ok){
+					m_pRepeater->setMode(mode);
+				}
+			}
+		}
+	} else if(localName == "define"){
+		/* ÊÑ¿ô½é´ü²½ */
+		m_code = 0;
+		m_enable = true;
+		for(int i=0; i<attr.length(); i++){
+			if(attr.localName(i).lower() == "key"){
+				/* keyname */
+				m_code = KeyNames::getCode(attr.value(i));
+			} else if(attr.localName(i).lower() == "code"){
+				/* keycode */
+				m_code = KHUtil::hex2int(attr.value(i).lower());
+			} else if(attr.localName(i).lower() == "enable"){
+				/* enable/disable */
+				if(attr.value(i).lower() == "false"){
+					m_enable = false;
+				} else {
+					m_enable = true;
+				}
+			}
+		}
+	}
+	return(true);
+}
+
+bool RepeaterHandler::endElement(const QString& /* namespaceURI */,
+	const QString& localName,
+	const QString& /* qName */)
+{
+	if(localName == "define"){
+		if(m_code > 0){
+			/* set repeat enable/disable */
+			m_pRepeater->setRepeatable(m_code, m_enable);
+		}
+	} else if(localName == "repeater"){
+		/* return parent */
+		m_parser->setContentHandler(m_parent);
+	}
+	return(true);
+}
diff --git a/noncore/applets/keyhelper/keyhelperapplet/config/RepeaterHandler.h b/noncore/applets/keyhelper/keyhelperapplet/config/RepeaterHandler.h
new file mode 100644
index 0000000..d25583b
--- a/dev/null
+++ b/noncore/applets/keyhelper/keyhelperapplet/config/RepeaterHandler.h
@@ -0,0 +1,39 @@
+#ifndef _REPEATER_HANDLER_H_
+#define _REPEATER_HANDLER_H_
+
+#include <qstring.h>
+#include <qvaluelist.h>
+#include <qxml.h>
+#include "KeyRepeater.h"
+#include "KeyNames.h"
+#include "KHUtil.h"
+
+class RepeaterHandler : public QXmlDefaultHandler
+{
+public:
+	void dispose(QXmlReader* parser, QXmlContentHandler* parent);
+
+	void setKeyRepeater(KeyRepeater* rep)
+	{
+		m_pRepeater = rep;
+	}
+
+	bool startElement(const QString& namespaceURI,
+		const QString& localName,
+		const QString& qName,
+		const QXmlAttributes& atts);
+	bool endElement(const QString& namespaceURI,
+		const QString& localName,
+		const QString& qName);
+private:
+	QXmlContentHandler* m_parent;
+	QXmlReader* m_parser;
+
+	KeyRepeater* m_pRepeater;
+
+	int m_code;
+	bool m_enable;
+
+};
+
+#endif /* _REPEATER_HANDLER_H_ */
diff --git a/noncore/applets/keyhelper/keyhelperapplet/extension/ExtensionFactory.cpp b/noncore/applets/keyhelper/keyhelperapplet/extension/ExtensionFactory.cpp
new file mode 100644
index 0000000..00a43d1
--- a/dev/null
+++ b/noncore/applets/keyhelper/keyhelperapplet/extension/ExtensionFactory.cpp
@@ -0,0 +1,110 @@
+#include "ExtensionFactory.h"
+
+ExtensionFactory::ExtensionFactory()
+{
+	qDebug("ExtensionFactory::ExtensionFactory()");
+	m_pLoadList = NULL;
+}
+
+ExtensionFactory::~ExtensionFactory()
+{
+	qDebug("ExtensionFactory::~ExtensionFactory()");
+}
+
+ExtensionInterface* ExtensionFactory::createInstance(const QString& kind)
+{
+	ExtensionInterface* ext;
+	QString kindstr = kind.lower();
+
+	if(kindstr == "switch"){
+		ext = new TaskSwitcher(kindstr);
+	} else if(kindstr == "select"){
+		ext = new TaskSelector(kindstr);
+	} else if(kindstr.find("launch") == 0){
+		ext = new KeyLauncher(kindstr);
+	} else if(kindstr.find("menu") == 0){
+		ext = new MenuLauncher(kindstr);
+	} else {
+		return(NULL);
+	}
+	m_oExtList.append(ext);
+	return(ext);
+}
+
+ExtensionInterface* ExtensionFactory::createInstance(const QString& kind,
+	int keycode, int keymask)
+{
+	ExtensionInterface* ext;
+	QString kindstr = kind.lower();
+
+	ext = loadInstance(kindstr, keycode, keymask);
+	if(ext != NULL){
+		return(ext);
+	}
+
+	if(kindstr == "switch"){
+		ext = new TaskSwitcher(kindstr);
+	} else if(kindstr == "select"){
+		ext = new TaskSelector(kindstr);
+	} else if(kindstr.find("launch") == 0){
+		ext = new KeyLauncher(kindstr);
+	} else if(kindstr.find("menu") == 0){
+		ext = new MenuLauncher(kindstr);
+	} else {
+		return(NULL);
+	}
+	ext->setKeycode(keycode);
+	ext->setKeymask(keymask);
+
+	m_oExtList.append(ext);
+	return(ext);
+}
+
+ExtensionInterface* ExtensionFactory::loadInstance(const QString& kindstr,
+	int keycode, int keymask)
+{
+	if(m_pLoadList == NULL){
+		return(NULL);
+	}
+
+	for(ExtensionList::Iterator it=m_pLoadList->begin();
+			it!=m_pLoadList->end(); ++it){
+		if((*it)->kind() == kindstr
+			&& (*it)->getKeycode() == keycode
+			&& (*it)->getKeymask() == keymask){
+			m_oExtList.append(*it);
+			return(*it);
+		}
+	}
+	return(NULL);
+}
+
+void ExtensionFactory::clear()
+{
+	for(ExtensionList::Iterator it=m_oExtList.begin();
+			it!=m_oExtList.end(); ++it){
+		delete *it;
+	}
+	m_oExtList.clear();
+}
+
+void ExtensionFactory::reset()
+{
+	m_pLoadList = new ExtensionList(m_oExtList);
+	m_oExtList.clear();
+}
+
+void ExtensionFactory::sweep()
+{
+	if(m_pLoadList == NULL){
+		return;
+	}
+	for(ExtensionList::Iterator it=m_pLoadList->begin();
+			it!=m_pLoadList->end(); ++it){
+		if(m_oExtList.contains(*it) == false){
+			delete *it;
+		}
+	}
+	delete m_pLoadList;
+	m_pLoadList = NULL;
+}
diff --git a/noncore/applets/keyhelper/keyhelperapplet/extension/ExtensionFactory.h b/noncore/applets/keyhelper/keyhelperapplet/extension/ExtensionFactory.h
new file mode 100644
index 0000000..7fa6a5f
--- a/dev/null
+++ b/noncore/applets/keyhelper/keyhelperapplet/extension/ExtensionFactory.h
@@ -0,0 +1,35 @@
+#ifndef _EXTENSION_FACTORY_H_
+#define _EXTENSION_FACTORY_H_
+
+#include "ExtensionInterface.h"
+#include "TaskSwitcher.h"
+#include "KeyLauncher.h"
+#include "TaskSelector.h"
+#include "MenuLauncher.h"
+
+class ExtensionFactory
+{
+public:
+	ExtensionFactory();
+	virtual ~ExtensionFactory();
+
+	ExtensionInterface* createInstance(const QString& kind);
+	ExtensionInterface* createInstance(const QString& kind,
+		int keycode, int keymask);
+	ExtensionList& getList()
+	{
+		return(m_oExtList);
+	}
+	void clear();
+	void reset();
+	void sweep();
+private:
+	ExtensionList m_oExtList;
+	ExtensionList* m_pLoadList;
+
+	ExtensionInterface* loadInstance(const QString& kind,
+		int keycode, int keymask);
+};
+
+#endif /* _EXTENSION_FACTORY_H_ */
+
diff --git a/noncore/applets/keyhelper/keyhelperapplet/extension/ExtensionInterface.h b/noncore/applets/keyhelper/keyhelperapplet/extension/ExtensionInterface.h
new file mode 100644
index 0000000..1a81141
--- a/dev/null
+++ b/noncore/applets/keyhelper/keyhelperapplet/extension/ExtensionInterface.h
@@ -0,0 +1,26 @@
+#ifndef _EXTENSION_INTERFACE_H_
+#define _EXTENSION_INTERFACE_H_
+
+#include <qvaluelist.h>
+
+class ExtensionInterface
+{
+public:
+	//ExtensionInterface();
+	virtual ~ExtensionInterface(){}
+	virtual bool onKeyPress(int keycode) = 0;
+	virtual bool onModRelease(int modcode) = 0;
+	virtual int getKeycode() = 0;
+	virtual int getKeymask() = 0;
+	virtual const QValueList<int>& getModcodes() = 0;
+	virtual void setKeycode(int keycode) = 0;
+	virtual void setKeymask(int keymask) = 0;
+	virtual void setModcodes(const QValueList<int>& modcodes) = 0;
+	virtual const QString& kind() = 0;
+private:
+};
+
+typedef QValueList<ExtensionInterface*> ExtensionList;
+
+#endif /* _EXTENSION_INTERFACE_H_ */
+
diff --git a/noncore/applets/keyhelper/keyhelperapplet/extension/KeyExtensions.cpp b/noncore/applets/keyhelper/keyhelperapplet/extension/KeyExtensions.cpp
new file mode 100644
index 0000000..a61ea0a
--- a/dev/null
+++ b/noncore/applets/keyhelper/keyhelperapplet/extension/KeyExtensions.cpp
@@ -0,0 +1,111 @@
+#include "KeyExtensions.h"
+
+KeyExtensions::KeyExtensions()
+{
+	qDebug("KeyExtensions::KeyExtensions()");
+	m_cancelcode = 0;
+}
+
+KeyExtensions::~KeyExtensions()
+{
+	qDebug("KeyExtensions::~KeyExtensions()");
+	clear();
+}
+
+void KeyExtensions::assign(const QString& kind, int keycode,
+	int keymask, const QValueList<int>& modcodes)
+{
+	ExtensionInterface* ext;
+#if 0
+	ext = m_oExtFactory.createInstance(kind);
+	if(ext != NULL){
+		ext->setKeycode(keycode);
+		ext->setKeymask(keymask);
+		ext->setModcodes(modcodes);
+	}
+#else
+	ext = m_oExtFactory.createInstance(kind, keycode, keymask);
+	if(ext != NULL){
+		ext->setModcodes(modcodes);
+	}
+#endif
+}
+
+void KeyExtensions::assign(const QString& kind, int keycode,
+	int keymask, int modcode)
+{
+	QValueList<int> modcodes;
+	modcodes.append(modcode);
+	assign(kind, keycode, keymask, modcodes);
+}
+
+bool KeyExtensions::doKey(int keycode, int keymask, bool isPress)
+{
+	bool fCancel = false;
+	ExtensionList& list = m_oExtFactory.getList();
+	for(ExtensionList::Iterator it=list.begin();
+			it!=list.end(); ++it){
+		if(isPress){
+			int code = (*it)->getKeycode();
+			if((*it)->getKeymask() == keymask
+				&& (code == 0 || code == keycode)){
+				if((*it)->onKeyPress(keycode)){
+					fCancel = true;
+				}
+				qWarning("ext:onKeyPress[%s][%x][%d]",
+					(*it)->kind().latin1(),
+					(*it)->getKeycode(),
+					fCancel);
+			}
+		} else {
+			if(keycode == m_cancelcode){
+				fCancel = true;
+			}
+			const QValueList<int>& rlist = (*it)->getModcodes();
+			if(rlist.contains(keycode)){
+				if((*it)->onModRelease(keycode)){
+					m_pModifiers->resetToggles();
+				}
+				qWarning("ext:onModRelease[%s][%x]",
+					(*it)->kind().latin1(),
+					keycode);
+			}
+		}
+	}
+	if(isPress && fCancel){
+		m_cancelcode = keycode;
+	} else {
+		m_cancelcode = 0;
+	}
+	return(fCancel);
+}
+
+void KeyExtensions::clear()
+{
+	m_oExtFactory.clear();
+}
+
+void KeyExtensions::reset()
+{
+	//clear();
+	m_oExtFactory.reset();
+}
+
+void KeyExtensions::init()
+{
+	m_oExtFactory.sweep();
+}
+
+void KeyExtensions::statistics()
+{
+	qWarning("KeyExtensions::statistics()");
+	ExtensionList& list = m_oExtFactory.getList();
+	for(ExtensionList::Iterator it=list.begin();
+			it!=list.end(); ++it){
+		qWarning(" [%s][%x][%x]",
+			(*it)->kind().latin1(),
+			(*it)->getKeycode(),
+			(*it)->getKeymask());
+	}
+}
+
diff --git a/noncore/applets/keyhelper/keyhelperapplet/extension/KeyExtensions.h b/noncore/applets/keyhelper/keyhelperapplet/extension/KeyExtensions.h
new file mode 100644
index 0000000..20ffc45
--- a/dev/null
+++ b/noncore/applets/keyhelper/keyhelperapplet/extension/KeyExtensions.h
@@ -0,0 +1,40 @@
+#ifndef _KEY_EXTENSIONS_H_
+#define _KEY_EXTENSIONS_H_
+
+#include <qstring.h>
+#include <qstringlist.h>
+#include "KeyNames.h"
+#include "KeyModifiers.h"
+#include "ExtensionFactory.h"
+
+class KeyExtensions
+{
+public:
+	KeyExtensions();
+	~KeyExtensions();
+
+	void setKeyModifiers(KeyModifiers* mod)
+	{
+		m_pModifiers = mod;
+	}
+
+	void assign(const QString& kind, int keycode,
+		int keymask, const QValueList<int>& modcodes);
+	void assign(const QString& kind, int keycode,
+		int keymask, int modcode);
+	bool doKey(int keycode, int keymask, bool isPress);
+
+	void statistics();
+
+	void reset();
+	void init();
+private:
+	KeyModifiers* m_pModifiers;
+	ExtensionFactory m_oExtFactory;
+	int m_cancelcode;
+
+	void clear();
+};
+
+#endif /* _KEY_EXTENSIONS_H_ */
+
diff --git a/noncore/applets/keyhelper/keyhelperapplet/extension/KeyLauncher.cpp b/noncore/applets/keyhelper/keyhelperapplet/extension/KeyLauncher.cpp
new file mode 100644
index 0000000..7a0b88c
--- a/dev/null
+++ b/noncore/applets/keyhelper/keyhelperapplet/extension/KeyLauncher.cpp
@@ -0,0 +1,57 @@
+#include "KeyLauncher.h"
+#include "KHUtil.h"
+
+KeyLauncher::KeyLauncher(const QString& kind) : m_kind(kind)
+{
+	qDebug("KeyLauncher::KeyLauncher()");
+}
+
+KeyLauncher::~KeyLauncher()
+{
+	qDebug("KeyLauncher::~KeyLauncher()");
+}
+
+bool KeyLauncher::onKeyPress(int keycode)
+{
+	QString key;
+	QStringList args;
+	ConfigEx& cfg = ConfigEx::getInstance("keyhelper");
+
+	key = KeyNames::getName(keycode);
+	if(key == QString::null){
+		return(false);
+	}
+
+	QString group = kind();
+	group[0] = group[0].upper();
+
+	/* read application launcher */
+	QString app = KHUtil::currentApp();
+	if(!app.isEmpty()){
+		cfg.setGroup(group + "_" + app);
+		/* read config */
+		args = cfg.readListEntry(key, '\t');
+	}
+
+	/* read default launcher */
+	if(args.isEmpty()){
+		cfg.setGroup(group);
+
+		/* read config */
+		args = cfg.readListEntry(key, '\t');
+	}
+
+	if(args.isEmpty()){
+		return(false);
+	}
+
+	/* launch application */
+	LnkWrapper lnk(args);
+	if(lnk.isValid()){
+		//args.remove(args.begin());
+		lnk.instance().execute();
+	}
+
+	return(true);
+}
+
diff --git a/noncore/applets/keyhelper/keyhelperapplet/extension/KeyLauncher.h b/noncore/applets/keyhelper/keyhelperapplet/extension/KeyLauncher.h
new file mode 100644
index 0000000..fbad3da
--- a/dev/null
+++ b/noncore/applets/keyhelper/keyhelperapplet/extension/KeyLauncher.h
@@ -0,0 +1,63 @@
+#ifndef _KEY_LAUNCHER_H_
+#define _KEY_LAUNCHER_H_
+
+#include <qstring.h>
+#include <qstringlist.h>
+#include <qvaluelist.h>
+
+#include <qpe/qpeapplication.h>
+#include <qpe/config.h>
+#include <qpe/applnk.h>
+#include <qpe/global.h>
+#include <qpe/qcopenvelope_qws.h>
+
+#include "ExtensionInterface.h"
+#include "KeyNames.h"
+#include "LnkWrapper.h"
+#include "ConfigEx.h"
+
+class KeyLauncher : public ExtensionInterface
+{
+public:
+	KeyLauncher(const QString& kind = "launch");
+	virtual ~KeyLauncher();
+
+	virtual bool onKeyPress(int keycode);
+	virtual bool onModRelease(int /*modcode*/){return(false);}
+	virtual int getKeycode()
+	{
+		return(m_keycode);
+	}
+	virtual int getKeymask()
+	{
+		return(m_keymask);
+	}
+	virtual const QValueList<int>& getModcodes()
+	{
+		return(m_modcodes);
+	}
+	virtual void setKeycode(int keycode)
+	{
+		m_keycode = keycode;
+	}
+	virtual void setKeymask(int keymask)
+	{
+		m_keymask = keymask;
+	}
+	virtual void setModcodes(const QValueList<int>& modcodes)
+	{
+		m_modcodes = modcodes;
+	}
+	virtual const QString& kind()
+	{
+		return(m_kind);
+	}
+private:
+	int m_keycode;
+	int m_keymask;
+	QString m_kind;
+	QValueList<int> m_modcodes;
+};
+
+#endif /* _KEY_LAUNCHER_H_ */
+
diff --git a/noncore/applets/keyhelper/keyhelperapplet/extension/MenuLauncher.cpp b/noncore/applets/keyhelper/keyhelperapplet/extension/MenuLauncher.cpp
new file mode 100644
index 0000000..0595a3e
--- a/dev/null
+++ b/noncore/applets/keyhelper/keyhelperapplet/extension/MenuLauncher.cpp
@@ -0,0 +1,324 @@
+#include "MenuLauncher.h" 
+extern QWidget* g_Widget;
+
+MenuLauncher::MenuLauncher(const QString& kind) : m_kind(kind)
+{
+	qDebug("MenuLauncher::MenuLauncher()");
+	m_pMenu = m_pTopMenu = NULL;
+	
+	m_isShowing = false;
+	m_id = -1;
+
+	m_pTimer = new QTimer(this);
+	connect(m_pTimer, SIGNAL(timeout()),
+		this, SLOT(select()));
+
+	init();
+}
+
+MenuLauncher::~MenuLauncher()
+{
+	qDebug("MenuLauncher::~MenuLauncher()");
+	delete m_pTopMenu;
+	delete m_pTimer;
+}
+
+void MenuLauncher::init()
+{
+	buildMenu();
+}
+
+QPopupMenu* MenuLauncher::initMenu(QWidget* parent, const QString& name)
+{
+	QPopupMenu* pMenu;
+	pMenu = new QPopupMenuEx(parent, name);
+	pMenu->installEventFilter(this);
+	connect(pMenu, SIGNAL(activated(int)), this, SLOT(select(int)));
+	connect(pMenu, SIGNAL(highlighted(int)), this, SLOT(highlight(int)));
+	//connect(pMenu, SIGNAL(aboutToHide()), this, SLOT(execute()));
+	return(pMenu);
+}
+
+bool MenuLauncher::onKeyPress(int /*keycode*/)
+{
+	if(m_isShowing){
+		qDebug("showing ...");
+	} else if(m_pMenu->isVisible()){
+		next();
+	} else {
+		ConfigEx& cfg = ConfigEx::getInstance("keyhelper");
+		cfg.setGroup("Global");
+		int delay = cfg.readNumEntry("DelayPopup", 5);
+		QTimer::singleShot(delay, this, SLOT(show()));
+		m_isShowing = true;
+	}
+	return true;
+}
+
+bool MenuLauncher::onModRelease(int /*modcode*/)
+{
+	if(m_pMenu->isVisible()){
+		QTimer::singleShot(0, this, SLOT(select()));
+		return(true);
+	} else {
+		return(false);
+	}
+}
+
+QString MenuLauncher::getMenuText(const QString& key, const QString& name)
+{
+	QRegExp rx("^[0-9]+_");
+	QString text;
+	QString ackey;
+	int len;
+	if(rx.match(key, 0, &len) == 0){
+		ackey = key.mid(len);
+	} else {
+		ackey = key;
+	}
+	if(ackey.length() == 1){
+		text = name;
+		text.append("(&");
+		text.append(ackey);
+		text.append(")");
+	} else {
+		text = ackey;
+	}
+	return(text);
+}
+
+int MenuLauncher::buildMenu(const QString& section,
+		QPopupMenu* pMenu, int& id)
+{
+	ConfigEx& cfg = ConfigEx::getInstance("keyhelper");
+
+	if(m_oMenuList.contains(pMenu)){
+		/* ̵¸Â¥ë¡¼¥×ËÉ»ß */
+		return(0);
+	}
+	m_oMenuList.append(pMenu);
+
+	QString oldgroup = cfg.getGroup();
+
+	QString group = section;
+	group[0] = group[0].upper();
+
+	cfg.setGroup(group);
+
+	QStringList apps = cfg.getKeys();
+	int cnt = 0;
+	if(apps.isEmpty() == false){
+		for(QStringList::Iterator it=apps.begin();
+				it!=apps.end(); ++it){
+			QStringList args = cfg.readListEntry(*it, '\t');
+			LnkWrapper lnk(args);
+			if(lnk.isValid()){
+				cnt++;
+				QString text = getMenuText(*it, lnk.instance().name());
+				if(args[0] == "@menu"){
+					QPopupMenu* pSubMenu = initMenu(m_pTopMenu, args[1]);
+					pMenu->insertItem(lnk.instance().pixmap(), text,
+						pSubMenu, id);
+					m_oItemList.append(ItemInfo(section));
+					id++;
+					buildMenu(args[1], pSubMenu, id);
+				} else {
+					pMenu->insertItem(lnk.instance().pixmap(), text, id);
+					m_oItemList.append(ItemInfo(section, *it));
+					id++;
+				}
+			}
+		}
+	}
+	cfg.setGroup(oldgroup);
+	return(cnt);
+}
+
+void MenuLauncher::clearSubMenu()
+{
+	for(QValueList<QPopupMenu*>::Iterator it=m_oMenuList.begin();
+			it!=m_oMenuList.end(); ++it){
+		if(*it != m_pTopMenu){
+			delete *it;
+		}
+	}
+	m_oMenuList.clear();
+	m_oItemList.clear();
+}
+
+int MenuLauncher::buildMenu(bool force)
+{
+	ConfigEx& cfg = ConfigEx::getInstance("keyhelper");
+	if(!force && m_lastmodify == cfg.lastRead()){
+		return(m_pTopMenu->count());
+	}
+	qDebug("buildMenu");
+
+	QString oldgroup = cfg.getGroup();
+
+	cfg.setGroup("Global");
+	m_submenuTimeout = cfg.readNumEntry("SubMenuTimeout", 500);
+
+	if(m_pTopMenu){
+		delete m_pTopMenu;
+	}
+	m_pMenu = m_pTopMenu = initMenu(g_Widget, kind());
+	m_oLastId.clear();
+	m_oMenuList.clear();
+	m_oItemList.clear();
+
+	MenuTitle* pTitle = new MenuTitle("MenuLauncher",
+		m_pTopMenu->font(), kind());
+	m_pTopMenu->insertItem(pTitle);
+
+	int id = 0;
+	int cnt = buildMenu(kind(), m_pTopMenu, id);
+	if(cnt > 0){
+		m_lastmodify = cfg.lastRead();
+	}
+
+	cfg.setGroup(oldgroup);
+	return(cnt);
+}
+
+void MenuLauncher::show()
+{
+	m_enablePopup = false;
+	int cnt = buildMenu();
+	if(cnt > 0){
+		m_pMenu = m_pTopMenu;
+		ConfigEx& cfg = ConfigEx::getInstance("keyhelper");
+		cfg.setGroup("Style");
+		int x,y;
+		QString key = "Position_" + kind();
+		if(cfg.hasKey(key)){
+			const QStringList& list = cfg.readListEntry(key, ',');
+			x = list[0].toInt();
+			y = list[1].toInt();
+		} else {
+			x = (qt_screen->width() - m_pTopMenu->sizeHint().width()) / 2;
+			y = (qt_screen->height() - m_pTopMenu->sizeHint().height()) / 2;
+		}
+		QPoint pos(x, y);
+		m_pTopMenu->popup(pos);
+		m_pTopMenu->setActiveItem(1);
+	}
+	m_isShowing = false;
+}
+
+void MenuLauncher::next()
+{
+	int index = m_pMenu->indexOf(m_id);
+	index++;
+	if(index >= (signed int)m_pMenu->count()){
+		if(m_pMenu == m_pTopMenu){
+	 		index = 1;
+		} else {
+			index = 0;
+		}
+	}
+	m_pMenu->setActiveItem(index);
+	m_id = m_pMenu->idAt(index);
+}
+
+void MenuLauncher::select()
+{
+	if(m_pMenu->isVisible()){
+		QMenuItem* item = m_pMenu->findItem(m_id);
+		int index = m_pMenu->indexOf(m_id);
+		QPopupMenu* p = m_pMenu;
+		//m_pMenu->activateItemAt(index);
+		if(item && item->popup()){
+			m_pMenu = item->popup();
+		}
+		p->activateItemAt(index);
+	}
+}
+
+void MenuLauncher::select(int id)
+{
+	if(id >= 0 && m_oItemList[id].entry != QString::null){
+	  	ConfigEx& cfg = ConfigEx::getInstance("keyhelper");
+
+		cfg.setGroup("Global");
+		int delay = cfg.readNumEntry("DelayExec", 100);
+
+		QString group = m_oItemList[id].group;
+		group[0] = group[0].upper();
+		cfg.setGroup(group);
+
+		//QStringList args = cfg.readListEntry(m_oItemList[id].entry, '\t');
+		m_args = cfg.readListEntry(m_oItemList[id].entry, '\t');
+
+#if 0
+		LnkWrapper lnk(args);
+		if(lnk.isValid()){
+			lnk.instance().execute();
+		}
+#else
+		QTimer::singleShot(delay, this, SLOT(execute()));
+#endif
+	}
+	m_pMenu = m_pTopMenu;
+	m_id = -1;
+}
+
+void MenuLauncher::execute()
+{
+	LnkWrapper lnk(m_args);
+	if(lnk.isValid()){
+		lnk.instance().execute();
+	}
+	m_args.clear();
+}
+
+void MenuLauncher::highlight(int id)
+{
+	if(m_pMenu && m_pMenu->isVisible()){
+		m_id = id;
+		if(m_enablePopup){
+			QMenuItem* item = m_pMenu->findItem(m_id);
+			if(item && item->popup()){
+				if(m_submenuTimeout > 0){
+					m_pTimer->start(m_submenuTimeout, true);
+				}
+			} else {
+				m_pTimer->stop();
+			}
+		} else {
+			/* ¥á¥Ë¥å¡¼É½¼¨Ä¾¸å¤Ï¥Ý¥Ã¥×¥¢¥Ã¥×¤·¤Ê¤¤ */
+			m_enablePopup = true;
+		}
+	}
+}
+
+bool MenuLauncher::eventFilter(QObject* o, QEvent* e)
+{
+	if(m_pTopMenu->isVisible()){
+		QKeyEvent* ke = (QKeyEvent*)e;
+		switch(e->type()){
+		case QEvent::Accel:
+			if(ke->key() == Qt::Key_Space
+				&& ke->isAutoRepeat() == false){
+				select();
+			}
+			break;
+		case QEvent::FocusIn:
+			//qDebug("FocusIn[%p][%p]", o, m_pMenu);
+			m_pMenu = (QPopupMenu*)o;
+			if(m_oLastId.contains(o)){
+				m_id = m_oLastId[o];
+			}
+			m_pMenu->updateItem(m_id);
+			break;
+		case QEvent::FocusOut:
+			//qDebug("FocusOut[%p][%p]", o, m_pMenu);
+			m_oLastId[o] = m_id;
+			break;
+		default:
+			//qDebug(">>>>> [%p][%d] <<<<<", o, e->type());
+			break;
+		}
+	}
+	return QObject::eventFilter(o, e);
+}
diff --git a/noncore/applets/keyhelper/keyhelperapplet/extension/MenuLauncher.h b/noncore/applets/keyhelper/keyhelperapplet/extension/MenuLauncher.h
new file mode 100644
index 0000000..5eebe78
--- a/dev/null
+++ b/noncore/applets/keyhelper/keyhelperapplet/extension/MenuLauncher.h
@@ -0,0 +1,110 @@
+#ifndef _MENU_LAUNCHER_H_
+#define _MENU_LAUNCHER_H_
+
+#include <qstring.h>
+#include <qstringlist.h>
+#include <qvaluelist.h>
+#include <qwindowsystem_qws.h>
+#define INCLUDE_MENUITEM_DEF
+#include <qpopupmenu.h>
+#include <qpoint.h>
+#include <qtimer.h>
+#include <qgfx_qws.h>
+
+#include <qpe/global.h>
+#include <qpe/applnk.h>
+#include <qpe/config.h>
+#include <qpe/qpeapplication.h>
+
+#include "ExtensionInterface.h"
+#include "MenuTitle.h"
+#include "KeyNames.h"
+#include "ConfigEx.h"
+#include "LnkWrapper.h"
+#include "QPopupMenuEx.h"
+
+struct ItemInfo{
+	ItemInfo(QString g=QString::null, QString e=QString::null)
+		: group(g), entry(e){}
+	QString group;
+	QString entry;
+};
+
+class MenuLauncher : public QObject, public ExtensionInterface
+{
+	Q_OBJECT
+public:
+	MenuLauncher(const QString& kind = "menu");
+	virtual ~MenuLauncher();
+
+	typedef QValueList<ItemInfo> ItemList;
+
+	virtual bool onKeyPress(int keycode);
+	virtual bool onModRelease(int modcode);
+	virtual int getKeycode()
+	{
+		return(m_keycode);
+	}
+	virtual int getKeymask()
+	{
+		return(m_keymask);
+	}
+	virtual const QValueList<int>& getModcodes()
+	{
+		return(m_modcodes);
+	}
+	virtual void setKeycode(int keycode)
+	{
+		m_keycode = keycode;
+	}
+	virtual void setKeymask(int keymask)
+	{
+		m_keymask = keymask;
+	}
+	virtual void setModcodes(const QValueList<int>& modcodes)
+	{
+		m_modcodes = modcodes;
+	}
+	virtual const QString& kind()
+	{
+		return(m_kind);
+	}
+public slots:
+	void show();
+	void select();
+	void select(int id);
+	void highlight(int id);
+private:
+	int m_keycode;
+	int m_keymask;
+	QString m_kind;
+	QValueList<int> m_modcodes;
+
+	int m_submenuTimeout;
+	bool m_isShowing;
+	bool m_enablePopup;
+	int m_id;
+	QPopupMenu* m_pMenu;
+	QPopupMenu* m_pTopMenu;
+	QDateTime m_lastmodify;
+
+	QMap<QObject*, int> m_oLastId;
+	QValueList<QPopupMenu*> m_oMenuList;
+	ItemList m_oItemList;
+	QTimer* m_pTimer;
+
+	QStringList m_args;
+
+	QString getMenuText(const QString& key, const QString& name);
+	QPopupMenu* initMenu(QWidget* parent, const QString& name);
+	int buildMenu(bool force=false);
+	int buildMenu(const QString& section, QPopupMenu* pMenu, int& id);
+	void clearSubMenu();
+	void init();
+	void next();
+private slots:
+	bool eventFilter(QObject* o, QEvent* e);
+	void execute();
+};
+
+#endif /* _MENU_LAUNCHER_H_ */
diff --git a/noncore/applets/keyhelper/keyhelperapplet/extension/MenuTitle.cpp b/noncore/applets/keyhelper/keyhelperapplet/extension/MenuTitle.cpp
new file mode 100644
index 0000000..d8fd2a3
--- a/dev/null
+++ b/noncore/applets/keyhelper/keyhelperapplet/extension/MenuTitle.cpp
@@ -0,0 +1,67 @@
+#include "MenuTitle.h"
+
+MenuTitle::MenuTitle(const QString& s, const QFont& f, const QString& k)
+{
+	font = f;
+	kind = k;
+
+	ConfigEx& cfg = ConfigEx::getInstance("keyhelper");
+
+	const QString curGroup = cfg.getGroup();
+	cfg.setGroup("Style");
+
+	caption = cfg.readEntry("Caption_" + k, s);
+	cfg.setGroup(curGroup);
+}
+
+bool MenuTitle::fullSpan() const
+{
+	return(true);
+}
+
+bool MenuTitle::isSeparator() const
+{
+	return(true);
+}
+
+void MenuTitle::paint(QPainter* p, const QColorGroup& cg, bool /*act*/,
+		bool /*enabled*/, int x, int y, int w, int h)
+{
+	ConfigEx& cfg = ConfigEx::getInstance("keyhelper");
+	const QString& curGroup = cfg.getGroup();
+
+	cfg.setGroup("Style");
+
+	QString name;
+	QColor color;
+
+	p->setFont(font);
+
+	/* set fontcolor */
+	name = cfg.readEntry("FontColor_" + kind, QString::null);
+	if(name != QString::null){
+		color.setNamedColor(name);
+		if(color.isValid()){
+			p->setPen(color);
+		}
+	}
+
+	/* set bgcolor */
+	name = cfg.readEntry("BgColor_" + kind, QString::null);
+	if(name != QString::null){
+		color.setNamedColor(name);
+		if(color.isValid() == false){
+			color = cg.mid();
+		}
+	} else {
+		color = cg.mid();
+	}
+	p->fillRect(x, y, w, h, QBrush(color));
+	p->drawText(x, y, w, h, AlignCenter, caption);
+	cfg.setGroup(curGroup);
+}
+
+QSize MenuTitle::sizeHint()
+{
+	return(QFontMetrics(font).size(AlignCenter, caption));
+}
diff --git a/noncore/applets/keyhelper/keyhelperapplet/extension/MenuTitle.h b/noncore/applets/keyhelper/keyhelperapplet/extension/MenuTitle.h
new file mode 100644
index 0000000..77e46a5
--- a/dev/null
+++ b/noncore/applets/keyhelper/keyhelperapplet/extension/MenuTitle.h
@@ -0,0 +1,29 @@
+#ifndef _MENU_TITLE_ITEM_H_
+#define _MENU_TITLE_ITEM_H_
+
+#include <qmenudata.h>
+#include <qpainter.h>
+#include <qbrush.h>
+#include <qcolor.h>
+#include <qpalette.h>
+#include <qpe/config.h>
+#include "ConfigEx.h"
+
+class MenuTitle : public QCustomMenuItem
+{
+public:
+	MenuTitle(const QString& s, const QFont& f, const QString& k = "default");
+	virtual ~MenuTitle(){}
+
+	bool fullSpan () const;
+	bool isSeparator() const;
+	void paint(QPainter* p, const QColorGroup& cg, bool act,
+			bool enabled, int x, int y, int w, int h);
+	QSize sizeHint();
+private:
+	QString caption;
+	QString kind;
+	QFont font;
+};
+
+#endif /* _MENU_TITLE_ITEM_H_ */
diff --git a/noncore/applets/keyhelper/keyhelperapplet/extension/QPopupMenuEx.h b/noncore/applets/keyhelper/keyhelperapplet/extension/QPopupMenuEx.h
new file mode 100644
index 0000000..16e18a1
--- a/dev/null
+++ b/noncore/applets/keyhelper/keyhelperapplet/extension/QPopupMenuEx.h
@@ -0,0 +1,28 @@
+#ifndef _QPOPUPMENUEX_H_
+#define _QPOPUPMENUEX_H_
+
+#include <qpopupmenu.h>
+#include <qstring.h>
+#include <qevent.h>
+
+class QPopupMenuEx : public QPopupMenu
+{
+public:
+	QPopupMenuEx(QWidget* parent=0, const char* name=0)
+		: QPopupMenu(parent, name){}
+protected:
+	void keyPressEvent(QKeyEvent* e){
+		QChar c = e->text()[0];
+		QKeyEvent* ke = new QKeyEvent(
+			e->type(),
+			e->key(),
+			c.lower().latin1(),
+			0,
+			c.lower(),
+			e->isAutoRepeat());
+		QPopupMenu::keyPressEvent(ke);
+	}
+private:
+};
+
+#endif /* _QPOPUPMENUEX_H_ */
diff --git a/noncore/applets/keyhelper/keyhelperapplet/extension/TaskSelector.cpp b/noncore/applets/keyhelper/keyhelperapplet/extension/TaskSelector.cpp
new file mode 100644
index 0000000..4fc9cc4
--- a/dev/null
+++ b/noncore/applets/keyhelper/keyhelperapplet/extension/TaskSelector.cpp
@@ -0,0 +1,225 @@
+#include "TaskSelector.h" 
+extern QWidget* g_Widget;
+
+static const char* defkeys = 
+"QWERTYUIOPASDFGHJKLZXCVBNM1234567890";
+
+#define START_INDEX		1
+
+TaskSelector::TaskSelector(const QString& kind) : m_kind(kind)
+{
+	qDebug("TaskSelector::TaskSelector()");
+	m_pMenu = new QPopupMenuEx(g_Widget);
+	m_pMenu->installEventFilter(this);
+	
+	m_isShowing = false;
+	m_index = START_INDEX-1;
+	connect(m_pMenu, SIGNAL(activated(int)), this, SLOT(select(int)));
+	connect(m_pMenu, SIGNAL(highlighted(int)), this, SLOT(highlight(int)));
+}
+
+TaskSelector::~TaskSelector()
+{
+	qDebug("TaskSelector::~TaskSelector()");
+	delete m_pMenu;
+}
+
+bool TaskSelector::onKeyPress(int /*keycode*/)
+{
+	if(m_isShowing){
+		qDebug("showing ...");
+	} else if(m_pMenu->isVisible()){
+		next();
+	} else {
+		ConfigEx& cfg = ConfigEx::getInstance("keyhelper");
+		cfg.setGroup("Global");
+		int delay = cfg.readNumEntry("DelayPopup", 5);
+		QTimer::singleShot(delay, this, SLOT(show()));
+		m_isShowing = true;
+	}
+	return true;
+}
+
+bool TaskSelector::onModRelease(int /*modcode*/)
+{
+	if(m_pMenu->isVisible()){
+		//m_pMenu->hide();
+		QTimer::singleShot(0, this, SLOT(select()));
+		return(true);
+	} else {
+		return(false);
+	}
+}
+
+int TaskSelector::buildMenu()
+{
+	const AppLnk* lnk;
+
+	ConfigEx& cfg = ConfigEx::getInstance("keyhelper");
+	QString oldgroup;
+
+	oldgroup = cfg.getGroup();
+	cfg.setGroup("Global");
+	QString accesskeys = cfg.readEntry("AccessKeys", defkeys);
+	if(accesskeys.length() <= 0){
+		accesskeys = defkeys;
+	}
+	cfg.setGroup(oldgroup);
+
+	/* get list */
+	int cnt = 0;
+	m_index = START_INDEX+1;
+	m_applist.clear();
+	m_pMenu->clear();
+	MenuTitle* pTitle = new MenuTitle("TaskSelector", m_pMenu->font(), kind());
+	m_pMenu->insertItem(pTitle);
+	const QList<QWSWindow>& list = qwsServer->clientWindows();
+	QWSWindow* w;
+	for(QListIterator<QWSWindow> it(list); (w=it.current()); ++it){
+		if(w->isVisible() == false
+			|| w->caption() == QString::null){
+			continue;
+		}
+		QString app = w->client()->identity();
+		if(app == NULL || m_applist.contains(app)){
+			continue;
+		}
+		/* exclude "launcher" */
+		if(app == "launcher"){
+			if(cnt == 0){
+				m_index--;
+			}
+			continue;
+		}
+		m_applist.append(app);
+		/* append menu */
+		cnt++;
+		AppLnkSet* lnkSet = AppLnkManager::getInstance();
+		lnk = lnkSet->findExec(app);
+		QString text;
+		QPixmap icon;
+#if 0
+		if(lnk != NULL){
+			icon = lnk->pixmap();
+			text = lnk->name();
+		} else {
+			AppLnkManager::notfound();
+			icon = QPixmap();
+			text = w->caption();
+		}
+#else
+		if(lnk != NULL){
+			icon = lnk->pixmap();
+			if(w->caption().length() > 0){
+				text = w->caption();
+			} else {
+				text = lnk->name();
+			}
+		} else {
+			AppLnkManager::notfound();
+			icon = QPixmap();
+			text = w->caption();
+		}
+#endif
+		if(cnt <= (int)accesskeys.length()){
+			text.append("(&");
+			text.append(accesskeys[cnt-1].upper());
+			text.append(")");
+		}
+		m_pMenu->insertItem(icon, text, cnt);
+	}
+	return(cnt);
+}
+
+void TaskSelector::show()
+{
+	/* build task selector menu */
+	int cnt = buildMenu();
+	ConfigEx& cfg = ConfigEx::getInstance("keyhelper");
+	QString oldgroup = cfg.getGroup();
+	cfg.setGroup("Global");
+	int min = cfg.readNumEntry("SelectMenuMin", 2);
+	if(min != 1 && min != 3){
+		min = 2;
+	}
+	cfg.setGroup(oldgroup);
+
+	if(cnt == 0){
+		qDebug("no applications");
+	} else if(cnt < min){
+		//m_index = START_INDEX;
+		if(m_index > cnt){
+			m_index = cnt;
+		}
+		QTimer::singleShot(0, this, SLOT(select()));
+	} else {
+		if(m_index > cnt){
+			m_index = cnt;
+		}
+		ConfigEx& cfg = ConfigEx::getInstance("keyhelper");
+		cfg.setGroup("Style");
+		int x,y;
+		QString key = "Position_" + kind();
+		if(cfg.hasKey(key)){
+			const QStringList& list = cfg.readListEntry(key, ',');
+			x = list[0].toInt();
+			y = list[1].toInt();
+		} else {
+			x = (qt_screen->width() - m_pMenu->sizeHint().width()) / 2;
+			y = (qt_screen->height() - m_pMenu->sizeHint().height()) / 2;
+		}
+		QPoint pos(x, y);
+		m_pMenu->popup(pos);
+		m_pMenu->setActiveItem(m_index);
+	}
+	m_isShowing = false;
+}
+
+void TaskSelector::next()
+{
+	m_index++;
+	if(m_index > (signed int)m_applist.count()){
+		m_index = START_INDEX;
+	}
+	m_pMenu->setActiveItem(m_index);
+}
+
+void TaskSelector::select()
+{
+	//select(m_index);
+	m_pMenu->activateItemAt(m_index);
+}
+
+void TaskSelector::select(int index)
+{
+	if(index > 0){
+		Global::execute(m_applist[index-1]);
+	}
+	m_index = 0;
+}
+
+void TaskSelector::highlight(int index)
+{
+	if(m_pMenu->isVisible()){
+		m_index = index;
+	}
+}
+
+bool TaskSelector::eventFilter(QObject* o, QEvent* e)
+{
+	if(m_pMenu->isVisible()){
+		QKeyEvent* ke = (QKeyEvent*)e;
+		switch(e->type()){
+		case QEvent::Accel:
+			if(ke->key() == Qt::Key_Space
+				&& ke->isAutoRepeat() == false){
+				select();
+			}
+			break;
+		default:
+			//qDebug(">>>>> [%p][%d] <<<<<", o, e->type());
+			break;
+		}
+	}
+	return QObject::eventFilter(o, e);
+}
diff --git a/noncore/applets/keyhelper/keyhelperapplet/extension/TaskSelector.h b/noncore/applets/keyhelper/keyhelperapplet/extension/TaskSelector.h
new file mode 100644
index 0000000..ceb157d
--- a/dev/null
+++ b/noncore/applets/keyhelper/keyhelperapplet/extension/TaskSelector.h
@@ -0,0 +1,85 @@
+#ifndef _TASK_SELECTOR_H_
+#define _TASK_SELECTOR_H_
+
+#include <qstring.h>
+#include <qstringlist.h>
+#include <qvaluelist.h>
+#include <qwindowsystem_qws.h>
+#include <qpopupmenu.h>
+#include <qpoint.h>
+#include <qtimer.h>
+#include <qgfx_qws.h>
+
+#include <qpe/global.h>
+#include <qpe/applnk.h>
+#include <qpe/config.h>
+#include <qpe/mimetype.h>
+
+#include "ExtensionInterface.h"
+#include "MenuTitle.h"
+#include "KeyNames.h"
+#include "AppLnkManager.h"
+#include "ConfigEx.h"
+#include "QPopupMenuEx.h"
+
+class TaskSelector : public QObject, public ExtensionInterface
+{
+	Q_OBJECT
+public:
+	TaskSelector(const QString& kind = "select");
+	virtual ~TaskSelector();
+
+	virtual bool onKeyPress(int keycode);
+	virtual bool onModRelease(int modcode);
+	virtual int getKeycode()
+	{
+		return(m_keycode);
+	}
+	virtual int getKeymask()
+	{
+		return(m_keymask);
+	}
+	virtual const QValueList<int>& getModcodes()
+	{
+		return(m_modcodes);
+	}
+	virtual void setKeycode(int keycode)
+	{
+		m_keycode = keycode;
+	}
+	virtual void setKeymask(int keymask)
+	{
+		m_keymask = keymask;
+	}
+	virtual void setModcodes(const QValueList<int>& modcodes)
+	{
+		m_modcodes = modcodes;
+	}
+	virtual const QString& kind()
+	{
+		return(m_kind);
+	}
+public slots:
+	void show();
+	void select();
+	void select(int);
+	void highlight(int id);
+private:
+	int m_keycode;
+	int m_keymask;
+	QString m_kind;
+	QValueList<int> m_modcodes;
+
+	bool m_isShowing;
+	int m_index;
+	QPopupMenu* m_pMenu;
+	QStringList m_applist;
+	QString m_accesskeys;
+
+	int buildMenu();
+	void next();
+private slots:
+	bool eventFilter(QObject* o, QEvent* e);
+};
+
+#endif /* _TASK_SELECTOR_H_ */
diff --git a/noncore/applets/keyhelper/keyhelperapplet/extension/TaskSwitcher.cpp b/noncore/applets/keyhelper/keyhelperapplet/extension/TaskSwitcher.cpp
new file mode 100644
index 0000000..c51eba5
--- a/dev/null
+++ b/noncore/applets/keyhelper/keyhelperapplet/extension/TaskSwitcher.cpp
@@ -0,0 +1,58 @@
+#include "TaskSwitcher.h"
+
+TaskSwitcher::TaskSwitcher(const QString& kind) : m_kind(kind)
+{
+	qDebug("TaskSwitcher::TaskSwitcher()");
+}
+
+TaskSwitcher::~TaskSwitcher()
+{
+	qDebug("TaskSwitcher::~TaskSwitcher()");
+}
+
+bool TaskSwitcher::onKeyPress(int /*keycode*/)
+{
+	if(m_applist.isEmpty()){
+		/* get list */
+		const QList<QWSWindow>& list = qwsServer->clientWindows();
+		QWSWindow* w;
+		for(QListIterator<QWSWindow> it(list); (w=it.current()); ++it){
+			if(w->isVisible()){
+				QString app = w->client()->identity();
+				qDebug("applist[%s]", app.latin1());
+				if(app != NULL && m_applist.contains(app) == false){
+					m_applist.append(app);
+				}
+			}
+		}
+		m_appit = m_applist.begin();
+	}
+	if(m_applist.count() > 1){
+		/* switch next */
+		next();
+		if(*m_appit == "launcher"){
+			next();
+		}
+		Global::execute(*m_appit);
+	} else if(m_applist.count() == 1
+		&& *m_appit != "launcher"){
+		Global::execute(*m_appit);
+	} else {
+		qDebug("no applications");
+	}
+	return(true);
+}
+
+bool TaskSwitcher::onModRelease(int /*keycode*/)
+{
+	m_applist.clear();
+	return(false);
+}
+
+void TaskSwitcher::next()
+{
+	++m_appit;
+	if(m_appit == m_applist.end()){
+		m_appit = m_applist.begin();
+	}	
+}
diff --git a/noncore/applets/keyhelper/keyhelperapplet/extension/TaskSwitcher.h b/noncore/applets/keyhelper/keyhelperapplet/extension/TaskSwitcher.h
new file mode 100644
index 0000000..7bbde55
--- a/dev/null
+++ b/noncore/applets/keyhelper/keyhelperapplet/extension/TaskSwitcher.h
@@ -0,0 +1,61 @@
+#ifndef _TASK_SWITCHER_H_
+#define _TASK_SWITCHER_H_
+
+#include <qstring.h>
+#include <qstringlist.h>
+#include <qvaluelist.h>
+#include <qwindowsystem_qws.h>
+
+#include <qpe/global.h>
+
+#include "ExtensionInterface.h"
+
+class TaskSwitcher : public ExtensionInterface
+{
+public:
+	TaskSwitcher(const QString& kind = "switch");
+	virtual ~TaskSwitcher();
+
+	virtual bool onKeyPress(int keycode);
+	virtual bool onModRelease(int modcode);
+	virtual int getKeycode()
+	{
+		return(m_keycode);
+	}
+	virtual int getKeymask()
+	{
+		return(m_keymask);
+	}
+	virtual const QValueList<int>& getModcodes()
+	{
+		return(m_modcodes);
+	}
+	virtual void setKeycode(int keycode)
+	{
+		m_keycode = keycode;
+	}
+	virtual void setKeymask(int keymask)
+	{
+		m_keymask = keymask;
+	}
+	virtual void setModcodes(const QValueList<int>& modcodes)
+	{
+		m_modcodes = modcodes;
+	}
+	virtual const QString& kind()
+	{
+		return(m_kind);
+	}
+private:
+	int m_keycode;
+	int m_keymask;
+	QString m_kind;
+	QValueList<int> m_modcodes;
+
+	QStringList m_applist;
+	QStringList::Iterator m_appit;
+
+	void next();
+};
+
+#endif /* _TASK_SWITCHER_H_ */
diff --git a/noncore/applets/keyhelper/keyhelperapplet/keyhelperapplet.pro b/noncore/applets/keyhelper/keyhelperapplet/keyhelperapplet.pro
new file mode 100644
index 0000000..dafb077
--- a/dev/null
+++ b/noncore/applets/keyhelper/keyhelperapplet/keyhelperapplet.pro
@@ -0,0 +1,80 @@
+TEMPLATE	= lib
+CONFIG		= qt plugin warn_on
+HEADERS		= anylnk/AnyLnk.h \
+		  anylnk/AppLnkManager.h \
+		  anylnk/AppLnkWrapper.h \
+		  anylnk/DocLnkWrapper.h \
+		  anylnk/ExecLnk.h \
+		  anylnk/LnkWrapper.h \
+		  anylnk/MenuLnk.h \
+		  anylnk/ProcessInvoker.h \
+		  anylnk/QCopLnk.h \
+		  anylnk/TextLnk.h \
+		  applet/KeyHelper.h \
+		  applet/KeyHelperApplet.h \
+		  applet/KeyHelperWidget.h \
+		  applet/QSafeDataStream.h \
+		  config/ExtensionsHandler.h \
+		  config/KeycfgErrorHandler.h \
+		  config/KeycfgHandler.h \
+		  config/KeycfgReader.h \
+		  config/MappingsHandler.h \
+		  config/ModifiersHandler.h \
+		  config/RepeaterHandler.h \
+		  extension/ExtensionFactory.h \
+		  extension/ExtensionInterface.h \
+		  extension/KeyExtensions.h \
+		  extension/KeyLauncher.h \
+		  extension/MenuLauncher.h \
+		  extension/MenuTitle.h \
+		  extension/QPopupMenuEx.h \
+		  extension/TaskSelector.h \
+		  extension/TaskSwitcher.h \
+		  misc/ConfigEx.h \
+		  misc/KHUtil.h \
+		  misc/KeyAction.h \
+		  misc/KeyMappings.h \
+		  misc/KeyModifiers.h \
+		  misc/KeyNames.h \
+		  misc/KeyRepeater.h \
+		  misc/StringParser.h
+SOURCES		= anylnk/AnyLnk.cpp \
+		  anylnk/AppLnkManager.cpp \
+		  anylnk/AppLnkWrapper.cpp \
+		  anylnk/LnkWrapper.cpp \
+		  anylnk/ProcessInvoker.cpp \
+		  anylnk/QCopLnk.cpp \
+		  anylnk/TextLnk.cpp \
+		  applet/KeyHelper.cpp \
+		  applet/KeyHelperApplet.cpp \
+		  applet/KeyHelperWidget.cpp \
+		  applet/QSafeDataStream.cpp \
+		  config/ExtensionsHandler.cpp \
+		  config/KeycfgErrorHandler.cpp \
+		  config/KeycfgHandler.cpp \
+		  config/KeycfgReader.cpp \
+		  config/MappingsHandler.cpp \
+		  config/ModifiersHandler.cpp \
+		  config/RepeaterHandler.cpp \
+		  extension/ExtensionFactory.cpp \
+		  extension/KeyExtensions.cpp \
+		  extension/KeyLauncher.cpp \
+		  extension/MenuLauncher.cpp \
+		  extension/MenuTitle.cpp \
+		  extension/TaskSelector.cpp \
+		  extension/TaskSwitcher.cpp \
+		  misc/ConfigEx.cpp \
+		  misc/KHUtil.cpp \
+		  misc/KeyAction.cpp \
+		  misc/KeyMappings.cpp \
+		  misc/KeyModifiers.cpp \
+		  misc/KeyNames.cpp \
+		  misc/KeyRepeater.cpp \
+		  misc/StringParser.cpp
+DESTDIR			= $(OPIEDIR)/plugins/applets/
+INCLUDEPATH		+= $(OPIEDIR)/include ./misc ./config ./applet ./extension ./anylnk
+LIBS			+= -lqpe -lopiecore2
+TARGET			= keyhelperapplet
+VERSION			= 1.2.2
+
+include( $(OPIEDIR)/include.pro )
diff --git a/noncore/applets/keyhelper/keyhelperapplet/misc/ConfigEx.cpp b/noncore/applets/keyhelper/keyhelperapplet/misc/ConfigEx.cpp
new file mode 100644
index 0000000..3693dff
--- a/dev/null
+++ b/noncore/applets/keyhelper/keyhelperapplet/misc/ConfigEx.cpp
@@ -0,0 +1,112 @@
+#include "ConfigEx.h"
+
+ConfigEx::ConfigEx(const QString& name, Domain domain)
+	: Config(name, domain)
+{
+	m_charset = "utf8";
+	decode();
+	m_lastRead = QDateTime::currentDateTime();
+}
+
+#if 0
+void ConfigEx::removeComment()
+{
+	for(QMap<QString,ConfigGroup>::Iterator it=groups.begin();
+			it!=groups.end(); ++it){
+		QStringList removeList;
+		for(ConfigGroup::Iterator it2=(*it).begin();
+				it2!=(*it).end(); ++it2){
+			if(it2.key()[0] == '#'){
+				QString key = it2.key();
+				removeList.append(it2.key());
+			}
+		}
+		for(QStringList::Iterator it3=removeList.begin();
+				it3!=removeList.end(); ++it3){
+			(*it).remove(*it3);
+		}
+	}
+}
+#endif
+
+void ConfigEx::decode()
+{
+	QString group = getGroup();
+	setGroup("Global");
+	QString charset = readEntry("CharSet", "utf8");
+	qWarning("ConfigEx::decode()[%s][%s]", charset.latin1(), m_charset.latin1());
+	setGroup(group);
+	if(charset != m_charset){
+		m_charset = charset;
+		read();
+	}
+	//removeComment();
+}
+
+void ConfigEx::read()
+{
+    qWarning("ConfigEx::read()");
+    groups.clear();
+    changed = FALSE;
+
+    if ( !QFileInfo( filename ).exists() ) {
+	git = groups.end();
+	return;
+    }
+
+    QFile f( filename );
+    if ( !f.open( IO_ReadOnly ) ) {
+	git = groups.end();
+	return;
+    }
+
+    QTextStream s( &f );
+#ifdef CONFIG_MULTICODEC
+    QTextCodec* codec = QTextCodec::codecForName(m_charset);
+    if(codec == NULL){
+    	codec = QTextCodec::codecForName("utf8");
+    	qWarning("Config CharSet[utf8]");
+    } else {
+    	qWarning("Config CharSet[%s]", m_charset.latin1());
+    }
+    s.setCodec(codec);
+#else /* CONFIG_MULTICODEC */
+#if QT_VERSION <= 230 && defined(QT_NO_CODECS)
+    // The below should work, but doesn't in Qt 2.3.0
+    s.setCodec( QTextCodec::codecForMib( 106 ) );
+#else
+    s.setEncoding( QTextStream::UnicodeUTF8 );
+#endif
+#endif /* CONFIG_MULTICODEC */
+
+    QStringList list = QStringList::split('\n', s.read() );
+
+    f.close();
+
+    for ( QStringList::Iterator it = list.begin(); it != list.end(); ++it ) {
+        if ( !parse( *it ) ) {
+            git = groups.end();
+            return;
+        }
+    }
+}
+
+QStringList ConfigEx::getKeys()
+{
+	QStringList keys;
+	if(groups.end() != git){
+		for(ConfigGroup::ConstIterator it=(*git).begin();
+				it!=(*git).end(); ++it){
+			if(it.key()[0] != '#'){
+				keys.append(it.key());
+			}
+		}
+	}
+	return(keys);
+}
+
+QDateTime ConfigEx::lastModified()
+{
+	QFileInfo info(filename);
+	return(info.lastModified());
+}
diff --git a/noncore/applets/keyhelper/keyhelperapplet/misc/ConfigEx.h b/noncore/applets/keyhelper/keyhelperapplet/misc/ConfigEx.h
new file mode 100644
index 0000000..32120cc
--- a/dev/null
+++ b/noncore/applets/keyhelper/keyhelperapplet/misc/ConfigEx.h
@@ -0,0 +1,89 @@
+#ifndef _CONFIG_EX_H_
+#define _CONFIG_EX_H_
+
+#include <qstringlist.h>
+#include <qdatetime.h>
+#include <qfileinfo.h>
+#include <qtextstream.h>
+#include <qtextcodec.h>
+
+#define QTOPIA_INTERNAL_LANGLIST
+#include <qpe/config.h>
+#include <qpe/global.h>
+
+#define CONFIG_MULTICODEC
+
+/* Singleton Object */
+class ConfigEx : public Config
+{
+public:
+	static ConfigEx& getInstance(const QString& name){
+		static ConfigEx cfg(name);
+		if(/*cfg.flush() ||*/cfg.m_lastRead < cfg.lastModified()){
+			cfg.load(&cfg);
+		}
+		return(cfg);
+	}
+
+#if 0
+	bool flush(){
+		if(changed){
+			write();
+			return(true);
+		} else {
+			return(false);
+		}
+	}
+#endif
+
+	const QString& getGroup(){
+		return(git.key());
+	}
+
+	void load(ConfigEx* cfg){
+		cfg->read();
+		cfg->decode();
+		cfg->m_lastRead = QDateTime::currentDateTime();
+	}
+
+	void setConfig(const QString& name){
+		if(name == QString::null){
+			return;
+		}
+		/*flush();*/
+		filename = configFilename(name, User);
+		load(this);
+	}
+
+	void reload() {
+		/*flush();*/
+		load(this);
+	}
+
+	QStringList getKeys();
+	QDateTime lastModified();
+	QDateTime lastRead(){
+		return(m_lastRead);
+	}
+
+	friend class Dummy;	 /* for compie warning */
+private:
+	ConfigEx(const QString& name, Domain domain=User);
+	ConfigEx& operator=(const ConfigEx&);
+	virtual ~ConfigEx(){changed = false;}
+
+	class Dummy{}; /* for compile warning */
+
+
+	void read();
+	void decode();
+	//void removeComment();
+
+	QDateTime m_lastRead;
+#ifdef CONFIG_MULTICODEC
+	QString m_charset;
+#endif
+};
+
+#endif /* _CONFIG_EX_H_ */
+
diff --git a/noncore/applets/keyhelper/keyhelperapplet/misc/KHUtil.cpp b/noncore/applets/keyhelper/keyhelperapplet/misc/KHUtil.cpp
new file mode 100644
index 0000000..b7134d9
--- a/dev/null
+++ b/noncore/applets/keyhelper/keyhelperapplet/misc/KHUtil.cpp
@@ -0,0 +1,90 @@
+#include "KHUtil.h"
+#include <qwindowsystem_qws.h>
+
+int KHUtil::hex2int(const QString& hexstr, bool* ok)
+{
+	int val;
+	bool success;
+	if(hexstr.find("0x") == 0){
+		val = hexstr.mid(2).toInt(&success, 16);
+	} else {
+		val = hexstr.toInt(&success, 16);
+	}
+	if(!success){
+		val = 0;
+	}
+	if(ok){
+		*ok = success;
+	}
+	return(val);
+}
+
+const QStringList KHUtil::parseArgs(const QString& arguments)
+{
+	QString str;
+	QStringList args;
+	char quote = 0;
+	char c;
+	for(unsigned int i=0; i<arguments.length(); i++){
+		c = arguments[i];
+		switch(c){
+		case '\"':
+			if(quote == 0){
+				quote = c;
+			} else if(quote == '\"'){
+				if(str.length() > 0){
+					args.append(str);
+				}
+				str = "";
+				quote = 0;
+			} else {
+				str += c;
+			}
+			break;
+		case '\'':
+			if(quote == 0){
+				quote = c;
+			} else if(quote == '\''){
+				if(str.length() > 0){
+					args.append(str);
+				}
+				str = "";
+				quote = 0;
+			} else {
+				str += c;
+			}
+			break;
+		case ' ':
+			if(quote == 0){
+				if(str.length() > 0){
+					args.append(str);
+					str = "";
+				}
+			} else {
+				str += c;
+			}
+			break;
+		default:
+			str += c;
+			break;
+		}
+	}
+	if(str.length() > 0){
+		args.append(str);
+	}
+	return(args);
+}
+
+const QString KHUtil::currentApp()
+{
+	QString app;
+	const QList<QWSWindow>& list = qwsServer->clientWindows();
+	QWSWindow* w;
+	for(QListIterator<QWSWindow> it(list); (w=it.current()); ++it){
+		if(w->isVisible() && w->client()->identity() != QString::null){
+			app = w->client()->identity();
+			break;
+		}
+	}
+	return app;
+}
diff --git a/noncore/applets/keyhelper/keyhelperapplet/misc/KHUtil.h b/noncore/applets/keyhelper/keyhelperapplet/misc/KHUtil.h
new file mode 100644
index 0000000..a92a1b2
--- a/dev/null
+++ b/noncore/applets/keyhelper/keyhelperapplet/misc/KHUtil.h
@@ -0,0 +1,15 @@
+#ifndef _KHUTIL_H_
+#define _KHUTIL_H_
+
+#include <qstring.h>
+#include <qstringlist.h>
+
+class KHUtil
+{
+public:
+	static int hex2int(const QString& hexstr, bool* ok=NULL);
+	static const QStringList parseArgs(const QString& arguments);
+	static const QString currentApp();
+};
+
+#endif /* _KHUTIL_H_ */
diff --git a/noncore/applets/keyhelper/keyhelperapplet/misc/KeyAction.cpp b/noncore/applets/keyhelper/keyhelperapplet/misc/KeyAction.cpp
new file mode 100644
index 0000000..f44138c
--- a/dev/null
+++ b/noncore/applets/keyhelper/keyhelperapplet/misc/KeyAction.cpp
@@ -0,0 +1,253 @@
+#include "KeyAction.h"
+
+KeyAction::KeyAction()
+{
+	qDebug("KeyAction::KeyAction()");
+	enable();
+}
+
+KeyAction::~KeyAction()
+{
+	qDebug("KeyAction::~KeyAction()");
+}
+
+void KeyAction::init()
+{
+	ConfigEx& cfg = ConfigEx::getInstance("keyhelper");
+
+	QString oldgroup = cfg.getGroup();
+	cfg.setGroup("Global");
+
+	m_keepToggle = cfg.readBoolEntry("KeepToggle", true);
+
+	m_excludeKeys.clear();
+	if(cfg.hasKey("ExcludeKeys")){
+		QStringList keys = cfg.readListEntry("ExcludeKeys", ',');
+		for(QStringList::Iterator it=keys.begin();
+				it!=keys.end(); ++it){
+			int code;
+			if((*it).find("0x") == 0){
+				code = KHUtil::hex2int(*it);
+			} else {
+				code = KeyNames::getCode(*it);
+			}
+			if(code > 0){
+				m_excludeKeys.append(code);
+			}
+		}
+	} else {
+		m_excludeKeys.append(Qt::Key_F34);
+	}
+
+	m_presscnt = 0;
+	m_check = true;
+	m_keep_toggle_code = 0;
+	m_capture = false;
+	cfg.setGroup(oldgroup);
+}
+
+void KeyAction::setAction(int unicode, int keycode, int modifiers,
+		bool isPress, bool autoRepeat)
+{
+	m_unicode = unicode;
+	m_keycode = keycode;
+	m_modifiers = modifiers;
+	m_isPress = isPress;
+	m_autoRepeat = autoRepeat;
+}
+
+bool KeyAction::checkState()
+{
+	if(0 < m_unicode && m_unicode < 0xFFFF){
+		QChar ch(m_unicode);
+		QChar::Category category = ch.category();
+		if(category == QChar::Letter_Lowercase){
+			if(m_modifiers == 0){
+				m_pMappings->setCapsLock(false);
+				return(true);
+			} else if(m_modifiers == Qt::ShiftButton){
+				m_pMappings->setCapsLock(true);
+				return(true);
+			}
+		} else if(category == QChar::Letter_Uppercase){
+			if(m_modifiers == 0){
+				m_pMappings->setCapsLock(true);
+				return(true);
+			} else if(m_modifiers == Qt::ShiftButton){
+				m_pMappings->setCapsLock(false);
+				return(true);
+			}
+		}
+	}
+	return(false);
+}
+
+void KeyAction::sendKeyEvent(int unicode, int keycode, int modifiers,
+		bool isPress, bool autoRepeat)
+{
+	if(m_hookChannel.isEmpty()){
+			QWSServer::sendKeyEvent(unicode, keycode, modifiers, isPress, autoRepeat);
+	} else {
+		if(QCopChannel::isRegistered(m_hookChannel)){
+			QCopEnvelope e(m_hookChannel, "keyEvent(int,int,int,int,int)");
+			e << unicode << keycode << modifiers << (int)isPress << (int)autoRepeat;
+		} else {
+			m_hookChannel = "";
+			QWSServer::sendKeyEvent(unicode, keycode, modifiers, isPress, autoRepeat);
+		}
+	}
+}
+
+bool KeyAction::doAction()
+{
+	if(m_enable == false){
+		return(false);
+	}
+#if 0
+	if(m_excludeKeys.contains(m_keycode)){
+		return(false);
+	}
+#endif
+	if(!m_autoRepeat){
+		qDebug("recv[%x][%x][%x][%d]",
+			m_unicode,
+			m_keycode,
+			m_modifiers,
+			m_isPress);
+	}
+
+	if(m_autoRepeat && !m_excludeKeys.contains(m_keycode)){
+		KeyRepeater::RepeaterMode repMode = m_pRepeater->getMode();
+		if(repMode == KeyRepeater::ENABLE
+			|| repMode == KeyRepeater::KILL){
+			/* autoRepeat ¤Ï̵»ë */
+			return(true);
+		}
+	}
+
+	if(m_pRepeater->isRepeatable(m_keycode)){
+		if(m_isPress){
+			m_presscnt++;
+		} else {
+			m_presscnt--;
+			if(m_presscnt <= 0){
+				m_pRepeater->stop();
+				m_presscnt = 0;
+			}
+		}
+	}
+
+	if(m_check && m_isPress){
+		/* check capslock state */
+		if(checkState()){
+			m_check = false;
+		}
+	}
+
+	int unicode, keycode, modifiers;
+	/* keep toggle reset */
+	if(m_keepToggle && m_keep_toggle_code != 0){
+		if(m_keep_toggle_code != m_keycode){
+			m_pModifiers->resetToggles();
+			m_keep_toggle_code = 0;
+		} else {
+			m_pModifiers->keepToggles();
+		}
+	}
+
+	/* modifier ¾õÂÖ¼èÆÀ */
+	int keymask = m_pModifiers->getState(m_modifiers);
+	modifiers = m_pModifiers->getModifiers(m_modifiers);
+
+	bool isModMapped = false;
+	/* modifier ¾õÂÖ¹¹¿· */
+	if(m_autoRepeat == false){
+		if(m_isPress){
+			isModMapped = m_pModifiers->pressKey(m_keycode, m_modifiers);
+		} else {
+			m_pModifiers->releaseKey(m_keycode);
+		}
+	}
+
+	if(m_capture && m_isPress && m_autoRepeat == false){
+		QCopEnvelope e("QPE/KeyHelperConf", "event(int,int,int)");
+		e << m_keycode << m_unicode << modifiers;
+	}
+
+	/* keyextension ŬÍÑ */
+	bool fKeyCancel = m_pExtensions->doKey(m_keycode, keymask, m_isPress);
+	if(fKeyCancel){
+		if(m_keepToggle){
+			m_keep_toggle_code = m_keycode;
+		} else {
+			m_pModifiers->resetToggles();
+		}
+		m_pRepeater->stop();
+		return(true);
+	}
+
+	/* keymapping ŬÍÑ */
+#if 0
+	bool isMapped = m_pMappings->apply(m_keycode, keymask, m_isPress);
+	if(isMapped == false){
+		if(m_pMappings->isDefined()){
+			m_pMappings->setOriginal(m_unicode, m_modifiers);
+		} else {
+			m_pMappings->setUnicode(m_unicode);
+			//m_pMappings->setKeycode(m_keycode);
+		}
+		//return(false);
+	}
+#else
+	bool isMapped = m_pMappings->apply(m_unicode, m_keycode, m_modifiers,
+				keymask, m_isPress);
+#endif
+
+	/* modifier ŬÍÑ */
+	m_pMappings->setModifiers(modifiers);
+
+	keycode = m_pMappings->getKeycode();
+	if(keycode <= 0){
+		return(true);
+	}
+
+	if(/*m_autoRepeat == false &&*/ m_isPress){
+		if(isModMapped == false || (isModMapped && isMapped)){
+			if(m_pModifiers->isModifier(keycode) == false){
+				m_pModifiers->resetToggles();
+			}
+		}
+	}
+	unicode = m_pMappings->getUnicode();
+	modifiers = m_pMappings->getModifiers();
+	if(keycode > 0){
+		/* disable mapping */
+		if(m_excludeKeys.contains(keycode)){
+			return(false);
+		}
+		/* send key event */
+		sendKeyEvent(
+			unicode,
+			keycode,
+			modifiers,
+			m_isPress,
+			m_autoRepeat);
+	}
+	if(m_isPress){
+		/* repeater start */
+		m_pRepeater->start(unicode, keycode, modifiers);
+#if 0
+	} else if(m_presscnt <= 0){
+		m_presscnt = 0;
+		m_pRepeater->stop();
+#endif
+	} else {
+		m_pRepeater->stop(keycode);
+	}
+	qWarning("send[%x][%x][%x][%d]",
+		m_pMappings->getUnicode(),
+		m_pMappings->getKeycode(),
+		m_pMappings->getModifiers(),
+		m_isPress);
+	return(true);
+}
diff --git a/noncore/applets/keyhelper/keyhelperapplet/misc/KeyAction.h b/noncore/applets/keyhelper/keyhelperapplet/misc/KeyAction.h
new file mode 100644
index 0000000..4eb5eb6
--- a/dev/null
+++ b/noncore/applets/keyhelper/keyhelperapplet/misc/KeyAction.h
@@ -0,0 +1,87 @@
+#ifndef _KEY_ACTION_H_
+#define _KEY_ACTION_H_
+
+#include <qobject.h>
+#include <qwindowsystem_qws.h>
+#include <qtimer.h>
+#include <qpe/power.h>
+#include "KeyMappings.h"
+#include "KeyModifiers.h"
+#include "KeyExtensions.h"
+#include "KeyRepeater.h"
+#include "ConfigEx.h"
+
+class KeyAction : public QObject
+{
+	Q_OBJECT
+public:
+	KeyAction();
+	virtual ~KeyAction();
+
+	void setKeyMappings(KeyMappings* map)
+	{
+		m_pMappings = map;
+	}
+	void setKeyModifiers(KeyModifiers* mod)
+	{
+		m_pModifiers = mod;
+	}
+	void setKeyExtensions(KeyExtensions* ext)
+	{
+		m_pExtensions = ext;
+	}
+	void setKeyRepeater(KeyRepeater* rep)
+	{
+		m_pRepeater = rep;
+		connect(m_pRepeater, SIGNAL(keyEvent(int,int,int,bool,bool)),
+			this, SLOT(sendKeyEvent(int,int,int,bool,bool)));
+	}
+	void setAction(int unicode, int keycode, int modifiers,
+		bool isPress, bool autoRepeat);
+	bool doAction();
+
+	void enable(){
+		init();
+		m_enable = true;
+	};
+	void disable(){
+		m_enable = false;
+	};
+	void setCapture(bool enable){
+		m_capture = enable;
+	}
+
+	void setHook(const QCString& s){
+		m_hookChannel = s;
+	}
+private:
+	int m_unicode;
+	int m_keycode;
+	int m_modifiers;
+	bool m_isPress;
+	bool m_autoRepeat;
+
+	bool m_capture;
+	bool m_enable;
+	int m_presscnt;
+
+	int m_keep_toggle_code;
+	bool m_keepToggle;
+	bool m_check;
+	QValueList<int> m_excludeKeys;
+
+	QCString m_hookChannel;
+
+	KeyMappings* m_pMappings;
+	KeyModifiers* m_pModifiers;
+	KeyExtensions* m_pExtensions;
+	KeyRepeater* m_pRepeater;
+
+	void init();
+	bool checkState();
+private slots:
+	void sendKeyEvent(int unicode, int keycode, int modifiers,
+		bool isPress, bool autoRepeat);
+};
+
+#endif /* _KEY_ACTION_H_ */
diff --git a/noncore/applets/keyhelper/keyhelperapplet/misc/KeyMappings.cpp b/noncore/applets/keyhelper/keyhelperapplet/misc/KeyMappings.cpp
new file mode 100644
index 0000000..0151d39
--- a/dev/null
+++ b/noncore/applets/keyhelper/keyhelperapplet/misc/KeyMappings.cpp
@@ -0,0 +1,340 @@
+#include "KeyMappings.h"
+
+static QIntDict<QWSServer::KeyMap> g_mapCache(127);
+
+MapInfo::MapInfo(int code, int mod, int uni,
+	int shift_uni, int ctrl_uni)
+{
+	const QWSServer::KeyMap* map;
+	if(uni == 0 || shift_uni == 0 || ctrl_uni == 0){
+		map = MapInfo::findKeyMap(code);
+		if(map != NULL){
+			isDefined = true;
+			unicode = map->unicode;
+			shift_unicode = map->shift_unicode;
+			ctrl_unicode = map->ctrl_unicode;
+		} else {
+			isDefined = false;
+			unicode = 0;
+			shift_unicode = 0;
+			ctrl_unicode = 0;
+		}
+	} else {
+		isDefined = true;
+	}
+	keycode = code;
+	modifiers = mod;
+	if(uni != 0){
+		unicode = uni;
+	}
+	if(shift_uni != 0){
+		shift_unicode = shift_uni;
+	}
+	if(ctrl_uni != 0){
+		ctrl_unicode = ctrl_uni;
+	}
+}
+
+const QWSServer::KeyMap* MapInfo::findKeyMap(int keycode)
+{
+	const QWSServer::KeyMap* m = QWSServer::keyMap();
+
+	while(m->key_code != 0){
+		if(m->key_code == keycode){
+			return(m);
+		}
+		m++;
+	}
+	return(NULL);
+}
+
+KeyMappings::KeyMappings()
+{
+	qDebug("KeyMappings::KeyMappings()");
+	init();
+}
+
+KeyMappings::~KeyMappings()
+{
+	qDebug("KeyMappings::~KeyMappings()");
+	clear();
+}
+
+void KeyMappings::init()
+{
+	m_capslock = false;
+}
+
+void KeyMappings::reset()
+{
+	clear();
+}
+
+void KeyMappings::clear()
+{
+	for(QMap<int, CodeMaps*>::Iterator it = m_keymaps.begin();
+			it!=m_keymaps.end(); ++it){
+		delete (*it);
+	}
+	m_keymaps.clear();
+	g_mapCache.setAutoDelete(true);
+	g_mapCache.clear();
+}
+
+void KeyMappings::assign(int keycode, int keymask, int mapcode,
+	int mapmodifiers, int unicode, int shift_unicode, int ctrl_unicode)
+{
+	CodeMaps* map;
+	if(m_keymaps.contains(keycode)){
+		map = m_keymaps[keycode];
+	} else {
+		map = new CodeMaps();
+		m_keymaps.insert(keycode, map);
+	}
+
+	MapInfo info(mapcode, mapmodifiers, unicode, shift_unicode, ctrl_unicode);
+	m_it = map->insert(keymask, info);
+}
+
+void KeyMappings::assignModifier(const QString& type, const QString& state)
+{
+	int maskbit = 0;
+	QString str;
+	str = type.lower();
+	if(str == "shift"){
+		maskbit = Qt::ShiftButton;
+	} else if(str == "control"){
+		maskbit = Qt::ControlButton;
+	} else if(str == "alt"){
+		maskbit = Qt::AltButton;
+	}
+	str = state.lower();
+	if(str == "off"){
+		maskbit = (maskbit << 16) & 0xFFFF0000;
+	}
+	(*m_it).modifiers |= maskbit;
+}
+
+void KeyMappings::assignUnicode(const QString& kind, const QString& ch)
+{
+	QString str;
+	int code = ch[0].unicode();
+	str = kind.lower();
+	if(str == "unicode"){
+		(*m_it).unicode = code;
+	} else if(str == "shift_unicode"){
+		(*m_it).shift_unicode = code;
+	} else if(str == "ctrl_unicode"){
+		(*m_it).ctrl_unicode = code;
+	}
+}
+
+void KeyMappings::assignUnicode(int unicode)
+{
+	(*m_it).unicode = (*m_it).shift_unicode = 
+		(*m_it).ctrl_unicode = unicode;
+}
+
+void KeyMappings::statistics()
+{
+	qWarning("KeyMappings::statistics()");
+	for(QMap<int, CodeMaps*>::Iterator it=m_keymaps.begin();
+			it!=m_keymaps.end(); ++it){
+		qWarning(" code = %x", it.key());
+		for(QMap<int, MapInfo>::Iterator it2=(*it)->begin();
+				it2!=(*it)->end(); ++it2){
+			qDebug("  [%x]-[%x][%x][%x][%x][%x]", it2.key(),
+				(*it2).keycode,
+				(*it2).modifiers,
+				(*it2).unicode,
+				(*it2).shift_unicode,
+				(*it2).ctrl_unicode);
+		}
+	}
+}
+
+bool KeyMappings::apply(int unicode, int keycode, int modifiers,
+	int keymask, bool isPress)
+{
+	CodeMaps* map;
+	m_isMapped = false;
+
+	if(m_keymaps.contains(keycode)){
+		map = m_keymaps[keycode];
+		if(map->contains(keymask)){
+			m_isMapped = true;
+			m_keyinfo = (*map)[keymask];
+		} else {
+			int mask = -1;
+			for(CodeMaps::Iterator it=map->begin();
+					it!=map->end(); ++it){
+				if((keymask & it.key()) == it.key()
+					&& it.key() > mask){
+					mask = it.key();
+				}
+			}
+			if(mask != -1){
+				m_isMapped = true;
+				m_keyinfo = (*map)[mask];
+			}
+		}
+	}
+
+	if(m_isMapped == false){
+		QWSServer::KeyMap* cache = g_mapCache[keycode];
+		if(cache == NULL){
+			cache = new QWSServer::KeyMap();
+			g_mapCache.insert(keycode, cache);
+			cache->unicode = cache->shift_unicode = cache->ctrl_unicode = 0;
+		}
+		if(cache->unicode == 0 || cache->shift_unicode == 0 || cache->ctrl_unicode == 0){
+			QChar ch(unicode);
+			if(modifiers & Qt::ControlButton){
+				cache->ctrl_unicode = unicode;
+			} else if(modifiers & Qt::ShiftButton){
+				cache->shift_unicode = ch.upper().unicode();
+			} else {
+				cache->unicode = ch.lower().unicode();
+			}
+		}
+		m_keyinfo = MapInfo(keycode, 0,
+			cache->unicode, cache->shift_unicode, cache->ctrl_unicode);
+		if(m_keyinfo.isDefined){
+			setOriginal(unicode, modifiers);
+		} else {
+			setUnicode(unicode);
+		}
+	}
+
+#if 1
+	if(isPress){
+		if(m_keyinfo.keycode == Qt::Key_CapsLock){
+			m_capslock = !m_capslock;
+		}
+	}
+#endif
+	return(m_isMapped);
+}
+
+bool KeyMappings::apply(int keycode, int keymask, bool isPress)
+{
+	CodeMaps* map;
+	m_isMapped = false;
+
+	if(m_keymaps.contains(keycode)){
+		map = m_keymaps[keycode];
+		if(map->contains(keymask)){
+			m_isMapped = true;
+			m_keyinfo = (*map)[keymask];
+		} else {
+			int mask = -1;
+			for(CodeMaps::Iterator it=map->begin();
+					it!=map->end(); ++it){
+				if((keymask & it.key()) == it.key()
+					&& it.key() > mask){
+					mask = it.key();
+				}
+			}
+			if(mask != -1){
+				m_isMapped = true;
+				m_keyinfo = (*map)[mask];
+			}
+		}
+	}
+	if(m_isMapped == false){
+		m_keyinfo = MapInfo(keycode);
+	}
+#if 1
+	if(isPress){
+		if(m_keyinfo.keycode == Qt::Key_CapsLock){
+			m_capslock = !m_capslock;
+		}
+	}
+#endif
+	return(m_isMapped);
+}
+
+/**
+ * set original unicode
+ */
+void KeyMappings::setOriginal(int unicode, int modifiers)
+{
+	if(modifiers & Qt::ControlButton){
+		m_keyinfo.ctrl_unicode = unicode;
+	} else if(modifiers & Qt::ShiftButton){
+		m_keyinfo.shift_unicode = unicode;
+	} else {
+		m_keyinfo.unicode = unicode;
+	}
+}
+
+void KeyMappings::setModifiers(int modifiers)
+{
+	m_modifiers = modifiers;
+	m_modifiers |= (m_keyinfo.modifiers & 0xFFFF);
+	m_modifiers &= ~((m_keyinfo.modifiers >> 16) & 0xFFFF);
+}
+
+void KeyMappings::setUnicode(int unicode)
+{
+	m_keyinfo.unicode = unicode;
+	m_keyinfo.shift_unicode = unicode;
+	m_keyinfo.ctrl_unicode = unicode;
+}
+
+void KeyMappings::setKeycode(int keycode)
+{
+	m_keyinfo.keycode = keycode;
+}
+
+int KeyMappings::getUnicode()
+{
+	int unicode;
+	if(m_modifiers & Qt::ControlButton){
+		unicode = m_keyinfo.ctrl_unicode;
+	} else if(m_modifiers & Qt::ShiftButton){
+		unicode = m_keyinfo.shift_unicode;
+		QChar ch(unicode);
+		if(m_capslock){
+			unicode = ch.lower().unicode();
+		} else {
+			unicode = ch.upper().unicode();
+		}
+	} else {
+		unicode = m_keyinfo.unicode;
+		QChar ch(unicode);
+		if(m_capslock){
+			unicode = ch.upper().unicode();
+		} else {
+			unicode = ch.lower().unicode();
+		}
+	}
+	qDebug("UNICODE[%d][%x][%x]", m_capslock, unicode, m_keyinfo.unicode);
+#if 0
+	if(m_isMapped && m_capslock){
+		QChar ch(unicode);
+		QChar::Category category = ch.category();
+		if(category == QChar::Letter_Uppercase){
+			unicode = ch.lower().unicode();
+		} else if(category == QChar::Letter_Lowercase){
+			unicode = ch.upper().unicode();
+		}
+	}
+#endif
+	return(unicode);
+}
+
+int KeyMappings::getKeycode()
+{
+	return(m_keyinfo.keycode);
+}
+
+int KeyMappings::getModifiers()
+{
+	return(m_modifiers);
+}
+
+bool KeyMappings::isDefined()
+{
+	return(m_keyinfo.isDefined);
+}
diff --git a/noncore/applets/keyhelper/keyhelperapplet/misc/KeyMappings.h b/noncore/applets/keyhelper/keyhelperapplet/misc/KeyMappings.h
new file mode 100644
index 0000000..9705c8c
--- a/dev/null
+++ b/noncore/applets/keyhelper/keyhelperapplet/misc/KeyMappings.h
@@ -0,0 +1,72 @@
+#ifndef _KEY_MAPPINGS_H_
+#define _KEY_MAPPINGS_H_
+
+#include <qwindowsystem_qws.h>
+#include <qmap.h>
+
+#include <qintdict.h>
+
+class MapInfo
+{
+public:
+	MapInfo(){};
+	MapInfo(int code, int mod = 0, int uni = 0,
+		int shift_uni = 0, int ctrl_uni = 0);
+
+	static const QWSServer::KeyMap* findKeyMap(int code);
+
+	int keycode;
+	int modifiers;
+	int unicode;
+	int shift_unicode;
+	int ctrl_unicode;
+	bool isDefined;
+};
+
+class KeyMappings
+{
+public:
+	typedef QWSServer::KeyMap KeyMap;
+	typedef QMap<int, MapInfo> CodeMaps;
+
+	KeyMappings();
+	virtual ~KeyMappings();
+
+	void setOriginal(int unicode, int modifiers);
+	void setModifiers(int modifiers);
+	void setUnicode(int unicode);
+	void setKeycode(int keycode);
+
+	int getUnicode();
+	int getKeycode();
+	int getModifiers();
+	bool isDefined();
+
+	void assign(int keycode, int keymask, int mapcode, int mapmodifiers = 0,
+		int unicode = 0, int shift_unicode = 0, int ctrl_unicode = 0);
+	void assignModifier(const QString& type, const QString& state);
+	void assignUnicode(const QString& kind, const QString& ch);
+	void assignUnicode(int unicode);
+	bool apply(int unicode, int keycode, int modifiers, int keymask, bool isPress);
+	bool apply(int keycode, int keymask, bool isPress);
+	void setCapsLock(bool on=true){
+		m_capslock = on;
+	}
+
+	void reset();
+
+	void statistics();
+private:
+	QMap<int, CodeMaps*> m_keymaps;
+	MapInfo m_keyinfo;
+	int m_modifiers;
+	CodeMaps::Iterator m_it;
+
+	bool m_capslock;
+	bool m_isMapped;
+
+	void init();
+	void clear();
+};
+
+#endif /* _KEY_MAPPINGS_H_ */
diff --git a/noncore/applets/keyhelper/keyhelperapplet/misc/KeyModifiers.cpp b/noncore/applets/keyhelper/keyhelperapplet/misc/KeyModifiers.cpp
new file mode 100644
index 0000000..4699b11
--- a/dev/null
+++ b/noncore/applets/keyhelper/keyhelperapplet/misc/KeyModifiers.cpp
@@ -0,0 +1,285 @@
+#include "KeyModifiers.h"
+
+KeyModifiers::KeyModifiers()
+{
+	qDebug("KeyModifiers::KeyModifiers()");
+	m_pTimer = new QTimer(this);
+	connect(m_pTimer, SIGNAL(timeout()),
+			this, SLOT(resetToggles()));
+	init();
+}
+
+KeyModifiers::~KeyModifiers()
+{
+	qDebug("KeyModifiers::~KeyModifiers()");
+	delete m_pTimer;
+	clear();
+}
+
+void KeyModifiers::addType(const QString& type)
+{
+	if(m_types.contains(type) == false){
+		qDebug("addType[%s][%x]", type.latin1(), m_bitmask);
+		m_types.insert(type, m_bitmask);
+		m_bitmask = m_bitmask << 1;
+	}
+}
+
+ModifierInfo* KeyModifiers::assign(const QString& type, int keycode,
+	int keymask, bool mode)
+{
+	m_info = new ModifierInfo(type, keycode, keymask, mode);
+	addType(type);
+	m_modifiers.append(m_info);
+	if(mode){
+		m_togglekeys.append(m_info);
+	}
+	assignRelease(m_info, keycode);
+	return(m_info);
+}
+
+void KeyModifiers::assignRelease(int keycode)
+{
+	assignRelease(m_info, keycode);
+}
+
+void KeyModifiers::assignRelease(ModifierInfo* info, int keycode)
+{
+	if(m_releasekeys.contains(keycode) == false){
+		m_releasekeys.insert(keycode, new ModifierList);
+	}
+	m_releasekeys[keycode]->append(info);
+}
+
+void KeyModifiers::setToggle()
+{
+	setToggle(m_info);
+}
+
+void KeyModifiers::setToggle(ModifierInfo* info)
+{
+	info->toggle_mode = true;
+	m_togglekeys.append(info);
+}
+
+void KeyModifiers::keepToggles()
+{
+	if(m_timeout > 0){
+		m_pTimer->start(m_timeout, true);
+	}
+}
+
+bool KeyModifiers::pressKey(int keycode, int modifiers)
+{
+	int keymask;
+
+	keymask = getState(modifiers, true);
+	
+	for(ModifierList::Iterator it=m_modifiers.begin();
+			it!=m_modifiers.end(); ++it){
+		if((*it)->keycode == keycode
+			&& ((*it)->keymask & keymask) == (*it)->keymask){
+			(*it)->pressed = true;
+			if((*it)->toggle_mode){
+				/* change toggle state */
+				(*it)->toggled = !((*it)->toggled);
+				if((*it)->toggled){
+					keepToggles();
+				} else {
+					m_pTimer->stop();
+				}
+			}
+			return(true);
+		}
+	}
+	return(false);
+}
+
+bool KeyModifiers::isModifier(int keycode)
+{
+	if(keycode == Qt::Key_Shift
+		|| keycode == Qt::Key_Control
+		|| keycode == Qt::Key_Alt
+		|| keycode == Qt::Key_Meta
+		|| keycode == Qt::Key_F22){
+		return(true);
+	} else {
+		return(false);
+	}
+}
+
+void KeyModifiers::releaseKey(int keycode)
+{
+	if(m_releasekeys.contains(keycode)){
+		ModifierList* list = m_releasekeys[keycode];
+		for(ModifierList::Iterator it=(*list).begin();
+				it!=(*list).end(); ++it){
+			(*it)->pressed = false;
+		}
+	}
+}
+
+int KeyModifiers::getState()
+{
+	int state = 0;
+	for(ModifierList::Iterator it=m_modifiers.begin();
+			it!=m_modifiers.end(); ++it){
+		if((*it)->pressed || (*it)->toggled){
+			state |= m_types[(*it)->type];
+		}
+	}
+	return(state);
+}
+
+int KeyModifiers::getState(int modifiers, bool reset)
+{
+	int state = getState();
+	int mask;
+
+	mask = getMask("Shift");
+	if(modifiers & Qt::ShiftButton){
+		state |= mask;
+	} else {
+		if(reset){
+			state &= ~mask;
+		}
+	}
+	mask = getMask("Control");
+	if(modifiers & Qt::ControlButton){
+		state |= mask;
+	} else {
+		if(reset){
+			state &= ~mask;
+		}
+	}
+	mask = getMask("Alt");
+	if(modifiers & Qt::AltButton){
+		state |= mask;
+	} else {
+		if(reset){
+			state &= ~mask;
+		}
+	}
+
+	return(state);
+}
+
+int KeyModifiers::getModifiers(int modifiers)
+{
+	int state = getState();
+
+	if(state & getMask("Shift")){
+		modifiers |= Qt::ShiftButton;
+	}
+	if(state & getMask("Control")){
+		modifiers |= Qt::ControlButton;
+	}
+	if(state & getMask("Alt")){
+		modifiers |= Qt::AltButton;
+	}
+
+	return(modifiers);
+}
+
+int KeyModifiers::getMask(const QString& type)
+{
+	if(m_types.contains(type)){
+		return(m_types[type]);
+	} else {
+		return(0);
+	}
+}
+
+void KeyModifiers::clear()
+{
+	m_types.clear();
+
+	m_togglekeys.clear();
+
+	for(ModifierList::Iterator it=m_modifiers.begin();
+			it!=m_modifiers.end(); ++it){
+		delete *it;
+	}
+	m_modifiers.clear();
+
+	for(QMap<int, ModifierList*>::Iterator it=m_releasekeys.begin();
+			it!=m_releasekeys.end(); ++it){
+		delete *it;
+	}
+	m_releasekeys.clear();
+}
+
+void KeyModifiers::init()
+{
+	m_bitmask = 0x00000001;
+	addType("Shift");
+	addType("Control");
+	addType("Alt");
+
+	ConfigEx& cfg = ConfigEx::getInstance("keyhelper");
+
+	cfg.setGroup("Global");
+
+	QString timeout = cfg.readEntry("ToggleTimeout", "10");
+	int msec = timeout.toInt();
+	msec *= 1000; /* sec to msec */
+	m_timeout = msec;
+}
+
+void KeyModifiers::reset()
+{
+	clear();
+	init();
+}
+
+bool KeyModifiers::isToggled()
+{
+	for(ModifierList::Iterator it=m_togglekeys.begin();
+			it!=m_togglekeys.end(); ++it){
+		if((*it)->toggled){
+			return(true);
+		}
+	}
+	return(false);
+}
+
+void KeyModifiers::resetToggles()
+{
+	for(ModifierList::Iterator it=m_togglekeys.begin();
+			it!=m_togglekeys.end(); ++it){
+		(*it)->toggled = false;
+	}
+	m_pTimer->stop();
+}
+
+void KeyModifiers::resetStates()
+{
+	for(ModifierList::Iterator it=m_modifiers.begin();
+			it!=m_modifiers.end(); ++it){
+		(*it)->pressed = false;
+	}
+	resetToggles();
+}
+
+void KeyModifiers::statistics()
+{
+	qWarning("KeyModifiers::statistics()");
+	for(ModifierList::Iterator it=m_modifiers.begin();
+			it!=m_modifiers.end(); ++it){
+		qWarning(" [%s][%x][%x][%d][%d]",
+			(*it)->type.latin1(),
+			(*it)->keycode,
+			(*it)->keymask,
+			(*it)->pressed,
+			(*it)->toggled);
+		for(QMap<int, ModifierList*>::Iterator it2=m_releasekeys.begin();
+				it2!=m_releasekeys.end(); ++it2){
+			for(ModifierList::Iterator it3=(*it2)->begin();
+					it3!=(*it2)->end(); ++it3){
+				if(*it == *it3){
+					qWarning("  release[%x]", it2.key());
+				}
+			}
+		}
+	}
+}
diff --git a/noncore/applets/keyhelper/keyhelperapplet/misc/KeyModifiers.h b/noncore/applets/keyhelper/keyhelperapplet/misc/KeyModifiers.h
new file mode 100644
index 0000000..a99c181
--- a/dev/null
+++ b/noncore/applets/keyhelper/keyhelperapplet/misc/KeyModifiers.h
@@ -0,0 +1,80 @@
+#ifndef _KEY_MODIFIERS_H_
+#define _KEY_MODIFIERS_H_
+
+#include <qmap.h>
+#include <qtimer.h>
+#include <qvaluelist.h>
+#include <qnamespace.h>
+
+#include <qpe/config.h>
+#include "ConfigEx.h"
+
+struct ModifierInfo {
+public:
+	ModifierInfo(const QString& tp, int code, int mask, bool mode)
+	{
+		type = tp;
+		keycode = code;
+		keymask = mask;
+		pressed = false;
+		toggled = false;
+		toggle_mode = mode;
+	}
+	QString type;
+	int keycode;
+	int keymask;
+	bool pressed;
+	bool toggled;
+	bool toggle_mode;
+private:
+} ;
+
+class KeyModifiers : public QObject
+{
+	Q_OBJECT
+public:
+	typedef QValueList<ModifierInfo*> ModifierList;
+
+	KeyModifiers();
+	virtual ~KeyModifiers();
+	void addType(const QString& type);
+	ModifierInfo* assign(const QString& type, int keycode,
+		int keymask = 0, bool toggle = false);
+	void assignRelease(int keycode);
+	void assignRelease(ModifierInfo* info, int keycode);
+	void setToggle();
+	void setToggle(ModifierInfo* info);
+
+	bool isToggled();
+	void resetStates();
+	void keepToggles();
+
+	bool pressKey(int keycode, int modifiers);
+	void releaseKey(int keycode);
+	int getState();
+	int getState(int modifiers, bool reset = false);
+	int getMask(const QString& type);
+	int getModifiers(int modifiers);
+
+	bool isModifier(int keycode);
+
+	void statistics();
+
+	void reset();
+public slots:
+	void resetToggles();
+private:
+	QMap<QString, int> m_types;
+	int m_bitmask;
+	ModifierList m_modifiers;
+	QMap<int, ModifierList*> m_releasekeys;
+	ModifierList m_togglekeys;
+	ModifierInfo* m_info;
+	QTimer* m_pTimer;
+	int m_timeout;
+
+	void clear();
+	void init();
+};
+
+#endif /* _KEY_MODIFIERS_H_ */
diff --git a/noncore/applets/keyhelper/keyhelperapplet/misc/KeyNames.cpp b/noncore/applets/keyhelper/keyhelperapplet/misc/KeyNames.cpp
new file mode 100644
index 0000000..2def857
--- a/dev/null
+++ b/noncore/applets/keyhelper/keyhelperapplet/misc/KeyNames.cpp
@@ -0,0 +1,303 @@
+#include "KeyNames.h"
+
+QMap<QString, int> KeyNames::codemap;
+QMap<int, QString> KeyNames::namemap;
+QString KeyNames::tmpname;
+
+static struct {
+	int code;
+	char* name;
+} stKeyNames[] = {
+{Qt::Key_Escape, "Escape"},
+{Qt::Key_Tab, "Tab"},
+{Qt::Key_Backtab, "Backtab"},
+{Qt::Key_BackTab, "BackTab"},
+{Qt::Key_Backtab, "Backtab"},
+{Qt::Key_Backspace, "Backspace"},
+{Qt::Key_BackSpace, "BackSpace"},
+{Qt::Key_Backspace, "Backspace"},
+{Qt::Key_Return, "Return"},
+{Qt::Key_Enter, "Enter"},
+{Qt::Key_Insert, "Insert"},
+{Qt::Key_Delete, "Delete"},
+{Qt::Key_Pause, "Pause"},
+{Qt::Key_Print, "Print"},
+{Qt::Key_SysReq, "SysReq"},
+{Qt::Key_Home, "Home"},
+{Qt::Key_End, "End"},
+{Qt::Key_Left, "Left"},
+{Qt::Key_Up, "Up"},
+{Qt::Key_Right, "Right"},
+{Qt::Key_Down, "Down"},
+{Qt::Key_Prior, "Prior"},
+{Qt::Key_PageUp, "PageUp"},
+{Qt::Key_Prior, "Prior"},
+{Qt::Key_Next, "Next"},
+{Qt::Key_PageDown, "PageDown"},
+{Qt::Key_Next, "Next"},
+{Qt::Key_Shift, "Shift"},
+{Qt::Key_Control, "Control"},
+{Qt::Key_Meta, "Meta"},
+{Qt::Key_Alt, "Alt"},
+{Qt::Key_CapsLock, "CapsLock"},
+{Qt::Key_NumLock, "NumLock"},
+{Qt::Key_ScrollLock, "ScrollLock"},
+{Qt::Key_F1, "F1"},
+{Qt::Key_F2, "F2"},
+{Qt::Key_F3, "F3"},
+{Qt::Key_F4, "F4"},
+{Qt::Key_F5, "F5"},
+{Qt::Key_F6, "F6"},
+{Qt::Key_F7, "F7"},
+{Qt::Key_F8, "F8"},
+{Qt::Key_F9, "F9"},
+{Qt::Key_F10, "F10"},
+{Qt::Key_F11, "F11"},
+{Qt::Key_F12, "F12"},
+{Qt::Key_F13, "F13"},
+{Qt::Key_F14, "F14"},
+{Qt::Key_F15, "F15"},
+{Qt::Key_F16, "F16"},
+{Qt::Key_F17, "F17"},
+{Qt::Key_F18, "F18"},
+{Qt::Key_F19, "F19"},
+{Qt::Key_F20, "F20"},
+{Qt::Key_F21, "F21"},
+{Qt::Key_F22, "F22"},
+{Qt::Key_F23, "F23"},
+{Qt::Key_F24, "F24"},
+{Qt::Key_F25, "F25"},
+{Qt::Key_F26, "F26"},
+{Qt::Key_F27, "F27"},
+{Qt::Key_F28, "F28"},
+{Qt::Key_F29, "F29"},
+{Qt::Key_F30, "F30"},
+{Qt::Key_F31, "F31"},
+{Qt::Key_F32, "F32"},
+{Qt::Key_F33, "F33"},
+{Qt::Key_F34, "F34"},
+{Qt::Key_F35, "F35"},
+{Qt::Key_Super_L, "Super_L"},
+{Qt::Key_Super_R, "Super_R"},
+{Qt::Key_Menu, "Menu"},
+{Qt::Key_Hyper_L, "Hyper_L"},
+{Qt::Key_Hyper_R, "Hyper_R"},
+{Qt::Key_Help, "Help"},
+{Qt::Key_Space, "Space"},
+{Qt::Key_Any, "Any"},
+{Qt::Key_Space, "Space"},
+{Qt::Key_Exclam, "Exclam"},
+{Qt::Key_QuoteDbl, "QuoteDbl"},
+{Qt::Key_NumberSign, "NumberSign"},
+{Qt::Key_Dollar, "Dollar"},
+{Qt::Key_Percent, "Percent"},
+{Qt::Key_Ampersand, "Ampersand"},
+{Qt::Key_Apostrophe, "Apostrophe"},
+{Qt::Key_ParenLeft, "ParenLeft"},
+{Qt::Key_ParenRight, "ParenRight"},
+{Qt::Key_Asterisk, "Asterisk"},
+{Qt::Key_Plus, "Plus"},
+{Qt::Key_Comma, "Comma"},
+{Qt::Key_Minus, "Minus"},
+{Qt::Key_Period, "Period"},
+{Qt::Key_Slash, "Slash"},
+{Qt::Key_0, "0"},
+{Qt::Key_1, "1"},
+{Qt::Key_2, "2"},
+{Qt::Key_3, "3"},
+{Qt::Key_4, "4"},
+{Qt::Key_5, "5"},
+{Qt::Key_6, "6"},
+{Qt::Key_7, "7"},
+{Qt::Key_8, "8"},
+{Qt::Key_9, "9"},
+{Qt::Key_Colon, "Colon"},
+{Qt::Key_Semicolon, "Semicolon"},
+{Qt::Key_Less, "Less"},
+{Qt::Key_Equal, "Equal"},
+{Qt::Key_Greater, "Greater"},
+{Qt::Key_Question, "Question"},
+{Qt::Key_At, "At"},
+{Qt::Key_A, "A"},
+{Qt::Key_B, "B"},
+{Qt::Key_C, "C"},
+{Qt::Key_D, "D"},
+{Qt::Key_E, "E"},
+{Qt::Key_F, "F"},
+{Qt::Key_G, "G"},
+{Qt::Key_H, "H"},
+{Qt::Key_I, "I"},
+{Qt::Key_J, "J"},
+{Qt::Key_K, "K"},
+{Qt::Key_L, "L"},
+{Qt::Key_M, "M"},
+{Qt::Key_N, "N"},
+{Qt::Key_O, "O"},
+{Qt::Key_P, "P"},
+{Qt::Key_Q, "Q"},
+{Qt::Key_R, "R"},
+{Qt::Key_S, "S"},
+{Qt::Key_T, "T"},
+{Qt::Key_U, "U"},
+{Qt::Key_V, "V"},
+{Qt::Key_W, "W"},
+{Qt::Key_X, "X"},
+{Qt::Key_Y, "Y"},
+{Qt::Key_Z, "Z"},
+{Qt::Key_BracketLeft, "BracketLeft"},
+{Qt::Key_Backslash, "Backslash"},
+{Qt::Key_BracketRight, "BracketRight"},
+{Qt::Key_AsciiCircum, "AsciiCircum"},
+{Qt::Key_Underscore, "Underscore"},
+{Qt::Key_QuoteLeft, "QuoteLeft"},
+{Qt::Key_BraceLeft, "BraceLeft"},
+{Qt::Key_Bar, "Bar"},
+{Qt::Key_BraceRight, "BraceRight"},
+{Qt::Key_AsciiTilde, "AsciiTilde"},
+{Qt::Key_nobreakspace, "nobreakspace"},
+{Qt::Key_exclamdown, "exclamdown"},
+{Qt::Key_cent, "cent"},
+{Qt::Key_sterling, "sterling"},
+{Qt::Key_currency, "currency"},
+{Qt::Key_yen, "yen"},
+{Qt::Key_brokenbar, "brokenbar"},
+{Qt::Key_section, "section"},
+{Qt::Key_diaeresis, "diaeresis"},
+{Qt::Key_copyright, "copyright"},
+{Qt::Key_ordfeminine, "ordfeminine"},
+{Qt::Key_guillemotleft, "guillemotleft"},
+{Qt::Key_notsign, "notsign"},
+{Qt::Key_hyphen, "hyphen"},
+{Qt::Key_registered, "registered"},
+{Qt::Key_macron, "macron"},
+{Qt::Key_degree, "degree"},
+{Qt::Key_plusminus, "plusminus"},
+{Qt::Key_twosuperior, "twosuperior"},
+{Qt::Key_threesuperior, "threesuperior"},
+{Qt::Key_acute, "acute"},
+{Qt::Key_mu, "mu"},
+{Qt::Key_paragraph, "paragraph"},
+{Qt::Key_periodcentered, "periodcentered"},
+{Qt::Key_cedilla, "cedilla"},
+{Qt::Key_onesuperior, "onesuperior"},
+{Qt::Key_masculine, "masculine"},
+{Qt::Key_guillemotright, "guillemotright"},
+{Qt::Key_onequarter, "onequarter"},
+{Qt::Key_onehalf, "onehalf"},
+{Qt::Key_threequarters, "threequarters"},
+{Qt::Key_questiondown, "questiondown"},
+{Qt::Key_Agrave, "Agrave"},
+{Qt::Key_Aacute, "Aacute"},
+{Qt::Key_Acircumflex, "Acircumflex"},
+{Qt::Key_Atilde, "Atilde"},
+{Qt::Key_Adiaeresis, "Adiaeresis"},
+{Qt::Key_Aring, "Aring"},
+{Qt::Key_AE, "AE"},
+{Qt::Key_Ccedilla, "Ccedilla"},
+{Qt::Key_Egrave, "Egrave"},
+{Qt::Key_Eacute, "Eacute"},
+{Qt::Key_Ecircumflex, "Ecircumflex"},
+{Qt::Key_Ediaeresis, "Ediaeresis"},
+{Qt::Key_Igrave, "Igrave"},
+{Qt::Key_Iacute, "Iacute"},
+{Qt::Key_Icircumflex, "Icircumflex"},
+{Qt::Key_Idiaeresis, "Idiaeresis"},
+{Qt::Key_ETH, "ETH"},
+{Qt::Key_Ntilde, "Ntilde"},
+{Qt::Key_Ograve, "Ograve"},
+{Qt::Key_Oacute, "Oacute"},
+{Qt::Key_Ocircumflex, "Ocircumflex"},
+{Qt::Key_Otilde, "Otilde"},
+{Qt::Key_Odiaeresis, "Odiaeresis"},
+{Qt::Key_multiply, "multiply"},
+{Qt::Key_Ooblique, "Ooblique"},
+{Qt::Key_Ugrave, "Ugrave"},
+{Qt::Key_Uacute, "Uacute"},
+{Qt::Key_Ucircumflex, "Ucircumflex"},
+{Qt::Key_Udiaeresis, "Udiaeresis"},
+{Qt::Key_Yacute, "Yacute"},
+{Qt::Key_THORN, "THORN"},
+{Qt::Key_ssharp, "ssharp"},
+{Qt::Key_agrave, "agrave"},
+{Qt::Key_aacute, "aacute"},
+{Qt::Key_acircumflex, "acircumflex"},
+{Qt::Key_atilde, "atilde"},
+{Qt::Key_adiaeresis, "adiaeresis"},
+{Qt::Key_aring, "aring"},
+{Qt::Key_ae, "ae"},
+{Qt::Key_ccedilla, "ccedilla"},
+{Qt::Key_egrave, "egrave"},
+{Qt::Key_eacute, "eacute"},
+{Qt::Key_ecircumflex, "ecircumflex"},
+{Qt::Key_ediaeresis, "ediaeresis"},
+{Qt::Key_igrave, "igrave"},
+{Qt::Key_iacute, "iacute"},
+{Qt::Key_icircumflex, "icircumflex"},
+{Qt::Key_idiaeresis, "idiaeresis"},
+{Qt::Key_eth, "eth"},
+{Qt::Key_ntilde, "ntilde"},
+{Qt::Key_ograve, "ograve"},
+{Qt::Key_oacute, "oacute"},
+{Qt::Key_ocircumflex, "ocircumflex"},
+{Qt::Key_otilde, "otilde"},
+{Qt::Key_odiaeresis, "odiaeresis"},
+{Qt::Key_division, "division"},
+{Qt::Key_oslash, "oslash"},
+{Qt::Key_ugrave, "ugrave"},
+{Qt::Key_uacute, "uacute"},
+{Qt::Key_ucircumflex, "ucircumflex"},
+{Qt::Key_udiaeresis, "udiaeresis"},
+{Qt::Key_yacute, "yacute"},
+{Qt::Key_thorn, "thorn"},
+{Qt::Key_ydiaeresis, "ydiaeresis"},
+{Qt::Key_unknown, "unknown"},
+{0,0},
+};
+
+void KeyNames::setCodeMap()
+{
+	int i;
+
+	codemap.clear();
+	for(i=0; stKeyNames[i].code != 0; i++){
+		codemap.insert(stKeyNames[i].name, stKeyNames[i].code);
+	}
+}
+
+void KeyNames::setNameMap()
+{
+	int i;
+
+	namemap.clear();
+	for(i=0; stKeyNames[i].code != 0; i++){
+		namemap.insert(stKeyNames[i].code, stKeyNames[i].name);
+	}
+}
+
+
+int KeyNames::getCode(const QString& s){
+	if(codemap.isEmpty()) setCodeMap();
+	if(codemap.contains(s)){
+		return(codemap[s]);
+	} else {
+		if(s.find("0x") == 0){
+			bool success;
+			int val = s.mid(2).toInt(&success, 16);
+			if(success){
+				return(val);
+			}
+		}
+		return(0);
+	}
+}
+
+const QString& KeyNames::getName(int code){
+	if(namemap.isEmpty()) setNameMap();
+	if(namemap.contains(code)){
+		return(namemap[code]);
+	} else {
+		tmpname.sprintf("0x%x", code);
+		return(tmpname);
+		//return(QString::null);
+	}
+}
diff --git a/noncore/applets/keyhelper/keyhelperapplet/misc/KeyNames.h b/noncore/applets/keyhelper/keyhelperapplet/misc/KeyNames.h
new file mode 100644
index 0000000..3e80763
--- a/dev/null
+++ b/noncore/applets/keyhelper/keyhelperapplet/misc/KeyNames.h
@@ -0,0 +1,37 @@
+#ifndef _KEY_NAMES_H_
+#define _KEY_NAMES_H_
+
+#include <qstring.h>
+#include <qmap.h>
+#include <qnamespace.h>
+
+class KeyNames
+{
+public:
+	static const QString& getName(int code);
+	static int getCode(const QString& s);
+
+	static void clearName(){
+		namemap.clear();
+	}
+	static void setCode(const QString& s, int code){
+		if(codemap.contains(s) == false){
+			codemap.insert(s, code);
+		}
+	}
+	static void clearCode(){
+		codemap.clear();
+	}
+	static void reset(){
+		clearCode();
+	}
+private:
+	static QMap<QString, int> codemap;
+	static QMap<int, QString> namemap;
+	static QString tmpname;
+
+	static void setCodeMap();
+	static void setNameMap();
+};
+
+#endif /* _KEY_NAMES_H_ */
diff --git a/noncore/applets/keyhelper/keyhelperapplet/misc/KeyRepeater.cpp b/noncore/applets/keyhelper/keyhelperapplet/misc/KeyRepeater.cpp
new file mode 100644
index 0000000..84a8a89
--- a/dev/null
+++ b/noncore/applets/keyhelper/keyhelperapplet/misc/KeyRepeater.cpp
@@ -0,0 +1,140 @@
+#include "KeyRepeater.h"
+
+KeyRepeater::KeyRepeater()
+{
+	qDebug("KeyRepeater::KeyRepeater()");
+	m_pTimer = new QTimer(this);
+	connect(m_pTimer, SIGNAL(timeout()), this, SLOT(autoRepeat()));
+	init();
+}
+
+KeyRepeater::~KeyRepeater()
+{
+	qDebug("KeyRepeater::~KeyRepeater()");
+	delete m_pTimer;
+}
+
+void KeyRepeater::start(int unicode, int keycode, int modifiers)
+{
+	m_unicode = unicode;
+	m_keycode = keycode;
+	m_modifiers = modifiers;
+	if(m_mode == ENABLE){
+		m_pTimer->stop();
+		if(isRepeatable(keycode)){
+			/* repeater start */
+			m_pTimer->start(m_repeatdelay, TRUE);
+		}
+	}
+}
+
+void KeyRepeater::stop(int keycode)
+{
+	if(keycode == 0
+		|| keycode == m_keycode
+		|| isRepeatable(keycode) == false){
+		m_pTimer->stop();
+	}
+}
+
+void KeyRepeater::init()
+{
+	m_mode = ENABLE;
+	m_repeatdelay = 400;
+	m_repeatperiod = 60;
+	m_disablekeys.append(0);
+	m_disablekeys.append(Qt::Key_Escape);
+	m_disablekeys.append(Qt::Key_Shift);
+	m_disablekeys.append(Qt::Key_Control);
+	m_disablekeys.append(Qt::Key_Alt);
+	m_disablekeys.append(Qt::Key_Meta);
+	for(int i=Qt::Key_F1; i<=Qt::Key_F35; i++){
+		m_disablekeys.append(i);
+	}
+}
+
+void KeyRepeater::clear()
+{
+	m_disablekeys.clear();
+}
+
+void KeyRepeater::reset()
+{
+	clear();
+	init();
+}
+
+void KeyRepeater::setRepeatable(int keycode, bool enable)
+{
+	if(enable){
+		QValueList<int>::Iterator it = m_disablekeys.find(keycode);
+		if(it != m_disablekeys.end()){
+			m_disablekeys.remove(it);
+		}
+	} else {
+		if(m_disablekeys.contains(keycode) == false){
+			m_disablekeys.append(keycode);
+		}
+	}
+}
+
+bool KeyRepeater::isRepeatable(int keycode)
+{
+	if(m_disablekeys.contains(keycode)){
+		return(false);
+	} else {
+		return(true);
+	}
+}
+
+void KeyRepeater::autoRepeat()
+{
+	/* key release event */
+#if 0
+	sendKeyEvent(
+		m_unicode,
+		m_keycode,
+		m_modifiers,
+		FALSE,
+		TRUE);
+	/* key press event */
+	sendKeyEvent(
+		m_unicode,
+		m_keycode,
+		m_modifiers,
+		TRUE,
+		TRUE);
+#else
+	emit keyEvent(
+		m_unicode,
+		m_keycode,
+		m_modifiers,
+		FALSE,
+		TRUE);
+	/* key press event */
+	emit keyEvent(
+		m_unicode,
+		m_keycode,
+		m_modifiers,
+		TRUE,
+		TRUE);
+#endif
+	/* start auto repeat */
+	m_pTimer->start(m_repeatperiod);
+#if 0
+	qDebug("autoRepeat[%x][%x][%x]",
+		m_unicode,
+		m_keycode,
+		m_modifiers);
+#endif
+}
+
+void KeyRepeater::statistics()
+{
+	qWarning("KeyRepeater::statistics()");
+	qWarning(" delay[%d] period[%d]", m_repeatdelay, m_repeatperiod);
+	for(QValueList<int>::Iterator it=m_disablekeys.begin();
+			it!=m_disablekeys.end(); ++it){
+		qDebug(" disable[%x]", *it);
+	}
+}
diff --git a/noncore/applets/keyhelper/keyhelperapplet/misc/KeyRepeater.h b/noncore/applets/keyhelper/keyhelperapplet/misc/KeyRepeater.h
new file mode 100644
index 0000000..56d6414
--- a/dev/null
+++ b/noncore/applets/keyhelper/keyhelperapplet/misc/KeyRepeater.h
@@ -0,0 +1,86 @@
+#ifndef _KEY_REPEATER_H_
+#define _KEY_REPEATER_H_
+
+#include <qobject.h>
+#include <qtimer.h>
+#include <qvaluelist.h>
+#include <qwindowsystem_qws.h>
+
+#include <syslog.h>
+
+class KeyRepeater : public QObject
+{
+	Q_OBJECT
+public:
+	KeyRepeater();
+	virtual ~KeyRepeater();
+
+	typedef enum {
+		DISABLE=0,
+		ENABLE=1,
+		KILL=2,
+	} RepeaterMode;
+
+	void start(int unicode, int keycode, int modifieres);
+	void stop(int keycode = 0);
+	void reset();
+
+	void setRepeatable(int keycode, bool enable);
+	bool isRepeatable(int keycode);
+
+	void setMode(int mode){
+		switch(mode){
+		case DISABLE:
+			m_mode = DISABLE;
+			break;
+		case ENABLE:
+			m_mode = ENABLE;
+			break;
+		case KILL:
+			m_mode = KILL;
+			break;
+		default:
+			m_mode = ENABLE;
+			break;
+		}
+	}
+	RepeaterMode getMode(){
+		return(m_mode);
+	}
+
+	void setDelay(int msec)
+	{
+		m_repeatdelay = msec;
+	}
+	void setPeriod(int msec)
+	{
+		m_repeatperiod = msec;
+	}
+
+	void statistics();
+private slots:
+	void autoRepeat();
+private:
+	int m_unicode;
+	int m_keycode;
+	int m_modifiers;
+
+	int m_repeatdelay;
+	int m_repeatperiod;
+
+	QCString m_hookChannel;
+
+	RepeaterMode m_mode;
+
+	QValueList<int> m_disablekeys;
+
+	QTimer* m_pTimer;
+
+	void init();
+	void clear();
+signals:
+	void keyEvent(int unicode, int keycode, int modifiers,
+		bool isPress, bool autoRepeat);
+};
+
+#endif /* _KEY_REPEATER_H_ */
diff --git a/noncore/applets/keyhelper/keyhelperapplet/misc/StringParser.cpp b/noncore/applets/keyhelper/keyhelperapplet/misc/StringParser.cpp
new file mode 100644
index 0000000..72c15f1
--- a/dev/null
+++ b/noncore/applets/keyhelper/keyhelperapplet/misc/StringParser.cpp
@@ -0,0 +1,72 @@
+#include "StringParser.h"
+
+#include <qregexp.h>
+
+QStringList StringParser::split(const QChar& sep, const QString& str,
+	bool allowEmptyEntries)
+{
+	QString line = str + sep;
+	QString quote;
+	QRegExp rxend;
+	QRegExp rxdbl;
+	int pos=0, len, idx=0;
+	QStringList list;
+	while(idx < (int)line.length()-1){
+		if(!quote.isEmpty()){
+			QString s;
+			while((pos = rxend.match(line, idx, &len)) != -1){
+				s += line.mid(idx, len+pos-idx-1);
+				idx = pos+len-1;
+				if(len % 2 == 0){
+					s.replace(rxdbl, quote);
+					list.append(s.left(s.length()-1));
+					idx++;
+					break;
+				}
+			}
+			quote = "";
+		} else if(line[idx] == '\"'){
+			rxend.setPattern(QString("\"+") + sep);
+			rxdbl.setPattern("\"\"");
+			quote = "\"";
+			idx++;
+		} else if(line[idx] == '\''){
+			rxend.setPattern(QString("\'+") + sep);
+			rxdbl.setPattern("\'\'");
+			quote = "\'";
+			idx++;
+		} else if(!allowEmptyEntries && line[idx] == sep){
+			idx++;
+		} else {
+			pos = line.find(sep, idx);
+			if(pos != -1){
+				const QString& s = line.mid(idx, pos-idx);
+				list.append(s);
+				idx = pos+1;
+			}
+		}
+		if(pos == -1) break;
+	}
+	return list;
+}
+
+QString StringParser::join(const QChar& sep, const QStringList& list)
+{
+	QString str;
+	QString s;
+	QStringList tmp;
+	QRegExp quote("\"");
+	for(QStringList::ConstIterator it=list.begin();
+			it!=list.end(); ++it){
+		s = *it;
+		if(s.find(sep) != -1
+			|| s[0] == '\"'
+			|| s[0] == '\''){
+			s.replace(quote, "\"\"");
+			tmp.append("\"" + s + "\"");
+		} else {
+			tmp.append(s);
+		}
+	}
+	return tmp.join(sep);
+}
diff --git a/noncore/applets/keyhelper/keyhelperapplet/misc/StringParser.h b/noncore/applets/keyhelper/keyhelperapplet/misc/StringParser.h
new file mode 100644
index 0000000..8c1dc58
--- a/dev/null
+++ b/noncore/applets/keyhelper/keyhelperapplet/misc/StringParser.h
@@ -0,0 +1,14 @@
+#ifndef _STRING_PARSER_H_
+#define _STRING_PARSER_H_
+
+#include <qstringlist.h>
+
+class StringParser
+{
+public:
+	static QStringList split(const QChar& sep, const QString& str,
+		bool allowEmptyEntries=FALSE);
+	static QString join(const QChar& sep, const QStringList& list);
+};
+
+#endif /* _STRING_PARSER_H_ */
diff --git a/noncore/applets/keyhelper/keyhelperconf/KHCWidget.cpp b/noncore/applets/keyhelper/keyhelperconf/KHCWidget.cpp
new file mode 100644
index 0000000..b0767cf
--- a/dev/null
+++ b/noncore/applets/keyhelper/keyhelperconf/KHCWidget.cpp
@@ -0,0 +1,307 @@
+#include "KHCWidget.h"
+
+KHCWidget::KHCWidget(QWidget* parent, const char* name, WFlags fl)
+	: KHCWidgetBase(parent, name, fl)
+{
+	m_isEnable = true;
+	setLayout();
+	setHandler();
+
+	txtOrgKey->installEventFilter(this);
+	txtMapKey->installEventFilter(this);
+}
+
+KHCWidget::~KHCWidget()
+{
+}
+
+void KHCWidget::setLayout()
+{
+	QBoxLayout* topLayout = new QVBoxLayout(this, 5);
+
+	QBoxLayout* orgLayout1 = new QHBoxLayout(topLayout);
+	orgLayout1->addWidget(lblOriginal);
+	orgLayout1->addWidget(txtOrgKey);
+
+	QBoxLayout* orgLayout2 = new QHBoxLayout(topLayout);
+	orgLayout2->addWidget(lblOrgK);
+	orgLayout2->addWidget(lblOrgKeycode);
+#if 0
+	orgLayout2->addWidget(lblOrgM);
+	orgLayout2->addWidget(lblOrgModifiers);
+#endif
+	orgLayout2->addWidget(lblOrgU);
+	orgLayout2->addWidget(lblOrgUnicode);
+	orgLayout2->addWidget(chkOrgShift);
+	orgLayout2->addWidget(chkOrgCtrl);
+	orgLayout2->addWidget(chkOrgAlt);
+
+	QBoxLayout* mapLayout1 = new QHBoxLayout(topLayout);
+	mapLayout1->addWidget(lblMapping);
+	mapLayout1->addWidget(txtMapKey);
+
+	QBoxLayout* mapLayout2 = new QHBoxLayout(topLayout);
+	mapLayout2->addWidget(lblMapK);
+	mapLayout2->addWidget(lblMapKeycode);
+#if 0
+	mapLayout2->addWidget(lblMapM);
+	mapLayout2->addWidget(lblMapModifiers);
+#endif
+	mapLayout2->addWidget(lblMapU);
+	mapLayout2->addWidget(lblMapUnicode);
+	mapLayout2->addWidget(chkMapShift);
+	mapLayout2->addWidget(chkMapCtrl);
+	mapLayout2->addWidget(chkMapAlt);
+
+	QBoxLayout* btnLayout = new QHBoxLayout(topLayout);
+	btnLayout->addWidget(btnGen);
+	btnLayout->addWidget(btnCopy);
+	btnLayout->addWidget(btnCtrl);
+
+	topLayout->addWidget(mleDefine);
+}
+
+void KHCWidget::setHandler()
+{
+	connect(btnGen, SIGNAL(clicked()), this, SLOT(onClick_Gen()));
+	connect(btnCopy, SIGNAL(clicked()), this, SLOT(onClick_Copy()));
+	connect(btnCtrl, SIGNAL(clicked()), this, SLOT(onClick_Ctrl()));
+}
+
+bool KHCWidget::eventFilter(QObject* o, QEvent* e)
+{
+	if(::strcmp(o->name(), "txtOrgKey") == 0){
+		if(e->type() == QEvent::KeyPress){
+			QKeyEvent* ke = (QKeyEvent*)e;
+			if(ke->isAutoRepeat() == false){
+				onPress_Org(ke);
+			}
+			return(true);
+		}
+	} else if(::strcmp(o->name(), "txtMapKey") == 0){
+		if(e->type() == QEvent::KeyPress){
+			QKeyEvent* ke = (QKeyEvent*)e;
+			if(ke->isAutoRepeat() == false){
+				onPress_Map(ke);
+			}
+			return(true);
+		}
+	}
+
+	return QWidget::eventFilter(o, e);
+}
+
+void KHCWidget::onPress_Org(QKeyEvent* ke)
+{
+	/* keycode */
+	const QString& name = KeyNames::getName(ke->key());
+	if(name == QString::null){
+		lblOrgKeycode->setText(QString::number(ke->key(), 16));
+	} else {
+		lblOrgKeycode->setText(name);
+	}
+	/* modifiers */
+	chkOrgShift->setChecked(ke->state() & Qt::ShiftButton);
+	chkOrgCtrl->setChecked(ke->state() & Qt::ControlButton);
+	chkOrgAlt->setChecked(ke->state() & Qt::AltButton);
+
+	/* unicode */
+	if(ke->text()[0].isPrint()){
+		lblOrgUnicode->setText(ke->text());
+	} else {
+		lblOrgUnicode->setText(QString::number(ke->ascii(), 16));
+	}
+	m_OrgkeyData.setData(ke);
+}
+
+void KHCWidget::onPress_Map(QKeyEvent* ke)
+{
+	/* keycode */
+	const QString& name = KeyNames::getName(ke->key());
+	if(name == QString::null){
+		lblMapKeycode->setText(QString::number(ke->key(), 16));
+	} else {
+		lblMapKeycode->setText(name);
+	}
+	/* modifiers */
+	chkMapShift->setChecked(ke->state() & Qt::ShiftButton);
+	chkMapCtrl->setChecked(ke->state() & Qt::ControlButton);
+	chkMapAlt->setChecked(ke->state() & Qt::AltButton);
+
+	/* unicode */
+	if(ke->text()[0].isPrint()){
+		lblMapUnicode->setText(ke->text());
+	} else {
+		lblMapUnicode->setText(QString::number(ke->ascii(), 16));
+	}
+	m_MapkeyData.setData(ke);
+}
+
+void KHCWidget::onClick_Gen()
+{
+	mleDefine->clear();
+	if(m_OrgkeyData.key == 0
+		|| m_MapkeyData.key == 0){
+		return;
+	}
+	/* original key */
+	QString line;
+	const QString& name = KeyNames::getName(m_OrgkeyData.key);
+	line = "<define ";
+	if(name == QString::null){
+		line.append("code=\"");
+		line.append(QString::number(m_OrgkeyData.key, 16));
+	} else {
+		line.append("key=\"");
+		line.append(name);
+	}
+	line.append("\">");
+	mleDefine->append(line);
+
+	/* original modifiers */
+	bool need = false;
+	line = "<modifier";
+	if(chkOrgShift->isChecked()){
+		line.append(" Shift=\"On\"");
+		need = true;
+	}
+	if(chkOrgCtrl->isChecked()){
+		line.append(" Control=\"On\"");
+		need = true;
+	}
+	if(chkOrgAlt->isChecked()){
+		line.append(" Alt=\"On\"");
+		need = true;
+	}
+	line.append("/>");
+	if(need){
+		mleDefine->append(line);
+	}
+
+	/* mapping key */
+	const QString& mapname = KeyNames::getName(m_MapkeyData.key);
+	line = "<map";
+	if(mapname == QString::null){
+		line.append(" code=\"");
+		line.append(QString::number(m_MapkeyData.key, 16));
+	} else {
+		line.append(" key=\"");
+		line.append(mapname);
+	}
+	line.append("\"/>");
+	mleDefine->append(line);
+
+	/* mapping modifiers */
+	need = false;
+	line = "<map_modifier";
+	bool on = chkMapShift->isChecked();
+	if(chkOrgShift->isChecked() != on){
+		line.append(" Shift=\"");
+		if(on){
+			line.append("On\"");
+		} else {
+			line.append("Off\"");
+		}
+		need = true;
+	}
+	on = chkMapCtrl->isChecked();
+	if(chkOrgCtrl->isChecked() != on){
+		line.append(" Control=\"");
+		if(on){
+			line.append("On\"");
+		} else {
+			line.append("Off\"");
+		}
+		need = true;
+	}
+	on = chkMapAlt->isChecked();
+	if(chkOrgAlt->isChecked() != on){
+		line.append(" Alt=\"");
+		if(on){
+			line.append("On\"");
+		} else {
+			line.append("Off\"");
+		}
+		need = true;
+	}
+	line.append("/>");
+	if(need){
+		mleDefine->append(line);
+	}
+
+	/* mapping unicode */
+	bool found = false;
+	for(const QWSServer::KeyMap* m = QWSServer::keyMap();
+			m->key_code != 0; m++){
+		if(m->key_code == m_MapkeyData.key){
+			if(m_MapkeyData.state & Qt::ControlButton){
+				if(m->ctrl_unicode == m_MapkeyData.ascii){
+					found = true;
+					break;
+				}
+			} else if(m_MapkeyData.state & Qt::ShiftButton){
+				if(m->shift_unicode == m_MapkeyData.ascii){
+					found = true;
+					break;
+				}
+			} else {
+				if(m->unicode == m_MapkeyData.ascii){
+					found = true;
+					break;
+				}
+			}
+		}
+	}
+	if(found == false){
+		if(m_MapkeyData.text[0].isPrint()){
+			line = "<map_unicode";
+			if(m_MapkeyData.state & Qt::ControlButton){
+				line.append(" ctrl_unicode=\"");
+			} else if(m_MapkeyData.state & Qt::ShiftButton){
+				line.append(" shift_unicode=\"");
+			} else {
+				line.append(" unicode=\"");
+			}
+			line.append(m_MapkeyData.text);
+			line.append("\"/>");
+			mleDefine->append(line);
+		} else {
+			mleDefine->clear();
+			mleDefine->append("Not Support");
+			return;
+		}
+	}
+
+	/* close tag */
+	line = "</define>";
+	mleDefine->append(line);
+}
+
+void KHCWidget::onClick_Copy()
+{
+	mleDefine->selectAll();
+	mleDefine->copy();
+	mleDefine->deselect();
+}
+
+void KHCWidget::onClick_Ctrl()
+{
+	if(m_isEnable){
+		QCopEnvelope e("QPE/KeyHelper", "disable()");
+		btnCtrl->setText(tr("Enable"));
+		//btnCtrl->update();
+	} else {
+		QCopEnvelope e("QPE/KeyHelper", "enable()");
+		btnCtrl->setText(tr("Disable"));
+		//btnCtrl->update();
+	}
+	m_isEnable = !m_isEnable;
+}
+
+void KHCWidget::closeEvent(QCloseEvent* ce)
+{
+	qDebug("closeEvent()");
+	QCopEnvelope e("QPE/KeyHelper", "enable()");
+	ce->accept();
+}
+
diff --git a/noncore/applets/keyhelper/keyhelperconf/KHCWidget.h b/noncore/applets/keyhelper/keyhelperconf/KHCWidget.h
new file mode 100644
index 0000000..08b29b3
--- a/dev/null
+++ b/noncore/applets/keyhelper/keyhelperconf/KHCWidget.h
@@ -0,0 +1,68 @@
+#ifndef _KHC_WIDGET_H_
+#define _KHC_WIDGET_H_
+
+#include <stdlib.h>
+
+#include <qlabel.h>
+#include <qpushbutton.h>
+#include <qlineedit.h>
+#include <qmultilineedit.h>
+#include <qgroupbox.h>
+#include <qcheckbox.h>
+#include <qlayout.h>
+
+#include <qwindowsystem_qws.h>
+
+#include <qpe/qcopenvelope_qws.h>
+
+#include "KHCWidgetBase.h"
+#include "KeyNames.h"
+
+struct KeyData
+{
+	KeyData(){
+		key = 0;
+		state = 0;
+		ascii = 0;
+	}
+	void setData(QKeyEvent* ke) {
+		key = ke->key();
+		state = ke->state();
+		ascii = ke->ascii();
+		text = ke->text();
+	}
+	int key;
+	int state;
+	int ascii;
+	QString text;
+};
+
+class KHCWidget : public KHCWidgetBase
+{
+	Q_OBJECT
+public:
+	KHCWidget(QWidget* parent=0, const char* name=0, WFlags fl=0);
+	virtual ~KHCWidget();
+
+protected:
+	void closeEvent(QCloseEvent* ce);
+
+private:
+	void setLayout();
+	void setHandler();
+
+	void onPress_Org(QKeyEvent* ke);
+	void onPress_Map(QKeyEvent* ke);
+
+	bool eventFilter(QObject* o, QEvent* e);
+
+	bool m_isEnable;
+	KeyData m_OrgkeyData;
+	KeyData m_MapkeyData;
+private slots:
+	void onClick_Gen();
+	void onClick_Copy();
+	void onClick_Ctrl();
+};
+
+#endif /* _KHC_WIDGET_H_ */
diff --git a/noncore/applets/keyhelper/keyhelperconf/KHCWidgetBase.cpp b/noncore/applets/keyhelper/keyhelperconf/KHCWidgetBase.cpp
new file mode 100644
index 0000000..16841f1
--- a/dev/null
+++ b/noncore/applets/keyhelper/keyhelperconf/KHCWidgetBase.cpp
@@ -0,0 +1,162 @@
+/****************************************************************************
+** Form implementation generated from reading ui file 'KHCWidgetBase.ui'
+**
+** Created: Mon Feb 28 09:58:22 2005
+**      by:  The User Interface Compiler (uic)
+**
+** WARNING! All changes made in this file will be lost!
+****************************************************************************/
+#include "KHCWidgetBase.h"
+
+#include <qcheckbox.h>
+#include <qlabel.h>
+#include <qlineedit.h>
+#include <qmultilineedit.h>
+#include <qpushbutton.h>
+#include <qlayout.h>
+#include <qvariant.h>
+#include <qtooltip.h>
+#include <qwhatsthis.h>
+
+/* 
+ *  Constructs a KHCWidgetBase which is a child of 'parent', with the 
+ *  name 'name' and widget flags set to 'f' 
+ */
+KHCWidgetBase::KHCWidgetBase( QWidget* parent,  const char* name, WFlags fl )
+    : QWidget( parent, name, fl )
+{
+    if ( !name )
+	setName( "KHCWidgetBase" );
+    resize( 431, 388 ); 
+    setCaption( tr( "KeyHelperConf" ) );
+
+    btnCtrl = new QPushButton( this, "btnCtrl" );
+    btnCtrl->setGeometry( QRect( 280, 150, 121, 31 ) ); 
+    btnCtrl->setText( tr( "Disable" ) );
+
+    btnGen = new QPushButton( this, "btnGen" );
+    btnGen->setGeometry( QRect( 10, 150, 110, 31 ) ); 
+    btnGen->setText( tr( "Generate" ) );
+
+    btnCopy = new QPushButton( this, "btnCopy" );
+    btnCopy->setGeometry( QRect( 140, 150, 121, 31 ) ); 
+    btnCopy->setText( tr( "Copy" ) );
+
+    lblOrgK = new QLabel( this, "lblOrgK" );
+    lblOrgK->setGeometry( QRect( 20, 50, 50, 20 ) ); 
+    lblOrgK->setText( tr( "K" ) );
+
+    lblMapK = new QLabel( this, "lblMapK" );
+    lblMapK->setGeometry( QRect( 20, 120, 20, 20 ) ); 
+    lblMapK->setText( tr( "K" ) );
+
+    lblMapKeycode = new QLabel( this, "lblMapKeycode" );
+    lblMapKeycode->setGeometry( QRect( 40, 120, 80, 21 ) ); 
+    lblMapKeycode->setSizePolicy( QSizePolicy( (QSizePolicy::SizeType)7, (QSizePolicy::SizeType)1, lblMapKeycode->sizePolicy().hasHeightForWidth() ) );
+    lblMapKeycode->setFrameShape( QLabel::Panel );
+    lblMapKeycode->setFrameShadow( QLabel::Sunken );
+    lblMapKeycode->setText( tr( "keycode" ) );
+
+    txtMapKey = new QLineEdit( this, "txtMapKey" );
+    txtMapKey->setGeometry( QRect( 200, 80, 200, 22 ) ); 
+
+    txtOrgKey = new QLineEdit( this, "txtOrgKey" );
+    txtOrgKey->setGeometry( QRect( 190, 10, 200, 22 ) ); 
+
+    lblOriginal = new QLabel( this, "lblOriginal" );
+    lblOriginal->setGeometry( QRect( 10, 10, 120, 31 ) ); 
+    lblOriginal->setFrameShape( QLabel::Box );
+    lblOriginal->setFrameShadow( QLabel::Raised );
+    lblOriginal->setText( tr( "Original Key" ) );
+
+    lblMapping = new QLabel( this, "lblMapping" );
+    lblMapping->setGeometry( QRect( 10, 80, 120, 21 ) ); 
+    lblMapping->setFrameShape( QLabel::Box );
+    lblMapping->setFrameShadow( QLabel::Raised );
+    lblMapping->setText( tr( "Mapping Key" ) );
+
+    mleDefine = new QMultiLineEdit( this, "mleDefine" );
+    mleDefine->setGeometry( QRect( 10, 200, 391, 110 ) ); 
+    mleDefine->setReadOnly( TRUE );
+
+    lblOrgKeycode = new QLabel( this, "lblOrgKeycode" );
+    lblOrgKeycode->setGeometry( QRect( 50, 50, 70, 21 ) ); 
+    lblOrgKeycode->setSizePolicy( QSizePolicy( (QSizePolicy::SizeType)7, (QSizePolicy::SizeType)1, lblOrgKeycode->sizePolicy().hasHeightForWidth() ) );
+    lblOrgKeycode->setFrameShape( QLabel::Panel );
+    lblOrgKeycode->setFrameShadow( QLabel::Sunken );
+    lblOrgKeycode->setText( tr( "keycode" ) );
+
+    lblOrgU = new QLabel( this, "lblOrgU" );
+    lblOrgU->setGeometry( QRect( 130, 50, 20, 21 ) ); 
+    lblOrgU->setText( tr( "U" ) );
+
+    lblOrgUnicode = new QLabel( this, "lblOrgUnicode" );
+    lblOrgUnicode->setGeometry( QRect( 150, 50, 80, 21 ) ); 
+    lblOrgUnicode->setSizePolicy( QSizePolicy( (QSizePolicy::SizeType)7, (QSizePolicy::SizeType)1, lblOrgUnicode->sizePolicy().hasHeightForWidth() ) );
+    lblOrgUnicode->setFrameShape( QLabel::Panel );
+    lblOrgUnicode->setFrameShadow( QLabel::Sunken );
+    lblOrgUnicode->setText( tr( "unicode" ) );
+
+    lblMapU = new QLabel( this, "lblMapU" );
+    lblMapU->setGeometry( QRect( 130, 120, 20, 21 ) ); 
+    lblMapU->setText( tr( "U" ) );
+
+    lblMapUnicode = new QLabel( this, "lblMapUnicode" );
+    lblMapUnicode->setGeometry( QRect( 150, 120, 80, 21 ) ); 
+    lblMapUnicode->setSizePolicy( QSizePolicy( (QSizePolicy::SizeType)7, (QSizePolicy::SizeType)1, lblMapUnicode->sizePolicy().hasHeightForWidth() ) );
+    lblMapUnicode->setFrameShape( QLabel::Panel );
+    lblMapUnicode->setFrameShadow( QLabel::Sunken );
+    lblMapUnicode->setText( tr( "unicode" ) );
+
+    chkMapShift = new QCheckBox( this, "chkMapShift" );
+    chkMapShift->setGeometry( QRect( 260, 120, 33, 19 ) ); 
+    chkMapShift->setText( tr( "S" ) );
+    chkMapShift->setAutoResize( TRUE );
+
+    chkMapCtrl = new QCheckBox( this, "chkMapCtrl" );
+    chkMapCtrl->setGeometry( QRect( 310, 120, 34, 19 ) ); 
+    chkMapCtrl->setText( tr( "C" ) );
+    chkMapCtrl->setAutoResize( TRUE );
+
+    chkMapAlt = new QCheckBox( this, "chkMapAlt" );
+    chkMapAlt->setGeometry( QRect( 360, 120, 34, 19 ) ); 
+    chkMapAlt->setText( tr( "A" ) );
+    chkMapAlt->setAutoResize( TRUE );
+
+    chkOrgShift = new QCheckBox( this, "chkOrgShift" );
+    chkOrgShift->setGeometry( QRect( 250, 50, 33, 19 ) ); 
+    chkOrgShift->setText( tr( "S" ) );
+    chkOrgShift->setAutoResize( TRUE );
+
+    chkOrgCtrl = new QCheckBox( this, "chkOrgCtrl" );
+    chkOrgCtrl->setGeometry( QRect( 300, 50, 34, 19 ) ); 
+    chkOrgCtrl->setText( tr( "C" ) );
+    chkOrgCtrl->setAutoResize( TRUE );
+
+    chkOrgAlt = new QCheckBox( this, "chkOrgAlt" );
+    chkOrgAlt->setGeometry( QRect( 350, 50, 34, 19 ) ); 
+    chkOrgAlt->setText( tr( "A" ) );
+    chkOrgAlt->setAutoResize( TRUE );
+
+    // tab order
+    setTabOrder( txtOrgKey, chkOrgShift );
+    setTabOrder( chkOrgShift, chkOrgCtrl );
+    setTabOrder( chkOrgCtrl, chkOrgAlt );
+    setTabOrder( chkOrgAlt, txtMapKey );
+    setTabOrder( txtMapKey, chkMapShift );
+    setTabOrder( chkMapShift, chkMapCtrl );
+    setTabOrder( chkMapCtrl, chkMapAlt );
+    setTabOrder( chkMapAlt, btnGen );
+    setTabOrder( btnGen, btnCopy );
+    setTabOrder( btnCopy, btnCtrl );
+    setTabOrder( btnCtrl, mleDefine );
+}
+
+/*  
+ *  Destroys the object and frees any allocated resources
+ */
+KHCWidgetBase::~KHCWidgetBase()
+{
+    // no need to delete child widgets, Qt does it all for us
+}
+
diff --git a/noncore/applets/keyhelper/keyhelperconf/KHCWidgetBase.h b/noncore/applets/keyhelper/keyhelperconf/KHCWidgetBase.h
new file mode 100644
index 0000000..8193b61
--- a/dev/null
+++ b/noncore/applets/keyhelper/keyhelperconf/KHCWidgetBase.h
@@ -0,0 +1,56 @@
+/****************************************************************************
+** Form interface generated from reading ui file 'KHCWidgetBase.ui'
+**
+** Created: Mon Feb 28 09:54:07 2005
+**      by:  The User Interface Compiler (uic)
+**
+** WARNING! All changes made in this file will be lost!
+****************************************************************************/
+#ifndef KHCWIDGETBASE_H
+#define KHCWIDGETBASE_H
+
+#include <qvariant.h>
+#include <qwidget.h>
+class QVBoxLayout; 
+class QHBoxLayout; 
+class QGridLayout; 
+class QCheckBox;
+class QLabel;
+class QLineEdit;
+class QMultiLineEdit;
+class QPushButton;
+
+class KHCWidgetBase : public QWidget
+{ 
+    Q_OBJECT
+
+public:
+    KHCWidgetBase( QWidget* parent = 0, const char* name = 0, WFlags fl = 0 );
+    ~KHCWidgetBase();
+
+    QPushButton* btnCtrl;
+    QPushButton* btnGen;
+    QPushButton* btnCopy;
+    QLabel* lblOrgK;
+    QLabel* lblMapK;
+    QLabel* lblMapKeycode;
+    QLineEdit* txtMapKey;
+    QLineEdit* txtOrgKey;
+    QLabel* lblOriginal;
+    QLabel* lblMapping;
+    QMultiLineEdit* mleDefine;
+    QLabel* lblOrgKeycode;
+    QLabel* lblOrgU;
+    QLabel* lblOrgUnicode;
+    QLabel* lblMapU;
+    QLabel* lblMapUnicode;
+    QCheckBox* chkMapShift;
+    QCheckBox* chkMapCtrl;
+    QCheckBox* chkMapAlt;
+    QCheckBox* chkOrgShift;
+    QCheckBox* chkOrgCtrl;
+    QCheckBox* chkOrgAlt;
+
+};
+
+#endif // KHCWIDGETBASE_H
diff --git a/noncore/applets/keyhelper/keyhelperconf/KHCWidgetBase.ui b/noncore/applets/keyhelper/keyhelperconf/KHCWidgetBase.ui
new file mode 100644
index 0000000..2be0772
--- a/dev/null
+++ b/noncore/applets/keyhelper/keyhelperconf/KHCWidgetBase.ui
@@ -0,0 +1,569 @@
+<!DOCTYPE UI><UI>
+<class>KHCWidgetBase</class>
+<widget>
+    <class>QWidget</class>
+    <property stdset="1">
+        <name>name</name>
+        <cstring>KHCWidgetBase</cstring>
+    </property>
+    <property stdset="1">
+        <name>geometry</name>
+        <rect>
+            <x>0</x>
+            <y>0</y>
+            <width>431</width>
+            <height>388</height>
+        </rect>
+    </property>
+    <property stdset="1">
+        <name>caption</name>
+        <string>KeyHelperConf</string>
+    </property>
+    <widget>
+        <class>QPushButton</class>
+        <property stdset="1">
+            <name>name</name>
+            <cstring>btnCtrl</cstring>
+        </property>
+        <property stdset="1">
+            <name>geometry</name>
+            <rect>
+                <x>280</x>
+                <y>150</y>
+                <width>121</width>
+                <height>31</height>
+            </rect>
+        </property>
+        <property stdset="1">
+            <name>text</name>
+            <string>Disable</string>
+        </property>
+    </widget>
+    <widget>
+        <class>QPushButton</class>
+        <property stdset="1">
+            <name>name</name>
+            <cstring>btnGen</cstring>
+        </property>
+        <property stdset="1">
+            <name>geometry</name>
+            <rect>
+                <x>10</x>
+                <y>150</y>
+                <width>110</width>
+                <height>31</height>
+            </rect>
+        </property>
+        <property stdset="1">
+            <name>text</name>
+            <string>Generate</string>
+        </property>
+    </widget>
+    <widget>
+        <class>QPushButton</class>
+        <property stdset="1">
+            <name>name</name>
+            <cstring>btnCopy</cstring>
+        </property>
+        <property stdset="1">
+            <name>geometry</name>
+            <rect>
+                <x>140</x>
+                <y>150</y>
+                <width>121</width>
+                <height>31</height>
+            </rect>
+        </property>
+        <property stdset="1">
+            <name>text</name>
+            <string>Copy</string>
+        </property>
+    </widget>
+    <widget>
+        <class>QLabel</class>
+        <property stdset="1">
+            <name>name</name>
+            <cstring>lblOrgK</cstring>
+        </property>
+        <property stdset="1">
+            <name>geometry</name>
+            <rect>
+                <x>20</x>
+                <y>50</y>
+                <width>50</width>
+                <height>20</height>
+            </rect>
+        </property>
+        <property stdset="1">
+            <name>text</name>
+            <string>K</string>
+        </property>
+    </widget>
+    <widget>
+        <class>QLabel</class>
+        <property stdset="1">
+            <name>name</name>
+            <cstring>lblMapK</cstring>
+        </property>
+        <property stdset="1">
+            <name>geometry</name>
+            <rect>
+                <x>20</x>
+                <y>120</y>
+                <width>20</width>
+                <height>20</height>
+            </rect>
+        </property>
+        <property stdset="1">
+            <name>text</name>
+            <string>K</string>
+        </property>
+    </widget>
+    <widget>
+        <class>QLabel</class>
+        <property stdset="1">
+            <name>name</name>
+            <cstring>lblMapKeycode</cstring>
+        </property>
+        <property stdset="1">
+            <name>geometry</name>
+            <rect>
+                <x>40</x>
+                <y>120</y>
+                <width>80</width>
+                <height>21</height>
+            </rect>
+        </property>
+        <property stdset="1">
+            <name>sizePolicy</name>
+            <sizepolicy>
+                <hsizetype>7</hsizetype>
+                <vsizetype>1</vsizetype>
+            </sizepolicy>
+        </property>
+        <property stdset="1">
+            <name>frameShape</name>
+            <enum>Panel</enum>
+        </property>
+        <property stdset="1">
+            <name>frameShadow</name>
+            <enum>Sunken</enum>
+        </property>
+        <property stdset="1">
+            <name>text</name>
+            <string>keycode</string>
+        </property>
+    </widget>
+    <widget>
+        <class>QLineEdit</class>
+        <property stdset="1">
+            <name>name</name>
+            <cstring>txtMapKey</cstring>
+        </property>
+        <property stdset="1">
+            <name>geometry</name>
+            <rect>
+                <x>200</x>
+                <y>80</y>
+                <width>200</width>
+                <height>22</height>
+            </rect>
+        </property>
+    </widget>
+    <widget>
+        <class>QLineEdit</class>
+        <property stdset="1">
+            <name>name</name>
+            <cstring>txtOrgKey</cstring>
+        </property>
+        <property stdset="1">
+            <name>geometry</name>
+            <rect>
+                <x>190</x>
+                <y>10</y>
+                <width>200</width>
+                <height>22</height>
+            </rect>
+        </property>
+    </widget>
+    <widget>
+        <class>QLabel</class>
+        <property stdset="1">
+            <name>name</name>
+            <cstring>lblOriginal</cstring>
+        </property>
+        <property stdset="1">
+            <name>geometry</name>
+            <rect>
+                <x>10</x>
+                <y>10</y>
+                <width>120</width>
+                <height>31</height>
+            </rect>
+        </property>
+        <property stdset="1">
+            <name>frameShape</name>
+            <enum>Box</enum>
+        </property>
+        <property stdset="1">
+            <name>frameShadow</name>
+            <enum>Raised</enum>
+        </property>
+        <property stdset="1">
+            <name>text</name>
+            <string>Original Key</string>
+        </property>
+    </widget>
+    <widget>
+        <class>QLabel</class>
+        <property stdset="1">
+            <name>name</name>
+            <cstring>lblMapping</cstring>
+        </property>
+        <property stdset="1">
+            <name>geometry</name>
+            <rect>
+                <x>10</x>
+                <y>80</y>
+                <width>120</width>
+                <height>21</height>
+            </rect>
+        </property>
+        <property stdset="1">
+            <name>frameShape</name>
+            <enum>Box</enum>
+        </property>
+        <property stdset="1">
+            <name>frameShadow</name>
+            <enum>Raised</enum>
+        </property>
+        <property stdset="1">
+            <name>text</name>
+            <string>Mapping Key</string>
+        </property>
+    </widget>
+    <widget>
+        <class>QMultiLineEdit</class>
+        <property stdset="1">
+            <name>name</name>
+            <cstring>mleDefine</cstring>
+        </property>
+        <property stdset="1">
+            <name>geometry</name>
+            <rect>
+                <x>10</x>
+                <y>200</y>
+                <width>391</width>
+                <height>110</height>
+            </rect>
+        </property>
+        <property stdset="1">
+            <name>readOnly</name>
+            <bool>true</bool>
+        </property>
+    </widget>
+    <widget>
+        <class>QLabel</class>
+        <property stdset="1">
+            <name>name</name>
+            <cstring>lblOrgKeycode</cstring>
+        </property>
+        <property stdset="1">
+            <name>geometry</name>
+            <rect>
+                <x>50</x>
+                <y>50</y>
+                <width>70</width>
+                <height>21</height>
+            </rect>
+        </property>
+        <property stdset="1">
+            <name>sizePolicy</name>
+            <sizepolicy>
+                <hsizetype>7</hsizetype>
+                <vsizetype>1</vsizetype>
+            </sizepolicy>
+        </property>
+        <property stdset="1">
+            <name>frameShape</name>
+            <enum>Panel</enum>
+        </property>
+        <property stdset="1">
+            <name>frameShadow</name>
+            <enum>Sunken</enum>
+        </property>
+        <property stdset="1">
+            <name>text</name>
+            <string>keycode</string>
+        </property>
+    </widget>
+    <widget>
+        <class>QLabel</class>
+        <property stdset="1">
+            <name>name</name>
+            <cstring>lblOrgU</cstring>
+        </property>
+        <property stdset="1">
+            <name>geometry</name>
+            <rect>
+                <x>130</x>
+                <y>50</y>
+                <width>20</width>
+                <height>21</height>
+            </rect>
+        </property>
+        <property stdset="1">
+            <name>text</name>
+            <string>U</string>
+        </property>
+    </widget>
+    <widget>
+        <class>QLabel</class>
+        <property stdset="1">
+            <name>name</name>
+            <cstring>lblOrgUnicode</cstring>
+        </property>
+        <property stdset="1">
+            <name>geometry</name>
+            <rect>
+                <x>150</x>
+                <y>50</y>
+                <width>80</width>
+                <height>21</height>
+            </rect>
+        </property>
+        <property stdset="1">
+            <name>sizePolicy</name>
+            <sizepolicy>
+                <hsizetype>7</hsizetype>
+                <vsizetype>1</vsizetype>
+            </sizepolicy>
+        </property>
+        <property stdset="1">
+            <name>frameShape</name>
+            <enum>Panel</enum>
+        </property>
+        <property stdset="1">
+            <name>frameShadow</name>
+            <enum>Sunken</enum>
+        </property>
+        <property stdset="1">
+            <name>text</name>
+            <string>unicode</string>
+        </property>
+    </widget>
+    <widget>
+        <class>QLabel</class>
+        <property stdset="1">
+            <name>name</name>
+            <cstring>lblMapU</cstring>
+        </property>
+        <property stdset="1">
+            <name>geometry</name>
+            <rect>
+                <x>130</x>
+                <y>120</y>
+                <width>20</width>
+                <height>21</height>
+            </rect>
+        </property>
+        <property stdset="1">
+            <name>text</name>
+            <string>U</string>
+        </property>
+    </widget>
+    <widget>
+        <class>QLabel</class>
+        <property stdset="1">
+            <name>name</name>
+            <cstring>lblMapUnicode</cstring>
+        </property>
+        <property stdset="1">
+            <name>geometry</name>
+            <rect>
+                <x>150</x>
+                <y>120</y>
+                <width>80</width>
+                <height>21</height>
+            </rect>
+        </property>
+        <property stdset="1">
+            <name>sizePolicy</name>
+            <sizepolicy>
+                <hsizetype>7</hsizetype>
+                <vsizetype>1</vsizetype>
+            </sizepolicy>
+        </property>
+        <property stdset="1">
+            <name>frameShape</name>
+            <enum>Panel</enum>
+        </property>
+        <property stdset="1">
+            <name>frameShadow</name>
+            <enum>Sunken</enum>
+        </property>
+        <property stdset="1">
+            <name>text</name>
+            <string>unicode</string>
+        </property>
+    </widget>
+    <widget>
+        <class>QCheckBox</class>
+        <property stdset="1">
+            <name>name</name>
+            <cstring>chkMapShift</cstring>
+        </property>
+        <property stdset="1">
+            <name>geometry</name>
+            <rect>
+                <x>260</x>
+                <y>120</y>
+                <width>33</width>
+                <height>19</height>
+            </rect>
+        </property>
+        <property stdset="1">
+            <name>text</name>
+            <string>S</string>
+        </property>
+        <property stdset="1">
+            <name>autoResize</name>
+            <bool>true</bool>
+        </property>
+    </widget>
+    <widget>
+        <class>QCheckBox</class>
+        <property stdset="1">
+            <name>name</name>
+            <cstring>chkMapCtrl</cstring>
+        </property>
+        <property stdset="1">
+            <name>geometry</name>
+            <rect>
+                <x>310</x>
+                <y>120</y>
+                <width>34</width>
+                <height>19</height>
+            </rect>
+        </property>
+        <property stdset="1">
+            <name>text</name>
+            <string>C</string>
+        </property>
+        <property stdset="1">
+            <name>autoResize</name>
+            <bool>true</bool>
+        </property>
+    </widget>
+    <widget>
+        <class>QCheckBox</class>
+        <property stdset="1">
+            <name>name</name>
+            <cstring>chkMapAlt</cstring>
+        </property>
+        <property stdset="1">
+            <name>geometry</name>
+            <rect>
+                <x>360</x>
+                <y>120</y>
+                <width>34</width>
+                <height>19</height>
+            </rect>
+        </property>
+        <property stdset="1">
+            <name>text</name>
+            <string>A</string>
+        </property>
+        <property stdset="1">
+            <name>autoResize</name>
+            <bool>true</bool>
+        </property>
+    </widget>
+    <widget>
+        <class>QCheckBox</class>
+        <property stdset="1">
+            <name>name</name>
+            <cstring>chkOrgShift</cstring>
+        </property>
+        <property stdset="1">
+            <name>geometry</name>
+            <rect>
+                <x>250</x>
+                <y>50</y>
+                <width>33</width>
+                <height>19</height>
+            </rect>
+        </property>
+        <property stdset="1">
+            <name>text</name>
+            <string>S</string>
+        </property>
+        <property stdset="1">
+            <name>autoResize</name>
+            <bool>true</bool>
+        </property>
+    </widget>
+    <widget>
+        <class>QCheckBox</class>
+        <property stdset="1">
+            <name>name</name>
+            <cstring>chkOrgCtrl</cstring>
+        </property>
+        <property stdset="1">
+            <name>geometry</name>
+            <rect>
+                <x>300</x>
+                <y>50</y>
+                <width>34</width>
+                <height>19</height>
+            </rect>
+        </property>
+        <property stdset="1">
+            <name>text</name>
+            <string>C</string>
+        </property>
+        <property stdset="1">
+            <name>autoResize</name>
+            <bool>true</bool>
+        </property>
+    </widget>
+    <widget>
+        <class>QCheckBox</class>
+        <property stdset="1">
+            <name>name</name>
+            <cstring>chkOrgAlt</cstring>
+        </property>
+        <property stdset="1">
+            <name>geometry</name>
+            <rect>
+                <x>350</x>
+                <y>50</y>
+                <width>34</width>
+                <height>19</height>
+            </rect>
+        </property>
+        <property stdset="1">
+            <name>text</name>
+            <string>A</string>
+        </property>
+        <property stdset="1">
+            <name>autoResize</name>
+            <bool>true</bool>
+        </property>
+    </widget>
+</widget>
+<tabstops>
+    <tabstop>txtOrgKey</tabstop>
+    <tabstop>chkOrgShift</tabstop>
+    <tabstop>chkOrgCtrl</tabstop>
+    <tabstop>chkOrgAlt</tabstop>
+    <tabstop>txtMapKey</tabstop>
+    <tabstop>chkMapShift</tabstop>
+    <tabstop>chkMapCtrl</tabstop>
+    <tabstop>chkMapAlt</tabstop>
+    <tabstop>btnGen</tabstop>
+    <tabstop>btnCopy</tabstop>
+    <tabstop>btnCtrl</tabstop>
+    <tabstop>mleDefine</tabstop>
+</tabstops>
+</UI>
diff --git a/noncore/applets/keyhelper/keyhelperconf/KeyNames.cpp b/noncore/applets/keyhelper/keyhelperconf/KeyNames.cpp
new file mode 100644
index 0000000..e3d90b4
--- a/dev/null
+++ b/noncore/applets/keyhelper/keyhelperconf/KeyNames.cpp
@@ -0,0 +1,274 @@
+#include "KeyNames.h"
+
+QMap<QString, int> KeyNames::codemap;
+QMap<int, QString> KeyNames::namemap;
+
+static struct {
+	int code;
+	char* name;
+} stKeyNames[] = {
+{Qt::Key_Escape, "Escape"},
+{Qt::Key_Tab, "Tab"},
+{Qt::Key_Backtab, "Backtab"},
+{Qt::Key_BackTab, "BackTab"},
+{Qt::Key_Backtab, "Backtab"},
+{Qt::Key_Backspace, "Backspace"},
+{Qt::Key_BackSpace, "BackSpace"},
+{Qt::Key_Backspace, "Backspace"},
+{Qt::Key_Return, "Return"},
+{Qt::Key_Enter, "Enter"},
+{Qt::Key_Insert, "Insert"},
+{Qt::Key_Delete, "Delete"},
+{Qt::Key_Pause, "Pause"},
+{Qt::Key_Print, "Print"},
+{Qt::Key_SysReq, "SysReq"},
+{Qt::Key_Home, "Home"},
+{Qt::Key_End, "End"},
+{Qt::Key_Left, "Left"},
+{Qt::Key_Up, "Up"},
+{Qt::Key_Right, "Right"},
+{Qt::Key_Down, "Down"},
+{Qt::Key_Prior, "Prior"},
+{Qt::Key_PageUp, "PageUp"},
+{Qt::Key_Prior, "Prior"},
+{Qt::Key_Next, "Next"},
+{Qt::Key_PageDown, "PageDown"},
+{Qt::Key_Next, "Next"},
+{Qt::Key_Shift, "Shift"},
+{Qt::Key_Control, "Control"},
+{Qt::Key_Meta, "Meta"},
+{Qt::Key_Alt, "Alt"},
+{Qt::Key_CapsLock, "CapsLock"},
+{Qt::Key_NumLock, "NumLock"},
+{Qt::Key_ScrollLock, "ScrollLock"},
+{Qt::Key_F1, "F1"},
+{Qt::Key_F2, "F2"},
+{Qt::Key_F3, "F3"},
+{Qt::Key_F4, "F4"},
+{Qt::Key_F5, "F5"},
+{Qt::Key_F6, "F6"},
+{Qt::Key_F7, "F7"},
+{Qt::Key_F8, "F8"},
+{Qt::Key_F9, "F9"},
+{Qt::Key_F10, "F10"},
+{Qt::Key_F11, "F11"},
+{Qt::Key_F12, "F12"},
+{Qt::Key_F13, "F13"},
+{Qt::Key_F14, "F14"},
+{Qt::Key_F15, "F15"},
+{Qt::Key_F16, "F16"},
+{Qt::Key_F17, "F17"},
+{Qt::Key_F18, "F18"},
+{Qt::Key_F19, "F19"},
+{Qt::Key_F20, "F20"},
+{Qt::Key_F21, "F21"},
+{Qt::Key_F22, "F22"},
+{Qt::Key_F23, "F23"},
+{Qt::Key_F24, "F24"},
+{Qt::Key_F25, "F25"},
+{Qt::Key_F26, "F26"},
+{Qt::Key_F27, "F27"},
+{Qt::Key_F28, "F28"},
+{Qt::Key_F29, "F29"},
+{Qt::Key_F30, "F30"},
+{Qt::Key_F31, "F31"},
+{Qt::Key_F32, "F32"},
+{Qt::Key_F33, "F33"},
+{Qt::Key_F34, "F34"},
+{Qt::Key_F35, "F35"},
+{Qt::Key_Super_L, "Super_L"},
+{Qt::Key_Super_R, "Super_R"},
+{Qt::Key_Menu, "Menu"},
+{Qt::Key_Hyper_L, "Hyper_L"},
+{Qt::Key_Hyper_R, "Hyper_R"},
+{Qt::Key_Help, "Help"},
+{Qt::Key_Space, "Space"},
+{Qt::Key_Any, "Any"},
+{Qt::Key_Space, "Space"},
+{Qt::Key_Exclam, "Exclam"},
+{Qt::Key_QuoteDbl, "QuoteDbl"},
+{Qt::Key_NumberSign, "NumberSign"},
+{Qt::Key_Dollar, "Dollar"},
+{Qt::Key_Percent, "Percent"},
+{Qt::Key_Ampersand, "Ampersand"},
+{Qt::Key_Apostrophe, "Apostrophe"},
+{Qt::Key_ParenLeft, "ParenLeft"},
+{Qt::Key_ParenRight, "ParenRight"},
+{Qt::Key_Asterisk, "Asterisk"},
+{Qt::Key_Plus, "Plus"},
+{Qt::Key_Comma, "Comma"},
+{Qt::Key_Minus, "Minus"},
+{Qt::Key_Period, "Period"},
+{Qt::Key_Slash, "Slash"},
+{Qt::Key_0, "0"},
+{Qt::Key_1, "1"},
+{Qt::Key_2, "2"},
+{Qt::Key_3, "3"},
+{Qt::Key_4, "4"},
+{Qt::Key_5, "5"},
+{Qt::Key_6, "6"},
+{Qt::Key_7, "7"},
+{Qt::Key_8, "8"},
+{Qt::Key_9, "9"},
+{Qt::Key_Colon, "Colon"},
+{Qt::Key_Semicolon, "Semicolon"},
+{Qt::Key_Less, "Less"},
+{Qt::Key_Equal, "Equal"},
+{Qt::Key_Greater, "Greater"},
+{Qt::Key_Question, "Question"},
+{Qt::Key_At, "At"},
+{Qt::Key_A, "A"},
+{Qt::Key_B, "B"},
+{Qt::Key_C, "C"},
+{Qt::Key_D, "D"},
+{Qt::Key_E, "E"},
+{Qt::Key_F, "F"},
+{Qt::Key_G, "G"},
+{Qt::Key_H, "H"},
+{Qt::Key_I, "I"},
+{Qt::Key_J, "J"},
+{Qt::Key_K, "K"},
+{Qt::Key_L, "L"},
+{Qt::Key_M, "M"},
+{Qt::Key_N, "N"},
+{Qt::Key_O, "O"},
+{Qt::Key_P, "P"},
+{Qt::Key_Q, "Q"},
+{Qt::Key_R, "R"},
+{Qt::Key_S, "S"},
+{Qt::Key_T, "T"},
+{Qt::Key_U, "U"},
+{Qt::Key_V, "V"},
+{Qt::Key_W, "W"},
+{Qt::Key_X, "X"},
+{Qt::Key_Y, "Y"},
+{Qt::Key_Z, "Z"},
+{Qt::Key_BracketLeft, "BracketLeft"},
+{Qt::Key_Backslash, "Backslash"},
+{Qt::Key_BracketRight, "BracketRight"},
+{Qt::Key_AsciiCircum, "AsciiCircum"},
+{Qt::Key_Underscore, "Underscore"},
+{Qt::Key_QuoteLeft, "QuoteLeft"},
+{Qt::Key_BraceLeft, "BraceLeft"},
+{Qt::Key_Bar, "Bar"},
+{Qt::Key_BraceRight, "BraceRight"},
+{Qt::Key_AsciiTilde, "AsciiTilde"},
+{Qt::Key_nobreakspace, "nobreakspace"},
+{Qt::Key_exclamdown, "exclamdown"},
+{Qt::Key_cent, "cent"},
+{Qt::Key_sterling, "sterling"},
+{Qt::Key_currency, "currency"},
+{Qt::Key_yen, "yen"},
+{Qt::Key_brokenbar, "brokenbar"},
+{Qt::Key_section, "section"},
+{Qt::Key_diaeresis, "diaeresis"},
+{Qt::Key_copyright, "copyright"},
+{Qt::Key_ordfeminine, "ordfeminine"},
+{Qt::Key_guillemotleft, "guillemotleft"},
+{Qt::Key_notsign, "notsign"},
+{Qt::Key_hyphen, "hyphen"},
+{Qt::Key_registered, "registered"},
+{Qt::Key_macron, "macron"},
+{Qt::Key_degree, "degree"},
+{Qt::Key_plusminus, "plusminus"},
+{Qt::Key_twosuperior, "twosuperior"},
+{Qt::Key_threesuperior, "threesuperior"},
+{Qt::Key_acute, "acute"},
+{Qt::Key_mu, "mu"},
+{Qt::Key_paragraph, "paragraph"},
+{Qt::Key_periodcentered, "periodcentered"},
+{Qt::Key_cedilla, "cedilla"},
+{Qt::Key_onesuperior, "onesuperior"},
+{Qt::Key_masculine, "masculine"},
+{Qt::Key_guillemotright, "guillemotright"},
+{Qt::Key_onequarter, "onequarter"},
+{Qt::Key_onehalf, "onehalf"},
+{Qt::Key_threequarters, "threequarters"},
+{Qt::Key_questiondown, "questiondown"},
+{Qt::Key_Agrave, "Agrave"},
+{Qt::Key_Aacute, "Aacute"},
+{Qt::Key_Acircumflex, "Acircumflex"},
+{Qt::Key_Atilde, "Atilde"},
+{Qt::Key_Adiaeresis, "Adiaeresis"},
+{Qt::Key_Aring, "Aring"},
+{Qt::Key_AE, "AE"},
+{Qt::Key_Ccedilla, "Ccedilla"},
+{Qt::Key_Egrave, "Egrave"},
+{Qt::Key_Eacute, "Eacute"},
+{Qt::Key_Ecircumflex, "Ecircumflex"},
+{Qt::Key_Ediaeresis, "Ediaeresis"},
+{Qt::Key_Igrave, "Igrave"},
+{Qt::Key_Iacute, "Iacute"},
+{Qt::Key_Icircumflex, "Icircumflex"},
+{Qt::Key_Idiaeresis, "Idiaeresis"},
+{Qt::Key_ETH, "ETH"},
+{Qt::Key_Ntilde, "Ntilde"},
+{Qt::Key_Ograve, "Ograve"},
+{Qt::Key_Oacute, "Oacute"},
+{Qt::Key_Ocircumflex, "Ocircumflex"},
+{Qt::Key_Otilde, "Otilde"},
+{Qt::Key_Odiaeresis, "Odiaeresis"},
+{Qt::Key_multiply, "multiply"},
+{Qt::Key_Ooblique, "Ooblique"},
+{Qt::Key_Ugrave, "Ugrave"},
+{Qt::Key_Uacute, "Uacute"},
+{Qt::Key_Ucircumflex, "Ucircumflex"},
+{Qt::Key_Udiaeresis, "Udiaeresis"},
+{Qt::Key_Yacute, "Yacute"},
+{Qt::Key_THORN, "THORN"},
+{Qt::Key_ssharp, "ssharp"},
+{Qt::Key_agrave, "agrave"},
+{Qt::Key_aacute, "aacute"},
+{Qt::Key_acircumflex, "acircumflex"},
+{Qt::Key_atilde, "atilde"},
+{Qt::Key_adiaeresis, "adiaeresis"},
+{Qt::Key_aring, "aring"},
+{Qt::Key_ae, "ae"},
+{Qt::Key_ccedilla, "ccedilla"},
+{Qt::Key_egrave, "egrave"},
+{Qt::Key_eacute, "eacute"},
+{Qt::Key_ecircumflex, "ecircumflex"},
+{Qt::Key_ediaeresis, "ediaeresis"},
+{Qt::Key_igrave, "igrave"},
+{Qt::Key_iacute, "iacute"},
+{Qt::Key_icircumflex, "icircumflex"},
+{Qt::Key_idiaeresis, "idiaeresis"},
+{Qt::Key_eth, "eth"},
+{Qt::Key_ntilde, "ntilde"},
+{Qt::Key_ograve, "ograve"},
+{Qt::Key_oacute, "oacute"},
+{Qt::Key_ocircumflex, "ocircumflex"},
+{Qt::Key_otilde, "otilde"},
+{Qt::Key_odiaeresis, "odiaeresis"},
+{Qt::Key_division, "division"},
+{Qt::Key_oslash, "oslash"},
+{Qt::Key_ugrave, "ugrave"},
+{Qt::Key_uacute, "uacute"},
+{Qt::Key_ucircumflex, "ucircumflex"},
+{Qt::Key_udiaeresis, "udiaeresis"},
+{Qt::Key_yacute, "yacute"},
+{Qt::Key_thorn, "thorn"},
+{Qt::Key_ydiaeresis, "ydiaeresis"},
+{Qt::Key_unknown, "unknown"},
+{0,0},
+};
+
+void KeyNames::setCodeMap()
+{
+	int i;
+
+	codemap.clear();
+	for(i=0; stKeyNames[i].code != 0; i++){
+		codemap.insert(stKeyNames[i].name, stKeyNames[i].code);
+	}
+}
+
+void KeyNames::setNameMap()
+{
+	int i;
+
+	namemap.clear();
+	for(i=0; stKeyNames[i].code != 0; i++){
+		namemap.insert(stKeyNames[i].code, stKeyNames[i].name);
+	}
+}
diff --git a/noncore/applets/keyhelper/keyhelperconf/KeyNames.h b/noncore/applets/keyhelper/keyhelperconf/KeyNames.h
new file mode 100644
index 0000000..edd7dc5
--- a/dev/null
+++ b/noncore/applets/keyhelper/keyhelperconf/KeyNames.h
@@ -0,0 +1,49 @@
+#ifndef _KEY_NAMES_H_
+#define _KEY_NAMES_H_
+
+#include <qstring.h>
+#include <qmap.h>
+#include <qnamespace.h>
+
+class KeyNames
+{
+public:
+	static const QString& getName(int code){
+		if(namemap.isEmpty()) setNameMap();
+		if(namemap.contains(code)){
+			return(namemap[code]);
+		} else {
+			return(QString::null);
+		}
+	}
+	static void clearName(){
+		namemap.clear();
+	}
+	static int getCode(const QString& s){
+		if(codemap.isEmpty()) setCodeMap();
+		if(codemap.contains(s)){
+			return(codemap[s]);
+		} else {
+			return(0);
+		}
+	}
+	static void setCode(const QString& s, int code){
+		if(codemap.contains(s) == false){
+			codemap.insert(s, code);
+		}
+	}
+	static void clearCode(){
+		codemap.clear();
+	}
+	static void reset(){
+		clearCode();
+	}
+private:
+	static QMap<QString, int> codemap;
+	static QMap<int, QString> namemap;
+
+	static void setCodeMap();
+	static void setNameMap();
+};
+
+#endif /* _KEY_NAMES_H_ */
diff --git a/noncore/applets/keyhelper/keyhelperconf/keyhelperconf.pro b/noncore/applets/keyhelper/keyhelperconf/keyhelperconf.pro
new file mode 100644
index 0000000..f84db3d
--- a/dev/null
+++ b/noncore/applets/keyhelper/keyhelperconf/keyhelperconf.pro
@@ -0,0 +1,13 @@
+CONFIG		= qt warn_on quick-app
+HEADERS		= KHCWidget.h \
+		  KeyNames.h
+SOURCES		= KHCWidget.cpp \
+		  KeyNames.cpp \
+		  khcmain.cpp
+INTERFACES	= KHCWidgetBase.ui
+DESTDIR			=	$(OPIEDIR)/bin
+INCLUDEPATH += . $(OPIEDIR)/include
+DEPENDPATH  += $(OPIEDIR)/include
+LIBS			+=	-lqpe
+
+include( $(OPIEDIR)/include.pro )
diff --git a/noncore/applets/keyhelper/keyhelperconf/khcmain.cpp b/noncore/applets/keyhelper/keyhelperconf/khcmain.cpp
new file mode 100644
index 0000000..757bde0
--- a/dev/null
+++ b/noncore/applets/keyhelper/keyhelperconf/khcmain.cpp
@@ -0,0 +1,11 @@
+#include <qpe/qpeapplication.h>
+#include "KHCWidget.h"
+
+int main(int argc, char* argv[])
+{
+	QPEApplication a(argc, argv);
+
+	KHCWidget w;
+	a.showMainWidget(&w);
+	return a.exec();
+}