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

**

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

#include "hbinputfocusobject_p.h"

#include <QInputMethodEvent>

#include <QGraphicsObject>

#include <QGraphicsScene>

#include <QGraphicsProxyWidget>

#include <QLineEdit>

#include <QTextEdit>

#include "hbinputmethod.h"

#include "hbinputvkbhost.h"

#include "hbinputstandardfilters.h"

#include "hbdeviceprofile.h"

#include "hbnamespace_p.h"

#include "hbmainwindow.h"

#include "hbevent.h"

#include "hbwidget.h"

#include "hbinputmainwindow_p.h"

/*!

@hbcore

\class HbInputFocusObject

\brief A helper class for accessing editor widget in abstract way.

This class is input method side API for accessing editor widgets. It hides

the details of performing editor related operations, such as sending input

method events, querying editor geometry, querying editor attributes and so on.

It implements a collection of convenience methods for most commonly used

editor operations.

This class is purely a convenience or helper type of class in nature. Everything

it does, can be done directly in input method code as well. The benefit from using

this class is that an input method implementation doesn't need to care whether

the focused editor is QWidget or QGraphicsWidget based (or proxied QWidget).

Application developers typically do not need this class, it is for input method

developers only.

The active focus object can be accessed through HbInputMethod::focusObject()

method.

\sa HbEditorInterface

\sa HbInputMethod

*/

/// @cond

/*!

\internal

Returns main window in case the editor is QGraphicsObject based and lives

inside HbGraphicsScene.

*/

HbMainWindow *HbInputFocusObjectPrivate::mainWindow() const

{

    QGraphicsObject *graphicsObject = 0;

    // check for graphics view related widgets.

    if (mWidget) {

        if (mWidget->graphicsProxyWidget()) {

            graphicsObject = mWidget->graphicsProxyWidget();

        } else {

            return HbInputMainWindow::instance();

        }

    } else {

        graphicsObject = mGraphicsObject;

    }

    if (graphicsObject) {

        if (graphicsObject->scene()) {

            QList<QGraphicsView*> views = graphicsObject->scene()->views();

            foreach (QGraphicsView *view, views) {

                HbMainWindow *mainWindow = qobject_cast<HbMainWindow*>(view);

                if (mainWindow) {

                    return mainWindow;

                }

            }

            // not a HbMainWindow.

            return HbInputMainWindow::instance();

        }

    }

    return 0;

}

/*!

\internal

Ensures cursor visibility for known editor types.

*/

void HbInputFocusObjectPrivate::ensureCursorVisible(QObject *widget)

{

    if (widget) {

        QTextEdit *textEdit = qobject_cast<QTextEdit *>(widget);

        if (textEdit) {

            textEdit->ensureCursorVisible();

        }

    }

}

/// @endcond

HbInputFocusObject::HbInputFocusObject(QObject *focusedObject)

    : d_ptr(new HbInputFocusObjectPrivate(focusedObject))

{

    Q_D(HbInputFocusObject);

    d->q_ptr = this;

    if (focusedObject) {

        if (focusedObject->isWidgetType()) {

            d->mWidget = qobject_cast<QWidget*>(focusedObject);

        } else {

            QGraphicsProxyWidget *proxy = qobject_cast<QGraphicsProxyWidget*>(focusedObject);

            if (proxy) {

                d->mWidget = proxy->widget();

            } else {

                d->mGraphicsObject = qobject_cast<QGraphicsObject*>(focusedObject);

            }

        }

        HbEvent *event = new HbEvent(HbEvent::InputMethodFocusIn);

        QCoreApplication::sendEvent(focusedObject, event);

        delete event;

        HbMainWindow *mainWindow = d->mainWindow();

        if (mainWindow) {

            connect(mainWindow, SIGNAL(aboutToChangeOrientation()), this, SIGNAL(aboutToChangeOrientation()));

            connect(mainWindow, SIGNAL(orientationChanged(Qt::Orientation)), this, SIGNAL(orientationChanged()));

        }

    }

}

HbInputFocusObject::~HbInputFocusObject()

{

    QObject *obj = object();

    if (obj) {

        HbEvent *event = new HbEvent(HbEvent::InputMethodFocusOut);

        QCoreApplication::postEvent(obj, event);

    }

    delete d_ptr;

}

/*!

Creates an input method event where given string is a pre-edit string and sends

it to focused editor. See QInputMethodEvent for more information on pre-edit strings.

*/

