FCL/sf/mw/hb: comparison src/hbcore/gui/hbwidget.cpp

equal deleted inserted replaced

-:730c025d4b77
+:f378acbc9cfb
 #include "hbstyleoption_p.h"
 #include "hbstyleparameters.h"
 #include "hbgraphicsscene.h"
 #include "hbgraphicsscene_p.h"
 #include "hbdeviceprofile.h"
-#include "hbspaceritem_p.h"
+#include "hbtapgesture.h"
+#include "hbnamespace_p.h"
 #include <QCoreApplication>
 #include <QMetaType>
 #include <QAction>
 #include <QDebug>
 #include <QDynamicPropertyChangeEvent>
 backgroundPrimitiveType(HbStyle::P_None),
 polished(false),
 polishPending(false),
 themingPending(true),
 repolishOutstanding(false),
+mHandlingRepolishSynchronously(false),
 notifyScene(false),
-pluginBaseId(0),
 focusGroup(0),
 focusActiveType(HbStyle::P_None),
 focusResidualType(HbStyle::P_None),
 highlightExpired(false),
 backgroundItem(0),
 {
 if (backgroundItem) {
 delete backgroundItem;
 backgroundItem = 0;
 }
+}
-// need to delete the hash values
-QList<QGraphicsLayoutItem *> deletedSpacers = mSpacers.values();
+void HbWidgetPrivate::setBackgroundItem(HbStyle::Primitive type, int zValue)
-mSpacers.clear();
+{
-qDeleteAll( deletedSpacers );
+Q_Q(HbWidget);
-}
+if(type!=backgroundPrimitiveType || type == HbStyle::P_None) {
+if (backgroundItem) {
-/*!
+delete backgroundItem;
-Creates a new spacer item with the given \a name.
+backgroundItem = 0;
+}
-Returns a pointer to the newly created spacer item. Widget keeps the ownership.
+backgroundPrimitiveType = type;
-*/
+backgroundItem = q->style()->createPrimitive(backgroundPrimitiveType, const_cast<HbWidget*>(q));
-QGraphicsLayoutItem *HbWidgetPrivate::createSpacerItem( const QString &name )
+if(backgroundItem) {
-{
+backgroundItem->setParentItem(q);
-#ifndef Q_OS_SYMBIAN
+}
-Q_ASSERT( !name.isEmpty() );
+q->updatePrimitives();
-// check in desktop environments that the item does not exist already
+}
-Q_ASSERT( !mSpacers.contains( name ) );
+if(backgroundItem && zValue != backgroundItem->zValue()) {
-#endif
+backgroundItem->setZValue(zValue);
+}
-HbSpacerItem *newSpacer = new HbSpacerItem();
+}
-mSpacers.insert( name, newSpacer );
-return newSpacer;
-}
+/*!
-/*
-\deprecated HbWidget::setBackgroundItem(HbStyle::Primitive, int)
-is deprecated. Use HbWidget::setBackgroundItem(QGraphicsItem *item, int zValue) instead.
-Creates background item to the widget from style primitive.
-Creates a new background item to the widget and the reparents it to
-be child of the widget. Also Z-value of the background item will be
-changed to zValue. By default the zValue is -1, which should be
-behind other widget content. Background item will be always resized
-to be same size as the widgets bounding rect.
-If type is HbStyle::P_None, the background item will be removed from
-widget.
-Previously set background item will be deleted.
-*/
-void HbWidget::setBackgroundItem(HbStyle::Primitive type, int zValue)
-{
-Q_D(HbWidget);
-if(type!=d->backgroundPrimitiveType || type == HbStyle::P_None) {
-if (d->backgroundItem) {
-delete d->backgroundItem;
-d->backgroundItem = 0;
-}
-d->backgroundPrimitiveType = type;
-d->backgroundItem = style()->createPrimitive(d->backgroundPrimitiveType, const_cast<HbWidget*>(this));
-if(d->backgroundItem) {
-d->backgroundItem->setParentItem(this);
-}
-updatePrimitives();
-}
-if(d->backgroundItem && zValue != d->backgroundItem->zValue()) {
-d->backgroundItem->setZValue(zValue);
-}
-}
-/*
 Sets background item to the widget.
 The item will be reparented to be child of the widget. Also Z-value
 of the background item will be changed to be zValue. By default the
 zValue is -1, which should be  behind other widget content.
 if(d->backgroundItem) {
 d->backgroundItem->setParentItem(this);
 d->backgroundItem->setZValue(zValue);
 d->updateBackgroundItemSize();
 }
-}
+updatePrimitives();
+}
-/*
+/*!
 Returns background item. 0 is returned if there isn't background
 item in the widget.
 */
 QGraphicsItem *HbWidget::backgroundItem() const
 {
 Q_D( const HbWidget );
 return d->backgroundItem;
 }
