--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/src/hbinput/inputwidgets/hbinputqwertytouchkeyboard.cpp Mon Apr 19 14:02:13 2010 +0300
@@ -0,0 +1,1159 @@
+/****************************************************************************
+**
+** 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 HbInput 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 <QtGui>
+#include <hbinputmethod.h>
+#include <hbinputkeymap.h>
+#include <hbinputsettingproxy.h>
+#include <hbstyleoptionlabel.h>
+#include <hbaction.h>
+#include <hbtextitem.h>
+#include <hbframeitem.h>
+#include <hbcolorscheme.h>
+
+#include "hbinputcharpreviewpane.h"
+#include "hbinputtouchkeypadbutton.h"
+#include "hbinputqwertytouchkeyboard.h"
+#include "hbinputqwertytouchkeyboard_p.h"
+#include "hbinputvkbwidget_p.h"
+
+const int HbVirtualQwertyNumberOfColumns = 10;
+const int HbVirtualQwertyNumberOfRows = 4;
+const int HbVirtualQwerty4x10MaxKeysCount = 32;
+const int HbVirtualQwerty4x11MaxKeysCount = 36;
+const int HbVirtualQwertyFunctionButtonCount = 5;
+const int HbVirtualQwertyNumericKeypadButtonCount = 18;
+const qreal HbVirtualQwertyButtonPreferredHeight = 58.0;
+const QSizeF HbVirtualQwerty4x10LayoutDimensions(64.0, HbVirtualQwertyButtonPreferredHeight);
+const QSizeF HbVirtualQwerty4x11LayoutDimensions(58.18, HbVirtualQwertyButtonPreferredHeight);
+const int HbVirtualQwertyNumberOfRowsNumberMode = 2;
+
+const QString HbButtonObjName = "qwerty ";
+const QString HbCustomButtonObjName = "qwerty custom button ";
+const QString HbEnterObjName = "qwerty enter";
+const QString HbShiftObjName = "qwerty shift";
+const QString HbControlObjName = "qwerty control";
+const QString HbBackspaceObjName = "qwerty backspace";
+const QString HbSpaceObjName = "qwerty space";
+
+const QString HbQwertyButtonTextLayout = "_hb_qwerty_button_text_layout";
+const QString HbQwertyButtonIconLayout = "_hb_qwerty_button_icon_layout";
+
+HbQwertyKeyboardPrivate::HbQwertyKeyboardPrivate()
+:mCtrlBtnIndex(-1),
+mPressedButtonIndex(-1),
+mPreviewPane(0),
+mInStickyRegion(false),
+mLongKeyPressCharsShown(false),
+mClickMapper(0),
+mKeypadCreated(false),
+mKeymapChanged(false),
+mKeyboardSize(HbQwerty4x10),
+mSize(QSizeF())
+{
+}
+
+void HbQwertyKeyboardPrivate::constructKeypad()
+{
+ Q_Q(HbQwertyKeyboard);
+
+ if (mMode == EModeAbc) {
+ const HbKeyboardMap *keyboardmap = mKeymap->keyboard(HbKeyboardVirtualQwerty);
+ for (int i = 0; i < HbVirtualQwerty4x11MaxKeysCount; i++) {
+ HbTouchKeypadButton *button = new HbTouchKeypadButton(q, textForKey(i), q);
+ if (keyboardmap && (i < keyboardmap->keys.count())) {
+ button->setKeyCode(keyboardmap->keys.at(i)->keycode.unicode());
+ }
+ button->setProperty(HbStyleRulesCacheId::hbStyleRulesForNodeCache, HbQwertyButtonTextLayout);
+ button->setAsStickyButton(true);
+ q->connect(button, SIGNAL(pressed()), mPressMapper, SLOT(map()));
+ q->connect(button, SIGNAL(released()), mReleaseMapper, SLOT(map()));
+ q->connect(button, SIGNAL(clicked()), mClickMapper, SLOT(map()));
+ q->connect(button, SIGNAL(enteredInNonStickyRegion()), q, SLOT(enteredInNonStickyRegion()));
+ if (i >= HbVirtualQwerty4x10MaxKeysCount) {
+ button->hide();
+ }
+ mButtons.append(button);
+ }
+ //Create the function buttons
+ for (int i = 0; i < HbVirtualQwertyFunctionButtonCount; ++i) {
+ HbTouchKeypadButton *button = 0;
+ switch ( i ) {
+ case 0: {
+ HbIcon icon("qtg_mono_backspace1");
+ button = new HbTouchKeypadButton(q, icon, QString(), q);
+ button->setAutoRepeatDelay(HbRepeatTimeout);
+ button->setAutoRepeatInterval(HbRepeatTimeoutShort);
+ button->setAutoRepeat(true);
+ button->setProperty(HbStyleRulesCacheId::hbStyleRulesForNodeCache, HbQwertyButtonIconLayout);
+ break;
+ }
+ case 1: {
+ HbIcon icon("qtg_mono_enter");
+ button = new HbTouchKeypadButton(q, icon, QString(), q);
+ button->setProperty(HbStyleRulesCacheId::hbStyleRulesForNodeCache, HbQwertyButtonIconLayout);
+ break;
+ }
+ case 2: {
+ HbIcon icon("qtg_mono_shift");
+ button = new HbTouchKeypadButton(q, icon, QString(), q);
+ button->setProperty(HbStyleRulesCacheId::hbStyleRulesForNodeCache, HbQwertyButtonIconLayout);
+ break;
+ }
+ case 3: {
+ HbIcon icon("qtg_mono_sym_qwerty");
+ button = new HbTouchKeypadButton(q, icon, QString(), q);
+ button->setProperty(HbStyleRulesCacheId::hbStyleRulesForNodeCache, HbQwertyButtonIconLayout);
+ mCtrlBtnIndex = mButtons.count()-1;
+ break;
+ }
+ case 4: {
+ button = new HbTouchKeypadButton(q, QString(), q);
+ button->setFrameIcon("qtg_mono_space");
+ button->setAutoRepeatDelay(HbRepeatTimeout);
+ button->setAutoRepeatInterval(HbRepeatTimeoutShort);
+ button->setAutoRepeat(true);
+ break;
+ }
+ default:
+ break;
+ }
+ button->setButtonType(HbTouchKeypadButton::HbTouchButtonFunction);
+ button->setBackgroundAttributes(HbTouchKeypadButton::HbTouchButtonReleased);
+ button->setAsStickyButton(false);
+ q->connect(button, SIGNAL(pressed()), mPressMapper, SLOT(map()));
+ q->connect(button, SIGNAL(released()), mReleaseMapper, SLOT(map()));
+ q->connect(button, SIGNAL(clicked()), mClickMapper, SLOT(map()));
+ q->connect(button, SIGNAL(enteredInNonStickyRegion()), q, SLOT(enteredInNonStickyRegion()));
+ mButtons.append(button);
+ }
+ } else {
+ QString allowedSctCharacters;
+ getAllowedSctCharcters(allowedSctCharacters);
+ int sctIndex = 1;
+ // Construct Numeric Keypad
+ for(int jj = 0; jj < HbVirtualQwertyNumericKeypadButtonCount ; jj++) {
+ HbTouchKeypadButton *button = 0;
+ if (jj < 10) {
+ button = new HbTouchKeypadButton(q, QString::number((jj+1)%10), q);
+ button->setAsStickyButton(true);
+ setButtonObjectName(*button, 0, jj, Qt::Key_unknown);
+ } else if(jj>= 12 && jj<=16) {
+ // One todo is what if their are more than 5 sct characters that are allowed
+ // in to the editor. UI Concept is not clear for this. Need to revisit this.
+ // But as of now, there are not numeric editors which have more than 5 sct
+ // characters allowed in to them.
+ QString buttonText;
+ if(allowedSctCharacters.length() >= sctIndex) {
+ buttonText = allowedSctCharacters[sctIndex-1];
+ }
+ button = new HbTouchKeypadButton(q, buttonText, q);
+ button->setAsStickyButton(true);
+ setButtonObjectName(*button, 1, jj%10 , Qt::Key_unknown);
+ sctIndex++;
+ } else {
+ //construct the function button in numeric keypad
+ switch(jj) {
+ case 10: {
+ HbIcon icon("qtg_mono_shift");
+ button = new HbTouchKeypadButton(q, icon, QString(), q);
+ setButtonObjectName(*button, 1, 0, Qt::Key_Shift);
+ button->setButtonType(HbTouchKeypadButton::HbTouchButtonFunction);
+ button->setBackgroundAttributes(HbTouchKeypadButton::HbTouchButtonReleased);
+ button->setAsStickyButton(false);
+ button->setEnabled(false);
+ }
+ break;
+ case 11: {
+ HbIcon icon("qtg_mono_sym_qwerty");
+ button = new HbTouchKeypadButton(q, icon, QString(), q);
+ setButtonObjectName(*button, 1, 1, Qt::Key_Control);
+ button->setButtonType(HbTouchKeypadButton::HbTouchButtonFunction);
+ button->setBackgroundAttributes(HbTouchKeypadButton::HbTouchButtonReleased);
+ button->setAsStickyButton(false);
+ button->setEnabled(false);
+ }
+ break;
+ case 17: {
+ HbIcon icon("qtg_mono_backspace1");
+ button = new HbTouchKeypadButton(q, icon, QString(), q);
+ setButtonObjectName(*button, 1, 7, Qt::Key_Backspace);
+ button->setButtonType(HbTouchKeypadButton::HbTouchButtonFunction);
+ button->setBackgroundAttributes(HbTouchKeypadButton::HbTouchButtonReleased);
+ button->setAsStickyButton(false);
+ button->setAutoRepeatDelay(HbRepeatTimeout);
+ button->setAutoRepeatInterval(HbRepeatTimeoutShort);
+ button->setAutoRepeat(true);
+ }
+ break;
+ default:
+ break;
+ }
+ }
+
+ q->connect(button, SIGNAL(pressed()), mPressMapper, SLOT(map()));
+ q->connect(button, SIGNAL(released()), mReleaseMapper, SLOT(map()));
+ q->connect(button, SIGNAL(clicked()), mClickMapper, SLOT(map()));
+ q->connect(button, SIGNAL(enteredInNonStickyRegion()), q, SLOT(enteredInNonStickyRegion()));
+ mButtons.append(button);
+ }
+ }
+
+
+ // intercepting signal before passing to mOwner
+ q->connect(mPressMapper, SIGNAL(mapped(int)), q, SLOT(mappedKeyPress(int)));
+ q->connect(mReleaseMapper, SIGNAL(mapped(int)), q, SLOT(mappedKeyRelease(int)));
+ q->connect(mClickMapper, SIGNAL(mapped(int)), q, SLOT(mappedKeyClick(int)));
+}
+
+void HbQwertyKeyboardPrivate::getAllowedSctCharcters(QString & allowedSctCharacters)
+{
+ QString sctCharacters;
+ if (mKeymap) {
+ const HbKeyboardMap* keymap = mKeymap->keyboard(HbKeyboardSctLandscape);
+ if (keymap == 0) {
+ return;
+ }
+ foreach (const HbMappedKey* mappedKey, keymap->keys) {
+ sctCharacters.append(mappedKey->characters(HbModifierNone));
+ }
+ }
+
+ HbInputFocusObject *focusedObject = mOwner->focusObject();
+ QString tempAllowedSctCharacters;
+ if(focusedObject) {
+ focusedObject->filterStringWithEditorFilter(sctCharacters,tempAllowedSctCharacters);
+ }
+
+ // Remove digits from it ( digits always come in the first row )
+ allowedSctCharacters.clear();
+ for(int i=0; i<tempAllowedSctCharacters.length() ;i++) {
+ if(!(tempAllowedSctCharacters[i]>='0' && tempAllowedSctCharacters[i] <= '9' )) {
+ // dont add duplicates to the list
+ if(!allowedSctCharacters.contains(tempAllowedSctCharacters[i])) {
+ allowedSctCharacters.append(tempAllowedSctCharacters[i]);
+ }
+ }
+ }
+}
+void HbQwertyKeyboardPrivate::updateButtonsText()
+{
+ if(mMode == EModeNumeric) {
+ QString allowedSctCharacters;
+ getAllowedSctCharcters(allowedSctCharacters);
+ int sctIndex = 1;
+ for(int jj = 0; jj < HbVirtualQwertyNumericKeypadButtonCount ; jj++) {
+ if(jj>=12 && jj<=16) {
+ QString buttonText;
+ if(allowedSctCharacters.length() >= sctIndex) {
+ buttonText = allowedSctCharacters[sctIndex-1];
+ }
+ mButtons[jj]->setText(buttonText);
+ sctIndex++;
+ }
+ }
+
+ }
+}
+HbQwertyKeyboardPrivate::~HbQwertyKeyboardPrivate()
+{
+ delete mPreviewPane;
+ mPreviewPane = 0;
+
+ while (!mKeypadButtonOption.isEmpty()) {
+ delete mKeypadButtonOption.takeFirst();
+ }
+}
+
+void HbQwertyKeyboardPrivate::launchPreviewPane(const QStringList& list)
+{
+ if (mPressedButtonIndex > -1 && mPressedButtonIndex < mButtons.size()) {
+ mPreviewPane->showCharacters(list, mButtons.at(mPressedButtonIndex)->sceneBoundingRect());
+ }
+}
+
+int HbQwertyKeyboardPrivate::indexForKeycode(int keycode) {
+ int index = -1;
+ if (mMode == EModeNumeric) {
+ switch(keycode) {
+ case Qt::Key_Control:
+ index = 10; // First key of second row
+ break;
+ case Qt::Key_Shift:
+ index = 11;
+ break;
+ case Qt::Key_Backspace:
+ index = 17;
+ break;
+ default:
+ index = keycode;
+ break;
+ }
+ } else {
+ const HbKeyboardMap* keymap = mKeymap->keyboard(HbKeyboardVirtualQwerty);
+ for (int i = 0; i < keymap->keys.count(); ++i) {
+ if (keymap->keys.at(i)->keycode == keycode) {
+ index = i;
+ break;
+ }
+ }
+ }
+ return index;
+}
+
+int HbQwertyKeyboardPrivate::keyCode(int buttonId)
+{
+ return buttonId;
+}
+
+int HbQwertyKeyboardPrivate::keyCode(HbTouchKeypadButton *button)
+{
+ int code = -1;
+ if(button) {
+ code = button->keyCode();
+ }
+ return code;
+}
+
+void HbQwertyKeyboardPrivate::handleStandardButtonPress(int buttonId)
+{
+ HbInputVkbWidgetPrivate::handleStandardButtonPress(buttonId);
+
+ // A new button is pressed so we should close
+ // preview pane on the previous button.
+ if (mPreviewPane->isVisible()) {
+ mPreviewPane->hide();
+ }
+ // a new button is pressed so we should reset the state of the
+ // long press character preview pane.
+ mLongKeyPressCharsShown = false;
+
+ if (buttonId < 0) {
+ return;
+ }
+
+ mPressedButtonIndex = indexForKeycode(buttonId);
+
+ if (!(buttonId & 0xffff0000) && showPreview(buttonId)) {
+ mInStickyRegion = false;
+ // Show character preview only incase of setting proxy allows us to do.
+ if (HbInputSettingProxy::instance()->isCharacterPreviewForQwertyEnabled()) {
+ if (mPressedButtonIndex >= 0 && mPressedButtonIndex < mButtons.count()) {
+ if(mButtons.at(mPressedButtonIndex)->isFaded()) {
+ return; // if the button is inactive, dont show character preview popup.
+ }
+ const QString &text = mButtons.at(mPressedButtonIndex)->text();
+ if (text.size()) {
+ QStringList list;
+ list.append(text);
+ // let's show the character preview.
+ launchPreviewPane(list);
+ return;
+ }
+ }
+ }
+ }
+}
+
+void HbQwertyKeyboardPrivate::handleStandardButtonRelease(int buttonId)
+{
+ Q_UNUSED(buttonId);
+ // mLongKeyPressCharsShown will be true in case there is a long key press
+ // detected and preview pane is showing some character(s) to be selected
+ // by user. so when mLongKeyPressCharsShown is true we should not close
+ // the preview pane.
+ if (!mLongKeyPressCharsShown) {
+ if (mPreviewPane->isVisible()) {
+ mPreviewPane->hide();
+ }
+ }
+ mLongKeyPressCharsShown = false;
+}
+
+void HbQwertyKeyboardPrivate::handleStandardButtonClick(int buttonId)
+{
+ // handle keypress only if there was no flick
+ if (mFlickDirection!=HbInputVkbWidget::HbFlickDirectionDown){
+ QKeyEvent releaseEvent(QEvent::KeyRelease, buttonId, Qt::NoModifier);
+ if (mOwner) {
+ mOwner->filterEvent(&releaseEvent);
+ }
+ }
+}
+
+void HbQwertyKeyboardPrivate::setLayoutDimensions(QSizeF dimensions)
+{
+ // only update the dimensions if they are not previously set and buttons have been created
+ if (mSize == dimensions || !mButtons.count()) {
+ return;
+ }
+ mSize = dimensions;
+
+ mButtonLayout->setContentsMargins(0.0, 0.0, 0.0, 0.0);
+ int numberOfRows = HbVirtualQwertyNumberOfRows;
+
+ foreach (HbTouchKeypadButton* button, mButtons) {
+ button->setInitialSize(dimensions);
+ }
+ if (mSettingsButton && mApplicationButton) {
+ mSettingsButton->setInitialSize(dimensions);
+ mApplicationButton->setInitialSize(dimensions);
+ }
+
+ if ( EModeNumeric == mMode ) {
+ numberOfRows = HbVirtualQwertyNumberOfRowsNumberMode;
+ }
+ if (mKeyboardSize == HbQwerty4x10) {
+ for (int jj = 0; jj < HbVirtualQwertyNumberOfColumns; jj++) {
+ mButtonLayout->setColumnFixedWidth(jj, dimensions.width() - HorizontalSpacing);
+ }
+ } else {
+ for (int jj = 0; jj < HbVirtualQwertyNumberOfColumns + 1; jj++) {
+ mButtonLayout->setColumnFixedWidth(jj, dimensions.width() - HorizontalSpacing);
+ }
+ }
+ for (int jj = 0; jj < numberOfRows; jj++) {
+ mButtonLayout->setRowFixedHeight(jj, dimensions.height() - VerticalSpacing);
+ }
+
+ mButtonLayout->setHorizontalSpacing(HorizontalSpacing);
+ mButtonLayout->setVerticalSpacing(VerticalSpacing);
+}
+
+QSizeF HbQwertyKeyboardPrivate::calculateDimensions(QSizeF size)
+{
+ QSizeF dimensions;
+ if (mKeyboardSize == HbQwertyKeyboardPrivate::HbQwerty4x10) {
+ dimensions.setWidth(size.width() / (qreal)HbVirtualQwertyNumberOfColumns);
+ } else {
+ dimensions.setWidth(size.width() / (qreal)(HbVirtualQwertyNumberOfColumns + 1));
+ }
+ if (mMode == EModeNumeric) {
+ dimensions.setHeight(size.height() / (qreal)HbVirtualQwertyNumberOfRowsNumberMode);
+ } else {
+ dimensions.setHeight(size.height() / (qreal)HbVirtualQwertyNumberOfRows);
+ }
+ return dimensions;
+}
+
+QString HbQwertyKeyboardPrivate::textForKey(int key)
+{
+ QString keydata;
+ if (mKeymap->keyboard(HbKeyboardVirtualQwerty)->keys.count() <= key) {
+ return QString();
+ }
+ if (mModifiers & HbModifierShiftPressed) {
+ keydata = mKeymap->keyboard(HbKeyboardVirtualQwerty)->keys.at(key)->characters(HbModifierShiftPressed);
+ } else {
+ keydata = mKeymap->keyboard(HbKeyboardVirtualQwerty)->keys.at(key)->characters(HbModifierNone);
+ }
+ return keydata.left(1);
+}
+
+void HbQwertyKeyboardPrivate::initializeNumericKeyboard()
+{
+ Q_Q(HbQwertyKeyboard);
+ removeExistingSignalMappings();
+ const HbKeyboardMap* keymap = mKeymap->keyboard(HbKeyboardVirtualQwerty);
+ if (keymap == 0) {
+ return;
+ }
+ for (int i = 0; i < HbVirtualQwertyNumericKeypadButtonCount; ++i) {
+ if (i <= 9) {
+ mButtonLayout->addItem(mButtons.at(i), 0, i);
+ mReleaseMapper->setMapping(mButtons.at(i), i);
+ mPressMapper->setMapping(mButtons.at(i), i);
+ mClickMapper->setMapping(mButtons.at(i), i);
+ } else if(i>=12 && i<= 16) {
+ mButtonLayout->addItem(mButtons.at(i), 1, i%10);
+ mReleaseMapper->setMapping(mButtons.at(i), i);
+ mPressMapper->setMapping(mButtons.at(i), i);
+ mClickMapper->setMapping(mButtons.at(i), i);
+ } else {
+ switch(i) {
+ case 10: {
+ mButtonLayout->addItem(mButtons.at(i), 1, 0);
+ mReleaseMapper->setMapping(mButtons.at(i), Qt::Key_Shift);
+ mPressMapper->setMapping(mButtons.at(i), Qt::Key_Shift);
+ mClickMapper->setMapping(mButtons.at(i), Qt::Key_Shift);
+ }
+ break;
+ case 11: {
+ mButtonLayout->addItem(mButtons.at(i), 1, 1);
+ mReleaseMapper->setMapping(mButtons.at(i), Qt::Key_Control);
+ mPressMapper->setMapping(mButtons.at(i), Qt::Key_Control);
+ mClickMapper->setMapping(mButtons.at(i), Qt::Key_Control);
+ }
+ break;
+ case 17: {
+ mButtonLayout->addItem(mButtons.at(i), 1, 7);
+ mReleaseMapper->setMapping(mButtons.at(i), Qt::Key_Backspace);
+ mPressMapper->setMapping(mButtons.at(i), Qt::Key_Backspace);
+ mClickMapper->setMapping(mButtons.at(i), Qt::Key_Backspace);
+ }
+ break;
+ default:
+ break;
+ }
+ }
+ }
+
+ q->setupToolCluster();
+ if (mSettingsButton) {
+ mSettingsButton->setObjectName(HbCustomButtonObjName + QString::number(2));
+ mButtonLayout->addItem(mSettingsButton, 1, 8);
+ }
+ if (mApplicationButton) {
+ mApplicationButton->setObjectName(HbCustomButtonObjName + QString::number(3));
+ mButtonLayout->addItem(mApplicationButton, 1, 9);
+ }
+
+ setLayoutDimensions(calculateDimensions(q->keypadButtonAreaSize()));
+ mKeypadCreated = true;
+}
+
+void HbQwertyKeyboardPrivate::initializeKeyboard(bool refreshButtonText)
+{
+ const HbKeyboardMap* keymap = mKeymap->keyboard(HbKeyboardVirtualQwerty);
+ if (mKeymap == 0) {
+ return;
+ }
+
+ int keymapCount = keymap->keys.count();
+ if (mMode == EModeNumeric) {
+ initializeNumericKeyboard();
+ } else if (keymapCount <= HbVirtualQwerty4x10MaxKeysCount) {
+ initialize4x10Keypad(refreshButtonText);
+ } else {
+ initialize4x11Keypad(refreshButtonText);
+ }
+ mKeypadCreated = true;
+}
+
+void HbQwertyKeyboardPrivate::setRockerPosition()
+{
+ Q_Q(HbQwertyKeyboard);
+
+ // Set rocker position.
+ QSizeF padArea = q->keypadButtonAreaSize();
+ QPointF point((padArea.width() * 0.5) - (mRocker->size().width() * 0.5),
+ (padArea.height() * 0.5) - (mRocker->size().height() * 0.5));
+ point.setY(point.y() + HbCloseHandleHeight);
+
+ if (q->keypadLayout() && q->keypadLayout()->geometry().height()) {
+ if(mKeyboardSize == HbQwerty4x10) {
+ point.setX((padArea.width() * 0.5) - (mRocker->size().width() * 0.5));
+ point.setY((q->keypadLayout()->geometry().height() * 0.5) - (mRocker->size().height() * 0.5) + HbCloseHandleHeight);
+ } else {
+ point.setX(((padArea.width() * 0.5) - (mRocker->size().width() * 0.5)) + HbVirtualQwerty4x11LayoutDimensions.width()/2);
+ point.setY((q->keypadLayout()->geometry().height() * 0.5) - (mRocker->size().height() * 0.5) + HbCloseHandleHeight);
+ }
+ }
+ mRocker->setPos(point);
+}
+
+void HbQwertyKeyboardPrivate::removeExistingSignalMappings()
+{
+ // removes all mappings except settings button and application button
+ if (mButtonLayout) {
+ int count = mButtonLayout->count();
+ for (int jj=0; jj < count-2 ; jj++) {
+ HbTouchKeypadButton * button = mButtons.at(jj);
+ mReleaseMapper->removeMappings(button);
+ mPressMapper->removeMappings(button);
+ mClickMapper->removeMappings(button);
+ }
+ for (int i = mButtonLayout->count() - 1; i >= 0; i--) {
+ mButtonLayout->removeAt(i);
+ }
+ }
+}
+
+void HbQwertyKeyboardPrivate::initialize4x10Keypad(bool refreshButtonText)
+{
+ removeExistingSignalMappings();
+ mKeyboardSize = HbQwerty4x10;
+ Q_Q(HbQwertyKeyboard);
+ const HbKeyboardMap* keymap = mKeymap->keyboard(HbKeyboardVirtualQwerty);
+ if (keymap == 0) {
+ return;
+ }
+
+ for (int i = 0; i < keymap->keys.count() && i < HbVirtualQwerty4x11MaxKeysCount; ++i) {
+ if (refreshButtonText) {
+ mButtons[i]->setText(textForKey(i));
+ }
+ mReleaseMapper->setMapping(mButtons.at(i), keymap->keys.at(i)->keycode.unicode());
+ mPressMapper->setMapping(mButtons.at(i), keymap->keys.at(i)->keycode.unicode());
+ mClickMapper->setMapping(mButtons.at(i), keymap->keys.at(i)->keycode.unicode());
+ int row = 0;
+ int column = 0;
+ if (i < 10) {
+ row = 0;
+ column = i;
+ } else if (i < 19) {
+ row = 1;
+ column = i-10;
+ } else if (i < 28) {
+ row = 2;
+ column = i-19;
+ } else {
+ row = 3;
+ column = i-28;
+ if (column == 0) {
+ column = 2;
+ } else if (column == 1) {
+ column = 3;
+ } else if (column == 2) {
+ column = 6;
+ } else if (column == 3) {
+ column = 7;
+ }
+ }
+ mButtonLayout->addItem(mButtons.at(i), row, column);
+ setButtonObjectName(*mButtons.at(i), row, column, Qt::Key_unknown);
+ }
+
+ for (int i = HbVirtualQwerty4x10MaxKeysCount; i < HbVirtualQwerty4x11MaxKeysCount; ++i) {
+ mButtons[i]->hide();
+ }
+
+ for (int i = 0; i < 5; ++i) {
+ switch ( i ) {
+ case 0: {
+ mButtonLayout->addItem(mButtons.at(HbVirtualQwerty4x11MaxKeysCount+i), 1, 9);
+ setButtonObjectName(*mButtons.at(HbVirtualQwerty4x11MaxKeysCount+i), 1, 9, Qt::Key_Backspace);
+ mReleaseMapper->setMapping(mButtons.at(HbVirtualQwerty4x11MaxKeysCount+i), Qt::Key_Backspace);
+ mPressMapper->setMapping(mButtons.at(HbVirtualQwerty4x11MaxKeysCount+i), Qt::Key_Backspace);
+ mClickMapper->setMapping(mButtons.at(HbVirtualQwerty4x11MaxKeysCount+i), Qt::Key_Backspace);
+ break;
+ }
+ case 1: {
+ mButtonLayout->addItem(mButtons.at(HbVirtualQwerty4x11MaxKeysCount+i), 2, 9);
+ setButtonObjectName(*mButtons.at(HbVirtualQwerty4x11MaxKeysCount+i), 2, 9, Qt::Key_Enter);
+ mReleaseMapper->setMapping(mButtons.at(HbVirtualQwerty4x11MaxKeysCount+i), Qt::Key_Enter);
+ mPressMapper->setMapping(mButtons.at(HbVirtualQwerty4x11MaxKeysCount+i), Qt::Key_Enter);
+ mClickMapper->setMapping(mButtons.at(HbVirtualQwerty4x11MaxKeysCount+i), Qt::Key_Enter);
+ break;
+ }
+ case 2: {
+ mButtonLayout->addItem(mButtons.at(HbVirtualQwerty4x11MaxKeysCount+i), 3, 0);
+ setButtonObjectName(*mButtons.at(HbVirtualQwerty4x11MaxKeysCount+i), 3, 0, Qt::Key_Shift);
+ mReleaseMapper->setMapping(mButtons.at(HbVirtualQwerty4x11MaxKeysCount+i), Qt::Key_Shift);
+ mPressMapper->setMapping(mButtons.at(HbVirtualQwerty4x11MaxKeysCount+i), Qt::Key_Shift);
+ mClickMapper->setMapping(mButtons.at(HbVirtualQwerty4x11MaxKeysCount+i), Qt::Key_Shift);
+ break;
+ }
+ case 3: {
+ mButtonLayout->addItem(mButtons.at(HbVirtualQwerty4x11MaxKeysCount+i), 3, 1);
+ setButtonObjectName(*mButtons.at(HbVirtualQwerty4x11MaxKeysCount+i), 3, 1, Qt::Key_Control);
+ mReleaseMapper->setMapping(mButtons.at(HbVirtualQwerty4x11MaxKeysCount+i), Qt::Key_Control);
+ mPressMapper->setMapping(mButtons.at(HbVirtualQwerty4x11MaxKeysCount+i), Qt::Key_Control);
+ mClickMapper->setMapping(mButtons.at(HbVirtualQwerty4x11MaxKeysCount+i), Qt::Key_Control);
+ break;
+ }
+ case 4: {
+ mButtonLayout->addItem(mButtons.at(HbVirtualQwerty4x11MaxKeysCount+i), 3, 4, 1, 2);
+ setButtonObjectName(*mButtons.at(HbVirtualQwerty4x11MaxKeysCount+i), 3, 4, Qt::Key_Space);
+ mReleaseMapper->setMapping(mButtons.at(HbVirtualQwerty4x11MaxKeysCount+i), Qt::Key_Space);
+ mPressMapper->setMapping(mButtons.at(HbVirtualQwerty4x11MaxKeysCount+i), Qt::Key_Space);
+ mClickMapper->setMapping(mButtons.at(HbVirtualQwerty4x11MaxKeysCount+i), Qt::Key_Space);
+ break;
+ }
+ default:
+ break;
+ }
+ }
+ q->setupToolCluster();
+ if (mSettingsButton) {
+ mSettingsButton->setObjectName(HbCustomButtonObjName + QString::number(2));
+ mButtonLayout->addItem(mSettingsButton, 3, 8);
+ }
+ if (mApplicationButton) {
+ mApplicationButton->setObjectName(HbCustomButtonObjName + QString::number(3));
+ mButtonLayout->addItem(mApplicationButton, 3, 9);
+ }
+
+ setLayoutDimensions(calculateDimensions(q->keypadButtonAreaSize()));
+}
+
+void HbQwertyKeyboardPrivate::initialize4x11Keypad(bool refreshButtonText)
+{
+ removeExistingSignalMappings();
+ mKeyboardSize = HbQwerty4x11;
+ Q_Q(HbQwertyKeyboard);
+ const HbKeyboardMap* keymap = mKeymap->keyboard(HbKeyboardVirtualQwerty);
+ if (keymap == 0) {
+ return;
+ }
+
+ for (int i = 0; i < keymap->keys.count() && i <= HbVirtualQwerty4x11MaxKeysCount; ++i) {
+ if (refreshButtonText) {
+ mButtons[i]->setText(textForKey(i));
+ }
+ mReleaseMapper->setMapping(mButtons.at(i), keymap->keys.at(i)->keycode.unicode());
+ mPressMapper->setMapping(mButtons.at(i), keymap->keys.at(i)->keycode.unicode());
+ mClickMapper->setMapping(mButtons.at(i), keymap->keys.at(i)->keycode.unicode());
+ int row = 0;
+ int column = 0;
+ if (i < 11) {
+ row = 0;
+ column = i;
+ } else if (i < 21) {
+ row = 1;
+ column = i-11;
+ } else if (i < 31) {
+ row = 2;
+ column = i-21;
+ } else {
+ row = 3;
+ column = i-31;
+ if (column == 0) {
+ column = 2;
+ } else if (column == 1) {
+ column = 3;
+ } else if (column == 2) {
+ column = 6;
+ } else if (column == 3) {
+ column = 7;
+ } else if (column == 4) {
+ column = 8;
+ }
+ }
+ mButtonLayout->addItem(mButtons.at(i), row, column);
+ setButtonObjectName(*mButtons.at(i), row, column, Qt::Key_unknown);
+ if (i >= HbVirtualQwerty4x10MaxKeysCount) {
+ mButtons[i]->show();
+ }
+ }
+
+ for (int i = 0; i < 5; ++i) {
+ switch ( i ) {
+ case 0: {
+ mButtonLayout->addItem(mButtons.at(HbVirtualQwerty4x11MaxKeysCount+i), 1, 10);
+ setButtonObjectName(*mButtons.at(HbVirtualQwerty4x11MaxKeysCount+i), 1, 10, Qt::Key_Backspace);
+ mReleaseMapper->setMapping(mButtons.at(HbVirtualQwerty4x11MaxKeysCount+i), Qt::Key_Backspace);
+ mPressMapper->setMapping(mButtons.at(HbVirtualQwerty4x11MaxKeysCount+i), Qt::Key_Backspace);
+ mClickMapper->setMapping(mButtons.at(HbVirtualQwerty4x11MaxKeysCount+i), Qt::Key_Backspace);
+ break;
+ }
+ case 1: {
+ mButtonLayout->addItem(mButtons.at(HbVirtualQwerty4x11MaxKeysCount+i), 2, 10);
+ setButtonObjectName(*mButtons.at(HbVirtualQwerty4x11MaxKeysCount+i), 2, 10, Qt::Key_Enter);
+ mReleaseMapper->setMapping(mButtons.at(HbVirtualQwerty4x11MaxKeysCount+i), Qt::Key_Enter);
+ mPressMapper->setMapping(mButtons.at(HbVirtualQwerty4x11MaxKeysCount+i), Qt::Key_Enter);
+ mClickMapper->setMapping(mButtons.at(HbVirtualQwerty4x11MaxKeysCount+i), Qt::Key_Enter);
+ break;
+ }
+ case 2: {
+ mButtonLayout->addItem(mButtons.at(HbVirtualQwerty4x11MaxKeysCount+i), 3, 0);
+ setButtonObjectName(*mButtons.at(HbVirtualQwerty4x11MaxKeysCount+i), 3, 0, Qt::Key_Shift);
+ mReleaseMapper->setMapping(mButtons.at(HbVirtualQwerty4x11MaxKeysCount+i), Qt::Key_Shift);
+ mPressMapper->setMapping(mButtons.at(HbVirtualQwerty4x11MaxKeysCount+i), Qt::Key_Shift);
+ mClickMapper->setMapping(mButtons.at(HbVirtualQwerty4x11MaxKeysCount+i), Qt::Key_Shift);
+ break;
+ }
+ case 3: {
+ mButtonLayout->addItem(mButtons.at(HbVirtualQwerty4x11MaxKeysCount+i), 3, 1);
+ setButtonObjectName(*mButtons.at(HbVirtualQwerty4x11MaxKeysCount+i), 3, 1, Qt::Key_Control);
+ mReleaseMapper->setMapping(mButtons.at(HbVirtualQwerty4x11MaxKeysCount+i), Qt::Key_Control);
+ mPressMapper->setMapping(mButtons.at(HbVirtualQwerty4x11MaxKeysCount+i), Qt::Key_Control);
+ mClickMapper->setMapping(mButtons.at(HbVirtualQwerty4x11MaxKeysCount+i), Qt::Key_Control);
+ break;
+ }
+ case 4: {
+ mButtonLayout->addItem(mButtons.at(HbVirtualQwerty4x11MaxKeysCount+i), 3, 4, 1, 2);
+ setButtonObjectName(*mButtons.at(HbVirtualQwerty4x11MaxKeysCount+i), 3, 4, Qt::Key_Space);
+ mReleaseMapper->setMapping(mButtons.at(HbVirtualQwerty4x11MaxKeysCount+i), Qt::Key_Space);
+ mPressMapper->setMapping(mButtons.at(HbVirtualQwerty4x11MaxKeysCount+i), Qt::Key_Space);
+ mClickMapper->setMapping(mButtons.at(HbVirtualQwerty4x11MaxKeysCount+i), Qt::Key_Space);
+ break;
+ }
+ default:
+ break;
+ }
+ }
+
+ q->setupToolCluster();
+ if (mSettingsButton) {
+ mSettingsButton->setObjectName(HbCustomButtonObjName + QString::number(2));
+ mButtonLayout->addItem(mSettingsButton, 3, 9);
+ }
+ if (mApplicationButton) {
+ mApplicationButton->setObjectName(HbCustomButtonObjName + QString::number(3));
+ mButtonLayout->addItem(mApplicationButton, 3, 10);
+ }
+
+ setLayoutDimensions(calculateDimensions(q->keypadButtonAreaSize()));
+}
+
+bool HbQwertyKeyboardPrivate::showPreview(int keycode)
+{
+ if (keycode == Qt::Key_Enter ||
+ keycode == Qt::Key_Shift ||
+ keycode == Qt::Key_Control ||
+ keycode == Qt::Key_Backspace ||
+ keycode == Qt::Key_Space) {
+ return false;
+ }
+ return true;
+}
+
+void HbQwertyKeyboardPrivate::setButtonObjectName(HbTouchKeypadButton& button, int row, int column, Qt::Key specialKey)
+{
+ // bs, enter, more, pred, .com, space, 123sym, shift
+ QString objName;
+ switch(specialKey) {
+ case Qt::Key_Enter:
+ objName = HbEnterObjName;
+ break;
+ case Qt::Key_Shift:
+ objName = HbShiftObjName;
+ break;
+ case Qt::Key_Control:
+ objName = HbControlObjName;
+ break;
+ case Qt::Key_Backspace:
+ objName = HbBackspaceObjName;
+ break;
+ case Qt::Key_Space:
+ objName = HbSpaceObjName;
+ break;
+ default:
+ objName = (HbButtonObjName + QString::number(row+1) + "," + QString::number(column+1) );
+ break;
+ }
+ button.setObjectName(objName);
+}
+
+/*!
+Apply editor constraints to the vkb
+*/
+void HbQwertyKeyboardPrivate::applyEditorConstraints()
+{
+ HbInputFocusObject *focusedObject = 0;
+ if (mOwner) {
+ focusedObject = mOwner->focusObject();
+ }
+
+ if(!focusedObject || isKeyboardDimmed()) {
+ // dont need to apply constraints when keypad is dimmed.
+ // applyEditorConstraints will be called from setKeyboardDimmed(false)
+ return;
+ }
+
+ for (int i = 0; i < mButtons.count(); i++) {
+ if(Hb::ItemType_InputCharacterButton == mButtons.at(i)->type()) {
+ QString buttonText = mButtons.at(i)->text();
+ if (buttonText.isEmpty() || !focusedObject->characterAllowedInEditor(buttonText[0])) {
+ mButtons.at(i)->setFade(true);
+ } else {
+ mButtons.at(i)->setFade(false);
+ }
+ }
+ }
+}
+
+//
+// HbQwertyKeyboard
+//
+
+/*!
+Constructs the object. aOwner is the owning input method implementation. keyData
+is key mapping data to be used to display button texts. Key mapping data can be
+changed later (for example when the input language changes) by calling
+setKeyMapData. The keyboard is initialized based on the mode.
+*/
+HbQwertyKeyboard::HbQwertyKeyboard(HbInputMethod* owner,
+ const HbKeymap* keymap,
+ QGraphicsItem* aParent, HbKeypadMode mode)
+ : HbInputVkbWidget(*new HbQwertyKeyboardPrivate, aParent)
+{
+ Q_D(HbQwertyKeyboard);
+ d->mKeymap = keymap;
+ d->mClickMapper = new QSignalMapper(this);
+ d->q_ptr = this;
+ d->mOwner = owner;
+
+ d->mButtonLayout = new QGraphicsGridLayout();
+
+ // character preview pane
+ d->mPreviewPane = new HbCharPreviewPane();
+ connect(d->mPreviewPane, SIGNAL(charFromPreviewSelected(QString)), this, SIGNAL(charFromPreviewSelected(QString)));
+ // A QGraphicsItem bydefault is shown so we need to hide it.
+ d->mPreviewPane->hide();
+
+ d->mMode = mode;
+}
+
+HbQwertyKeyboard::HbQwertyKeyboard(HbQwertyKeyboardPrivate &dd, QGraphicsItem* parent)
+: HbInputVkbWidget(dd, parent)
+{
+}
+
+// ---------------------------------------------------------------------------
+// HbQwertyKeyboard::~HbQwertyKeyboard
+//
+// ---------------------------------------------------------------------------
+//
+HbQwertyKeyboard::~HbQwertyKeyboard()
+{
+}
+
+/*!
+Returns keyboard type.
+*/
+HbKeyboardType HbQwertyKeyboard::keyboardType() const
+{
+ return HbKeyboardVirtualQwerty;
+}
+
+// ---------------------------------------------------------------------------
+// HbQwertyKeyboard::setMode
+//
+// ---------------------------------------------------------------------------
+//
+void HbQwertyKeyboard::setMode(HbKeypadMode mode, HbModifiers modifiers)
+{
+ Q_D(HbQwertyKeyboard);
+
+ if(d->mMode == EModeNumeric && d->mKeypadCreated) {
+ // for numeric edito we need to update sct character button everytime
+ // we move between editors. ( dialer editor, digits only, formatted editor ect)
+ d->updateButtonsText();
+ }
+
+ setupToolCluster();
+ if (d->mMode == mode && d->mModifiers == modifiers && d->mKeypadCreated && !d->mKeymapChanged) {
+ d->applyEditorConstraints();
+ return;
+ }
+
+ d->mMode = mode;
+ d->mModifiers = modifiers;
+
+ const HbKeyboardMap* keymap = d->mKeymap->keyboard(HbKeyboardVirtualQwerty);
+ if (keymap == 0) {
+ return;
+ }
+
+ int keymapCount = keymap->keys.count();
+
+ if (!d->mKeypadCreated
+ || (keymapCount == HbVirtualQwerty4x10MaxKeysCount && d->mKeyboardSize == HbQwertyKeyboardPrivate::HbQwerty4x11)
+ || (keymapCount == HbVirtualQwerty4x11MaxKeysCount && d->mKeyboardSize == HbQwertyKeyboardPrivate::HbQwerty4x10)) {
+ if (!d->mKeypadCreated) {
+ d->constructKeypad();
+ d->initializeKeyboard(false);
+ } else {
+ d->initializeKeyboard(true);
+ }
+ d->applyEditorConstraints();
+ d->setRockerPosition();
+ return;
+ }
+ if (d->mMode == EModeNumeric) {
+ // Numeric keyboard does not change mode
+ return;
+ }
+
+ for (int i = 0; i < d->mButtons.count(); i++) {
+ if (i < keymapCount) {
+ d->mButtons.at(i)->setText(d->textForKey(i));
+ if (d->mKeymapChanged) {
+ HbTouchKeypadButton *button = d->mButtons.at(i);
+ d->mReleaseMapper->removeMappings(button);
+ d->mPressMapper->removeMappings(button);
+ d->mClickMapper->removeMappings(button);
+ d->mReleaseMapper->setMapping(button, keymap->keys.at(i)->keycode.unicode());
+ d->mPressMapper->setMapping(button, keymap->keys.at(i)->keycode.unicode());
+ d->mClickMapper->setMapping(button, keymap->keys.at(i)->keycode.unicode());
+ }
+ }
+ }
+ d->applyEditorConstraints();
+}
+
+/*!
+Sets key map data object. Given key map data will be used as a source for button titles.
+Usually the key map data for active input language is used.
+*/
+void HbQwertyKeyboard::setKeymap(const HbKeymap* keymap)
+{
+ Q_D(HbQwertyKeyboard);
+ if (keymap) {
+ d->mKeymap = keymap;
+ d->mKeymapChanged = true;
+ // let's change the button text depending on the new keymapping.
+ HbInputState newState = d->mOwner->inputState();
+ if (newState.textCase() == HbTextCaseUpper || newState.textCase() == HbTextCaseAutomatic) {
+ setMode(d->mMode, HbModifierShiftPressed);
+ } else {
+ setMode(d->mMode, HbModifierNone);
+ }
+ d->mKeymapChanged = false;
+ }
+}
+
+/*!
+Initializes keypad dimensions based on the current screen configuration.
+*/
+void HbQwertyKeyboard::aboutToOpen(HbVkbHost *host)
+{
+ Q_D(HbQwertyKeyboard);
+
+ HbInputVkbWidget::aboutToOpen(host);
+
+ d->setLayoutDimensions(d->calculateDimensions(keypadButtonAreaSize()));
+}
+
+/*!
+Returns preferred keyboard size. HbVkbHost uses this information when it opens the keyboard.
+*/
+QSizeF HbQwertyKeyboard::preferredKeyboardSize()
+{
+ Q_D(HbQwertyKeyboard);
+
+ QSizeF result = HbInputVkbWidget::preferredKeyboardSize();
+
+ if (d->mMode == EModeNumeric) {
+ //We need to subtract the height of the close handle from prefered size of keypad
+ //before calculating the height of each row.
+ qreal height = (result.height() - HbCloseHandleHeight) / (qreal)HbVirtualQwertyNumberOfRows;
+ result.setHeight(HbVirtualQwertyNumberOfRowsNumberMode * height + HbCloseHandleHeight);
+ }
+
+ return QSizeF(result);
+}
+
+/*!
+This function shows the preview of characters on top of currently pressed button.
+*/
+bool HbQwertyKeyboard::previewCharacters(const QStringList& characters)
+{
+ Q_D(HbQwertyKeyboard);
+
+ // Don't do anything if the current button index is not in the range.
+ if (d->mPressedButtonIndex < 0 || d->mPressedButtonIndex > d->mButtons.size()) {
+ return false;
+ }
+
+ // let's set mLongKeyPressCharsShown. Since if the long press preview pane is On
+ // we should not close the preview pane when the button is released.
+ if (!d->mInStickyRegion) {
+ if (characters.count()) {
+ // we should not show the long press preview pane if the character size is 1 and matches with
+ // the the button text.
+ if (characters.count() == 1
+ && (d->mButtons.at(d->mPressedButtonIndex)->text().compare(characters.at(0)) == 0)) {
+ d->mLongKeyPressCharsShown = false;
+ } else {
+ d->launchPreviewPane(characters);
+ d->mLongKeyPressCharsShown = true;
+ }
+ } else {
+ d->mLongKeyPressCharsShown = false;
+ }
+ } else {
+ // This situation is not likely to happen as we might have closed
+ // the preview pane in enteredInNonStickyRegion function.
+ if (d->mPreviewPane->isVisible()) {
+ d->mPreviewPane->hide();
+ }
+ d->mLongKeyPressCharsShown = false;
+ }
+
+ // let's inform the caller that there preview is not possible with the
+ // character set sent.
+ return d->mLongKeyPressCharsShown;
+}
+
+/*!
+This function is called when the keypad is about to close.
+*/
+void HbQwertyKeyboard::aboutToClose(HbVkbHost *host)
+{
+ Q_UNUSED(host);
+ Q_D(HbQwertyKeyboard);
+ // Let's hide the preview pane.
+ if (d->mPreviewPane->isVisible()) {
+ d->mPreviewPane->hide();
+ }
+ // reset the states as the keypad is closing..!
+ d->mLongKeyPressCharsShown = false;
+ d->mInStickyRegion = true;
+
+ HbInputVkbWidget::aboutToClose(host);
+}
+
+/*!
+\deprecated HbQwertyKeyboard::initSctModeList()
+ is deprecated. Sct mode list is not supported anymore.
+*/
+void HbQwertyKeyboard::initSctModeList()
+{
+}
+
+/*!
+\deprecated HbQwertyKeyboard::sctModeListClosed()
+ is deprecated. Sct mode list is not supported anymore.
+*/
+void HbQwertyKeyboard::sctModeListClosed()
+{
+}
+
+/*!
+This slot is called when we slide our fingures on top of the keypad buttons and
+while sliding our fingure comes on top of a non sticky button Or on a region outside
+the keypad area.
+*/
+void HbQwertyKeyboard::enteredInNonStickyRegion()
+{
+ Q_D(HbQwertyKeyboard);
+ if (d->mPreviewPane->isVisible()) {
+ d->mPreviewPane->hide();
+ }
+ d->mInStickyRegion = true;
+ d->mLongKeyPressCharsShown = false;
+}
+
+/*!
+Handles virtual key release
+*/
+void HbQwertyKeyboard::mappedKeyClick(int buttonid)
+{
+ Q_D(HbQwertyKeyboard);
+
+ if( d->mMode == EModeNumeric && buttonid != Qt::Key_Control && buttonid != Qt::Key_Shift
+ && buttonid != Qt::Key_Backspace ) {
+ const QString &text = d->mButtons[buttonid]->text();
+ if(!text.isEmpty()){
+ buttonid = text[0].unicode();
+ }
+ }
+
+ d->handleStandardButtonClick(buttonid);
+}
+// End of file