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

equal deleted inserted replaced

-:923ff622b8b9
+:4633027730f5
 #include <QEventLoop>
 #include <QPointer>
 #include <QDebug>
 #include <QBitmap>
 #include <hbinstance_p.h>
+#include <QGraphicsScene>
 #include <QApplication> // krazy:exclude=qclasses
 #include <hbwidgetfeedback.h>
 #ifdef HB_EFFECTS
 #endif
 /*!
 @beta
 @hbcore
 \class HbPopup
-\brief HbPopup is a base class for different popups in Hb library.
+\brief The HbPopup class defines a set of properties that control the behavior of
+the many dialog and popup classes that derive from it.
-Popup is a widget that is displayed above other widgets in the view.
+Objects of classes derived from %HbPopup are called \b popups. Typically they
-Lastly shown popup is always positioned in Z order on the the top
+are displayed above other objects within the view, at the highest z-order. The %HbPopup
-of already visible popups.
+class simply defines a frame with a number of properties. If you want to create an
+application dialog with a heading, content and a toolbar, use the HbDialog class (which
-A popup can be permanent or automatically dismissed after a
+is derived from %HbPopup) or one of its convenience subclasses.
-time-out.  Modal popups interrupt any other user interaction
-outside of the popup while they are visible, whereas non-modal
+%HbPopup provides properties that you can use to customize the following aspects of a popup:
-popups do not.
+- \b Modality. You can define whether the popup is modal or non-modal. A modal popup stops
-\sa HbDialog
+the user interacting with anything outside of the popup until it closes. A non-modal
-*/
+popup does not block the user's interaction with things outside of the popup. You
+set and get the modality by calling setModal() and isModal(), respectively.
-/*!
-\reimp
+- <b>Dismiss policy</b>. You can define which user actions, if any, cause the popup to
+close. Possible values are defined by HbPopup::DismissPolicy. You set and get the dismiss
+policy by calling setDismissPolicy() and dismissPolicy(), respectively.
+- <b>Background fade policy</b>. You can set a policy to fade everything behind the
+popup. This is useful for modal dialogs, because the user cannot interact with
+anything behind the popup. You control this policy by calling setBackgroundFaded() and
+get the current policy by calling isBackgroundFaded().
+- \b Timeout. You can define a timeout that causes the popup to be dismissed automatically
+after a set a period. You set and get this property by calling setTimeout() and
+timeout(), respectively. Call the setTimeout(HbPopup::DefaultTimeout) overload to use the
+default value for the popup type, which provides a common look and feel.
+- <b>Frame background type</b>. You can define the popup's background style. However,
+the actual appearance of the popup depends on the theme. You set and get this property by
+calling setFrameType() and frameType(), respectively.
+By default, popups are displayed in the center of the screen. Typically you should not override
+the default position of modal dialogs. However, some popups, such as context menus, need to be
+in a specific position. For these, you can use the setPreferredPos() method to set the
+preferred position.
+Popups that contain an editor may be repositioned by the virtual keyboard when it opens.
+When the virtual keyboard closes, it attempts to reposition the popup back to its
+previous position. However, this is not always possible, particularly when there has also
+been an orientation switch.
+\section _usecases_hbpopup Using the HbPopup class
+Although it is possible to create an instance of the HbPopup class, it is designed as a
+base class to provide common features to the many popup and dialog classes that are
+derived from it (such as HbMenu, HbDialog, HbToolBarExtension, HbZoomSliderPopup).
+How you open a popup depends on whether it is modal. It is important to use the
+appropriate method, because this ensures the correct touch event handling.
+<table border="1" style="border-collapse: collapse; border: solid;">
+<tr><th>To open</TH><TH>Call</th></tr>
+<tr><td>Modal popups</td><td>open()</td></tr>
+<tr><td>Non-modal popups</td><td>\link QGraphicsItem::show() show()\endlink</td></tr>
+</table>
+\sa HbDialog, HbMenu
+*/
+/*!
 \fn int HbPopup::type() const
 */
 /*!
 \enum HbPopup::DefaultTimeout
-This enum defines available default timeout values to be used in method
+Identifies default timeout values for various popup types. The timeout defines a time
-setTimeout(HbPopup::DefaultTimeout).
+period after which the popup is automatically closed. Using these default values
+provides a consistent look and feel.
+\sa setTimeout(HbPopup::DefaultTimeout)
 */
 /*!
 \var HbPopup::NoTimeout
+Defines a permanent popup, for which no timeout is defined.
-No timeout is defined for automatically closing the popup. i.e. the popup is permanent.
 */
 /*!
 \var HbPopup::ConfirmationNoteTimeout
+The default timeout value for confirmation notes.
-Timeout value intended to be used by confirmation notes.
 */
 /*!
 \var HbPopup::StandardTimeout
+The default timeout value for standard non-permanent popups, such as notes.
-The default timeout value intended to be used by most non-permanent popups e.g. by notes.
 */
 /*!
 \var HbPopup::ContextMenuTimeout
+The default timeout value for context menus.
-The default timeout value intended to be used by context menus.
 */
 /*!
 \enum HbPopup::DismissPolicy
-This enum defines available dismiss policy values.
+Defines the available dismiss policy values. The dismiss policy defines which
+user actions cause the popup to close.
-The dismiss policy defines what user actions will cause the popup to be dismissed i.e. closed.
+\sa setDismissPolicy(), dismissPolicy()
 */
 /*!
 \var HbPopup::NoDismiss
+The popup cannot be closed by the user.
-The popup cannot be dismissed automatically by user interaction.
 */
 /*!
 \var HbPopup::TapInside
+Closes the popup when the user taps within the popup's bounding rectangle.
-The popup is dismissed when user taps within the bounding rectangle of the popup.
 */
 /*!
 \var HbPopup::TapOutside
-The popup is dismissed when user taps outside of the bounding rectangle of the popup.
+Closes the popup when the user taps outside of the popup's bounding rectangle.
 */
 /*!
 \var HbPopup::TapAnywhere
+Closes the popup when the user taps either inside or outside the popup's bounding
-The popup is dismissed when user taps either within or outside
+rectangle.
-of the bounding rectangle of the popup.
 */
 /*!
 \enum HbPopup::FrameType
-This enum defines available frame type values.
+Identifies the background graphical styles of the popup's frame.
-The frame types defines what frame item backgrounds will be used
+\sa setFrameType(), frameType()
-by the popup. Actual appearance is dependent on theme.
 */
 /*!
 \var HbPopup::Strong
+Use the "strong" frame background style.
-The popup is using strong frame.
 */
 /*!
 \var HbPopup::Weak
+Use the "weak" frame background style.
-The popup is using weak frame.
 */
 /*!
 \fn void HbPopup::aboutToShow();
-This signal is emitted when the popup is about to be shown i.e. when method show() is called.
+This signal is emitted when the popup is about to be shown; that is, when
+\link QGraphicsItem::show() show()\endlink is called.
 */
 /*!
 \fn void HbPopup::aboutToHide();
-This signal is emitted when the popup is about to be hidden i.e. when method hide() is called.
+This signal is emitted when the popup is about to be hidden; that is, when
+\link QGraphicsItem::hide() hide()\endlink is called.
 */
 /*!
 \fn void HbPopup::aboutToClose();
-This signal is emitted when the popup is about to be closed i.e. when method close() is called
+This signal is emitted when the popup is about to close; that is, when
-or the popup is
+\link QGraphicsWidget::close() close()\endlink is called or the popup is dismissed
-dismissed by the user or timeout.
+by the user or timeout.
 */
 /*!
 \enum HbPopup::Placement
+Identifies the corners and edges of the popup for use when setting its position
-Placement is the corner or edge to which position of the popup refers to.
+using setPreferredPos().
 */
 /*!
-\primitives
+\var HbPopup::TopLeftCorner
-\primitive{background} HbFrameItem representing the popup background. The background can be weak or strong (different graphical styles) depending on popup type.
+The popup's top left corner.
-\primitive{P_Popup_heading_frame} HbFrameItem representing the popup heading text background
+*/
-*/
+/*!
+\var HbPopup::TopRightCorner
+The popup's top right corner.
+*/
+/*!
+\var HbPopup::BottomLeftCorner
+The popup's bottom left corner.
+*/
+/*!
+\var HbPopup::BottomRightCorner
+The popup's bottom right corner.
+*/
+/*!
+\var HbPopup::TopEdgeCenter
+The center of the popup's top edge.
+*/
+/*!
+\var HbPopup::RightEdgeCenter
+The center of the popup's rightmost edge.
+*/
+/*!
+\var HbPopup::BottomEdgeCenter
+The center of the popup's bottom edge.
+*/
+/*!
+\var HbPopup::LeftEdgeCenter
+The center of the popup's leftmost edge.
+*/
+/*!
+\var HbPopup::Center
+The center of the popup.
+*/
 static const struct { HbPopup::DefaultTimeout timeout; int value; } timeoutValues[] =
 {
 {HbPopup::NoTimeout,0},
 {HbPopup::ConfirmationNoteTimeout,1500},
 {HbPopup::StandardTimeout,3000},
 {HbPopup::ContextMenuTimeout,6000},
 };
