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

**

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

#include <QGraphicsWidget>

#include <QGraphicsScene>

#include <QGraphicsProxyWidget>

#include <QLineEdit>

#include <QTextEdit>

#include <QPointer>

#include <QGraphicsView>

#include "hbinputmethod.h"

#include "hbinputeditorinterface.h"

#include "hbinputvkbhost.h"

#include "hbinputstandardfilters.h"

#include "hbinpututils.h"

#include "hbnamespace_p.h"

/*!

@alpha

@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 was added because

in some cases Qt's QInputMethodEvent/inputMethodQuery system is not enough and direct

access via type casting between QWidget and QGraphiscWidget based editors is needed.

Focus object hides those cases behind a convinience API.

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. It just wraps

most commonly used operations behind one API to avoid duplicate code.

Application developers should never need to use this class, it is for input method developers only.

\sa HbEditorInterface

*/

/// @cond

/*

This function ensures cursor visibility for known editor types.

*/

void ensureCursorVisible(QObject *widget)

{

    if (widget) {

        if (textEdit) {

            textEdit->ensureCursorVisible();

        }

    }

}

class HbInputFocusObjectPrivate

{

public:

    HbInputFocusObjectPrivate(QObject *focusedObject)

        : mFocusedObject(focusedObject),

          mEditorInterface(focusedObject)

    {}

public:

    QPointer<QObject> mFocusedObject;

    HbEditorInterface mEditorInterface;

    QString mPreEditString;

};

/// @endcond

HbInputFocusObject::HbInputFocusObject(QObject *focusedObject)

    : d_ptr(new HbInputFocusObjectPrivate(focusedObject))

{

}

HbInputFocusObject::~HbInputFocusObject()

{

    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.

*/

{

    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.

*/

{

    QList<QInputMethodEvent::Attribute> list;

    QInputMethodEvent event(QString(), list);

    event.setCommitString(string);

    sendEvent(event);

}

/*!

Sends given event to focused editor.

*/

{

    Q_D(HbInputFocusObject);

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

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

        } else {

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

        }

    }

    if (d->mFocusedObject) {

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

            QInputContext *ic = qApp->inputContext();

            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.

            ensureCursorVisible(d->mFocusedObject);

        } else {

            QInputContext *ic = qApp->inputContext();

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

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

            }

        }

    }

}

/*!

Posts given event to focused editor in an asynchronous manner.

*/

{

    Q_D(HbInputFocusObject);

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

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

        } else {

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

        }

    }

    if (d->mFocusedObject) {

        QApplication::postEvent(d->mFocusedObject, &event);

    }

}

/*!

Passes input method query to focused editor.

*/

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

{

    Q_D(const HbInputFocusObject);

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

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

    }

    // check if QWidget is embedded as a proxy in scene. If yes try to get details

    // from the scene.

    QGraphicsProxyWidget *pw = HbInputUtils::graphicsProxyWidget(widget);

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

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

    }

    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.

*/

{

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

    if (!graphicsObject) {

        if (widget) {

            if (!(graphicsObject = HbInputUtils::graphicsProxyWidget(widget))) {

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

    if (!graphicsObject) {

        if (widget) {

            // check if widget is inside a proxy.

            QGraphicsProxyWidget *pw = HbInputUtils::graphicsProxyWidget(widget);

            if (pw) {

                // check if we are pointing to the toplevel

                // proxy widget, if not then we must check for

                // the widgets window and see if it is a proxy.

                if (pw->widget() == widget) {

                    graphicsObject = pw;

                } else if (pw->widget() == widget->window()) {

                    // inside a proxy, query to proxy about

                    // the focused objects rect.

                    QRectF rect = pw->subWidgetRect(widget);

                    rect.translate(pw->scenePos());

                    return rect;

                }

            } 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

{

    return inputMethodQuery(Qt::ImMicroFocus).toRectF();

}

/*!

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

    if (!editorWidget) {

        if (widget) {

            editorWidget = HbInputUtils::graphicsProxyWidget(widget);

        }

    }

    if (editorWidget) {

        qreal result = editorWidget->zValue();

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

            result += parent->zValue();

        }

        result += HbPrivate::VKBValueUnit;

            return result;

        }

    }

    return 0.0;

}

/*!

Returns input method hints. See QWidget and QGraphicsItem documentation for more information.

*/

Qt::InputMethodHints HbInputFocusObject::inputMethodHints() const

{

    Q_D(const HbInputFocusObject);

    if (graphicsObject) {

        return graphicsObject->inputMethodHints();

    }

    if (widget) {

        return widget->inputMethodHints();

    }

    return Qt::ImhNone;

}

/*!

Sets input method hints. See QWidget and QGraphicsWidget documentation for more information.

*/

void HbInputFocusObject::setInputMethodHints(Qt::InputMethodHints hints)

{

    Q_D(HbInputFocusObject);

    if (graphicsObject) {

        graphicsObject->setInputMethodHints(hints);

        return;

    }

    if (widget) {

        widget->setInputMethodHints(hints);

    }

}

/*!

A convenience method for filtering strings. Uses filter attached to connected editor

and filters given string with it.

*/

{

    QString intermediate = source;

    // Chained two-pass filtering because this can be case-constrained editor with a filter.

    Qt::InputMethodHints hints = inputMethodHints();

    if (hints & Qt::ImhLowercaseOnly) {

        intermediate.clear();

        HbInputLowerCaseFilter::instance()->filterString(source, intermediate);

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

        intermediate.clear();

        HbInputUpperCaseFilter::instance()->filterString(source, intermediate);

    }

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

    if (filter) {

        filter->filterString(intermediate, result);

        return;

    }

    result = intermediate;

}

/*!

Returns true if given character is allowed in active editor.

*/

bool HbInputFocusObject::characterAllowedInEditor(QChar character) const

{

    // Two pass filtering, this can be case constrained editor with a filter.

    Qt::InputMethodHints hints = inputMethodHints();

    if (hints & Qt::ImhLowercaseOnly) {

        if (HbInputLowerCaseFilter::instance()->filter(character) == false) {

            return false;

        }

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

        if (HbInputUpperCaseFilter::instance()->filter(character) == false) {

            return false;

        }

    }

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

    if (filter) {

        return filter->filter(character);

    }

    return true;