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

**

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

#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 purely a convenience or helper type of class in nature. Everything

\sa HbEditorInterface

*/

/// @cond

*/

HbMainWindow *HbInputFocusObjectPrivate::mainWindow() const

{

    QGraphicsObject *graphicsObject = 0;

    // check for graphics view related widgets.

        } else {

            return HbInputMainWindow::instance();

        }

    } else {

    }

    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;

}

/// @endcond

HbInputFocusObject::HbInputFocusObject(QObject *focusedObject)

    : d_ptr(new HbInputFocusObjectPrivate(focusedObject))

{

    Q_D(HbInputFocusObject);

    d->q_ptr = this;

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

{

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

    }

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

        }

    }

        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.

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

        }

    }

    }

}

/*!

*/

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

{

    Q_D(const HbInputFocusObject);

    }

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

    if (!graphicsObject) {

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

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

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

    if (!editorWidget) {

        if (widget) {

        }

    }

    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;

}

/*!

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)

{