Building 2D Graphics Applications with Qt Widgets

Components

• QGraphicsView
  This is the widget that displays the QGraphicsScene on the screen. It provides functionalities like zooming, panning, and scrolling to navigate through your scene, similar to a viewport.
• QGraphicsItem
  This is the base class for all the individual visual elements you place in your scene. You can create custom QGraphicsItem subclasses to represent shapes, images, text, or any other visual element you need.
• QGraphicsScene
  This acts like a container that holds all the visual elements you want to display in your scene. It's like a virtual canvas where you arrange your graphical items.

Working Together

1. You create a QGraphicsScene instance.
2. You create various QGraphicsItem subclasses representing your desired visual elements.
3. You add these custom items to the QGraphicsScene using the addItem function.
4. You create a QGraphicsView instance and set the scene you created using setScene.
5. Finally, you add the QGraphicsView to your application's layout and show it.

Key Features

• Interaction
  The framework provides an event propagation mechanism. User interactions like mouse clicks or drags on the QGraphicsView are translated into events that your custom QGraphicsItem classes can handle by overriding functions like mousePressEvent.
• Performance
  Qt's Graphics View utilizes a BSP (Binary Space Partitioning) tree for efficient item discovery. This allows it to handle large scenes with millions of items smoothly.
• Customizable Items
  The power of Graphics View lies in its ability to create custom QGraphicsItem subclasses. You can implement the painting behavior of your items by overriding the paint function to draw any shapes, text, or images you need.

---

Simple Drawing

This example shows how to create a scene with a rectangle and display it in a QGraphicsView:

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

int main(int argc, char *argv[]) {
  QApplication app(argc, argv);

  // Create scene and rectangle item
  QGraphicsScene scene;
  QGraphicsRectItem* rect = scene.addRect(0, 0, 100, 100, QPen(Qt::black), QBrush(Qt::red));

  // Create view and set scene
  QGraphicsView view;
  view.setScene(&scene);
  view.show();

  return app.exec();
}

Custom Item

This example shows how to create a custom item that draws a circle:

#include <QGraphicsScene>
#include <QPainter>

class CircleItem : public QGraphicsItem {
public:
  void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget) override {
    painter->setPen(QPen(Qt::blue));
    painter->drawEllipse(boundingRect());
  }

  QRectF boundingRect() const override {
    return QRectF(0, 0, 100, 100);
  }
};

int main(int argc, char *argv[]) {
  // ... (similar to previous example)

  // Create custom circle item and add to scene
  CircleItem* circle = new CircleItem;
  scene.addItem(circle);

  // ... (remaining code)
}

Interaction

This example demonstrates how to handle mouse clicks on a rectangle item:

#include <QGraphicsScene>
#include <QGraphicsRectItem>

class ClickableRect : public QGraphicsRectItem {
  Q_OBJECT

public:
  ClickableRect() : QGraphicsRectItem(0, 0, 100, 100) {}

signals:
  void clicked();

protected:
  void mousePressEvent(QMouseEvent *event) override {
    if (event->button() == Qt::LeftButton) {
      emit clicked();
    }
  }
};

int main(int argc, char *argv[]) {
  // ... (similar to previous example)

  // Create clickable rectangle
  ClickableRect* rect = new ClickableRect;
  scene.addItem(rect);

  // Connect clicked signal to a slot
  QObject::connect(rect, &ClickableRect::clicked, []() {
    qDebug() << "Rectangle clicked!";
  });

  // ... (remaining code)
}

---

Qt Quick (Declarative UI)

• Can be integrated with Graphics View using QQuickWidget for specific areas requiring more control.
• Not as low-level as Graphics View, can be less performant for complex scenes with millions of items.
• Offers a more modern and visually appealing way to build UIs.
• Focuses on a declarative approach using QML, a language similar to JavaScript.

Custom Painting with QWidget

• Less maintainable for complex scenarios compared to dedicated frameworks.
• Requires manual handling of coordinate systems, event handling, and performance optimization.
• Suitable for simpler 2D graphics or when you need maximum control over painting behavior.

External Libraries

• Offer broader functionality but require additional learning curve and might not integrate as seamlessly with Qt.
• For specific needs like scientific visualization or game development, consider libraries like OpenGL, SFML, or VTK.

• **For specialized needs like scientific visualization: **Investigate external libraries.
• For simple 2D graphics or maximum control
  Consider custom painting with QWidget.
• For modern, visually-appealing interfaces with moderate complexity
  Explore Qt Quick.
• For complex 2D scenes with high performance requirements
  Stick with Graphics View.