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

**

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

/*!

\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, QGraphicsWidget *containerWidget)

: q_ptr(myHost),

mCallback(0),

mKeypad(0),

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

}

void HbAbstractVkbHostPrivate::prepareAnimationsCommon()

{

    if (mContainerWidget && 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 || !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());

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

{

    if (mContainerWidget) {

        q_ptr->connect(mContainerWidget, SIGNAL(yChanged()), q_ptr, SLOT(ensureCursorVisibility()));

    }

    HbWidget *hbWidget = qobject_cast<HbWidget*>(mContainerWidget);

    if (hbWidget) {

        HbMainWindow* mainWindow = hbWidget->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)));

        }

    }

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

    if (popup) {

        q_ptr->connect(popup, SIGNAL(aboutToHide()), q_ptr, SLOT(containerAboutToClose()));

    }

}

void HbAbstractVkbHostPrivate::disconnectSignals()

{

    if (mContainerWidget) {

        q_ptr->disconnect(mContainerWidget, SIGNAL(yChanged()), q_ptr, SLOT(ensureCursorVisibility()));

    }

    HbWidget *hbWidget = qobject_cast<HbWidget*>(mContainerWidget);

    if (hbWidget) {

        HbMainWindow* mainWindow = hbWidget->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)));

        }

    }

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

    if (popup) {

        q_ptr->disconnect(popup, SIGNAL(aboutToHide()), q_ptr, SLOT(containerAboutToClose()));

    }

}

void HbAbstractVkbHostPrivate::openKeypad()

{    

    if (mContainerWidget) {

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

            if (prepareAnimations(HbVkbHost::HbVkbStatusMinimized)) {

                mKeypadStatus = HbVkbHost::HbVkbStatusMinimized;

                mTimeLine.start();

            }

        }

    }

}

void HbAbstractVkbHostPrivate::openKeypadWithoutAnimation()

{

    HbMainWindow *mainWin = mainWindow();

    if (mKeypadStatus!= HbVkbHost::HbVkbStatusOpened && mKeypad && mContainerWidget && 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) {

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

        }

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

        }

        mKeypadStatus = HbVkbHost::HbVkbStatusMinimized;

        if (!disableCursorShift()) {

            // Return the container widget to original position.

            mContainerWidget->setPos(mOriginalContainerPosition);

            // Set the keypad to minimized position.

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

        }

    }

}

void HbAbstractVkbHostPrivate::cancelAnimationAndHideVkbWidget()

{

    if (mTimeLine.state() == QTimeLine::Running) {

        mTimeLine.stop();

        if (!disableCursorShift()) {

            mContainerWidget->setPos(mOriginalContainerPosition);

        }

        if (mKeypad) {

            mKeypad->hide();

        }

        // Clear possible pending call.

        mPendingCall.vkb = 0;

        emit q_ptr->keypadClosed();

        HbVkbHostBridge::instance()->connectHost(0);

        mKeypadStatus = HbVkbHost::HbVkbStatusClosed;

    }

}

HbMainWindow *HbAbstractVkbHostPrivate::mainWindow() const

{

    HbWidget *hbWidget = qobject_cast<HbWidget*>(mContainerWidget);

    if (hbWidget) {

        return hbWidget->mainWindow();

    }

    return qobject_cast<HbMainWindow*>(qApp->activeWindow());

}

QSizeF HbAbstractVkbHostPrivate::screenSize() const

{

    HbMainWindow *mainWin = mainWindow();

    QSizeF result = static_cast<QSizeF>(HbDeviceProfile::profile(mainWin).logicalSize());

    // do some sanity checking for the size got from device profile

    if( result.isNull() || result.width() < 200 || result.height() < 200 ) {

        qWarning("VkbHost error: size from device profile is faulty, using fallback!");

        if (mainWin) {

            if (mainWin->orientation() == Qt::Horizontal) {

                result.setWidth(640);

                result.setHeight(360);

            } else {

                result.setWidth(360);

                result.setHeight(640);

            }

        }

    }

    return result;

}

bool HbAbstractVkbHostPrivate::disableCursorShift() {

    if (!mInputMethod

        || mainWindow()) {

        return false;

    }

    if ( (mainWindow()->orientation() == Qt::Horizontal)

        && (mInputMethod->inputState().inputMode() == HbInputModeHwrChinese

        || mInputMethod->inputState().inputMode() == HbInputModeHwrChineseFull) ) {

        return true;

    }

    return false;

}

/// @endcond

HbAbstractVkbHost::HbAbstractVkbHost(HbWidget *containerWidget) : d_ptr(new HbAbstractVkbHostPrivate(this, containerWidget))

{

    Q_D(HbAbstractVkbHost);

    setParent(containerWidget);

    HbVkbHost::attachHost(this, containerWidget);

    connect(&d->mTimeLine, SIGNAL(finished()), this, SLOT(animationFinished()));

    connect(&d->mTimeLine, SIGNAL(valueChanged(qreal)), this, SLOT(animValueChanged(qreal)));

}

HbAbstractVkbHost::HbAbstractVkbHost(QGraphicsWidget *containerWidget) : d_ptr(new HbAbstractVkbHostPrivate(this, containerWidget))

{

    Q_D(HbAbstractVkbHost);

    setParent(containerWidget);

    HbVkbHost::attachHost(this, containerWidget);

    connect(&d->mTimeLine, SIGNAL(finished()), this, SLOT(animationFinished()));

    connect(&d->mTimeLine, SIGNAL(valueChanged(qreal)), this, SLOT(animValueChanged(qreal)));

}

HbAbstractVkbHost::HbAbstractVkbHost(HbAbstractVkbHostPrivate *dd) : d_ptr(dd)

{

    Q_D(HbAbstractVkbHost);

    setParent(d->mContainerWidget);