diff -r 000000000000 -r 16d8024aca5e src/hbcore/inputfw/hbinputkeymap.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/hbcore/inputfw/hbinputkeymap.cpp	Mon Apr 19 14:02:13 2010 +0300
@@ -0,0 +1,394 @@
+/****************************************************************************
+**
+** Copyright (C) 2008-2010 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (developer.feedback@nokia.com)
+**
+** This file is part of the HbCore module of the UI Extensions for Mobile.
+**
+** GNU Lesser General Public License Usage
+** This file may be used under the terms of the GNU Lesser General Public
+** License version 2.1 as published by the Free Software Foundation and
+** appearing in the file LICENSE.LGPL included in the packaging of this file.
+** Please review the following information to ensure the GNU Lesser General
+** Public License version 2.1 requirements will be met:
+** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at developer.feedback@nokia.com.
+**
+****************************************************************************/
+
+#include "hbinputkeymap.h"
+
+#include <QChar>
+#include <QString>
+#include <QStringList>  
+
+const int DeadKeyTable[14] = {0x060, 0x0B4, 0x05E, 0x0A8, 0x022, 0x2C7, 0x2D8, 0x0B0, 0x2DB, 0x2DD, 0x07E, 0x0B8, 0x201A, 0x0B7};
+
+const int DeadKeyCombineTable[59][3] = {
+    {0x060, 0x061, 0x0e0},
+    {0x060, 0x065, 0x0e8},
+    {0x060, 0x069, 0x0ec},
+    {0x060, 0x06F, 0x0f2},
+    {0x060, 0x075, 0x0f9},
+    
+    {0x0b4, 0x061, 0x0e1},
+    {0x0b4, 0x065, 0x0e9},
+    {0x0b4, 0x069, 0x0ed},
+    {0x0b4, 0x06F, 0x0f3},
+    {0x0b4, 0x075, 0x0fa},
+    {0x0b4, 0x079, 0x0fd},
+    {0x0b4, 0x063, 0x107},
+    {0x0b4, 0x06c, 0x13A},
+    {0x0b4, 0x06e, 0x144},
+    {0x0b4, 0x072, 0x155},
+    {0x0b4, 0x053, 0x15b},
+    {0x0b4, 0x074, 0x163},
+    {0x0b4, 0x07A, 0x17A},
+
+    {0x05e, 0x061, 0x0e2},
+    {0x05e, 0x065, 0x0ea},
+    {0x05e, 0x069, 0x0ee},
+    {0x05e, 0x06F, 0x0f4},
+    {0x05e, 0x075, 0x0fb},
+    
+    {0x0a8, 0x061, 0x0e4},
+    {0x0a8, 0x065, 0x0eb},
+    {0x0a8, 0x069, 0x0ef},
+    {0x0a8, 0x06F, 0x0f6},
+    {0x0a8, 0x075, 0x0fc},
+    {0x0a8, 0x079, 0x0ff},
+    
+    {0x022, 0x061, 0x0e4},
+    {0x022, 0x065, 0x0eb},
+    {0x022, 0x069, 0x0ef},
+    {0x022, 0x06F, 0x0f6},
+    {0x022, 0x075, 0x0fc},
+    {0x022, 0x079, 0x0ff},
+    
+    {0x2c7, 0x065, 0x11b},
+    {0x2c7, 0x063, 0x10d},
+    {0x2c7, 0x064, 0x10f},
+    {0x2c7, 0x06C, 0x13e},
+    {0x2c7, 0x06E, 0x148},
+    {0x2c7, 0x072, 0x159},
+    {0x2c7, 0x053, 0x161},
+    {0x2c7, 0x074, 0x165},
+    {0x2c7, 0x07A, 0x17E},
+    
+    {0x2d8, 0x061, 0x103},
+
+    {0x0b0, 0x061, 0x0c5},
+    {0x0b0, 0x075, 0x16f},
+
+    {0x2db, 0x061, 0x105},
+    {0x2db, 0x065, 0x119},
+
+    {0x2dd, 0x06F, 0x151},
+    {0x2dd, 0x075, 0x171},
+
+    {0x07e, 0x061, 0x0e3},
+    {0x07e, 0x06F, 0x0f5},
+    {0x07e, 0x06E, 0x0f1},
+
+    {0x0b8, 0x063, 0x0e7},
+    {0x0b8, 0x072, 0x15f},
+
+    {0x201a, 0x063, 0x0e7},
+    {0x201a, 0x072, 0x15f},
+
+    {0x0b7, 0x07A, 0x17c}};
+
+class HbKeymapPrivate
+{
+
+public:
+    HbKeymapPrivate(HbInputLanguage language);
+    ~HbKeymapPrivate();
+
+public:
+    QMap<HbKeyboardType, HbKeyboardMap*> mKeyboards;
+    HbInputLanguage mLanguage;
+};
+
+
+HbKeymapPrivate::HbKeymapPrivate(HbInputLanguage language)
+: mLanguage(language)
+{
+}
+
+HbKeymapPrivate::~HbKeymapPrivate()
+{
+    foreach (HbKeyboardMap* keymap, mKeyboards) {
+        foreach (HbMappedKey* key, keymap->keys) {
+            delete key;
+        }
+        delete keymap;
+    }
+    mKeyboards.clear();
+}
+
+/// @endcond
+
+/*!
+@alpha
+@hbcore
+\class HbMappedKey
+
+\brief Contains definition for characters associated with one keyboard key.
+
+*/
+
+/*!
+Constructs the object.
+*/
+HbMappedKey::HbMappedKey()
+{
+
+}
+
+/*!
+Destructs the object.
+*/
+HbMappedKey::~HbMappedKey()
+{
+}
+
+/*!
+Returns QString of characters associated with the given modifiers in this key if defined,
+otherwise returns an empty QString.
+*/
+const QString HbMappedKey::characters(const HbModifiers modifiers) const
+{
+    switch (modifiers) {
+    case HbModifierNone:
+        if (chars.count() >= 1) {
+            return chars.at(0);
+        } else {
+            return QString();
+        }
+    case HbModifierShiftPressed:
+        if (chars.count() >= 2) {
+            return chars.at(1);
+        } else {
+            return QString();
+        }
+    case HbModifierFnPressed:
+        if (chars.count() >= 3) {
+            return chars.at(2);
+        } else {
+            return QString();
+        }
+    case HbModifierShiftPressed | HbModifierFnPressed:
+        if (chars.count() >= 4) {
+            return chars.at(3);
+        } else {
+            return QString();
+        }
+    default:
+        return QString();
+    }
+}
+/*!
+@alpha
+@hbcore
+\class HbKeymap
+\brief Contains information on characters mapped to keyboard keys.
+
+HbKeymaps contain keymap data for different keyboards and a single language.
+Usually a HbKeymap is created by HbKeymapFactory and already contains the data
+for all keyboards defined in the system.
+
+The keyboards can be accessed using the keyboard() function, which returns a HbKeyboardMap struct, containing
+a list of HbMappedKeys. HbMappedKeys each contain keycode and strings for characters available using different modifiers.
+Any of the character strings except noModifier may be null if they are not defined.
+
+Also helper methods are provided for finding keys containing certain keycodes or mapped characters.
+
+\sa HbKeymapFactory
+\sa HbInputLanguage
+*/
+
+/*!
+Constructs the object.
+*/
+HbKeymap::HbKeymap(HbInputLanguage language)
+{
+    mPrivate = new HbKeymapPrivate(language);
+}
+
+/*!
+Destructs the object.
+*/
+HbKeymap::~HbKeymap()
+{
+    delete mPrivate;
+}
+
+/*!
+Adds a keyboard definition to the keymap. Usually needed only by the HbKeymapFactory.
+
+\param keyboard Keyboard to be added in the internal structure.
+*/
+void HbKeymap::addKeyboard(HbKeyboardMap *keyboard)
+{
+    if (keyboard) {
+        mPrivate->mKeyboards.insert(keyboard->type, keyboard);
+    }
+}
+
+/*!
+Returns a keyboard of the type \a keyboard or 0 if not found.
+
+\param keyboard The type of the keyboard.
+*/
+const HbKeyboardMap *HbKeymap::keyboard(HbKeyboardType keyboard) const
+{
+    HbKeyboardMap* keyboardMap = 0;
+    if (mPrivate->mKeyboards.contains(keyboard)) {
+        keyboardMap = mPrivate->mKeyboards.value(keyboard);
+    }
+    return keyboardMap;
+}
+
+/*!
+Returns the language of this keymap.
+
+\sa HbInputLanguage
+*/
+HbInputLanguage HbKeymap::language() const
+{
+    return mPrivate->mLanguage;
+}
+
+/*!
+Returns the key in the keyboard of type \a keyboard, on the position \a keyIndex or 0 if not found.
+
+\param keyboard The type of the keyboard.
+\param keyIndex Index of the key, first key at index 0.
+*/
+const HbMappedKey *HbKeymap::keyForIndex(HbKeyboardType keyboard, int keyIndex) const
+{
+    HbMappedKey* key = 0;
+    if (mPrivate->mKeyboards.contains(keyboard)) {
+        HbKeyboardMap* keymap = mPrivate->mKeyboards.value(keyboard);
+        if (keymap->keys.count() > keyIndex && keyIndex >= 0) {
+            key = keymap->keys.at(keyIndex);
+        }
+    }
+
+    return key;
+}
+
+/*!
+Returns the key on the keyboard \a keyboard with specified \a keycode or 0 if not found.
+
+\param keyboard The type of the keyboard.
+\param keycode Keycode to look for.
+*/
+const HbMappedKey *HbKeymap::keyForKeycode(HbKeyboardType keyboard, QChar keycode) const
+{
+    HbMappedKey* key = 0;
+    if (mPrivate->mKeyboards.contains(keyboard)) {
+        HbKeyboardMap* keymap = mPrivate->mKeyboards.value(keyboard);
+        foreach (HbMappedKey* mappedKey, keymap->keys) {
+            if (mappedKey->keycode == keycode) {
+                key = mappedKey;
+                break;
+            }
+        }
+    }
+
+    return key;
+}
+
+/*!
+Returns the key on the keyboard \a keyboard containing a mapping to character \a character or 0
+if not found.
+
+\param keyboard The type of the keyboard.
+\param character Character to look for.
+*/
+const HbMappedKey *HbKeymap::keyForCharacter(HbKeyboardType keyboard, QChar character) const
+{
+    HbMappedKey* key = 0;
+    if (mPrivate->mKeyboards.contains(keyboard)) {
+        HbKeyboardMap* keymap = mPrivate->mKeyboards.value(keyboard);
+        foreach (HbMappedKey* mappedKey, keymap->keys) {
+            foreach (QString charstring, mappedKey->chars) {
+                if (charstring.contains(character)) {
+                    key = mappedKey;
+                    break;
+                }
+            }
+            if (key) {
+                break;
+            }
+        }
+    }
+
+    return key;
+}
+
+/*!
+Returns true if key is a dead key
+
+\param key Key to check.
+*/
+
+bool HbKeymap::isDeadKey(int key)
+{
+    int size = sizeof(DeadKeyTable) / sizeof(DeadKeyTable[0]);
+    for (int i=0; i<size; i++){
+        if (key == DeadKeyTable[i]){
+            return true;
+        }
+    }
+    return false;
+}
+
+/*!
+Returns key combination for dead key + another key
+
+\param deadKey Dead key
+\param key Key after dead key.
+\param firstKey possible first combination result key
+\param secondKey possible second combination result key
+*/
+void HbKeymap::combineCharacter(QChar deadKey, QChar key, QChar &firstKey, QChar &secondKey)
+{
+    QChar lowerKey = key.toLower();
+    if (key == Qt::Key_Space) {
+        // deadkey + space = deadkey
+        firstKey = deadKey;
+        secondKey = 0;
+    } else if (key == Qt::Key_Backspace) {
+        // deadkey + backspace = nothing
+        firstKey = 0;
+        secondKey = 0;
+    } else {
+        firstKey = deadKey;
+        secondKey = key;
+        int size = sizeof(DeadKeyCombineTable) / sizeof(DeadKeyCombineTable[0][0])/3;
+        for (int i=0; i<size; i++){
+            if (deadKey == DeadKeyCombineTable[i][0] && lowerKey == DeadKeyCombineTable[i][1]){
+                if (key.isUpper()) {
+                    firstKey = ((QChar)DeadKeyCombineTable[i][2]).toUpper();
+                } else {
+                    firstKey = DeadKeyCombineTable[i][2];
+                }
+                secondKey = 0;
+                break;
+            }
+        }
+    }
+    return;
+}
+
+// End of file