- properly namespace the input methods. fixes symbols clashes at run-time

  with names like 'Keyboard' or 'KeyboardConfig' . the qcom interface
  objects are in an anonymous namespace now and the actual keyboard
  implementations are in Dvorak, JumpX, etc. namespaces.

What's left is to solve the symbol clashes of the multiply compiled
pickboard classes. I'll leave that one (as part of the patch posted
yesterday) for another day for review. This part (namespacing) sounds like
a safe bet to me though, so comitting now. (got no comments anyway)

20 files changed, 89 insertions, 20 deletions

diff --git a/inputmethods/dvorak/dvorak.cpp b/inputmethods/dvorak/dvorak.cpp
index 29b5bd0..97afa0a 100644
--- a/inputmethods/dvorak/dvorak.cpp
+++ b/inputmethods/dvorak/dvorak.cpp
@@ -1,793 +1,795 @@
 /**********************************************************************
 ** Copyright (C) 2000 Trolltech AS.  All rights reserved.
 **
 ** This file is part of Qtopia Environment.
 **
 ** This file may be distributed and/or modified under the terms of the
 ** GNU General Public License version 2 as published by the Free Software
 ** Foundation and appearing in the file LICENSE.GPL included in the
 ** packaging of this file.
 **
 ** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 ** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 **
 ** See http://www.trolltech.com/gpl/ for GPL licensing information.
 **
 ** Contact info@trolltech.com if any conditions of this licensing are
 ** not clear to you.
 **
 **********************************************************************/
 
 #include "dvorak.h"
 
 #include <qpe/global.h>
 
 #include <qwindowsystem_qws.h>
 #include <qpainter.h>
 #include <qfontmetrics.h>
 #include <qtimer.h>
 #include <ctype.h>
 
 
 #define USE_SMALL_BACKSPACE
 
+using namespace Dvorak;
+
 Keyboard::Keyboard(QWidget* parent, const char* name, WFlags f) :
     QFrame(parent, name, f),  shift(FALSE), lock(FALSE), ctrl(FALSE),
     alt(FALSE), useLargeKeys(TRUE), useOptiKeys(0), pressedKey(-1),
     unicode(-1), qkeycode(0), modifiers(0)
 {
     //  setPalette(QPalette(QColor(240,240,230))); // Beige!
     //  setFont( QFont( "Helvetica", 8 ) );
 //    setPalette(QPalette(QColor(200,200,200))); // Gray
     setPalette(QPalette(QColor(220,220,220))); // Gray
 
     picks = new KeyboardPicks( this );
     picks->setFont( QFont( "smallsmooth", 9 ) );
     setFont( QFont( "smallsmooth", 9 ) );
     picks->initialise();
     QObject::connect( picks, SIGNAL(key(ushort,ushort,ushort,bool,bool) ),
             this, SIGNAL(key(ushort,ushort,ushort,bool,bool)) );
 
     repeatTimer = new QTimer( this );
     connect( repeatTimer, SIGNAL(timeout()), this, SLOT(repeat()) );
 }
 
 void Keyboard::resizeEvent(QResizeEvent*)
 {
     int ph = picks->sizeHint().height();
     picks->setGeometry( 0, 0, width(), ph );
     keyHeight = (height()-ph)/5;
     int nk;
     if ( useOptiKeys ) {
 	nk = 15;
     } else if ( useLargeKeys ) {
 	nk = 15;
     } else {
 	nk = 19;
     }
     defaultKeyWidth = width()/nk;
     xoffs = (width()-defaultKeyWidth*nk)/2;
 }
 
 void KeyboardPicks::initialise()
 {
     setSizePolicy(QSizePolicy(QSizePolicy::Expanding,QSizePolicy::Fixed));
     mode = 0;
     dc = new KeyboardConfig(this);
     configs.append(dc);
 }
 
 QSize KeyboardPicks::sizeHint() const
 {
     return QSize(240,fontMetrics().lineSpacing());
 }
 
 
 void  KeyboardConfig::generateText(const QString &s)
 {
 #if defined(Q_WS_QWS) || defined(_WS_QWS_)
     for (int i=0; i<(int)backspaces; i++) {
 	parent->emitKey( 0, Qt::Key_Backspace, 0, true, false );
 	parent->emitKey( 0, Qt::Key_Backspace, 0, false, false );
     }
     for (int i=0; i<(int)s.length(); i++) {
 	parent->emitKey( s[i].unicode(), 0, 0, true, false );
 	parent->emitKey( s[i].unicode(), 0, 0, false, false );
     }
     parent->emitKey( 0, Qt::Key_Space, 0, true, false );
     parent->emitKey( 0, Qt::Key_Space, 0, false, false );
     backspaces = 0;
 #endif
 }
 
 
 //PC keyboard layout and scancodes
 
 /*
   Format: length, code, length, code, ..., 0
   
   length is measured in half the width of a standard key.
   If code < 0x80 we have length/2 consecutive standard keys,
   starting with scancode code.
   
   Special keys are hardcoded, one at a time, with length of key
   and code >= 0x80, these are NOT standard PC scancodes, but are looked
   up in specialM[]. (The special keys are not keymappable.)
   
  */
 
 static const uchar * const keyboard_opti[5] = { 
     (const uchar *const) "\001\223\003\240\002\20\002\41\002\26\002\62\002\56\002\45\002\54\003\200\001\223\002\226\002\235\002\234\002\236",
     (const uchar *const) "\001\223\003\201\004\207\002\30\002\24\002\43\004\207\003\203\001\223\006\002\002\065",
     (const uchar *const) "\001\223\003\202\002\60\002\37\002\23\002\22\002\36\002\21\002\55\003\203\001\223\006\005\002\055",
     (const uchar *const) "\001\223\003\205\004\207\002\27\002\61\002\40\004\207\003\204\001\223\006\010\002\014",
     (const uchar *const) "\001\223\003\206\002\44\002\31\002\57\002\42\002\46\002\25\002\207\003\204\001\223\002\013\002\064\002\015\002\230"
 };
 
 static const uchar * const keyboard_standard[5] = {
 
 #ifdef USE_SMALL_BACKSPACE
     (const uchar *const)"\002\240\002`\0021\0022\0023\0024\0025\0026\0027\0028\0029\0020\002[\002]\002\200\002\223\002\215\002\216\002\217",
 #else
     (const uchar *const)"\002\051\0021\0022\0023\0024\0025\0026\0027\0028\0029\0020\002[\002]\004\200\002\223\002\215\002\216\002\217",
 #endif
     //~ + 123...+ BACKSPACE //+ INSERT + HOME + PGUP
 
     (const uchar *const)"\003\201\002'\002,\002.\002p\002y\002f\002g\002c\002r\002l\002/\002=\002\\\001\224\002\223\002\221\002\220\002\222",
     //TAB + qwerty..  + backslash //+ DEL + END + PGDN
 
     (const uchar *const)"\004\202\002a\002o\002e\002u\002i\002d\002h\002t\002n\002s\002-\004\203",
     //CAPS + asdf.. + RETURN
 
     (const uchar *const)"\005\204\002;\002q\002j\002k\002x\002b\002m\002w\002v\002z\005\204\002\223\002\223\002\211",
     //SHIFT + zxcv... //+ UP
 
     (const uchar *const)"\003\205\003\206\022\207\003\206\003\205\002\223\002\212\002\213\002\214"
     //CTRL + ALT + SPACE //+ LEFT + DOWN + RIGHT
 
 };
 
 
 struct ShiftMap {
     char normal;
     char shifted;
 };
 
 
 static const ShiftMap shiftMap[] = {
     { '`', '~' },
     { '1', '!' },
     { '2', '@' },
     { '3', '#' },
     { '4', '$' },
     { '5', '%' },
     { '6', '^' },
     { '7', '&' },
     { '8', '*' },
     { '9', '(' },
     { '0', ')' },
     { '-', '_' },
     { '=', '+' },
     { '\\', '|' },
     { '[', '{' },
     { ']', '}' },
     { ';', ':' },
     { '\'', '"' },
     { ',', '<' },
     { '.', '>' },
     { '/', '?' }
 };
 
 
 /* XPM */
 static const char * const uparrow_xpm[]={
 "9 9 2 1",
 "a c #000000",
 ". c None",
 ".........",
 "....a....",
 "...aaa...",
 "..aaaaa..",
 "....a....",
 "....a....",
 "....a....",
 "....a....",
 "........."};
 /* XPM */
 static const char * const leftarrow_xpm[]={
 "9 9 2 1",
 "a c #000000",
 ". c None",
 ".........",
 ".........",
 "...a.....",
 "..aa.....",
 ".aaaaaaa.",
 "..aa.....",
 "...a.....",
 ".........",
 "........."};
 /* XPM */
 static const char * const downarrow_xpm[]={
 "9 9 2 1",
 "a c #000000",
 ". c None",
 ".........",
 "....a....",
 "....a....",
 "....a....",
 "....a....",
 "..aaaaa..",
 "...aaa...",
 "....a....",
 "........."};
 /* XPM */
 static const char * const rightarrow_xpm[]={
 "9 9 2 1",
 "a c #000000",
 ". c None",
 ".........",
 ".........",
 ".....a...",
 ".....aa..",
 ".aaaaaaa.",
 ".....aa..",
 ".....a...",
 ".........",
 "........."};
 /* XPM */
 static const char * const insert_xpm[]={
 "9 9 2 1",
 "a c #000000",
 ". c None",
 ".........",
 "a........",
 "a.aaa.aaa",
 "a.a.a.a..",
 "a.a.a..a.",
 "a.a.a...a",
 "a.a.a.aaa",
 ".........",
 "........."};
 /* XPM */
 static const char * const delete_xpm[]={
 "9 9 2 1",
 "a c #000000",
 ". c None",
 ".........",
 "aa......a",
 "a.a.aaa.a",
 "a.a.a.a.a",
 "a.a.aaa.a.",
 "a.a.a...a",
 "aaa.aaa.a",
 ".........",
 "........."};
 /* XPM */
 static const char * const home_xpm[]={
 "9 9 2 1",
 "a c #000000",
 ". c None",
 "....a....",
 "...a.a...",
 "..a...a..",
 ".a.....a.",
 "aa.aaa.aa",
 ".a.a.a.a.",
 ".a.a.a.a.",
 ".aaaaaaa.",
 "........."};
 /* XPM */
 static const char * const end_xpm[]={
 "10 9 2 1",
 "a c #000000",
 ". c None",
 "..........",
 "aa.......a",
 "a..aaa.aaa",
 "aa.a.a.a.a",
 "a..a.a.a.a",
 "a..a.a.a.a",
 "aa.a.a.aaa",
 "..........",
 ".........."};
 /* XPM */
 static const char * const pageup_xpm[]={
 "9 9 2 1",
 "a c #000000",
 ". c None",
 ".aaa.aaa.",
 ".a.a.a.a.",
 ".aaa..aa.",
 ".a...aaa.",
 ".........",
 ".a.a.aaa.",
 ".a.a.a.a.",
 ".aaa.aaa.",
 ".....a..."};
 /* XPM */
 static const char * const pagedown_xpm[]={
 "9 9 2 1",
 "a c #000000",
 ". c None",
 ".aaa.aaa.",
 ".a.a.a.a.",
 ".aaa..aa.",
 ".a...aaa.",
 ".........",
 "...a.....",
 ".aaa.aaa.",
 ".a.a.a.a.",
 ".aaa.a.a."};
 /* XPM */
 static const char * const expand_xpm[]={
 "4 9 2 1",
 "a c #408040",
 ". c None",
 "a...",
 "aa..",
 "aaa.",
 "aaaa",
 "aaaa",
 "aaaa",
 "aaa.",
 "aa..",
 "a..."};
 /* XPM */
 #ifdef USE_SMALL_BACKSPACE
 static const char * const backspace_xpm[]={
 "9 9 2 1",
 "a c #000000",
 ". c None",
 ".........",
 ".........",
 "...a.....",
 "..aa.....",
 ".aaaaaaaa",
 "..aa.....",
 "...a.....",
 ".........",
 "........."};
 #else
 static const char * const backspace_xpm[]={
 "21 9 2 1",
 "a c #000000",
 ". c None",
 ".....................",
 ".....................",
 ".....aaa..a..........",
 ".a...a..a.a.a.aaa.aaa",
 "aaaa.aaa..aa..aa..a.a",
 ".a...a..a.aaa..aa.a.a",
 ".....aaaa.a.a.aaa.aa.",
 "..................a..",
 "....................."};
 #endif
 /* XPM */
 static const char * const escape_xpm[]={
 "9 9 2 1",
 "a c #000000",
 ". c None",
 ".........",
 ".........",
 ".aa.aa.aa",
 ".a..a..a.",
 ".aa.aa.a.",
 ".a...a.a.",
 ".aa.aa.aa",
 ".........",
 "........."};
 
 
 enum { BSCode = 0x80, TabCode, CapsCode, RetCode, 
        ShiftCode, CtrlCode, AltCode, SpaceCode, BackSlash,
        UpCode, LeftCode, DownCode, RightCode, Blank, Expand,
        Opti, ResetDict,
        Divide, Multiply, Add, Subtract, Decimal, Equal,
        Percent, Sqrt, Inverse, Escape };
 
 typedef struct SpecialMap {
     int qcode;
     ushort unicode;
     const char * label;
     const char * const * xpm;
 };
 
 
 static const SpecialMap specialM[] = {
     {	Qt::Key_Backspace,	8,	"<",     backspace_xpm },
     {	Qt::Key_Tab,		9,	"Tab",   NULL },
     {	Qt::Key_CapsLock,	0,	"Caps",  NULL },
     {	Qt::Key_Return,		13,	"Ret",   NULL },
     {	Qt::Key_Shift,		0,	"Shift", NULL },
     {	Qt::Key_Control,	0,	"Ctrl",  NULL },
     {	Qt::Key_Alt,		0,	"Alt",   NULL },
     {	Qt::Key_Space,		' ',	"",      NULL },
     {	BackSlash,		43,	"\\",    NULL },
 
     // Need images?
     {	Qt::Key_Up,		0,	"^",     uparrow_xpm },
     {	Qt::Key_Left,		0,	"<",     leftarrow_xpm },
     {	Qt::Key_Down,		0,	"v",     downarrow_xpm },
     {	Qt::Key_Right,		0,	">",     rightarrow_xpm },
     {	Qt::Key_Insert,		0,	"I",     insert_xpm },
     {	Qt::Key_Home,		0,	"H",     home_xpm },
     {	Qt::Key_PageUp,		0,	"U",     pageup_xpm },
     {	Qt::Key_End,		0,	"E",     end_xpm },
     {	Qt::Key_Delete,		0,	"X",     delete_xpm },
     {	Qt::Key_PageDown,	0,	"D",     pagedown_xpm },
     {	Blank,			0,	" ",     NULL },
     {	Expand,			0,	"->",    expand_xpm },
     {	Opti,			0,	"#",     NULL },
     {	ResetDict,		0,	"R",     NULL },
    
     // number pad stuff
     {	Divide,			0,	"/",     NULL },
     {	Multiply,		0,	"*",     NULL },
     {	Add,			0,	"+",     NULL },
     {	Subtract,		0,	"-",     NULL },
     {	Decimal,		0,	".",     NULL },
     {	Equal,			0,	"=",     NULL },
     {	Percent,		0,	"%",     NULL },
     {	Sqrt,			0,	"^1/2",	 NULL },
     {	Inverse,		0,	"1/x",	 NULL },
 
     {	Escape,			27,	"ESC",	 escape_xpm }
 };
 
 
 static int keycode( int i2, int j, const uchar **keyboard )
 {
     if ( j <0 || j >= 5 )
 	return 0;
     
     const uchar *row = keyboard[j];
 
     while ( *row && *row <= i2 ) {
 	i2 -= *row;
 	row += 2;
     }
 
     if ( !*row ) return 0;
     
     int k;
     if ( row[1] >= 0x80 ) {
 	k = row[1];
     } else {
 	k = row[1]+i2/2;
     }
     
     return k;
 }
 
 
 /*
   return scancode and width of first key in row \a j if \a j >= 0,
   or next key on current row if \a j < 0.
   
 */
 
 int Keyboard::getKey( int &w, int j ) {
     static const uchar *row = 0;
     static int key_i = 0;
     static int scancode = 0;
     static int half = 0;
     
     if ( j >= 0 && j < 5 ) {
 	if (useOptiKeys)
     	    row = keyboard_opti[j];
 	else
     	    row = keyboard_standard[j];
 	half=0;
     }
 
     if ( !row || !*row ) {
 	return 0;    
     } else if ( row[1] >= 0x80 ) {
 	scancode = row[1];
 	w = (row[0] * w + (half++&1)) / 2;
 	row += 2;
 	return scancode;
     } else if ( key_i <= 0 ) {
 	key_i = row[0]/2;
 	scancode = row[1];
     }
     key_i--;
     if ( key_i <= 0 )
 	row += 2;
     return scancode++;
 }
     
 
 void Keyboard::paintEvent(QPaintEvent* e)
 {
     QPainter painter(this);
     painter.setClipRect(e->rect());
     drawKeyboard( painter );
     picks->dc->draw( &painter );
 }
 
 
 /*
   Draw the keyboard.
 
   If key >= 0, only the specified key is drawn.
 */
 void Keyboard::drawKeyboard( QPainter &p, int key )
 {
     const bool threeD = FALSE;
     const QColorGroup& cg = colorGroup();
     QColor keycolor = // cg.background();
 		    	QColor(240,240,230); // Beige!
     QColor keycolor_pressed = cg.mid();
     QColor keycolor_lo = cg.dark();
     QColor keycolor_hi = cg.light();
     QColor textcolor = QColor(0,0,0); // cg.text();
 
     int margin = threeD ? 1 : 0;
     
 //    p.fillRect( 0, , kw-1, keyHeight-2, keycolor_pressed );
 
     for ( int j = 0; j < 5; j++ ) {
 	int y = j * keyHeight + picks->height() + 1;
 	int x = xoffs;
 	int kw = defaultKeyWidth;
 	int k= getKey( kw, j );
 	while ( k ) {
 	    if ( key < 0 || k == key ) {
 		QString s;
 		bool pressed = (k == pressedKey);
 		bool blank = (k == 0223);
 		const char * const * xpm = NULL;
 		
 		if ( k >= 0x80 ) {
 		    s = specialM[k - 0x80].label;
 
 		    xpm = specialM[k - 0x80].xpm;
 			
 		    if ( k == ShiftCode ) {
 			pressed = shift;
 		    } else if ( k == CapsCode ) {
 			pressed = lock;
 		    } else if ( k == CtrlCode ) {
 			pressed = ctrl;
 		    } else if ( k == AltCode ) {
 			pressed = alt;
 		    } 
 		} else {
 #if defined(Q_WS_QWS) || defined(_WS_QWS_)
 /*
 		    s = QChar( shift^lock ? QWSServer::keyMap()[k].shift_unicode : 
 			       QWSServer::keyMap()[k].unicode);
 */
 		    // ### Fixme, bad code, needs improving, whole thing needs to
 		    // be re-coded to get rid of the way it did things with scancodes etc
 		    char shifted = k;
 		    if ( !isalpha( k ) ) {
 			for ( unsigned i = 0; i < sizeof(shiftMap)/sizeof(ShiftMap); i++ )
 			    if ( shiftMap[i].normal == k )
 				shifted = shiftMap[i].shifted;
 		    } else {
 			shifted = toupper( k );
 		    }
 		    s = QChar( shift^lock ? shifted : k );
 #endif
 		}
 
 		if (!blank) {
 		    if ( pressed )
 			p.fillRect( x+margin, y+margin, kw-margin, keyHeight-margin-1, keycolor_pressed );
 		    else
 			p.fillRect( x+margin, y+margin, kw-margin, keyHeight-margin-1, keycolor );
 
 		    if ( threeD ) {
 			p.setPen(pressed ? keycolor_lo : keycolor_hi);
 			p.drawLine( x, y+1, x, y+keyHeight-2 );
 			p.drawLine( x+1, y+1, x+1, y+keyHeight-3 );
 			p.drawLine( x+1, y+1, x+1+kw-2, y+1 );
 		    } else if ( j == 0 ) {
 			p.setPen(pressed ? keycolor_hi : keycolor_lo);
 			p.drawLine( x, y, x+kw, y );
 		    }
 
 		    // right
 		    p.setPen(pressed ? keycolor_hi : keycolor_lo);
 		    p.drawLine( x+kw-1, y, x+kw-1, y+keyHeight-2 );
 
 		    if ( threeD ) {
 			p.setPen(keycolor_lo.light());
 			p.drawLine( x+kw-2, y+keyHeight-2, x+kw-2, y+1 );
 			p.drawLine( x+kw-2, y+keyHeight-2, x+1, y+keyHeight-2 );
 		    }
 
 		    if (xpm) {
 			p.drawPixmap( x + 1, y + 2, QPixmap((const char**)xpm) );
 		    } else {
     			p.setPen(textcolor);
 			p.drawText( x - 1, y, kw, keyHeight-2, AlignCenter, s );
 		    }
 	    
 		    if ( threeD ) {
 			p.setPen(keycolor_hi);
 			p.drawLine( x, y, x+kw-1, y );
 		    }
 
 		    // bottom
 		    p.setPen(keycolor_lo);
 		    p.drawLine( x, y+keyHeight-1, x+kw-1, y+keyHeight-1 );
 	    
 		} else {
 		    p.fillRect( x, y, kw, keyHeight, cg.background() );
 		}
 	    }
 
 	    x += kw;
 	    kw = defaultKeyWidth;
 	    k = getKey( kw );
 	}
     }
 }
 
 
 void Keyboard::mousePressEvent(QMouseEvent *e)
 {
     clearHighlight(); // typing fast?
 
     int i2 = ((e->x() - xoffs) * 2) / defaultKeyWidth;
     int j = (e->y() - picks->height()) / keyHeight;
 
     int k = keycode( i2, j, (const uchar **)((useOptiKeys) ? keyboard_opti : keyboard_standard) );
     bool need_repaint = FALSE;
     unicode = -1;
     qkeycode = 0;
     if ( k >= 0x80 ) {
 	if ( k == ShiftCode ) {
 	    shift = !shift;
 	    need_repaint = TRUE;
 	} else if ( k == AltCode ){
 	    alt = !alt;
 	    need_repaint = TRUE;
 	} else if ( k == CapsCode ) {
 	    lock = !lock;
 	    need_repaint = TRUE;
 	} else if ( k == CtrlCode ) {
 	    ctrl = !ctrl;
 	    need_repaint = TRUE;
 	} else if ( k == 0224 /* Expand */ ) {
 	    useLargeKeys = !useLargeKeys;
 	    resizeEvent(0);
 	    repaint( TRUE ); // need it to clear first
 	} else if ( k == 0225 /* Opti/Toggle */ ) {
 	    useOptiKeys = !useOptiKeys;
 	    resizeEvent(0);
 	    repaint( TRUE ); // need it to clear first
 	} else {
 	    qkeycode = specialM[ k - 0x80 ].qcode;
 	    unicode = specialM[ k - 0x80 ].unicode;
 	}
     } else {
 #if defined(Q_WS_QWS) || defined(_WS_QWS_)
 /*
 	qk = QWSServer::keyMap()[k].key_code;
 	if ( qk != Key_unknown ) {
 		if ( ctrl )
 		    u = QWSServer::keyMap()[k].ctrl_unicode;
 		else if ( shift^lock )
 		    u = QWSServer::keyMap()[k].shift_unicode;
 		else 
 		    u = QWSServer::keyMap()[k].unicode;
 	}
 */
 	char shifted = k;
 	if ( !isalpha( k ) ) {
 	    // ### Fixme, bad code, needs improving, whole thing needs to
 	    // be re-coded to get rid of the way it did things with scancodes etc
 	    for ( unsigned i = 0; i < sizeof(shiftMap)/sizeof(ShiftMap); i++ )
 		if ( shiftMap[i].normal == k )
 		    shifted = shiftMap[i].shifted;
 	} else {
 	    shifted = toupper( k );
 	}
 	QChar tempChar( shift^lock ? shifted : k );
 	unicode = tempChar.unicode();
 #endif
     }
     if  ( unicode != -1 ) {
 	modifiers = (shift ? Qt::ShiftButton : 0) | (ctrl ? Qt::ControlButton : 0) |
 		  (alt ? Qt::AltButton : 0);
 #if defined(Q_WS_QWS) || defined(_WS_QWS_)
 	emit key( unicode, qkeycode, modifiers, true, false );
 	repeatTimer->start( 500 );
 #endif
 	need_repaint = shift || alt || ctrl;
 	shift = alt = ctrl = FALSE;
 	//qDebug( "pressed %d -> %04x ('%c')", k, u, u&0xffff < 256 ? u&0xff : 0 );
 
 	KeyboardConfig *dc = picks->dc;
 
 	if (dc) {
 	    if (qkeycode == Qt::Key_Backspace) {
 		dc->input.remove(dc->input.last()); // remove last input
 		dc->decBackspaces();
 	    } else if ( k == 0226 || qkeycode == Qt::Key_Return ||
 		        qkeycode == Qt::Key_Space ||
 			QChar(unicode).isPunct() ) {
 		dc->input.clear();
 		dc->resetBackspaces();
 	    } else {
 		dc->add(QString(QChar(unicode)));
 		dc->incBackspaces();
 	    }
 	}
 
 	picks->repaint();
 
     }
     pressedKey = k;
     if ( need_repaint ) {
 	repaint( FALSE );
     } else {
 	QPainter p(this);
 	drawKeyboard( p, pressedKey );
     }
     pressTid = startTimer(80);
     pressed = TRUE;
 }
 
 
 void Keyboard::mouseReleaseEvent(QMouseEvent*)
 {
     if ( pressTid == 0 )
 	clearHighlight();
 #if defined(Q_WS_QWS) || defined(_WS_QWS_)
     if ( unicode != -1 ) {
 	emit key( unicode, qkeycode, modifiers, false, false );
 	repeatTimer->stop();
     }
 #endif
     pressed = FALSE;
 }
 
 void Keyboard::timerEvent(QTimerEvent* e)
 {
     if ( e->timerId() == pressTid ) {
 	killTimer(pressTid);
 	pressTid = 0;
 	if ( !pressed )
 	    clearHighlight();
     }
 }
 
 void Keyboard::repeat()
 {
     repeatTimer->start( 150 );
     emit key( unicode, qkeycode, modifiers, true, true );
 }
 
 void Keyboard::clearHighlight()
 {
     if ( pressedKey >= 0 ) {
 	int tmp = pressedKey;
 	pressedKey = -1;
 	QPainter p(this);
 	drawKeyboard( p, tmp );
     }
 }
 
 
 QSize Keyboard::sizeHint() const
 {
     QFontMetrics fm=fontMetrics();
     int keyHeight = fm.lineSpacing()+2;
 
     if (useOptiKeys)
     	keyHeight += 1;
     
     return QSize( 320, keyHeight * 5 + picks->sizeHint().height() + 1 );
 }
 
 
 void Keyboard::resetState()
 {
     picks->resetState();
 }
