/****************************************************************************

**

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

** All rights reserved.

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

**

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

**

** GNU Lesser General Public License Usage

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

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

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

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

** Public License version 2.1 requirements will be met:

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

**

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

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

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

**

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

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

**

****************************************************************************/

#include "hbabstractvkbhost.h"

#include "hbabstractvkbhost_p.h"

#include "private/hbvkbgeometrylogic_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"

#include "hbwidgetfeedback.h"

#include "hbinstance.h"

#include <QTextEdit>

const int HbAnimationTime = 200;

const qreal HbHeightVerticalFactor = 0.5;

const qreal HbHeightHorizFactor = 0.7;

const QString KHandWritingName("Handwriting");

// see hbpopup.cpp for this

extern const char* KPositionManagedByVKB;

/// @cond

{

    }

}

QPointF HbVkbHostContainerWidget::pos()

{

    }

    return QPointF(0, 0);

}

QRectF HbVkbHostContainerWidget::sceneBoundingRect()

{

    }

    return QRectF(0, 0, 0, 0);

}

void HbVkbHostContainerWidget::connectSignals(QObject *receiver)

{

                         receiver, SLOT(ensureCursorVisibility()));

    }

    if (popup) {

    }

    if (view) {

        QObject::connect(view->mainWindow(), SIGNAL(currentViewChanged(HbView *)),

    }

}

void HbVkbHostContainerWidget::disconnectSignals(QObject *receiver)

{

                            receiver, SLOT(ensureCursorVisibility()));

    }

    if (popup) {

    }

    if (view) {

        QObject::disconnect(view->mainWindow(), SIGNAL(currentViewChanged(HbView *)),

    }

}

/// @endcond

/*!

\proto

\class HbAbstractVkbHost

\brief Base class for HbCore's virtual keyboard hosts.

This class contains common code for HbCore's virtual keyboard hosts.

*/

/// @cond

HbAbstractVkbHostPrivate::HbAbstractVkbHostPrivate(HbAbstractVkbHost *myHost, QObject *containerWidget)

    : q_ptr(myHost),

      mCallback(0),

      mKeypad(0),

      mContainerWidget(new HbVkbHostContainerWidget(containerWidget)),

      mTimeLine(HbAnimationTime),

      mKeypadStatus(HbVkbHost::HbVkbStatusClosed),

      mKeypadOperationOngoing(false),

      mOriginalContainerPosition(QPointF(0, 0)),

      mContainerMovementStartingPoint(QPointF(0, 0)),

      mContainerMovementVector(QPointF(0, 0)),

      mKeypadMovementStartingPoint(QPointF(0, 0)),

      mKeypadMovementVector(QPointF(0, 0)),

      mInputMethod(0),

      mKeypadStatusBeforeOrientationChange(HbVkbHost::HbVkbStatusClosed),

      mTitleBarHiddenByVkbHost(false),

      mStatusBarHiddenByVkbHost(false)

{

    mTimeLine.setUpdateInterval(16);

}

HbAbstractVkbHostPrivate::~HbAbstractVkbHostPrivate()

{

    delete mContainerWidget;

}

void HbAbstractVkbHostPrivate::prepareAnimationsCommon()

{

        // If the keyboard is not already open, remember the original position.

        // That is where the container will eventually be returned to.

        if (mKeypadStatus == HbVkbHost::HbVkbStatusClosed) {

            mOriginalContainerPosition = mContainerWidget->pos();

        }

        // Initialize movement variables to starting values. These will

        // be fine tuned later.

        mKeypadMovementVector = QPointF(0, 0);

        mContainerMovementVector = QPointF(0, 0);

        mContainerMovementStartingPoint = mContainerWidget->pos();

        mKeypadMovementStartingPoint = mKeypad->pos();

    }

    mScreenSize = screenSize();

}

bool HbAbstractVkbHostPrivate::getViewAndFocusObjects(HbView*& currentView, HbInputFocusObject*& focusObject)

    if (!mKeypad || !mInputMethod || !mContainerWidget ) {

        return false;

    }

    HbMainWindow* window = mainWindow();

    if (!window) {

        return false;

    }

    currentView = window->currentView();

    if (!currentView) {

        return false;

    }

    focusObject = mInputMethod->focusObject();

    if (!focusObject) {

        return false;

    }

    return true;

}

bool HbAbstractVkbHostPrivate::prepareContainerAnimation(HbVkbHost::HbVkbStatus status)

