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

**

** 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 HbEditorExtraMargin = 5.0;

const qreal HbCursorLineMargin = 15.0;

const qreal HbContainerBorderMargin = 20.0;

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)

{

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

}

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

{

    if (!mKeypad || !mContainerWidget->widgetObject() || !mInputMethod || !mInputMethod->focusObject()) {

        return false;

    }

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

        // Find out the container area.

        QRectF containerArea = mContainerWidget->sceneBoundingRect();

        containerArea.adjust(0.0, -HbContainerBorderMargin, 0.0, HbContainerBorderMargin);

        if (visibleArea.contains(containerArea)) {

            // The whole container is already inside the visible area, nothing to do.

            return false;

        }

        if (visibleArea.height() >= containerArea.height()) {

            // It isn't in the visible area yet but fits there. Let's move it there.

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

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

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

                } else {

                    mContainerMovementVector = QPointF(0.0, visibleArea.bottom() - editorGeometry.bottom());

                }

                return true;

            }

        }

        // The editor is either already inside the visible area or doesn't fit there.

        // Let's see if the cursor is visble.

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

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

                // A sanity check. If the microFocus rectangle is outside the editor

                // bounding rect, don't do anything. The situation in editor widget is not

                // up to date.

                return false;

            }

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

                // First see what would happen if we returned the container to original position.

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

        }

    } else {

        // It is going to be closed or minimized.

        mContainerMovementVector = mOriginalContainerPosition - mContainerMovementStartingPoint;

        return true;

    }

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

        q_ptr->connect(mainWindow, SIGNAL(currentViewChanged(HbView *)), q_ptr, SLOT(currentViewChanged(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(currentViewChanged(HbView *)), q_ptr, SLOT(currentViewChanged(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) {

                mCallback->aboutToOpen(q_ptr);

                q_ptr->resizeKeyboard(); // Make sure that the keyboard doesn't exceed given boundaries.

            }

            if (prepareAnimations(HbVkbHost::HbVkbStatusOpened)) {

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

            mKeypadStatus = HbVkbHost::HbVkbStatusClosed;

            mTimeLine.start();

        }

    }

}

void HbAbstractVkbHostPrivate::minimizeKeypad()

{

    if (mCallback && mKeypadStatus != HbVkbHost::HbVkbStatusMinimized) {

        mCallback->aboutToClose(q_ptr);

        if (mContainerWidget->widgetObject()) {

            if (prepareAnimations(HbVkbHost::HbVkbStatusMinimized)) {

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

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

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

    }