void HbInputFocusObject::sendPreEditString(const QString &string)

{

    QList<QInputMethodEvent::Attribute> list;

    QInputMethodEvent event(string, list);

    sendEvent(event);

}

/*!

Creates an input method event where given string is a commit string and sends

it to focused editor. See QInputMethodEvent for more information on commit strings.

*/

void HbInputFocusObject::sendCommitString(const QString &string)

{

    QList<QInputMethodEvent::Attribute> list;

    QInputMethodEvent event(QString(), list);

    event.setCommitString(string);

    sendEvent(event);

}

/*!

Sends given event to focused editor.

*/

void HbInputFocusObject::sendEvent(QEvent &event)

{

    Q_D(HbInputFocusObject);

    if (event.type() == QEvent::InputMethod) {

        QInputMethodEvent *imEvent = static_cast<QInputMethodEvent *>(&event);

        if (imEvent->commitString().size() > 0) {

            d->mPreEditString.clear();

        } else {

            d->mPreEditString = imEvent->preeditString();

        }

    }

    QObject *obj = object();

    if (obj) {

        if (event.type() == QEvent::InputMethod) {

            QInputContext *ic = qApp->inputContext();

            QInputMethodEvent *imEvent = static_cast<QInputMethodEvent *>(&event);

            if (ic) {

                ic->sendEvent(*imEvent);

            }

            // Currently in Qt, QTextEdit doesn't ensure cursor visibility

            // in case we are sending text in the form of QInputMethodEvent. So we need

            // to call QTextEdit:ensureCursorVisible() here till we get a fix from Qt.

            d->ensureCursorVisible(obj);

        } else {

            QInputContext *ic = qApp->inputContext();

            if (ic && ic->focusWidget()) {

                QApplication::sendEvent(ic->focusWidget(), &event);

            }

        }

    }

}

/*!

Posts given event to focused editor in an asynchronous manner.

*/

void HbInputFocusObject::postEvent(QEvent &event)

{

    Q_D(HbInputFocusObject);

    if (event.type() == QEvent::InputMethod) {

        QInputMethodEvent *imEvent = static_cast<QInputMethodEvent *>(&event);

        if (imEvent->commitString().size() > 0) {

            d->mPreEditString.clear();

        } else {

            d->mPreEditString = imEvent->preeditString();

        }

    }

    QObject *obj = object();

    if (obj) {

        QApplication::postEvent(obj, &event);

    }

}

/*!

Passes input method query to focused editor widget.

*/

QVariant HbInputFocusObject::inputMethodQuery(Qt::InputMethodQuery query) const

{

    Q_D(const HbInputFocusObject);

    QGraphicsObject *graphicsObject = d->mGraphicsObject;

    if (graphicsObject) {

        if (graphicsObject->scene()) {

            return graphicsObject->scene()->inputMethodQuery(query);

        }

        return QVariant();

    }

    QWidget *widget = d->mWidget;

    if (widget) {

        // QWidget returns microfocus in local coordinate.

        // we need to map it to global coordinate.

        QVariant v = widget->inputMethodQuery(query);

        if (v.type() == QVariant::Rect) {

            v = v.toRect().translated(widget->mapToGlobal(QPoint(0, 0)));

        }

        return v;

    }

    return QVariant();

}

/*!

Returns editor cursor position by sending Qt::ImCursorPosition event to it.

*/

int HbInputFocusObject::editorCursorPosition()

{

    return inputMethodQuery(Qt::ImCursorPosition).toInt();

}

/*!

Returns editor's font by sending Qt::ImFont input method query to it.

*/

QFont HbInputFocusObject::editorFont()

{

    return inputMethodQuery(Qt::ImFont).value<QFont>();

}

/*!

Returns text selection by sending Qt::ImCurrentTextSelection to editor.

*/

QString HbInputFocusObject::editorTextSelection()

{

    return inputMethodQuery(Qt::ImCurrentSelection).toString();

}

/*!

Returns text surrounding the editor cursor position by sending Qt::ImSurroundingText event to editor.

*/

QString HbInputFocusObject::editorSurroundingText()

{

    return inputMethodQuery(Qt::ImSurroundingText).toString();

}

/*!

Returns editor interface object pointing to focused editor.

*/

HbEditorInterface &HbInputFocusObject::editorInterface() const

{

    return d_ptr->mEditorInterface;

}

/*!

Sends left arrow key press to focused editor.

*/

