FCL/sf/mw/hb: comparison src/hbwidgets/itemviews/hbabstractviewitem.cpp

equal deleted inserted replaced

-:4633027730f5
+:e6ad4ef83b23
 \brief The HbAbstractViewItem class represents a single item in a AbstractItemView.
 The HbAbstractViewItem class provides an item that is used by HbAbstractItemView class to
 visualize content within single model index. By default HbAbstractViewItem supports QString and QStringList
 stored into Qt::DisplayRole role and QIcon, HbIcon or list of them in QVariantList stored into
 Qt::DecoratorRole role.
 This class is provided mainly for customization purposes but it also acts as a default
 item prototype inside HbAbstractItemView. See HbAbstractItemView how to set customized class as a item prototype.
 \b Subclassing
 }
 if (!child->isVisible() || child == mNonCachableItem || child == mFrontPixmapPainter || child == mBackPixmapPainter) {
 continue;
 }
 if (!itemPainted && child->zValue() >= 0) {
-painter->save();
 option->exposedRect = q->boundingRect();
 q->paint(painter, option, 0);
-painter->restore();
 itemPainted = true;
 }
-painter->save();
 if (child == mFrame) {
+QPainter::CompositionMode mode = painter->compositionMode();
 painter->setCompositionMode(QPainter::CompositionMode_Source);
-}
+painter->translate(child->pos());
+option->exposedRect = child->boundingRect();
-painter->translate(child->pos());
+child->paint(painter, option, 0);
+painter->setCompositionMode(mode);
-option->exposedRect = child->boundingRect();
+painter->translate(-child->pos());
-child->paint(painter, option, 0);
+continue;
+}
-painter->restore();
+paintChildItemsRecursively(child,painter,option);
 }
 mInPaintItems = false;
 }
