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

**

** 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 "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

HbVkbHostContainerWidget::HbVkbHostContainerWidget(QObject *containterWidget)

    : mContainerWidget(containterWidget)

{

}

// sets container widgets position to new position.

void HbVkbHostContainerWidget::setPos(QPointF newPosition)

{

    if (mContainerWidget) {

        QGraphicsObject *graphicsObject = qobject_cast<QGraphicsObject *>(mContainerWidget);

        if (graphicsObject) {

            graphicsObject->setPos(newPosition);

            return;

        }

        QWidget *qWidget = qobject_cast<QWidget *>(mContainerWidget);

        if (qWidget) {

#ifdef Q_WS_WIN

            QPoint finalPosition = newPosition.toPoint();

            finalPosition -= qWidget->geometry().topLeft() - qWidget->frameGeometry().topLeft();

            qWidget->move(finalPosition);

#else

            qWidget->move(newPosition.toPoint());

#endif

            return;

        }

    }

}

// returns the global position, if container widget is a QGraphicsObject, it returns

// scene position. In case the widget is QWidget it returns global co-ordinates

QPointF HbVkbHostContainerWidget::pos()

{

    if (mContainerWidget) {

        QGraphicsObject *graphicsObject = qobject_cast<QGraphicsObject *>(mContainerWidget);

        if (graphicsObject) {

            return graphicsObject->pos();;

        }

        QWidget *qWidget = qobject_cast<QWidget *>(mContainerWidget);

        if (qWidget) {

            return qWidget->mapToGlobal(QPoint(0, 0));

        }

    }

    return QPointF(0, 0);

}

// returns the bounding rect in global co-ordinate, if container widget is a QGraphicsObject

// it returns in scene co-ordinate, incase widget is QWidget it returns in global co-ordinate

QRectF HbVkbHostContainerWidget::sceneBoundingRect()

{

    if (mContainerWidget) {

        QGraphicsObject *graphicsObject = qobject_cast<QGraphicsObject *>(mContainerWidget);

        if (graphicsObject) {

            return graphicsObject->sceneBoundingRect();;

        }

        QWidget *qWidget = qobject_cast<QWidget *>(mContainerWidget);

        if (qWidget) {

            return QRectF(qWidget->mapToGlobal(QPoint(0, 0)), qWidget->size());

        }

    }

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

}

// connect container specific signals here.

void HbVkbHostContainerWidget::connectSignals(QObject *receiver)

{

    if (qobject_cast<QGraphicsObject *> (mContainerWidget)) {

        QObject::connect(mContainerWidget, SIGNAL(yChanged()),

                         receiver, SLOT(ensureCursorVisibility()));

    }

    HbPopup *popup = qobject_cast<HbPopup *>(mContainerWidget);

    if (popup) {

        QObject::connect(popup, SIGNAL(aboutToHide()), receiver, SLOT(containerAboutToClose()));

    }

    HbView *view = qobject_cast<HbView *>(mContainerWidget);

    if (view) {

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

                         receiver, SLOT(currentViewChanged(HbView *)));

    }

}

// disconnect container specific signals here.

void HbVkbHostContainerWidget::disconnectSignals(QObject *receiver)

{

    if (qobject_cast<QGraphicsObject *> (mContainerWidget)) {

        QObject::disconnect(mContainerWidget, SIGNAL(yChanged()),

                            receiver, SLOT(ensureCursorVisibility()));

    }

    HbPopup *popup = qobject_cast<HbPopup *>(mContainerWidget);

    if (popup) {

        QObject::disconnect(popup, SIGNAL(aboutToHide()), receiver, SLOT(containerAboutToClose()));

    }

    HbPopup *view = qobject_cast<HbPopup *>(mContainerWidget);

    if (view) {

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

                            receiver, SLOT(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 (mContainerWidget->widgetObject() && mKeypad) {

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

}

        return false;

    }

    }

    return false;

}

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

{

    if (status == HbVkbHost::HbVkbStatusOpened) {

        if (mKeypadStatus == HbVkbHost::HbVkbStatusClosed) {

            // Set up keyboard open animation.

            mKeypadMovementStartingPoint.setY(mScreenSize.height());

            mKeypadMovementVector.setY(-mKeypad->size().height());

            if (!disableCursorShift()) {

                // Initialize keypad position

                mKeypad->setPos(mKeypadMovementStartingPoint);

            }

            return true;

        } else if (mKeypadStatus == HbVkbHost::HbVkbStatusMinimized && mCallback) {

            mKeypadMovementVector.setY(-(mKeypad->size().height() - mCallback->minimizedKeyboardSize().height()));

            return true;

        }

    } else if (status == HbVkbHost::HbVkbStatusMinimized && mCallback) {

        mKeypadMovementVector = QPointF(0, mKeypad->size().height() - mCallback->minimizedKeyboardSize().height());

        return true;

    } else {

        // It is going to be closed.

        mKeypadMovementVector = QPointF(0, mKeypad->size().height());

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

    }

}

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

    }

}

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) {

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

            }

        }

    }

}

void HbAbstractVkbHostPrivate::closeKeypad()

{

    // Since the keypad is already in a minimized state we should not play animation.

    if (mKeypadStatus == HbVkbHost::HbVkbStatusMinimized) {

        closeKeypadWithoutAnimation();

    }

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

        }

    }

}

void HbAbstractVkbHostPrivate::minimizeKeypad()

{

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

            }

        }

    }

}

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) {

            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

                mKeypad->setPos(mKeypadMovementStartingPoint + mKeypadMovementVector);

            }

            mKeypadStatus = HbVkbHost::HbVkbStatusOpened;

            mCallback->keyboardOpened(q_ptr);

        }

    }

}

void HbAbstractVkbHostPrivate::openMinimizedKeypad()

{

    // No need of any animation as this minimized keypad is very small to be a candidate for an

    // animation.

    HbMainWindow *mainWin = mainWindow();

    if (mainWin && mKeypad && mContainerWidget->widgetObject()) {

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

            // 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()) {

                mKeypad->setPos(0.0, mScreenSize.height() - mCallback->minimizedKeyboardSize().height());

            }

            mKeypadStatus = HbVkbHost::HbVkbStatusMinimized;

            mCallback->keyboardMinimized(q_ptr);

        }

    }

}

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.

            mContainerWidget->setPos(mOriginalContainerPosition);

            mContainerWidget->widgetObject()->setProperty(KPositionManagedByVKB, false );

        }

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