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

equal deleted inserted replaced

-:e6ad4ef83b23
+:b7da29130b0e
 ** If you have questions regarding the use of this file, please contact
 ** Nokia at developer.feedback@nokia.com.
 **
 ****************************************************************************/
 #include "hbinputfocusobject.h"
+#include "hbinputfocusobject_p.h"
 #include <QInputMethodEvent>
-#include <QGraphicsWidget>
+#include <QGraphicsObject>
 #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 "hbdeviceprofile.h"
-#include "hbinpututils.h"
 #include "hbnamespace_p.h"
 #include "hbmainwindow.h"
 #include "hbevent.h"
 #include "hbwidget.h"
 #include "hbinputmainwindow_p.h"
 /*!
-@alpha
+@beta
 @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
+This class is input method side API for accessing editor widgets. It hides
-in some cases Qt's QInputMethodEvent/inputMethodQuery system is not enough and direct
+the details of performing editor related operations, such as sending input
-access via type casting between QWidget and QGraphiscWidget based editors is needed.
+method events, querying editor geometry, querying editor attributes and so on.
-Focus object hides those cases behind a convinience API.
+It implements a collection of convenience methods for most commonly used
+editor operations.
 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
+it does, can be done directly in input method code as well. The benefit from using
-most commonly used operations behind one API to avoid duplicate code.
+this class is that an input method implementation doesn't need to care whether
+the focused editor is QWidget or QGraphicsWidget based (or proxied QWidget).
-Application developers should never need to use this class, it is for input method developers only.
+Application developers typically do not need this class, it is for input method
+developers only.
+The active focus object can be accessed through HbInputMethod::focusObject()
+method.
 \sa HbEditorInterface
+\sa HbInputMethod
 */
 /// @cond
