add pixels to qgraphicsitem

[mcarter]

I have derived a class from QGraphicsRectItem that draw a rect on the screen. Simple enough.

I have enabled selection on this item and the normal dotted frame appears over the displayed rect. Now I want to highlight this rect when selected so I would like to place a selection border around the item's rect.

From what I have read about QGraphicsItems, they should only draw within the boundingRect. I have overridden the boundingRect method and tried to adjust the rect by 1, but as you guess that did not quite work since the QGraphicsRectItem uses the scene's coordinate system. The transform of the item does not seem to help since its type is always TxNone.

The paint event seems to be the only time when I can get a decent transform for the item. Do I need to save that and then apply it in the boundingRect method?

All I want to do is add a few pixels around the QGraphicsRectItem.

[wysota]

Adjusting boundingRect() by "1" should have worked provided that your scene works in terms of pixels in the 1:1 scale. Please show us your item implementation.

[mcarter]

My scene is not 1:1 scale, but the transform on the item does not represent that. Is there a way to get the transform of the scene/view?

Right now my implementation is just the basics . . . overriding just the boundingRect and paint methods. The boundingRect is just "return this->rect().adjusted( -1, -1, 1, 1 );" and the paint method is taken straight from QGraphicsRectItem qt code.

[wysota]

So what exactly does not work?

[mcarter]

Adding pixels to the QGraphicsRectItem does not work.

So here is some sample code that demonstrates my problem. I have an initial scene and then "zoom" to a particular area. This is where I draw the rectangle. If the rectangle is then selected, a red "hilite" should be drawn around the rectangle . . . and currently its suppose to be penWidth pixels wide. However, it is many pixels wide in the Y direction and nowhere in the X direction.

MyRect.h

#include <QPen>
#include <QDebug>
#include <QPainter>
#include <QGraphicsRectItem>
#include <QStyleOptionGraphicsItem>
 
class MyRect : public QObject, public QGraphicsRectItem
{
    Q_OBJECT
 
public:
    MyRect( QGraphicsItem *pParent=0 )
     :  QGraphicsRectItem( pParent )
    {
        setItUp();
    }
    MyRect( const QRectF & rect, QGraphicsItem* pParent=0 ) 
     :  QGraphicsRectItem( rect, pParent )
    {
        setItUp();
    }
    ~MyRect() {}
 
    void setItUp()
    {
        m_penWidth = 1.0;
        setPen( QPen(Qt::green) );
        setAcceptHoverEvents( true );
        setFlag( QGraphicsItem::ItemIsSelectable, true );
    }
 
    QRectF boundingRect() const
    {
        return this->rect().adjusted( -m_penWidth, -m_penWidth,
                                       m_penWidth,  m_penWidth );
    }
 
 
protected:
    void paint( QPainter *painter,
                const QStyleOptionGraphicsItem *option,
                QWidget *widget )
    {
        Q_UNUSED(widget);
        painter->setPen(pen());
        painter->setBrush(brush());
        painter->drawRect(rect());
 
        if (option->state & QStyle::State_Selected)
        {
            const QRectF murect = painter->transform().mapRect(QRectF(0, 0, 1, 1));
            if (qFuzzyCompare(qMax(murect.width(), murect.height()) + 1, 1))
                return;
 
            const QRectF mbrect = painter->transform().mapRect(this->boundingRect());
            if (qMin(mbrect.width(), mbrect.height()) < qreal(1.0))
                return;
 
            QPen hilitePen(QBrush(Qt::red),m_penWidth);
            const qreal pad = hilitePen.widthF() / 2;
            painter->setPen(hilitePen);
            painter->setBrush(Qt::NoBrush);
            painter->drawRect(this->boundingRect().adjusted(pad, pad, -pad, -pad));
        }
    }
 
private:
    qreal m_penWidth;
};

#include <QPen>
#include <QDebug>
#include <QPainter>
#include <QGraphicsRectItem>
#include <QStyleOptionGraphicsItem>

class MyRect : public QObject, public QGraphicsRectItem
{
    Q_OBJECT

public:
    MyRect( QGraphicsItem *pParent=0 )
     :  QGraphicsRectItem( pParent )
    {
        setItUp();
    }
    MyRect( const QRectF & rect, QGraphicsItem* pParent=0 ) 
     :  QGraphicsRectItem( rect, pParent )
    {
        setItUp();
    }
    ~MyRect() {}

    void setItUp()
    {
        m_penWidth = 1.0;
        setPen( QPen(Qt::green) );
        setAcceptHoverEvents( true );
        setFlag( QGraphicsItem::ItemIsSelectable, true );
    }

