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

equal deleted inserted replaced

-:16d8024aca5e
+:f7ac710697a9
 #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"
 /*!
 @hbcore
 \class HbInputMethod
 \brief A base class for input method implementations.
 HbInputMethod is the base class for input method implementations. It inherits from QInputContext,
-connects to the input framework behind the scenes and provides focusing and other framework level
+connects to the input framework behind the scenes and resolves correct input state handler when
-services.
+an editor widget is focused.
-An internal framework class called HbInputModeCache scans through the system and looks for available HbInputMethod instances. It then forms a list of available input methods based on language
+An internal framework class called HbInputModeCache scans through the system and looks for
-and keyboard type. Input method plugin reports (on plugin level, as meta-data) which languages, keyboards and input modes that input method instance supports. Input mode cache then activates suitable
+available HbInputMethod instances. It then forms a list of input methods based on language
-input method depending on the situation. It can also switch active input method on the fly
+and keyboard type. Input method plugin reports (as plugin meta-data) which languages,
-when the focus switches between editors and the previously active input method is unable to
+keyboards and input modes that plugin instance implements. Input mode cache then activates matching
+HbInputMethod depending on the editor properties. It switches the active input method on the fly
+when the focus switches between editors if the previous input method is unable to
 support newly focused editor.
 Custom input methods are a special class of input methods. Once a custom input method is
-activated from UI, input mode cache stops resolving suitable input methods upon focus operations
+activated from UI, input mode cache stops resolving input methods upon focus operations
-and the custom input is ative in all editors until it is deactivated.
+and the custom input is active in all editors until it is deactivated.
 Following is the basic input framework program flow:
 1. An editor gains input focus.
 2  Input mode cache resolves correct mode handler and activates it.
 3. A virtual function HbInputMethod::focusReceived is called. At this point the input method
 initializes whatever it needs to initialize in order to start the input operation (for example,
 opens the virtual keyboard by using HbVkbHost API) and waits for user actions.
 4. Text is written. The input method delivers results to the editor buffer by using HbInputFocusObject API.
 It can access editor attributes via HbEditorInterface API.
 5. The active editor loses focus. At this point the input method receives a call to virtual function
 HbInputMethod::focusLost and is expected to conclude any ongoing input operations and shut down active
 UI elements (such as the virtual keyboard).
 6. The input method waits for next focusReceived() call.
 \sa QInputContext
 \sa HbInputFocusObject
 \sa HbEditorInterface
 /*!
 Constructs the object
 */
 HbInputMethod::HbInputMethod() : d_ptr(new HbInputMethodPrivate(this))
 {
 HbInputSettingProxy::instance()->connectObservingObject(this);
 }
 /*!
 Destructs the object
 */
 delete d_ptr;
 }
 /*!
-Initializes the HbInputs framework. Each Qt application needs to call this
+Initializes the input framework.
-method once in order to connect to the HbInputs framework.
 */
 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()));
+connect(&app, SIGNAL(aboutToQuit()), HbExtraDictionaryFactory::instance(), SLOT(shutdown()));
 HbInputMethod *master = HbInputMethodNull::Instance();
 if (!master) {
 return false;
 return true;
 }
 /*!
-Returns active instance of HbInputMethod. There is always active HbInputMethod instance after
+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). Normally this method is needed only for special cases, such as developing
+be so called null input method).
-and debugging framework level code, but it is made public for convenience.
 */
 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
 {
 return HbInputModeCache::instance()->listCustomInputMethods();
 }
 /*!
-Activates given input method. input context is
+Activates given input method. Input context is
 switched to custom method. Returns false if input method was not found
 or the framework was not able to activate it.
 */
 bool HbInputMethod::activateInputMethod(const HbInputMethodDescriptor &inputMethod)
 {
 }
 return false;
 }
 /*!
 This slot is called when the input language changes. The framework connects it
 to the input setting proxy. When the signal is received, the input method implementation
 is notified by calling inputLanguageChanged.
 \sa inputLanguageChanged
 \sa HbInputSettingProxy
 */
 void HbInputMethod::globalInputLanguageChanged(const HbInputLanguage &newLanguage)
 {
 Q_D(HbInputMethod);
 inputLanguageChanged(newLanguage);
 if (!isActiveMethod()) {
 // Notify non-active input methods of language change, but check
 // if the method has promised to handle the new language only
 // in the active method
 return;
 }
 // Just behave as if this was the first focus operation
 // to this editor.
 if (d->mFocusObject) {
 HbInputState state;
 editorRootState(state);
 activateState(state);
 }
 }
 /*!
 is notified by calling secondaryInputLanguageChanged.
 \sa secondaryInputLanguageChanged
 \sa HbInputSettingProxy
 */