diff --git a/inputmethods/dvorak/dvorak.h b/inputmethods/dvorak/dvorak.h
index 38ae338..216b5e5 100644
--- a/inputmethods/dvorak/dvorak.h
+++ b/inputmethods/dvorak/dvorak.h
@@ -1,103 +1,107 @@
 /**********************************************************************
 ** Copyright (C) 2000 Trolltech AS.  All rights reserved.
 **
 ** This file is part of Qtopia Environment.
 **
 ** This file may be distributed and/or modified under the terms of the
 ** GNU General Public License version 2 as published by the Free Software
 ** Foundation and appearing in the file LICENSE.GPL included in the
 ** packaging of this file.
 **
 ** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 ** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 **
 ** See http://www.trolltech.com/gpl/ for GPL licensing information.
 **
 ** Contact info@trolltech.com if any conditions of this licensing are
 ** not clear to you.
 **
 **********************************************************************/
 #include <qframe.h>
 #include "../pickboard/pickboardcfg.h"
 #include "../pickboard/pickboardpicks.h"
 
 class QTimer;
 
+namespace Dvorak
+{
+
 class KeyboardConfig : public DictFilterConfig
 {
 public:
     KeyboardConfig(PickboardPicks* p) : DictFilterConfig(p), backspaces(0) { nrows = 1; }
     virtual void generateText(const QString &s);
     void decBackspaces() { if (backspaces) backspaces--; }
     void incBackspaces() { backspaces++; }
     void resetBackspaces() { backspaces = 0; }
 private:
     int backspaces;
 };
 
 
 class KeyboardPicks : public PickboardPicks
 {
     Q_OBJECT
 public:
     KeyboardPicks(QWidget* parent=0, const char* name=0, WFlags f=0)
 	: PickboardPicks(parent, name, f) { }
     void initialise();
     virtual QSize sizeHint() const;
     KeyboardConfig *dc;
 };
 
 class Keyboard : public QFrame
 {
     Q_OBJECT
 public:
     Keyboard( QWidget* parent=0, const char* name=0, WFlags f=0 );
 
     void resetState();
 
     void mousePressEvent(QMouseEvent*);
     void mouseReleaseEvent(QMouseEvent*);
     void resizeEvent(QResizeEvent*);
     void paintEvent(QPaintEvent* e);
     void timerEvent(QTimerEvent* e);
     void drawKeyboard( QPainter &p, int key = -1 );
 
     void setMode(int mode) { useOptiKeys = mode; }
 
     QSize sizeHint() const;
 
 signals:
     void key( ushort scancode, ushort unicode, ushort modifiers, bool, bool );
 
 private slots:
     void repeat();
     
 private:
     int getKey( int &w, int j = -1 );
     void clearHighlight();
 
     uint shift:1;
     uint lock:1;
     uint ctrl:1;
     uint alt:1;
     uint useLargeKeys:1;
     uint useOptiKeys:1;
     
     int pressedKey;
 
     KeyboardPicks *picks;
 
     int keyHeight;
     int defaultKeyWidth;
     int xoffs;
 
     int unicode;
     int qkeycode;
     int modifiers;
 
     int pressTid;
     bool pressed;
 
     QTimer *repeatTimer;
 };
 
+} // namespace Dvorak
diff --git a/inputmethods/dvorak/dvorakimpl.cpp b/inputmethods/dvorak/dvorakimpl.cpp
index 3c83464..8050ce1 100644
--- a/inputmethods/dvorak/dvorakimpl.cpp
+++ b/inputmethods/dvorak/dvorakimpl.cpp
@@ -1,130 +1,130 @@
 /**********************************************************************
 ** Copyright (C) 2000 Trolltech AS.  All rights reserved.
 **
 ** This file is part of Qtopia Environment.
 **
 ** This file may be distributed and/or modified under the terms of the
 ** GNU General Public License version 2 as published by the Free Software
 ** Foundation and appearing in the file LICENSE.GPL included in the
 ** packaging of this file.
 **
 ** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 ** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 **
 ** See http://www.trolltech.com/gpl/ for GPL licensing information.
 **
 ** Contact info@trolltech.com if any conditions of this licensing are
 ** not clear to you.
 **
 **********************************************************************/
 #include <qapplication.h>
 #include <qpixmap.h>
 #include "dvorak.h"
 #include "dvorakimpl.h"
 
 /* XPM */
