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

equal deleted inserted replaced

-:923ff622b8b9
+:4633027730f5
 #include "hbinstance.h"
 #include <QTextEdit>
 const int HbAnimationTime = 200;
-const qreal HbEditorExtraMargin = 5.0;
+const qreal HbEditorExtraMargin = 17.0;
-const qreal HbCursorLineMargin = 15.0;
+const qreal HbCursorLineMargin = 5.0;
 const qreal HbContainerBorderMargin = 20.0;
 const qreal HbHeightVerticalFactor = 0.5;
 const qreal HbHeightHorizFactor = 0.7;
+//Marginal value of the keypad height
+const qreal HbHeightMarginFactor = 0.6;
+const qreal HbDeltaHeight = 3.0;
 const QString KHandWritingName("Handwriting");
 // see hbpopup.cpp for this
 extern const char* KPositionManagedByVKB;
 /// @cond
 mContainerMovementStartingPoint(QPointF(0, 0)),
 mContainerMovementVector(QPointF(0, 0)),
 mKeypadMovementStartingPoint(QPointF(0, 0)),
 mKeypadMovementVector(QPointF(0, 0)),
 mInputMethod(0),
-mKeypadStatusBeforeOrientationChange(HbVkbHost::HbVkbStatusClosed)
+mKeypadStatusBeforeOrientationChange(HbVkbHost::HbVkbStatusClosed),
+mTitleBarHiddenByVkbHost(false),
+mStatusBarHiddenByVkbHost(false)
 {
 mTimeLine.setUpdateInterval(16);
 }
 HbAbstractVkbHostPrivate::~HbAbstractVkbHostPrivate()
 }
 if (status == HbVkbHost::HbVkbStatusOpened) {
 // Calculate the area that remains visible when the keypad is open.
 QRectF visibleArea = QRectF(0.0, 0.0, mScreenSize.width(), mScreenSize.height() - mKeypad->size().height());
+// adjust the container position such that the focused object is always visible. This is required in some cases
+// where the actual visible area is very less when the keypad is opened. The cotainer position is automatically adjusted when
+// the keypad height to screen height ratio exceeds the marginal height value HbHeightMarginFactor. By doing this, we can make
+// sure that some space available for displaying popups like exactword popup in some input methods
+bool adjustContainer = (q_ptr->confirmedKeyboardSize().height() >
+(mScreenSize.height() * HbHeightMarginFactor))? true : false;
 // Find out the container area.
 QRectF containerArea = mContainerWidget->sceneBoundingRect();
 containerArea.adjust(0.0, -HbContainerBorderMargin, 0.0, HbContainerBorderMargin);
+HbMainWindow *mainWin = mainWindow();
+HbView *currentView = mainWin ? mainWin->currentView() : 0;
+if (!currentView) {
+return false;
+}
+// check whether the title and status bars are hidden or not
+bool isTitleOrStatusBarVisible = currentView->isItemVisible(
+Hb::TitleBarItem) | currentView->isItemVisible(Hb::StatusBarItem);
+// move the container up when hiding the title and status bars
+if (isTitleOrStatusBarVisible) {
+mContainerMovementVector.setY(visibleArea.top() - currentView->sceneBoundingRect().top());
+}
 if (visibleArea.contains(containerArea)) {
 // The whole container is already inside the visible area, nothing to do.
 return false;
 }
+// If it isn't in the visible area yet but fits there. Let's move it there.
 if (visibleArea.height() >= containerArea.height()) {
-// It isn't in the visible area yet but fits there. Let's move it there.
+// calculate the new container area after hiding the bars
-mContainerMovementVector = QPointF(0.0, visibleArea.bottom() - containerArea.bottom());
+containerArea.translate(mContainerMovementVector);
+if (adjustContainer) {
+adjustContainerPosition();
+} else {
+mContainerMovementVector += QPointF(0.0, visibleArea.bottom() - containerArea.bottom());
+}
 return true;
 }
 // Find out the editor bounding box and add a small margin to height.
 QRectF editorGeometry = mInputMethod->focusObject()->editorGeometry();
 editorGeometry.adjust(0.0, -HbCursorLineMargin, 0.0, HbCursorLineMargin);
+// calculate the new editor position after hiding the title bars
+editorGeometry.translate(mContainerMovementVector);
 // Then see if the editor is already inside the visible area.
 // If it isn't, see if it would fit there.
 if (!visibleArea.contains(editorGeometry)) {
 if (editorGeometry.width() <= visibleArea.width() &&
 editorGeometry.height() <= visibleArea.height()) {
+// first check whether the microfocus rectangle is inside the visible area. In case of
+// text or multiline editors, dont change the editor position if cursor is in visible area
+if (adjustContainer) {
+if (adjustContainerPosition()) {
+return true;
+}
+}
 // Yes, it fits into visible area, let's move it there so that
 // the whole editor area is in use right away.
 // First check if we want to move it to upper or lower
 // part of the visible area.
 if (editorGeometry.top() <= visibleArea.top()) {
 // It goes to the upper part of the visible area.
-mContainerMovementVector = QPointF(0.0, -editorGeometry.top());
+mContainerMovementVector += QPointF(0.0, -editorGeometry.top());
 } else {
-mContainerMovementVector = QPointF(0.0, visibleArea.bottom() - editorGeometry.bottom());
+mContainerMovementVector += QPointF(0.0, visibleArea.bottom() - editorGeometry.bottom());
 }
 return true;
 }
 }
 // The editor is either already inside the visible area or doesn't fit there.
 // First find out micro focus rectangle and increase the height by a small margin.
 QRectF microFocus = mInputMethod->focusObject()->microFocus();
 microFocus.setTop(microFocus.top() - HbEditorExtraMargin);
 microFocus.setBottom(microFocus.bottom() + HbEditorExtraMargin);
+// calculate the new cursor position after hiding the title bars
+microFocus.translate(mContainerMovementVector);
 // Check whether the cursor rectangle is inside visible area.
 if (!visibleArea.contains(microFocus)) {
 QRectF realEditorGeometry = editorGeometry;
 realEditorGeometry.adjust(0.0, HbCursorLineMargin, 0.0, -HbCursorLineMargin);
 if (!realEditorGeometry.contains(microFocus)) {
 // 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;
+mContainerMovementVector += toOriginalPos;
 } else {
 // It goes to the upper part of the visible area.
-mContainerMovementVector = QPointF(0.0, HbCursorLineMargin - microFocus.top());
+mContainerMovementVector += QPointF(0.0, visibleArea.top() - microFocus.top());
 }
 } else {
-mContainerMovementVector = QPointF(0.0, visibleArea.bottom() - HbCursorLineMargin - microFocus.bottom());
+mContainerMovementVector += QPointF(0.0, visibleArea.bottom() - microFocus.bottom());
 }
 return true;
 }