{

    // Init and check main objects

    if (!getViewAndFocusObjects(currentView, focusObject)) {

        return false;

    }

    // Init parameters before calling...

    QSizeF keypadSize = mKeypad->size();

    QRectF viewRect = currentView->sceneBoundingRect();

    bool vkbOpen = mKeypadStatus == HbVkbHost::HbVkbStatusOpened;

    bool titlebarVisible = currentView->isItemVisible(Hb::TitleBarItem);

    bool statusbarVisible = currentView->isItemVisible(Hb::StatusBarItem);

    QRectF containerRect = mContainerWidget->sceneBoundingRect();

    QRectF editorRect = focusObject->editorGeometry();

    QRectF cursorRect = focusObject->microFocus();

    if (status == HbVkbHost::HbVkbStatusOpened) {

        // Initialize geometry calculation unit to handle all geometry calculations.

        HbVkbGeometryLogicPrivate unit = HbVkbGeometryLogicPrivate(

                mScreenSize,

                keypadSize,

                viewRect,

                vkbOpen,

                titlebarVisible,

                statusbarVisible,

                containerRect,

                editorRect,

                cursorRect);

        return unit.calculateContainerMovement( mContainerMovementVector );

    }

    return false;

}

bool HbAbstractVkbHostPrivate::prepareKeypadAnimation(HbVkbHost::HbVkbStatus status)

{

            }

            return true;

        }

    }

    return false;

}

bool HbAbstractVkbHostPrivate::prepareAnimations(HbVkbHost::HbVkbStatus status)

{

    prepareAnimationsCommon();

    bool containerResult = prepareContainerAnimation(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()

{

    mContainerWidget->connectSignals(q_ptr);

    // global signal not specific to any containter widget, can be connected now.

    HbMainWindow *mainWindow = this->mainWindow();

    if (mainWindow) {

        q_ptr->connect(mainWindow, SIGNAL(aboutToChangeOrientation()), q_ptr, SLOT(orientationAboutToChange()));

        q_ptr->connect(mainWindow, SIGNAL(orientationChanged(Qt::Orientation)), q_ptr, SLOT(orientationChanged(Qt::Orientation)));

        q_ptr->connect(mainWindow, SIGNAL(aboutToChangeView(HbView *, HbView *)), q_ptr, SLOT(aboutToChangeView(HbView *, HbView *)));

    }

}

void HbAbstractVkbHostPrivate::disconnectSignals()

{

    mContainerWidget->disconnectSignals(q_ptr);

    // global signal not specific to any containter widget, can be connected now.

    HbMainWindow *mainWindow = this->mainWindow();

    if (mainWindow) {

        q_ptr->disconnect(mainWindow, SIGNAL(aboutToChangeOrientation()), q_ptr, SLOT(orientationAboutToChange()));

        q_ptr->disconnect(mainWindow, SIGNAL(orientationChanged(Qt::Orientation)), q_ptr, SLOT(orientationChanged(Qt::Orientation)));

        q_ptr->disconnect(mainWindow, SIGNAL(aboutToChangeView(HbView *, HbView *)), q_ptr, SLOT(aboutToChangeView(HbView *, HbView *)));

    }

}

void HbAbstractVkbHostPrivate::openKeypad()

{

    if (mContainerWidget->widgetObject()) {

        HbMainWindow *mainWin = mainWindow();

        if (mainWin && mKeypad) {

            if (mKeypad->scene() != mainWin->scene()) {

                // Add keypad to scene if it is not already in there.

                mainWin->scene()->addItem(mKeypad);

            }

            if (mKeypadStatus != HbVkbHost::HbVkbStatusOpened) {

                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();

            }

        }

    }

}

void HbAbstractVkbHostPrivate::closeKeypad()

    if (mKeypadStatus != HbVkbHost::HbVkbStatusClosed) {

        if (prepareAnimations(HbVkbHost::HbVkbStatusClosed)) {

            // show the title bar and status bar when closing the vkb   

            setTitleAndStatusBarVisible(true);

            mKeypadStatus = HbVkbHost::HbVkbStatusClosed;

            mTimeLine.start();

        }

    }

}

void HbAbstractVkbHostPrivate::openKeypadWithoutAnimation()

{

    HbMainWindow *mainWin = mainWindow();

    if (mKeypadStatus != HbVkbHost::HbVkbStatusOpened && mKeypad && mContainerWidget->widgetObject() && mainWin) {

        if (mKeypad->scene() != mainWin->scene()) {

            // Add item to scene if it is not already in there.

            mainWin->scene()->addItem(mKeypad);

        }

        if (mKeypadStatus != HbVkbHost::HbVkbStatusOpened) {

            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

                mKeypad->setPos(mKeypadMovementStartingPoint + mKeypadMovementVector);

            }

            mKeypadStatus = HbVkbHost::HbVkbStatusOpened;

        }

    }

}

void HbAbstractVkbHostPrivate::closeKeypadWithoutAnimation()

{

        mCallback->aboutToClose(q_ptr);

        // show the title bar and status bar when closing the vkb