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

equal deleted inserted replaced

-:923ff622b8b9
+:4633027730f5
 HbInputVkbWidgetPrivate::init();
 if (HbInputSettingProxy::instance()->activeKeyboard() & HbQwertyKeyboardMask) {
 mType = HbKeyboardSctLandscape;
+} else {
+mType = HbKeyboardSctPortrait;
 }
 HbInputButtonGroup *buttonGroup = static_cast<HbInputButtonGroup *>(q->contentItem());
 if (buttonGroup) {
 mColumns = HbSctPortraitNumberOfColumns;
 ++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 HbPortraitButtonKeyCodeTable[buttonId];
+return HbLandscapeButtonKeyCodeTable[buttonId];
 } else {
-return HbLandscapeButtonKeyCodeTable[buttonId];
+return HbPortraitButtonKeyCodeTable[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;
 state = HbInputButton::ButtonStateReleased;
 }
 }
 item->setState(state);
 }
 buttonGroup->setButtons(buttons);
 }
 }
 void HbSctKeyboardPrivate::updateKeyCodes()
 {
 Q_Q(HbSctKeyboard);
+HbInputFocusObject *focusedObject = mOwner->focusObject();
+if (!focusedObject) {
+return;
+}
+if (HbInputSettingProxy::instance()->activeKeyboard() & HbQwertyKeyboardMask){
+mType = HbKeyboardSctLandscape;
+} else if (focusedObject && focusedObject->editorInterface().editorClass() == HbInputEditorClassEmail) {
+mType = HbKeyboardSctEmail;
+} else if (focusedObject && focusedObject->editorInterface().editorClass() == HbInputEditorClassUrl) {
+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)
+{
+Q_Q(HbSctKeyboard);
+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;
+}
 /*!
 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
 changed later (for example when the input language changes) by calling
 setKeymap.
 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)));
 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)));
 Returns 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.
 */
 void HbSctKeyboard::changePage(HbInputVkbWidget::HbFlickDirection flickDirection)
 {
 Q_D(HbSctKeyboard);
-if (flickDirection == HbInputVkbWidget::HbFlickDirectionRight ||
+if (d->mFlickAnimation) {
-flickDirection == HbInputVkbWidget::HbFlickDirectionLeft) {
 int direction = 1;
 if (flickDirection == HbInputVkbWidget::HbFlickDirectionRight) {
 direction = -1;
 }
 d->mActivePage = (d->mActivePage + direction) % d->mPages;
 if (d->mActivePage < 0) {
 d->mActivePage = d->mPages - 1;
 }
+d->updateButtons();
 d->updateKeyCodes();
-d->updateButtons();
-d->applyEditorConstraints();
 }
 }
 /*!
 Sends key event to owning input method.

changeset 21	4633027730f5
parent 7	923ff622b8b9
child 23	e6ad4ef83b23