FCL/sf/mw/hb: comparison src/hbcore/effects/hbeffect.cpp

equal deleted inserted replaced

-:11d3954df52a
+:627c4a0fd0e7
 int result = key1.mItem - key2.mItem;
 // If that is same, compare effect event string
 if (!result) {
 result = key1.mEffectEvent.compare(key2.mEffectEvent);
 }
-return result<0;
+return result < 0;
 }
 static void fixEffectGroupOrder(QList<HbEffectGroup *> *groupList)
 {
 // If there is only one group, no need to change order
 groupList->append(group);
 movedCount++;
 }
 }
-if (last - movedCount > 0 ) {
+if (last - movedCount > 0) {
 for (int i = last - movedCount; i >= 0; --i) {
 HbEffectGroup *group = groupList->at(i);
 // If the group has a scale effect, move it second last before groups that had translate effects
 if (group->hasScaleEffect()) {
 groupList->takeAt(i);
 // Needed for notifying effect finish asynchronously
 qRegisterMetaType<HbEffect::EffectStatus>();
 }
 HbEffectPrivate::~HbEffectPrivate()
 {
 privateDestroyed = true;
 mDisabledItems.clear();
 }
 void HbEffectPrivate::connectViewChanges()
 {
 // Connect to view change signals if not done yet
 if (!mViewChangeConnected) {
 mViewChangeConnected = true;
 QList<HbMainWindow *> windowList = hbInstance->allMainWindows();
-foreach (const HbMainWindow *window, windowList) {
+foreach(const HbMainWindow * window, windowList) {
-connect(window, SIGNAL(currentViewChanged(HbView*)), SLOT(handleViewChanged(HbView*)));
+connect(window, SIGNAL(currentViewChanged(HbView *)), SLOT(handleViewChanged(HbView *)));
 }
 // Need a notification when a mainwindow is added in the future.
-connect(HbInstancePrivate::d_ptr(), SIGNAL(windowAdded(HbMainWindow*)), SLOT(handleWindowAdded(HbMainWindow*)));
+connect(HbInstancePrivate::d_ptr(), SIGNAL(windowAdded(HbMainWindow *)), SLOT(handleWindowAdded(HbMainWindow *)));
 }
 }
 void HbEffectPrivate::handleWindowAdded(HbMainWindow *window)
 {
-connect(window, SIGNAL(currentViewChanged(HbView*)), SLOT(handleViewChanged(HbView*)));
+connect(window, SIGNAL(currentViewChanged(HbView *)), SLOT(handleViewChanged(HbView *)));
 }
 void HbEffectPrivate::handleViewChanged(HbView *view)
 {
 // Observers may be notified during cancellations which may result in starting a new
 // effect during which groups may be deleted and removed from
 // mEventEffectList. Therefore we cannot directly iterate on mEventEffectList.
 QList<HbEffectGroup *> groupsToBeHandled;
-foreach (HbEffectGroup *group, d.mEventEffectList) {
+foreach(HbEffectGroup * group, d.mEventEffectList) {
 groupsToBeHandled.append(group);
 }
-foreach (HbEffectGroup *group, groupsToBeHandled) {
+foreach(HbEffectGroup * group, groupsToBeHandled) {
 // Check if the real list still contains the group. If not then it may have been
 // deleted and removed meanwhile so do nothing.
 if (d.mEventEffectList.values().contains(group)) {
 if (group->isRunning()) {
 // Looping effect
 if (group->isLooping()) {
 if (group->view() == view) {
 group->resume(); // Effect's view activated, resume effect
 } else {
 group->pause(); // Effect's view deactivated, pause effect
 }
 } else { // Non-looping effect
 if (group->view() != view) { // Effect's view deactivated, cancel the effect
 group->cancelAll(true);
+// remove group from eventEffectsList
-// remove group from eventEffectsList
+QMap<EffectMapKey, HbEffectGroup *>::iterator e = d.mEventEffectList.begin();
-QMap<EffectMapKey, HbEffectGroup *>::iterator e = d.mEventEffectList.begin();
+while (e != d.mEventEffectList.end()) {
-while (e != d.mEventEffectList.end()) {
+if (e.value() == group) { // found, erase from event effect list
-if (e.value() == group) { // found, erase from event effect list
+d.mEventEffectList.erase(e);
-d.mEventEffectList.erase(e);
+delete group; // once removed from list, delete group
-							 delete group; // once removed from list, delete group
+e = d.mEventEffectList.end();
-e = d.mEventEffectList.end();
+} else {
-}
+e++;  // try next one
-else
+}
-e++;  // try next one
+}
 }
 }
 }
 }
 }
-}
 }
 HbAnimatedItemGroup::HbAnimatedItemGroup(
 const QList<QGraphicsItem *> &items,
 mUserData(userData)
 {
 // Need information of receiver destroyed because this class gets
 // the notifications asynchronously so it must not invoke the
 // receiver if it has been destroyed meanwhile.
 connect(mReceiver, SIGNAL(destroyed()), this, SLOT(receiverDestroyed()));
 }
 void HbAnimatedItemGroup::finished(const HbEffect::EffectStatus &status)
 {
 if (++mFinishedCount == mItems.count()) {
 Q_UNUSED(effectEvent);
 return false;
 #else
 // This API cannot be used to add HB library's effect definitions.
 // There is internal API in class HbEffectInternal for that.
-if (itemType.startsWith(HB_EFFECT_ITEM_PREFIX))
+if (itemType.startsWith(HB_EFFECT_ITEM_PREFIX)) {
-{
 return false;
 }
 return HbEffectInternal::add(itemType, filePath, effectEvent);
 #endif //HB_EFFECT_API_OFF
 Q_UNUSED(itemType);
 Q_UNUSED(filePath);
 Q_UNUSED(effectEvent);
 return false;
 #else
-foreach (const QString &type, itemType) {
+foreach(const QString & type, itemType) {
-if (type.startsWith(HB_EFFECT_ITEM_PREFIX))
+if (type.startsWith(HB_EFFECT_ITEM_PREFIX)) {
 return false;
+}
 }
 return HbEffectInternal::add(itemType, filePath, effectEvent);
 #endif // HB_EFFECT_API_OFF
 }
 Q_UNUSED(effectEvent);
 return false;
 #else
 // This API cannot be used to remove HB library's effect definitions.
 // There is internal API in class HbEffectInternal for that.
-if (itemType.startsWith(HB_EFFECT_ITEM_PREFIX))
+if (itemType.startsWith(HB_EFFECT_ITEM_PREFIX)) {
-{
 return false;
 }
 HbEffectInternal::remove(itemType, filePath, effectEvent);
 return true;
 #endif //HB_EFFECT_API_OFF
 HbEffectInternal::remove(item);
 return true;
 #endif //HB_EFFECT_API_OFF
 }
 /*! \brief This function is used to start an effect on a graphics item.
 The effect definition is taken from the FXML file registered for the graphics
 item with matching itemType and effectEvent.
 \param item The target item for the effect
 The function returns \c false if some invalid parameter is passed, or if the
 effect was disabled using disable().
 Example to get notification of effect completion.
 \code
 // Create a public slot in a the widget class if you want to get effect-finished
 // notification. In normal scenario, the widget itself can be receiver. But it is possible
 // to use any QObject as receiver.
 class MyHbWidget : public HbWidget
 {
 Q_OBJECT
 public slots:
 void effectFinished(const HbEffect::EffectStatus &status);
 // Other stuffs
 };
 void MyObserver::effectFinished(const HbEffect::EffectStatus &status)
 {
 // Effect is finished. Do something.
 }
 // Some function which starts effect..
 void MyHbWidget::myFunction()
 {
 // myFunction related other stuff
 // calling startefect
 HbEffect::start(myGraphicsItem,
 "myItemType",
 "myEvent",
 this,
 "effectFinished");
 // myFunction related other stuff
 }
 \endcode
 \sa cancel()
 */
 bool HbEffect::start(QGraphicsItem *item,
 const QString &itemType,
 const QString &effectEvent,
 QObject *receiver,
 const char *member,
 const QVariant &userData,
 const QRectF &extRect)
 \sa HbEffect::EffectStatus
 The function returns \c false if some invalid parameter is passed, or if the
 effect was disabled using disable().
 */
 bool HbEffect::start(QGraphicsItem *item,
 const QString &effectEvent,
 QObject *receiver,
 const char *member,
 const QVariant &userData,
 const QRectF &extRect)
 Q_UNUSED(userData);
 Q_UNUSED(extRect);
 return false;
 #else
 return HbEffect::start(
 item, HB_EFFECT_INTERNAL_ITEM, effectEvent, receiver, member, userData, extRect);
 #endif //HB_EFFECT_API_OFF
 }
 /*!  \brief This function starts the same effect simultaneously for a given list
 of graphics items.
 The function returns \c false if some invalid parameter is passed, or if the
 effect was disabled using disable().
 */
 bool HbEffect::start(
 const QList<QGraphicsItem *> &items,
 const QString &itemType,
 const QString &effectEvent,
 QObject *receiver,
 const char *member,
 const QVariant &userData)
 {
 #ifdef HB_EFFECT_API_OFF
 Q_UNUSED(items);
 Q_UNUSED(itemType);
 Q_UNUSED(effectEvent);
 Q_UNUSED(receiver);
 Q_UNUSED(member);
 Q_UNUSED(userData);
 return false;
 if (receiver) {
 groupReceiver = group;
 groupMember = "finished";
 }
-foreach (QGraphicsItem *item, items) {
+foreach(QGraphicsItem * item, items) {
 if (HbEffect::start(item, itemType, effectEvent, groupReceiver, groupMember, userData)) {
 // If at least one item succeeded to start, set return value to true
 ret = true;
 }
 }
 bool ret = false;
 // Return true if the given item is running any effect
 if (effectEvent.isEmpty()) {
 for (QMap<EffectMapKey, HbEffectGroup *>::const_iterator e = d.mEventEffectList.constBegin();
 e != d.mEventEffectList.constEnd();
-++e ) {
+++e) {
 HbEffectGroup *group = *e;
 if (group->registrationItem() == item && group->isRunning()) {
 ret = true;
 break;
 }
 }
 } else {
 // effectEvent was specified, check if effect matching that is running
 EffectMapKey key(item, effectEvent);
 QMap<EffectMapKey, HbEffectGroup *>::const_iterator e = d.mEventEffectList.find(key);
 // Effect found in the list?
-if(e != d.mEventEffectList.constEnd()) {
+if (e != d.mEventEffectList.constEnd()) {
-HbEffectGroup* group = *e;
+HbEffectGroup *group = *e;
 ret = group->isRunning();
 }
 }
 return ret;
 Q_UNUSED(effectEvent);
 Q_UNUSED(clearEffect);
 Q_UNUSED(sendCallback);
 Q_UNUSED(itemIsValid);
 return false;
 #else
 if (privateDestroyed) {
 return false;
 }
 bool ret = false;
 if (effectEvent.isEmpty()) {
 // Stop all the effects running on item at that point of time.
 // (iterator way had some problem and caused crash so using foreach)
 QList<HbEffectGroup *> groupsToBeCanceled;
-foreach (const EffectMapKey &key, d.mEventEffectList.keys()) {
+QList<EffectMapKey> keys = d.mEventEffectList.keys();
+foreach(const EffectMapKey & key, keys) {
 if (key.mItem == item) {
-HbEffectGroup* group = d.mEventEffectList.take(key);
+HbEffectGroup *group = d.mEventEffectList.take(key);
 groupsToBeCanceled.append(group);
 }
 }
 // Before blindly calling cancelAll to the effect groups, try to fix their order so that
 // may still be incorrect end state if there are multiple effect groups which each have multiple effects,
 // but this at least fixes cases, where there are multiple effect groups which each consist of a single effect.
 fixEffectGroupOrder(&groupsToBeCanceled);
 bool first = true;
-foreach (HbEffectGroup *group, groupsToBeCanceled) {
+foreach(HbEffectGroup * group, groupsToBeCanceled) {
 // If clearEffect is false then it is important to pass a default transform
 // first so the matrix multiplication in cancelAll ends up correct.
 group->cancelAll(sendCallback, itemIsValid, clearEffect, first || !itemIsValid ? QTransform() : item->transform());
 if (first) {
 first = false;
 ret = true;
 }
 return ret;
 } else {
 EffectMapKey key(item, effectEvent);
-HbEffectGroup* group = d.mEventEffectList.take(key);
+HbEffectGroup *group = d.mEventEffectList.take(key);
 if (group) {
 group->cancelAll(sendCallback, itemIsValid, clearEffect);
 delete group;
 return true;
 } else {
 effect for a graphicsitem was disabled this method can be used to enable the
 effect again for that item.
 The function takes following parameters:
 \param item pointer to QGraphicsItem for which the effect will be enabled.
 \sa disable()
 */
 void HbEffect::enable(QGraphicsItem *item)
 {
 #ifdef HB_EFFECT_API_OFF
 }
 /*! This function can be used to disable an effect for a graphicsitem. This is
 useful in cases where you have a component which usually shows an effect but
 you want to skip the effect for your object.
 You can enable the effect using enable(), and you should always call enable()
 once you do not need the object to be disabled, at latest when you're deleting
 your animated graphicsitem. This should be done to clean up the list of
 disabled items. Note that if the animated item is an HbWidget, then the
 enable() call happens automatically at the HbWidget destructor.
 Unlike remove()-methods, this won't touch the effect definition at all. The
 effect is just skipped when trying to start the effect.  Note also that
 start()-method returns false if the effect is disabled.
 \param item pointer to QGraphicsItem for which the effect will be disabled
 \sa enable()
 \sa start()
 */
 void HbEffect::disable(QGraphicsItem *item)
 {
 }
 /*!
 \internal
 */
-HbGVWrapperItem::HbGVWrapperItem():mMainWindow(0)
+HbGVWrapperItem::HbGVWrapperItem(): mMainWindow(0)
 {
 }
-void HbGVWrapperItem::setMainWindow(HbMainWindow& mainWindow)
+void HbGVWrapperItem::setMainWindow(HbMainWindow &mainWindow)
 {
 mMainWindow = &mainWindow;
 }
 HbMainWindow *HbGVWrapperItem::mainWindow() const
 QRectF HbGVWrapperItem::boundingRect() const
 {
 QRectF bRect;
 // viewportitem is used as a boundingrect since viewport item gets resized when changing orientation
-if( mMainWindow ) {
+if (mMainWindow) {
 bRect = mMainWindow->layoutRect();
 }
 return bRect;
 }
 void HbGVWrapperItem::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
 {
 Q_UNUSED(painter);
 Q_UNUSED(option);
 Q_UNUSED(widget);
 };
 bool ret = d.mController.addFXML(itemType, filePath, effectEvent, true);
 if (ret) {
 // Mark all effects using the given item type dirty,
 // so that they get re-created when the effect is shown next time
 for (QMap<EffectMapKey, HbEffectGroup *>::iterator e = d.mEventEffectList.begin();
 e != d.mEventEffectList.end();
-++e ) {
+++e) {
 HbEffectGroup *group = *e;
 if (group->itemType() == itemType) {
 group->setDirty(true);
 }
 }
 }
 if (ret) {
 // Mark all effects using the given item type dirty,
 // so that they get re-created when the effect is shown next time
 for (QMap<EffectMapKey, HbEffectGroup *>::iterator e = d.mEventEffectList.begin();
 e != d.mEventEffectList.end();
-++e ) {
+++e) {
 HbEffectGroup *group = *e;
 if (group->registrationItem() == item) {
 group->setDirty(true);
 }
 }
 }
 Q_UNUSED(filePath);
 Q_UNUSED(effectEvent);
 #else
 // FXML
 // If extension is not given then try both with and without .fxml
-if (!filePath.endsWith(".fxml")) {
+if (!filePath.endsWith(QLatin1String(".fxml"))) {
-d.mController.removeFXML(itemType, filePath + ".fxml", effectEvent);
+d.mController.removeFXML(itemType, filePath + QLatin1String(".fxml"), effectEvent);
 }
 d.mController.removeFXML(itemType, filePath, effectEvent);
 // Clean up mEventEffectList.
-foreach (const EffectMapKey &key, d.mEventEffectList.keys()) {
+QList<EffectMapKey> keys = d.mEventEffectList.keys();
+foreach(const EffectMapKey & key, keys) {
 if (key.mEffectEvent == effectEvent) {
 HbEffectGroup *group = d.mEventEffectList.value(key);
 group->setDirty(true); // so the next start() will try to recreate the effect instead of re-using it
 }
 }
 Q_UNUSED(filePath);
 Q_UNUSED(effectEvent);
 #else
 // FXML
 // If extension is not given then try both with and without .fxml
-if (!filePath.endsWith(".fxml")) {
+if (!filePath.endsWith(QLatin1String(".fxml"))) {
-d.mController.removeFXML(item, filePath + ".fxml", effectEvent);
+d.mController.removeFXML(item, filePath + QLatin1String(".fxml"), effectEvent);
 }
 d.mController.removeFXML(item, filePath, effectEvent);
 // Clean up mEventEffectList.
-foreach (const EffectMapKey &key, d.mEventEffectList.keys()) {
+QList<EffectMapKey> keys = d.mEventEffectList.keys();
+foreach(const EffectMapKey & key, keys) {
 if (key.mItem == item && key.mEffectEvent == effectEvent) {
 HbEffectGroup *group = d.mEventEffectList.value(key);
 group->setDirty(true);
 }
 }
 #else
 if (item) {
 d.mDisabledItems.removeOne(item); // clean the disabled list as well
 d.mController.removeFXML(item);
 // Clean up mEventEffectList.
-foreach (const EffectMapKey &key, d.mEventEffectList.keys()) {
+QList<EffectMapKey> keys = d.mEventEffectList.keys();
+foreach(const EffectMapKey & key, keys) {
 if (key.mItem == item) {
 HbEffectGroup *group = d.mEventEffectList.value(key);
 group->setDirty(true);
 }
 }
 //ToDo Currently all the parsed Fxml Data is being deleted with themechange.
 //     Make this function intelligent enough to delete only theme specific Fxml
 //     data.
 //parsedDataList.clear();
 QList<HbEffectInfo> newDataList;
-for (int i=0; i < parsedDataList.count(); i++) {
+for (int i = 0; i < parsedDataList.count(); i++) {
 if (parsedDataList[i].fromTheme()) {
 newDataList.append(parsedDataList[i]);
 parsedDataList.removeAt(i);
 i--;
 }
 }
-for (int i=0; i < newDataList.count(); i++) {
+for (int i = 0; i < newDataList.count(); i++) {
 HbEffectInfo effectData = newDataList.at(i);
 bool ret = false;
 QString relativename = QFileInfo(effectData.xmlFileFullPath()).baseName();
 if (effectData.item() != 0) {
 ret = d.mController.addFXML(effectData.item(), relativename,
 effectData.effectEvent(), true);
-}
+} else if (!effectData.componentType().isEmpty()) {
-else if (!effectData.componentType().isEmpty()) {
 ret = d.mController.addFXML(effectData.componentType(), relativename,
 effectData.effectEvent(), true);
 }
 if (ret) {
 // Mark all effects using the given item type dirty,
 // so that they get re-created when the effect is shown next time
 for (QMap<EffectMapKey, HbEffectGroup *>::iterator e = d.mEventEffectList.begin();
 e != d.mEventEffectList.end();
-++e ) {
+++e) {
 HbEffectGroup *group = *e;
 if (group->registrationItem() == effectData.item()) {
 group->setDirty(true);
 }
 }
 /*!
 Cancels all effects. List of graphicsitems can be given as an exception which are not cancelled.
 This is used for example when changing orientation; all but the orientation change effects
 are cancelled.
 */
-void HbEffectInternal::cancelAll(const QList<QGraphicsItem*> *exceptionList, bool ignoreLooping)
+void HbEffectInternal::cancelAll(const QList<QGraphicsItem *> *exceptionList, bool ignoreLooping)
 {
 // Observers may be notified during cancelations which may result in starting a new
 // effect during which groups may be deleted and removed from
 // mEventEffectList. Therefore we cannot directly iterate on mEventEffectList.
 QList<HbEffectGroup *> groupsToBeCanceled;
-foreach (HbEffectGroup *group, d.mEventEffectList) {
+foreach(HbEffectGroup * group, d.mEventEffectList) {
 groupsToBeCanceled.append(group);
 }
-foreach (HbEffectGroup *group, groupsToBeCanceled) {
+foreach(HbEffectGroup * group, groupsToBeCanceled) {
 // Check if the real list still contains the group. If not then it may have been
 // deleted and removed meanwhile so do nothing.
 if (d.mEventEffectList.values().contains(group)) {
 if (!exceptionList || !exceptionList->contains(group->registrationItem())) {
 // Already cancelled effects may refer to graphics items that do not
 be valid anymore.
 */
 void HbEffectInternal::safeCancelAll(bool clear)
 {
 QList<HbEffectGroup *> groupsToBeCanceled;
-foreach (HbEffectGroup *group, d.mEventEffectList) {
+foreach(HbEffectGroup * group, d.mEventEffectList) {
 groupsToBeCanceled.append(group);
 }
-foreach (HbEffectGroup *group, groupsToBeCanceled) {
+foreach(HbEffectGroup * group, groupsToBeCanceled) {
 if (d.mEventEffectList.values().contains(group)) {
 group->cancelAll(false, false, clear);
 }
 }
 }
 \sa HbEffectInternal::resumeEffects()
 */
 void HbEffectInternal::stopEffects()
 {
-// Pause looping effects and stop others
+// Pause looping effects and stop others. As usual, we cannot just
-foreach (HbEffectGroup *group, d.mEventEffectList) {
+// simply iterate through the list as cancelAll() may change the
-if (group->isRunning()) {
+// elements in mEventEffectList.
-if (group->isLooping()) {
+QList<HbEffectGroup *> groupsToBeChecked;
-group->pause();
+foreach(HbEffectGroup * group, d.mEventEffectList) {
-} else {
+groupsToBeChecked.append(group);
-group->cancelAll(true);
+}
+foreach(HbEffectGroup * group, groupsToBeChecked) {
+if (d.mEventEffectList.values().contains(group)) {
+if (group->isRunning()) {
+if (group->isLooping()) {
+group->pause();
+} else {
+group->cancelAll(true);
+}
 }
 }
 }
 }
 \sa HbEffectInternal::stopEffects()
 */
 void HbEffectInternal::resumeEffects()
 {
 // Resume any looping effects that were paused with stopEffects call.
-foreach (HbEffectGroup *group, d.mEventEffectList) {
+foreach(HbEffectGroup * group, d.mEventEffectList) {
 if (group->isRunning() && group->isLooping()) {
 group->resume();
 }
 }
 }
 \sa HbEffect::start()
 */
 bool HbEffectInternal::start(QGraphicsItem *registrationItem,
 QGraphicsItem *targetItem,
 EffectFlags flags,
 const QString &itemType,
 const QString &effectEvent,
 QObject *receiver,
 const char *member,
 const QVariant &userData,
 const QRectF &extRect)
 EffectMapKey key(registrationItem, effectEvent);
 QMap<EffectMapKey, HbEffectGroup *>::iterator e = d.mEventEffectList.find(key);
 // Same effect found in the list?
-if(e != d.mEventEffectList.end()) {
+if (e != d.mEventEffectList.end()) {
 HbEffectGroup *group = e.value();
 if (!group->dirty()) {
 // if the effect group is not dirty, restart it. Cancel possible earlier
 // effect first so that end position gets correct.
 group->cancelAll(true);
 // Update with given notification parameters
 updateGroup(group, receiver, member, userData, extRect, flags);
 group->startAll();
 started = true;

changeset 5	627c4a0fd0e7
parent 1	f7ac710697a9
child 21	4633027730f5
child 34	ed14f46c0e55