FCL/sf/mw/hb: comparison src/hbinput/inputwidgets/hbinputsctkeyboard.cpp

equal deleted inserted replaced

-:7516d6d86cf5
+:ed14f46c0e55
 #include <hbinputmethod.h>
 #include <hbinputkeymap.h>
 #include <hbinpututils.h>
 #include <hbframedrawer.h>
 #include <hbinputsettingproxy.h>
+#include <hbmainwindow.h>
+#include <hbwidgetfeedback.h>
 #include "hbinputbuttongroup.h"
 #include "hbinputbutton.h"
 const qreal HbPortraitKeyboardHeightInUnits = 45.9;
 const qreal HbPortraitKeyboardWidthInUnits = 53.8;
-const qreal HbLandscapeKeyboardHeightInUnits = 33.7;
+const qreal HbLandscapeKeyboardHeightInUnits = 27.0;
 const qreal HbLandscapeKeyboardWidthInUnits = 95.5;
 const int HbSctPortraitNumberOfRows = 5;
 const int HbSctPortraitNumberOfColumns = 5;
-const int HbPortraitButtonKeyCodeTable[HbSctPortraitNumberOfRows *HbSctPortraitNumberOfColumns] = {
+const int HbPortraitButtonCount = HbSctPortraitNumberOfRows * HbSctPortraitNumberOfColumns;
+const int HbPortraitButtonKeyCodeTable[HbPortraitButtonCount] = {
 HbInputButton::ButtonKeyCodeCharacter,
 HbInputButton::ButtonKeyCodeCharacter,
 HbInputButton::ButtonKeyCodeCharacter,
 HbInputButton::ButtonKeyCodeCharacter,
 HbInputButton::ButtonKeyCodeDelete,
 HbInputButton::ButtonKeyCodeCustom
 };
 const int HbSctLandscapeNumberOfRows = 4;
 const int HbSctLandscapeNumberOfColumns = 10;
-const int HbLandscapeButtonKeyCodeTable[HbSctLandscapeNumberOfRows *HbSctLandscapeNumberOfColumns] = {
+const int HbLandscapeButtonCount = HbSctLandscapeNumberOfRows * HbSctLandscapeNumberOfColumns - 1;
+const int HbLandscapeButtonKeyCodeTable[HbLandscapeButtonCount] = {
 HbInputButton::ButtonKeyCodeCharacter,
 HbInputButton::ButtonKeyCodeCharacter,
 HbInputButton::ButtonKeyCodeCharacter,
 HbInputButton::ButtonKeyCodeCharacter,
 HbInputButton::ButtonKeyCodeCharacter,
 const QChar HbSctSpaceGlyph = ' ';
 const QChar HbSctEnterGlyph = ' ';
 #endif
 /*!
-@proto
+@stable
 @hbinput
 \class HbSctKeyboard
-\brief Touch keyboard for special characters
+\brief The HbSctKeyboard class provides a touch keyboard for special characters.
-Implements special character keyboard. The keyboard knows how to set up button titles according to
+The class implements a special character keyboard. The keyboard supports setting up
-given key map data object and it also supports editor specific custom buttons.
+button titles according to a given keymap data object, and it also supports
+editor-specific custom buttons.
 \sa HbInputVkbWidget
 */
 HbSctKeyboardPrivate::HbSctKeyboardPrivate()
 {
 Q_Q(HbSctKeyboard);
 HbInputVkbWidgetPrivate::init();
-if (HbInputSettingProxy::instance()->activeKeyboard() & HbQwertyKeyboardMask) {
+Qt::Orientation orientation = Qt::Horizontal;
+if (q->mainWindow()) {
+orientation = q->mainWindow()->orientation();
+}
+if (HbInputSettingProxy::instance()->activeKeyboard(orientation) & HbQwertyKeyboardMask) {
 mType = HbKeyboardSctLandscape;
+} else {
+mType = HbKeyboardSctPortrait;
 }
 HbInputButtonGroup *buttonGroup = static_cast<HbInputButtonGroup *>(q->contentItem());
 if (buttonGroup) {
 mColumns = HbSctPortraitNumberOfColumns;
 mRows = HbSctPortraitNumberOfRows;
+int count = HbPortraitButtonCount;
 if (mType == HbKeyboardSctLandscape) {
 mColumns = HbSctLandscapeNumberOfColumns;
 mRows = HbSctLandscapeNumberOfRows;
+count = HbLandscapeButtonCount;
 buttonGroup->setButtonPreviewEnabled(HbInputSettingProxy::instance()->isCharacterPreviewForQwertyEnabled());
 }
 buttonGroup->setGridSize(QSize(mColumns, mRows));
 int key = 0;
 QList<HbInputButton *> buttons;
-for (int i = 0; i < mColumns * mRows; ++i) {
+for (int i = 0; i < count; ++i) {
 HbInputButton *item = new HbInputButton(keyCode(i), QPoint(key % mColumns, key / mColumns));
 buttons.append(item);
 if (keyCode(i) == HbInputButton::ButtonKeyCodeCharacter) {
 ++mCharacterButtons;
 } else if (keyCode(i) == HbInputButton::ButtonKeyCodeSpace) {
 item->setSize(QSize(2, 1));
 ++key;
 } else if (keyCode(i) == HbInputButton::ButtonKeyCodeDelete &&
-mType == HbKeyboardSctPortrait) {
+(mType == HbKeyboardSctPortrait || mType == HbKeyboardSctEmail || mType == HbKeyboardSctUrl )) {
 // Portrait SCT has different delete icon from the default one
 item->setIcon(HbIcon(HbInputButtonIconDelete2), HbInputButton::ButtonIconIndexPrimary);
 } else if (keyCode(i) == HbInputButton::ButtonKeyCodeAlphabet) {
 // Button that is used to return to normal keypad should be shown as latched
 item->setState(HbInputButton::ButtonStateLatched);
-if (mType == HbKeyboardSctPortrait) {
+if (mType == HbKeyboardSctPortrait || mType == HbKeyboardSctEmail || mType == HbKeyboardSctUrl ) {
 // Portrait SCT has different symbol icon from the default one
 item->setIcon(HbIcon(HbInputButtonIconSymbol2), HbInputButton::ButtonIconIndexPrimary);
 }
 }
 ++key;
 QObject::connect(q, SIGNAL(flickEvent(HbInputVkbWidget::HbFlickDirection)), buttonGroup, SLOT(cancelButtonPress()));
 }
 int HbSctKeyboardPrivate::keyCode(int buttonId)
 {
-if (mType == HbKeyboardSctPortrait) {
+if (mType == HbKeyboardSctLandscape) {
+return HbLandscapeButtonKeyCodeTable[buttonId];
+} else {
 return HbPortraitButtonKeyCodeTable[buttonId];
-} else {
+}
-return HbLandscapeButtonKeyCodeTable[buttonId];
+}
-}
-}
 void HbSctKeyboardPrivate::applyEditorConstraints()
 {
 Q_Q(HbSctKeyboard);
 HbInputFocusObject *focusedObject = mOwner->focusObject();
+HbInputButtonGroup *buttonGroup = static_cast<HbInputButtonGroup *>(q->contentItem());
+applyEditorConstraints(focusedObject, buttonGroup);
+}
+void HbSctKeyboardPrivate::applyEditorConstraints(HbInputFocusObject *focusedObject, HbInputButtonGroup *buttonGroup)
+{
 if (!focusedObject) {
 return;
 }
-HbInputButtonGroup *buttonGroup = static_cast<HbInputButtonGroup *>(q->contentItem());
 if (buttonGroup) {
-QList<HbInputButton *> buttons = buttonGroup->buttons();
+QList<HbInputButton*> buttons = buttonGroup->buttons();
 for (int i = 0; i < buttons.count(); ++i) {
 HbInputButton *item = buttons.at(i);
 HbInputButton::HbInputButtonState state = item->state();
 if (keyCode(i) == HbInputButton::ButtonKeyCodeCharacter) {
 QString data = item->text(HbInputButton::ButtonTextIndexPrimary);
 if (data.isEmpty() || !focusedObject->characterAllowedInEditor(data.at(0))) {
 state = HbInputButton::ButtonStateDisabled;
 } else if (item->state() == HbInputButton::ButtonStateDisabled) {
 state = HbInputButton::ButtonStateReleased;
 }
 } else if (keyCode(i) == HbInputButton::ButtonKeyCodeSmiley) {
 if (focusedObject->editorInterface().isNumericEditor() ||
-!focusedObject->editorInterface().editorClass() == HbInputEditorClassUnknown ||
 !isSmileysEnabled()) {
 state = HbInputButton::ButtonStateDisabled;
 } else if (item->state() == HbInputButton::ButtonStateDisabled) {
 state = HbInputButton::ButtonStateReleased;
 }
 state = HbInputButton::ButtonStateReleased;
 }
 }
 item->setState(state);
 }
 buttonGroup->setButtons(buttons);
 }
 }
 void HbSctKeyboardPrivate::updateKeyCodes()
 {
 Q_Q(HbSctKeyboard);
+HbInputFocusObject *focusedObject = mOwner->focusObject();
+if (!focusedObject) {
+return;
+}
+Qt::Orientation orientation = Qt::Horizontal;
+if (q->mainWindow()) {
+orientation = q->mainWindow()->orientation();
+}
+if (HbInputSettingProxy::instance()->activeKeyboard(orientation) & HbQwertyKeyboardMask){
+mType = HbKeyboardSctLandscape;
+} else if (focusedObject && focusedObject->editorInterface().editorClass() == HbInputEditorClassEmail &&
+mKeymap->keyboard(HbKeyboardSctEmail)) {
+mType = HbKeyboardSctEmail;
+} else if (focusedObject && focusedObject->editorInterface().editorClass() == HbInputEditorClassUrl &&
+mKeymap->keyboard(HbKeyboardSctUrl)) {
+mType = HbKeyboardSctUrl;
+} else {
+mType = HbKeyboardSctPortrait;
+}
 mPages = 0;
 const HbKeyboardMap *keyboardMap = mKeymap->keyboard(q->keyboardType());
 if (keyboardMap) {
-mPages = (int)ceil((float)(keyboardMap->keys.count() / mCharacterButtons));
+mPages = (int)ceil((float)countActiveKeys() / mCharacterButtons);
 }
-if (mPages > 1) {
+mFlickAnimation = mPages > 1;
-mFlickAnimation = true;
-}
 HbInputButtonGroup *buttonGroup = static_cast<HbInputButtonGroup *>(q->contentItem());
 if (buttonGroup) {
-int key = mActivePage * mCharacterButtons;
+int key = keyAtIndex(mActivePage * mCharacterButtons);
 QList<HbInputButton *> buttons = buttonGroup->buttons();
 for (int i = 0; i < buttons.count(); ++i) {
 if (keyCode(i) == HbInputButton::ButtonKeyCodeCharacter) {
 HbInputButton *item = buttons.at(i);
 if (keyboardMap && key < keyboardMap->keys.count()) {
 // Replace space and enter markers with correct keycodes
-if (keyboardMap->keys.at(key)->keycode.unicode() == HbSctSpaceMarker) {
+if (focusedObject->characterAllowedInEditor(keyboardMap->keys.at(key)->characters(HbModifierNone).at(0)) || mType == HbKeyboardSctLandscape){
-item->setKeyCode(HbInputButton::ButtonKeyCodeSpace);
+if (keyboardMap->keys.at(key)->keycode.unicode() == HbSctSpaceMarker) {
-} else if (keyboardMap->keys.at(key)->keycode.unicode() == HbSctEnterMarker) {
+item->setKeyCode(HbInputButton::ButtonKeyCodeSpace);
-item->setKeyCode(HbInputButton::ButtonKeyCodeEnter);
+} else if (keyboardMap->keys.at(key)->keycode.unicode() == HbSctEnterMarker) {
+item->setKeyCode(HbInputButton::ButtonKeyCodeEnter);
+} else {
+item->setKeyCode(keyboardMap->keys.at(key)->keycode.unicode());
+}
 } else {
-item->setKeyCode(keyboardMap->keys.at(key)->keycode.unicode());
+i--;
 }
 } else {
 item->setKeyCode(-1);
 }
 ++key;
 }
 }
 }
+applyEditorConstraints();
 }
 void HbSctKeyboardPrivate::updateButtons()
 {
 Q_Q(HbSctKeyboard);
+HbInputFocusObject *focusedObject = mOwner->focusObject();
+if (!focusedObject) {
+return;
+}
 HbInputButtonGroup *buttonGroup = static_cast<HbInputButtonGroup *>(q->contentItem());
 if (buttonGroup) {
-int key = mActivePage * mCharacterButtons;
+int key = keyAtIndex(mActivePage * mCharacterButtons);
 QList<HbInputButton *> buttons = buttonGroup->buttons();
 for (int i = 0; i < buttons.count(); ++i) {
 if (keyCode(i) == HbInputButton::ButtonKeyCodeCharacter) {
 HbInputButton *item = buttons.at(i);
 const HbKeyboardMap *keyboardMap = mKeymap->keyboard(q->keyboardType());
 if (keyboardMap && key < keyboardMap->keys.count() && keyboardMap->keys.at(key)->characters(HbModifierNone) != QString("")) {
-QString keydata = keyboardMap->keys.at(key)->characters(HbModifierNone);
+if (focusedObject->characterAllowedInEditor(keyboardMap->keys.at(key)->characters(HbModifierNone).at(0)) || mType == HbKeyboardSctLandscape){
-// Replace space and enter markers with correct glyphs.
+QString keydata = keyboardMap->keys.at(key)->characters(HbModifierNone);
-// These only exist in symbian fonts, so if we are not using symbian, use blank.
+// Replace space and enter markers with correct glyphs.
-if (keydata.at(0) == HbSctSpaceMarker) {
+// These only exist in symbian fonts, so if we are not using symbian, use blank.
-item->setText(HbSctSpaceGlyph, HbInputButton::ButtonTextIndexPrimary);
+if (keydata.at(0) == HbSctSpaceMarker) {
-} else if (keydata.at(0) == HbSctEnterMarker) {
+item->setText(HbSctSpaceGlyph, HbInputButton::ButtonTextIndexPrimary);
-item->setText(HbSctEnterGlyph, HbInputButton::ButtonTextIndexPrimary);
+} else if (keydata.at(0) == HbSctEnterMarker) {
+item->setText(HbSctEnterGlyph, HbInputButton::ButtonTextIndexPrimary);
+} else {
+item->setText(keydata.at(0), HbInputButton::ButtonTextIndexPrimary);
+}
 } else {
-item->setText(keydata.at(0), HbInputButton::ButtonTextIndexPrimary);
+i--;
 }
 } else {
 item->setText("", HbInputButton::ButtonTextIndexPrimary);
 }
 }
 buttonGroup->setButtons(buttons);
 }
 }
-/*!
+int HbSctKeyboardPrivate::keyAtIndex(int index)
-Constructs the object. owner is the owning input method implementation. Keymap
+{
-is key mapping data to be used to display button texts. Key mapping data can be
+Q_Q(HbSctKeyboard);
-changed later (for example when the input language changes) by calling
-setKeymap.
+const HbKeyboardMap *keyboardMap = mKeymap->keyboard(q->keyboardType());
+if (mType == HbKeyboardSctLandscape){
+return index;
+}
+int totalKeys=0;
+HbInputFocusObject *focusedObject = mOwner->focusObject();
+HbInputButtonGroup *buttonGroup = static_cast<HbInputButtonGroup*>(q->contentItem());
+if (buttonGroup) {
+if (keyboardMap && totalKeys < keyboardMap->keys.count()) {
+while (index){
+if (focusedObject->characterAllowedInEditor(keyboardMap->keys.at(totalKeys)->characters(HbModifierNone).at(0))){
+index--;
+}
+totalKeys++;
+}
+}
+}
+return totalKeys;
+}
+int HbSctKeyboardPrivate::countActiveKeys()
+{
+Q_Q(HbSctKeyboard);
+const HbKeyboardMap *keyboardMap = mKeymap->keyboard(q->keyboardType());
+if (mType == HbKeyboardSctLandscape){
+return keyboardMap->keys.count();
+}
+int totalKeys=0;
+HbInputFocusObject *focusedObject = mOwner->focusObject();
+HbInputButtonGroup *buttonGroup = static_cast<HbInputButtonGroup*>(q->contentItem());
+if (buttonGroup) {
+if (keyboardMap && totalKeys < keyboardMap->keys.count()) {
+foreach(HbMappedKey *key, keyboardMap->keys){
+if (focusedObject->characterAllowedInEditor(key->characters(HbModifierNone).at(0))){
+totalKeys++;
+}
+}
+}
+}
+return totalKeys;
+}
+void HbSctKeyboardPrivate::changePage(HbInputVkbWidget::HbFlickDirection flickDirection)
+{
+if (mFlickAnimation) {
+int direction = 1;
+if (flickDirection == HbInputVkbWidget::HbFlickDirectionRight) {
+direction = -1;
+}
+mActivePage = (mActivePage + direction) % mPages;
+if (mActivePage < 0) {
+mActivePage = mPages - 1;
+}
+updateButtons();
+updateKeyCodes();
+}
+}
+/*!
+Constructor. \a owner is the owning input method implementation, and
+\a keymap is the key mapping data that is used to display the button texts. Key mapping
+data can be changed later (for example when the input language changes) by calling
+the base class function HbInputVkbWidget::setKeymap.
 */
 HbSctKeyboard::HbSctKeyboard(HbInputMethod *owner, const HbKeymap *keymap, QGraphicsItem *parent)
 : HbInputVkbWidget(*new HbSctKeyboardPrivate, parent)
 {
 if (!owner) {
 d->mOwner = owner;
 setKeymap(keymap);
 const HbKeyboardMap *keyboardMap = keymap->keyboard(keyboardType());
 if (keyboardMap) {
-d->mPages = (int)ceil((float)(keyboardMap->keys.count() / d->mCharacterButtons));
+d->mPages = (int)ceil((float)d->countActiveKeys() / d->mCharacterButtons);
 }
-if (d->mPages > 1) {
+d->mFlickAnimation = d->mPages > 1;
-d->mFlickAnimation = true;
-}
 if (d->mType == HbKeyboardSctLandscape) {
 connect(HbInputSettingProxy::instance(), SIGNAL(characterPreviewStateForQwertyChanged(bool)), this, SLOT(updateButtonPreviewStatus(bool)));
 }
 connect(this, SIGNAL(flickEvent(HbInputVkbWidget::HbFlickDirection)), this, SLOT(changePage(HbInputVkbWidget::HbFlickDirection)));
 }
 /*!
-Constructs the object. owner is the owning input method implementation. Keymap
+Constructor. \a owner is the owning input method implementation, and
-is key mapping data to be used to display button texts. Key mapping data can be
+\a keymap is the key mapping data that is used to display the button texts. Key mapping
-changed later (for example when the input language changes) by calling
+data can be changed later (for example when the input language changes) by calling
-setKeymap.
+the base class function HbInputVkbWidget::setKeymap.
 */
 HbSctKeyboard::HbSctKeyboard(HbSctKeyboardPrivate &dd, HbInputMethod *owner,
 const HbKeymap *keymap, QGraphicsItem *parent)
 : HbInputVkbWidget(dd, parent)
 {
 d->mOwner = owner;
 setKeymap(keymap);
 const HbKeyboardMap *keyboardMap = keymap->keyboard(keyboardType());
 if (keyboardMap) {
-d->mPages = (int)ceil((float)(keyboardMap->keys.count() / d->mCharacterButtons));
+d->mPages = (int)ceil((float)d->countActiveKeys() / d->mCharacterButtons);
 }
-if (d->mPages > 1) {
+d->mFlickAnimation = d->mPages > 1;
-d->mFlickAnimation = true;
-}
 if (d->mType == HbKeyboardSctLandscape) {
 connect(HbInputSettingProxy::instance(), SIGNAL(characterPreviewStateForQwertyChanged(bool)), this, SLOT(updateButtonPreviewStatus(bool)));
 }
 connect(this, SIGNAL(flickEvent(HbInputVkbWidget::HbFlickDirection)), this, SLOT(changePage(HbInputVkbWidget::HbFlickDirection)));
 }
 /*!
-Destructs the object.
+Destructor.
 */
 HbSctKeyboard::~HbSctKeyboard()
 {
 }
 /*!
-Returns keyboard type.
+Returns the keyboard type.
 */
 HbKeyboardType HbSctKeyboard::keyboardType() const
 {
 Q_D(const HbSctKeyboard);
 return d->mType;
 }
 /*!
-Returns preferred keyboard size. HbVkbHost uses this information when it opens the keyboard.
+Returns the preferred keyboard size. HbVkbHost uses this information when it opens the keyboard.
 */
 QSizeF HbSctKeyboard::preferredKeyboardSize()
 {
 Q_D(HbSctKeyboard);
 return QSizeF(result);
 }
 /*!
-Sets the keypad to given mode. Possible values are EModeAbc, EModeNumeric and EModeSct.
+Sets the keypad to given \a mode. Possible values are EModeAbc and EModeNumeric.
+\a modifiers is a set of flags for shift, chr, and fn keys (see details in file
+<tt>hbinputdef.h</tt>).
 */
 void HbSctKeyboard::setMode(HbKeypadMode mode, HbModifiers modifiers)
 {
 Q_D(HbSctKeyboard);
 HbInputVkbWidget::setMode(mode, modifiers);
 }
 /*!
-Updates button preview status.
+Updates the button preview status.
 */
 void HbSctKeyboard::updateButtonPreviewStatus(bool status)
 {
 HbInputButtonGroup *buttonGroup = static_cast<HbInputButtonGroup *>(contentItem());
 if (buttonGroup) {
 buttonGroup->setButtonPreviewEnabled(status);
 }
 }
 /*!
-Handles flick gesture
+Handles the flick gesture.
 */
 void HbSctKeyboard::changePage(HbInputVkbWidget::HbFlickDirection flickDirection)
 {
 Q_D(HbSctKeyboard);
-if (flickDirection == HbInputVkbWidget::HbFlickDirectionRight ||
+if (d->mFlickAnimation &&
-flickDirection == HbInputVkbWidget::HbFlickDirectionLeft) {
+(flickDirection == HbInputVkbWidget::HbFlickDirectionRight ||
-int direction = 1;
+flickDirection == HbInputVkbWidget::HbFlickDirectionLeft)) {
-if (flickDirection == HbInputVkbWidget::HbFlickDirectionRight) {
-direction = -1;
+HbWidgetFeedback::triggered(this, Hb::InstantFlicked);
-}
+d->changePage(flickDirection);
+}
-d->mActivePage = (d->mActivePage + direction) % d->mPages;
+}
-if (d->mActivePage < 0) {
-d->mActivePage = d->mPages - 1;
+/*!
-}
+Sends the key press event to the owning input method.
-d->updateKeyCodes();
-d->updateButtons();
-d->applyEditorConstraints();
-}
-}
-/*!
-Sends key event to owning input method.
 */
 void HbSctKeyboard::sendKeyPressEvent(const QKeyEvent &event)
 {
 if (event.key() != HbInputButton::ButtonKeyCodePageChange &&
 event.key() != HbInputButton::ButtonKeyCodeSmiley) {
 HbInputVkbWidget::sendKeyPressEvent(event);
 }
 }
 /*!
-Sends key event to owning input method.
+Sends the key release event to the owning input method.
 */
 void HbSctKeyboard::sendKeyReleaseEvent(const QKeyEvent &event)
 {
+Q_D(HbSctKeyboard);
 if (event.key() == HbInputButton::ButtonKeyCodePageChange) {
-changePage(HbInputVkbWidget::HbFlickDirectionLeft);
+d->changePage(HbInputVkbWidget::HbFlickDirectionLeft);
 } else if (event.key() == HbInputButton::ButtonKeyCodeSmiley) {
 showSmileyPicker();
 } else {
 HbInputVkbWidget::sendKeyReleaseEvent(event);
 }
 }
 /*!
-Sends key event to owning input method.
+Sends the key change event to the owning input method.
-Release event is ignored.
+The release event is ignored, and the press event is handled further.
 */
 void HbSctKeyboard::sendKeyChangeEvent(const QKeyEvent &releaseEvent, const QKeyEvent &pressEvent)
 {
 if (pressEvent.key() != HbInputButton::ButtonKeyCodePageChange &&
 pressEvent.key() != HbInputButton::ButtonKeyCodeSmiley) {

changeset 34	ed14f46c0e55
parent 7	923ff622b8b9