    QRectF boundingRect() const
    {
        return this->rect().adjusted( -m_penWidth, -m_penWidth,
                                       m_penWidth,  m_penWidth );
    }


protected:
    void paint( QPainter *painter,
                const QStyleOptionGraphicsItem *option,
                QWidget *widget )
    {
        Q_UNUSED(widget);
        painter->setPen(pen());
        painter->setBrush(brush());
        painter->drawRect(rect());

        if (option->state & QStyle::State_Selected)
        {
            const QRectF murect = painter->transform().mapRect(QRectF(0, 0, 1, 1));
            if (qFuzzyCompare(qMax(murect.width(), murect.height()) + 1, 1))
                return;

            const QRectF mbrect = painter->transform().mapRect(this->boundingRect());
            if (qMin(mbrect.width(), mbrect.height()) < qreal(1.0))
                return;

            QPen hilitePen(QBrush(Qt::red),m_penWidth);
            const qreal pad = hilitePen.widthF() / 2;
            painter->setPen(hilitePen);
            painter->setBrush(Qt::NoBrush);
            painter->drawRect(this->boundingRect().adjusted(pad, pad, -pad, -pad));
        }
    }

private:
    qreal m_penWidth;
};

To copy to clipboard, switch view to plain text mode 

main.cpp

#include "MyRect.h"
 
#include <QApplication>
#include <QGraphicsView>
#include <QGraphicsScene>
 
int main(int argc, char **argv)
{
    QApplication app(argc, argv);
    QGraphicsView view;
 
    view.setVerticalScrollBarPolicy( Qt::ScrollBarAlwaysOff );
    view.setHorizontalScrollBarPolicy( Qt::ScrollBarAlwaysOff );
 
    QGraphicsScene *scene = new QGraphicsScene( 2147583648.0,22.0,
                                                19900000.0,1536.0 );
    view.setScene(scene);
 
    QRectF seRect(2154794311.0,742.0,4000.0,5.0);
    MyRect *rect = new MyRect;
    scene->addItem( rect );
    rect->setRect( seRect );
 
    QRectF zmRect(2154696311.0,732.0,200000.0,20.0);
 
    view.show();
    view.fitInView( zmRect );
 
    return app.exec();
}

#include "MyRect.h"

#include <QApplication>
#include <QGraphicsView>
#include <QGraphicsScene>

int main(int argc, char **argv)
{
    QApplication app(argc, argv);
    QGraphicsView view;

    view.setVerticalScrollBarPolicy( Qt::ScrollBarAlwaysOff );
    view.setHorizontalScrollBarPolicy( Qt::ScrollBarAlwaysOff );

    QGraphicsScene *scene = new QGraphicsScene( 2147583648.0,22.0,
                                                19900000.0,1536.0 );
    view.setScene(scene);

    QRectF seRect(2154794311.0,742.0,4000.0,5.0);
    MyRect *rect = new MyRect;
    scene->addItem( rect );
    rect->setRect( seRect );

    QRectF zmRect(2154696311.0,732.0,200000.0,20.0);

    view.show();
    view.fitInView( zmRect );

    return app.exec();
}

To copy to clipboard, switch view to plain text mode 

[wysota]

I think you have a wrong assumption. If you increase the bounding rect by X then if you scale the item your X will be scaled as well. From what I see it is not what you want. Your current solution will not have a chance to work if you start scaling down the item. If you wish to continue this path then just invert the transformation of the painter and draw the hilight rect then.

[mcarter]

I agree . . . I am still trying to understand QGraphicsView/QGraphicsScene/QGraphicsItem interaction.

That was sort of my original question. I guess since the item can be drawn in many views, you cannot process the transform until the paint event. (?)

If I draw the hilite inside the paint event, will it not draw outside the boundingRect? Is it true that an item can only draw within its boundingRect? Can I adjust the boundingRect inside the paint event?

btw, is the pen size also based on scene scaling? So if I want to change the pen size to be larger for the rectangle draw I need to adjust based on transform to get the proper pixel width? Will there be an impact if I have 100,000's of these items on the screen?

Since I am new the this, is there a better way?

[wysota]

If I draw the hilite inside the paint event, will it not draw outside the boundingRect?

Physically it will be drawn but you'll get artifacts if you start manipulating your view.

Can I adjust the boundingRect inside the paint event?

No.

btw, is the pen size also based on scene scaling?

Unless you set it to cosmetic then yes.

So if I want to change the pen size to be larger for the rectangle draw I need to adjust based on transform to get the proper pixel width? Will there be an impact if I have 100,000's of these items on the screen?

I don't understand what you mean.

Since I am new the this, is there a better way?

Yes. Use a separate item was hilighting. Make it a child of your main item and adjust its geometry based on the geometry of the parent. You can even set the ItemIgnoresTransformations flag on it.

[MarekR22]

From my experience you should restore state of painter at the end of paint.
Without it you can have strange artifacts. Of course if you are using some optimization flag to auto store painter then this problem will not appear.
When you are writing own graphics item you shouldn't try to evaluate impact of transformation, especially when you have little experience with graphics freamework.

Try correct this code like that:

class MyRect : public QObject, public QGraphicsRectItem
{
    Q_OBJECT
 
public:
    MyRect( QGraphicsItem *pParent=0 )
     :  QGraphicsRectItem( pParent )
    {
        setItUp();
    }
    MyRect( const QRectF & rect, QGraphicsItem* pParent=0 ) 
     :  QGraphicsRectItem( rect, pParent )
    {
        setItUp();
    }
    ~MyRect() {}
 
