FCL/sf/mw/hb: comparison src/hbcore/inputfw/hbinputmethod.cpp

equal deleted inserted replaced

-:627c4a0fd0e7
+:c3690ec91ef8
 **
 ** If you have questions regarding the use of this file, please contact
 ** Nokia at developer.feedback@nokia.com.
 **
 ****************************************************************************/
+#include "hbinputmethod.h"
+#include "hbinputmethod_p.h"
 #include <QInputMethodEvent>
 #include <QGraphicsView>
 #include <QGraphicsProxyWidget>
 #include <QLocale>
-#include "hbinputmethod.h"
-#include "hbinputmethod_p.h"
 #include "hbinputmodecache_p.h"
 #include "hbinputsettingproxy.h"
 #include "hbinputcontextproxy_p.h"
 #include "hbinputfilter.h"
 #include "hbinputmethodnull_p.h"
 #include "hbinputpredictionfactory.h"
 #include "hbinputextradictionaryfactory.h"
 #include "hbinputstandardfilters.h"
 #include "hbinpututils.h"
 #include "hbinputvkbhost.h"
+#include "hbinputvkbhostbridge.h"
 /*!
 @alpha
 @hbcore
 \class HbInputMethod
 }
 /*!
 Initializes the input framework.
 */
-bool HbInputMethod::initializeFramework(QApplication& app)
+bool HbInputMethod::initializeFramework(QApplication &app)
 {
 // Activate singleton shutdown.
 connect(&app, SIGNAL(aboutToQuit()), HbInputModeCache::instance(), SLOT(shutdown()));
 connect(&app, SIGNAL(aboutToQuit()), HbInputSettingProxy::instance(), SLOT(shutdown()));
 connect(&app, SIGNAL(aboutToQuit()), HbPredictionFactory::instance(), SLOT(shutDown()));
 }
 master->d_ptr->mIsActive = true;
 // Finally set application input context.
-QInputContext* proxy = master->d_ptr->proxy();
+QInputContext *proxy = master->d_ptr->proxy();
 // A check required so that Qt does not delete inputcontext
 // which we are passing.
-if (proxy != app.inputContext())
+if (proxy != app.inputContext()) {
 app.setInputContext(proxy);
+}
 return true;
 }
 /*!
 Returns the active instance of HbInputMethod. There is always active HbInputMethod instance after
 InitializeFramework method has been called, even when there is no focused editor (in some cases it may
 be so called null input method).
 */
