Hi,
I had asked this kind of question in past but i concentrated more on QGraphicsScene::drawBackground() that time.

Here follows an example of three possible approach of drawing resistor with nodes. To test while running, select all elements of particular colour and move them together and notice difference for different colours. Obviously the last part, drawing nodes as part of component is faster. But this results in lot of book keeping for my app which I think will not be a nice trade off (sacrificing benifits of gv).

I am using the first method, where nodes are moved manually. Originally in my app I move them in scene, but for example sake I'm moving in itemChange().

My questions are:
1) Using 2nd method (NodesAsChild) doubles number of items when the components are connected. But using first method I will just have a single node for connected components where i just add a reference in nodes component list.
Will the performance decrease significantly if I use 2nd method ?

2) Are there any other ways of opimizing any of the methods further ?

3) Are there any other method of doing what I want, I mean design ?

I'm using Qt 4.2.3 on kubuntu.

Qt Code: 
  1. #include <QtGui>
  2. #include <cmath>
  3.  
  4. const int NodeRadius = 3;
  5.  
  6. inline qreal distance(const QPointF& p1, const QPointF& p2)
  7. {
  8.    qreal dx = p1.x() - p2.x();
  9.    qreal dy = p1.y() - p2.y();
  10.    return std::sqrt((dx*dx)+(dy*dy));
  11. }
  12.  
  13.  
  14. class Node : public QGraphicsItem
  15. {
  16.    public:
  17.       enum { Type = UserType + 1 };
  18.  
  19.       Node(QGraphicsItem *parent=0, QGraphicsScene *scene=0) : QGraphicsItem(parent,scene)
  20.       {
  21.          setAcceptedMouseButtons(0);
  22.          setFlags(0);
  23.       }
  24.  
  25.       QRectF boundingRect() const
  26.       {
  27.          return QRectF(-NodeRadius, -NodeRadius, 2*NodeRadius, 2*NodeRadius);
  28.       }
  29.  
  30.       void paint(QPainter *p, const QStyleOptionGraphicsItem *o, QWidget *w = 0)
  31.       {
  32.          Q_UNUSED(o);
  33.          Q_UNUSED(w);
  34.          p->setRenderHints(QPainter::Antialiasing);
  35.          p->setPen(Qt::darkRed);
  36.          p->drawEllipse(boundingRect());
  37.       }
  38.  
  39.       bool contains(const QPointF& pt) const
  40.       {
  41.          qreal dist = distance(QPointF(0,0),pt);
  42.          return (((dist * dist) - (NodeRadius*NodeRadius)) <= 0);
  43.       }
  44.  
  45.       bool collidesWithItem(QGraphicsItem *other) const
  46.       {
  47.          Node *port = qgraphicsitem_cast<Node*>(other);
  48.          if(!port)
  49.             return QGraphicsItem::collidesWithItem(other);
  50.          qreal dist = distance(pos(),port->pos());
  51.  
  52.          return (dist <= (2 * NodeRadius));
  53.       }
  54.  
  55.       QPainterPath shape() const
  56.       {
  58.          path.addEllipse(boundingRect());
  59.          return path;
  60.       }
  61.  
  62.       int type() const
  63.       {
  64.          return Type;
  65.       }
  66.  
  67. };
  68.  
  69. namespace SeparateNodes
  70. {
  71.    class Resistor : public QGraphicsItem
  72.    {
  73.       public:
  74.          Resistor(QGraphicsItem *parent = 0, QGraphicsScene *scene=0) : QGraphicsItem(parent,scene)
  75.          {
  76.             setFlags(ItemIsMovable | ItemIsSelectable | ItemIsFocusable);
  77.             Node *n = new Node(0,scene);
  78.             n->setPos(-27.0,0.0);
  79.             nodes << n;
  80.             n = new Node(0,scene);
  81.             n->setPos(27.0,0.0);
  82.             nodes << n;
  83.          }
  84.  
  85.          QRectF boundingRect() const
  86.          {
  87.             return QRectF(-27,-9,54,18);
  88.          }
  89.  
  90.          void paint(QPainter *p, const QStyleOptionGraphicsItem *o, QWidget *w = 0)
  91.          {
  92.             Q_UNUSED(o);
  93.             Q_UNUSED(w);
  94.             p->setPen(Qt::darkMagenta);
  95.             p->drawLine(-18, -9, 18, -9);
  96.             p->drawLine( 18, -9, 18,  9);
  97.             p->drawLine( 18,  9,-18,  9);
  98.             p->drawLine(-18,  9,-18, -9);
  99.             p->drawLine(-27,  0,-18,  0);
  100.             p->drawLine( 18,  0, 27,  0);
  101.  
  102.             if( o->state & QStyle::State_Selected)
  103.             {
  104.                p->setPen(Qt::darkGray);
  105.                p->drawRect(boundingRect());
  106.             }
  107.  
  108.          }
  109.  
  110.          QVariant itemChange(GraphicsItemChange change, const QVariant &value)
  111.          {
  112.             if (change == ItemPositionChange && scene()) {
  113.                QPointF newPos = value.toPointF();
  114.                QPointF delta = newPos - pos();
  115.                foreach(Node *n, nodes)
  116.                   n->moveBy(delta.x(), delta.y());
  117.             }
  118.             return QGraphicsItem::itemChange(change, value);
  119.          }
  120.  
  121.          QList<Node*> nodes;
  122.    };
  123. }
  124.  
  125. namespace NodesAsChild
  126. {
  127.    class Resistor : public QGraphicsItem
  128.    {
  129.       public:
  130.          Resistor(QGraphicsItem *parent = 0, QGraphicsScene *scene=0) : QGraphicsItem(parent,scene)
  131.          {
  132.             setFlags(ItemIsMovable | ItemIsSelectable | ItemIsFocusable);
  133.             Node *n = new Node(this,scene);
  134.             n->setPos(-27.0,0.0);
  135.             n = new Node(this,scene);
  136.             n->setPos(27.0,0.0);
  137.          }
  138.  
  139.          QRectF boundingRect() const
  140.          {
  141.             return QRectF(-27,-9,54,18);
  142.          }
  143.  
  144.          void paint(QPainter *p, const QStyleOptionGraphicsItem *o, QWidget *w = 0)
  145.          {
  146.             Q_UNUSED(o);
  147.             Q_UNUSED(w);
  148.             p->setPen(Qt::darkBlue);
  149.             p->drawLine(-18, -9, 18, -9);
  150.             p->drawLine( 18, -9, 18,  9);
  151.             p->drawLine( 18,  9,-18,  9);
  152.             p->drawLine(-18,  9,-18, -9);
  153.             p->drawLine(-27,  0,-18,  0);
  154.             p->drawLine( 18,  0, 27,  0);
  155.  
  156.             if( o->state & QStyle::State_Selected)
  157.             {
  158.                p->setPen(Qt::darkGray);
  159.                p->drawRect(boundingRect());
  160.             }
  161.  
  162.          }
  163.    };
  164. }
  165.  
  166. namespace NodesPartOfResistor
  167. {
  168.    class Resistor : public QGraphicsItem
  169.    {
  170.       public:
  171.          Resistor(QGraphicsItem *parent = 0, QGraphicsScene *scene=0) : QGraphicsItem(parent,scene)
  172.          {
  173.             setFlags(ItemIsMovable | ItemIsSelectable | ItemIsFocusable);
  174.          }
  175.  
  176.          QRectF boundingRect() const
  177.          {
  178.             return QRectF(-30,-12,60,24);
  179.          }
  180.  
  181.          void paint(QPainter *p, const QStyleOptionGraphicsItem *o, QWidget *w = 0)
  182.          {
  183.             Q_UNUSED(o);
  184.             Q_UNUSED(w);
  185.             p->setPen(Qt::darkGreen);
  186.             p->drawLine(-18, -9, 18, -9);
  187.             p->drawLine( 18, -9, 18,  9);
  188.             p->drawLine( 18,  9,-18,  9);
  189.             p->drawLine(-18,  9,-18, -9);
  190.             p->drawLine(-27,  0,-18,  0);
  191.             p->drawLine( 18,  0, 27,  0);
  192.  
  193.             p->setPen(Qt::darkRed);
  194.             p->setRenderHints(QPainter::Antialiasing);
  195.             p->drawEllipse(-27-NodeRadius,-NodeRadius,2*NodeRadius,2*NodeRadius);
  196.             p->drawEllipse(27-NodeRadius,-NodeRadius,2*NodeRadius,2*NodeRadius);
  197.             if( o->state & QStyle::State_Selected)
  198.             {
  199.                p->setPen(Qt::darkGray);
  200.                p->drawRect(boundingRect());
  201.             }
  202.  
  203.          }
  204.    };
  205. }
  206.  
  207. int main(int argc, char *argv[])
  208. {
  209.    QApplication app(argc,argv);
  210.    QGraphicsScene *scene = new QGraphicsScene(0.,0.,1024,768);
  211.    QGraphicsView *view = new QGraphicsView(scene);
  212.    view->setDragMode(QGraphicsView::RubberBandDrag);
  213.    view->setAcceptDrops(true);
  214.    //view->setRenderHints(QPainter::Antialiasing | QPainter::SmoothPixmapTransform);
  215.    const int factor = 68;
  216.    for(int i = 1; i < 11; i++)
  217.       for(int j=1;j<3;j++) {
  218.          SeparateNodes::Resistor *r = new SeparateNodes::Resistor(0,scene);
  219.          r->setPos(100+i*factor,j*100);
  220.       }
  221.  
  222.    for(int i = 1; i < 11; i++)
  223.       for(int j=1;j<3;j++) {
  224.          NodesAsChild::Resistor *r = new NodesAsChild::Resistor(0,scene);
  225.          r->setPos(100+i*factor,200+j*100);
  226.       }
  227.  
  228.    for(int i = 1; i < 11; i++)
  229.       for(int j=1;j<3;j++) {
  230.          NodesPartOfResistor::Resistor *r = new NodesPartOfResistor::Resistor(0,scene);
  231.          r->setPos(100+i*factor,400+j*100);
  232.       }
  233.  
  234.    view->show();
  235.    return app.exec();
  236. }
To copy to clipboard, switch view to plain text mode