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

**

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

#include "hbinputmethod.h"

#include <QInputMethodEvent>

#include <QGraphicsView>

#include <QGraphicsScene>

#include <QGraphicsProxyWidget>

#include <QLocale>

#include <QClipboard>

#include <QPointer>

#include "hbinputmodecache_p.h"

#include "hbinputsettingproxy.h"

#include "hbinputcontextproxy_p.h"

#include "hbinputfilter.h"

#include "hbinputmethodnull_p.h"

#include "hbinpututils.h"

#include "hbinputstandardfilters.h"

#include "hbinputmainwindow_p.h"

#include "hbgraphicsscene.h"

#include <hbcssinspector_p.h>

#include <hbsettingswindow_p.h>

#if defined(Q_OS_SYMBIAN)

#include <coemain.h>

#include <coecntrl.h>

#include <e32cmn.h>

#endif

/// @cond

/*!

\internal

Destructs the object.

*/

HbInputMethodPrivate::~HbInputMethodPrivate()

{

    delete mFocusObject;

}

/*!

\internal

Returns input filter of the focused editor.

*/

HbInputFilter *HbInputMethodPrivate::editorFilter() const

{

    if (mFocusObject) {

        return mFocusObject->editorInterface().filter();

    }

    return 0;

}

/*!

\internal

Returns constraint flags of the focused editor.

*/

int HbInputMethodPrivate::editorConstraints() const

{

    if (mFocusObject) {

        return mFocusObject->editorInterface().inputConstraints();

    }

    return 0;

}

/*!

\internal

Reads input state information from focused editor using editor interface and creates a local copy of it.

Finds out correct values for those fields that have not been initialized by the client application.

*/

void HbInputMethodPrivate::inputStateFromEditor(HbInputState &result)

{

    if (mFocusObject) {

        HbEditorInterface &editorInterface = mFocusObject->editorInterface();

        editorInterface.lastFocusedState(result);

        if (result != HbInputState()) {

            // The editor has been focused before. Let's see if the input language has changed since the editor

            // was last focused.

            HbInputLanguage language = findStateLanguage();

            if (language != result.language()) {

                // Reconstruct the state since we don't know if the last one is valid for the new language.

                editorRootState(result);

                return;

            }

            // Keyboard may have changed since the last focus. Re-initialize it.

            result.setKeyboard(activeKeyboard());

            return;

        }

        // this editor has not been focused before, return the root state.

        editorRootState(result);

        // See if the editor prefers numeric mode when focused for the first time.

        Qt::InputMethodHints hints = mFocusObject->inputMethodHints();

        if (hints & Qt::ImhPreferNumbers) {

            result.setInputMode(HbInputModeNumeric);

        }

    } else {

        result = HbInputState();

    }

}

/*!

\internal

Transfers local copy of the input state back to the editor using editor interface.

*/

void HbInputMethodPrivate::inputStateToEditor(const HbInputState &source)

{

    if (mFocusObject) {

        mFocusObject->editorInterface().setLastFocusedState(source);

        mFocusObject->editorInterface().setMode(source.inputMode());

        mFocusObject->editorInterface().setTextCase(source.textCase());

    }

}

/*!

\internal

Returns input language for current input state. Ususally it is same as the global input language but

in case of latin only -editors it may be english if the global input language isn't valid for latin only -editors.

*/

HbInputLanguage HbInputMethodPrivate::activeLanguage() const

{

    HbInputLanguage ret = mInputState.language();

    if (ret.undefined()) {

    }

}

/*!

\internal

Returns true if given input mode is valid in focused editor.

*/

bool HbInputMethodPrivate::modeAllowedInEditor(HbInputModeType mode) const