-HbInputMethod* HbInputMethod::activeInputMethod()
+HbInputMethod *HbInputMethod::activeInputMethod()
 {
 // First try, try app input context directly. It is possible that it is an instance
 // of HbInputMethod that is installed directly there without framework knowing about it
 // (that shouldn't be done, but it is possible). That's why we rely on app input context as
 // a primary source instead of mode cache.
-QInputContext* context = qApp->inputContext();
+QInputContext *context = qApp->inputContext();
 if (context && context->inherits("HbInputMethod")) {
-HbInputMethod* active = static_cast<HbInputMethod*>(context);
+HbInputMethod *active = static_cast<HbInputMethod *>(context);
 return active;
 }
 // Then check if the 'null' is active.
-HbInputMethod* nullInstance = HbInputMethodNull::Instance();
+HbInputMethod *nullInstance = HbInputMethodNull::Instance();
 if (nullInstance && nullInstance->isActiveMethod()) {
 return nullInstance;
 }
 // No it wasn't, then go through the methods in the cache and see which one is
 */
 bool HbInputMethod::activateInputMethod(const HbInputMethodDescriptor &inputMethod)
 {
 Q_D(HbInputMethod);
 if (!inputMethod.isEmpty()) {
 if (inputMethod.isDefault()) {
 d->setFocusCommon();
 return true;
 } else {
 HbInputMethod *customMethod = HbInputModeCache::instance()->loadInputMethod(inputMethod);
 if (customMethod) {
 d->contextSwitch(customMethod);
 return true;
 }
 }
 }
 return false;
 }
 This slot is connected to the setting proxy activeKeyboard attribute. It will
 activate proper state when the signal is received.
 */
 void HbInputMethod::activeKeyboardChanged(HbKeyboardType newKeyboard)
 {
-if (!isActiveMethod()) {
+if (!isActiveMethod() || !HbInputSettingProxy::instance()->orientationChangeCompleted()) {
 return;
 }
 Q_D(HbInputMethod);
 d->mInputState.setKeyboard(newKeyboard);
-HbInputMethod* stateHandler = d->findStateHandler(d->mInputState);
+HbInputMethod *stateHandler = d->findStateHandler(d->mInputState);
 if (stateHandler) {
 d->inputStateToEditor(d->mInputState);
 if (stateHandler != this) {
 // Context switch needed.
 d->contextSwitch(stateHandler);
 }
 /*!
 Returns pointer to active focus object.
 */
-HbInputFocusObject* HbInputMethod::focusObject() const
+HbInputFocusObject *HbInputMethod::focusObject() const
 {
 Q_D(const HbInputMethod);
 return d->mFocusObject;
 }
 default focus handling mechanism for QInputContext system. Input method
 implementation should never override this method unless it knows what it is doing.
 \sa setFocusObject
 */
-void HbInputMethod::setFocusWidget(QWidget* widget)
+void HbInputMethod::setFocusWidget(QWidget *widget)
 {
 Q_D(HbInputMethod);
 if (d->mFocusLocked) {
-	    return;
+return;
-	}
+}
 // attach focuswidget to prxoy inputcontext as proxy is
 // the only inputcotext known to qt framework.
 d->proxy()->QInputContext::setFocusWidget(widget);
 if (!widget) {
 // Losing focus.
 if (d->mFocusObject) {
 focusLost(false);
 d->hideMainWindow();
 d->mFocusObject = 0;
 }
 return;
 }
-QGraphicsView* gView = qobject_cast<QGraphicsView*>(widget);
+QGraphicsView *gView = qobject_cast<QGraphicsView *>(widget);
 if (gView) {
 // We don't want to focus to graphics view but the items inside the scene, so just return
 return;
 }
 delete d->mFocusObject;
 d->mFocusObject = 0;
 // Attach focus.
 d->mFocusObject = new HbInputFocusObject(widget);
-connect(widget, SIGNAL(destroyed(QObject*)), this, SLOT(editorDeleted(QObject*)));
+connect(widget, SIGNAL(destroyed(QObject *)), this, SLOT(editorDeleted(QObject *)));
 d->setFocusCommon();
 // The focus jumped from one editor to another. Make sure that vkb host
 // updates the situation correctly.
 /*!
 Checks if the destroyed widget is currently focused and clears the focus
 if needed. This method should not be overridden.
 */
-void HbInputMethod::widgetDestroyed(QWidget* widget)
+void HbInputMethod::widgetDestroyed(QWidget *widget)
 {
 Q_D(HbInputMethod);
 if (d->mFocusObject && d->mFocusObject->object() == widget) {
 delete d->mFocusObject;
 requestSoftwareInputPanel event.
 \sa setFocusWidget
 \sa HbInputFocusObject
 */
-void HbInputMethod::setFocusObject(HbInputFocusObject* focusObject)
+void HbInputMethod::setFocusObject(HbInputFocusObject *focusObject)
 {
 Q_D(HbInputMethod);
 if (d->mFocusLocked) {
 return;
 }
 if (focusObject == 0) {
 // Losing focus.
 if (d->mFocusObject != 0) {
-disconnect(d->mFocusObject->object(), SIGNAL(destroyed(QObject*)), this, SLOT(editorDeleted(QObject*)));
+disconnect(d->mFocusObject->object(), SIGNAL(destroyed(QObject *)), this, SLOT(editorDeleted(QObject *)));
 focusLost(false);
 d->hideMainWindow();
 delete d->mFocusObject;
 d->mFocusObject = 0;
 }
 return;
 }
-if(d->compareWithCurrentFocusObject( focusObject )) {
+if (d->compareWithCurrentFocusObject(focusObject)) {
 // The incoming focus object is either same or points to same
 // widget that the framework is already focused to and nothing needs to be done here.
 // But because the ownership of the focus object is transferred to the
 // the framework, we need to delete the the incoming focus object in case it is
 // dirrefent than current one.
 if (d->mFocusObject != focusObject) {
 // Delete previous focus object.
 if (d->mFocusObject) {
 refreshHost = true;
 focusLost(true);
-disconnect(d->mFocusObject->object(), SIGNAL(destroyed(QObject*)), this, SLOT(editorDeleted(QObject*)));
+disconnect(d->mFocusObject->object(), SIGNAL(destroyed(QObject *)), this, SLOT(editorDeleted(QObject *)));
 delete d->mFocusObject;
 d->mFocusObject = 0;
 }
 // Attach focus.
 d->mFocusObject = focusObject;
-connect(d->mFocusObject->object(), SIGNAL(destroyed(QObject*)), this, SLOT(editorDeleted(QObject*)));
+connect(d->mFocusObject->object(), SIGNAL(destroyed(QObject *)), this, SLOT(editorDeleted(QObject *)));
 d->setFocusCommon();
 // The focus jumped from one editor to another. Make sure that vkb host
 // updates the situation correctly.
 /*!
 The framework calls this method every time the input state changes. This is an empty default
 implementation and the inheriting class should override it.
 */
-void HbInputMethod::inputStateActivated(const HbInputState& newState)
+void HbInputMethod::inputStateActivated(const HbInputState &newState)
 {
 Q_UNUSED(newState);
 // Empty default implementation.
 if (this != HbInputMethodNull::Instance()) {
 qWarning("WARNING: inputStateActivated() default implementation called: Is that ok?");
 instance may occur.
 \sa activateNextState
 \sa InputState
 */
-bool HbInputMethod::activateState(const HbInputState& state)
+bool HbInputMethod::activateState(const HbInputState &state)
 {
 Q_D(HbInputMethod);
 if (!d->stateAllowedInEditor(state)) {
 return false;
 }
 d->mStateChangeInProgress = true;
-HbInputMethod* stateHandler = HbInputModeCache::instance()->findStateHandler(state);
+HbInputMethod *stateHandler = HbInputModeCache::instance()->findStateHandler(state);
 if (!stateHandler) {
 stateHandler = HbInputMethodNull::Instance();
 }
 if (currentTextCase == HbTextCaseAutomatic) {
 if (!autoCaseNeeded) {
 currentTextCase = HbTextCaseLower;
 refresh = true;
 }
-} else if (autoCaseNeeded && currentTextCase != HbTextCaseUpper ) {
+} else if (autoCaseNeeded && currentTextCase != HbTextCaseUpper) {
 if (!d->isFixedCaseEditor()) {
 currentTextCase = HbTextCaseAutomatic;
 refresh = true;
 } else {
 return;
 Receives the screen orientation signal. Will determine correct input state for new
 orientation and find state handler for it.
 */
 void HbInputMethod::orientationChanged(Qt::Orientation orientation)
 {
+Q_D(HbInputMethod);
 Q_UNUSED(orientation);
-if (isActiveMethod()) {
+if (d->mOldFocusObject) {
-// Make sure that if there was an editor focus before the orientation change,
+setFocusObject(d->mOldFocusObject);
-// it will re-focus.
+d->mOldFocusObject = 0;
-QInputContext *ic = qApp->inputContext();
+}
-if (ic) {
-QEvent *event = new QEvent(QEvent::RequestSoftwareInputPanel);
-ic->filterEvent(event);
-delete event;
-}
-}
 }
 /*!
 This slot is connected to setting proxy's orientation change warning signal. The default
 base class implementation is empty.
 \sa HbInputSettingProxy
 */
 void HbInputMethod::orientationAboutToChange()
 {
+Q_D(HbInputMethod);
+reset();
+d->inputStateToEditor(d->mInputState);
+if (d->mFocusObject) {
+d->mOldFocusObject = d->mFocusObject;
+d->mFocusObject = 0;
+}
+HbVkbHostBridge::instance()->closeKeypad(true);
 }
 /*!
 Returns active input language. Unlike setting proxy's global input language,
 this method takes into account input state language and possible editor local language,
 }
 \endcode
 */
 void HbInputMethod::forceUnfocus()
 {
-HbInputMethod* active = activeInputMethod();
+HbInputMethod *active = activeInputMethod();
 if (active) {
 active->focusLost(false);
 delete active->d_ptr->mFocusObject;
 active->d_ptr->mFocusObject = 0;
 }
 }
 }
 /*!
 Deep copies the input state back to editor interface.
 */
-void HbInputMethod::inputStateToEditor(const HbInputState& source)
+void HbInputMethod::inputStateToEditor(const HbInputState &source)
 {
 Q_D(HbInputMethod);
 d->inputStateToEditor(source);
 }
 {
 Q_D(HbInputMethod);
 Q_UNUSED(obj);
 focusLost();
-	d->hideMainWindow();
+d->hideMainWindow();
 delete d->mFocusObject;
 d->mFocusObject = 0;
 reset();
 }

changeset 6	c3690ec91ef8
parent 5	627c4a0fd0e7
child 7	923ff622b8b9