void HbInputFocusObject::cursorLeft(Qt::KeyboardModifiers modifiers)

{

    QKeyEvent keyEvent(QEvent::KeyPress, Qt::Key_Left, modifiers);

    sendEvent(keyEvent);

}

/*!

Sends right arrow key press to focused editor.

*/

void HbInputFocusObject::cursorRight(Qt::KeyboardModifiers modifiers)

{

    QKeyEvent keyEvent(QEvent::KeyPress, Qt::Key_Right, modifiers);

    sendEvent(keyEvent);

}

/*!

Removes focus from the editor.

*/

void HbInputFocusObject::releaseFocus()

{

    Q_D(HbInputFocusObject);

    QGraphicsObject *graphicsObject = d->mGraphicsObject;

    if (!graphicsObject) {

        QWidget *widget = d->mWidget;

        if (widget) {

            if (widget->graphicsProxyWidget()) {

                graphicsObject = widget->graphicsProxyWidget();

            } else {

                widget->clearFocus();

                return;

            }

        }

    }

    if (graphicsObject && graphicsObject->scene()) {

        graphicsObject->scene()->setFocusItem(0);

    }

}

/*!

Runs the given character through active input filter and commits it if it was accepted.

Returns true if the character was accepted.

*/

bool HbInputFocusObject::filterAndCommitCharacter(QChar character)

{

    // Two pass filtering because this may be a case constrained editor

    // with a filter.

    Qt::InputMethodHints hints = inputMethodHints();

    if (hints & Qt::ImhLowercaseOnly) {

        if (!HbInputLowerCaseFilter::instance()->filter(character)) {

            return false;

        }

    } else if (hints & Qt::ImhUppercaseOnly) {

        if (!HbInputUpperCaseFilter::instance()->filter(character)) {

            return false;

        }

    }

    HbInputFilter *filter = editorInterface().filter();

    if (filter) {

        if (!filter->filter(character)) {

            return false;

        }

    }

    QString cString;

    cString.append(character);

    sendCommitString(cString);

    return true;

}

/*!

Returns editor widget geometry. In case of QGraphicsObject, the returned value is in scene coordinates.

*/

QRectF HbInputFocusObject::editorGeometry() const

{

    Q_D(const HbInputFocusObject);

    QGraphicsObject *graphicsObject = d->mGraphicsObject;

    if (!graphicsObject) {

        QWidget *widget = d->mWidget;

        if (widget) {

            // Check if widget is inside a proxy.

            QGraphicsProxyWidget *pw = widget->graphicsProxyWidget();

            if (pw) {

                graphicsObject = pw;

            } else {

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

            }

        }

    }

    if (graphicsObject) {

        return QRectF(graphicsObject->scenePos(), graphicsObject->boundingRect().size());

    }

    return QRectF();

}

/*!

Returns cursor micro focus by sending Qt::ImMicroFocus to focused editor.

In case of QGraphicsObject, the returned rectangle is in scene coordinates.

*/

QRectF HbInputFocusObject::microFocus() const

{

    Q_D(const HbInputFocusObject);

    QRectF rect = inputMethodQuery(Qt::ImMicroFocus).toRectF();

    QGraphicsObject *editorWidget = d->mGraphicsObject;

    if (editorWidget) {

        rect = editorWidget->mapRectToScene(rect);

    }

    return rect;

}

/*!

Returns active pre-edit string. Note that this method works only if the pre-edit

string was set by using this class.

*/

QString HbInputFocusObject::preEditString() const

{

    Q_D(const HbInputFocusObject);

    return d->mPreEditString;

}

/*!

Returns the Z-value that should be used with virtual keyboard widget. Usually only HbVkbHost

needs this value.

*/

qreal HbInputFocusObject::findVkbZValue() const

{

    Q_D(const HbInputFocusObject);

    QGraphicsObject *editorWidget = d->mGraphicsObject;

    if (!editorWidget) {

        QWidget *widget = d->mWidget;

        if (widget) {

            editorWidget = widget->graphicsProxyWidget();

        }

    }

    if (editorWidget) {

        qreal result = editorWidget->zValue();

        for (QGraphicsObject *parent = editorWidget->parentObject(); parent; parent = parent->parentObject()) {

            result += parent->zValue();

        }

        result += HbPrivate::VKBValueUnit;

        if (result >= 0) {

            return result;

        }

    }

    return 0.0;

}

/*!