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

**

** 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 "hbinstance.h"

#include <QTextEdit>

const QString KHandWritingName("Handwriting");

// see hbpopup.cpp for this

extern const char* KPositionManagedByVKB;

*/

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

    : q_ptr(myHost),

      mCallback(0),

      mKeypad(0),

      mContainerWidget(new HbVkbHostContainerWidget(containerWidget)),

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

{

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

        }

        mContainerMovementStartingPoint = mContainerWidget->pos();

        mKeypadMovementStartingPoint = mKeypad->pos();

    }

    mScreenSize = screenSize();

}

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

{

        return false;

    }

        }

                }

                return true;

            }

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

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

    if (mKeypadStatus != HbVkbHost::HbVkbStatusClosed) {

        if (prepareAnimations(HbVkbHost::HbVkbStatusClosed)) {

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

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

        // 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::cancelAnimationAndHideVkbWidget()

{

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

        mTimeLine.stop();

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

    if (hbWidget) {

        return hbWidget->mainWindow();

    }

    // below is the case when we have a pure vanilla application.

    // there should be one hbmainwindow to show all the widgets.

    if (hbInstance->allMainWindows().size()) {

        return hbInstance->allMainWindows().at(0);

    }

    // no mainwindow.

    return 0;

}

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;