FCL/sf/mw/hb: comparison src/hbcore/vkbhosts/hbabstractvkbhost.cpp

equal deleted inserted replaced

-:16d8024aca5e
+:f7ac710697a9
 ****************************************************************************/
 #include "hbabstractvkbhost.h"
 #include "hbabstractvkbhost_p.h"
 #include "hbinputvirtualkeyboard.h"
 #include "hbinputsettingproxy.h"
+#include "hbinputvkbhostbridge.h"
 #include "hbinputmethod.h"
 #include "hbdeviceprofile.h"
 #include "hbmainwindow.h"
 #include "hbpopup.h"
 #include "hbview.h"
 mKeypadMovementStartingPoint(QPointF(0, 0)),
 mKeypadMovementVector(QPointF(0, 0)),
 mInputMethod(0),
 mKeypadStatusBeforeOrientationChange(HbVkbHost::HbVkbStatusClosed)
 {
+mTimeLine.setUpdateInterval(16);
 }
 void HbAbstractVkbHostPrivate::prepareAnimationsCommon()
 {
 if (mContainerWidget && mKeypad) {
 // Check whether the cursor rectangle is inside visible area.
 if (!visibleArea.contains(microFocus)) {
 // The cursor is outside the visible area. Figure out how much and
 // to which direction the container has to be moved.
 if (microFocus.bottom() <= visibleArea.top()) {
-// It goes to the upper part of the visible area.
+// First see what would happen if we returned the container to original position.
-mContainerMovementVector = QPointF(0.0, HbCursorLineMargin - microFocus.top());
+// Is the cursor visible then?
+// This is always preferred, use it if possible.
+QPointF toOriginalPos = mOriginalContainerPosition - mContainerWidget->pos();
+QRectF translatedMicroFocus = microFocus.translated(toOriginalPos);
+if (visibleArea.contains(translatedMicroFocus)) {
+mContainerMovementVector = toOriginalPos;
+} else {
+// It goes to the upper part of the visible area.
+mContainerMovementVector = QPointF(0.0, HbCursorLineMargin - microFocus.top());
+}
 } else {
 mContainerMovementVector = QPointF(0.0, visibleArea.bottom() - HbCursorLineMargin - microFocus.bottom());
 }
 return true;
 bool HbAbstractVkbHostPrivate::prepareAnimations(HbVkbHost::HbVkbStatus status)
 {
 prepareAnimationsCommon();
-return (prepareContainerAnimation(status) |
+bool containerResult = prepareContainerAnimation(status);
-prepareKeypadAnimation(status));
+if (containerResult) {
+// A sanity check. Container should never be moved below it's original
+// position. Limit the movement in case editor's micro focus returned faulty value
+// or something else bad happened.
+if ((mContainerMovementStartingPoint + mContainerMovementVector).y() > mOriginalContainerPosition.y()) {
+mContainerMovementVector.setY(mOriginalContainerPosition.y() - mContainerMovementStartingPoint.y());
+qWarning("Abstract VKB host: Invalid container position.");
+}
+}
+return (containerResult | prepareKeypadAnimation(status));
 }
 void HbAbstractVkbHostPrivate::connectSignals()
 {
 if (mContainerWidget) {
 q_ptr->disconnect(popup, SIGNAL(aboutToHide()), q_ptr, SLOT(containerAboutToClose()));
 }
 }
 void HbAbstractVkbHostPrivate::openKeypad()
 {
 if (mContainerWidget) {
 HbMainWindow* mainWin = mainWindow();
 if (mainWin && mKeypad) {
 if (mKeypad->scene() != mainWin->scene()) {
 // Add keypad to scene if it is not already in there.
 if (mKeypadStatus != HbVkbHost::HbVkbStatusOpened) {
 mCallback->aboutToOpen(q_ptr);
 q_ptr->resizeKeyboard(); // Make sure that the keyboard doesn't exceed given boundaries.
 }
 if (prepareAnimations(HbVkbHost::HbVkbStatusOpened)) {
 if (!disableCursorShift()) {
 // Move the container widget to keep the focused line visible.
 mContainerWidget->setPos(mContainerWidget->pos() + mContainerMovementVector);
 // Move the keypad
 mKeypad->setPos(mKeypadMovementStartingPoint + mKeypadMovementVector);
 }
 mKeypadStatus = HbVkbHost::HbVkbStatusOpened;
+mCallback->keyboardOpened(q_ptr);
 q_ptr->openFinished();
 }
 }
 }
 // Add item to scene if it is not already in there.
 mainWin->scene()->addItem(mKeypad);
 }
 if (mKeypadStatus != HbVkbHost::HbVkbStatusMinimized) {
 mCallback->aboutToOpen(q_ptr);
 q_ptr->resizeKeyboard(); // Make sure that the keyboard doesn't exceed given boundaries.
 }
 if (prepareAnimations(HbVkbHost::HbVkbStatusMinimized)) {
 if (!disableCursorShift()) {
 mContainerWidget->setPos(mOriginalContainerPosition);
 }
 // Hide the keypad
 mKeypad->hide();
+mCallback->keyboardClosed(q_ptr);
 mCallback = 0;
 }
 }
 void HbAbstractVkbHostPrivate::minimizeKeypadWithoutAnimation()
 {
 HbMainWindow *mainWin = mainWindow();
 if (mKeypadStatus != HbVkbHost::HbVkbStatusMinimized && mKeypad && mainWin) {
 mCallback->aboutToClose(q_ptr);
 if (mKeypad->scene() != mainWin->scene()) {
 // Add item to scene if it is not already in there.
 mainWin->scene()->addItem(mKeypad);
 }
+mKeypadStatus = HbVkbHost::HbVkbStatusMinimized;
 if (!disableCursorShift()) {
 // Return the container widget to original position.
 mContainerWidget->setPos(mOriginalContainerPosition);
 // Set the keypad to minimized position.
 mKeypad->setPos(QPointF(0.0, mScreenSize.height() - mCallback->minimizedKeyboardSize().height()));
 }
-mKeypadStatus = HbVkbHost::HbVkbStatusMinimized;
 }
 }
 void HbAbstractVkbHostPrivate::cancelAnimationAndHideVkbWidget()
 {
 }
 // Clear possible pending call.
 mPendingCall.vkb = 0;
+emit q_ptr->keypadClosed();
+HbVkbHostBridge::instance()->connectHost(0);
 mKeypadStatus = HbVkbHost::HbVkbStatusClosed;
 }
 }
 HbMainWindow *HbAbstractVkbHostPrivate::mainWindow() const
 }
 /*!
 \reimp
 */
 void HbAbstractVkbHost::openKeypad(HbVirtualKeyboard *vkb, HbInputMethod* owner, bool animationAllowed)
 {
 Q_D(HbAbstractVkbHost);
 if (owner) {
 // all the needed parameters. Null parameters are ok only if minimized
 // keypad is reopened.
 return;
 }
-if (d->mTimeLine.state() == QTimeLine::Running) {
+if (!HbVkbHostBridge::instance()->connectHost(this)) {
+connect(HbVkbHostBridge::instance(), SIGNAL(stateTransitionCompleted()), this, SLOT(stateTransitionCompleted()));
 // The previous keyboard is still closing. Set the call pending and return.
 d->mPendingCall.vkb = vkb;
 d->mPendingCall.animationAllowed = animationAllowed;
 return;
 }
 // Keyboard widget creation failed for some reason, can't go on.
 d->mCallback = 0;
 return;
 }
+emit aboutToOpen();
 if (animationAllowed) {
 d->openKeypad();
 } else {
 d->openKeypadWithoutAnimation();
+emit keypadOpened();
 }
 d->connectSignals();
 d->mKeypadOperationOngoing = false;
 }
 {
 Q_D(HbAbstractVkbHost);
 if (d->mKeypadStatus != HbVkbStatusClosed && !d->mKeypadOperationOngoing) {
 d->mKeypadOperationOngoing = true;
+emit aboutToClose();
 if (animationAllowed) {
 d->closeKeypad();
 } else {
 d->closeKeypadWithoutAnimation();
+emit keypadClosed();
+HbVkbHostBridge::instance()->connectHost(0);
 }
 d->disconnectSignals();
 d->mKeypadOperationOngoing = false;
 }
 if (d->mContainerWidget && d->mKeypad && d->mCallback && d->mInputMethod) {
 if (!d->disableCursorShift()) {
 // Make sure the container reached target position.
 d->mContainerWidget->setPos(d->mContainerMovementStartingPoint + d->mContainerMovementVector);
 // Make sure the keypad reached target position.
 d->mKeypad->setPos(d->mKeypadMovementStartingPoint + d->mKeypadMovementVector);
 }
 // Notify
 emit keypadOpened();
 } else if (d->mKeypadStatus == HbVkbHost::HbVkbStatusMinimized) {
 d->mCallback->keyboardMinimized(this);
 emit keypadClosed();
 } else {
-// It was closed.
+// It was closed. Hide the keyboard.
 d->mKeypad->hide();
+// Return the container where it was.
+d->mContainerWidget->setPos(d->mOriginalContainerPosition);
 d->mCallback->keyboardClosed(this);
 emit keypadClosed();
+HbVkbHostBridge::instance()->connectHost(0);
-if (d->mPendingCall.vkb) {
-// There was an open call pending. Do it now.
-HbVirtualKeyboard *vkb = d->mPendingCall.vkb;
-d->mPendingCall.vkb = 0;
-openKeypad(vkb, d->mInputMethod, d->mPendingCall.animationAllowed);
-}
 }
 }
 }
 /*!
 void HbAbstractVkbHost::currentViewChanged(HbView *view)
 {
 Q_D(HbAbstractVkbHost);
 if (view != d->mContainerWidget) {
 if (d->mTimeLine.state() == QTimeLine::Running) {
 d->cancelAnimationAndHideVkbWidget();
 if (d->mCallback) {
 d->mCallback->keyboardClosed(this);
 }
-emit keypadClosed();
 } else if (d->mKeypadStatus != HbVkbStatusClosed) {
 d->closeKeypadWithoutAnimation();
 }
 }
 }
 d->mTimeLine.start();
 }
 }
 }
+/*!
+\reimp
+*/
+bool HbAbstractVkbHost::stateTransitionOngoing() const
+{
+Q_D(const HbAbstractVkbHost);
+return (d->mTimeLine.state() == QTimeLine::Running);
+}
+/*!
+Receives signal from HbVkbHostBridge when previous host completes its state
+transition and sens pending call if any.
+*/
+void HbAbstractVkbHost::stateTransitionCompleted()
+{
+Q_D(HbAbstractVkbHost);
+disconnect(HbVkbHostBridge::instance(), SIGNAL(stateTransitionCompleted()), this, SLOT(stateTransitionCompleted()));
+if (d->mPendingCall.vkb) {
+// There was an open call pending. Do it now.
+HbVirtualKeyboard *vkb = d->mPendingCall.vkb;
+d->mPendingCall.vkb = 0;
+openKeypad(vkb, d->mInputMethod, d->mPendingCall.animationAllowed);
+}
+}
 // End of file

changeset 1	f7ac710697a9
parent 0	16d8024aca5e
child 2	06ff229162e9