-/*
+/*!
 Returns focusItem primitive items.
 Focus primitive is created if has not been created already.
 */
 QGraphicsItem *HbWidgetPrivate::focusPrimitive(HbWidget::FocusHighlight highlightType) const
 {
 }
 return 0;
 }
-/*
+/*!
 Hides or shows focus primitive depending on the focus state of the widget.
 */
 void HbWidgetPrivate::focusChangeEvent(HbWidget::FocusHighlight focusHighlight)
 {
 Q_Q(HbWidget);
 focusResidualItem->update();
 }
 }
-/*
+/*!
 Find closest parent with focus group and update the focused child.
 */
 void HbWidgetPrivate::updateCurrentFocusChild()
 {
 Q_Q(HbWidget);
 if (group) {
 group->updateCurrentFocusChild(q);
 }
 }
-/*
+/*!
 Find and return the closest parent with focus group if any. If propagate
 is true then the closest parent with focus group and children is accepted as
 valid focus group e.g. used for a widget which has the key for changing the
 focus mode set only.
 */
 };
 }
 return (group) ? group : 0;
 }
-/*
+/*!
 Set focus to child widget depending on the set focus delegation
 policy.
 */
 bool HbWidgetPrivate::delegateFocus(QFocusEvent *event) const
 {
 }
 }
 }
 }
