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

equal deleted inserted replaced

-:11d3954df52a
+:627c4a0fd0e7
 #include <QGraphicsScene>
 #include <QGraphicsProxyWidget>
 #include <QLineEdit>
 #include <QTextEdit>
 #include <QPointer>
+#include <QGraphicsView>
 #include "hbinputmethod.h"
 #include "hbinputfocusobject.h"
 #include "hbinputeditorinterface.h"
 #include "hbinputvkbhost.h"
 #include "hbinputstandardfilters.h"
+#include "hbinpututils.h"
 #include "hbnamespace_p.h"
 /*!
 @alpha
 @hbcore
 \class HbInputFocusObject
 d->mPreEditString = imEvent->preeditString();
 }
 }
 if (d->mFocusedObject) {
-QApplication::sendEvent(d->mFocusedObject, &event);
 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);
-}
+} 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)
 */
 QVariant HbInputFocusObject::inputMethodQuery(Qt::InputMethodQuery query) const
 {
 Q_D(const HbInputFocusObject);
-QGraphicsWidget *graphicsWidget = qobject_cast<QGraphicsWidget*>(d->mFocusedObject);
+QGraphicsObject *graphicsObject = qobject_cast<QGraphicsObject*>(d->mFocusedObject);
-if (graphicsWidget && graphicsWidget->scene()) {
+if (graphicsObject && graphicsObject->scene()) {
-return graphicsWidget->scene()->inputMethodQuery(query);
+return graphicsObject->scene()->inputMethodQuery(query);
 }
+// check if QWidget is embedded as a proxy in scene. If yes try to get details
+// from the scene.
 QWidget *widget = qobject_cast<QWidget*>(d->mFocusedObject);
+QGraphicsProxyWidget *pw = HbInputUtils::graphicsProxyWidget(widget);
+if (pw && pw->scene()) {
+return pw->scene()->inputMethodQuery(query);
+}
 if (widget) {
-return widget->inputMethodQuery(query);
+// 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();
 }
 */
 void HbInputFocusObject::releaseFocus()
 {
 Q_D(HbInputFocusObject);
-QGraphicsWidget *graphicsWidget = qobject_cast<QGraphicsWidget*>(d->mFocusedObject);
+QGraphicsObject *graphicsObject = qobject_cast<QGraphicsObject*>(d->mFocusedObject);
-if (!graphicsWidget) {
+if (!graphicsObject) {
 QWidget *widget = qobject_cast<QWidget*>(d->mFocusedObject);
 if (widget) {
-if (widget->graphicsProxyWidget()) {
+if (!(graphicsObject = HbInputUtils::graphicsProxyWidget(widget))) {
-graphicsWidget = widget->graphicsProxyWidget();
-} else {
 widget->clearFocus();
-}
+return;
 }
 }
+}
-if (graphicsWidget && graphicsWidget->scene()) {
-graphicsWidget->scene()->setFocusItem(0);
+if (graphicsObject && graphicsObject->scene()) {
+graphicsObject->scene()->setFocusItem(0);
 }
 }
 /*!
 Runs the given character through active input filter and commits it if it was accepted.
 return true;
 }
 /*!
-Returns editor widget geometry. In case of QGraphicsWidget, the returned value is in scene coordinates.
+Returns editor widget geometry. In case of QGraphicsObject, the returned value is in scene coordinates.
 */
 QRectF HbInputFocusObject::editorGeometry() const
 {
 Q_D(const HbInputFocusObject);
-QGraphicsWidget *graphicsWidget = qobject_cast<QGraphicsWidget*>(d->mFocusedObject);
+QGraphicsObject *graphicsObject = qobject_cast<QGraphicsObject*>(d->mFocusedObject);
-if (!graphicsWidget) {
+if (!graphicsObject) {
 QWidget *widget = qobject_cast<QWidget*>(d->mFocusedObject);
 if (widget) {
-if (widget->graphicsProxyWidget()) {
+// check if widget is inside a proxy.
-graphicsWidget = widget->graphicsProxyWidget();
+QGraphicsProxyWidget *pw = HbInputUtils::graphicsProxyWidget(widget);
+if (pw) {
+// check if we are pointing to the toplevel
+// 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 widget->geometry();
+return QRectF(widget->mapToGlobal(QPoint(0, 0)), widget->size());
 }
 }
 }
-if (graphicsWidget) {
+// we need to find the editor which is inside
-return QRectF(graphicsWidget->scenePos(), graphicsWidget->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 QGraphicsWidget, the returned rectangle is in scene coordinates.
+In case of QGraphicsObject, the returned rectangle is in scene coordinates.
 */
 QRectF HbInputFocusObject::microFocus() const
 {
 return inputMethodQuery(Qt::ImMicroFocus).toRectF();
 }
 */
 qreal HbInputFocusObject::findVkbZValue() const
 {
 Q_D(const HbInputFocusObject);
-QGraphicsWidget *editorWidget = qobject_cast<QGraphicsWidget*>(d->mFocusedObject);
+QGraphicsObject *editorWidget = qobject_cast<QGraphicsObject*>(d->mFocusedObject);
 if (!editorWidget) {
 QWidget *widget = qobject_cast<QWidget*>(d->mFocusedObject);
 if (widget) {
-editorWidget = widget->graphicsProxyWidget();
+editorWidget = HbInputUtils::graphicsProxyWidget(widget);
 }
 }
 if (editorWidget) {
 qreal result = editorWidget->zValue();
-for (QGraphicsWidget *parent = editorWidget->parentWidget(); parent; parent = parent->parentWidget()) {
+for (QGraphicsObject *parent = editorWidget->parentObject(); parent; parent = parent->parentObject()) {
 result += parent->zValue();
 }
+result += HbPrivate::VKBValueUnit;
-return result + HbPrivate::VKBValueUnit;
+if(result >= 0) {
+return result;
+}
 }
 return 0.0;
 }
 /*!
-Returns input method hints. See QWidget and QGraphicsWidget documentation for more information.
+Returns input method hints. See QWidget and QGraphicsItem documentation for more information.
 */
 Qt::InputMethodHints HbInputFocusObject::inputMethodHints() const
 {
 Q_D(const HbInputFocusObject);
-QGraphicsWidget *graphicsWidget = qobject_cast<QGraphicsWidget*>(d->mFocusedObject);
+QGraphicsObject *graphicsObject = qobject_cast<QGraphicsObject*>(d->mFocusedObject);
-if (graphicsWidget) {
+if (graphicsObject) {
-return graphicsWidget->inputMethodHints();
+return graphicsObject->inputMethodHints();
 }
 QWidget *widget = qobject_cast<QWidget*>(d->mFocusedObject);
 if (widget) {
 return widget->inputMethodHints();
 */
 void HbInputFocusObject::setInputMethodHints(Qt::InputMethodHints hints)
 {
 Q_D(HbInputFocusObject);
-QGraphicsWidget *graphicsWidget = qobject_cast<QGraphicsWidget*>(d->mFocusedObject);
+QGraphicsObject *graphicsObject = qobject_cast<QGraphicsObject*>(d->mFocusedObject);
-if (graphicsWidget) {
+if (graphicsObject) {
-graphicsWidget->setInputMethodHints(hints);
+graphicsObject->setInputMethodHints(hints);
 return;
 }
 QWidget *widget = qobject_cast<QWidget*>(d->mFocusedObject);
 if (widget) {
 return true;
 }
 /*!
 Returns the scenePos of the associated editor widget, if the concept makes sense
-in its context (i.e. the editor is part of a scene, either being a QGraphicsWidget or
+in its context (i.e. the editor is part of a scene, either being a QGraphicsObject or
 a QWidget embedded in a QGraphicsProxyWidget). Otherwise returns QPointF(0.0, 0.0).
 */
 QPointF HbInputFocusObject::scenePos() const
 {
 Q_D(const HbInputFocusObject);
-QGraphicsWidget *graphicsWidget = qobject_cast<QGraphicsWidget*>(d->mFocusedObject);
+QGraphicsObject *graphicsObject = qobject_cast<QGraphicsObject*>(d->mFocusedObject);
-if (graphicsWidget) {
+if (graphicsObject) {
-return graphicsWidget->scenePos();
+return graphicsObject->scenePos();
 }
-QWidget *widget = qobject_cast<QWidget*>(d->mFocusedObject);
+QWidget *w = qobject_cast<QWidget*>(d->mFocusedObject);
-if (widget && widget->graphicsProxyWidget()) {
+// check if widget is inside a proxy.
-return widget->graphicsProxyWidget()->scenePos();
+QGraphicsProxyWidget *pw = HbInputUtils::graphicsProxyWidget(w);
+if (pw) {
+// check if we are pointing to the toplevel
+// proxy widget, if not then we must check for
+// the widgets window and see if it is a proxy.
+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);
 }
 return textEdit->isReadOnly();
 }
 return false;
 } else {
-QGraphicsWidget *graphicsWidget = qobject_cast<QGraphicsWidget*>(editorObject);
+QGraphicsObject *graphicsObject = qobject_cast<QGraphicsObject*>(editorObject);
-if (graphicsWidget) {
+if (graphicsObject) {
-if (!(graphicsWidget->flags() & QGraphicsItem::ItemAcceptsInputMethod)) {
+if (!(graphicsObject->flags() & QGraphicsItem::ItemAcceptsInputMethod)) {
 return true;
 }
 }
 return false;
 }
 }
 return true;
 }
 /*!
 Returns true if the input framework recognizes given object as editor.
 */
 bool HbInputFocusObject::isEditor(QObject *object)
 {
-QGraphicsObject *graphicsObject = qobject_cast<QGraphicsObject*>(object);
+if (QWidget *w = qobject_cast<QWidget *>(object)) {
-if (graphicsObject) {
+if (w->testAttribute(Qt::WA_InputMethodEnabled)) {
-return ((graphicsObject->flags() & QGraphicsItem::ItemAcceptsInputMethod) != 0);
+return true;
 }
+}
-if (qobject_cast<QLineEdit*>(object)) {
-return true;
+if (QGraphicsObject *gw = qobject_cast<QGraphicsObject *>(object)) {
-}
+if (gw->flags() & QGraphicsItem::ItemAcceptsInputMethod) {
+return true;
-if (qobject_cast<QTextEdit*>(object)) {
+}
-return true;
 }
 return false;
 }
 */
 void HbInputFocusObject::setFocus()
 {
 Q_D(HbInputFocusObject);
-QGraphicsWidget *graphicsWidget = qobject_cast<QGraphicsWidget*>(d->mFocusedObject);
+QGraphicsObject *graphicsObject = qobject_cast<QGraphicsObject*>(d->mFocusedObject);
-if (graphicsWidget && graphicsWidget->scene()) {
+if (graphicsObject && graphicsObject->scene()) {
-graphicsWidget->scene()->setFocusItem(graphicsWidget);
+graphicsObject->scene()->setFocusItem(graphicsObject);
 } else {
 QWidget *widget = qobject_cast<QWidget*>(d->mFocusedObject);
 if (widget) {
 widget->setFocus();
 }

changeset 5	627c4a0fd0e7
parent 2	06ff229162e9
child 6	c3690ec91ef8