-/*
+/*!
-This function ensures cursor visibility for known editor types.
+\internal
-*/
+Returns main window in case the editor is QGraphicsObject based and lives
-void ensureCursorVisible(QObject *widget)
+inside HbGraphicsScene.
-{
+*/
-if (widget) {
-QTextEdit *textEdit = qobject_cast<QTextEdit *>(widget);
-if (textEdit) {
-textEdit->ensureCursorVisible();
-}
-}
-}
-class HbInputFocusObjectPrivate
-{
-Q_DECLARE_PUBLIC(HbInputFocusObject)
-public:
-HbInputFocusObjectPrivate(QObject *focusedObject)
-: mFocusedObject(focusedObject),
-mEditorInterface(focusedObject)
-{}
-HbMainWindow *mainWindow() const;
-public:
-HbInputFocusObject *q_ptr;
-QPointer<QObject> mFocusedObject;
-HbEditorInterface mEditorInterface;
-QString mPreEditString;
-};
 HbMainWindow *HbInputFocusObjectPrivate::mainWindow() const
 {
-QWidget *qWidgetObject = qobject_cast<QWidget *>(mFocusedObject);
 QGraphicsObject *graphicsObject = 0;
 // check for graphics view related widgets.
-if (qWidgetObject) {
+if (mWidget) {
-if (qWidgetObject->graphicsProxyWidget()) {
+if (mWidget->graphicsProxyWidget()) {
-graphicsObject = qWidgetObject->graphicsProxyWidget();
+graphicsObject = mWidget->graphicsProxyWidget();
 } else {
 return HbInputMainWindow::instance();
 }
 } else {
-graphicsObject = qobject_cast<QGraphicsObject *>(mFocusedObject);
+graphicsObject = mGraphicsObject;
 }
 if (graphicsObject) {
 if (graphicsObject->scene()) {
 QList<QGraphicsView*> views = graphicsObject->scene()->views();
 }
 return 0;
 }
+/*!
+\internal
+Ensures cursor visibility for known editor types.
+*/
+void HbInputFocusObjectPrivate::ensureCursorVisible(QObject *widget)
+{
+if (widget) {
+QTextEdit *textEdit = qobject_cast<QTextEdit *>(widget);
+if (textEdit) {
+textEdit->ensureCursorVisible();
+}
+}
+}
 /// @endcond
 HbInputFocusObject::HbInputFocusObject(QObject *focusedObject)
 : d_ptr(new HbInputFocusObjectPrivate(focusedObject))
 {
 Q_D(HbInputFocusObject);
 d->q_ptr = this;
 if (focusedObject) {
+if (focusedObject->isWidgetType()) {
+d->mWidget = qobject_cast<QWidget*>(focusedObject);
+} else {
+QGraphicsProxyWidget *proxy = qobject_cast<QGraphicsProxyWidget*>(focusedObject);
+if (proxy) {
+d->mWidget = proxy->widget();
+} else {
+d->mGraphicsObject = qobject_cast<QGraphicsObject*>(focusedObject);
+}
+}
 HbEvent *event = new HbEvent(HbEvent::InputMethodFocusIn);
 QCoreApplication::sendEvent(focusedObject, event);
 delete event;
 HbMainWindow *mainWindow = d->mainWindow();
 }
 }
 HbInputFocusObject::~HbInputFocusObject()
 {
-Q_D(HbInputFocusObject);
+QObject *obj = object();
+if (obj) {
-if (d->mFocusedObject) {
 HbEvent *event = new HbEvent(HbEvent::InputMethodFocusOut);
-QCoreApplication::postEvent(d->mFocusedObject, event);
+QCoreApplication::postEvent(obj, event);
 }
 delete d_ptr;
 }
 } else {
 d->mPreEditString = imEvent->preeditString();
 }
 }
-if (d->mFocusedObject) {
+QObject *obj = object();
+if (obj) {
 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.
-ensureCursorVisible(d->mFocusedObject);
+d->ensureCursorVisible(obj);
 } else {
 QInputContext *ic = qApp->inputContext();
 if (ic && ic->focusWidget()) {
 QApplication::sendEvent(ic->focusWidget(), &event);
 }
 } else {
 d->mPreEditString = imEvent->preeditString();
 }
 }
-if (d->mFocusedObject) {
+QObject *obj = object();
-QApplication::postEvent(d->mFocusedObject, &event);
+if (obj) {
-}
+QApplication::postEvent(obj, &event);
 }
+}
-/*!
-Passes input method query to focused editor.
+/*!
+Passes input method query to focused editor widget.
 */
 QVariant HbInputFocusObject::inputMethodQuery(Qt::InputMethodQuery query) const
 {
 Q_D(const HbInputFocusObject);
-QGraphicsObject *graphicsObject = qobject_cast<QGraphicsObject *>(d->mFocusedObject);
+QGraphicsObject *graphicsObject = d->mGraphicsObject;
-if (graphicsObject && graphicsObject->scene()) {
+if (graphicsObject) {
-return graphicsObject->scene()->inputMethodQuery(query);
+if (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.
+return QVariant();
-QWidget *widget = qobject_cast<QWidget *>(d->mFocusedObject);
+}
-QGraphicsProxyWidget *pw = HbInputUtils::graphicsProxyWidget(widget);
-if (pw && pw->scene()) {
+QWidget *widget = d->mWidget;
-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) {
 */
 void HbInputFocusObject::releaseFocus()
 {
 Q_D(HbInputFocusObject);
-QGraphicsObject *graphicsObject = qobject_cast<QGraphicsObject *>(d->mFocusedObject);
+QGraphicsObject *graphicsObject = d->mGraphicsObject;
 if (!graphicsObject) {
-QWidget *widget = qobject_cast<QWidget *>(d->mFocusedObject);
+QWidget *widget = d->mWidget;
 if (widget) {
-if (!(graphicsObject = HbInputUtils::graphicsProxyWidget(widget))) {
+if (widget->graphicsProxyWidget()) {
+graphicsObject = widget->graphicsProxyWidget();
+} else {
 widget->clearFocus();
 return;
 }
 }
 }
 */
 QRectF HbInputFocusObject::editorGeometry() const
 {
 Q_D(const HbInputFocusObject);
-QGraphicsObject *graphicsObject = qobject_cast<QGraphicsObject *>(d->mFocusedObject);
+QGraphicsObject *graphicsObject = d->mGraphicsObject;
 if (!graphicsObject) {
-QWidget *widget = qobject_cast<QWidget *>(d->mFocusedObject);
+QWidget *widget = d->mWidget;
 if (widget) {
-// check if widget is inside a proxy.
+// Check if widget is inside a proxy.
-QGraphicsProxyWidget *pw = HbInputUtils::graphicsProxyWidget(widget);
+QGraphicsProxyWidget *pw = widget->graphicsProxyWidget();
 if (pw) {
-// check if we are pointing to the toplevel
+graphicsObject = pw;
-// 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()) {
-// focused object is not a proxy but it is
-// 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());
 }
 }
 }
-// we need to find the editor which is inside
 if (graphicsObject) {
 return QRectF(graphicsObject->scenePos(), graphicsObject->boundingRect().size());
 }
 return QRectF();
 QRectF HbInputFocusObject::microFocus() const
 {
 Q_D(const HbInputFocusObject);
 QRectF rect = inputMethodQuery(Qt::ImMicroFocus).toRectF();
-QGraphicsObject *editorWidget = qobject_cast<QGraphicsObject*>(d->mFocusedObject);
+QGraphicsObject *editorWidget = d->mGraphicsObject;
 if (editorWidget) {
 rect = editorWidget->mapRectToScene(rect);
 }
 return rect;
 */
 qreal HbInputFocusObject::findVkbZValue() const
 {
 Q_D(const HbInputFocusObject);
-QGraphicsObject *editorWidget = qobject_cast<QGraphicsObject *>(d->mFocusedObject);
+QGraphicsObject *editorWidget = d->mGraphicsObject;
 if (!editorWidget) {
-QWidget *widget = qobject_cast<QWidget *>(d->mFocusedObject);
+QWidget *widget = d->mWidget;
 if (widget) {
-editorWidget = HbInputUtils::graphicsProxyWidget(widget);
+editorWidget = widget->graphicsProxyWidget();
 }
 }
 if (editorWidget) {
 qreal result = editorWidget->zValue();
 */
 Qt::InputMethodHints HbInputFocusObject::inputMethodHints() const
 {
 Q_D(const HbInputFocusObject);
-QGraphicsObject *graphicsObject = qobject_cast<QGraphicsObject *>(d->mFocusedObject);
+QGraphicsObject *graphicsObject = d->mGraphicsObject;
 if (graphicsObject) {
 return graphicsObject->inputMethodHints();
 }
-QWidget *widget = qobject_cast<QWidget *>(d->mFocusedObject);
+QWidget *widget = d->mWidget;
 if (widget) {
 return widget->inputMethodHints();
 }
 return Qt::ImhNone;
 */
 void HbInputFocusObject::setInputMethodHints(Qt::InputMethodHints hints)
 {
 Q_D(HbInputFocusObject);
-QGraphicsObject *graphicsObject = qobject_cast<QGraphicsObject *>(d->mFocusedObject);
+QGraphicsObject *graphicsObject = d->mGraphicsObject;
 if (graphicsObject) {
 graphicsObject->setInputMethodHints(hints);
 return;
 }
-QWidget *widget = qobject_cast<QWidget *>(d->mFocusedObject);
+QWidget *widget = d->mWidget;
 if (widget) {
 widget->setInputMethodHints(hints);
 }
 }
 */
 QPointF HbInputFocusObject::scenePos() const
 {
 Q_D(const HbInputFocusObject);
-QGraphicsObject *graphicsObject = qobject_cast<QGraphicsObject *>(d->mFocusedObject);
+QGraphicsObject *graphicsObject = d->mGraphicsObject;
 if (graphicsObject) {
 return graphicsObject->scenePos();
 }
-QWidget *w = qobject_cast<QWidget *>(d->mFocusedObject);
+QWidget *widget = d->mWidget;
-// check if widget is inside a proxy.
+if (widget) {
-QGraphicsProxyWidget *pw = HbInputUtils::graphicsProxyWidget(w);
+QGraphicsProxyWidget *proxy = widget->graphicsProxyWidget();
-if (pw) {
+if (proxy) {
-// check if we are pointing to the toplevel
+return proxy->scenePos();
-// proxy widget, if not then we must check for
+}
-// the widgets window and see if it is a proxy.
+return widget->mapToGlobal(QPoint(0, 0));
-if (pw->widget() == w) {
-return pw->scenePos();
-} else if (pw->widget() == w->window()) {
-QRectF rect = pw->subWidgetRect(w);
-rect.translate(pw->scenePos());
-return rect.topLeft();
-}
-}
-if (w) {
-// not a proxy.. Meaning widget is inside a QWidget window.
-return w->mapToGlobal(QPoint(0, 0));
 }
 return QPointF(0.0, 0.0);
 }
 Returns true if all the characters in given string are allowed in active editor.
 */
 bool HbInputFocusObject::stringAllowedInEditor(const QString &string) const
 {
 // Two pass filtering. This can be a case constrained editor with a filter.
-Qt::InputMethodHints hints;
+Qt::InputMethodHints hints = inputMethodHints();
 if (hints & Qt::ImhLowercaseOnly) {
 QString outStr;
 HbInputLowerCaseFilter::instance()->filterString(string, outStr);
 if (string != outStr) {
 return false;
 /*!
 Commits given smiley.
 */
 void HbInputFocusObject::commitSmiley(QString smiley)
 {
-Q_D(HbInputFocusObject);
+QObject *obj = object();
+if (obj) {
-if (d->mFocusedObject) {
+obj->setProperty("SmileyIcon", smiley);
-d->mFocusedObject->setProperty("SmileyIcon", smiley);
 }
 }
 /*!
 Returns the editor widget as QObject.
 */
 QObject *HbInputFocusObject::object() const
 {
 Q_D(const HbInputFocusObject);
-return d->mFocusedObject;
+if (d->mGraphicsObject) {
+return d->mGraphicsObject.data();
+}
+return d->mWidget.data();
 }
 /*!
 Returns true if widget is read-only widget. This works
 only for known editor types.
 */
 void HbInputFocusObject::setFocus()
 {
 Q_D(HbInputFocusObject);
-QGraphicsObject *graphicsObject = qobject_cast<QGraphicsObject *>(d->mFocusedObject);
+bool sendRequest = false;
+QGraphicsObject *graphicsObject = d->mGraphicsObject;
 if (graphicsObject && graphicsObject->scene()) {
 graphicsObject->scene()->setFocusItem(graphicsObject);
+sendRequest = true;
 } else {
-QWidget *widget = qobject_cast<QWidget *>(d->mFocusedObject);
+QWidget *widget = d->mWidget;
 if (widget) {
 widget->setFocus();
-}
+sendRequest = true;
 }
+}
-QInputContext* ic = qApp->inputContext();
-if (ic) {
+if (sendRequest) {
-QEvent *openEvent = new QEvent(QEvent::RequestSoftwareInputPanel);
+QInputContext* ic = qApp->inputContext();
-ic->filterEvent(openEvent);
+if (ic) {
-delete openEvent;
+QEvent *openEvent = new QEvent(QEvent::RequestSoftwareInputPanel);
+ic->filterEvent(openEvent);
+delete openEvent;
+}
 }
 }
 /*!
 Returns the screen orientation in editor widget's context. For widgets

changeset 28	b7da29130b0e
parent 23	e6ad4ef83b23
child 30	80e4d18b72f5