{

    const int constraints = editorConstraints();

    if (mFocusObject &&

        mFocusObject->editorInterface().isNumericEditor() &&

        (mode & HbNumericModeMask) == 0) {

        // This is number only -editor but the proposed mode is not number mode, reject.

        return false;

    }

    if (constraints & HbEditorConstraintFixedInputMode) {

        if (!mFocusObject || mFocusObject->editorInterface().mode() != mode) {

            // This is fixed mode editor but proposed mode is something else.

            // Reject.

            return false;

        }

    }

    if ((constraints & HbEditorConstraintLatinAlphabetOnly) && (mode & HbChineseModeMask)) {

        // Editor is flagged to be latin-alphabet only but

        // the input mode indicates non-latin mode. Reject.

        return false;

    }

    return true;

}

/*!

\internal

Returns true if given state is valid in focused editor.

*/

bool HbInputMethodPrivate::stateAllowedInEditor(const HbInputState &state)

{

    if (!modeAllowedInEditor(state.inputMode())) {

        return false;

    }

        }

    }

    return true;

}

/*!

\internal

*/

HbInputMethod *HbInputMethodPrivate::findStateHandler(HbInputState &state)

{

    HbInputMethod *stateHandler = 0;

        }

        }

    }

    return stateHandler;

}

/*!

\internal

Returns input language for current input state. Ususally it is same as the global input language but

in case of latin only -editors it may be english if the global input language isn't valid for latin only -editors.

*/

HbInputLanguage HbInputMethodPrivate::findStateLanguage() const

{

    HbInputLanguage lang = HbInputSettingProxy::instance()->globalInputLanguage();

    if ((editorConstraints() & HbEditorConstraintLatinAlphabetOnly) &&

        !lang.isLatinAlphabetLanguage()) {

        // This is latin alphabet flagged editor, but the language isn't

        // latin alphabet language. Switch to english locally.

        lang = QLocale::English;

    }

    return lang;

}

/*!

\internal

Returns true if auto-capitalisation is needed in current cursor position.

*/

bool HbInputMethodPrivate::automaticTextCaseNeeded() const

{

    // If active keyboard is qwerty based and settings do not allow

    // automatic text case to be used with it, return false.

    if (mInputState.keyboard() & HbQwertyKeyboardMask

        && !HbInputSettingProxy::instance()->automaticTextCasingForQwerty()) {

        return false;

    }

    if (mFocusObject) {

        if (mFocusObject->inputMethodHints() & (Qt::ImhNoAutoUppercase | Qt::ImhPreferLowercase |

                                                Qt::ImhPreferUppercase | Qt::ImhDialableCharactersOnly | Qt::ImhEmailCharactersOnly | Qt::ImhUrlCharactersOnly)) {

            // Input method hint forbids auto-capitalisation or prefers either case.

            return false;

        }

        if (isFixedCaseEditor()) {

            // This is "uper case only" or "lower case only" editor. No automatic casing needed.

            return false;

        }

        if (mFocusObject->preEditString().size() > 0) {

            // If these is active word in inline edit state,

            // then for sure auto-casing is not needed.

            return false;

        }

        QString sText = mFocusObject->editorSurroundingText();

        int cursorPosition = mFocusObject->editorCursorPosition();

        if (cursorPosition >= 2) {

            QString previousChar = sText.mid(cursorPosition - 1, 1);

            QString previousToPreviousChar = sText.mid(cursorPosition - 2, 1);

            if (QString::compare(previousChar, " ") == 0) {

                if (QString::compare(previousToPreviousChar, ".") == 0) {

                    return true;

                }

                if (QString::compare(previousToPreviousChar, "!") == 0) {

                    return true;

                }

                if (QString::compare(previousToPreviousChar, "?") == 0) {

                    return true;

                }

            }

        } else if (cursorPosition == 0) {

            // when the cursor is at the beginning of the editor, auto-capitalisation is needed

            return true;

        }

    }

    return false;

}

/*!

\internal

Returns true if the concept of text case applies to current input language and input state.

*/

bool HbInputMethodPrivate::textCaseApplies() const

{

    HbInputLanguage language = activeLanguage();

    if (!language.isCaseSensitiveLanguage()) {

        return false;

    }

    if (!HbInputUtils::isCaseSensitiveMode(mInputState.inputMode())) {

        // Text case doesn't apply.

        return false;

    }

    return true;

}