-/*
-Test if some item in our parent hierarchy has
-the Hb::InputMethodNeutral flag set.
-*/
-bool HbWidgetPrivate::isInputMethodNeutral()
-{
-Q_Q(HbWidget);
-// Test the widget itself...
-if(q->testAttribute(Hb::InputMethodNeutral)) {
-return true;
-}
-// and then all parents
-QGraphicsWidget* i = q->parentWidget();
-while(i) {
-HbWidget* w = qobject_cast<HbWidget *>(i);
-if(w && w->testAttribute(Hb::InputMethodNeutral)) {
-return true;
-}
-i = i->parentWidget();
-}
-return false;
-}
 /*!
 \class HbWidget
 \brief HbWidget is a base for all Hb widgets. It contains common functionality
 HbWidget::HbWidget( QGraphicsItem *parent, Qt::WindowFlags wFlags ):
 HbWidgetBase( *new HbWidgetPrivate, parent, wFlags )
 {
 Q_D( HbWidget );
 d->q_ptr = this;
+setAttribute(Hb::Widget, true);
 #ifdef HB_TESTABILITY
 	if(d->testabilitySignal) {
 		d->testabilitySignal->setParent(this);
 		d->testabilitySignal->notifySignalEnabled(testabilitySignalEnabledChange, this);
 HbWidget::HbWidget(HbWidgetPrivate &dd, QGraphicsItem *parent, Qt::WindowFlags wFlags):
 HbWidgetBase( dd, parent, wFlags )
 {
 Q_D( HbWidget );
 d->q_ptr = this;
+setAttribute(Hb::Widget, true);
 #ifdef HB_TESTABILITY
 	if (d->testabilitySignal) {
 		d->testabilitySignal->setParent(this);
 		d->testabilitySignal->notifySignalEnabled(testabilitySignalEnabledChange, this);
 //Start of snippet 1
 HbEvent event1( HbEvent::ChildFocusIn);
 QCoreApplication::sendEvent( parentWidget(), &event1 );
 //End of snippet 1
 }
-#if QT_VERSION >= 0x040600
-if(!d->isInputMethodNeutral() && !(flags() & QGraphicsItem::ItemAcceptsInputMethod)) {
-// Make sure the input panel is closed if this widget is not input method neutral or
-// it does not accept input method
-// Send close input panel event.
-QInputContext *ic = qApp->inputContext();
-if (ic) {
-QEvent *closeEvent = new QEvent(QEvent::CloseSoftwareInputPanel);
-ic->filterEvent(closeEvent);
-delete closeEvent;
-}
-}
-#endif
 }
 /*!
 FocusOut event hadler.
 */
 delete acts[i];
 }
 }
 /*!
-This function returns the base id of the style plugin of the widget or
+\deprecated HbWidget::pluginBaseId()
-	\c 0 if the widget is not plugin based.
+is deprecated. Style plugins are deprecated.
 */
 int HbWidget::pluginBaseId() const
 {
-Q_D(const HbWidget);
+return 0; // deprecated
-return d->pluginBaseId;
+}
-}
+/*!
-/*!
+\deprecated HbWidget::setPluginBaseId(int)
-Sets the base id of the style plugin of the widget.
+is deprecated. Style plugins are deprecated.
 */
 void HbWidget::setPluginBaseId( int baseId )
 {
-Q_D(HbWidget);
+Q_UNUSED(baseId); // deprecated
-d->pluginBaseId = baseId;
 }
 /*!
 This function returns the HbMainWindow of the widget or \c 0 if
 it doesn't exist.  Note that if the widget is not added to the scene
 if(d->backgroundPrimitiveType != HbStyle::P_None) {
 style()->updatePrimitive(backgroundItem(), d->backgroundPrimitiveType, &option);
 }
 d->updateBackgroundItemSize();
 }
 if (d->focusPrimitive(HbWidget::FocusHighlightResidual)) {
 style()->updatePrimitive(d->focusPrimitive(HbWidget::FocusHighlightResidual),
 d->focusResidualType, &option);
 }
 }
 if (d->polishPending && value.toBool()) {
 d->polishPending = false;
 HbStyleParameters params;
 polish( params );
+if (scene()) {
+// The widget is polished again or is beign polished now. As we set layout to widget in polishEvent,
+// inform scene to polish any new child items and handle any resulting layoutrequest
+// events before drawing.
+HbGraphicsScene *hbscene = qobject_cast<HbGraphicsScene*>(scene());
+if (hbscene) {
+HbGraphicsScenePrivate::d_ptr(hbscene)->mPolishWidgets = true;
+}
+}
 }
 }
 else if (change == QGraphicsItem::ItemChildAddedChange) {
 if (d->focusGroup) {
 QGraphicsItem *child = qVariantValue<QGraphicsItem *>(value);
 Override this method if you want to do something special in polish
 (e.g. fetch some custom style parameters to your widget from style
 backend). When overriding, always call the base classes
 impelentation.
-If you are implementing a custom widget that has a style plugin
-you must make sure that pluginBaseId is set.
 \param params, For querying (custom) style parameters from HbStyle.
-\sa polish(), pluginBaseId()
+\sa polish()
 */
 void HbWidget::polish( HbStyleParameters& params )
 {
 Q_D(HbWidget);
 if (isVisible()) {
 	if (d->polished && !d->repolishOutstanding) {
 #endif
 d->repolishOutstanding = true;
 QEvent* polishEvent = new QEvent( QEvent::Polish );
 QCoreApplication::postEvent(this, polishEvent);
+// If no one is handling repolish synchronously, lets make sure they are handled
+// before painting. For example view items handle them synchronously.
+if (scene() && !d->mHandlingRepolishSynchronously) {
+// The widget needs to be polished again. As we set layout to widget in polishEvent,
+// inform scene to handle polish and any resulting layoutrequest
+// events before drawing.
+HbGraphicsScene *hbscene = qobject_cast<HbGraphicsScene*>(scene());
+if (hbscene) {
+HbGraphicsScenePrivate::d_ptr(hbscene)->mRepolishWidgets = true;
+}
+}
 }
 }
 /*!
 }
 /*!
 Returns primitive which HbStyle::itemName equals to \a itemName.
-If the \a itemName is empty, the layout is returned.
+If the \a itemName is empty, the layout is returned, otherwise
+returns the primitive that matches the \a itemName.
-If the \a itemName does not match any primitive, \a itemName is mapped to owned spacers.
 If the \a itemName cannot be mapped to any of the above, returns 0.
 \sa HbStyle::itemName()
 */
 QGraphicsLayoutItem *HbWidget::layoutPrimitive(const QString &itemName) const
 {
-Q_D(const HbWidget);
 if ( itemName == "" ) {
 return layout();
 } else {
 QList<QGraphicsItem*> list = childItems();
 for ( int i = 0 ; i < list.count() ; i++  ) {
 if ( HbStyle::itemName(item) == itemName ) {
 return item->isWidget() ? static_cast<QGraphicsWidget*>(item) : 0;
 }
 }
 }
-if ( d->mSpacers.contains(itemName) ) {
-return d->mSpacers.value(itemName);
-}
 return 0;
 }
 /*!
 Defines the orientation to move focus from focused widget to previous or next
 } else if (highlightType == HbWidget::FocusHighlightResidual) {
 primitive = d->focusResidualType;
 }
 return primitive;
 }
+bool HbWidget::sceneEventFilter (QGraphicsItem *watched, QEvent *event)
+{
+if(event->type() == QEvent::Gesture && watched->type() == Hb::ItemType_TouchArea) {
+QGestureEvent* ge = static_cast<QGestureEvent*>(event);
+HbTapGesture* tap = qobject_cast<HbTapGesture*>(ge->gesture(Qt::TapGesture));
+if (tap && tap->state() == Qt::GestureStarted) {
+tap->setProperty(HbPrivate::ThresholdRect.latin1(), watched->mapRectToScene(watched->boundingRect()).toRect());
+}
+sceneEvent(event);
+return true;
+}
+return HbWidgetBase::sceneEventFilter(watched, event);
+}

branch	GCC_SURGE
changeset 15	f378acbc9cfb
parent 7	923ff622b8b9
child 21	4633027730f5
child 34	ed14f46c0e55