    void setItUp()
    {
        m_penWidth = 1.0;
        setPen( QPen(Qt::green) );
        setAcceptHoverEvents( true );
        setFlag( QGraphicsItem::ItemIsSelectable, true );
    }
 
    QRectF boundingRect() const
    { //looks ok
        return this->rect().adjusted( -m_penWidth, -m_penWidth,
                                       m_penWidth,  m_penWidth );
    }
 
protected:
    void paint( QPainter *painter,
                const QStyleOptionGraphicsItem *option,
                QWidget *widget )
    {
        Q_UNUSED(widget);
 
        // this way is faster then painter->store();
        QPen oldPen = painter->pen();
        QBrush oldoldBrush = painter->brush();
 
        painter->setBrush(brush());
        if (option->state & QStyle::State_Selected) {
            painter->setPen(pen());
        } else {
            QPen hilitePen(QBrush(Qt::red),m_penWidth);
            painter->setPen(hilitePen);
        }
        painter->drawRect(rect());
 
        // restore painter:
        painter->setPen(oldPen);
        painter->setBrush(oldBrush);
    }
 
private:
    qreal m_penWidth;
};

class MyRect : public QObject, public QGraphicsRectItem
{
    Q_OBJECT

public:
    MyRect( QGraphicsItem *pParent=0 )
     :  QGraphicsRectItem( pParent )
    {
        setItUp();
    }
    MyRect( const QRectF & rect, QGraphicsItem* pParent=0 ) 
     :  QGraphicsRectItem( rect, pParent )
    {
        setItUp();
    }
    ~MyRect() {}

    void setItUp()
    {
        m_penWidth = 1.0;
        setPen( QPen(Qt::green) );
        setAcceptHoverEvents( true );
        setFlag( QGraphicsItem::ItemIsSelectable, true );
    }

    QRectF boundingRect() const
    { //looks ok
        return this->rect().adjusted( -m_penWidth, -m_penWidth,
                                       m_penWidth,  m_penWidth );
    }

protected:
    void paint( QPainter *painter,
                const QStyleOptionGraphicsItem *option,
                QWidget *widget )
    {
        Q_UNUSED(widget);

        // this way is faster then painter->store();
        QPen oldPen = painter->pen();
        QBrush oldoldBrush = painter->brush();

        painter->setBrush(brush());
        if (option->state & QStyle::State_Selected) {
            painter->setPen(pen());
        } else {
            QPen hilitePen(QBrush(Qt::red),m_penWidth);
            painter->setPen(hilitePen);
        }
        painter->drawRect(rect());

        // restore painter:
        painter->setPen(oldPen);
        painter->setBrush(oldBrush);
    }

private:
    qreal m_penWidth;
};

To copy to clipboard, switch view to plain text mode 

Another thing why you are trying do it yourself?
Why not just manipulate properties of QGraphicsRectItem?
Just use QAbstractGraphicsShapeItem::setBrush and QAbstractGraphicsShapeItem::setPen when state of item is changed.
Re-implement itemChange method to react on that.

[mcarter]

So if I want to change the pen size to be larger for the rectangle draw I need to adjust based on transform to get the proper pixel width? Will there be an impact if I have 100,000's of these items on the screen?

I don't understand what you mean.

I was wondering if I start doing a lot of transform manipulation in the item, will this have an impact of I have many, many, many of these items in the view.

Since I am new the this, is there a better way?

Yes. Use a separate item was hilighting. Make it a child of your main item and adjust its geometry based on the geometry of the parent. You can even set the ItemIgnoresTransformations flag on it.

This sounds like the way to go, especially with the itemIgnoresTransformation. However, I am not sure how to implement. Do I override the itemChange of the main item to update the geometry of the child? Does the child get the actual transform of the scene/view thru its paintEvent so I can scale it properly? Just need a little push to get a better handle on GV.

---

Added after 6 minutes:

MarekR22, your answer is a valid response if I was only interested in changing the color of the item rectangle. I would indeed let the item do most of the work.

What I am looking for is a way to place a highlight rectangle around the entire item's rectangle.

[wysota]

I was wondering if I start doing a lot of transform manipulation in the item, will this have an impact of I have many, many, many of these items in the view.

Yes, of course.

This sounds like the way to go, especially with the itemIgnoresTransformation. However, I am not sure how to implement. Do I override the itemChange of the main item to update the geometry of the child?

Probably the other way would be better. It'd be best if the "parent" had a placeholder for the "hilight item" and called some function in the item when its boundingRect() changes.

Does the child get the actual transform of the scene/view thru its paintEvent so I can scale it properly? Just need a little push to get a better handle on GV.

The child only has to reread the parent's bounding rect and adjust itself to it. If you make the child a "resizer item" (with anchors that resize the main item when you drag them) it's even simpler as the child can then control the parent without any special treatment from the parent.