-static const char * kb_xpm[] = {
+static const char * const kb_xpm[] = {
 "28 13 4 1",
 "       c None",
 ".      c #4C4C4C",
 "+      c #FFF7DD",
 "@      c #D6CFBA",
 " .......................... ",
 " .+++.+++.+++.+++.+++.++++. ",
 " .+@@.+@@.+@@.+@@.+@@.+@@@. ",
 " .......................... ",
 " .+++++.+++.+++.+++.++++++. ",
 " .+@@@@.+@@.+@@.+@@.+@@@@@. ",
 " .......................... ",
 " .++++++.+++.+++.+++.+++++. ",
 " .+@@@@@.+@@.+@@.+@@.+@@@@. ",
 " .......................... ",
 " .++++.++++++++++++++.++++. ",
 " .+@@@.+@@@@@@@@@@@@@.+@@@. ",
 " .......................... "};
 
 
 /* XPM */
-static char * opti_xpm[] = {
+static const char * const opti_xpm[] = {
 "28 13 4 1",
 "       c None",
 ".      c #4C4C4C",
 "+      c #FFF7DD",
 "@      c #D6CFBA",
 " .........................  ",
 " .+++.+++.+++.+++.+++.+++.  ",
 " .+@@.+@@.+@@.+@@.+@@.+@@.  ",
 " .........................  ",
 " .+++.+++.+++.+++.+++.+++.  ",
 " .+@@.+@@.+@@.+@@.+@@.+@@.  ",
 " .........................  ",
 " .+++.+++.+++.+++.+++.+++.  ",
 " .+@@.+@@.+@@.+@@.+@@.+@@.  ",
 " .........................  ",
 " .+++.+++.+++.+++.+++.+++.  ",
 " .+@@.+@@.+@@.+@@.+@@.+@@.  ",
 " .........................  "};
 
 
 
 KeyboardImpl::KeyboardImpl()
     : input(0), icn(0), ref(0)
 {
 }
 
 KeyboardImpl::~KeyboardImpl()
 {
     delete input;
     delete icn;
 }
 
 QWidget *KeyboardImpl::inputMethod( QWidget *parent, Qt::WFlags f )
 {
     if ( !input )
-	input = new Keyboard( parent, "Keyboard", f );
+	input = new Dvorak::Keyboard( parent, "Keyboard", f );
     return input;
 }
 
 void KeyboardImpl::resetState()
 {
     if ( input )
 	input->resetState();
 }
 
 QPixmap *KeyboardImpl::icon()
 {
     if ( !icn )
 	icn = new QPixmap( (const char **)kb_xpm );
     return icn;
 }
 
 QString KeyboardImpl::name()
 {
     return qApp->translate( "InputMethods", "Dvorak" );
 }
 
 void KeyboardImpl::onKeyPress( QObject *receiver, const char *slot )
 {
     if ( input )
 	QObject::connect( input, SIGNAL(key(ushort,ushort,ushort,bool,bool)), receiver, slot );
 }
 
 #ifndef QT_NO_COMPONENT
 QRESULT KeyboardImpl::queryInterface( const QUuid &uuid, QUnknownInterface **iface )
 {
     *iface = 0;
     if ( uuid == IID_QUnknown )
 	*iface = this;
     else if ( uuid == IID_InputMethod )
 	*iface = this;
 
     if ( *iface )
 	(*iface)->addRef();
     return QS_OK;
 }
 
 Q_EXPORT_INTERFACE()
 {
     Q_CREATE_INSTANCE( KeyboardImpl )
 }
 #endif
diff --git a/inputmethods/dvorak/dvorakimpl.h b/inputmethods/dvorak/dvorakimpl.h
index e756364..bd9fa88 100644
--- a/inputmethods/dvorak/dvorakimpl.h
+++ b/inputmethods/dvorak/dvorakimpl.h
@@ -1,51 +1,60 @@
 /**********************************************************************
 ** Copyright (C) 2000 Trolltech AS.  All rights reserved.
 **
 ** This file is part of Qtopia Environment.
 **
 ** This file may be distributed and/or modified under the terms of the
 ** GNU General Public License version 2 as published by the Free Software
 ** Foundation and appearing in the file LICENSE.GPL included in the
 ** packaging of this file.
 **
 ** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 ** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 **
 ** See http://www.trolltech.com/gpl/ for GPL licensing information.
 **
 ** Contact info@trolltech.com if any conditions of this licensing are
 ** not clear to you.
 **
 **********************************************************************/
 #ifndef KEYBOARDIMPL_H
 #define KEYBOARDIMPL_H
 
 #include <qpe/inputmethodinterface.h>
 
+namespace Dvorak
+{
 class Keyboard;
+}
+
 class QPixmap;
 
+namespace
+{
+
 class KeyboardImpl : public InputMethodInterface
 {
 public:
     KeyboardImpl();
     virtual ~KeyboardImpl();
 
 #ifndef QT_NO_COMPONENT
     QRESULT queryInterface( const QUuid&, QUnknownInterface** );
     Q_REFCOUNT
 #endif
 
     virtual QWidget *inputMethod( QWidget *parent, Qt::WFlags f );
     virtual void resetState();
     virtual QPixmap *icon();
     virtual QString name();
     virtual void onKeyPress( QObject *receiver, const char *slot );
 
 private:
-    Keyboard *input;
+    Dvorak::Keyboard *input;
     QPixmap *icn;
     ulong ref;
 };
 
+} // anonymous namespace
+
 #endif
diff --git a/inputmethods/jumpx/keyboard.cpp b/inputmethods/jumpx/keyboard.cpp
index 0b8fc14..0cfb4be 100644
--- a/inputmethods/jumpx/keyboard.cpp
+++ b/inputmethods/jumpx/keyboard.cpp
@@ -1,524 +1,525 @@
 /**************************************************************************************94x78**
 **
 ** This file may be distributed and/or modified under the terms of the
 ** GNU General Public License version 2 as published by the Free Software
 ** Foundation and appearing in the file LICENSE.GPL included in the
 ** packaging of this file.
 **
 ** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 ** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 **
 *********************************************************************************************/
 #include "keyboard.h"
 
 #include <qpe/resource.h>
 
 //#include <iostream.h>
 
 
 static const int autorepeatDelaytime = 500; // ms
 static const int autorepeatRate      = 20;  // chars per second
 
 static const int mod1x1    =   0;
 static const int mod1x2    =  23;
 static const int mod1w     =  mod1x2 - mod1x1;
 
 static const int letterx1  =  27;
 static const int letterx2  = 129;
 static const int letterw   =  17;
 static const int letterh   =  14;
 
 static const int num1x1    = 130;
 static const int num1x2    = 137;
 static const int num1w     = num1x2 - num1x1;
 
 static const int specialx1 = 138;
 static const int specialx2 = 170;
 static const int specialw  =  16;
 
 static const int num2x1    = 171;
 static const int num2x2    = 178;
 static const int num2w     = num2x2 - num2x1;
 
 static const int mod2x1    = 179;
 static const int mod2x2    = 203;
 static const int mod2w     = mod2x2 - mod2x1;
 
 static const int cursorx1  = 207;
 static const int cursorw   =  16;
 
 static const int myParenID = -10;
 
 
 typedef struct mapElement
 {
     int    qcode;
     ushort unicode;
 };
 
 static const mapElement mod1Map[] = {
     { Qt::Key_Escape, 27 },
     { Qt::Key_Tab,     9 },
     { Qt::Key_Return, 13 },
     { Qt::Key_Alt,     0 },
     { Qt::Key_Control, 0 },
 };
 
 static const uchar *const letterMap[] = {
     (const uchar *const)"zvchwk",
     (const uchar *const)"fitaly",
     (const uchar *const)"  ne  ",
     (const uchar *const)"gdorsb",
     (const uchar *const)"qjumpx",
 };
 
 static const uchar *const letterMapShift[] = {
     (const uchar *const)"ZVCHWK",
     (const uchar *const)"FITALY",
     (const uchar *const)"  NE  ",
     (const uchar *const)"GDORSB",
     (const uchar *const)"QJUMPX",
 };
 
 static const uchar *const num1Map = (const uchar *const)"12345";
 
 static const uchar *const specialMap[] = {
     (const uchar *const)"-+",
     (const uchar *const)"*!",
     (const uchar *const)",'",
     (const uchar *const)".%",
     (const uchar *const)"/$",
 };
 
 static const uchar *const specialMapShift[] = {
     (const uchar *const)"_=",
     (const uchar *const)"#?",
     (const uchar *const)";\"",
     (const uchar *const)":|",
     (const uchar *const)"\\&",
 };
 
 static const uchar *const specialMapParen[] = {
     (const uchar *const)"()",
     (const uchar *const)"[]",
     (const uchar *const)"{}",
     (const uchar *const)"<>",
     (const uchar *const)"@~",
 };
 
 static const uchar *const num2Map = (const uchar *const)"67890";
 
 static const mapElement mod2Map[] = {
     { Qt::Key_Backspace,  8 },
     { Qt::Key_Delete,     0 },
     { Qt::Key_Return,    13 },
     { Qt::Key_Shift,      0 },
     { myParenID,          0 },
 };
 
 static const int cursorMap[][2] = {
     { Qt::Key_Home, Qt::Key_PageUp   },
     { Qt::Key_End,  Qt::Key_PageDown },
     { Qt::Key_Up,   Qt::Key_Up       },
     { Qt::Key_Left, Qt::Key_Right    },
     { Qt::Key_Down, Qt::Key_Down     },
 };
 
+using namespace JumpX;
 
 Keyboard::Keyboard(QWidget* parent, const char* name, WFlags f) :
     QFrame(parent, name, f),
     shift(0), paren(0), ctrl(0), alt(0),
     pressedKeyUnicode(0), pressedKeyQcode(0), pressedMod(0),
     isnoncont(false),
     slideKeyUnicodeH(0), slideKeyQcodeH(0), slideKeyUnicodeV(0), slideKeyQcodeV(0),
     enableMouseTracking(false), slidePix(NULL), slidePixH(NULL), slidePixV(NULL),
     releasedPix(NULL), pressedPix(NULL)
 {
     //setPalette(QPalette(QColor(240,240,230))); // Beige!
 
     releasedPlain = releasedShift = releasedParen = Resource::loadPixmap("jumpx/released");
     pressedPlain  = pressedShift  = pressedParen  = Resource::loadPixmap("jumpx/pressed");
     pressedDigit = Resource::loadPixmap("jumpx/pressed");
 
     QPixmap tmp;
 
     tmp = Resource::loadPixmap("jumpx/releasedShift");
     bitBlt(&releasedShift, letterx1, 0, &tmp);
 
     tmp = Resource::loadPixmap("jumpx/releasedParen");
     bitBlt(&releasedParen, specialx1, 0, &tmp);
 
     tmp = Resource::loadPixmap("jumpx/pressedShift");
     bitBlt(&pressedShift, letterx1, 0, &tmp);
 
     tmp = Resource::loadPixmap("jumpx/pressedParen");
     bitBlt(&pressedParen, specialx1, 0, &tmp);
 
     tmp = Resource::loadPixmap("jumpx/pressedDigit");
     bitBlt(&pressedDigit, specialx1, 0, &tmp);
 
     offscreen = QPixmap( releasedPlain );
 
     releasedPix = &releasedPlain;
     pressedPix  = &pressedPlain;
     slidePix    = &pressedPlain;
 
     delayTimer = new QTimer(this);
     rateTimer  = new QTimer(this);
     connect( delayTimer, SIGNAL( timeout() ), this, SLOT( delayTimerDone() ) );
     connect( rateTimer,  SIGNAL( timeout() ), this, SLOT( rateTimerDone() ) );
 }
 
 void Keyboard::resizeEvent(QResizeEvent*)
 {
     //cout << "resizeEvent()" << endl;
 }
 
 void Keyboard::paintEvent(QPaintEvent*)
 {
     bitBlt(this, 0, 0, &offscreen);
 }
 
 void Keyboard::mousePressEvent(QMouseEvent *e)
 {
     pressedx = -1;
     pressedKeyUnicode = pressedKeyQcode = pressedMod = 0;
 
     int x = e->x();
     int y = e->y();
 
     int row = (y - 1) / letterh;
 
     if ( x <= mod1x2 ) // mod1
     {
         pressedx = mod1x1;
         pressedy = row * letterh;
         pressedw = mod1w + 1;
         pressedh = letterh + 1;
         if ( row == 2 ) // return
         {
             pressed2x = mod2x1;
             pressed2y = 2 * letterh;
             pressed2w = mod2w + 1;
             pressed2h = letterh + 1;
             isnoncont = true;
         }
         else if ( row == 3 ) // alt
             alt = 1;
         else if ( row == 4 ) // ctrl
             ctrl = 1;
         pressedKeyUnicode = mod1Map[row].unicode;
         pressedKeyQcode   = mod1Map[row].qcode;
     }
     else if ( x >= letterx1 && x <= letterx2 ) // letter
     {
         int column = (x - letterx1 - 1) / letterw;
         QChar temp;
         if ( shift )
             temp = QChar( letterMapShift[row][column] );
         else
             temp = QChar( letterMap[row][column] );
         if ( temp == ' ' ) // space
         {
             if ( column < 3 )
             {
                 pressedx  = letterx1;
                 pressed2x = letterx1 + letterw * 4;
             }
             else
             {
                 pressedx  = letterx1 + letterw * 4;
                 pressed2x = letterx1;
             }
             pressedy = pressed2y = row * letterh;
             pressedw = pressed2w = letterw * 2 + 1;
             pressedh = pressed2h = letterh + 1;
             isnoncont = true;
         }
         else
         {
             pressedx = letterx1 + column * letterw;
             pressedy = row * letterh;
             pressedw = letterw + 1;
             pressedh = letterh + 1;
         }
         pressedKeyUnicode = temp.unicode();
         pressedKeyQcode = slideKeyQcodeH = slideKeyQcodeV = temp.upper().unicode();
         if ( temp == ' ' )
         {
             slideKeyUnicodeH = slideKeyUnicodeV = 8;
             slideKeyQcodeH   = slideKeyQcodeV   = Qt::Key_Backspace;
         }
         else if ( temp == temp.lower() )
         {
             slideKeyUnicodeH = slideKeyUnicodeV = temp.upper().unicode();
             slidePixH = slidePixV = &pressedShift;
         }
         else
         {
             slideKeyUnicodeH = slideKeyUnicodeV = temp.lower().unicode();
             slidePixH = slidePixV = &pressedPlain;
         }
         enableMouseTracking = true;
     }
     else if ( x >= num1x1 && x <= num1x2 ) // num1
     {
         pressedx = num1x1;
         pressedy = row * letterh;
         pressedw = num1w + 1;
         pressedh = letterh + 1;
         QChar temp = QChar( num1Map[row] );
         pressedKeyUnicode = pressedKeyQcode = temp.unicode();
     }
     else if ( x >= specialx1 && x <= specialx2 ) // special
     {
         int column = (x - specialx1 - 1) / specialw;
         pressedx = specialx1 + column * specialw;
         pressedy = row * letterh;
         pressedw = specialw + 1;
         pressedh = letterh + 1;
         QChar temp;
         if ( shift )
             temp = QChar( specialMapShift[row][column] );
         else if ( paren )
             temp = QChar( specialMapParen[row][column] );
         else
             temp = QChar( specialMap[row][column] );
         pressedKeyUnicode = pressedKeyQcode = temp.unicode();
         slideKeyUnicodeH = slideKeyQcodeH = slideKeyUnicodeV = slideKeyQcodeV =
             QChar('0').unicode() + ( 5 * column + row + 1 ) % 10;
         slidePixH = slidePixV = &pressedDigit;
         if ( shift )
         {
             slideKeyUnicodeV = slideKeyQcodeV =
                 QChar( specialMap[row][column] ).unicode();
             slidePixV = &pressedPlain;
         }
         else if ( !(shift || paren) )
         {
             slideKeyUnicodeV = slideKeyQcodeV =
                 QChar( specialMapShift[row][column] ).unicode();
             slidePixV = &pressedShift;
         }
         enableMouseTracking = true;
     }
     else if ( x >= num2x1 && x <= num2x2 ) // num2
     {
         pressedx = num2x1;
         pressedy = row * letterh;
         pressedw = num2w + 1;
         pressedh = letterh + 1;
         QChar temp = QChar( num2Map[row] );
         pressedKeyUnicode = pressedKeyQcode = temp.unicode();
     }
     else if ( x >= mod2x1 && x <= mod2x2 ) // mod2
     {
         pressedx = mod2x1;
         pressedy = row * letterh;
         pressedw = mod2w + 1;
         pressedh = letterh + 1;
         if ( row == 2 ) // return
         {
             pressed2x = mod1x1;
             pressed2y = 2 * letterh;
             pressed2w = mod2w + 1;
             pressed2h = letterh + 1;
             isnoncont = true;
         }
         pressedKeyUnicode = mod2Map[row].unicode;
         pressedKeyQcode   = mod2Map[row].qcode;
 
         if ( row == 3 ) // shift
         {
             paren = 0;
             switch ( shift )
             {
             case 0:
             {
                 shift = 1;
                 releasedPix = &releasedShift;
                 pressedPix = &pressedShift;
                 bitBlt( &offscreen, 0, 0, releasedPix );
                 break;
             }
             case 1:
             {
                 shift = 2;
                 break;
             }
             case 2:
             {
                 shift = 0;
                 releasedPix = &releasedPlain;
                 pressedPix = &pressedPlain;
                 bitBlt( &offscreen, 0, 0, releasedPix );
                 break;
             }
             }
         }
         else if ( row == 4 ) // parenthesis
         {
             shift = 0;
             switch ( paren )
             {
             case 0:
             {
                 paren = 1;
                 releasedPix = &releasedParen;
                 pressedPix = &pressedParen;
                 bitBlt( &offscreen, 0, 0, releasedPix );
                 break;
             }
             case 1:
             {
                 paren = 2;
                 break;
             }
             case 2:
             {
                 paren = 0;
                 releasedPix = &releasedPlain;
                 pressedPix = &pressedPlain;
                 bitBlt( &offscreen, 0, 0, releasedPix );
                 break;
             }
             }
         }
     }
     else if ( x >= cursorx1 ) // cursor
     {
         int column = (x - cursorx1 - 1) / cursorw;
         if ( row == 2 || row == 4 )
             pressedx = cursorx1 + cursorw / 2;
         else
             pressedx = cursorx1 + column * cursorw;
         pressedy = row * letterh;
         pressedw = cursorw + 1;
         pressedh = letterh + 1;
         pressedKeyQcode = cursorMap[row][column];
     }
 
     pressedMod = ( shift ? Qt::ShiftButton : 0 ) |
                  ( ctrl ? Qt::ControlButton : 0 ) |
                  ( alt ? Qt::AltButton : 0 );
 
     emit key( pressedKeyUnicode, pressedKeyQcode, pressedMod, true, false );
     delayTimer->start( autorepeatDelaytime, true );
 
     if ( pressedx == -1 )
         return;
 
     bitBlt( &offscreen, pressedx, pressedy,
             pressedPix, pressedx, pressedy, pressedw, pressedh );
     if ( isnoncont )
         bitBlt( &offscreen, pressed2x, pressed2y,
                 pressedPix, pressed2x, pressed2y, pressed2w, pressed2h );
 
     repaint( false );
 }
 
 void Keyboard::mouseReleaseEvent(QMouseEvent*)
 {
     //cout << pressedx << " " << pressedy << " " << pressedw << " " << pressedh << endl;
 
     delayTimer->stop();
     rateTimer->stop();
     enableMouseTracking = false;
 
     if ( pressedx == -1 )
         return;
 
     if ( shift == 2 && pressedKeyQcode == Qt::Key_Shift )
         return;
     if ( paren == 2 && pressedKeyQcode == myParenID )
         return;
 
     if ( shift == 1 && pressedKeyQcode != Qt::Key_Shift )
     {
         shift = 0;
         releasedPix = &releasedPlain;
         pressedPix = &pressedPlain;
         bitBlt( &offscreen, 0, 0, releasedPix );
     }
 
     if ( paren == 1 && pressedKeyQcode != myParenID )
     {
         paren = 0;
         releasedPix = &releasedPlain;
         pressedPix = &pressedPlain;
         bitBlt( &offscreen, 0, 0, releasedPix );
     }
 
     if ( alt && pressedKeyQcode != Qt::Key_Alt )
         alt = 0;
     if ( ctrl && pressedKeyQcode != Qt::Key_Control )
         ctrl = 0;
 
     bitBlt( &offscreen, pressedx, pressedy,
             releasedPix, pressedx, pressedy, pressedw, pressedh );
 
     if ( isnoncont )
     {
         isnoncont = false;
         bitBlt( &offscreen, pressed2x, pressed2y,
                 releasedPix, pressed2x, pressed2y, pressed2w, pressed2h );
     }
 
     repaint( false );
 }
 
 void Keyboard::mouseMoveEvent(QMouseEvent *e)
 {
     if ( !enableMouseTracking )
         return;
 
     if ( e->x() < pressedx || e->x() >= pressedx + pressedw )
     {
         pressedKeyUnicode = slideKeyUnicodeH;
         pressedKeyQcode = slideKeyQcodeH;
         slidePix = slidePixH;
     }
     else if ( e->y() < pressedy || e->y() >= pressedy + pressedh )
     {
         pressedKeyUnicode = slideKeyUnicodeV;
         pressedKeyQcode = slideKeyQcodeV;
         slidePix = slidePixV;
     }
     else
         return;
 
     enableMouseTracking = false;
 
     delayTimer->stop();
     rateTimer->stop();
 
     bitBlt( &offscreen, pressedx, pressedy,
             slidePix, pressedx, pressedy, pressedw, pressedh );
 
     emit key( 8, Qt::Key_Backspace, pressedMod, true, false );
     emit key( pressedKeyUnicode, pressedKeyQcode, pressedMod, true, false );
     delayTimer->start( autorepeatDelaytime, true );
 
     repaint( false );
 }
 
 void Keyboard::delayTimerDone()
 {
     emit key( pressedKeyUnicode, pressedKeyQcode, pressedMod, true, true );
     rateTimer->start( 1000/autorepeatRate, false );
 }
 
 void Keyboard::rateTimerDone()
 {
     emit key( pressedKeyUnicode, pressedKeyQcode, pressedMod, true, true );
 }
 
 QSize Keyboard::sizeHint() const
 {
     return offscreen.size();
 }
 
 void Keyboard::resetState()
 {
     //cout << "resetState()" << endl;
 }
diff --git a/inputmethods/jumpx/keyboard.h b/inputmethods/jumpx/keyboard.h
index 1be095d..689d95a 100644
--- a/inputmethods/jumpx/keyboard.h
+++ b/inputmethods/jumpx/keyboard.h
@@ -1,71 +1,76 @@
 /**************************************************************************************94x78**
 **
 ** This file may be distributed and/or modified under the terms of the
 ** GNU General Public License version 2 as published by the Free Software
 ** Foundation and appearing in the file LICENSE.GPL included in the
 ** packaging of this file.
 **
 ** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 ** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 **
 *********************************************************************************************/
 #include <qframe.h>
 #include <qpixmap.h>
 #include <qtimer.h>
 
+namespace JumpX
+{
+
 class Keyboard : public QFrame
 {
     Q_OBJECT
 public:
     Keyboard( QWidget* parent=0, const char* name=0, WFlags f=0 );
 
     void resetState();
 
     void mousePressEvent(QMouseEvent*);
     void mouseReleaseEvent(QMouseEvent*);
     void mouseMoveEvent(QMouseEvent*);
     void resizeEvent(QResizeEvent*);
     void paintEvent(QPaintEvent* e);
     //void timerEvent(QTimerEvent* e);
 
     QSize sizeHint() const;
 
 signals:
     void key( ushort unicode, ushort qcode, ushort modifiers, bool, bool );
 
 private slots:
     void delayTimerDone();
     void rateTimerDone();
 
 private:
     int shift; // 0, 1, 2
     int paren; // 0, 1, 2
     int ctrl;  // 0, 1
     int alt;   // 0, 1
 
     int pressedKeyUnicode, pressedKeyQcode, pressedMod;
     int pressedx, pressedy, pressedw, pressedh;
     bool isnoncont;
     int pressed2x, pressed2y, pressed2w, pressed2h;
 
     int slideKeyUnicodeH, slideKeyQcodeH, slideKeyUnicodeV, slideKeyQcodeV;
     bool enableMouseTracking;
     QPixmap *slidePix, *slidePixH, *slidePixV;
 
     QPixmap releasedPlain;
     QPixmap releasedShift;
     QPixmap releasedParen;
 
     QPixmap pressedPlain;
     QPixmap pressedShift;
     QPixmap pressedParen;
     QPixmap pressedDigit;
 
     QPixmap offscreen;
 
     QPixmap *releasedPix;
     QPixmap *pressedPix;
 
     QTimer *delayTimer;
     QTimer *rateTimer;
 };
+
+} // namespace JumpX
diff --git a/inputmethods/jumpx/keyboardimpl.cpp b/inputmethods/jumpx/keyboardimpl.cpp
index 92abb09..34c227f 100644
--- a/inputmethods/jumpx/keyboardimpl.cpp
+++ b/inputmethods/jumpx/keyboardimpl.cpp
@@ -1,97 +1,97 @@
 /**************************************************************************************94x78**
 **
 ** This file may be distributed and/or modified under the terms of the
 ** GNU General Public License version 2 as published by the Free Software
 ** Foundation and appearing in the file LICENSE.GPL included in the
 ** packaging of this file.
 **
 ** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 ** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 **
 *********************************************************************************************/
 #include <qapplication.h>
 #include <qpixmap.h>
 #include "keyboard.h"
 #include "keyboardimpl.h"
 
 /* XPM */
-static const char * icon_xpm[] = {
+static const char * const icon_xpm[] = {
 "26 13 2 1",
 " 	c None",
 ".	c #000000",
 " ... ... ... ... ... ...  ",
 ".   .   .   .   .   .   . ",
 ".   .   .   .   .   .   . ",
 ".   .   .   .   .   .   . ",
 " ....... ... ... .......  ",
 ".       .   .   .       . ",
 ".       .   .   .       . ",
 ".       .   .   .       . ",
 " ....... ... ... .......  ",
 ".   .   .   .   .   .   . ",
 ".   .   .   .   .   .   . ",
 ".   .   .   .   .   .   . ",
 " ... ... ... ... ... ...  "};
 
 
 KeyboardImpl::KeyboardImpl()
     : input(0), icn(0), ref(0)
 {
 }
 
 KeyboardImpl::~KeyboardImpl()
 {
     delete input;
     delete icn;
 }
 
 QWidget *KeyboardImpl::inputMethod( QWidget *parent, Qt::WFlags f )
 {
     if ( !input )
-	input = new Keyboard( parent, "Keyboard", f );
+	input = new JumpX::Keyboard( parent, "Keyboard", f );
     return input;
 }
 
 void KeyboardImpl::resetState()
 {
     if ( input )
 	input->resetState();
 }
 
 QPixmap *KeyboardImpl::icon()
 {
     if ( !icn )
 	icn = new QPixmap( (const char **)icon_xpm );
     return icn;
 }
 
 QString KeyboardImpl::name()
 {
     return qApp->translate( "InputMethods", "JumpX" );
 }
 
 void KeyboardImpl::onKeyPress( QObject *receiver, const char *slot )
 {
     if ( input )
 	QObject::connect( input, SIGNAL(key(ushort,ushort,ushort,bool,bool)), receiver, slot );
 }
 
 #ifndef QT_NO_COMPONENT
 QRESULT KeyboardImpl::queryInterface( const QUuid &uuid, QUnknownInterface **iface )
 {
     *iface = 0;
     if ( uuid == IID_QUnknown )
 	*iface = this;
     else if ( uuid == IID_InputMethod )
 	*iface = this;
 
     if ( *iface )
 	(*iface)->addRef();
     return QS_OK;
 }
 
 Q_EXPORT_INTERFACE()
 {
     Q_CREATE_INSTANCE( KeyboardImpl )
 }
 #endif
diff --git a/inputmethods/jumpx/keyboardimpl.h b/inputmethods/jumpx/keyboardimpl.h
index a82ec4a..087781f 100644
--- a/inputmethods/jumpx/keyboardimpl.h
+++ b/inputmethods/jumpx/keyboardimpl.h
@@ -1,43 +1,51 @@
 /**************************************************************************************94x78**
 **
 ** This file may be distributed and/or modified under the terms of the
 ** GNU General Public License version 2 as published by the Free Software
 ** Foundation and appearing in the file LICENSE.GPL included in the
 ** packaging of this file.
 **
 ** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 ** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 **
 *********************************************************************************************/
 #ifndef KEYBOARDIMPL_H
 #define KEYBOARDIMPL_H
 
 #include <qpe/inputmethodinterface.h>
 
+namespace JumpX
+{
 class Keyboard;
+};
 class QPixmap;
 
+namespace
+{
+
 class KeyboardImpl : public InputMethodInterface
 {
 public:
     KeyboardImpl();
     virtual ~KeyboardImpl();
 
 #ifndef QT_NO_COMPONENT
     QRESULT queryInterface( const QUuid&, QUnknownInterface** );
     Q_REFCOUNT
 #endif
 
     virtual QWidget *inputMethod( QWidget *parent, Qt::WFlags f );
     virtual void resetState();
     virtual QPixmap *icon();
     virtual QString name();
     virtual void onKeyPress( QObject *receiver, const char *slot );
 
 private:
-    Keyboard *input;
+    JumpX::Keyboard *input;
     QPixmap *icn;
     ulong ref;
 };
 
+} // anonymous namespace
+
 #endif
diff --git a/inputmethods/keyboard/keyboard.cpp b/inputmethods/keyboard/keyboard.cpp
index 0f0b188..a85a7b1 100644
--- a/inputmethods/keyboard/keyboard.cpp
+++ b/inputmethods/keyboard/keyboard.cpp
@@ -1,809 +1,810 @@
 /**********************************************************************
 ** Copyright (C) 2000 Trolltech AS.  All rights reserved.
 **
 ** This file is part of Qtopia Environment.
 **
 ** This file may be distributed and/or modified under the terms of the
 ** GNU General Public License version 2 as published by the Free Software
 ** Foundation and appearing in the file LICENSE.GPL included in the
 ** packaging of this file.
 **
 ** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 ** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 **
 ** See http://www.trolltech.com/gpl/ for GPL licensing information.
 **
 ** Contact info@trolltech.com if any conditions of this licensing are
 ** not clear to you.
 **
 **********************************************************************/
 
 #include "keyboard.h"
 
 #include <qpe/global.h>
 
 #include <qwindowsystem_qws.h>
 #include <qpainter.h>
 #include <qfontmetrics.h>
 #include <qtimer.h>
 #include <ctype.h>
 
 #include <sys/utsname.h>
 
+using namespace KeyboardInput;
 
 #define USE_SMALL_BACKSPACE
 
 Keyboard::Keyboard(QWidget* parent, const char* _name, WFlags f) :
     QFrame(parent, _name, f),  shift(FALSE), lock(FALSE), ctrl(FALSE),
     alt(FALSE), useLargeKeys(TRUE), useOptiKeys(0), pressedKey(-1),
     unicode(-1), qkeycode(0), modifiers(0)
 {
     //  setPalette(QPalette(QColor(240,240,230))); // Beige!
     //  setFont( QFont( "Helvetica", 8 ) );
 //    setPalette(QPalette(QColor(200,200,200))); // Gray
     setPalette(QPalette(QColor(220,220,220))); // Gray
 
     picks = new KeyboardPicks( this );
     picks->setFont( QFont( "smallsmooth", 9 ) );
     setFont( QFont( "smallsmooth", 9 ) );
     picks->initialise();
     QObject::connect( picks, SIGNAL(key(ushort,ushort,ushort,bool,bool) ),
             this, SIGNAL(key(ushort,ushort,ushort,bool,bool)) );
 
     repeatTimer = new QTimer( this );
 
     // temporary quick and dirty fix for the "sticky keyboard bug"
     // on ipaq.
 //    struct utsname name;
 //    if (uname(&name) != -1)
     //    {
 //	QString release=name.release;
 //	qWarning("System release: %s\n", name.release);
 //	if(release.find("embedix",0,TRUE) !=-1)
 //	  {
     connect( repeatTimer, SIGNAL(timeout()), this, SLOT(repeat()) );
 //	  }
     //     }
 }
 
 void Keyboard::resizeEvent(QResizeEvent*)
 {
     int ph = picks->sizeHint().height();
     picks->setGeometry( 0, 0, width(), ph );
     keyHeight = (height()-ph)/5;
     int nk;
     if ( useOptiKeys ) {
 	nk = 15;
     } else if ( useLargeKeys ) {
 	nk = 15;
     } else {
 	nk = 19;
     }
     defaultKeyWidth = width()/nk;
     xoffs = (width()-defaultKeyWidth*nk)/2;
 }
 
 void KeyboardPicks::initialise()
 {
     setSizePolicy(QSizePolicy(QSizePolicy::Expanding,QSizePolicy::Fixed));
     mode = 0;
     dc = new KeyboardConfig(this);
     configs.append(dc);
 }
 
 QSize KeyboardPicks::sizeHint() const
 {
     return QSize(240,fontMetrics().lineSpacing());
 }
 
 
 void  KeyboardConfig::generateText(const QString &s)
 {
 #if defined(Q_WS_QWS) || defined(_WS_QWS_)
     for (int i=0; i<(int)backspaces; i++) {
 	parent->emitKey( 0, Qt::Key_Backspace, 0, true, false );
 	parent->emitKey( 0, Qt::Key_Backspace, 0, false, false );
     }
     for (int i=0; i<(int)s.length(); i++) {
 	parent->emitKey( s[i].unicode(), 0, 0, true, false );
 	parent->emitKey( s[i].unicode(), 0, 0, false, false );
     }
     parent->emitKey( 0, Qt::Key_Space, 0, true, false );
     parent->emitKey( 0, Qt::Key_Space, 0, false, false );
     backspaces = 0;
 #endif
 }
 
 
 //PC keyboard layout and scancodes
 
 /*
   Format: length, code, length, code, ..., 0
 
   length is measured in half the width of a standard key.
   If code < 0x80 we have length/2 consecutive standard keys,
   starting with scancode code.
 
   Special keys are hardcoded, one at a time, with length of key
   and code >= 0x80, these are NOT standard PC scancodes, but are looked
   up in specialM[]. (The special keys are not keymappable.)
 
  */
 
 static const uchar * const keyboard_opti[5] = {
     (const uchar *const) "\001\223\003\240\002\20\002\41\002\26\002\62\002\56\002\45\002\54\003\200\001\223\002\226\002\235\002\234\002\236",
     (const uchar *const) "\001\223\003\201\004\207\002\30\002\24\002\43\004\207\003\203\001\223\006\002\002\065",
     (const uchar *const) "\001\223\003\202\002\60\002\37\002\23\002\22\002\36\002\21\002\55\003\203\001\223\006\005\002\055",
     (const uchar *const) "\001\223\003\205\004\207\002\27\002\61\002\40\004\207\003\204\001\223\006\010\002\014",
     (const uchar *const) "\001\223\003\206\002\44\002\31\002\57\002\42\002\46\002\25\002\207\003\204\001\223\002\013\002\064\002\015\002\230"
 };
 
 
 static const uchar * const keyboard_standard[5] = {
 
 #ifdef USE_SMALL_BACKSPACE
     (const uchar *const)"\002\240\002`\0021\0022\0023\0024\0025\0026\0027\0028\0029\0020\002-\002=\002\200\002\223\002\215\002\216\002\217",
 #else
     (const uchar *const)"\002\051\0021\0022\0023\0024\0025\0026\0027\0028\0029\0020\002-\002=\004\200\002\223\002\215\002\216\002\217",
 #endif
     //~ + 123...+ BACKSPACE //+ INSERT + HOME + PGUP
 
     (const uchar *const)"\003\201\002q\002w\002e\002r\002t\002y\002u\002i\002o\002p\002[\002]\002\\\001\224\002\223\002\221\002\220\002\222",
     //TAB + qwerty..  + backslash //+ DEL + END + PGDN
 
     (const uchar *const)"\004\202\002a\002s\002d\002f\002g\002h\002j\002k\002l\002;\002'\004\203",
     //CAPS + asdf.. + RETURN
 
     (const uchar *const)"\005\204\002z\002x\002c\002v\002b\002n\002m\002,\002.\002/\005\204\002\223\002\223\002\211",
     //SHIFT + zxcv... //+ UP
 
     (const uchar *const)"\003\205\003\206\022\207\003\206\003\205\002\223\002\212\002\213\002\214"
     //CTRL + ALT + SPACE //+ LEFT + DOWN + RIGHT
 
 };
 
 
 struct ShiftMap {
     char normal;
     char shifted;
 };
 
 
 static const ShiftMap shiftMap[] = {
     { '`', '~' },
     { '1', '!' },
     { '2', '@' },
     { '3', '#' },
     { '4', '$' },
     { '5', '%' },
     { '6', '^' },
     { '7', '&' },
     { '8', '*' },
     { '9', '(' },
     { '0', ')' },
     { '-', '_' },
     { '=', '+' },
     { '\\', '|' },
     { '[', '{' },
     { ']', '}' },
     { ';', ':' },
     { '\'', '"' },
     { ',', '<' },
     { '.', '>' },
     { '/', '?' }
 };
 
 
 /* XPM */
 static const char * const uparrow_xpm[]={
 "9 9 2 1",
 "a c #000000",
 ". c None",
 ".........",
 "....a....",
 "...aaa...",
 "..aaaaa..",
 "....a....",
 "....a....",
 "....a....",
 "....a....",
 "........."};
 /* XPM */
 static const char * const leftarrow_xpm[]={
 "9 9 2 1",
 "a c #000000",
 ". c None",
 ".........",
 ".........",
 "...a.....",
 "..aa.....",
 ".aaaaaaa.",
 "..aa.....",
 "...a.....",
 ".........",
 "........."};
 /* XPM */
 static const char * const downarrow_xpm[]={
 "9 9 2 1",
 "a c #000000",
 ". c None",
 ".........",
 "....a....",
 "....a....",
 "....a....",
 "....a....",
 "..aaaaa..",
 "...aaa...",
 "....a....",
 "........."};
 /* XPM */
 static const char * const rightarrow_xpm[]={
 "9 9 2 1",
 "a c #000000",
 ". c None",
 ".........",
 ".........",
 ".....a...",
 ".....aa..",
 ".aaaaaaa.",
 ".....aa..",
 ".....a...",
 ".........",
 "........."};
 /* XPM */
 static const char * const insert_xpm[]={
 "9 9 2 1",
 "a c #000000",
 ". c None",
 ".........",
 "a........",
 "a.aaa.aaa",
 "a.a.a.a..",
 "a.a.a..a.",
 "a.a.a...a",
 "a.a.a.aaa",
 ".........",
 "........."};
 /* XPM */
 static const char * const delete_xpm[]={
 "9 9 2 1",
 "a c #000000",
 ". c None",
 ".........",
 "aa......a",
 "a.a.aaa.a",
 "a.a.a.a.a",
 "a.a.aaa.a.",
 "a.a.a...a",
 "aaa.aaa.a",
 ".........",
 "........."};
 /* XPM */
 static const char * const home_xpm[]={
 "9 9 2 1",
 "a c #000000",
 ". c None",
 "....a....",
 "...a.a...",
 "..a...a..",
 ".a.....a.",
 "aa.aaa.aa",
 ".a.a.a.a.",
 ".a.a.a.a.",
 ".aaaaaaa.",
 "........."};
 /* XPM */
 static const char * const end_xpm[]={
 "10 9 2 1",
 "a c #000000",
 ". c None",
 "..........",
 "aa.......a",
 "a..aaa.aaa",
 "aa.a.a.a.a",
 "a..a.a.a.a",
 "a..a.a.a.a",
 "aa.a.a.aaa",
 "..........",
 ".........."};
 /* XPM */
 static const char * const pageup_xpm[]={
 "9 9 2 1",
 "a c #000000",
 ". c None",
 ".aaa.aaa.",
 ".a.a.a.a.",
 ".aaa..aa.",
 ".a...aaa.",
 ".........",
 ".a.a.aaa.",
 ".a.a.a.a.",
 ".aaa.aaa.",
 ".....a..."};
 /* XPM */
 static const char * const pagedown_xpm[]={
 "9 9 2 1",
 "a c #000000",
 ". c None",
 ".aaa.aaa.",
 ".a.a.a.a.",
 ".aaa..aa.",
 ".a...aaa.",
 ".........",
 "...a.....",
 ".aaa.aaa.",
 ".a.a.a.a.",
 ".aaa.a.a."};
 /* XPM */
 static const char * const expand_xpm[]={
 "4 9 2 1",
 "a c #408040",
 ". c None",
 "a...",
 "aa..",
 "aaa.",
 "aaaa",
 "aaaa",
 "aaaa",
 "aaa.",
 "aa..",
 "a..."};
 /* XPM */
 #ifdef USE_SMALL_BACKSPACE
 static const char * const backspace_xpm[]={
 "9 9 2 1",
 "a c #000000",
 ". c None",
 ".........",
 ".........",
 "...a.....",
 "..aa.....",
 ".aaaaaaaa",
 "..aa.....",
 "...a.....",
 ".........",
 "........."};
 #else
 static const char * const backspace_xpm[]={
 "21 9 2 1",
 "a c #000000",
 ". c None",
 ".....................",
 ".....................",
 ".....aaa..a..........",
 ".a...a..a.a.a.aaa.aaa",
 "aaaa.aaa..aa..aa..a.a",
 ".a...a..a.aaa..aa.a.a",
 ".....aaaa.a.a.aaa.aa.",
 "..................a..",
 "....................."};
 #endif
 /* XPM */
 static const char * const escape_xpm[]={
 "9 9 2 1",
 "a c #000000",
 ". c None",
 ".........",
 ".........",
 ".aa.aa.aa",
 ".a..a..a.",
 ".aa.aa.a.",
 ".a...a.a.",
 ".aa.aa.aa",
 ".........",
 "........."};
 
 
 enum { BSCode = 0x80, TabCode, CapsCode, RetCode,
        ShiftCode, CtrlCode, AltCode, SpaceCode, BackSlash,
        UpCode, LeftCode, DownCode, RightCode, Blank, Expand,
        Opti, ResetDict,
        Divide, Multiply, Add, Subtract, Decimal, Equal,
        Percent, Sqrt, Inverse, Escape };
 
 typedef struct SpecialMap {
     int qcode;
     ushort unicode;
     const char * label;
     const char * const * xpm;
 };
 
 
 static const SpecialMap specialM[] = {
     {	Qt::Key_Backspace,	8,	"<",     backspace_xpm },
     {	Qt::Key_Tab,		9,	"Tab",   NULL },
     {	Qt::Key_CapsLock,	0,	"Caps",  NULL },
     {	Qt::Key_Return,		13,	"Ret",   NULL },
     {	Qt::Key_Shift,		0,	"Shift", NULL },
     {	Qt::Key_Control,	0,	"Ctrl",  NULL },
     {	Qt::Key_Alt,		0,	"Alt",   NULL },
     {	Qt::Key_Space,		' ',	"",      NULL },
     {	BackSlash,		43,	"\\",    NULL },
 
     // Need images?
     {	Qt::Key_Up,		0,	"^",     uparrow_xpm },
     {	Qt::Key_Left,		0,	"<",     leftarrow_xpm },
     {	Qt::Key_Down,		0,	"v",     downarrow_xpm },
     {	Qt::Key_Right,		0,	">",     rightarrow_xpm },
     {	Qt::Key_Insert,		0,	"I",     insert_xpm },
     {	Qt::Key_Home,		0,	"H",     home_xpm },
     {	Qt::Key_PageUp,		0,	"U",     pageup_xpm },
     {	Qt::Key_End,		0,	"E",     end_xpm },
     {	Qt::Key_Delete,		0,	"X",     delete_xpm },
     {	Qt::Key_PageDown,	0,	"D",     pagedown_xpm },
     {	Blank,			0,	" ",     NULL },
     {	Expand,			0,	"->",    expand_xpm },
     {	Opti,			0,	"#",     NULL },
     {	ResetDict,		0,	"R",     NULL },
 
     // number pad stuff
     {	Divide,			0,	"/",     NULL },
     {	Multiply,		0,	"*",     NULL },
     {	Add,			0,	"+",     NULL },
     {	Subtract,		0,	"-",     NULL },
     {	Decimal,		0,	".",     NULL },
     {	Equal,			0,	"=",     NULL },
     {	Percent,		0,	"%",     NULL },
     {	Sqrt,			0,	"^1/2",	 NULL },
     {	Inverse,		0,	"1/x",	 NULL },
 
     {	Escape,			27,	"ESC",	 escape_xpm }
 };
 
 
 static int keycode( int i2, int j, const uchar **keyboard )
 {
     if ( j <0 || j >= 5 )
 	return 0;
 
     const uchar *row = keyboard[j];
 
     while ( *row && *row <= i2 ) {
 	i2 -= *row;
 	row += 2;
     }
 
     if ( !*row ) return 0;
 
     int k;
     if ( row[1] >= 0x80 ) {
 	k = row[1];
     } else {
 	k = row[1]+i2/2;
     }
 
     return k;
 }
 
 
 /*
   return scancode and width of first key in row \a j if \a j >= 0,
   or next key on current row if \a j < 0.
 
 */
 
 int Keyboard::getKey( int &w, int j ) {
     static const uchar *row = 0;
     static int key_i = 0;
     static int scancode = 0;
     static int half = 0;
 
     if ( j >= 0 && j < 5 ) {
 	if (useOptiKeys)
     	    row = keyboard_opti[j];
 	else
     	    row = keyboard_standard[j];
 	half=0;
     }
 
     if ( !row || !*row ) {
 	return 0;
     } else if ( row[1] >= 0x80 ) {
 	scancode = row[1];
 	w = (row[0] * w + (half++&1)) / 2;
 	row += 2;
 	return scancode;
     } else if ( key_i <= 0 ) {
 	key_i = row[0]/2;
 	scancode = row[1];
     }
     key_i--;
     if ( key_i <= 0 )
 	row += 2;
     return scancode++;
 }
 
 
 void Keyboard::paintEvent(QPaintEvent* e)
 {
     QPainter painter(this);
     painter.setClipRect(e->rect());
     drawKeyboard( painter );
     picks->dc->draw( &painter );
 }
 
 
 /*
   Draw the keyboard.
 
   If key >= 0, only the specified key is drawn.
 */
 void Keyboard::drawKeyboard( QPainter &p, int key )
 {
     const bool threeD = FALSE;
     const QColorGroup& cg = colorGroup();
     QColor keycolor = // cg.background();
 		    	QColor(240,240,230); // Beige!
     QColor keycolor_pressed = cg.mid();
     QColor keycolor_lo = cg.dark();
     QColor keycolor_hi = cg.light();
     QColor textcolor = QColor(0,0,0); // cg.text();
 
     int margin = threeD ? 1 : 0;
 
 //    p.fillRect( 0, , kw-1, keyHeight-2, keycolor_pressed );
 
     for ( int j = 0; j < 5; j++ ) {
 	int y = j * keyHeight + picks->height() + 1;
 	int x = xoffs;
 	int kw = defaultKeyWidth;
 	int k= getKey( kw, j );
 	while ( k ) {
 	    if ( key < 0 || k == key ) {
 		QString s;
 		bool pressed = (k == pressedKey);
 		bool blank = (k == 0223);
 		const char * const * xpm = NULL;
 
 		if ( k >= 0x80 ) {
 		    s = specialM[k - 0x80].label;
 
 		    xpm = specialM[k - 0x80].xpm;
 
 		    if ( k == ShiftCode ) {
 			pressed = shift;
 		    } else if ( k == CapsCode ) {
 			pressed = lock;
 		    } else if ( k == CtrlCode ) {
 			pressed = ctrl;
 		    } else if ( k == AltCode ) {
 			pressed = alt;
 		    }
 		} else {
 #if defined(Q_WS_QWS) || defined(_WS_QWS_)
 /*
 		    s = QChar( shift^lock ? QWSServer::keyMap()[k].shift_unicode :
 			       QWSServer::keyMap()[k].unicode);
 */
 		    // ### Fixme, bad code, needs improving, whole thing needs to
 		    // be re-coded to get rid of the way it did things with scancodes etc
 		    char shifted = k;
 		    if ( !isalpha( k ) ) {
 			for ( unsigned i = 0; i < sizeof(shiftMap)/sizeof(ShiftMap); i++ )
 			    if ( shiftMap[i].normal == k )
 				shifted = shiftMap[i].shifted;
 		    } else {
 			shifted = toupper( k );
 		    }
 		    s = QChar( shift^lock ? shifted : k );
 #endif
 		}
 
 		if (!blank) {
 		    if ( pressed )
 			p.fillRect( x+margin, y+margin, kw-margin, keyHeight-margin-1, keycolor_pressed );
 		    else
 			p.fillRect( x+margin, y+margin, kw-margin, keyHeight-margin-1, keycolor );
 
 		    if ( threeD ) {
 			p.setPen(pressed ? keycolor_lo : keycolor_hi);
 			p.drawLine( x, y+1, x, y+keyHeight-2 );
 			p.drawLine( x+1, y+1, x+1, y+keyHeight-3 );
 			p.drawLine( x+1, y+1, x+1+kw-2, y+1 );
 		    } else if ( j == 0 ) {
 			p.setPen(pressed ? keycolor_hi : keycolor_lo);
 			p.drawLine( x, y, x+kw, y );
 		    }
 
 		    // right
 		    p.setPen(pressed ? keycolor_hi : keycolor_lo);
 		    p.drawLine( x+kw-1, y, x+kw-1, y+keyHeight-2 );
 
 		    if ( threeD ) {
 			p.setPen(keycolor_lo.light());
 			p.drawLine( x+kw-2, y+keyHeight-2, x+kw-2, y+1 );
 			p.drawLine( x+kw-2, y+keyHeight-2, x+1, y+keyHeight-2 );
 		    }
 
 		    if (xpm) {
 			p.drawPixmap( x + 1, y + 2, QPixmap((const char**)xpm) );
 		    } else {
     			p.setPen(textcolor);
 			p.drawText( x - 1, y, kw, keyHeight-2, AlignCenter, s );
 		    }
 
 		    if ( threeD ) {
 			p.setPen(keycolor_hi);
 			p.drawLine( x, y, x+kw-1, y );
 		    }
 
 		    // bottom
 		    p.setPen(keycolor_lo);
 		    p.drawLine( x, y+keyHeight-1, x+kw-1, y+keyHeight-1 );
 
 		} else {
 		    p.fillRect( x, y, kw, keyHeight, cg.background() );
 		}
 	    }
 
 	    x += kw;
 	    kw = defaultKeyWidth;
 	    k = getKey( kw );
 	}
     }
 }
 
 
 void Keyboard::mousePressEvent(QMouseEvent *e)
 {
     clearHighlight(); // typing fast?
 
     int i2 = ((e->x() - xoffs) * 2) / defaultKeyWidth;
     int j = (e->y() - picks->height()) / keyHeight;
 
     int k = keycode( i2, j, (const uchar **)((useOptiKeys) ? keyboard_opti : keyboard_standard) );
     bool need_repaint = FALSE;
     unicode = -1;
     qkeycode = 0;
     if ( k >= 0x80 ) {
 	if ( k == ShiftCode ) {
 	    shift = !shift;
 	    need_repaint = TRUE;
 	} else if ( k == AltCode ){
 	    alt = !alt;
 	    need_repaint = TRUE;
 	} else if ( k == CapsCode ) {
 	    lock = !lock;
 	    need_repaint = TRUE;
 	} else if ( k == CtrlCode ) {
 	    ctrl = !ctrl;
 	    need_repaint = TRUE;
 	} else if ( k == 0224 /* Expand */ ) {
 	    useLargeKeys = !useLargeKeys;
 	    resizeEvent(0);
 	    repaint( TRUE ); // need it to clear first
 	} else if ( k == 0225 /* Opti/Toggle */ ) {
 	    useOptiKeys = !useOptiKeys;
 	    resizeEvent(0);
 	    repaint( TRUE ); // need it to clear first
 	} else {
 	    qkeycode = specialM[ k - 0x80 ].qcode;
 	    unicode = specialM[ k - 0x80 ].unicode;
 	}
     } else {
 #if defined(Q_WS_QWS) || defined(_WS_QWS_)
 /*
 	qk = QWSServer::keyMap()[k].key_code;
 	if ( qk != Key_unknown ) {
 		if ( ctrl )
 		    u = QWSServer::keyMap()[k].ctrl_unicode;
 		else if ( shift^lock )
 		    u = QWSServer::keyMap()[k].shift_unicode;
 		else
 		    u = QWSServer::keyMap()[k].unicode;
 	}
 */
 	char shifted = k;
 	if ( !isalpha( k ) ) {
 	    // ### Fixme, bad code, needs improving, whole thing needs to
 	    // be re-coded to get rid of the way it did things with scancodes etc
 	    for ( unsigned i = 0; i < sizeof(shiftMap)/sizeof(ShiftMap); i++ )
 		if ( shiftMap[i].normal == k )
 		    shifted = shiftMap[i].shifted;
 	} else {
 	    shifted = toupper( k );
 	}
 	QChar tempChar( shift^lock ? shifted : k );
 	unicode = tempChar.unicode();
 #endif
     }
     if  ( unicode != -1 ) {
 	modifiers = (shift ? Qt::ShiftButton : 0) | (ctrl ? Qt::ControlButton : 0) |
 		  (alt ? Qt::AltButton : 0);
 #if defined(Q_WS_QWS) || defined(_WS_QWS_)
 	emit key( unicode, qkeycode, modifiers, true, false );
 	repeatTimer->start( 500 );
 #endif
 	need_repaint = shift || alt || ctrl;
 	shift = alt = ctrl = FALSE;
 	//qDebug( "pressed %d -> %04x ('%c')", k, u, u&0xffff < 256 ? u&0xff : 0 );
 
 	KeyboardConfig *dc = picks->dc;
 
 	if (dc) {
 	    if (qkeycode == Qt::Key_Backspace) {
 		dc->input.remove(dc->input.last()); // remove last input
 		dc->decBackspaces();
 	    } else if ( k == 0226 || qkeycode == Qt::Key_Return ||
 		        qkeycode == Qt::Key_Space ||
 			QChar(unicode).isPunct() ) {
 		dc->input.clear();
 		dc->resetBackspaces();
 	    } else {
 		dc->add(QString(QChar(unicode)));
 		dc->incBackspaces();
 	    }
 	}
 
 	picks->repaint();
 
     }
     pressedKey = k;
     if ( need_repaint ) {
 	repaint( FALSE );
     } else {
 	QPainter p(this);
 	drawKeyboard( p, pressedKey );
     }
     pressTid = startTimer(80);
     pressed = TRUE;
 }
 
 
 void Keyboard::mouseReleaseEvent(QMouseEvent*)
 {
     if ( pressTid == 0 )
 	clearHighlight();
 #if defined(Q_WS_QWS) || defined(_WS_QWS_)
     if ( unicode != -1 ) {
 	emit key( unicode, qkeycode, modifiers, false, false );
 	repeatTimer->stop();
     }
 #endif
     pressed = FALSE;
 }
 
 void Keyboard::timerEvent(QTimerEvent* e)
 {
     if ( e->timerId() == pressTid ) {
 	killTimer(pressTid);
 	pressTid = 0;
 	if ( !pressed )
 	    clearHighlight();
     }
 }
 
 void Keyboard::repeat()
 {
 
   repeatTimer->start( 200 );
   emit key( unicode, qkeycode, modifiers, true, true );
 }
 
 void Keyboard::clearHighlight()
 {
     if ( pressedKey >= 0 ) {
 	int tmp = pressedKey;
 	pressedKey = -1;
 	QPainter p(this);
 	drawKeyboard( p, tmp );
     }
 }
 
 
 QSize Keyboard::sizeHint() const
 {
     QFontMetrics fm=fontMetrics();
     int keyHeight = fm.lineSpacing()+2;
 
     if (useOptiKeys)
     	keyHeight += 1;
 
     return QSize( 320, keyHeight * 5 + picks->sizeHint().height() + 1 );
 }
 
 
 void Keyboard::resetState()
 {
     picks->resetState();
 }
diff --git a/inputmethods/keyboard/keyboard.h b/inputmethods/keyboard/keyboard.h
index 38ae338..cc7f3f5 100644
--- a/inputmethods/keyboard/keyboard.h
+++ b/inputmethods/keyboard/keyboard.h
@@ -1,103 +1,108 @@
 /**********************************************************************
 ** Copyright (C) 2000 Trolltech AS.  All rights reserved.
 **
 ** This file is part of Qtopia Environment.
 **
 ** This file may be distributed and/or modified under the terms of the
 ** GNU General Public License version 2 as published by the Free Software
 ** Foundation and appearing in the file LICENSE.GPL included in the
 ** packaging of this file.
 **
 ** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 ** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 **
 ** See http://www.trolltech.com/gpl/ for GPL licensing information.
 **
 ** Contact info@trolltech.com if any conditions of this licensing are
 ** not clear to you.
 **
 **********************************************************************/
 #include <qframe.h>
 #include "../pickboard/pickboardcfg.h"
 #include "../pickboard/pickboardpicks.h"
 
 class QTimer;
 
+namespace KeyboardInput
+{
+
 class KeyboardConfig : public DictFilterConfig
 {
 public:
     KeyboardConfig(PickboardPicks* p) : DictFilterConfig(p), backspaces(0) { nrows = 1; }
     virtual void generateText(const QString &s);
     void decBackspaces() { if (backspaces) backspaces--; }
     void incBackspaces() { backspaces++; }
     void resetBackspaces() { backspaces = 0; }
 private:
     int backspaces;
 };
 
 
 class KeyboardPicks : public PickboardPicks
 {
     Q_OBJECT
 public:
     KeyboardPicks(QWidget* parent=0, const char* name=0, WFlags f=0)
 	: PickboardPicks(parent, name, f) { }
     void initialise();
     virtual QSize sizeHint() const;
     KeyboardConfig *dc;
 };
 
 class Keyboard : public QFrame
 {
     Q_OBJECT
 public:
     Keyboard( QWidget* parent=0, const char* name=0, WFlags f=0 );
 
     void resetState();
 
     void mousePressEvent(QMouseEvent*);
     void mouseReleaseEvent(QMouseEvent*);
     void resizeEvent(QResizeEvent*);
     void paintEvent(QPaintEvent* e);
     void timerEvent(QTimerEvent* e);
     void drawKeyboard( QPainter &p, int key = -1 );
 
     void setMode(int mode) { useOptiKeys = mode; }
 
     QSize sizeHint() const;
 
 signals:
     void key( ushort scancode, ushort unicode, ushort modifiers, bool, bool );
 
 private slots:
     void repeat();
     
 private:
     int getKey( int &w, int j = -1 );
     void clearHighlight();
 
     uint shift:1;
     uint lock:1;
     uint ctrl:1;
     uint alt:1;
     uint useLargeKeys:1;
     uint useOptiKeys:1;
     
     int pressedKey;
 
     KeyboardPicks *picks;
 
     int keyHeight;
     int defaultKeyWidth;
     int xoffs;
 
     int unicode;
     int qkeycode;
     int modifiers;
 
     int pressTid;
     bool pressed;
 
     QTimer *repeatTimer;
 };
 
+} // namespace KeyboardInput
+
diff --git a/inputmethods/keyboard/keyboardimpl.cpp b/inputmethods/keyboard/keyboardimpl.cpp
index bc96402..3c77fe6 100644
--- a/inputmethods/keyboard/keyboardimpl.cpp
+++ b/inputmethods/keyboard/keyboardimpl.cpp
@@ -1,130 +1,128 @@
 /**********************************************************************
 ** Copyright (C) 2000 Trolltech AS.  All rights reserved.
 **
 ** This file is part of Qtopia Environment.
 **
 ** This file may be distributed and/or modified under the terms of the
 ** GNU General Public License version 2 as published by the Free Software
 ** Foundation and appearing in the file LICENSE.GPL included in the
 ** packaging of this file.
 **
 ** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 ** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 **
 ** See http://www.trolltech.com/gpl/ for GPL licensing information.
 **
 ** Contact info@trolltech.com if any conditions of this licensing are
 ** not clear to you.
 **
 **********************************************************************/
 #include <qapplication.h>
 #include <qpixmap.h>
 #include "keyboard.h"
 #include "keyboardimpl.h"
 
 /* XPM */
-static const char * kb_xpm[] = {
+static const char * const kb_xpm[] = {
 "28 13 4 1",
 "       c None",
 ".      c #4C4C4C",
 "+      c #FFF7DD",
 "@      c #D6CFBA",
 " .......................... ",
 " .+++.+++.+++.+++.+++.++++. ",
 " .+@@.+@@.+@@.+@@.+@@.+@@@. ",
 " .......................... ",
 " .+++++.+++.+++.+++.++++++. ",
 " .+@@@@.+@@.+@@.+@@.+@@@@@. ",
 " .......................... ",
 " .++++++.+++.+++.+++.+++++. ",
 " .+@@@@@.+@@.+@@.+@@.+@@@@. ",
 " .......................... ",
 " .++++.++++++++++++++.++++. ",
 " .+@@@.+@@@@@@@@@@@@@.+@@@. ",
 " .......................... "};
 
 
 /* XPM */
-static char * opti_xpm[] = {
+static const char * const ipti_xpm[] = {
 "28 13 4 1",
 "       c None",
 ".      c #4C4C4C",
 "+      c #FFF7DD",
 "@      c #D6CFBA",
 " .........................  ",
 " .+++.+++.+++.+++.+++.+++.  ",
 " .+@@.+@@.+@@.+@@.+@@.+@@.  ",
 " .........................  ",
 " .+++.+++.+++.+++.+++.+++.  ",
 " .+@@.+@@.+@@.+@@.+@@.+@@.  ",
 " .........................  ",
 " .+++.+++.+++.+++.+++.+++.  ",
 " .+@@.+@@.+@@.+@@.+@@.+@@.  ",
 " .........................  ",
 " .+++.+++.+++.+++.+++.+++.  ",
 " .+@@.+@@.+@@.+@@.+@@.+@@.  ",
 " .........................  "};
 
-
-
 KeyboardImpl::KeyboardImpl()
     : input(0), icn(0), ref(0)
 {
 }
 
 KeyboardImpl::~KeyboardImpl()
 {
     delete input;
     delete icn;
 }
 
 QWidget *KeyboardImpl::inputMethod( QWidget *parent, Qt::WFlags f )
 {
     if ( !input )
-	input = new Keyboard( parent, "Keyboard", f );
+	input = new KeyboardInput::Keyboard( parent, "Keyboard", f );
     return input;
 }
 
 void KeyboardImpl::resetState()
 {
     if ( input )
 	input->resetState();
 }
 
 QPixmap *KeyboardImpl::icon()
 {
     if ( !icn )
 	icn = new QPixmap( (const char **)kb_xpm );
     return icn;
 }
 
 QString KeyboardImpl::name()
 {
     return qApp->translate( "InputMethods", "Keyboard" );
 }
 
 void KeyboardImpl::onKeyPress( QObject *receiver, const char *slot )
 {
     if ( input )
 	QObject::connect( input, SIGNAL(key(ushort,ushort,ushort,bool,bool)), receiver, slot );
 }
 
 #ifndef QT_NO_COMPONENT
 QRESULT KeyboardImpl::queryInterface( const QUuid &uuid, QUnknownInterface **iface )
 {
     *iface = 0;
     if ( uuid == IID_QUnknown )
 	*iface = this;
     else if ( uuid == IID_InputMethod )
 	*iface = this;
 
     if ( *iface )
 	(*iface)->addRef();
     return QS_OK;
 }
 
 Q_EXPORT_INTERFACE()
 {
     Q_CREATE_INSTANCE( KeyboardImpl )
 }
 #endif
diff --git a/inputmethods/keyboard/keyboardimpl.h b/inputmethods/keyboard/keyboardimpl.h
index e756364..d33a822 100644
--- a/inputmethods/keyboard/keyboardimpl.h
+++ b/inputmethods/keyboard/keyboardimpl.h
@@ -1,51 +1,60 @@
 /**********************************************************************
 ** Copyright (C) 2000 Trolltech AS.  All rights reserved.
 **
 ** This file is part of Qtopia Environment.
 **
 ** This file may be distributed and/or modified under the terms of the
 ** GNU General Public License version 2 as published by the Free Software
 ** Foundation and appearing in the file LICENSE.GPL included in the
 ** packaging of this file.
 **
 ** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 ** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 **
 ** See http://www.trolltech.com/gpl/ for GPL licensing information.
 **
 ** Contact info@trolltech.com if any conditions of this licensing are
 ** not clear to you.
 **
 **********************************************************************/
 #ifndef KEYBOARDIMPL_H
 #define KEYBOARDIMPL_H
 
 #include <qpe/inputmethodinterface.h>
 
+namespace KeyboardInput
+{
 class Keyboard;
+}
+
 class QPixmap;
 
+namespace
+{
+
 class KeyboardImpl : public InputMethodInterface
 {
 public:
     KeyboardImpl();
     virtual ~KeyboardImpl();
 
 #ifndef QT_NO_COMPONENT
     QRESULT queryInterface( const QUuid&, QUnknownInterface** );
     Q_REFCOUNT
 #endif
 
     virtual QWidget *inputMethod( QWidget *parent, Qt::WFlags f );
     virtual void resetState();
     virtual QPixmap *icon();
     virtual QString name();
     virtual void onKeyPress( QObject *receiver, const char *slot );
 
 private:
-    Keyboard *input;
+    KeyboardInput::Keyboard *input;
     QPixmap *icn;
     ulong ref;
 };
 
+} // anonymous namespace
+
 #endif
diff --git a/inputmethods/kjumpx/keyboard.cpp b/inputmethods/kjumpx/keyboard.cpp
index 3af6a78..dc44805 100644
--- a/inputmethods/kjumpx/keyboard.cpp
+++ b/inputmethods/kjumpx/keyboard.cpp
@@ -1,855 +1,856 @@
 /**************************************************************************************94x78**
 **
 ** This file may be distributed and/or modified under the terms of the
 ** GNU General Public License version 2 as published by the Free Software
 ** Foundation and appearing in the file LICENSE.GPL included in the
 ** packaging of this file.
 **
 ** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 ** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 **
 *********************************************************************************************/
 #include "keyboard.h"
 
 #include <qpe/resource.h>
 
 //#include <iostream.h>
 
 
 static const int autorepeatDelaytime = 500; // ms
 static const int autorepeatRate      = 20;  // chars per second
 
 static const int mod1x1    =   0;
 static const int mod1x2    =  23;
 static const int mod1w     =  mod1x2 - mod1x1;
 
 static const int letterx1  =  27;
 static const int letterx2  = 129;
 static const int letterw   =  17;
 static const int letterh   =  14;
 
 static const int num1x1    = 130;
 static const int num1x2    = 137;
 static const int num1w     = num1x2 - num1x1;
 
 static const int specialx1 = 138;
 static const int specialx2 = 170;
 static const int specialw  =  16;
 
 static const int num2x1    = 171;
 static const int num2x2    = 178;
 static const int num2w     = num2x2 - num2x1;
 
 static const int mod2x1    = 179;
 static const int mod2x2    = 203;
 static const int mod2w     = mod2x2 - mod2x1;
 
 static const int cursorx1  = 207;
 static const int cursorw   =  16;
 
 static const int myParenID = -10;
 
 
 typedef struct mapElement
 {
     int    qcode;
     ushort unicode;
 };
 
 static const mapElement mod1Map[] = {
     { Qt::Key_Escape, 27 },
     { Qt::Key_Tab,     9 },
     { Qt::Key_Return, 13 },
     { Qt::Key_Alt,     0 },
     { Qt::Key_Control, 0 },
 };
 
 static const uchar *const letterMap[] = {
     (const uchar *const)"zvchwk",
     (const uchar *const)"fitaly",
     (const uchar *const)"  ne  ",
     (const uchar *const)"gdorsb",
     (const uchar *const)"qjumpx",
 };
 
 static const ushort kletterMap[][6] = {
 	{ 0x110c, 0x1112, 0x1109, 0x116d, 0x1167, 0x1163 },
 	{ 0x110f, 0x1105, 0x1100, 0x1161, 0x1175, 0x1162 },
 	{ ' ',    ' ',    0x110b, 0x1165, ' ',    ' '    },
 	{ 0x1110, 0x1103, 0x1102, 0x1169, 0x1173, 0x1166 },
 	{ 0x110e, 0x1107, 0x1106, 0x1111, 0x116e, 0x1172 },
 };
 
 static const uchar *const letterMapShift[] = {
     (const uchar *const)"ZVCHWK",
     (const uchar *const)"FITALY",
     (const uchar *const)"  NE  ",
     (const uchar *const)"GDORSB",
     (const uchar *const)"QJUMPX",
 };
 
 static const ushort kletterMapShift[][6] = {
 	{ 0x110d, 0x1112, 0x110a, 0x116d, 0x1167, 0x1163 },
 	{ 0x110f, 0x1105, 0x1101, 0x1161, 0x1175, 0x1164 },
 	{ ' ',    ' ',    0x110b, 0x1165, ' ',    ' '    },
 	{ 0x1110, 0x1104, 0x1102, 0x1169, 0x1173, 0x1168 },
 	{ 0x110e, 0x1108, 0x1106, 0x1111, 0x116e, 0x1172 },
 };
 
 static const uchar *const num1Map = (const uchar *const)"12345";
 
 static const uchar *const specialMap[] = {
     (const uchar *const)"-+",
     (const uchar *const)"*!",
     (const uchar *const)",'",
     (const uchar *const)".%",
     (const uchar *const)"/$",
 };
 
 static const uchar *const specialMapShift[] = {
     (const uchar *const)"_=",
     (const uchar *const)"#?",
     (const uchar *const)";\"",
     (const uchar *const)":|",
     (const uchar *const)"\\&",
 };
 
 static const uchar *const specialMapParen[] = {
     (const uchar *const)"()",
     (const uchar *const)"[]",
     (const uchar *const)"{}",
     (const uchar *const)"<>",
     (const uchar *const)"@~",
 };
 
 static const uchar *const num2Map = (const uchar *const)"67890";
 
 static const mapElement mod2Map[] = {
     { Qt::Key_Backspace,  8 },
     { Qt::Key_Delete,     0 },
     { Qt::Key_Return,    13 },
     { Qt::Key_Shift,      0 },
     { myParenID,          0 },
 };
 
 static const int cursorMap[][2] = {
     { Qt::Key_Home, Qt::Key_PageUp   },
     { Qt::Key_End,  Qt::Key_PageDown },
     { Qt::Key_Up,   Qt::Key_Up       },
     { Qt::Key_Left, Qt::Key_Right    },
     { Qt::Key_Down, Qt::Key_Down     },
 };
 
+using namespace KJumpX;
 
 Keyboard::Keyboard(QWidget* parent, const char* name, WFlags f) :
     QFrame(parent, name, f),
     shift(0), paren(0), ctrl(0), alt(0), lang(1), lastKey(0),
     pressedKeyUnicode(0), pressedKeyQcode(0), pressedMod(0),
     isnoncont(false),
     slideKeyUnicodeH(0), slideKeyQcodeH(0), slideKeyUnicodeV(0), slideKeyQcodeV(0),
     enableMouseTracking(false), slidePix(NULL), slidePixH(NULL), slidePixV(NULL),
     releasedPix(NULL), pressedPix(NULL)
 {
     //setPalette(QPalette(QColor(240,240,230))); // Beige!
 
     releasedPlain = releasedShift = releasedParen = Resource::loadPixmap("kjumpx/released");
     pressedPlain  = pressedShift  = pressedParen  = Resource::loadPixmap("kjumpx/pressed");
     pressedDigit = Resource::loadPixmap("kjumpx/pressed");
 
     QPixmap tmp;
 
     tmp = Resource::loadPixmap("kjumpx/releasedShift");
     bitBlt(&releasedShift, letterx1, 0, &tmp);
 
     tmp = Resource::loadPixmap("kjumpx/releasedParen");
     bitBlt(&releasedParen, specialx1, 0, &tmp);
 
     tmp = Resource::loadPixmap("kjumpx/pressedShift");
     bitBlt(&pressedShift, letterx1, 0, &tmp);
 
     tmp = Resource::loadPixmap("kjumpx/pressedParen");
     bitBlt(&pressedParen, specialx1, 0, &tmp);
 
     tmp = Resource::loadPixmap("kjumpx/pressedDigit");
     bitBlt(&pressedDigit, specialx1, 0, &tmp);
 
     offscreen = QPixmap( releasedPlain );
 
     releasedPix = &releasedPlain;
     pressedPix  = &pressedPlain;
     slidePix    = &pressedPlain;
 
     delayTimer = new QTimer(this);
     rateTimer  = new QTimer(this);
     connect( delayTimer, SIGNAL( timeout() ), this, SLOT( delayTimerDone() ) );
     connect( rateTimer,  SIGNAL( timeout() ), this, SLOT( rateTimerDone() ) );
 }
 
 void Keyboard::resizeEvent(QResizeEvent*)
 {
     //cout << "resizeEvent()" << endl;
 }
 
 void Keyboard::paintEvent(QPaintEvent*)
 {
     bitBlt(this, 0, 0, &offscreen);
 }
 
 void Keyboard::mousePressEvent(QMouseEvent *e)
 {
     pressedx = -1;
     pressedKeyUnicode = pressedKeyQcode = pressedMod = 0;
 
     int x = e->x();
     int y = e->y();
 
     int row = (y - 1) / letterh;
 
     if ( x <= mod1x2 ) // mod1
     {
         pressedx = mod1x1;
         pressedy = row * letterh;
         pressedw = mod1w + 1;
         pressedh = letterh + 1;
         if ( row == 2 ) // return
         {
             pressed2x = mod2x1;
             pressed2y = 2 * letterh;
             pressed2w = mod2w + 1;
             pressed2h = letterh + 1;
             isnoncont = true;
         }
         else if ( row == 3 ) // alt
             alt = 1;
         else if ( row == 4 ) // ctrl
             ctrl = 1;
         pressedKeyUnicode = mod1Map[row].unicode;
         pressedKeyQcode   = mod1Map[row].qcode;
     }
     else if ( x >= letterx1 && x <= letterx2 ) // letter
     {
         int column = (x - letterx1 - 1) / letterw;
         QChar temp;
 		if (lang == 0) // english
         	if ( shift )
             	temp = QChar( letterMapShift[row][column] );
         	else 
             	temp = QChar( letterMap[row][column] );
 		else if (lang == 1) // korean
         	if ( shift )
             	temp = parseKoreanInput( kletterMapShift[row][column] );
         	else 
             	temp = parseKoreanInput( kletterMap[row][column] );
 
         if ( temp == ' ' ) // space
         {
             if ( column < 3 )
             {
                 pressedx  = letterx1;
                 pressed2x = letterx1 + letterw * 4;
             }
             else
             {
                 pressedx  = letterx1 + letterw * 4;
                 pressed2x = letterx1;
             }
             pressedy = pressed2y = row * letterh;
             pressedw = pressed2w = letterw * 2 + 1;
             pressedh = pressed2h = letterh + 1;
             isnoncont = true;
         }
         else
         {
             pressedx = letterx1 + column * letterw;
             pressedy = row * letterh;
             pressedw = letterw + 1;
             pressedh = letterh + 1;
         }
         pressedKeyUnicode = temp.unicode();
         pressedKeyQcode = slideKeyQcodeH = slideKeyQcodeV = temp.upper().unicode();
         if ( temp == ' ' )
         {
             slideKeyUnicodeH = slideKeyUnicodeV = 8;
             slideKeyQcodeH   = slideKeyQcodeV   = Qt::Key_Backspace;
         }
         else if ( temp == temp.lower() )
         {
             slideKeyUnicodeH = slideKeyUnicodeV = temp.upper().unicode();
             slidePixH = slidePixV = &pressedShift;
         }
         else
         {
             slideKeyUnicodeH = slideKeyUnicodeV = temp.lower().unicode();
             slidePixH = slidePixV = &pressedPlain;
         }
         enableMouseTracking = true;
     }
     else if ( x >= num1x1 && x <= num1x2 ) // num1
     {
         pressedx = num1x1;
         pressedy = row * letterh;
         pressedw = num1w + 1;
         pressedh = letterh + 1;
         QChar temp = QChar( num1Map[row] );
         pressedKeyUnicode = pressedKeyQcode = temp.unicode();
     }
     else if ( x >= specialx1 && x <= specialx2 ) // special
     {
         int column = (x - specialx1 - 1) / specialw;
         pressedx = specialx1 + column * specialw;
         pressedy = row * letterh;
         pressedw = specialw + 1;
         pressedh = letterh + 1;
         QChar temp;
         if ( shift )
             temp = QChar( specialMapShift[row][column] );
         else if ( paren )
             temp = QChar( specialMapParen[row][column] );
         else
             temp = QChar( specialMap[row][column] );
         pressedKeyUnicode = pressedKeyQcode = temp.unicode();
         slideKeyUnicodeH = slideKeyQcodeH = slideKeyUnicodeV = slideKeyQcodeV =
             QChar('0').unicode() + ( 5 * column + row + 1 ) % 10;
         slidePixH = slidePixV = &pressedDigit;
         if ( shift )
         {
             slideKeyUnicodeV = slideKeyQcodeV =
                 QChar( specialMap[row][column] ).unicode();
             slidePixV = &pressedPlain;
         }
         else if ( !(shift || paren) )
         {
             slideKeyUnicodeV = slideKeyQcodeV =
                 QChar( specialMapShift[row][column] ).unicode();
             slidePixV = &pressedShift;
         }
         enableMouseTracking = true;
     }
     else if ( x >= num2x1 && x <= num2x2 ) // num2
     {
         pressedx = num2x1;
         pressedy = row * letterh;
         pressedw = num2w + 1;
         pressedh = letterh + 1;
         QChar temp = QChar( num2Map[row] );
         pressedKeyUnicode = pressedKeyQcode = temp.unicode();
     }
     else if ( x >= mod2x1 && x <= mod2x2 ) // mod2
     {
         pressedx = mod2x1;
         pressedy = row * letterh;
         pressedw = mod2w + 1;
         pressedh = letterh + 1;
         if ( row == 2 ) // return
         {
             pressed2x = mod1x1;
             pressed2y = 2 * letterh;
             pressed2w = mod2w + 1;
             pressed2h = letterh + 1;
             isnoncont = true;
         }
         pressedKeyUnicode = mod2Map[row].unicode;
         pressedKeyQcode   = mod2Map[row].qcode;
 
         if ( row == 3 ) // shift
         {
             paren = 0;
             switch ( shift )
             {
             case 0:
             {
                 shift = 1;
                 releasedPix = &releasedShift;
                 pressedPix = &pressedShift;
                 bitBlt( &offscreen, 0, 0, releasedPix );
                 break;
             }
             case 1:
             {
                 shift = 2;
                 break;
             }
             case 2:
             {
                 shift = 0;
                 releasedPix = &releasedPlain;
                 pressedPix = &pressedPlain;
                 bitBlt( &offscreen, 0, 0, releasedPix );
                 break;
             }
             }
         }
         else if ( row == 4 ) // parenthesis
         {
             shift = 0;
             switch ( paren )
             {
             case 0:
             {
                 paren = 1;
                 releasedPix = &releasedParen;
                 pressedPix = &pressedParen;
                 bitBlt( &offscreen, 0, 0, releasedPix );
                 break;
             }
             case 1:
             {
                 paren = 2;
                 break;
             }
             case 2:
             {
                 paren = 0;
                 releasedPix = &releasedPlain;
                 pressedPix = &pressedPlain;
                 bitBlt( &offscreen, 0, 0, releasedPix );
                 break;
             }
             }
         }
     }
     else if ( x >= cursorx1 ) // cursor
     {
         int column = (x - cursorx1 - 1) / cursorw;
         if ( row == 2 || row == 4 )
             pressedx = cursorx1 + cursorw / 2;
         else
             pressedx = cursorx1 + column * cursorw;
         pressedy = row * letterh;
         pressedw = cursorw + 1;
         pressedh = letterh + 1;
         pressedKeyQcode = cursorMap[row][column];
     }
 
     pressedMod = ( shift ? Qt::ShiftButton : 0 ) |
                  ( ctrl ? Qt::ControlButton : 0 ) |
                  ( alt ? Qt::AltButton : 0 );
 
 	lastKey = pressedKeyUnicode;
 
     emit key( pressedKeyUnicode, pressedKeyQcode, pressedMod, true, false );
     delayTimer->start( autorepeatDelaytime, true );
 
     if ( pressedx == -1 )
         return;
 
     bitBlt( &offscreen, pressedx, pressedy,
             pressedPix, pressedx, pressedy, pressedw, pressedh );
     if ( isnoncont )
         bitBlt( &offscreen, pressed2x, pressed2y,
                 pressedPix, pressed2x, pressed2y, pressed2w, pressed2h );
 
     repaint( false );
 }
 
 void Keyboard::mouseReleaseEvent(QMouseEvent*)
 {
     //cout << pressedx << " " << pressedy << " " << pressedw << " " << pressedh << endl;
 
     delayTimer->stop();
     rateTimer->stop();
     enableMouseTracking = false;
 
     if ( pressedx == -1 )
         return;
 
     if ( shift == 2 && pressedKeyQcode == Qt::Key_Shift )
         return;
     if ( paren == 2 && pressedKeyQcode == myParenID )
         return;
 
     if ( shift == 1 && pressedKeyQcode != Qt::Key_Shift )
     {
         shift = 0;
         releasedPix = &releasedPlain;
         pressedPix = &pressedPlain;
         bitBlt( &offscreen, 0, 0, releasedPix );
     }
 
     if ( paren == 1 && pressedKeyQcode != myParenID )
     {
         paren = 0;
         releasedPix = &releasedPlain;
         pressedPix = &pressedPlain;
         bitBlt( &offscreen, 0, 0, releasedPix );
     }
 
     if ( alt && pressedKeyQcode != Qt::Key_Alt )
         alt = 0;
     if ( ctrl && pressedKeyQcode != Qt::Key_Control )
         ctrl = 0;
 
     bitBlt( &offscreen, pressedx, pressedy,
             releasedPix, pressedx, pressedy, pressedw, pressedh );
 
     if ( isnoncont )
     {
         isnoncont = false;
         bitBlt( &offscreen, pressed2x, pressed2y,
                 releasedPix, pressed2x, pressed2y, pressed2w, pressed2h );
     }
 
     repaint( false );
 }
 
 void Keyboard::mouseMoveEvent(QMouseEvent *e)
 {
     if ( !enableMouseTracking )
         return;
 
     if ( e->x() < pressedx || e->x() >= pressedx + pressedw )
     {
         pressedKeyUnicode = slideKeyUnicodeH;
         pressedKeyQcode = slideKeyQcodeH;
         slidePix = slidePixH;
     }
     else if ( e->y() < pressedy || e->y() >= pressedy + pressedh )
     {
         pressedKeyUnicode = slideKeyUnicodeV;
         pressedKeyQcode = slideKeyQcodeV;
         slidePix = slidePixV;
     }
     else
         return;
 
     enableMouseTracking = false;
 
     delayTimer->stop();
     rateTimer->stop();
 
     bitBlt( &offscreen, pressedx, pressedy,
             slidePix, pressedx, pressedy, pressedw, pressedh );
 
     emit key( 8, Qt::Key_Backspace, pressedMod, true, false );
     emit key( pressedKeyUnicode, pressedKeyQcode, pressedMod, true, false );
     delayTimer->start( autorepeatDelaytime, true );
 
     repaint( false );
 }
 
 void Keyboard::delayTimerDone()
 {
     emit key( pressedKeyUnicode, pressedKeyQcode, pressedMod, true, true );
     rateTimer->start( 1000/autorepeatRate, false );
 }
 
 void Keyboard::rateTimerDone()
 {
     emit key( pressedKeyUnicode, pressedKeyQcode, pressedMod, true, true );
 }
 
 QSize Keyboard::sizeHint() const
 {
     return offscreen.size();
 }
 
 void Keyboard::resetState()
 {
     //cout << "resetState()" << endl;
 }
 
 /*
  *
  * TODO
  * one major problem with this implementation is that you can't move the
  * cursor after inputing korean chars, otherwise it will eat up and replace
  * the char before the cursor you move to. fix that
  *
  * make a kor/eng swaping key
  *
  * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
  *
  * how korean input works
  *
  * all following chars means unicode char value and are in hex
  *
  * ���� = schar (start char)
  * ���� = mchar (middle char)
  * ���� = echar (end char)
  *
  * there are 19 schars. unicode position is at 1100 - 1112
  * there are 21 mchars. unicode position is at 1161 - 1175
  * there are 27 echars. unicode position is at 11a8 - 11c2
  *
  * the map with everything combined is at ac00 - d7a3
  *
  * to find a combination of schar + mchar in the map, lookup 
  * ((schar - 0x1100) * 587) + ((mchar - 0x1161) * 27) + (echar - 0x11a8) + 0xac00)
  *
  */
 
 QChar Keyboard::parseKoreanInput (ushort c) {
 
 	static ushort schar, mchar, echar;
 
 	if ((lastKey < 0x1100 || 0x11c2 < lastKey) && (lastKey < 0xac00 || 0xd7a3 < lastKey)
 					&& !(lastKey == 0 && (shift || paren || ctrl || alt))) {
 
 		//printf ("reset...\n");
 		schar = 0, mchar = 0, echar = 0;
 	}
 
 	//printf ("in %x %x %x %x %x\n", schar, mchar, echar, c, lastKey);
 	if ( 0x1100 <= c && c <= 0x1112 ) { // schar or echar was input
 
 		if (schar == 0 || (schar != 0 && mchar == 0)) {
 			schar = c; mchar = 0; echar = 0;
 			return QChar(c);
 		}
 		else if (mchar != 0) {
 
 			if (echar == 0) {
 
 				if (!(echar = constoe(c))) {
 
 					schar = c; mchar = 0; echar = 0; 
 					return QChar(c);
 				}
 
 			}
 			else { // must figure out what the echar is
 
 				if (echar == 0x11a8) { // ��
 
 					if (c == 0x1100) 		echar = 0x11a9; // �� + ��
 					else if (c == 0x1109) 	echar = 0x11aa; // �� + ��
 					else { 
 						schar = c; mchar = 0; echar = 0; 
 						return QChar(c);
 					}
 
 				} else if (echar == 0x11ab) { // ��
 
 					if (c == 0x110c)  		echar = 0x11ac; // �� + ��
 					else if (c == 0x1112)  	echar = 0x11ad; // �� + ��
 					else {
 						schar = c; mchar = 0; echar = 0; 
 						return QChar(c);
 					}
 
 				} else if (echar == 0x11af) { // ��
 
 					if (c == 0x1100) 		echar = 0x11b0; // �� + ��
 					else if (c == 0x1106) 	echar = 0x11b1; // �� + ��
 					else if (c == 0x1107) 	echar = 0x11b2; // �� + ��
 					else if (c == 0x1109) 	echar = 0x11b3; // �� + ��
 					else if (c == 0x1110) 	echar = 0x11b4; // �� + ��
 					else if (c == 0x1111) 	echar = 0x11b5; // �� + ��
 					else if (c == 0x1112) 	echar = 0x11b6; // �� + ��
 					else {
 						schar = c; mchar = 0; echar = 0; 
 						return QChar(c);
 					}
 
 				} else if (echar == 0x11b8) { // ��
 
 					if (c == 0x1109) 		echar = 0x11b9; // �� + ��
 					else {
 						schar = c; mchar = 0; echar = 0; 
 						return QChar(c);
 					}
 
 				} else if (echar == 0x11ba) { // �� 
 
 					if (c == 0x1109) 		echar = 0x11bb; // �� + �� 
 					else {
 						schar = c; mchar = 0; echar = 0; 
 						return QChar(c);
 					}
 
 				} else { // if any other char, cannot combine chars
 
 					schar = c; mchar = 0; echar = 0;
 					return QChar(c);
 				}
 
 				lastKey  = echar;
 			}
 		}
 
 	}
 	else if (0x1161 <= c && c <= 0x1175) { // mchar was input
 
 		if (schar != 0 && mchar == 0) { mchar = c; }
 
 		else if (schar != 0 && mchar != 0 && echar == 0) {
 
 			switch (mchar) {
 				case 0x1169:
 					if (c == 0x1161) mchar = 0x116a;
 					else if (c == 0x1162) mchar = 0x116b;
 					else if (c == 0x1175) mchar = 0x116c;
 					else {
 						schar = 0; mchar = 0; echar = 0;
 						return QChar(c);
 					}
 					break;
 				case 0x116e:
 					if (c == 0x1165) mchar = 0x116f;
 					else if (c == 0x1166) mchar = 0x1170;
 					else if (c == 0x1175) mchar = 0x1171;
 					else {
 						schar = 0; mchar = 0; echar = 0;
 						return QChar(c);
 					}
 					break;
 				case 0x1173:
 					if (c == 0x1175) mchar = 0x1174;
 					else {
 						schar = 0; mchar = 0; echar = 0;
 						return QChar(c);
 					}
 					break;
 				default: 
 					schar = 0; mchar = 0; echar = 0;
 					return QChar(c);
 			}
 		}
 		else if (schar != 0 && mchar != 0 && echar != 0) {
 
 			emit key( 8, Qt::Key_Backspace, 0, true, false );
 
 			ushort prev = 0;
 			switch (echar) {
 				/*
 				case 0x11a9:
 					prev = combineKoreanChars(schar, mchar, 0x11a8);
 					schar = 0x1100; 
 					break;
 				*/
 				case 0x11aa:
 					prev = combineKoreanChars(schar, mchar, 0x11a8);
 					schar = 0x1109;
 					break;
 				case 0x11ac:
 					prev = combineKoreanChars(schar, mchar, 0x11ab);
 					schar = 0x110c; 
 					break;
 				case 0x11ad:
 					prev = combineKoreanChars(schar, mchar, 0x11ab);
 					schar = 0x1112;
 					break;
 				case 0x11b0:
 					prev = combineKoreanChars(schar, mchar, 0x11af);
 					schar = 0x1100; 
 					break;
 				case 0x11b1:
 					prev = combineKoreanChars(schar, mchar, 0x11af);
 					schar = 0x1106;
 					break;
 				case 0x11b2:
 					prev = combineKoreanChars(schar, mchar, 0x11af);
 					schar = 0x1107; 
 					break;
 				case 0x11b3:
 					prev = combineKoreanChars(schar, mchar, 0x11af);
 					schar = 0x1109;
 					break;
 				case 0x11b4:
 					prev = combineKoreanChars(schar, mchar, 0x11af);
 					schar = 0x1110;
 					break;
 				case 0x11b9:
 					prev = combineKoreanChars(schar, mchar, 0x11b8);
 					schar = 0x1109;
 					break;
 				/*
 				case 0x11bb:
 					prev = combineKoreanChars(schar, mchar, 0x11ba);
 					schar = 0x1109; 
 					break;
 				*/
 				default: 
 
 					if (constoe(echar)) {
 
 						prev = combineKoreanChars(schar, mchar, 0);
 						schar = constoe(echar); 
 					} 
 					break;
 			}
 			
 			emit key( prev, prev, 0, true, false );
 
 			mchar = c; echar = 0;
 
 			return QChar(combineKoreanChars(schar, mchar, 0));
 		
 		} 
 		else {
 			schar = 0; mchar = 0; echar = 0;
 			return QChar(c);
 		}
 
 	} 
 	else if (c == ' ') return QChar(c);
 
 
 	// and now... finally delete previous char, and return new char
 	emit key( 8, Qt::Key_Backspace, 0, true, false );
 
 	//printf ("out %x %x %x %x\n", schar, mchar, echar, c);
 
 
 	return QChar (combineKoreanChars( schar, mchar, echar));
 
 }
 
 ushort Keyboard::combineKoreanChars(const ushort s, const ushort m, const ushort e) {
 
 	return ((s - 0x1100) * 588) + ((m - 0x1161) * 28) + (e ? e - 0x11a7 : 0) + 0xac00;
 
 }
 
 ushort Keyboard::constoe(const ushort c) {
 
 	// converts schars to echars if possible
 
 	if (0x1100 <= c && c <= 0x1112) { // schar to echar
 
 		switch (c) {
 			case 0x1100: return 0x11a8;
 			case 0x1101: return 0x11a9;
 			case 0x1102: return 0x11ab;
 			case 0x1103: return 0x11ae;
 			case 0x1105: return 0x11af;
 			case 0x1106: return 0x11b7;
 			case 0x1107: return 0x11b8;
 			case 0x1109: return 0x11ba;
 			case 0x110a: return 0x11bb;
 			case 0x110b: return 0x11bc;
 			case 0x110c: return 0x11bd;
 			case 0x110e: return 0x11be;
 			case 0x110f: return 0x11bf;
 			case 0x1110: return 0x11c0;
 			case 0x1111: return 0x11c1;
 			case 0x1112: return 0x11c2;
 			default: return 0;
 
 		}
 
 	} else { //echar to schar
 
 		switch (c) {
 			case 0x11a8: return 0x1100;
 			case 0x11a9: return 0x1101;
 			case 0x11ab: return 0x1102;
 			case 0x11ae: return 0x1103;
 			case 0x11af: return 0x1105;
 			case 0x11b7: return 0x1106;
 			case 0x11b8: return 0x1107;
 			case 0x11ba: return 0x1109;
 			case 0x11bb: return 0x110a;
 			case 0x11bc: return 0x110b;
 			case 0x11bd: return 0x110c;
 			case 0x11be: return 0x110e;
 			case 0x11bf: return 0x110f;
 			case 0x11c0: return 0x1110;
 			case 0x11c1: return 0x1111;
 			case 0x11c2: return 0x1112;
 			default: return 0;
 
 		}
 
 	}
 }
diff --git a/inputmethods/kjumpx/keyboard.h b/inputmethods/kjumpx/keyboard.h
index 148cb72..ca83915 100644
--- a/inputmethods/kjumpx/keyboard.h
+++ b/inputmethods/kjumpx/keyboard.h
@@ -1,79 +1,84 @@
 /**************************************************************************************94x78**
 **
 ** This file may be distributed and/or modified under the terms of the
 ** GNU General Public License version 2 as published by the Free Software
 ** Foundation and appearing in the file LICENSE.GPL included in the
 ** packaging of this file.
 **
 ** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 ** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 **
 *********************************************************************************************/
 #include <qframe.h>
 #include <qpixmap.h>
 #include <qtimer.h>
 
+namespace KJumpX
+{
+
 class Keyboard : public QFrame
 {
     Q_OBJECT
 public:
     Keyboard( QWidget* parent=0, const char* name=0, WFlags f=0 );
 
     void resetState();
 
     void mousePressEvent(QMouseEvent*);
     void mouseReleaseEvent(QMouseEvent*);
     void mouseMoveEvent(QMouseEvent*);
     void resizeEvent(QResizeEvent*);
     void paintEvent(QPaintEvent* e);
     //void timerEvent(QTimerEvent* e);
 
     QSize sizeHint() const;
 
 	QChar parseKoreanInput(ushort);
 	ushort combineKoreanChars(const ushort, const ushort, const ushort);
 	ushort constoe(const ushort);
 
 
 signals:
     void key( ushort unicode, ushort qcode, ushort modifiers, bool, bool );
 
 private slots:
     void delayTimerDone();
     void rateTimerDone();
 
 private:
     int shift; // 0, 1, 2
     int paren; // 0, 1, 2
     int ctrl;  // 0, 1
     int alt;   // 0, 1
 	bool lang; // 0 -> english, 1 -> korean
 
 	int lastKey;
 
     int pressedKeyUnicode, pressedKeyQcode, pressedMod;
     int pressedx, pressedy, pressedw, pressedh;
     bool isnoncont;
     int pressed2x, pressed2y, pressed2w, pressed2h;
 
     int slideKeyUnicodeH, slideKeyQcodeH, slideKeyUnicodeV, slideKeyQcodeV;
     bool enableMouseTracking;
     QPixmap *slidePix, *slidePixH, *slidePixV;
 
     QPixmap releasedPlain;
     QPixmap releasedShift;
     QPixmap releasedParen;
 
     QPixmap pressedPlain;
     QPixmap pressedShift;
     QPixmap pressedParen;
     QPixmap pressedDigit;
 
     QPixmap offscreen;
 
     QPixmap *releasedPix;
     QPixmap *pressedPix;
 
     QTimer *delayTimer;
     QTimer *rateTimer;
 };
+
+} // namespace KJumpX
diff --git a/inputmethods/kjumpx/keyboardimpl.cpp b/inputmethods/kjumpx/keyboardimpl.cpp
index 5d8e0d3..976d816 100644
--- a/inputmethods/kjumpx/keyboardimpl.cpp
+++ b/inputmethods/kjumpx/keyboardimpl.cpp
@@ -1,97 +1,97 @@
 /**************************************************************************************94x78**
 **
 ** This file may be distributed and/or modified under the terms of the
 ** GNU General Public License version 2 as published by the Free Software
 ** Foundation and appearing in the file LICENSE.GPL included in the
 ** packaging of this file.
 **
 ** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 ** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 **
 *********************************************************************************************/
 #include <qapplication.h>
 #include <qpixmap.h>
 #include "keyboard.h"
 #include "keyboardimpl.h"
 
 /* XPM */
-static char * icon_xpm[] = {
+static const char * const icon_xpm[] = {
 "26 13 2 1",
 " 	c None",
 ".	c #000000",
 " ... ... ... ... ... ...  ",
 ".   .   .           .   . ",
 ".   .     ...  ..   .   . ",
 ".   .          ..   .   . ",
 " ...... ...... ...  ....  ",
 ".        .. .. ..       . ",
 ".        .. .. ..       . ",
 ".         ...  ..       . ",
 " ......  ..       ......  ",
 ".   .    ..         .   . ",
 ".   .     .......   .   . ",
 ".   .   .           .   . ",
 " ... ... ... ... ... ...  "};
 
 
 KeyboardImpl::KeyboardImpl()
     : input(0), icn(0), ref(0)
 {
 }
 
 KeyboardImpl::~KeyboardImpl()
 {
     delete input;
     delete icn;
 }
 
 QWidget *KeyboardImpl::inputMethod( QWidget *parent, Qt::WFlags f )
 {
     if ( !input )
-	input = new Keyboard( parent, "Keyboard", f );
+	input = new KJumpX::Keyboard( parent, "Keyboard", f );
     return input;
 }
 
 void KeyboardImpl::resetState()
 {
     if ( input )
 	input->resetState();
 }
 
 QPixmap *KeyboardImpl::icon()
 {
     if ( !icn )
 	icn = new QPixmap( (const char **)icon_xpm );
     return icn;
 }
 
 QString KeyboardImpl::name()
 {
     return qApp->translate( "InputMethods", "KJumpX" );
 }
 
 void KeyboardImpl::onKeyPress( QObject *receiver, const char *slot )
 {
     if ( input )
 	QObject::connect( input, SIGNAL(key(ushort,ushort,ushort,bool,bool)), receiver, slot );
 }
 
 #ifndef QT_NO_COMPONENT
 QRESULT KeyboardImpl::queryInterface( const QUuid &uuid, QUnknownInterface **iface )
 {
     *iface = 0;
     if ( uuid == IID_QUnknown )
 	*iface = this;
     else if ( uuid == IID_InputMethod )
 	*iface = this;
 
     if ( *iface )
 	(*iface)->addRef();
     return QS_OK;
 }
 
 Q_EXPORT_INTERFACE()
 {
     Q_CREATE_INSTANCE( KeyboardImpl )
 }
 #endif
diff --git a/inputmethods/kjumpx/keyboardimpl.h b/inputmethods/kjumpx/keyboardimpl.h
index a82ec4a..1ff1034 100644
--- a/inputmethods/kjumpx/keyboardimpl.h
+++ b/inputmethods/kjumpx/keyboardimpl.h
@@ -1,43 +1,51 @@
 /**************************************************************************************94x78**
 **
 ** This file may be distributed and/or modified under the terms of the
 ** GNU General Public License version 2 as published by the Free Software
 ** Foundation and appearing in the file LICENSE.GPL included in the
 ** packaging of this file.
 **
 ** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 ** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 **
 *********************************************************************************************/
 #ifndef KEYBOARDIMPL_H
 #define KEYBOARDIMPL_H
 
 #include <qpe/inputmethodinterface.h>
 
+namespace KJumpX
+{
 class Keyboard;
+}
 class QPixmap;
 
+namespace
+{
+
 class KeyboardImpl : public InputMethodInterface
 {
 public:
     KeyboardImpl();
     virtual ~KeyboardImpl();
 
 #ifndef QT_NO_COMPONENT
     QRESULT queryInterface( const QUuid&, QUnknownInterface** );
     Q_REFCOUNT
 #endif
 
     virtual QWidget *inputMethod( QWidget *parent, Qt::WFlags f );
     virtual void resetState();
     virtual QPixmap *icon();
     virtual QString name();
     virtual void onKeyPress( QObject *receiver, const char *slot );
 
 private:
-    Keyboard *input;
+    KJumpX::Keyboard *input;
     QPixmap *icn;
     ulong ref;
 };
 
+} // anonymous namespace
+
 #endif
diff --git a/inputmethods/multikey/keyboard.cpp b/inputmethods/multikey/keyboard.cpp
index 84c0c74..c22fbb1 100644
--- a/inputmethods/multikey/keyboard.cpp
+++ b/inputmethods/multikey/keyboard.cpp
@@ -1,1063 +1,1064 @@
 /**********************************************************************
 ** Copyright (C) 2000 Trolltech AS.  All rights reserved.
 **
 ** This file is part of Qtopia Environment.
 **
 ** This file may be distributed and/or modified under the terms of the
 ** GNU General Public License version 2 as published by the Free Software
 ** Foundation and appearing in the file LICENSE.GPL included in the
 ** packaging of this file.
 **
 ** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 ** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 **
 ** See http://www.trolltech.com/gpl/ for GPL licensing information.
 **
 ** Contact info@trolltech.com if any conditions of this licensing are
 ** not clear to you.
 **
 **********************************************************************/
 
 #include "keyboard.h"
 #include "configdlg.h"
 
 #include <qpe/global.h>
 #include <qpe/qcopenvelope_qws.h>
 
 #include <qwindowsystem_qws.h>
 #include <qpainter.h>
 #include <qfontmetrics.h>
 #include <qtimer.h>
 #include <qpe/qpeapplication.h>
 #include <qpe/config.h>
 #include <ctype.h>
 #include <qfile.h>
 #include <qtextstream.h>
 #include <qstringlist.h>
 
 #include <sys/utsname.h>
 
+using namespace MultiKey;
 
 /* Keyboard::Keyboard {{{1 */
 Keyboard::Keyboard(QWidget* parent, const char* _name, WFlags f) :
     QFrame(parent, _name, f),  shift(0), lock(0), ctrl(0), alt(0), 
     meta(0), circumflex(0), diaeresis(0), baccent(0), accent(0),
     useLargeKeys(TRUE), usePicks(0), useRepeat(0), 
     pressedKeyRow(-1), pressedKeyCol(-1),
     unicode(-1), qkeycode(0), modifiers(0), schar(0), mchar(0), echar(0),
     configdlg(0)
 
 {
 
     // get the default font
     Config *config = new Config( "qpe" );
     config->setGroup( "Appearance" );
     QString familyStr = config->readEntry( "FontFamily", "fixed" );
     delete config;
 
     config = new Config("multikey");
     config->setGroup ("general");
     usePicks = config->readBoolEntry ("usePickboard", 0); // default closed
     useRepeat = config->readBoolEntry ("useRepeat", 1);
     delete config;
 
 
     setFont( QFont( familyStr, 10 ) );
 
     picks = new KeyboardPicks( this );
     picks->setFont( QFont( familyStr, 10 ) );
     picks->initialise();
     if (usePicks) {
 
         QObject::connect( picks, SIGNAL(key(ushort,ushort,ushort,bool,bool) ),
             this, SIGNAL(key(ushort,ushort,ushort,bool,bool)) );
 
     } else picks->hide();
 
     loadKeyboardColors();
 
     keys = new Keys();
 
     repeatTimer = new QTimer( this );
     connect( repeatTimer, SIGNAL(timeout()), this, SLOT(repeat()) );
 
 }
 
 Keyboard::~Keyboard() {
 
     if ( configdlg ) { 
         delete (ConfigDlg *) configdlg; 
         configdlg = 0;
     }
 
 }
 
 /* Keyboard::resizeEvent {{{1 */
 void Keyboard::resizeEvent(QResizeEvent*)
 {
     int ph = picks->sizeHint().height();
     picks->setGeometry( 0, 0, width(), ph );
     keyHeight = (height()-(usePicks ? ph : 0))/(keys->rows()?keys->rows():1);
 
     int nk; // number of keys?
     if ( useLargeKeys ) {
 	nk = 15;
     } else {
 	nk = 19;
     }
     defaultKeyWidth = (width()/nk)/2;
     xoffs = (width()-defaultKeyWidth*nk)/2; // empty key spaces?
 
 }
 
 /* KeyboardPicks::initialize {{{1 */
 void KeyboardPicks::initialise()
 {
     setSizePolicy(QSizePolicy(QSizePolicy::Expanding,QSizePolicy::Fixed));
     mode = 0;
     dc = new KeyboardConfig(this);
     configs.append(dc);
 }
 
 /* KeyboardPicks::sizeHint {{{1 */
 QSize KeyboardPicks::sizeHint() const
 {
     return QSize(240,fontMetrics().lineSpacing());
 }
 
 
 /* KeyboardConfig::generateText {{{1 */
 void  KeyboardConfig::generateText(const QString &s)
 {
 #if defined(Q_WS_QWS) || defined(_WS_QWS_)
     for (int i=0; i<(int)backspaces; i++) {
 	parent->emitKey( 0, Qt::Key_Backspace, 0, true, false );
 	parent->emitKey( 0, Qt::Key_Backspace, 0, false, false );
     }
     for (int i=0; i<(int)s.length(); i++) {
 	parent->emitKey( s[i].unicode(), 0, 0, true, false );
 	parent->emitKey( s[i].unicode(), 0, 0, false, false );
     }
     parent->emitKey( 0, Qt::Key_Space, 0, true, false );
     parent->emitKey( 0, Qt::Key_Space, 0, false, false );
     backspaces = 0;
 #endif
 }
 
 
 
 
 /* Keyboard::paintEvent {{{1 */
 void Keyboard::paintEvent(QPaintEvent* e)
 {
     QPainter painter(this);
     painter.setClipRect(e->rect());
     drawKeyboard( painter );
     picks->dc->draw( &painter );
 }
 
 
 /* Keyboard::drawKeyboard {{{1 */
 
 void Keyboard::drawKeyboard(QPainter &p, int row, int col)
 {
 
 
     if (row != -1 && col != -1) { //just redraw one key
 
         int x = 0;
         for (int i = 0; i < col; i++) {
 
             x += keys->width(row, i) * defaultKeyWidth;
         }
         int y = (row - 1) * keyHeight + (usePicks ? picks->height() : 0);
 
         int keyWidth = keys->width(row, col);
 
         p.fillRect(x + 1, y + 1, 
                    keyWidth * defaultKeyWidth - 1, keyHeight - 1, 
                    pressed || keys->pressed(row, col) ? keycolor_pressed : keycolor);
 
         QImage *pix = keys->pix(row,col);
 
         ushort c = keys->uni(row, col);
 
         p.setPen(textcolor);
         if (!pix) {
             if ((shift || lock) && keys->shift(c)) 
 
                 if (circumflex && keys->circumflex(keys->shift(c)))
                     c = keys->circumflex(keys->shift(c));
                 else if (diaeresis && keys->diaeresis(keys->shift(c)))
                     c = keys->diaeresis(keys->shift(c));
 			 else if (baccent && keys->baccent(keys->shift(c)))
                     c = keys->baccent(keys->shift(c));
                 else if (accent && keys->accent(keys->shift(c)))
                     c = keys->accent(keys->shift(c));
                 else if (meta && keys->meta(keys->shift(c)))
                     c = keys->meta(keys->shift(c));
                 else 
                     c = keys->shift(c);
 
             else if (meta && keys->meta(c)) 
                 c = keys->meta(c);
             else if (circumflex && keys->circumflex(c)) 
                 c = keys->circumflex(c);
 		  else if (baccent && keys->baccent(c))
                 c = keys->baccent(c);
 		  else if (accent && keys->accent(c))
                 c = keys->accent(c);
             else if (diaeresis && (keys->diaeresis(c) || c == 0x2c6)) {
 
                 // the diaeresis key itself has to be in the diaeresisMap,
                 // or just do this to make it display the diaeresis char.
                 
                 if (c == 0x2c6)
                     c = 0xa8;
                 else 
                     c = keys->diaeresis(c);
             }
             
             p.drawText(x, y, 
                defaultKeyWidth * keyWidth + 3, keyHeight,
                AlignCenter, (QChar)c);
         }
         else
             // center the image in the middle of the key
             p.drawImage( x + (defaultKeyWidth * keyWidth - pix->width())/2 + 1, 
                           y + (keyHeight - pix->height())/2 + 1, 
                           *pix );
 
         // this fixes the problem that the very right end of the board's vertical line
         // gets painted over, because it's one pixel shorter than all other keys
         p.setPen(keycolor_lines);
         p.drawLine(width() - 1, 0, width() - 1, height());
 
     } else {
 
 
     p.fillRect(0, 0, width(), height(), keycolor);
 
     for (row = 1; row <= keys->rows(); row++) {
 
         int x = 0;
         int y = (row - 1) * keyHeight + (usePicks ? picks->height() : 0);
 
         p.setPen(keycolor_lines);
         p.drawLine(x, y, x + width(), y);
 
         for (int col = 0; col < keys->numKeys(row); col++) {
 
             QImage *pix = keys->pix(row, col);
             int keyWidth = keys->width(row, col);
 
 
             int keyWidthPix = defaultKeyWidth * keyWidth;
 
             if (keys->pressed(row, col)) 
                 p.fillRect(x+1, y+1, keyWidthPix - 1, 
                            keyHeight - 1, keycolor_pressed);
 
             ushort c = keys->uni(row, col);
 
             p.setPen(textcolor);
             if (!pix) {
                 if ((shift || lock) && keys->shift(c)) 
 
                     if (circumflex && keys->circumflex(keys->shift(c)))
                         c = keys->circumflex(keys->shift(c));
                     else if (diaeresis && keys->diaeresis(keys->shift(c)))
                         c = keys->diaeresis(keys->shift(c));
                     else if (baccent && keys->baccent(keys->shift(c)))
                         c = keys->baccent(keys->shift(c));
                     else if (accent && keys->accent(keys->shift(c)))
                         c = keys->accent(keys->shift(c));
                     else if (meta && keys->meta(keys->shift(c)))
                         c = keys->meta(keys->shift(c));
                     else 
                         c = keys->shift(c);
 
                 else if (meta && keys->meta(c)) 
                     c = keys->meta(c);
                 else if (circumflex && keys->circumflex(c))
                     c = keys->circumflex(c);
                 else if (baccent && keys->baccent(c))
                     c = keys->baccent(c);
                 else if (accent && keys->accent(c))
                     c = keys->accent(c);
                 else if (diaeresis && (keys->diaeresis(c) || c == 0x2c6)) {
 
                     if (c == 0x2c6)
                         c = 0xa8;
                     else 
                         c = keys->diaeresis(c);
                 }
 
                 p.drawText(x, y, 
                    keyWidthPix + 3, keyHeight,
                    AlignCenter, (QChar)c);
             }
             else {
                 // center the image in the middle of the key
                 pix->setColor(1, textcolor.rgb());
                 p.drawImage( x + (keyWidthPix - pix->width())/2 + 1, 
                               y + (keyHeight - pix->height())/2 + 1, 
                               QImage(*pix) );
             }
 
             p.setPen(keycolor_lines);
             p.drawLine(x, y, x, y + keyHeight);
 
             x += keyWidthPix;
         }
 
 
     }
     p.setPen(keycolor_lines);
     p.drawLine(0, height() - 1, width(), height() - 1);
     p.drawLine(width() - 1, 0, width() - 1, height());
     }
 
 }
 
 
 /* Keyboard::mousePressEvent {{{1 */
 void Keyboard::mousePressEvent(QMouseEvent *e)
 {
     int row = (e->y() - (usePicks ? picks->height() : 0)) / keyHeight + 1;
     if (row > 5) row = 5;
 
     // figure out the column
     int col = 0; 
     for (int w = 0; e->x() >= w; col++)
         if (col < keys->numKeys(row)) // it segfaults if it trys to read past numKeys
             w += keys->width(row,col) * defaultKeyWidth;
         else break;
 
     if (col <= 0) return;
 
     col --; // rewind one...
 
     qkeycode = keys->qcode(row, col);
     unicode = keys->uni(row, col);
 
     // might need to repaint if two or more of the same keys.
     // should be faster if just paint one key even though multiple keys exist.
     bool need_repaint = FALSE; 
 
     // circumflex and diaeresis support
     // messy to have this here, but too hard to implement any other method
     if (unicode == 0x2c6) { 
 
         unicode = 0; 
         if (shift || lock) {
 
             // diaeresis
             qkeycode = 0x2001; 
         }
         else {
             
             // circumflex
             qkeycode = 0x2000; 
         }
     }
 
     // Back accent character support
 
     // the keys from 2c6 ~ 2cf should be used instead of the ascii one
     if (unicode == 0x2cb) {
 
         unicode = 0;
         if (shift || lock) {
 
             // circumblex
             qkeycode = 0x2000;
         }
         else {
 
             // back accent
             qkeycode = 0x2002;
         }
     }
 
     // Accent character support
 
     if (unicode == 0x2ca) {
 
         unicode = 0;
         if (shift || lock) {
 
             // diaeresis
             qkeycode = 0x2001;
         }
         else {
 
             // accent
             qkeycode = 0x2003;
         }
     }
 
 
     if (unicode == 0) { // either Qt char, or nothing
 
         if (qkeycode == Qt::Key_F1) { // toggle the pickboard
 
             if ( configdlg ) { 
 
                 delete (ConfigDlg *) configdlg; 
                 configdlg = 0;
             }
             else {
                configdlg = new ConfigDlg ();
                connect(configdlg, SIGNAL(setMapToDefault()), 
                        this, SLOT(setMapToDefault()));
                connect(configdlg, SIGNAL(setMapToFile(QString)), 
                        this, SLOT(setMapToFile(QString)));
                connect(configdlg, SIGNAL(pickboardToggled(bool)), 
                        this, SLOT(togglePickboard(bool)));
                connect(configdlg, SIGNAL(repeatToggled(bool)),
                        this, SLOT(toggleRepeat(bool)));
                connect(configdlg, SIGNAL(reloadKeyboard()),
                        this, SLOT(reloadKeyboard()));
                connect(configdlg, SIGNAL(configDlgClosed()),
                        this, SLOT(cleanupConfigDlg()));
                configdlg->showMaximized();
                configdlg->show();
                configdlg->raise();
             }
 
         } else if (qkeycode == Qt::Key_Control) {
             need_repaint = TRUE;
 
             if (ctrl) {
 
                 *ctrl = 0;
                 ctrl = 0;
 
             } else {
 
                 ctrl = keys->pressedPtr(row, col);
                 need_repaint = TRUE;
                 *ctrl = !keys->pressed(row, col);
 
             }
 
         } else if (qkeycode == Qt::Key_Alt) {
             need_repaint = TRUE;
 
             if (alt) {
                 *alt = 0;
                 alt = 0;
 
             } else {
 
                 alt = keys->pressedPtr(row, col);
                 need_repaint = TRUE;
                 *alt = !keys->pressed(row, col);
             }
 
         } else if (qkeycode == Qt::Key_Shift) {
             need_repaint = TRUE;
 
             if (shift) {
                 *shift = 0;
                 shift = 0;
             }
             else {
                 shift = keys->pressedPtr(row, col);
                 *shift = 1;
                 if (lock) {
                     *lock = 0;
                     lock = 0;
                 }
             }
 
 
             /* 
              * want to be able to hit circumflex/diaeresis -> shift
              * to type in shifted circumflex/diaeresis chars.
              * same thing with meta
 
             if (meta) { *meta = 0; meta = 0; }
             if (circumflex) { *circumflex = 0; circumflex = 0; }
             if (diaeresis) { *diaeresis = 0; diaeresis = 0; }
 
              */
 
         } else if (qkeycode == Qt::Key_CapsLock) {
             need_repaint = TRUE;
 
             if (lock) {
                 *lock = 0;
                 lock = 0;
             }
             else {
                 lock = keys->pressedPtr(row, col);;
                 *lock = true;;
                 if (shift) {
                     *shift = 0;
                     shift = 0;
                 }
             }
 
             /*
             if (meta) { *meta = 0; meta = 0; }
             if (circumflex) { *circumflex = 0; circumflex = 0; }
             if (diaeresis) { *diaeresis = 0; diaeresis = 0; }
             */
 
         } else if (qkeycode == Qt::Key_Meta) {
             need_repaint = TRUE;
 
             if (meta) {
                 *meta = 0;
                 meta = 0;
 
             } else {
 
                 meta = keys->pressedPtr(row, col);
                 *meta = true;
             }
 
             // reset all the other keys
             if (shift) { *shift = 0; shift = 0; } 
             if (lock) { *lock = 0; lock = 0; }
             if (circumflex) { *circumflex = 0; circumflex = 0; }
             if (diaeresis) { *diaeresis = 0; diaeresis = 0; }
 	        if (baccent) { *baccent = 0; baccent = 0; }
 	        if (accent) { *accent = 0; accent = 0; }
 
             // dont need to emit this key... acts same as alt
             qkeycode = 0;
 
         // circumflex
         } else if (qkeycode == 0x2000) {
             need_repaint = TRUE;
 
             if (circumflex) {
 
                 *circumflex = 0;
                 circumflex = 0;
 
             } else {
 
                 circumflex = keys->pressedPtr(row, col);
                 *circumflex = true;
             }
 
             /* no need to turn off shift or lock if circumflex
              * keys are pressed
              
             if (shift) { *shift = 0; shift = 0; }
             if (lock) { *lock = 0; lock = 0; }
 
              */
             
             // have to reset all the other keys
             if (meta) { *meta = 0; meta = 0; }
             if (diaeresis) { 
                 
                 // *diaeresis and *circumflex point to the same thing
                 // when diaeresis is enabled and you hit the circumflex
                 // since they are the same key, it should turn off the
                 // key
                 
                 *diaeresis = 0; 
                 diaeresis = 0; 
                 circumflex = 0;
             }
 
             qkeycode = 0;
 
         // diaeresis
         } else if (qkeycode == 0x2001) {
             need_repaint = TRUE;
 
             if (diaeresis) {
 
                 *diaeresis = 0;
                 diaeresis = 0;
 
             } else {
 
                 diaeresis = keys->pressedPtr(row, col);
                 *diaeresis = true;
             }
 
              
             if (shift) { *shift = 0; shift = 0; }
 
             /*
              *
             if (lock) { *lock = 0; lock = 0; }
              *
              */
 
             if (meta) { *meta = 0; meta = 0; }
             if (circumflex) { 
 
                 // *circumflex = 0; 
                 //
                 // same thing the diaeresis pointer points too
                 
                 circumflex = 0; 
             }
 
 
             qkeycode = 0;
 
         // Back accent
         } else if (qkeycode == 0x2002) {
             need_repaint = TRUE;
 
             if (baccent) {
 
                 *baccent = 0;
                 baccent = 0;
 
             } else {
 
                 baccent = keys->pressedPtr(row, col);
                 *baccent = true;
             }
 
 
             if (shift) { *shift = 0; shift = 0; }
             if (meta) { *meta = 0; meta = 0; }
 		    if (accent) { *accent = 0; accent = 0; }
 
             qkeycode = 0;
         
 	   // Accent
         } else if (qkeycode == 0x2003) {
             need_repaint = TRUE;
 
             if (accent) {
 
                 *accent = 0;
                 accent = 0;
 
             } else {
 
                 accent = keys->pressedPtr(row, col);
                 *accent = true;
             }
 
 
             if (shift) { *shift = 0; shift = 0; }
             if (meta) { *meta = 0; meta = 0; }
 		    if (baccent) { *baccent = 0; }
 
             qkeycode = 0;
         }
 
     }
     else { // normal char
         if ((shift || lock) && keys->shift(unicode)) {
 
             // make diaeresis/circumflex -> shift input shifted
             // diaeresis/circumflex chars
             
             if (circumflex && keys->circumflex(keys->shift(unicode)))
                 unicode = keys->circumflex(keys->shift(unicode));
             else if (diaeresis && keys->diaeresis(keys->shift(unicode)))
                 unicode = keys->diaeresis(keys->shift(unicode));
 	        else if (baccent && keys->baccent(keys->shift(unicode)))
                 unicode = keys->baccent(keys->shift(unicode));
             else if (accent && keys->accent(keys->shift(unicode)))
                 unicode = keys->accent(keys->shift(unicode));
             else if (meta && keys->meta(keys->shift(unicode)))
                 unicode = keys->meta(keys->shift(unicode));
             else
                 unicode = keys->shift(unicode);
         }
         else if (meta && keys->meta(unicode)) {
             unicode = keys->meta(unicode);
         }
         else if (circumflex && keys->circumflex(unicode)) {
             unicode = keys->circumflex(unicode);
         }
         else if (diaeresis && keys->diaeresis(unicode)) {
 
             unicode = keys->diaeresis(unicode);
         }
 	   else if (baccent && keys->baccent(unicode)) {
             unicode = keys->baccent(unicode);
         }
         else if (accent && keys->accent(unicode)) {
             unicode = keys->accent(unicode);
         }
     }
 
     // korean parsing
     if (keys->lang == "ko") {
 
         unicode = parseKoreanInput(unicode);
     }
 
     modifiers = (ctrl ? Qt::ControlButton : 0) | (alt ? Qt::AltButton : 0);
 
     if ('A' <= unicode && unicode <= 'z' && modifiers) {
 
         qkeycode = QChar(unicode).upper();
         unicode = qkeycode - '@';
     }
 
     QWSServer::sendKeyEvent(unicode, qkeycode, modifiers, true, false); 
 
     // pickboard stuff
     if (usePicks) {
 
         KeyboardConfig *dc = picks->dc;
     
         if (dc) {
             if (qkeycode == Qt::Key_Backspace) {
                 dc->input.remove(dc->input.last()); // remove last input
                 dc->decBackspaces();
             } else if ( qkeycode == Qt::Key_Return || QChar(unicode).isPunct() || QChar(unicode).isSpace() || unicode == 0) {
                 dc->input.clear();
                 dc->resetBackspaces();
             } else {
                 dc->add(QString(QChar(unicode)));
                 dc->incBackspaces();
             }
         }
         picks->repaint();
     }
 
 
     // painting
     pressed = TRUE;
 
     pressedKeyRow = row;
     pressedKeyCol = col;
 
     if (need_repaint) repaint(FALSE);
     else { // just paint the one key pressed
 
 
 
         QPainter p(this);
         drawKeyboard(p, row, col);
 
     }
 
     if (useRepeat) repeatTimer->start( 800 );
     //pressTid = startTimer(80);
 
 }
 
 
 /* Keyboard::mouseReleaseEvent {{{1 */
 void Keyboard::mouseReleaseEvent(QMouseEvent*)
 {
     pressed = FALSE;
     //if ( pressTid == 0 )
 #if defined(Q_WS_QWS) || defined(_WS_QWS_)
     if ( unicode != -1 ) {
 	emit key( unicode, qkeycode, modifiers, false, false );
 	repeatTimer->stop();
     }
 #endif
     if (shift && unicode != 0) {
 
 
         *shift = 0; // unpress shift key
         shift = 0;  // reset the shift pointer
         repaint(FALSE);
 
     } 
     if (ctrl && unicode != 0) {
 
         *ctrl = 0;
         ctrl = 0;
         repaint(FALSE);
 
     }
     if (alt && alt != 0) {
 
         *alt = 0;
         alt = 0;
         repaint(FALSE);
 
     }
     
     /*
      * do not make the meta key release after being pressed
      *
 
     else if (meta && unicode != 0) {
 
         *meta = 0;
         meta = 0;
         repaint(FALSE);
     }
 
      */
 
     else clearHighlight();
 }
 
 /* Keyboard::timerEvent {{{1 */
 
 /* dont know what this does, but i think it is here so that if your screen
  * sticks (like on an ipaq) then it will stop repeating if you click another
  * key... but who knows what anything does in this thing anyway?
 
  void Keyboard::timerEvent(QTimerEvent* e)
 {
     if ( e->timerId() == pressTid ) {
 	killTimer(pressTid);
 	pressTid = 0;
 	if ( !pressed )
         cout << "calling clearHighlight from timerEvent\n";
 	    //clearHighlight();
     }
 }
 */
 
 void Keyboard::repeat()
 {
 
   repeatTimer->start( 200 );
   emit key( unicode, qkeycode, modifiers, true, true );
 }
 
 void Keyboard::clearHighlight()
 {
     if ( pressedKeyRow >= 0 && pressedKeyCol >= 0) {
 	    int tmpRow = pressedKeyRow;
         int tmpCol = pressedKeyCol;
 
 	    pressedKeyRow = -1;
 	    pressedKeyCol = -1;
 
 	    QPainter p(this);
 	    drawKeyboard(p, tmpRow, tmpCol);
     }
 }
 
 
 /* Keyboard::sizeHint {{{1 */
 QSize Keyboard::sizeHint() const
 {
     QFontMetrics fm=fontMetrics();
     int keyHeight = fm.lineSpacing() + 2;
 
     return QSize( 240, keyHeight * keys->rows() + (usePicks ? picks->sizeHint().height() : 0) + 1);
 }
 
 
 void Keyboard::resetState()
 {
     if (shift) { *shift = 0; shift = 0; }
     if (lock)  {*lock = 0;  lock = 0; }
     if (meta)  { *meta = 0;  meta = 0; }
     if (circumflex) { *circumflex = 0; circumflex = 0; }
     if (diaeresis)  { *diaeresis = 0; diaeresis = 0; }
     if (baccent)  { *baccent = 0; baccent = 0; }
     if (accent)  { *accent = 0; accent = 0; }
 
     schar = mchar = echar = 0;
     picks->resetState();
 }
 
 /* Keyboard::togglePickboard {{{1 */
 void Keyboard::togglePickboard(bool on_off)
 {
     usePicks = on_off;
     if (usePicks) {
         picks->show();
         //move(x(), y() - picks->height()); // not required anymore because QCopChannel::send
         //adjustSize();
         QObject::connect( picks, SIGNAL(key(ushort,ushort,ushort,bool,bool) ),
             this, SIGNAL(key(ushort,ushort,ushort,bool,bool)) );
     } else {
 
         picks->hide();
         picks->resetState();
         //move(x(), y() + picks->height());
         //adjustSize();
         QObject::disconnect( picks, SIGNAL(key(ushort,ushort,ushort,bool,bool) ),
             this, SIGNAL(key(ushort,ushort,ushort,bool,bool)) );
 
     }
     /*
      * this closes && opens the input method
      */
     QCopChannel::send ("QPE/TaskBar", "hideInputMethod()");
     QCopChannel::send ("QPE/TaskBar", "showInputMethod()");
 }
 
 void Keyboard::toggleRepeat(bool on) {
 
     useRepeat = on;
     //cout << "setting useRepeat to: " << useRepeat << "\n";
 }
 
 void Keyboard::cleanupConfigDlg() {
 
     if ( configdlg ) { 
         delete (ConfigDlg *) configdlg; 
         configdlg = 0;
     }
 }
 
 /* Keyboard::setMapTo ... {{{1 */
 void Keyboard::setMapToDefault() {
 
 
     /* load current locale language map */
     Config *config = new Config("locale");
     config->setGroup( "Language" );
     QString l = config->readEntry( "Language" , "en" );
     delete config;
 
     QString key_map = QPEApplication::qpeDir() + "share/multikey/" 
             + l + ".keymap";
 
     /* save change to multikey config file */
     config = new Config("multikey");
     config->setGroup ("keymaps");
     config->writeEntry ("current", key_map); // default closed
     delete config;
 
     int prevRows = keys->rows();
 
     delete keys;
     keys = new Keys(key_map);
 
     // have to repaint the keyboard
     if (prevRows != keys->rows()) {
 
         QCopChannel::send ("QPE/TaskBar", "hideInputMethod()"); 
         QCopChannel::send ("QPE/TaskBar", "showInputMethod()");
 
     } else repaint(FALSE);
 
     resetState();
 }
 
 void Keyboard::setMapToFile(QString map) {
 
     /* save change to multikey config file */
     Config *config = new Config("multikey");
     config->setGroup ("keymaps");
     config->writeEntry ("current", map); // default closed
 
     delete config;
 
     int prevRows = keys->rows();
 
     delete keys;
     if (QFile(map).exists()) 
         keys = new Keys(map);
     else 
         keys = new Keys();
 
     if (keys->rows() != prevRows) {
 
         QCopChannel::send ("QPE/TaskBar", "hideInputMethod()");
         QCopChannel::send ("QPE/TaskBar", "showInputMethod()");
     }
     else repaint(FALSE);
 
     resetState();
 }
 
 /* Keybaord::reloadKeyboard {{{1 */
 void Keyboard::reloadKeyboard() {
 
     // reload colors and redraw
     loadKeyboardColors();
     repaint();
 
 }
 
 void Keyboard::loadKeyboardColors() {
 
     Config config ("multikey");
     config.setGroup("colors");
 
     QStringList color;
     color = config.readListEntry("keycolor", QChar(','));
     if (color.isEmpty()) {
         color = QStringList::split(",", "240,240,240");
         config.writeEntry("keycolor", color.join(","));
 
     }
     keycolor = QColor(color[0].toInt(), color[1].toInt(), color[2].toInt());
 
     color = config.readListEntry("keycolor_pressed", QChar(','));
     if (color.isEmpty()) {
         color = QStringList::split(",", "171,183,198");
         config.writeEntry("keycolor_pressed", color.join(","));
 
     }
     keycolor_pressed = QColor(color[0].toInt(), color[1].toInt(), color[2].toInt());
 
     color = config.readListEntry("keycolor_lines", QChar(','));
     if (color.isEmpty()) {
         color = QStringList::split(",", "138,148,160");
         config.writeEntry("keycolor_lines", color.join(","));
 
     }
     keycolor_lines = QColor(color[0].toInt(), color[1].toInt(), color[2].toInt());
 
     color = config.readListEntry("textcolor", QChar(','));
     if (color.isEmpty()) {
         color = QStringList::split(",", "43,54,68");
         config.writeEntry("textcolor", color.join(","));
 
     }
     textcolor = QColor(color[0].toInt(), color[1].toInt(), color[2].toInt());
 
 }
 
 /* korean input functions {{{1 
  *
  * TODO
  * one major problem with this implementation is that you can't move the
  * cursor after inputing korean chars, otherwise it will eat up and replace
  * the char before the cursor you move to. fix that
  *
  * make backspace delete one single char, not the whole thing if still 
  * editing.
  *
  * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
  *
  * how korean input works
  *
  * all following chars means unicode char value and are in hex
  *
  * 초음 = schar (start char)
  * 중음 = mchar (middle char)
  * 끝음 = echar (end char)
  *
  * there are 19 schars. unicode position is at 1100 - 1112
  * there are 21 mchars. unicode position is at 1161 - 1175
  * there are 27 echars. unicode position is at 11a8 - 11c2
  *
  * the map with everything combined is at ac00 - d7a3
  *
  */
 
 ushort Keyboard::parseKoreanInput (ushort c) {
 
 	if ((c != 0 && (c < 0x1100 || 0x11c2 < c) && (c < 0xac00 || 0xd7a3 < c)) 
           ||
         (c == 0 && qkeycode != Qt::Key_Shift && Qt::Key_CapsLock != qkeycode
          && qkeycode != Qt::Key_Control && qkeycode != Qt::Key_Alt)) {
 
 		schar = 0, mchar = 0, echar = 0;
         return c;
 	}
 
 	if ( 0x1100 <= c && c <= 0x1112 ) { // schar or echar was input
 
 		if (schar == 0 || (schar != 0 && mchar == 0)) {
 			schar = c; mchar = 0; echar = 0;
 			return c;
 		}
 		else if (mchar != 0) {
 
diff --git a/inputmethods/multikey/keyboard.h b/inputmethods/multikey/keyboard.h
index bc74e71..20c5cee 100644
--- a/inputmethods/multikey/keyboard.h
+++ b/inputmethods/multikey/keyboard.h
@@ -1,188 +1,191 @@
 /**********************************************************************
 ** Copyright (C) 2000 Trolltech AS.  All rights reserved.
 **
 ** This file is part of Qtopia Environment.
 **
 ** This file may be distributed and/or modified under the terms of the
 ** GNU General Public License version 2 as published by the Free Software
 ** Foundation and appearing in the file LICENSE.GPL included in the
 ** packaging of this file.
 **
 ** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 ** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 **
 ** See http://www.trolltech.com/gpl/ for GPL licensing information.
 **
 ** Contact info@trolltech.com if any conditions of this licensing are
 ** not clear to you.
 **
 **********************************************************************/
 #include <qframe.h>
 #include <qmap.h>
 #include "../pickboard/pickboardcfg.h"
 #include "../pickboard/pickboardpicks.h"
 #include "configdlg.h"
 
 class QTimer;
 
+namespace MultiKey
+{
+
 class KeyboardConfig : public DictFilterConfig
 {
 public:
     KeyboardConfig(PickboardPicks* p) : DictFilterConfig(p), backspaces(0) { nrows = 1; }
     virtual void generateText(const QString &s);
     void decBackspaces() { if (backspaces) backspaces--; }
     void incBackspaces() { backspaces++; }
     void resetBackspaces() { backspaces = 0; }
 private:
     int backspaces;
 };
 
 
 class KeyboardPicks : public PickboardPicks
 {
     Q_OBJECT
 public:
     KeyboardPicks(QWidget* parent=0, const char* name=0, WFlags f=0)
 	: PickboardPicks(parent, name, f) { }
     void initialise();
     virtual QSize sizeHint() const;
     KeyboardConfig *dc;
 };
 
 
 class Keys {
 public:
 
     Keys();
     Keys(const char * filename);
     ~Keys();
     int     width(const int row, const int col);
     int     rows();
     ushort  uni(const int row, const int col);
     int     qcode(const int row, const int col);
     bool    pressed(const int row, const int col);
     bool    *pressedPtr(const int row, const int col);
     ushort  shift(const ushort);
     ushort  meta(const ushort);
     ushort  circumflex(const ushort);
     ushort  diaeresis(const ushort);
     ushort  baccent(const ushort);
     ushort  accent(const ushort);
     QImage *pix(const int row, const int col);
     int     numKeys(const int row);
     void    setKeysFromFile(const char *filename);
     void    setKey(const int row, const int qcode, const ushort unicode, 
                     const int width, QImage *pix);
     void    setPressed(const int row, const int col, const bool pressed);
     QString lang;
     QString label;
 
 private:
 
     typedef struct Key {
 	    int qcode; // are qt key codes just unicode values?
 	    ushort unicode;
 	    int width;  // not pixels but relative key width. normal key is 2
 
         // only needed for keys like ctrl that can have multiple keys pressed at once
         bool *pressed; 
 	    QImage *pix;
     };
 
     QList<Key> keys[6];
     QMap<ushort,ushort> shiftMap;
     QMap<ushort,ushort> metaMap;
     QMap<ushort,ushort> circumflexMap;
     QMap<ushort,ushort> diaeresisMap;
     QMap<ushort,ushort> baccentMap;
     QMap<ushort,ushort> accentMap;
 
 };
 
 class Keyboard : public QFrame
 {
     Q_OBJECT
 public:
     Keyboard( QWidget* parent=0, const char* name=0, WFlags f=0 );
     ~Keyboard();
 
     void resetState();
 
     void mousePressEvent(QMouseEvent*);
     void mouseReleaseEvent(QMouseEvent*);
     void resizeEvent(QResizeEvent*);
     void paintEvent(QPaintEvent* e);
     //void timerEvent(QTimerEvent* e);
     void drawKeyboard( QPainter &p, int row = -1, int col = -1);
 
     QSize sizeHint() const;
 
 signals:
     void key( ushort scancode, ushort unicode, ushort modifiers, bool, bool );
 
 private slots:
     void repeat();
     void togglePickboard(bool on_off);
     void toggleRepeat(bool on_off);
     void setMapToDefault();
     void setMapToFile(QString map);
     void cleanupConfigDlg();
 
     // used to redraw keyboard after edited colors
     void reloadKeyboard();
     
 private:
     int getKey( int &w, int j = -1 );
     void clearHighlight();
 
     bool *shift;
     bool *lock;
     bool *ctrl;
     bool *alt;
     bool *meta;
     bool *circumflex;
     bool *diaeresis;
     bool *baccent;
     bool *accent;
 
     uint useLargeKeys:1;
     uint usePicks:1;
     uint useRepeat:1;
     
     int pressedKeyRow;
     int pressedKeyCol;
 
     KeyboardPicks *picks;
 
     int keyHeight;
     int defaultKeyWidth;
     int xoffs;
 
     int unicode;
     int qkeycode;
     int modifiers;
 
     int pressTid;
     bool pressed;
 
     Keys *keys;
 
     /* for korean input */
     ushort schar, mchar, echar;
     ushort parseKoreanInput(ushort c);
     ushort combineKoreanChars(const ushort s, const ushort m, const ushort e);
     ushort constoe(const ushort c);
 
     QTimer *repeatTimer;
 
     /* colors */
     void loadKeyboardColors();
     QColor keycolor;
     QColor keycolor_pressed;
     QColor keycolor_lines;
     QColor textcolor;
 
     ConfigDlg *configdlg;
 };
 
-
+} // namespace MultiKey
diff --git a/inputmethods/multikey/keyboardimpl.cpp b/inputmethods/multikey/keyboardimpl.cpp
index cebd43d..4cfbcd5 100644
--- a/inputmethods/multikey/keyboardimpl.cpp
+++ b/inputmethods/multikey/keyboardimpl.cpp
@@ -1,107 +1,107 @@
 /**********************************************************************
 ** Copyright (C) 2000 Trolltech AS.  All rights reserved.
 **
 ** This file is part of Qtopia Environment.
 **
 ** This file may be distributed and/or modified under the terms of the
 ** GNU General Public License version 2 as published by the Free Software
 ** Foundation and appearing in the file LICENSE.GPL included in the
 ** packaging of this file.
 **
 ** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 ** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 **
 ** See http://www.trolltech.com/gpl/ for GPL licensing information.
 **
 ** Contact info@trolltech.com if any conditions of this licensing are
 ** not clear to you.
 **
 **********************************************************************/
 #include <qapplication.h>
 #include <qpixmap.h>
 #include "keyboard.h"
 #include "keyboardimpl.h"
 
 /* XPM */
-static const char * kb_xpm[] = {
+static const char * const kb_xpm[] = {
 "28 13 4 1",
 "       c None",
 ".      c #4C4C4C",
 "+      c #FFF7DD",
 "@      c #D6CFBA",
 " .......................... ",
 " .+++.+++.+++.+++.+++.++++. ",
 " .+@@.+@@.+@@.+@@.+@@.+@@@. ",
 " .......................... ",
 " .+++++.+++.+++.+++.++++++. ",
 " .+@@@@.+@@.+@@.+@@.+@@@@@. ",
 " .......................... ",
 " .++++++.+++.+++.+++.+++++. ",
 " .+@@@@@.+@@.+@@.+@@.+@@@@. ",
 " .......................... ",
 " .++++.++++++++++++++.++++. ",
 " .+@@@.+@@@@@@@@@@@@@.+@@@. ",
 " .......................... "};
 
 
 KeyboardImpl::KeyboardImpl()
     : input(0), icn(0), ref(0)
 {
 }
 
 KeyboardImpl::~KeyboardImpl()
 {
     delete input;
     delete icn;
 }
 
 QWidget *KeyboardImpl::inputMethod( QWidget *parent, Qt::WFlags f )
 {
     if ( !input )
-	input = new Keyboard( parent, "Keyboard", f );
+	input = new MultiKey::Keyboard( parent, "Keyboard", f );
     return input;
 }
 
 void KeyboardImpl::resetState()
 {
     if ( input )
 	input->resetState();
 }
 
 QPixmap *KeyboardImpl::icon()
 {
     if ( !icn )
 	icn = new QPixmap( (const char **)kb_xpm );
     return icn;
 }
 
 QString KeyboardImpl::name()
 {
     return qApp->translate( "InputMethods", "Multikey" );
 }
 
 void KeyboardImpl::onKeyPress( QObject *receiver, const char *slot )
 {
     if ( input )
 	QObject::connect( input, SIGNAL(key(ushort,ushort,ushort,bool,bool)), receiver, slot );
 }
 
 #ifndef QT_NO_COMPONENT
 QRESULT KeyboardImpl::queryInterface( const QUuid &uuid, QUnknownInterface **iface )
 {
     *iface = 0;
     if ( uuid == IID_QUnknown )
 	*iface = this;
     else if ( uuid == IID_InputMethod )
 	*iface = this;
 
     if ( *iface )
 	(*iface)->addRef();
     return QS_OK;
 }
 
 Q_EXPORT_INTERFACE()
 {
     Q_CREATE_INSTANCE( KeyboardImpl )
 }
 #endif
diff --git a/inputmethods/multikey/keyboardimpl.h b/inputmethods/multikey/keyboardimpl.h
index e756364..76a2955 100644
--- a/inputmethods/multikey/keyboardimpl.h
+++ b/inputmethods/multikey/keyboardimpl.h
@@ -1,51 +1,60 @@
 /**********************************************************************
 ** Copyright (C) 2000 Trolltech AS.  All rights reserved.
 **
 ** This file is part of Qtopia Environment.
 **
 ** This file may be distributed and/or modified under the terms of the
 ** GNU General Public License version 2 as published by the Free Software
 ** Foundation and appearing in the file LICENSE.GPL included in the
 ** packaging of this file.
 **
 ** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 ** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 **
 ** See http://www.trolltech.com/gpl/ for GPL licensing information.
 **
 ** Contact info@trolltech.com if any conditions of this licensing are
 ** not clear to you.
 **
 **********************************************************************/
 #ifndef KEYBOARDIMPL_H
 #define KEYBOARDIMPL_H
 
 #include <qpe/inputmethodinterface.h>
 
+namespace MultiKey
+{
 class Keyboard;
+}
+
 class QPixmap;
 
+namespace
+{
+
 class KeyboardImpl : public InputMethodInterface
 {
 public:
     KeyboardImpl();
     virtual ~KeyboardImpl();
 
 #ifndef QT_NO_COMPONENT
     QRESULT queryInterface( const QUuid&, QUnknownInterface** );
     Q_REFCOUNT
 #endif
 
     virtual QWidget *inputMethod( QWidget *parent, Qt::WFlags f );
     virtual void resetState();
     virtual QPixmap *icon();
     virtual QString name();
     virtual void onKeyPress( QObject *receiver, const char *slot );
 
 private:
-    Keyboard *input;
+    MultiKey::Keyboard *input;
     QPixmap *icn;
     ulong ref;
 };
 
+} // anonymous namespace
+
 #endif