+if (adjustContainer && adjustContainerPosition()) {
+return true;
+		}
 } else {
 // It is going to be closed or minimized.
 mContainerMovementVector = mOriginalContainerPosition - mContainerMovementStartingPoint;
 return true;
 }
 mCallback->aboutToOpen(q_ptr);
 q_ptr->resizeKeyboard(); // Make sure that the keyboard doesn't exceed given boundaries.
 }
 if (prepareAnimations(HbVkbHost::HbVkbStatusOpened)) {
+// hide the title bar and status bar when opening the vkb
+setTitleAndStatusBarVisible(false);
 // Run the animation
 mKeypadStatus = HbVkbHost::HbVkbStatusOpened;
 mTimeLine.start();
 }
 }
 if (mKeypadStatus != HbVkbHost::HbVkbStatusClosed) {
 mCallback->aboutToClose(q_ptr);
 if (prepareAnimations(HbVkbHost::HbVkbStatusClosed)) {
+// show the title bar and status bar when closing the vkb
+setTitleAndStatusBarVisible(true);
 mKeypadStatus = HbVkbHost::HbVkbStatusClosed;
 mTimeLine.start();
 }
 }
 }
 {
 if (mCallback && mKeypadStatus != HbVkbHost::HbVkbStatusMinimized) {
 mCallback->aboutToClose(q_ptr);
 if (mContainerWidget->widgetObject()) {
 if (prepareAnimations(HbVkbHost::HbVkbStatusMinimized)) {
+//show the title bar and status bar when minimizing the vkb
+setTitleAndStatusBarVisible(true);
 mKeypadStatus = HbVkbHost::HbVkbStatusMinimized;
 mTimeLine.start();
 }
 }
 }
 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)) {
+// hide the title bar and status bar when opening the vkb
+setTitleAndStatusBarVisible(false);
 if (!disableCursorShift()) {
 // Move the container widget to keep the focused line visible.
 mContainerWidget->setPos(mContainerWidget->pos() + mContainerMovementVector);
 // Move the keypad
 void HbAbstractVkbHostPrivate::closeKeypadWithoutAnimation()
 {
 if (mKeypadStatus != HbVkbHost::HbVkbStatusClosed && mKeypad) {
 mCallback->aboutToClose(q_ptr);
+// show the title bar and status bar when closing the vkb
+setTitleAndStatusBarVisible(true);
 // Set original content widget position
 mKeypadStatus = HbVkbHost::HbVkbStatusClosed;
 if (!disableCursorShift()) {
 // Return the container widget to original position.
 mCallback->aboutToClose(q_ptr);
 if (mKeypad->scene() != mainWin->scene()) {
 // Add item to scene if it is not already in there.
 mainWin->scene()->addItem(mKeypad);
 }
+// show the title bar and status bar when minimizing the vkb
+setTitleAndStatusBarVisible(true);
 mKeypadStatus = HbVkbHost::HbVkbStatusMinimized;
 if (!disableCursorShift()) {
 // Return the container widget to original position.
 mContainerWidget->setPos(mOriginalContainerPosition);
 if (mainWindow() && mainWindow()->orientation() == Qt::Horizontal && imName == KHandWritingName) {
 return true;
 }
 return false;
 }
+void HbAbstractVkbHostPrivate::setTitleAndStatusBarVisible(bool visible)
+{
+HbMainWindow *mainWin = mainWindow();
+HbView *currentView;
+if (mainWin && (currentView = mainWin->currentView())) {
+HbView::HbViewFlags flags = currentView->viewFlags();
+HbView::HbViewFlags setFlags = HbView::ViewFlagNone;
+if (!visible) {
+if (!(flags & HbView::ViewTitleBarHidden)) {
+setFlags |= HbView::ViewTitleBarHidden;
+mTitleBarHiddenByVkbHost = true;
+}
+if (!(flags & HbView::ViewStatusBarHidden)) {
+setFlags |= HbView::ViewStatusBarHidden;
+mStatusBarHiddenByVkbHost = true;
+}
+if (mTitleBarHiddenByVkbHost || mStatusBarHiddenByVkbHost) {
+setFlags |= HbView::ViewDisableRelayout;
+}
+currentView->setViewFlags(flags | setFlags);
+} else {
+if ((flags & HbView::ViewDisableRelayout) && (mTitleBarHiddenByVkbHost ||
+mStatusBarHiddenByVkbHost)) {
+setFlags |= HbView::ViewDisableRelayout;
+}
+if ((flags & HbView::ViewTitleBarHidden) && mTitleBarHiddenByVkbHost) {
+setFlags |= HbView::ViewTitleBarHidden;
+mTitleBarHiddenByVkbHost = false;
+}
+if ((flags & HbView::ViewStatusBarHidden) && mStatusBarHiddenByVkbHost) {
+setFlags |= HbView::ViewStatusBarHidden;
+mStatusBarHiddenByVkbHost = false;
+}
+currentView->setViewFlags(flags & ~setFlags);
+}
+}
+}
+bool HbAbstractVkbHostPrivate::adjustContainerPosition()
+{
+bool result = false;
+if (!mInputMethod || !mInputMethod->focusObject()) {
+return result;
+}
+// Calculate the area that remains visible when the keypad is open.
+QRectF visibleArea = QRectF(0.0, 0.0, mScreenSize.width(), mScreenSize.height() - mKeypad->size().height());
+QRectF microFocus = mInputMethod->focusObject()->microFocus();
+microFocus.adjust(0.0, -HbEditorExtraMargin, 0.0, HbEditorExtraMargin);
+// calculate the new cursor position after moving it to the visible area
+QRectF newCursorRect = microFocus.translated(mContainerMovementVector);
+if (visibleArea.contains(newCursorRect)) {
+qreal topArea = newCursorRect.top() - visibleArea.top() - HbDeltaHeight;
+qreal bottomArea = visibleArea.bottom() - newCursorRect.bottom() - HbDeltaHeight;
+if (topArea > 0 && bottomArea > 0) {
+if (topArea >= bottomArea) {
+mContainerMovementVector += QPointF(0.0, bottomArea);
+} else {
+mContainerMovementVector += QPointF(0.0, -topArea);
+}
+}
+result = true;
+}
+return result;
+}
 /// @endcond
 HbAbstractVkbHost::HbAbstractVkbHost(HbWidget *containerWidget) : d_ptr(new HbAbstractVkbHostPrivate(this, containerWidget))
 return QRectF();
 }
 /*!
-\reimp
+\deprecated HbAbstractVkbHost::minimizeKeypad(bool)
+is deprecated.
 */
 void HbAbstractVkbHost::minimizeKeypad(bool animationAllowed)
 {
 Q_D(HbAbstractVkbHost);
 if (d->mKeypadStatus != HbVkbStatusClosed && !d->mKeypadOperationOngoing) {
 d->mKeypadOperationOngoing = false;
 }
 }
 /*!
-\reimp
+\deprecated HbAbstractVkbHost::openMinimizedKeypad(HbVirtualKeyboard*, HbInputMethod*)
+is deprecated.
 */
 void HbAbstractVkbHost::openMinimizedKeypad(HbVirtualKeyboard *vkb, HbInputMethod *owner)
 {
 Q_D(HbAbstractVkbHost);
 d->mInputMethod = owner;

changeset 21	4633027730f5
parent 6	c3690ec91ef8
child 23	e6ad4ef83b23