I am facing a problem with QGraphicsView framework. I am using QGraphicsPixmapItem for drawing image on View. To prevent it from the zooming functionality i.e increasing it’s size when zoomedIn , I have used flag setFlag(QGraphicsItem::ItemIgnoresTransformations); but it’s not working.
I have posted a thread on QTCenter Forum and for detailed description you can see it.

http://www.qtcentre.org/forum/f-qt-programming-2/t-problem-with-qgraphicsview-and-itemignorestransformations-14400.html

If you have any suggestion plz let me know.

Thanks

Unfortunately, that also means that line widths are no longer scaled with the graphics view, so we have to do that manually now for example in QGraphicsView::drawItems(…);

This solution provided the performance boost we needed to make the whole graphics view framework usable for our needs.

So , i will try your solutin.

Thanks

Regards
Veeru

However, thanks for your excellent article! Instant bookmark!

Yes, your approach works well when there are many moving QGraphicsItems on the screen at once, and works at the QGraphicsView level.

On the other hand, my optimization was at the QGraphicsItem level, and works well when only a subset of items are moving.

In fact, your optimization combined with mine would provide excellent handling of many, small QGraphicsItems moving all at once.

Thanks!

–Dave

Thanks for your Tricks, they can help a lot,
I would like to speek about avoiding painting :
-Avoiding unecessary paintings is a great idea, the purpose is, i imagine, to save time in order to make drawing as ligth as possible.
But it can become an illusion, like it is in Qt4, for certain cases, items with simple shapes, a lot of times is spent to avoid spending few milliseconds:

in Qt4, there are two ways of redrawing :

Using BSP tree, in wich case each modification to the draw should update the BSP tree, making the intersection computing between the items and the region to update unecessary.
The classical way, in wich you need to compute this intersection.

In the second case, Qt is very inefficient, as it compute the intersection between each item and each rect of the region to update
imagine; in a qregion you can find 500 rects, so with 500 items, it makes
250000 intersections to compute, do you really think it is faster then redrawing 500 items?
To have a good idea about that, if you have a program with a lot of items, you can make an experience:
Instead of QGraphicsView, use a sub class, MyFasterGraphicView :

class MyFasterGraphicView :public QGraphicsView
{
Q_OBJECT
public:
MyFasterGraphicView( …);
protected:
…
void paintEvent ( QPaintEvent * event );
…
};

void MyFasterGraphicView::paintEvent ( QPaintEvent * event )
{
QPaintEvent *newEvent=new QPaintEvent(event->region().boundingRect());
QGraphicsView::paintEvent(newEvent);
delete newEvent;
}

So the question is:
what is better? bad results with good intentions, or better results with bad workarounds?
And keep me updated,
Regards,

Cyril
Ps: this “workaround” have a great result with the collidingmices example delivered in the Qt4 distribution, at full screen