-void HbInputMethod::globalSecondaryInputLanguageChanged(const HbInputLanguage &aNewLanguage)
+void HbInputMethod::globalSecondaryInputLanguageChanged(const HbInputLanguage &newLanguage)
 {
-secondaryInputLanguageChanged(aNewLanguage);
+secondaryInputLanguageChanged(newLanguage);
 }
 /*!
-This slot is connected to the setting proxy hw keyboard attribute. It will
+\deprecated HbInputMethod::activeHwKeyboardChanged(HbKeyboardType)
-do refreshState() when the signal is received.
+is deprecated.
 */
 void HbInputMethod::activeHwKeyboardChanged(HbKeyboardType newKeyboard)
 {
 Q_UNUSED(newKeyboard);
 Q_D(HbInputMethod);
 // ...
 d->refreshState();
 }
 /*!
-This slot is connected to the setting proxy touch keyboard attribute. It will
+\deprecated HbInputMethod::activeTouchKeyboardChanged(HbKeyboardType)
-do refreshState() when the signal is received.
+is deprecated.
 */
 void HbInputMethod::activeTouchKeyboardChanged(HbKeyboardType newKeyboard)
 {
 Q_UNUSED(newKeyboard);
 Q_D(HbInputMethod);
 d->refreshState();
 }
 /*!
 This slot is connected to the setting proxy activeKeyboard attribute. It will
 activate proper state when the signal is received.
 */
 if (!isActiveMethod()) {
 return;
 }
 Q_D(HbInputMethod);
 d->mInputState.setKeyboard(newKeyboard);
 HbInputMethod* stateHandler = d->findStateHandler(d->mInputState);
 if (stateHandler) {
 d->inputStateToEditor(d->mInputState);
 if (stateHandler != this) {
 // Context switch needed.
 d->contextSwitch(stateHandler);
 }
 }
 }
 /*!
-This slot is called when the predictive input state changes. The framework connects it
+\deprecated HbInputMethod::predictiveInputStateChanged(int newStatus)
-to the input setting proxy. When the signal is received, the input method implementation
+is deprecated.
-is notified by calling predictiveInputStatusChanged.
-\sa predictiveInputStatusChanged
-\sa HbInputSettingProxy
 */
 void HbInputMethod::predictiveInputStateChanged(int newStatus)
 {
-// Do here whatever needs to be done on HbInputMethod level, then
+Q_UNUSED(newStatus);
-// call virtual predictiveInputStatusChanged() in case plugin needs to do something.
+}
-// ...
+/*!
-predictiveInputStatusChanged(newStatus);
+\deprecated HbInputMethod::predictiveInputStateChanged(HbKeyboardSettingFlags, bool)
+is deprecated.
+*/
+void HbInputMethod::predictiveInputStateChanged(HbKeyboardSettingFlags keyboardType, bool newState)
+{
+Q_UNUSED(keyboardType);
+Q_UNUSED(newState);
 }
 /*!
 The framework calls this method when an input capable widget receives UI focus. This is empty
 default implementation and the inheriting class should override it.
 QInputContext::setFocusWidget(widget);
 if (!widget) {
 // Losing focus.
 if (d->mFocusObject) {
 focusLost(false);
 delete d->mFocusObject;
 d->mFocusObject = 0;
 }
 return;
 if (d->mFocusObject) {
 focusLost();
 }
 return;
 }
 if (d->mFocusObject) {
 if (d->mFocusObject->object() == widget) {
 // Focus remains in same widget, do nothing.
 return;
 } else {
 releaseFocus();
 }
 }
 /*!
-Checks if the destroyed object is currently focused and clears the focus
+\deprecated HbInputMethod::focusObjectDestroyed(const HbInputFocusObject*)
-if needed.
+is deprecated.
-\sa widgetDestroyed
 */
 void HbInputMethod::focusObjectDestroyed(const HbInputFocusObject* focusObject)
 {
 Q_D(HbInputMethod);
 }
 /*!
 Graphics item based editors (or any other object that implements
 HbInputFocusObject) send their focus events notifications through this method.
-Since Qt's QInputContext mechanism works only with QWidget based editors,
-this alternate focus channel is needed for objects belonging to a graphics scene
+Typically this method is called by HbInputContextProxy when it receives
-(in case of a graphics scene, the topmost QWidget that has focus is
+requestSoftwareInputPanel event.
-graphics view, not the the object inside the view). The ownership of
-incoming focus object is transferred to the input framework.
 \sa setFocusWidget
 \sa HbInputFocusObject
 */
 void HbInputMethod::setFocusObject(HbInputFocusObject* focusObject)
 if (d->mFocusObject != focusObject) {
 delete focusObject;
 }
 return;
 }
 bool refreshHost = false;
 // Delete previous focus object.
 if (d->mFocusObject) {
 refreshHost = true;
 }
 }
 }
 /*!
-The secondary channel uses this slot for inserting text active editor.
+\deprecated HbInputMethod::receiveText(const QString&)
+is deprecated.
 */
 void HbInputMethod::receiveText(const QString& string)
 {
-Q_D(HbInputMethod);
+Q_UNUSED(string);
+}
-if (isActiveMethod() && d->mFocusObject &&
-(d->editorConstraints() & HbEditorConstraintsNoSecondaryChannel) == 0) {
+/*!
-QList<QInputMethodEvent::Attribute> list;
+\deprecated HbInputMethod::candidatePopupClosed(int closingKey)
-QInputMethodEvent event(QString(), list);
+is deprecated.
-event.setCommitString(string);
-d->mFocusObject->sendEvent(event);
-}
-}
-/*!
-This slot is called when the candidate list popup is closed. The base
-class implementation is empty so any input method interested in
-candidate list close event should implement it.
 */
 void HbInputMethod::candidatePopupClosed(int closingKey)
 {
 Q_UNUSED(closingKey);
 // Empty default implementation
 // Empty default implementation.
 Q_UNUSED(aNewLanguage);
 }
 /*!
-The framework calls this method when the predictive input status changes.
+\deprecated HbInputMethod::predictiveInputStatusChanged(int newStatus)
-The base class implementation is empty so any input method interested in
+is deprecated.
-prediction status events should implement it.
 */
 void HbInputMethod::predictiveInputStatusChanged(int newStatus)
 {
 Q_UNUSED(newStatus);
 // Empty default implementation.
 void HbInputMethod::inputStateActivated(const HbInputState& newState)
 {
 Q_UNUSED(newState);
 // Empty default implementation.
 if (this != HbInputMethodNull::Instance()) {
-qDebug("WARNING: inputStateActivated() default implementation called: Is that ok?");
+qWarning("WARNING: inputStateActivated() default implementation called: Is that ok?");
 }
 }
 /*!
 Returns active input state.
 Q_D(const HbInputMethod);
 return d->mInputState;
 }
 /*!
 Returns the first input state that should be activated when an editor is
 focused for the first time. The state is constructed from edirtor attributes and
 input settings.
 */
 void HbInputMethod::editorRootState(HbInputState &result) const
 {
 stateHandler = HbInputMethodNull::Instance();
 }
 d->mInputState = state;
 if (stateHandler != this) {
 stateHandler->d_ptr->mStateChangeInProgress = true;
 // Context switch needed.
 d->inputStateToEditor(d->mInputState);
 d->contextSwitch(stateHandler);
 stateHandler->d_ptr->mStateChangeInProgress = false;
 } else {
 // Same method handles new state, just report the state change.
 d->inputStateToEditor(d->mInputState);
 inputStateActivated(d->mInputState);
 }
 inputStateActivated(d->mInputState);
 }
 }
 /*!
-Clears focus state from input method side. After calling this method,
+\deprecated HbInputMethod::releaseFocus()
-HbInputMethod instance thinks that it is not focused to any widget.
+is deprecated.
-The widget itself still remain focused to this input context.
 */
 void HbInputMethod::releaseFocus()
 {
 Q_D(HbInputMethod);
 if (active) {
 active->focusLost(false);
 active->releaseFocus();
 delete active->d_ptr->mFocusObject;
 active->d_ptr->mFocusObject = 0;
 }
 }
 /*!
-Wrapper
+Wrapper.
 */
 bool HbInputMethod::automaticTextCaseNeeded() const
 {
 Q_D(const HbInputMethod);
 return d->automaticTextCaseNeeded();
 }
 /*!
-Wrapper
+Deep copies the input state back to editor interface.
 */
 void HbInputMethod::inputStateToEditor(const HbInputState& source)
 {
 Q_D(HbInputMethod);
 d->inputStateToEditor(source);
 releaseFocus();
 reset();
 }
 /*!
-This function returns true if there is a context switch happening due to a orientation
+\deprecated HbInputMethod::orientationContextSwitchInProgress()
-switch.
+is deprecated.
 */
 bool HbInputMethod::orientationContextSwitchInProgress()
 {
 Q_D(HbInputMethod);
 return d->mIsOrientationContextSwitchInProgress;

changeset 1	f7ac710697a9
parent 0	16d8024aca5e
child 2	06ff229162e9