+/*
+\primitives
+\primitive{background} HbFrameItem representing the popup background. The background can be
+weak or strong (different graphical styles) depending on popup type.
+\primitive{P_Popup_heading_frame} HbFrameItem representing the popup heading text background
+*/
 HbPopupBackGround::HbPopupBackGround(HbPopup * popup, QGraphicsItem *parent) :
 QGraphicsItem(parent),
 popup(popup)
 {
 // This is needed to be able to block moving the focus to items behind background item by
 dismissPolicy(HbPopup::TapOutside),
 backgroundItem(0),
 mousePressLocation(None),
 frameType(HbPopup::Strong),
 preferredPosSet(false),
-mStartEffect(false),
+placement(HbPopup::TopLeftCorner),
+mStartEffect(true),
 mScreenMargin(0.0),
 mAutoLayouting(true),
 mOriginalAutoLayouting(mAutoLayouting),
+mActivePopup(true),
 mVgMaskEffect(0),
 mOrientationEffectHide(false),
+mGestureOverride(false),
 timeoutTimerInstance(0)
 {
 }
 HbPopupPrivate::~HbPopupPrivate()
 q->setAttribute(Hb::InsidePopup);
 // By default popups are focusable
 q->setFocusPolicy(Qt::StrongFocus);
-setBackgroundItem(HbStyle::P_Popup_background);
+setBackgroundItem(HbStylePrivate::P_Popup_background);
 q->updatePrimitives();
 // Only for popup without parent
 if (!q->parentItem()) {
 hidingInProgress = false;
 QGraphicsItem::GraphicsItemFlags itemFlags = q->flags();
 itemFlags |= QGraphicsItem::ItemClipsToShape;
 itemFlags |= QGraphicsItem::ItemClipsChildrenToShape;
 itemFlags |= QGraphicsItem::ItemSendsGeometryChanges;
-//itemFlags |= QGraphicsItem::ItemIsPanel;
+itemFlags |= QGraphicsItem::ItemIsPanel;
 q->setFlags(itemFlags);
 }
 void HbPopupPrivate::_q_appearEffectEnded(HbEffect::EffectStatus status)
 {
-	Q_UNUSED(status);
+Q_UNUSED(status);
 }
 CSystemToneService* HbPopupPrivate::systemToneService()
 {
 	return HbInstancePrivate::d_ptr()->systemTone();
 #ifdef HB_EFFECTS
 void HbPopupPrivate::_q_delayedHide(HbEffect::EffectStatus status)
 {
 Q_UNUSED(status);
 Q_Q(HbPopup);
 // Apply forceHide only if the effect started successfully
 if (status.reason != Hb::EffectNotStarted) {
 forceHide();
 if (deleteOnClose) {
 q->deleteLater();
 }
 hidingInProgress = false;
+mGestureOverride = false;
 }
 void HbPopupPrivate::_q_orientationAboutToChange(Qt::Orientation orient, bool animate)
 {
 Q_UNUSED(orient);
 #endif // HB_EFFECTS
 void HbPopupPrivate::_q_orientationChanged()
 {
 Q_Q(HbPopup);
-if (q->isVisible()) {
+if (q->isVisible() || q) {
 QEvent userEvent(QEvent::ContextMenu);
 QCoreApplication::sendEvent(q, &userEvent);
 }
 #ifdef HB_EFFECTS
 if (mOrientationEffectHide) {
 void HbPopupPrivate::handleBackgroundMousePressEvent()
 {
 Q_Q(HbPopup);
 mousePressLocation = Background;
-if (dismissPolicy & HbPopup::TapOutside) {
+if (dismissPolicy & HbPopup::TapOutside && !modal) {
 q->close();
 }
 }
 void HbPopupPrivate::handleBackgroundMouseReleaseEvent(QGraphicsSceneMouseEvent *event)
 // Close popup if mouse press is initiated within popup or TapOutside is set
 if (mousePressLocation == Popup || dismissPolicy & HbPopup::TapOutside) {
 q->close();
 }
 }
+} else if ( mousePressLocation == Background &&
+dismissPolicy & HbPopup::TapOutside && modal) {
+q->close();
 }
 }
 // reset mousePressLocation
 mousePressLocation = None;
 }
 }
 void HbPopupPrivate::calculateShape()
 {
-#if 0
 Q_Q(HbPopup);
+// Only used for HbMenu currently, this is not fully correct as some dialogs may need masking too.
+if (q->type() != Hb::ItemType_Menu) {
+return;
+}
+// Cannot set up masking if the background item is not available.
+if (!q->backgroundItem() || !q->backgroundItem()->boundingRect().isValid()) {
+return;
+}
 // Contrary to the name, HbVgMaskEffect has a software
 // implementation too, and we will actually force the usage of
 // that here, ignoring the pure OpenVG version.
 if (!mVgMaskEffect) {
 mVgMaskEffect = new HbVgMaskEffect;
 mVgMaskEffect->setForceSwMode(true);
 // There may be children (like the scroll area in menus) that
 // would mess up the masking so exclude those.
 mVgMaskEffect->setIncludeSourceItemOnly(true);
 if (!q->graphicsEffect()) {
-// Attach the effect. Ownership is transferred to q.
+// Attach the effect. Ownership is transferred to the chain. The
-mVgMaskEffect->install(q);
+// ownership of the chain is transferred to q.  The chain is needed
+// because we must co-exist with FXML-based filter effects.
+HbVgChainedEffect *c = new HbVgChainedEffect;
+c->add(mVgMaskEffect);
+c->install(q);
 } else {
-// Avoid replacing already set effects. Do not mask if
+// Avoid replacing already set effects. Do not mask if this is not
-// this is not possible, otherwise we would unexpectedly
+// possible, otherwise we would unexpectedly delete the previously
-// delete the previously set graphics effect.
+// set graphics effect. However by being able to add the effect to a
+// chain makes it possible to co-exist with FXML-based filter
+// effects. Similar solution is also present in HbEffectGroup.
 HbVgChainedEffect *c = qobject_cast<HbVgChainedEffect *>(q->graphicsEffect());
 if (c) {
 c->add(mVgMaskEffect);
 } else {
 delete mVgMaskEffect;
+mVgMaskEffect = 0;
 }
 }
 }
-QPixmap image(QSize(static_cast<int>(q->backgroundItem()->boundingRect().width()),
+QPixmap image(q->backgroundItem()->boundingRect().size().toSize());
-static_cast<int>(q->backgroundItem()->boundingRect().height())));
 image.fill(Qt::transparent);
 QPainter imagePainter(&image);
 q->backgroundItem()->paint(&imagePainter, 0, 0);
 imagePainter.end();
 mVgMaskEffect->setMask(image);
-#endif
+}
-}
+void HbPopupPrivate::resizePopup()
-/*!
+{
-Constructs a popup with given  \a parent graphics item.\n
-Note: popups with \a parent set as 0 are behaving as real popups.
+}
-This is actually the intended use.
+/*!
-However in some situation could be useful to embedd a popup into a QGraphicsItem.
+Constructs a popup with the given \a parent graphics item. For true popup
-In this case a non zero \a parent value must be passed.
+behavior (which means that it opens above other objects, at the highest z-order)
-Popups with parent items behaving just like any other QGraphicsWidget.
+set \a parent to 0. This is the primary intended use of this class.
-The following features are not supported (i.e. ignored) for popup with parents:
+However, it may sometimes be useful to embed a popup into a QGraphicsItem. To do
-- modality
+this, pass a non-zero \a parent value. HbPopup objects that have a parent are
-- timeout
+not real popups: they behave like any other QGraphicsWidget object and following
-- unfadedItems
+properties are ignored. In addition the aboutToClose() signal is not emitted.
-- dismissPolicy
-- signal aboutToClose
+- \link isModal() modal\endlink property
+- \link timeout() timeout\endlink  property
+- \link isBackgroundFaded() Backgroundfaded\endlink property
+- \link  dismissPolicy() dismissPolicy\endlink property
 */
 HbPopup::HbPopup(QGraphicsItem *parent) :
 HbWidget(*new HbPopupPrivate,parent)
 {
 Q_D(HbPopup);
 Q_D(HbPopup);
 d->q_ptr = this;
 d->init();
 }
 /*!
-Destroys the popup.
+Destructor.
 */
 HbPopup::~HbPopup()
 {
 Q_D(HbPopup);
 d->inDestruction = true;
 delete d->backgroundItem;
 }
 }
 }