+void HbAbstractViewItemPrivate::paintChildItemsRecursively(QGraphicsItem *child, QPainter *painter,QStyleOptionGraphicsItem *option)
+{
+if (!child->isVisible())
+return;
+int i = 0;
+QList<QGraphicsItem *> children =  child->childItems();
+int count(children.size());
+painter->translate(child->pos());
+// Draw children behind
+for (i = 0; i < count; ++i) {
+QGraphicsItem *subChild = children.at(i);
+if (!(subChild->flags() & QGraphicsItem::ItemStacksBehindParent))
+break;
+paintChildItemsRecursively(subChild, painter,option);
+}
+option->exposedRect = child->boundingRect();
+child->paint(painter, option, 0);
+// Draw children in front
+for (; i < count; ++i) {
+QGraphicsItem *subChild = children.at(i);
+paintChildItemsRecursively(subChild, painter,option);
+}
+painter->translate(-child->pos());
+}
 void HbAbstractViewItemPrivate::setChildFlags(QGraphicsItem *child, bool pixmapCacheEnabled)
 {
+QGraphicsItem::GraphicsItemFlags itemFlags = child->flags();
+if (pixmapCacheEnabled) {
+itemFlags |= QGraphicsItem::ItemHasNoContents;
+itemFlags |= QGraphicsItem::ItemIgnoresParentOpacity;
+}
+else {
+itemFlags &= ~QGraphicsItem::ItemHasNoContents;
+itemFlags &= ~QGraphicsItem::ItemIgnoresParentOpacity;
+}
+child->setFlags(itemFlags);
+foreach (QGraphicsItem *subChild, child->childItems()) {
+setChildFlags(subChild,pixmapCacheEnabled);
+}
+}
+void HbAbstractViewItemPrivate::setChildFlagRecursively(bool pixmapCacheEnabled)
+{
 Q_Q(HbAbstractViewItem);
+foreach (QGraphicsItem *subChild, q->childItems()) {
-if (child) {
+if (subChild == mNonCachableItem || subChild == mFrontPixmapPainter ||
-QGraphicsItem::GraphicsItemFlags itemFlags = child->flags();
+subChild == mBackPixmapPainter) {
-if (pixmapCacheEnabled) {
+continue;
-itemFlags |= QGraphicsItem::ItemHasNoContents;
+}
-itemFlags |= QGraphicsItem::ItemIgnoresParentOpacity;
+setChildFlags(subChild, pixmapCacheEnabled);
-}
-else {
-itemFlags &= ~QGraphicsItem::ItemHasNoContents;
-itemFlags &= ~QGraphicsItem::ItemIgnoresParentOpacity;
-}
-child->setFlags(itemFlags);
-} else {
-foreach (QGraphicsItem *child, q->childItems()) {
-if (child == mNonCachableItem || child == mFrontPixmapPainter || child == mBackPixmapPainter) {
-continue;
-}
-QGraphicsItem::GraphicsItemFlags itemFlags = child->flags();
-if (pixmapCacheEnabled) {
-itemFlags |= QGraphicsItem::ItemHasNoContents;
-itemFlags |= QGraphicsItem::ItemIgnoresParentOpacity;
-}
-else {
-itemFlags &= ~QGraphicsItem::ItemHasNoContents;
-itemFlags &= ~QGraphicsItem::ItemIgnoresParentOpacity;
-}
-child->setFlags(itemFlags);
-}
 }
 }
 void HbAbstractViewItemPrivate::updatePixmap(QPixmap *pixmap,
 QPainter *painter,
 paintItems(&pixmapPainter, &pixmapOption, startItem, endItem);
 }
 void HbAbstractViewItemPrivate::releasePixmaps()
 {
-if (mFrontCachePixmap) {
-delete mFrontCachePixmap;
-mFrontCachePixmap = 0;
-}
 if (mFrontPixmapPainter) {
 mFrontPixmapPainter->setPixmap(0);
-}
-if (mBackCachePixmap) {
-delete mBackCachePixmap;
-mBackCachePixmap = 0;
 }
 if (mBackPixmapPainter) {
 mBackPixmapPainter->setPixmap(0);
 }
 {
 HB_SDD(HbAbstractViewItem);
 if (d && !d->isPrototype()) {
 sd->mCloneItems.removeOne(this);
 }
-delete d->mFrontCachePixmap;
-delete d->mBackCachePixmap;
 }
 /*!
 Returns true if \a model index is supported by Abstract view item, otherwise returns false.
 This function is called for every item on the prototype list (, if several prototypes exist)
 */
 bool HbAbstractViewItem::event(QEvent *e)
 {
 switch (e->type()) {
 case QEvent::GraphicsSceneResize: {
 Q_D(HbAbstractViewItem );
-d->releasePixmaps();
-updatePixmapCache();
 QGraphicsSceneResizeEvent *resizeEvent = static_cast<QGraphicsSceneResizeEvent *>(e);
 if (d->mFrontPixmapPainter) {
 d->mFrontPixmapPainter->setSize(resizeEvent->newSize());
 }
 Invalidates parent layout when ItemTransformHasChanged is received.
 */
 QVariant HbAbstractViewItem::itemChange(GraphicsItemChange change, const QVariant &value)
 {
 switch (change) {
 case ItemTransformHasChanged: {
-Q_D(HbAbstractViewItem);
 QGraphicsLayoutItem *parentLayoutItem = this->parentLayoutItem();
 if (parentLayoutItem && parentLayoutItem->isLayout()) {
 QGraphicsLayout *parentLayout = static_cast<QGraphicsLayout *>(parentLayoutItem);
 parentLayout->invalidate();
 }
-d->releasePixmaps();
-updatePixmapCache();
 break;
 }
 case ItemEnabledHasChanged: {
 updateChildItems();
 break;
 }
 case ItemVisibleHasChanged: {
 Q_D(HbAbstractViewItem);
 if (!value.toBool() && d->usePixmapCache()) {
-d->setChildFlags(0, false);
+d->setChildFlagRecursively(false);
 d->releasePixmaps();
 d->mResetPixmapCache = true;
 }
 break;
 }
 if (d->usePixmapCache()) {
 d->setChildFlags(qvariant_cast<QGraphicsItem *>(value), true);
 }
 break;
 }
 default:
 break;
 }
 return HbWidget::itemChange(change, value);
 }
 }
 if (d->mFocusItem) {
 HbStylePrivate::updatePrimitive(d->mFocusItem, HbStylePrivate::P_ItemViewItem_focus, d->mSharedData->mStyleOption);
 }
 updatePixmapCache();
 }
 /*!
 if (!d->polished && layout()) {
 return;
 }
-if (d->polished && !d->repolishOutstanding && !d->mRepolishRequested) {
-return;
-}
 if (sd->mItemView) {
 setProperty("layoutName", sd->mItemView->layoutName());
 }
 d->mRepolishRequested = false;
 void HbAbstractViewItem::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
 {
 Q_UNUSED(widget);
 Q_D(HbAbstractViewItem);
 if (!d->mInPaintItems) {
 bool usePixmapCache = d->usePixmapCache();
 if (usePixmapCache) {
 QRectF deviceBounds = painter->worldTransform().mapRect(boundingRect());
 QRect deviceRect = deviceBounds.toRect().adjusted(-1, -1, 1, 1);
+if (deviceRect.size() != d->mFrontPixmapPainter->pixmapSize()) {
+d->mResetPixmapCache = true;
+d->releasePixmaps();
+}
 if (d->mResetPixmapCache) {
-if (!d->mFrontCachePixmap) {
+if (!d->mFrontPixmapPainter->pixmap()) {
-d->setChildFlags(0, true);
+d->setChildFlagRecursively(true);
+QPixmap *pixmap = new QPixmap(deviceRect.size());
-d->mFrontCachePixmap = new QPixmap(deviceRect.size());
+d->mFrontPixmapPainter->setPixmap(pixmap);
-d->mFrontPixmapPainter->setPixmap(d->mFrontCachePixmap);
 }
 // Construct an item-to-pixmap transform.
 QPointF p = deviceRect.topLeft();
 QTransform itemToPixmap = painter->worldTransform();
 if (!p.isNull())
 itemToPixmap *= QTransform::fromTranslate(-p.x(), -p.y());
-d->updatePixmap(d->mFrontCachePixmap, painter, itemToPixmap, option, d->mNonCachableItem, 0);
+d->updatePixmap(d->mFrontPixmapPainter->pixmap(), painter, itemToPixmap, option, d->mNonCachableItem, 0);
 if (d->mNonCachableItem) {
-if (!d->mBackCachePixmap) {
+if (!d->mBackPixmapPainter->pixmap()) {
-d->mBackCachePixmap = new QPixmap(deviceRect.size());
+QPixmap *pixmap = new QPixmap(deviceRect.size());
+d->mBackPixmapPainter->setPixmap(pixmap);
 }
-d->mBackPixmapPainter->setPixmap(d->mBackCachePixmap);
+d->updatePixmap(d->mBackPixmapPainter->pixmap(), painter, itemToPixmap, option, 0, d->mNonCachableItem);
-d->updatePixmap(d->mBackCachePixmap, painter, itemToPixmap, option, 0, d->mNonCachableItem);
 } else if (d->mBackPixmapPainter) {
 d->mBackPixmapPainter->setPixmap(0);
 }
 d->mResetPixmapCache = false;
 if (d->mFrontPixmapPainter) {
 d->mFrontPixmapPainter->setDeviceRect(deviceRect);
 }
 } else {
-if (d->mFrontCachePixmap) {
+if (d->mFrontPixmapPainter->pixmap()) {
-d->setChildFlags(0, false);
+d->setChildFlagRecursively(false);
 d->releasePixmaps();
 }
 }
 }
 }
 */
 void HbAbstractViewItem::updatePixmapCache()
 {
 Q_D(HbAbstractViewItem);
-if (d->usePixmapCache()) {
+if (!d->mResetPixmapCache && d->usePixmapCache()) {
 d->mResetPixmapCache = true;
 update();
 }
 }

changeset 23	e6ad4ef83b23
parent 21	4633027730f5
child 28	b7da29130b0e