1 /****************************************************************************

     2 **

     3 ** Copyright (C) 2008-2010 Nokia Corporation and/or its subsidiary(-ies).

     4 ** All rights reserved.

     5 ** Contact: Nokia Corporation (developer.feedback@nokia.com)

     6 **

     7 ** This file is part of the HbInput module of the UI Extensions for Mobile.

     8 **

     9 ** GNU Lesser General Public License Usage

    10 ** This file may be used under the terms of the GNU Lesser General Public

    11 ** License version 2.1 as published by the Free Software Foundation and

    12 ** appearing in the file LICENSE.LGPL included in the packaging of this file.

    13 ** Please review the following information to ensure the GNU Lesser General

    14 ** Public License version 2.1 requirements will be met:

    15 ** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

    16 **

    17 ** In addition, as a special exception, Nokia gives you certain additional

    18 ** rights.  These rights are described in the Nokia Qt LGPL Exception

    19 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

    20 **

    21 ** If you have questions regarding the use of this file, please contact

    22 ** Nokia at developer.feedback@nokia.com.

    23 **

    24 ****************************************************************************/

    25 #include <QPixmap>

    26 #include <QBitmap>

    27 #include <QPainter>

    28 #include <QGraphicsItemAnimation>

    29 #include <QGraphicsSceneMouseEvent>

    30 #include <QGraphicsProxyWidget>

    31 #include <QTimeLine>

    32 #include <QGraphicsGridLayout>

    33 #include <QGraphicsScene>

    34 #include <QGraphicsLinearLayout>

    35 

    36 #include <hbapplication.h>

    37 #include <hbmainwindow.h>

    38 #include <hbaction.h>

    39 #include <hbview.h>

    40 #include <hbwidget.h>

    41 #include <hbpushbutton.h>

    42 #include <hbinputsettingproxy.h>

    43 #include <hbdialog.h>

    44 #include <hbeffect.h>

    45 #include <hbstackedwidget.h>

    46 #include <hbframedrawer.h>

    47 #include <hbevent.h>

    48 

    49 #include <hbinputmethod.h>

    50 #include <hbinputsettingproxy.h>

    51 #include <hbinpututils.h>

    52 #include <hbinputdef.h>

    53 #include <hbinputvkbhost.h>

    54 #include <hbinputsettingdialog.h>

    55 #include <hbinputcommondialogs.h>

    56 #include <hbinputkeymap.h>

    57 #include <hbinputkeymapfactory.h>

    58 #include <hbwidgetfeedback.h>

    59 #include <hbsmileyengine.h>

    60 #include <hbinputpredictionfactory.h>

    61 

    62 #include "hbinputvirtualrocker.h"

    63 #include "hbinputvkbwidget.h"

    64 #include "hbinputvkbwidget_p.h"

    65 #include "hbinputtouchkeypadbutton.h"

    66 #include "hbinputsettinglist.h"

    67 #include "hbinputmodeindicator.h"

    68 #include <hbfeedbackmanager.h>

    69 #include "hbinputsmileypicker.h"

    70 #include "hbinputscreenshotwidget.h"

    71 const qreal HbMouseDragDelta = 0.4;

    72 const qreal HbRockerWidth = 50.0;

    73 

    74 const int MaxSweepTime = 500;

    75 const int SweepLength = 150;

    76 

    77 

    78 /*!

    79 @proto

    80 @hbinput

    81 \class HbInputVkbWidget

    82 \brief A base class for touch keypads.

    83 

    84 This class implements default mechanisms for opening and closing touch keypads.

    85 It know how to operate in landscape and in portait modes and it know how

    86 implement split view -mechasnism for S60 QT UI's Hb library. It also implements

    87 closing mechansim, where used is able to close the touch keypad by sliding it downwards

    88 with a finger. This class also implements background drawing for touch keypads.

    89 */

    90 

    91 /// @cond

    92 

    93 inline HbWidget* hbwidget_cast(QGraphicsItem *item)

    94 {

    95     if( item->isWidget() && static_cast<QGraphicsWidget*>(item)->inherits("HbWidget") ) {

    96         return static_cast<HbWidget*>(item);

    97     }

    98     return 0;

    99 }

   100 

   101 HbInputVkbWidgetPrivate::HbInputVkbWidgetPrivate()

   102 : mOwner(0),

   103 mMode(EModeAbc),

   104 mKeymap(0),

   105 mModifiers(0),

   106 mInputModeIndicator(0),

   107 mApplicationButton(0),

   108 mSettingsButton(0),

   109 mSettingList(0),

   110 mButtonLayout(0),

   111 mRocker(0),

   112 mBackgroundDrawer(0),

   113 mIconDrawer(0),

   114 mMainWinConnected(false),

   115 mShowRocker(false),

   116 mLayout(0),

   117 mCurrentHost(0),

   118 mDrawbackground(true),

   119 mMouseButtonPressedDown(false),

   120 mFlickDirection(HbInputVkbWidget::HbFlickDirectionNone),

   121 mSmileyPicker(0),

   122 mScreenshotWidget(0),

   123 mScreenshotTimeLine(250),

   124 mMostRecentlyAccessedButton(0),

   125 mMostRecentlyClickedLocation(0.0,0.0),

   126 mFocusedObject(0),

   127 mFlickAnimation(false),

   128 mSettingsListOpen(false),

   129 mAnimateWhenDialogCloses(false),

   130 mKeyboardSize(HbQwerty4x10),

   131 mCloseHandleHeight(0),

   132 mCloseHandle(NULL),

   133 mKeyboardDimmed(false)

   134 {

   135 }

   136 

   137 

   138 HbInputVkbWidgetPrivate::~HbInputVkbWidgetPrivate()

   139 {

   140     delete mSettingList;

   141     delete mBackgroundDrawer;

   142     delete mIconDrawer;

   143     delete mSmileyPicker;

   144     delete mScreenshotWidget;

   145 }

   146 

   147 void HbInputVkbWidgetPrivate::init()

   148 {

   149     Q_Q(HbInputVkbWidget);

   150 

   151     mRocker = new HbInputVirtualRocker(q);

   152     mRocker->setObjectName("VirtualRocker");

   153     QSizeF rockerSize(HbRockerWidth, HbRockerWidth);

   154     mRocker->resize(rockerSize);

   155     mRocker->setMinimumSize(HbRockerWidth, HbRockerWidth);

   156     mRocker->setMaximumSize(HbRockerWidth*20, HbRockerWidth*20);

   157 

   158     QObject::connect(mRocker, SIGNAL(rockerDirection(int, HbInputVirtualRocker::RockerSelectionMode)),

   159         q, SIGNAL(rockerDirection(int, HbInputVirtualRocker::RockerSelectionMode)));

   160 

   161     mRocker->setVisible(false);

   162 

   163     mBackgroundDrawer = new HbFrameDrawer();

   164     mBackgroundDrawer->setFrameGraphicsName(backgroundGraphics);

   165     mBackgroundDrawer->setFrameType(HbFrameDrawer::ThreePiecesVertical);

   166     mBackgroundDrawer->setFillWholeRect(true);

   167     mBackgroundDrawer->setBorderWidths(0.0, HbCloseHandleHeight, 0.0, HbCloseHandleHeight);

   168 

   169     mIconDrawer = new HbFrameDrawer();

   170     mIconDrawer->setFrameType(HbFrameDrawer::OnePiece);

   171     mIconDrawer->setFrameGraphicsName(HbInputVkbHandleIcon);

   172 

   173     mReleaseMapper = new QSignalMapper(q);

   174     mPressMapper = new QSignalMapper(q);

   175     mActionMapper = new QSignalMapper(q);

   176 }

   177 

   178 // re-implemented by inherited keyboards

   179 int HbInputVkbWidgetPrivate::keyCode(int buttonId)

   180 {

   181     Q_UNUSED(buttonId);

   182     return -1;

   183 }

   184 

   185 // re-implemented by inherited keyboards

   186 int HbInputVkbWidgetPrivate::keyCode(HbTouchKeypadButton *button)

   187 {

   188     Q_UNUSED(button);

   189     return -1;

   190 }

   191 

   192 void HbInputVkbWidgetPrivate::handleStandardButtonPress(int buttonid)

   193 {

   194     int keycode = buttonid;

   195     if (buttonid >= 0) {

   196         keycode = keyCode(buttonid);

   197     }

   198 

   199     QKeyEvent event(QEvent::KeyPress, keycode, Qt::NoModifier);

   200     if (mOwner) {

   201         mOwner->filterEvent(&event);

   202     }

   203 }

   204 

   205 void HbInputVkbWidgetPrivate::handleStandardButtonRelease(int buttonid)

   206 {

   207     int keycode = buttonid;

   208     if (buttonid >= 0) {

   209         keycode = keyCode(buttonid);

   210     }

   211 

   212     QKeyEvent event(QEvent::KeyRelease, keycode, Qt::NoModifier);

   213     if (mOwner) {

   214         mOwner->filterEvent(&event);

   215     }

   216 }

   217 

   218 void HbInputVkbWidgetPrivate::addCustomButtonToLayout( HbTouchKeypadButton* button,

   219                                                        int index)

   220 {

   221     Q_UNUSED(button);

   222     Q_UNUSED(index);

   223 }

   224 

   225 void HbInputVkbWidgetPrivate::redirectMousePressEvent(QGraphicsSceneMouseEvent *aEvent)

   226 {

   227     q_ptr->mousePressEvent(aEvent);

   228 }

   229 

   230 void HbInputVkbWidgetPrivate::redirectMouseReleaseEvent(QGraphicsSceneMouseEvent *aEvent)

   231 {

   232     q_ptr->mouseReleaseEvent(aEvent);

   233 }

   234 

   235 void HbInputVkbWidgetPrivate::applyEditorConstraints() {

   236     // no default implementaiton as of now.

   237 }

   238 

   239 void HbInputVkbWidgetPrivate::setRockerPosition()

   240 {

   241     Q_Q(HbInputVkbWidget);

   242 

   243     // Set rocker position.

   244     QSizeF padArea = q->keypadButtonAreaSize();

   245     QPointF point((padArea.width() * 0.5) - (mRocker->size().width() * 0.5),

   246         (padArea.height() * 0.5) - (mRocker->size().height() * 0.5));

   247     point.setY(point.y() + mCloseHandleHeight);

   248 

   249     if (q->keypadLayout() && q->keypadLayout()->geometry().height()) {

   250         point.setX(((padArea.width() * 0.5) - (mRocker->size().width() * 0.5)));

   251         point.setY(((q->keypadLayout()->geometry().height() * 0.5) - (mRocker->size().height() * 0.5) + mCloseHandleHeight));

   252     }

   253     mRocker->setPos(point);

   254 }

   255 

   256 void HbInputVkbWidgetPrivate::captureScreenshot()

   257 {

   258     Q_Q(HbInputVkbWidget);

   259 

   260     if (!mScreenshotWidget) {

   261         mScreenshotWidget = new HbInputScreenshotWidget();

   262         mScreenshotWidget->setGeometry(q->geometry());

   263         q->mainWindow()->scene()->addItem(mScreenshotWidget);

   264     }

   265 

   266     QPointF position = q->pos();

   267     QRectF rect = QRectF(position.x(), position.y()+ mCloseHandleHeight, q->boundingRect().width(), q->boundingRect().height()- mCloseHandleHeight);

   268     QTransform rotateTrans;

   269     rotateTrans = q->mainWindow()->viewportTransform();

   270     QRectF transRect = rotateTrans.mapRect(rect);

   271     QPixmap pixmap;

   272     pixmap = QPixmap::grabWidget(q->mainWindow(), (int)transRect.x(), (int)transRect.y(), (int)transRect.width(), (int)transRect.height());

   273     pixmap = pixmap.transformed(rotateTrans.inverted());

   274     mScreenshotWidget->setScreenshot(pixmap);

   275 }

   276 

   277 

   278 void HbInputVkbWidgetPrivate::updateMouseHitItem(HbTouchKeypadButton *button, QPointF position)

   279 {

   280     mMostRecentlyAccessedButton = button;

   281     mMostRecentlyClickedLocation = position;

   282 }

   283 

   284 void HbInputVkbWidgetPrivate::normalizeProbabilities(QList<HbKeyPressProbability> &allProbableKeys)

   285 {

   286     qreal sum = 0.0;

   287     foreach (HbKeyPressProbability key, allProbableKeys) {

   288         sum += key.probability;

   289     }

   290 

   291     for (int count=0;count<allProbableKeys.size();count++) {

   292         allProbableKeys[count].probability = allProbableKeys[count].probability / sum;

   293     }

   294 }

   295 

   296 bool HbInputVkbWidgetPrivate::isKeyboardDimmed()

   297 {

   298     return mKeyboardDimmed;

   299 }

   300 

   301 bool HbInputVkbWidgetPrivate::isSmileysEnabled()

   302 {

   303     bool ret = false;

   304     if (!mOwner || !mOwner->focusObject()) {

   305         return ret;

   306     }

   307     if (mOwner->focusObject()->editorInterface().editor()->inherits("HbAbstractEdit")) {

   308         if (!mOwner->focusObject()->editorInterface().smileyTheme().isNull()) {

   309             ret = true;

   310         }		

   311     }	else {

   312         HbSmileyEngine smileyEngine;

   313         if (!smileyEngine.defaultTheme().isNull()) {

   314             ret = true;

   315         }	

   316     }	

   317     return ret;	

   318 }

   319 /// @endcond

   320 

   321 /*!

   322 Costructs the object.

   323 */

   324 HbInputVkbWidget::HbInputVkbWidget(QGraphicsItem* parent)

   325     : HbWidget(*new HbInputVkbWidgetPrivate, parent)

   326 {

   327     Q_D(HbInputVkbWidget);

   328     d->q_ptr = this;

   329     d->init();

   330 

   331     setFocusPolicy(Qt::ClickFocus);

   332     setPos(QPointF(0,0));

   333 

   334 #ifdef HB_EFFECTS

   335     HbEffect::disable(this);

   336 #endif // HB_EFFECTS

   337 

   338 #if QT_VERSION >= 0x040600

   339     // Make sure the keypad never steals focus.

   340     setFlag(QGraphicsItem::ItemIsPanel, true);

   341     setActive(false);

   342 #endif

   343 }

   344 

   345 /*!

   346 Constructs the object.

   347 */

   348 HbInputVkbWidget::HbInputVkbWidget(HbInputVkbWidgetPrivate& dd, QGraphicsItem* parent)

   349   : HbWidget(dd, parent)

   350 {

   351     Q_D(HbInputVkbWidget);

   352     d->q_ptr = this;

   353     d->init();

   354 

   355     setFocusPolicy(Qt::ClickFocus);

   356     setPos(QPointF(0,0));

   357 

   358 #ifdef HB_EFFECTS

   359     HbEffect::disable(this);

   360 #endif // HB_EFFECTS

   361 

   362 #if QT_VERSION >= 0x040600

   363     // Make sure the keypad never steals focus.

   364     setFlag(QGraphicsItem::ItemIsPanel, true);

   365     setActive(false);

   366 #endif

   367 }

   368 

   369 /*!

   370 Destructs the object.

   371 */

   372 HbInputVkbWidget::~HbInputVkbWidget()

   373 {

   374 }

   375 

   376 /*!

   377 Vkb host calls this handler when the keypad open animation finishes.

   378 */

   379 void HbInputVkbWidget::keyboardOpened(HbVkbHost *host)

   380 {

   381     Q_D(HbInputVkbWidget);

   382 

   383     d->mCurrentHost = host;

   384     d->mRocker->setVisible(d->mShowRocker);

   385     d->setRockerPosition();

   386 }

   387 

   388 /*!

   389 Vkb host calls this handler when the keyboard close animation has finished.

   390 

   391 \sa HbVkbHost

   392 */

   393 void HbInputVkbWidget::keyboardClosed(HbVkbHost *host)

   394 {

   395     Q_UNUSED(host);

   396     Q_D(HbInputVkbWidget);

   397 

   398     d->mRocker->setVisible(false);

   399 }

   400 

   401 /*!

   402 Vkb host calls this handler when the keyboard minimize animation has finished.

   403 

   404 \sa HbVkbHost

   405 */

   406 void HbInputVkbWidget::keyboardMinimized(HbVkbHost *host)

   407 {

   408     Q_UNUSED(host);

   409 }

   410 

   411 /*!

   412 handles mouse press event.

   413 */

   414 void HbInputVkbWidget::mousePressEvent(QGraphicsSceneMouseEvent* event)

   415 {

   416     Q_D(HbInputVkbWidget);

   417     Q_UNUSED(event);

   418     if (!d->mMouseButtonPressedDown) {

   419         d->mMouseButtonPressedDown = true;

   420         d->mMousePressTime.start();

   421     }

   422 }

   423 

   424 /*!

   425 Handles mouse release event.

   426 */

   427 void HbInputVkbWidget::mouseReleaseEvent(QGraphicsSceneMouseEvent* event)

   428 {

   429     Q_D(HbInputVkbWidget);

   430     d->mFlickDirection = HbFlickDirectionNone;

   431     d->mMouseButtonPressedDown = false;

   432 

   433     QPointF mouseDownpoint = event->buttonDownScenePos(Qt::LeftButton);

   434 

   435     if (d->mCurrentHost && d->mCurrentHost->keypadStatus() != HbVkbHost::HbVkbStatusOpened &&

   436         d->mCurrentHost->activeKeypad() && d->mOwner) {

   437         HbWidgetFeedback::triggered(this, Hb::InstantFlicked);

   438         d->mCurrentHost->openKeypad(d->mCurrentHost->activeKeypad(), d->mOwner);

   439     } else if (d->mMousePressTime.elapsed() < MaxSweepTime || mouseDownpoint.y() <= scenePos().y() + d->mCloseHandleHeight) {

   440         QPointF delta = event->scenePos() - mouseDownpoint;

   441 

   442         qreal height;

   443         if (HbInputSettingProxy::instance()->screenOrientation() == Qt::Horizontal) {

   444             height = geometry().height() * 0.5;

   445         } else {

   446             // For ITU-T, 40% of the scene height is considered.

   447             height = 0.4 * geometry().height();

   448         }

   449         // If the user drags the mouse on keypad and the

   450         // delta is greater than 10% of the height, keypad is closed

   451         height = HbMouseDragDelta * height;

   452 

   453         if (delta.y() > height) {

   454             HbWidgetFeedback::triggered(this, Hb::InstantFlicked);

   455             d->mFlickDirection = HbFlickDirectionDown;

   456             emit keypadCloseEventDetected(HbVkbCloseMethodButtonDrag);

   457         }

   458 

   459         if (qAbs(delta.x()) > SweepLength) {

   460 

   461             d->mFlickDirection = delta.x()>0 ? HbFlickDirectionRight : HbFlickDirectionLeft;

   462 

   463             if (d->mFlickAnimation){

   464                 HbWidgetFeedback::triggered(this, Hb::InstantFlicked);

   465                 animKeyboardChange();

   466             }

   467             emit flickEvent(d->mFlickDirection);

   468         }

   469     }

   470 }

   471 

   472 /*!

   473 Handles virtual key press

   474 */

   475 void HbInputVkbWidget::mappedKeyPress(int buttonid)

   476 {

   477     Q_D(HbInputVkbWidget);

   478     d->handleStandardButtonPress(buttonid);

   479 }

   480 

   481 /*!

   482 Handles virtual key release

   483 */

   484 void HbInputVkbWidget::mappedKeyRelease(int buttonid)

   485 {

   486     Q_D(HbInputVkbWidget);

   487     d->handleStandardButtonRelease(buttonid);

   488 }

   489 

   490 

   491 /*!

   492 The paint method. Draws the widget.

   493 */

   494 void HbInputVkbWidget::paint(QPainter* painter, const QStyleOptionGraphicsItem* option, QWidget* widget)

   495 {

   496     Q_UNUSED(option);

   497     Q_UNUSED(widget);

   498 

   499     Q_D(HbInputVkbWidget);

   500 

   501     QRectF rect = boundingRect();

   502     if (d->mDrawbackground) {

   503         d->mBackgroundDrawer->paint(painter, rect);

   504     }

   505 

   506     rect.setLeft(rect.width()/2 - d->mCloseHandleHeight*3);

   507     rect.setWidth(d->mCloseHandleHeight*6);

   508     rect.setHeight(d->mCloseHandleHeight);

   509     d->mIconDrawer->paint(painter, rect);

   510 }

   511 

   512 /*!

   513 Sets virtual rocker visibility.

   514 */

   515 void HbInputVkbWidget::setRockerVisible(bool visible)

   516 {

   517     Q_D(HbInputVkbWidget);

   518     d->mShowRocker = visible;

   519 }

   520 

   521 /*!

   522 Returns true if virtual rocker is allowed to be visible.

   523 */

   524 bool HbInputVkbWidget::isRockerVisible() const

   525 {

   526     Q_D(const HbInputVkbWidget);

   527     if (d->mShowRocker) {

   528         return d->mRocker->isVisible();

   529     } else {

   530         return false;

   531     }

   532 }

   533 

   534 /*!

   535 Returns active keypad mode. Possible values are EModeAbc, EModeNumeric and EModeSct.

   536 */

   537 HbKeypadMode HbInputVkbWidget::mode() const

   538 {

   539     Q_D(const HbInputVkbWidget);

   540     return d->mMode;

   541 }

   542 

   543 /*!

   544 Returns active keypad modifiers.

   545 */

   546 HbModifiers HbInputVkbWidget::modifiers() const

   547 {

   548     Q_D(const HbInputVkbWidget);

   549     return d->mModifiers;

   550 }

   551 

   552 /*!

   553 Sets the keypad to given mode. Possible values are EModeAbc, EModeNumeric and EModeSct.

   554 */

   555 void HbInputVkbWidget::setMode(HbKeypadMode mode, HbModifiers modifiers)

   556 {

   557     Q_D(HbInputVkbWidget);

   558     d->mModifiers = modifiers;

   559     d->mMode = mode;

   560 }

   561 

   562 /*!

   563 Sets key map data object. Given key map data will be used as a source for button titles.

   564 Usually the key map data for active input language is used.

   565 */

   566 void HbInputVkbWidget::setKeymap(const HbKeymap* keymap)

   567 {

   568     Q_D(HbInputVkbWidget);

   569     if (keymap) {

   570         d->mKeymap = keymap;

   571     }

   572 }

   573 

   574 /*!

   575 This is called right before the keypad is about to open. This gives inheriting classes opportunity

   576 to do whatever initialization they need to do at this point.

   577 */

   578 void HbInputVkbWidget::aboutToOpen(HbVkbHost *host)

   579 {

   580     Q_D(HbInputVkbWidget);

   581 

   582     d->mCurrentHost = host;

   583 

   584     if (!d->mLayout) {

   585         // get preferred size from vkbhost and set it to vkb.

   586         // Keypad buttons will flicker while vkb opening (when we open keypad for first time )

   587         // if we dont set size to vkb before seting layout to vkb.

   588         resize(preferredKeyboardSize());

   589         d->mLayout = new QGraphicsLinearLayout(Qt::Vertical);

   590         d->mLayout->setContentsMargins(0.0, 0.0, 0.0, 0.0);

   591         d->mLayout->setSpacing(0.0);

   592 

   593         setLayout(d->mLayout);

   594 

   595         d->mCloseHandle = new QGraphicsWidget();

   596         d->mCloseHandle->setObjectName("vkbHandle");

   597         d->mCloseHandleHeight = HbCloseHandleHeight;

   598         d->mCloseHandle->setMinimumHeight(d->mCloseHandleHeight);

   599         d->mCloseHandle->setMaximumHeight(d->mCloseHandleHeight);

   600 

   601         d->mLayout->addItem(d->mCloseHandle);

   602         d->mLayout->addItem(keypadLayout());

   603     }

   604 

   605 

   606     if (d->mOwner && d->mOwner->focusObject()) {

   607         qreal vkbZValue = d->mOwner->focusObject()->findVkbZValue();

   608         setZValue(vkbZValue);

   609         d->mRocker->setZValue(vkbZValue+0.5);

   610     }

   611 

   612     show();

   613 }

   614 

   615 /*!

   616 This is called right before the keypad is about to close.

   617 */

   618 void HbInputVkbWidget::aboutToClose(HbVkbHost *host)

   619 {

   620     Q_D(HbInputVkbWidget);

   621 

   622     d->mCurrentHost = host;

   623 

   624     d->mRocker->setVisible(false);

   625     if (d->mSettingList) {

   626         d->mSettingList->close();

   627     }

   628 }

   629 

   630 /*!

   631 Enables or disabled all buttons in the keyboard that have not been disabled directly.

   632 */

   633 void HbInputVkbWidget::setKeyboardDimmed(bool dimmed)

   634 {

   635     Q_D(HbInputVkbWidget);

   636     d->mKeyboardDimmed = dimmed;

   637     if (keypadLayout()) {

   638         int itemCount = keypadLayout()->count();

   639         for (int i=0; i<itemCount; i++) {

   640             HbTouchKeypadButton* button = static_cast<HbTouchKeypadButton*>(keypadLayout()->itemAt(i));

   641             button->setFade(dimmed);

   642         }

   643     }

   644     if (!dimmed) {

   645         // when we undimmed the keyboard, all the buttons will be enabled by default.

   646         // we need to call applyEditorConstraints on the keyboard to apply constraints

   647         d->applyEditorConstraints();

   648     }

   649 

   650 }

   651 

   652 /*!

   653 Shows settings list

   654 */

   655 void HbInputVkbWidget::showSettingList()

   656 {

   657     Q_D(HbInputVkbWidget);

   658     HbPredictionFactory *predFactory = HbPredictionFactory::instance();

   659 

   660     d->mSettingsListOpen = true;

   661     d->captureScreenshot();

   662 

   663     if (!d->mSettingList) {

   664         d->mSettingList = new HbInputSettingList();

   665         connect(d->mSettingList, SIGNAL(aboutToClose()), this, SLOT(settingsClosed()));

   666         connect(d->mSettingList, SIGNAL(inputSettingsButtonClicked()), this, SLOT(executeSettingsDialog()));

   667         connect(d->mSettingList, SIGNAL(inputMethodsButtonClicked()), this, SLOT(executeMethodDialog()));

   668     }

   669 

   670 #if QT_VERSION >= 0x040600

   671     HbInputFocusObject *focusObject = d->mOwner->focusObject();

   672     if (focusObject &&

   673         focusObject->editorInterface().isPredictionAllowed() &&

   674         !focusObject->editorInterface().isNumericEditor() &&

   675         predFactory->predictionEngineForLanguage(HbInputSettingProxy::instance()->globalInputLanguage())) {

   676         d->mSettingList->setPredictionSelectionEnabled(true);

   677     } else {

   678         d->mSettingList->setPredictionSelectionEnabled(false);

   679     }

   680 #endif

   681 

   682     d->mSettingsButton->setBackgroundAttributes(HbTouchKeypadButton::HbTouchButtonLatched);

   683     qreal x = d->mSettingsButton->scenePos().x() + d->mSettingsButton->rect().width();

   684     qreal y = d->mSettingsButton->scenePos().y();

   685     d->mSettingList->setPreferredPos(QPointF(x, y), HbPopup::BottomRightCorner);

   686     d->mSettingList->showSettingList();

   687     d->mSettingsListOpen = false;

   688     if ( d->mAnimateWhenDialogCloses ) {

   689         animKeyboardChange();

   690         d->mAnimateWhenDialogCloses = false;

   691     } else if(d->mScreenshotTimeLine.state() != QTimeLine::Running) {

   692         keypadLanguageChangeFinished();

   693     }

   694 }

   695 

   696 /*!

   697 Slot to connect aboutToClose of settings list to update keyboard graphics.

   698 */

   699 void HbInputVkbWidget::settingsClosed()

   700 {

   701     Q_D(HbInputVkbWidget);

   702     d->mSettingsButton->setBackgroundAttributes(HbTouchKeypadButton::HbTouchButtonReleased);

   703 }

   704 

   705 /*!

   706 Closes settings list

   707 */

   708 void HbInputVkbWidget::closeSettingList()

   709 {

   710     Q_D(HbInputVkbWidget);

   711     d->mSettingList->close();

   712     d->mSettingsButton->setBackgroundAttributes(HbTouchKeypadButton::HbTouchButtonReleased);

   713 }

   714 

   715 /*!

   716 Toggles prediction status.

   717 */

   718 void HbInputVkbWidget::togglePredictionStatus()

   719 {

   720     closeSettingList();

   721     bool predictionStatus = HbInputSettingProxy::instance()->predictiveInputStatus();

   722     HbInputSettingProxy::instance()->setPredictiveInputStatus(!predictionStatus);

   723     update();

   724 }

   725 

   726 /*!

   727 Executes settingsDialog

   728 */

   729 void HbInputVkbWidget::executeSettingsDialog()

   730 {

   731     Q_D(HbInputVkbWidget);

   732 

   733     closeSettingList();

   734     HbInputSettingDialog::HbSettingItems items = HbInputSettingDialog::HbSettingItemAll;

   735     if (d->mOwner->focusObject()->editorInterface().isNumericEditor()) {

   736         items &=  (~HbInputSettingDialog::HbSettingItemPrediction);

   737     }

   738     HbInputSettingDialog* settings = new HbInputSettingDialog(items);

   739     d->mSettingsListOpen = true;

   740     settings->exec();

   741     delete settings;

   742     d->mSettingsListOpen = false;

   743     if ( d->mAnimateWhenDialogCloses ) {

   744         animKeyboardChange();

   745         d->mAnimateWhenDialogCloses = false;

   746     } else {

   747         keypadLanguageChangeFinished();

   748     }

   749 }

   750 

   751 /*!

   752 Executes input method selection dialog

   753 */

   754 void HbInputVkbWidget::executeMethodDialog()

   755 {

   756     Q_D(HbInputVkbWidget);

   757 

   758     closeSettingList();

   759     HbInputMethodDescriptor method

   760         = HbInputCommonDialogs::showCustomInputMethodSelectionDialog(HbInputSettingProxy::instance()->globalInputLanguage());

   761     if (!method.isEmpty() && d->mOwner) {

   762         d->mOwner->activateInputMethod(method);

   763     }

   764 }

   765 

   766 /*!

   767 Virtual function, each derived keypads should calculate and provide the

   768 layout information through this functions. This layout information is used

   769 by HbInputVkbWidget for layouting different components of vkb.

   770 */

   771 QGraphicsLayout *HbInputVkbWidget::keypadLayout()

   772 {

   773     Q_D(HbInputVkbWidget);

   774     return d->mButtonLayout;

   775 }

   776 

   777 /*!

   778 Returns the keypad in QWidget form.

   779 */

   780 QWidget* HbInputVkbWidget::asWidget()

   781 {

   782     return HbInputUtils::createWrapperWidget(this);

   783 }

   784 

   785 /*!

   786 Returns the keypad in QGraphicsWidget form.

   787 */

   788 QGraphicsWidget* HbInputVkbWidget::asGraphicsWidget()

   789 {

   790     return this;

   791 }

   792 

   793 /*!

   794 Returns preferred keyboard size. HbVkbHost uses this information when it opens the keyboard.

   795 */

   796 QSizeF HbInputVkbWidget::preferredKeyboardSize()

   797 {

   798     Q_D(HbInputVkbWidget);

   799 

   800     if (d->mCurrentHost) {

   801         // Just rely on the host and return what it suggests.

   802         QSizeF rect = d->mCurrentHost->keyboardArea();

   803         return rect;

   804     }

   805 

   806     return QSizeF(0.0, 0.0);

   807 }

   808 

   809 /*!

   810 This method is called every time vkb host draws an opening animation frame.

   811 */

   812 void HbInputVkbWidget::keyboardAnimationFrame(HbVkbAnimationType type, qreal x)

   813 {

   814     Q_UNUSED(type);

   815     Q_UNUSED(x);

   816 

   817     Q_D(HbInputVkbWidget);

   818     d->setRockerPosition();

   819 }

   820 

   821 /*!

   822 Returns the size of the keypad button area.

   823 */

   824 QSizeF HbInputVkbWidget::keypadButtonAreaSize()

   825 {

   826     Q_D(HbInputVkbWidget);

   827     QSizeF ret = preferredKeyboardSize();

   828     if (ret.height() >  d->mCloseHandleHeight) {

   829         ret.setHeight(ret.height() - d->mCloseHandleHeight);

   830 	}

   831 

   832     return ret;

   833 }

   834 

   835 /*!

   836 Sets the status of the background drawing. This method can be used to

   837 optimize vkb widget drawing. If it is known that the widget will cover whole

   838 vkb area and there are no places where the background shows through, then the background

   839 drawing can be turned off to speed up paint method.

   840 */

   841 void HbInputVkbWidget::setBackgroundDrawing(bool backgroundEnabled)

   842 {

   843     Q_D(HbInputVkbWidget);

   844     d->mDrawbackground = backgroundEnabled;

   845 }

   846 

   847 

   848 /*!

   849 Returns all possible keys those the user could have intended to press

   850 for the last registered touch along with their corresponding probability.

   851 One issue of thecurrent API implementation is that it does not always

   852 sum up the probabilities to 1.0, but sometimes it returns.999999899 etc.

   853 Need to be careful about it!

   854 */

   855 QList<HbKeyPressProbability> HbInputVkbWidget::probableKeypresses()

   856 {

   857     Q_D(HbInputVkbWidget);

   858 

   859     QList<HbKeyPressProbability> probableKeys;

   860     int totalItems = d->mButtonLayout->count();

   861     QRectF buttonRect = d->mMostRecentlyAccessedButton->geometry();

   862     //The overlaying rectangle is the test rectangle that is used for finding

   863     //intersactions with other buttons.

   864     QRectF overlayingRect(d->mMostRecentlyClickedLocation.x()-buttonRect.width()/2,d->mMostRecentlyClickedLocation.y()-buttonRect.height()/2, buttonRect.width(), buttonRect.height());

   865     QPainterPath path(overlayingRect.topLeft());

   866     path.addRect(overlayingRect);

   867     for(int count=0; count < totalItems; count++) {

   868         QGraphicsItem *item = d->mButtonLayout->itemAt(count)->graphicsItem();

   869         QPainterPath testPath = item->mapFromScene(path);

   870         HbTouchKeypadButton *buttonItem = 0;

   871         if(item->isWidget()){

   872             buttonItem =  qobject_cast<HbTouchKeypadButton *>(static_cast<QGraphicsWidget *>(item));

   873         }

   874         if(!buttonItem) {

   875             continue;

   876         }

   877 

   878         //Checkif the button collides with the path, if yes,it means that the colliding

   879         //key also could have been clicked by the user. The probability of the button being

   880         //clickedin that case willdependon the area of the intersaction rectangle.

   881         if(buttonItem->collidesWithPath(testPath)) {

   882             //Initiallylet the intersaction be same as the overlaying rectangle,later we will

   883             //shrink the rectangle and find the actual intersected rectangle.

   884             QRectF intersactionRect = overlayingRect;

   885             //The overlaying rectangle is in scene coordinates, map it to the item coordinates.

   886             intersactionRect.moveTopLeft(buttonItem->mapFromScene(overlayingRect.topLeft()));

   887             int width = (int)intersactionRect.width();

   888             int height = (int)intersactionRect.height();

   889             qreal probability = 0.0;

   890             //Shrink based on the size of the intersaction

   891             if (intersactionRect.topLeft().x() > 0) {

   892                 width -= (int)intersactionRect.topLeft().x();

   893             } else {

   894                 width += (int)intersactionRect.topLeft().x();

   895             }

   896             if (intersactionRect.topLeft().y() > 0) {

   897                 height -= (int)intersactionRect.topLeft().y();

   898             } else {

   899                 height += (int)intersactionRect.topLeft().y();

   900             }

   901             //The probabilty of the key is based on the intersaction area.

   902             probability = (height * width) / (intersactionRect.width()* intersactionRect.height());

   903             HbKeyPressProbability probablekey;

   904             probablekey.keycode = d->keyCode(buttonItem);

   905             probablekey.probability = probability;

   906 

   907             if(probablekey.keycode && (probablekey.probability>0)) {

   908                 probableKeys.append(probablekey);

   909             }

   910         }

   911     }

   912     //Normalize makes sure that all probability summation is 1.0.

   913     d->normalizeProbabilities(probableKeys);

   914     return probableKeys;

   915 }

   916 

   917 /*!

   918 Sets up the common buttons in the tool cluster (settings and application buttons).

   919 */

   920 void HbInputVkbWidget::setupToolCluster()

   921 {

   922     Q_D(HbInputVkbWidget);

   923     if(!d->mOwner || !d->mOwner->focusObject()) {

   924         return;

   925     }

   926 

   927     // Create settings button if it does not exist

   928     if (!d->mSettingsButton) {

   929         d->mSettingsButton = new HbTouchKeypadButton(this, QString(""));

   930         d->mInputModeIndicator = new HbInputModeIndicator(*d->mSettingsButton, this);

   931         d->mSettingsButton->setButtonType(HbTouchKeypadButton::HbTouchButtonFunction);

   932         d->mSettingsButton->setBackgroundAttributes(HbTouchKeypadButton::HbTouchButtonReleased);

   933 

   934         connect(d->mSettingsButton, SIGNAL(clicked()), this, SLOT(showSettingList()));

   935 

   936         connect(d->mSettingsButton, SIGNAL(pressed()), d->mPressMapper, SLOT(map()));

   937         connect(d->mSettingsButton, SIGNAL(released()), d->mReleaseMapper, SLOT(map()));

   938         d->mPressMapper->setMapping(d->mSettingsButton, -1);

   939         d->mReleaseMapper->setMapping(d->mSettingsButton, -1);

   940     } else {

   941         d->mInputModeIndicator->updateIndicator();

   942     }

   943 

   944     // If there's a application specific button defined, create new button with the properties

   945     // or update the existing one. Otherwise create an empty button or clean the properties of an existing one.

   946     if (!d->mOwner->focusObject()->editorInterface().actions().isEmpty()) {

   947         QList<HbAction*> actions = d->mOwner->focusObject()->editorInterface().actions();

   948         if (d->mApplicationButtonAction != actions.first()) {

   949             if (d->mApplicationButton) {

   950                 d->mApplicationButton->setText(actions.first()->text());

   951                 d->mApplicationButton->setIcon(actions.first()->icon());

   952                 d->mApplicationButton->disconnect(SIGNAL(clicked()));

   953                 d->mApplicationButton->disconnect(SIGNAL(pressed()));

   954                 d->mApplicationButton->disconnect(SIGNAL(released()));

   955 

   956                 // disconnects old signal

   957                 disconnect(d->mApplicationButtonAction, SIGNAL(changed()), this, SLOT(refreshApplicationButton()));

   958                 disconnect(d->mApplicationButton, SIGNAL(clicked()), d->mApplicationButtonAction, SLOT(trigger()));

   959             } else {

   960                 d->mApplicationButton = new HbTouchKeypadButton(this, actions.first()->icon(), actions.first()->text());

   961             }

   962             d->mApplicationButtonAction = actions.first();

   963             // Connect to enabling signal and check its value

   964             connect(actions.first(), SIGNAL(changed()), this, SLOT(refreshApplicationButton()));

   965 

   966             if (actions.first()->isEnabled()) {

   967                 // action is enabled

   968                 connect(d->mApplicationButton, SIGNAL(clicked()), d->mApplicationButtonAction, SLOT(trigger()));

   969 

   970                 connect(d->mApplicationButton, SIGNAL(pressed()), d->mPressMapper, SLOT(map()));

   971                 connect(d->mApplicationButton, SIGNAL(released()), d->mReleaseMapper, SLOT(map()));

   972                 d->mPressMapper->setMapping(d->mApplicationButton, -1);

   973                 d->mReleaseMapper->setMapping(d->mApplicationButton, -1);

   974 

   975                 d->mApplicationButton->setToolTip(actions.first()->toolTip());

   976                 d->mApplicationButton->setButtonType(HbTouchKeypadButton::HbTouchButtonFunction);

   977                 d->mApplicationButton->setBackgroundAttributes(HbTouchKeypadButton::HbTouchButtonReleased);

   978             } else {

   979                 // action is disabled

   980                 d->mApplicationButton->setButtonType(HbTouchKeypadButton::HbTouchButtonFnInActive);

   981                 d->mApplicationButton->setBackgroundAttributes(HbTouchKeypadButton::HbTouchButtonPressed);

   982             }

   983             d->mApplicationButton->setToolTip(actions.first()->toolTip());

   984         }

   985     } else {

   986         if (d->mApplicationButton) {

   987             if (d->mApplicationButtonAction) {

   988                 disconnect(d->mApplicationButtonAction, SIGNAL(changed()), this, SLOT(refreshApplicationButton()));

   989             }

   990             d->mApplicationButton->disconnect(SIGNAL(clicked()));

   991             d->mApplicationButton->disconnect(SIGNAL(pressed()));

   992             d->mApplicationButton->disconnect(SIGNAL(released()));

   993             d->mApplicationButton->setText(QString());

   994             d->mApplicationButton->setIcon(HbIcon());

   995             d->mApplicationButton->setToolTip(QString());

   996 			d->mApplicationButtonAction = 0;

   997         } else {

   998             d->mApplicationButton = new HbTouchKeypadButton(this, QString());

   999             d->mApplicationButton->setButtonType(HbTouchKeypadButton::HbTouchButtonFunction);

  1000             d->mApplicationButton->setBackgroundAttributes(HbTouchKeypadButton::HbTouchButtonReleased);

  1001         }

  1002         d->mApplicationButtonAction = NULL;

  1003     }

  1004 }

  1005 

  1006 /*!

  1007 shape function actually refines the bounding rect. This function is used for collision detection

  1008 and hit test.

  1009 */

  1010 QPainterPath HbInputVkbWidget::shape() const

  1011 {

  1012     QRectF rect = boundingRect();

  1013     QPainterPath path;

  1014     path.addRect(rect);

  1015     return path;

  1016 }

  1017 

  1018 QSizeF HbInputVkbWidget::minimizedKeyboardSize()

  1019 {

  1020     Q_D(HbInputVkbWidget);

  1021     return QSizeF(0.0, d->mCloseHandleHeight);

  1022 }

  1023 

  1024 void HbInputVkbWidget::showSmileyPicker(int rows, int columns)

  1025 {

  1026     Q_D(HbInputVkbWidget);

  1027     if (!d->mOwner || !d->mOwner->focusObject()) {

  1028         return;

  1029     }

  1030     // check whether the smiley recognition is enabled 	in the currently focused editor.

  1031     if (!d->isSmileysEnabled()) {

  1032         return;

  1033     }

  1034     HbInputFocusObject *focusObject = d->mOwner->focusObject();

  1035 	

  1036     if (!d->mSmileyPicker || d->mFocusedObject != focusObject) {

  1037         d->mFocusedObject = focusObject;

  1038         if (d->mSmileyPicker) {

  1039             delete d->mSmileyPicker;

  1040         }

  1041         // get the smiley list from editor interface smiley theme.

  1042         QStringList smileys = focusObject->editorInterface().smileyTheme().smileys();

  1043         // if the smiley list is empty and the editor is not a Hb editor, 

  1044         // then get the default smiley list from smiley engine.

  1045         if (smileys.isEmpty() && !focusObject->editorInterface().editor()->inherits("HbAbstractEdit")) {

  1046             HbSmileyEngine smileyEngine;

  1047             smileys = smileyEngine.defaultTheme().smileys();

  1048         }

  1049 

  1050         if (!smileys.isEmpty()) {

  1051             d->mSmileyPicker = new HbInputSmileyPicker(rows, columns, 0, smileys);

  1052             d->mSmileyPicker->setObjectName("vkbwidget_smiley_picker");

  1053             connect(d->mSmileyPicker, SIGNAL(selected(QString)), this, SIGNAL(smileySelected(QString)));

  1054         }			

  1055     }

  1056 

  1057     if (d->mSmileyPicker) {

  1058         d->mSmileyPicker->setGeometry(QRectF(0, pos().y(), geometry().width(),

  1059             geometry().height()));

  1060         d->mSmileyPicker->show();

  1061     }		

  1062 }

  1063 

  1064 HbInputVkbWidget::HbFlickDirection HbInputVkbWidget::flickDirection()

  1065 {

  1066     Q_D(HbInputVkbWidget);

  1067     return d->mFlickDirection;

  1068 }

  1069 

  1070 /*!

  1071     Intended for internal use only

  1072 */

  1073 void HbInputVkbWidget::refreshApplicationButton()

  1074 {

  1075     Q_D(HbInputVkbWidget);

  1076 

  1077     d->mApplicationButton->setText(d->mApplicationButtonAction->text());

  1078     d->mApplicationButton->setIcon(d->mApplicationButtonAction->icon());

  1079 

  1080     if (d->mApplicationButton->getButtonType() == HbTouchKeypadButton::HbTouchButtonFnInActive

  1081         && d->mApplicationButtonAction->isEnabled()) {

  1082         // action has been enabled

  1083         connect(d->mApplicationButton, SIGNAL(clicked()), d->mApplicationButtonAction, SLOT(trigger()));

  1084         d->mApplicationButton->setToolTip(d->mApplicationButtonAction->toolTip());

  1085         d->mApplicationButton->setFade(false);

  1086     } else if (d->mApplicationButton->getButtonType() == HbTouchKeypadButton::HbTouchButtonFunction

  1087         && !d->mApplicationButtonAction->isEnabled()) {

  1088         // action has been disabled

  1089         d->mApplicationButton->disconnect(SIGNAL(clicked()));

  1090         d->mApplicationButton->setFade(true);

  1091     }

  1092 }

  1093 

  1094 void HbInputVkbWidget::keypadLanguageChangeAnimationUpdate(qreal aValue)

  1095 {

  1096     Q_D(HbInputVkbWidget);

  1097 

  1098     int direction = 1;

  1099     if (flickDirection() == HbFlickDirectionLeft) {

  1100         direction = -1;

  1101     }

  1102 

  1103     QRectF rect = boundingRect();

  1104     QPointF position = pos();

  1105     position.setX(direction * (-rect.width() + rect.width() * aValue));

  1106     if (d->mScreenshotWidget) {

  1107        d->mScreenshotWidget->setPos(position.x() + direction * rect.width(), position.y());

  1108        setPos(position);

  1109     }

  1110 }

  1111 

  1112 void HbInputVkbWidget::keypadLanguageChangeFinished()

  1113 {

  1114     Q_D(HbInputVkbWidget);

  1115     delete d->mScreenshotWidget;

  1116     d->mScreenshotWidget = NULL;

  1117 }

  1118 

  1119 void HbInputVkbWidget::animKeyboardChange()

  1120 {

  1121     Q_D(HbInputVkbWidget);

  1122     if (mainWindow()) {

  1123         if (d->mSettingsListOpen){

  1124             d->mAnimateWhenDialogCloses = true;

  1125         } else {

  1126             if (!d->mAnimateWhenDialogCloses) {

  1127                 d->captureScreenshot();

  1128             }

  1129             connect(&d->mScreenshotTimeLine, SIGNAL(valueChanged(qreal)), this, SLOT(keypadLanguageChangeAnimationUpdate(qreal)));

  1130             connect(&d->mScreenshotTimeLine, SIGNAL(finished()), this, SLOT(keypadLanguageChangeFinished()));

  1131             d->mScreenshotTimeLine.start();

  1132         }

  1133     }

  1134 }