/*!

\internal

Returns the active keyboard.

*/

HbKeyboardType HbInputMethodPrivate::activeKeyboard() const

{

}

/*!

\internal

Takes care of the part of focus in operation that is common to both QWidgets and QGraphicsWidgets.

*/

void HbInputMethodPrivate::setFocusCommon()

{

    Q_Q(HbInputMethod);

    if (mFocusObject &&

        !(mFocusObject->editorInterface().inputConstraints() & HbEditorConstraintIgnoreFocus)) {

        Qt::InputMethodHints hints = mFocusObject->inputMethodHints();

        if (hints & Qt::ImhDialableCharactersOnly) {

            setUpFocusedObjectAsPhoneNumberEditor();

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

            setUpFocusedObjectAsFormattedNumberEditor();

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

            setUpFocusedObjectAsDigitsOnlyEditor();

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

            setUpFocusedObjectAsUrlEditor();

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

            setUpFocusedObjectAsEmailEditor();

        }

        if (mFocusObject->editorInterface().editorClass() != HbInputEditorClassUnknown &&

            mFocusObject->editorInterface().extraDictionaryId() == 0) {

            // Editor class is set, but no dictionary id. Set it automatically here.

            mFocusObject->editorInterface().setExtraDictionaryId(mFocusObject->editorInterface().editorClass());

        }

    }

    // Create input state.

    inputStateFromEditor(mInputState);

    // Find state handler

    HbInputMethod *stateHandler = findStateHandler(mInputState);

    if (stateHandler == 0) {

        // No state handler found (this should never happen under normal circumstances).

        // Fall back to null method.

        stateHandler = HbInputMethodNull::Instance();

    }

    checkAndShowMainWindow();

    if (stateHandler != q_ptr) {

        // This method cannot handle requested input state. Switch to another one.

        contextSwitch(stateHandler);

        return;

    }

    // Deep copy possibly modified input state back to editor at this point.

    inputStateToEditor(mInputState);

    q->focusReceived();

    refreshState();

}

/*!

\internal

Refreshes input state. Stores local edit state back to the editor and calls child class' inputMethodActived method.

*/

void HbInputMethodPrivate::refreshState()

{

    Q_Q(HbInputMethod);

    inputStateToEditor(mInputState);

    q->inputStateActivated(mInputState);

}

/*!

\internal

Returns true if given focus object is same as currently focused or points to same editor instance.

*/

bool HbInputMethodPrivate::compareWithCurrentFocusObject(HbInputFocusObject *focusObject) const

{

    // both null pointer

    if (!mFocusObject) {

        return false;

    }

    if (!focusObject) {

        return false;

    }

    if (mFocusObject == focusObject) {

        return true;

    }

    return mFocusObject->object() == focusObject->object();

}

/*!

\internal

Creates and returns new input context proxy.

*/

QInputContext *HbInputMethodPrivate::proxy()

{

    if (!mProxy) {

        mProxy = new HbInputContextProxy(q_ptr);

    }

    return mProxy;

}

/*!

\internal

Returns true if currently focused editor is fixed text case editor.

*/

bool HbInputMethodPrivate::isFixedCaseEditor() const

{

    if (mFocusObject) {

        return (mFocusObject->inputMethodHints() & (Qt::ImhLowercaseOnly | Qt::ImhUppercaseOnly));

    }

    return false;

}

/*!

\internal

Returns true if focused editor is lower case -only editor.

*/

bool HbInputMethodPrivate::isLowerCaseOnlyEditor() const

{

    if (mFocusObject) {

        return (mFocusObject->inputMethodHints() & Qt::ImhLowercaseOnly);

    }

    return false;

}

/*!

\internal

Returns true if focused editor is upper case -only editor.

*/

bool HbInputMethodPrivate::isUpperCaseOnlyEditor() const

{

    if (mFocusObject) {

        return (mFocusObject->inputMethodHints() & Qt::ImhUppercaseOnly);

    }