+/*!
-/*!
+Returns the popup's timeout property in milliseconds. The timeout causes the popup to
-Returns the popup timeout property in milliseconds.
+be dismissed automatically after the specified time period has elapsed. A value of
-If this property is not set the deafult is HbPopup::StandardTimeout.
+zero or less than zero, means that the popup is permanent and the user must take
-\sa setTimeout()
+some explicit action in order to close the popup.
+The default value for this property is HbPopup::StandardTimeout.
+\sa setTimeout(), setTimeout(HbPopup::DefaultTimeout)
 */
 int HbPopup::timeout() const
 {
 Q_D(const HbPopup);
 return d->timeout;
 }
 /*!
-Sets the popup timeout property in milliseconds.
+Sets the popup's timeout property in milliseconds. A value of zero or less than zero
-If timeout <= 0 then the popup is permanent and not closed automatically.
+means that the popup is permanent and is not closed automatically.
-\sa timeout() setTimeout(HbPopup::DefaultTimeout) QGraphicsWidget::close()
+\overload
+\sa timeout() setTimeout(HbPopup::DefaultTimeout), QGraphicsWidget::close()
 */
 void HbPopup::setTimeout(int timeout)
 {
 Q_D(HbPopup);
 d->setTimeout(timeout);
 //d->timeout = timeout;
 }
 /*!
-It is a convenience overload of \a timeout() for setting HbPopup::DefaultTimeout values
+Sets the popup's timeout property to the default value for a standard popup type.
-to achieve common look & feel.
+This has the advantage of creating a common look and feel.
-\sa enum DefaultTimeout
-\sa timeout() setTimeout(int) QGraphicsWidget::close()
+\overload
+\sa timeout(), setTimeout(int), QGraphicsWidget::close()
 */
 void HbPopup::setTimeout(HbPopup::DefaultTimeout timeout)
 {
 setTimeout(HbPopupPrivate::timeoutValue(timeout));
 }
 /*!
-Returns the popup modality property.
+Returns the popup's modality property. A modal popup blocks any user-initiated
-A modal popup blocks any user initiated events outside of the popup
+events outside of the popup until it is closed.
-until it is closed.
+\sa setModal()
-\sa setModal()
 */
 bool HbPopup::isModal() const
 {
 Q_D(const HbPopup);
 return d->modal;
 }
 /*!
-Sets the popup modality property.
+Sets the popup's modality property.
-\sa isModal()
+To open a modal popup, call open(). To open a non-modal popup, call
+\link QGraphicsItem::show() show()\endlink.
+\sa isModal()
 */
 void HbPopup::setModal(bool enabled)
 {
 Q_D(HbPopup);
 d->modal = enabled;
 d->doSetModal( d->modal );
 }
 /*!
-Sets the background of popup faded if \a fadeBackground is true otherwise
+Sets the popup's background fade policy property. When this is set to true, it causes
-the background will not be faded.
+everything behind the popup to be faded.
 \sa isBackgroundFaded()
 */
 void HbPopup::setBackgroundFaded(bool fadeBackground)
 {
 Q_D(HbPopup);
 d->fadeBackground = fadeBackground;
 }
 /*!
-Returns if the background of the popup is faded or not.
+Returns the popup's background fade policy property. This controls whether
-Default: true
+everything behind the popup is faded while the popup is on the screen. Typically
-\sa isBackgroundFaded()
+this property is set to true for modal dialogs only. The default is true.
+\sa setBackgroundFaded()
 */
 bool HbPopup::isBackgroundFaded() const
 {
 Q_D(const HbPopup);
 return d->backgroundItem && d->fadeBackground;
 }
 /*!
-Returns the dismiss policy of the popup.
+Returns the popup's dismiss policy. This defines which user actions (if any) cause
-Default is HbPopup::TapOutside.
+the popup to close. The default is HbPopup::TapOutside.
 \sa setDismissPolicy()
 */
 HbPopup::DismissPolicy HbPopup::dismissPolicy() const
 {
 Q_D(const HbPopup);
 return d->dismissPolicy;
 }
 /*!
-Sets the dismiss policy property for the the popup.
+Sets the popup's dismiss policy property.
 \sa dismissPolicy()
 */
 void HbPopup::setDismissPolicy(HbPopup::DismissPolicy dismissPolicy)
 {
 Q_D(HbPopup);
 d->dismissPolicy = dismissPolicy;
 }
 /*!
-Returns the frame type of the popup.
+Returns the popup's frame type. This controls the popup's background style. However,
-Default is HbPopup::Strong
+the actual appearance depends on the theme. The default value is HbPopup::Strong.
-\sa setFrameType()
+\sa setFrameType()
 */
 HbPopup::FrameType HbPopup::frameType() const
 {
 Q_D(const HbPopup);
 return d->frameType;
 }
 /*!
-Sets the frame typeproperty for the the popup.
+Sets the popup's frame type, which controls the popup's background style.
 \sa frameType()
 */
 void HbPopup::setFrameType(HbPopup::FrameType frameType)
 {
 Q_D(HbPopup);
 if ( d->frameType != frameType ) {
 switch( frameType ) {
 case HbPopup::Weak:
-d->setBackgroundItem(HbStyle::P_Popup_background_weak);
+d->setBackgroundItem(HbStylePrivate::P_Popup_background_weak);
 break;
 case HbPopup::Strong:
 default:
-d->setBackgroundItem(HbStyle::P_Popup_background);
+d->setBackgroundItem(HbStylePrivate::P_Popup_background);
 break;
 }
 d->frameType = frameType;
 updatePrimitives();
 }
 }
 /*!
-Shows the popup as modal popup returning immediately.
+Displays the popup on the screen and returns immediately. This function also
+connects the popup's aboutToClose() signal to a specified slot. The signal
-Connects aboutToClose() signal to the slot specified by \a receiver and
+is disconnected from the slot when the popup closes.
-\a member. The signal will be disconnected from the slot when the
-popup is closed.
+Use this function to open modal popups. To open non-modal popups, call
+\link QGraphicsItem::show() show()\endlink.
-For non modal popups, use show().
+\param receiver  The object that is to receive the signal.
+\param member  The slot on the receiver to which the signal is to connect.
+\sa isModal()
 */
 void HbPopup::open( QObject *receiver, const char *member )
 {
 Q_D(HbPopup);
 if (receiver) {
 show();
 }
 /*!
-\reimp
 */
 QVariant HbPopup::itemChange ( GraphicsItemChange change, const QVariant & value )
 {
 Q_D(HbPopup);
 if (change == QGraphicsItem::ItemPositionChange) {
 d->mAutoLayouting = false;
 }
 if (change == QGraphicsItem::ItemVisibleHasChanged) {
 if (value.toBool()) {
-if(d->hasEffects && boundingRect().isValid()) {
+if (d->hasEffects && boundingRect().isValid() && d->polished) {
 #ifdef HB_EFFECTS
 QRectF extRect(0.0,
 -boundingRect().height(),
 boundingRect().width(),
 0);
-d->mStartEffect = true;
 HbEffect::cancel(this);
 d->mStartEffect = false;
-HbEffect::start(this, d->effectType, "appear", this, "_q_appearEffectEnded", QVariant(), extRect);
+HbEffectInternal::start(this, this, HbEffectInternal::UpdateAtEachStep,
-#endif//HB_EFFECTS
+d->effectType, "appear", this, "_q_appearEffectEnded",
-} else {
+QVariant(), extRect);
-d->mStartEffect = true;
+#endif //HB_EFFECTS
 }
 }
 }
 if (change == QGraphicsItem::ItemVisibleChange) {
 } else {
 d->aboutToShowSignalGuard = false;
 if (!d->hidingInProgress) {
 emit aboutToHide();
 }
 if (d->delayedHide &&  // about to hide and we wanna delay hiding
 d->hasEffects && !parentItem()) { // only for popup without parent
 bool hideDelayed = d->delayedHide;
 if (!d->hidingInProgress) { // Prevent reentrance
 d->hidingInProgress = true;
 QRectF extRect(0.0,
 -boundingRect().height(),
 boundingRect().width(),
 0);
 HbEffect::cancel(this);
-if (!HbEffect::start(this, d->effectType, "disappear",
+if (!HbEffectInternal::start(this, this, HbEffectInternal::UpdateAtEachStep,
-this, "_q_delayedHide",
+d->effectType, "disappear",
-QVariant(), extRect)) {
+this, "_q_delayedHide",
+QVariant(), extRect)) {
 d->delayedHide = false;
 return HbWidget::itemChange(change, value);
 }
+d->mGestureOverride = true;
 #endif
 }
 if (hideDelayed) {
 return true;
 } else {
 }
 return HbWidget::itemChange(change, value);
 }
 /*!
-\deprecated HbPopup::handlePopupPos()
+Reimplemented from QGraphicsItem.
-is deprecated. This function should not be used from the application side.
-Handles the popup position when Orientation changes
-*/
-void HbPopup::handlePopupPos()
-{
-HB_DEPRECATED("HbPopup::handlePopupPos() is deprecated.");
-QEvent userEvent(QEvent::ContextMenu);
-QCoreApplication::sendEvent(this, &userEvent);
-}
-/*!
-\reimp
 */
 void HbPopup::mousePressEvent(QGraphicsSceneMouseEvent *event )
 {
 Q_D(HbPopup);
 // to ignored
 event->accept();
 }
 /*!
-\reimp
+Reimplemented from QGraphicsItem.
 */
 void HbPopup::mouseReleaseEvent(QGraphicsSceneMouseEvent *event )
 {
 QGraphicsItem::mouseReleaseEvent(event);
 event->accept();
 // Note: Mouse release event is always handled in handleBackgroundMouseReleaseEvent
 }
 /*!
-\reimp
+Reimplemented from QGraphicsWidget.
 */
 //
 // Shows the popup with an animation and starts the timer to dismiss the popup,
 // unless it is a permanent popup.
 //
 //check if popup needs to be added to scene.This can result in duplciate show event,
 // if popup is added to scene here.
 if(d->addPopupToScene()) {
 d->duplicateShowEvent = true;
 }
-//setActive(true);
+if (d->mActivePopup) {
+setActive(true);
+}
 // Popup clears closed state
 d->closed = false;
 if (d->backgroundItem) {
 d->backgroundItem->setVisible(true);
-d->backgroundItem->setAcceptHoverEvents(isModal());
 if (isModal()) {
 d->backgroundItem->setFlag(QGraphicsItem::ItemIsPanel);
 }
 }
 if (qobject_cast<HbGraphicsScene *>(scene())) {
 }
 }
 }
 /*!
-\reimp
+Reimplemented from QGraphicsWidget.
 */
 void HbPopup::hideEvent(QHideEvent *event)
 {
 Q_D(HbPopup);
 if (d->eventLoop) {
 d->eventLoop->exit();
 }
 d->doSetModal( d->modal );
+if (d->mActivePopup) {
-}
+setActive(false);
+}
-/*!
+}
-\reimp
+/*!
+Reimplemented from QGraphicsWidget.
 */
 void HbPopup::resizeEvent( QGraphicsSceneResizeEvent * event )
 {
 HbWidget::resizeEvent(event);
 updatePrimitives();
 d->calculateShape();
 }
 }
 /*!
-\reimp
+Reimplemented from QGraphicsWidget.
 */
 void HbPopup::closeEvent ( QCloseEvent * event )
 {
 Q_D(HbPopup);
 d->stopTimeout();
 d->memberToDisconnectOnClose.clear();
 HbWidget::closeEvent(event);
 }
-/* Currently, virtual keyboard must be able to position a popup
+/*
-containing a editor to an arbitrary place. VKB does it's best to
+Currently, virtual keyboard must be able to position a popup
-reposition popup back to original position when needed. At least in
+containing an editor to an arbitrary place. VKB does its best to
+reposition the popup back to original position when needed. At least in
 orientation switch the old position naturally is wrong, hence popup
 must be relayouted.
 It would be unreasonable to make special checks for popup in vkb
 side. It also would be unreasonable to do special checks for vkb in
 raise a feature request and we might make this a proper API.
 */
 const char* KPositionManagedByVKB("PositionManagedByVKB");
 /*!
-\reimp
+Reimplemented from QGraphicsWidget.
 */
 bool HbPopup::event(QEvent *event)
 {
 Q_D(HbPopup);
 if ( event->type() == QEvent::DynamicPropertyChange ) {
 }
 }
 } else if (event->type() == QEvent::LayoutRequest) {
 //Workaround when showing first time
 #ifdef HB_EFFECTS
-if(d->mStartEffect && boundingRect().isValid()) {
+if (d->mStartEffect && boundingRect().isValid()) {
 d->mStartEffect = false;
 QCoreApplication::sendPostedEvents(this, QEvent::LayoutRequest);
 QRectF extRect(0.0,
 -boundingRect().height(),
 boundingRect().width(),
 0);
-d->mStartEffect = true;
 HbEffect::cancel(this);
-d->mStartEffect = false;
+HbEffectInternal::start(this, this, HbEffectInternal::UpdateAtEachStep,
-HbEffect::start(this, d->effectType, "appear", this, "_q_appearEffectEnded", QVariant(), extRect);
+d->effectType, "appear", this, "_q_appearEffectEnded",
-}
+QVariant(), extRect);
-#endif//HB_EFFECTS
+} else if (d->mStartEffect) {
+// Workaround for submenus that do not have any effect when shown
+// first. The appear/disappear effect would call update() a number
+// of times but in this case we have to do it manually.
+new HbPopupUpdater(this, this);
+}
+#endif //HB_EFFECTS
 //workaround ends
-}
+} else if (d->mGestureOverride && event->type() == QEvent::GestureOverride) {
+event->accept();
+return true;
+}
 return HbWidget::event(event);
 }
 /*!
-Sets preferred position\a position for popup with \a placement
+Sets the preferred position of the popup. By default, the popup is placed in the middle
-as origin.
+of the screen. If you use this function to set the preferred position, it is your
+responsibility to ensure that this position works correctly on devices with different
-By default popup is placed in the middle of the screen. If other positions are needed please
+screen sizes.
-ensure that the preferred position is working properly with different screen sizes.
+Typically you should set the preferred position only for context aware popups, such as
-\param position is the position at which the popup is shown.
+context menus and slider popups. The position is not relevant for most dialogs and
-\param placement is the corner or edge which \a position refers to
+popups and you should use the default position for these.
-Example usage:
+\param preferredPos Defines the coordinates of preferred position on the screen where
-\code
+the popup is to open.
-HbPopup *popup = new HbPopup();
+\param placement The corner or edge of the dialog that is to be placed at \a preferredPos.
-...
-popup->setPreferredPosition( QPointF(x,y), HbPopupBase::BottomEdgeCenter );
+\b Example:
-popup->show();
+\code
-\endcode
+HbPopup *popup = new HbPopup();
+popup->setPreferredPos( QPointF(x,y), HbPopup::BottomEdgeCenter );
+popup->show();
+\endcode
 */
 void HbPopup::setPreferredPos( const QPointF& preferredPos,
 HbPopup::Placement placement )
 {
 Q_D(HbPopup);
 QApplication::sendEvent(this, &layoutRequest);
 }
 }
 /*!
-\reimp
+Returns the shape of this item as a QPainterPath.
-Returns the shape of this item as a QPainterPath.
+*/
-*/
 QPainterPath HbPopup::shape() const
 {
 #if 0
 /*Q_D(const HbPopup);
 if (backgroundItem() && d->mPath) {
 #else
 return HbWidget::shape();
 #endif
 }
+/*!
+Reimplemented from HbWidget.
+*/
+void HbPopup::polish(HbStyleParameters &params)
+{
+HbWidget::polish(params);
+}
 #include "moc_hbpopup.cpp"

changeset 21	4633027730f5
parent 7	923ff622b8b9
child 23	e6ad4ef83b23