Grafikansichts-Framework

Die Grafikansicht bietet eine Oberfläche zur Verwaltung und Interaktion mit einer großen Anzahl benutzerdefinierter 2D-Grafikelemente sowie ein Ansichts-Widget zur Visualisierung der Elemente mit Unterstützung für Zoomen und Drehen.

Das Framework umfasst eine Architektur zur Ereignisweitergabe, die präzise Interaktionsmöglichkeiten mit doppelter Genauigkeit für die Elemente in der Szene ermöglicht. Elemente können Tastenereignisse sowie Mausklick-, Mausbewegungs-, Mausloslass- und Doppelklick-Ereignisse verarbeiten und zudem die Mausbewegung verfolgen.

Graphics View nutzt einen BSP-Baum (Binary Space Partitioning), um eine sehr schnelle Erkennung von Elementen zu ermöglichen. Dadurch kann es große Szenen in Echtzeit visualisieren, selbst wenn diese Millionen von Elementen enthalten.

Die Graphics View wurde in Qt 4.2 eingeführt und ersetzt ihren Vorgänger, QCanvas.

Die Architektur von Graphics View

Graphics View bietet einen objektbasierten Ansatz für die Model-View-Programmierung, ähnlich wie die Komfortklassen von InterView: QTableView, QTreeView und QListView. Mehrere Ansichten können eine einzelne Szene beobachten, und die Szene enthält Objekte mit unterschiedlichen geometrischen Formen.

Die Szene

QGraphicsScene stellt die Szene der Graphics View bereit. Die Szene hat folgende Aufgaben:

• Bereitstellung einer schnellen Schnittstelle zur Verwaltung einer großen Anzahl von Elementen
• Weitergabe von Ereignissen an jedes Element
• Verwaltung des Objektzustands, z. B. Auswahl und Fokusbehandlung
• Bereitstellung einer untransformierten Rendering-Funktionalität; hauptsächlich für den Druck

Die Szene dient als Container für „ QGraphicsItem “-Objekte. Elemente werden der Szene durch den Aufruf von ` QGraphicsScene::addItem()` hinzugefügt und anschließend durch den Aufruf einer der zahlreichen Funktionen zur Elementerkennung abgerufen. ` QGraphicsScene::items()` und seine Überladungen geben alle Elemente zurück, die in einem Punkt, einem Rechteck, einem Polygon oder einem allgemeinen Vektorpfad enthalten sind oder diesen schneiden. ` QGraphicsScene::itemAt` () gibt das oberste Element an einem bestimmten Punkt zurück. Alle Funktionen zur Erkennung von Elementen geben die Elemente in absteigender Stapelreihenfolge zurück (d. h., das erste zurückgegebene Element befindet sich ganz oben und das letzte Element ganz unten).

QGraphicsScene scene;
QGraphicsRectItem *rect = scene.addRect(QRectF(0, 0, 100, 100));

QGraphicsItem *item = scene.itemAt(50, 50, QTransform());

QGraphicsSceneDie Ereignisausbreitungsarchitektur von plant Szenenereignisse für die Übermittlung an Elemente und verwaltet zudem die Ausbreitung zwischen den Elementen. Wenn die Szene an einer bestimmten Position ein Mausklick-Ereignis empfängt, leitet die Szene das Ereignis an das Element weiter, das sich an dieser Position befindet.

QGraphicsScene QGraphicsScene verwaltet zudem bestimmte Objektzustände, wie beispielsweise die Objektauswahl und den Fokus. Sie können Objekte in der Szene auswählen, indem Sie ` ()` aufrufen und dabei eine beliebige Form übergeben. Diese Funktionalität dient auch als Grundlage für die Gummibandauswahl in . Um die Liste aller derzeit ausgewählten Objekte abzurufen, rufen Sie ` ()` auf. Ein weiterer von verwalteter Zustand ist, ob ein Objekt den Tastatureingabefokus besitzt oder nicht. Sie können den Fokus auf ein Element setzen, indem Sie ` ()` oder ` ()` aufrufen, oder das aktuell fokussierte Element abrufen, indem Sie ` ()` aufrufen. QGraphicsScene::setSelectionArea QGraphicsView QGraphicsScene::selectedItems QGraphicsScene::setFocusItem QGraphicsItem::setFocus QGraphicsScene::focusItem

Schließlich ermöglicht Ihnen „ QGraphicsScene “, Teile der Szene über die Funktion „ QGraphicsScene::render()“ auf ein Zeichen-Device zu rendern. Mehr dazu erfahren Sie im Abschnitt „Drucken“ weiter unten in diesem Dokument.

Das View-Widget

QGraphicsView stellt das View-Widget bereit, das den Inhalt einer Szene visualisiert. Sie können mehrere Views an dieselbe Szene anhängen, um mehrere Ansichtsfenster für denselben Datensatz bereitzustellen. Das View-Widget ist ein Scrollbereich und verfügt über Bildlaufleisten zur Navigation durch große Szenen. Um die OpenGL-Unterstützung zu aktivieren, können Sie eine ` QOpenGLWidget ` als Ansichtsfenster festlegen, indem Sie ` QGraphicsView::setViewport()` aufrufen.

QGraphicsScene scene;
myPopulateScene(&scene);
QGraphicsView view(&scene);
view.show();

Die Ansicht empfängt Eingabeereignisse von Tastatur und Maus und wandelt diese in Szenenereignisse um (wobei die verwendeten Koordinaten gegebenenfalls in Szenekoordinaten umgerechnet werden), bevor die Ereignisse an die visualisierte Szene gesendet werden.

Mithilfe ihrer Transformationsmatrix „ QGraphicsView::transform()“ kann die Ansicht das Koordinatensystem der Szene transformieren. Dies ermöglicht erweiterte Navigationsfunktionen wie Zoomen und Drehen. Der Einfachheit halber bietet „ QGraphicsView “ auch Funktionen zur Umrechnung zwischen Ansichts- und Szenenkoordinaten: „ QGraphicsView::mapToScene()“ und „ QGraphicsView::mapFromScene()“.

Das Item

QGraphicsItem ist die Basisklasse für grafische Elemente in einer Szene. Graphics View stellt mehrere Standardelemente für typische Formen bereit, wie beispielsweise Rechtecke (QGraphicsRectItem), Ellipsen (QGraphicsEllipseItem) und Textelemente (QGraphicsTextItem), doch die leistungsstärksten Funktionen von QGraphicsItem stehen erst dann zur Verfügung, wenn Sie ein benutzerdefiniertes Element erstellen. Unter anderem unterstützt QGraphicsItem die folgenden Funktionen:

• Ereignisse beim Klicken, Bewegen, Loslassen und Doppelklicken der Maus sowie Hover-Ereignisse, Mausrad-Ereignisse und Kontextmenü-Ereignisse.
• Tastatureingabefokus und Tastenereignisse
• Ziehen und Ablegen
• Gruppierung, sowohl über Eltern-Kind-Beziehungen als auch mit QGraphicsItemGroup
• Kollisionserkennung

Elemente befinden sich in einem lokalen Koordinatensystem, und ähnlich wie bei „ QGraphicsView “ stehen auch hier zahlreiche Funktionen zur Abbildung von Koordinaten zwischen dem Element und der Szene sowie von Element zu Element zur Verfügung. Ebenso wie bei „ QGraphicsView “ kann das Koordinatensystem mithilfe einer Matrix transformiert werden: ` QGraphicsItem::transform()`. Dies ist nützlich, um einzelne Elemente zu drehen und zu skalieren.

Elemente können andere Elemente (Unterelemente) enthalten. Die Transformationen der übergeordneten Elemente werden von allen ihren Unterelementen geerbt. Unabhängig von der kumulierten Transformation eines Elements arbeiten jedoch alle seine Funktionen (z. B. ` QGraphicsItem::contains()`, ` QGraphicsItem::boundingRect()`, `QGraphicsItem::collidesWith()`) weiterhin in lokalen Koordinaten.

QGraphicsItem Unterstützt die Kollisionserkennung über die Funktionen ` QGraphicsItem::shape()` und `QGraphicsItem::collidesWith()`, die beide virtuelle Funktionen sind. Indem Sie die Form Ihres Elements als lokalen Koordinatenwert ` QPainterPath ` aus ` QGraphicsItem::shape()` zurückgeben, übernimmt ` QGraphicsItem ` die gesamte Kollisionserkennung für Sie. Wenn Sie jedoch eine eigene Kollisionserkennung bereitstellen möchten, können Sie `QGraphicsItem::collidesWith()` neu implementieren.

Klassen im Graphics View Framework

Diese Klassen bieten ein Framework zur Erstellung interaktiver Anwendungen.

Das Koordinatensystem der Grafikansicht

Die Graphics View basiert auf dem kartesischen Koordinatensystem; die Position und Geometrie der Elemente in der Szene werden durch Paare von Zahlen dargestellt: die x-Koordinate und die y-Koordinate. Betrachtet man eine Szene mit einer nicht transformierten Ansicht, entspricht eine Einheit in der Szene einem Pixel auf dem Bildschirm.

In Graphics View kommen drei effektive Koordinatensysteme zum Einsatz: Objektkoordinaten, Szenenkoordinaten und Ansichts-Koordinaten. Um Ihre Implementierung zu vereinfachen, stellt Graphics View Hilfsfunktionen bereit, mit denen Sie zwischen den drei Koordinatensystemen umrechnen können.

Beim Rendern entsprechen die Szenenkoordinaten von „Graphics View“ den logischen Koordinaten von „ QPainter “, und die Ansichts-Koordinaten entsprechen den Gerätekoordinaten. In der Dokumentation zum Koordinatensystem erfahren Sie mehr über die Beziehung zwischen logischen Koordinaten und Gerätekoordinaten.

Objektkoordinaten

Elemente befinden sich in ihrem eigenen lokalen Koordinatensystem. Ihre Koordinaten sind in der Regel um ihren Mittelpunkt (0, 0) zentriert, und dieser ist auch der Mittelpunkt für alle Transformationen. Geometrische Primitive im Elementkoordinatensystem werden oft als Elementpunkte, Elementlinien oder Elementrechtecke bezeichnet.

Beim Erstellen eines benutzerdefinierten Elements müssen Sie sich nur um die Elementkoordinaten kümmern; „ QGraphicsScene “ und „ QGraphicsView “ führen alle Transformationen für Sie durch. Dies macht die Implementierung benutzerdefinierter Elemente sehr einfach. Wenn Sie beispielsweise ein Mausklick- oder ein Drag-Enter-Ereignis erhalten, wird die Ereignisposition in Objektkoordinaten angegeben. Die virtuelle Funktion ` QGraphicsItem::contains()` (die ` true ` zurückgibt, wenn sich ein bestimmter Punkt innerhalb Ihres Objekts befindet, und andernfalls `false`), nimmt ein Punktargument in Objektkoordinaten entgegen. Ebenso liegen das umschließende Rechteck und die Form eines Objekts in Objektkoordinaten vor.

Die Position eines Elements ist die Koordinate des Mittelpunkts des Elements im Koordinatensystem seines übergeordneten Elements; dies wird manchmal auch als „Elternkoordinaten“ bezeichnet. Die Szene wird in diesem Sinne als „Elternelement“ aller Elemente ohne übergeordnetes Element betrachtet. Die Positionen von Elementen der obersten Ebene liegen in Szenekoordinaten.

Die Koordinaten eines untergeordneten Elements beziehen sich auf die Koordinaten des übergeordneten Elements. Ist das untergeordnete Element nicht transformiert, entspricht die Differenz zwischen einer Koordinate des untergeordneten Elements und einer Koordinate des übergeordneten Elements dem Abstand zwischen den Elementen in den übergeordneten Koordinaten. Beispiel: Befindet sich ein nicht transformiertes untergeordnetes Element genau am Mittelpunkt seines übergeordneten Elements, sind die Koordinatensysteme der beiden Elemente identisch. Liegt die Position des untergeordneten Elements jedoch bei (10, 0), entspricht der Punkt (0, 10) des untergeordneten Elements dem Punkt (10, 10) des übergeordneten Elements.

Da die Position und Transformation von Elementen relativ zum übergeordneten Element sind, bleiben die Koordinaten von untergeordneten Elementen von der Transformation des übergeordneten Elements unberührt, obwohl die Transformation des übergeordneten Elements das untergeordnete Element implizit transformiert. Im obigen Beispiel entspricht der Punkt (0, 10) des untergeordneten Elements auch dann noch dem Punkt (10, 10) des übergeordneten Elements, wenn dieses gedreht und skaliert wird. Relativ zur Szene folgt das untergeordnete Element jedoch der Transformation und Position des übergeordneten Elements. Wird das übergeordnete Element um das Zweifache skaliert (2x, 2x), befindet sich die Position des untergeordneten Elements bei der Szenenkoordinate (20, 0), und sein Punkt (10, 0) entspricht dem Punkt (40, 0) in der Szene.

Mit QGraphicsItem::pos() als einer der wenigen Ausnahmen arbeiten die Funktionen von QGraphicsItem in Objektkoordinaten, unabhängig vom Objekt oder der Transformation eines seiner übergeordneten Objekte. Beispielsweise wird das Begrenzungsrechteck eines Objekts (d. h. QGraphicsItem::boundingRect()) immer in Objektkoordinaten angegeben.

Szenenkoordinaten

Die Szene stellt das Basiskoordinatensystem für alle ihre Elemente dar. Das Szenekoordinatensystem beschreibt die Position jedes Elements der obersten Ebene und bildet zudem die Grundlage für alle Szenenereignisse, die von der Ansicht an die Szene übermittelt werden. Jedes Element in der Szene verfügt neben seiner lokalen Position und seinem lokalen Begrenzungsrechteck über eine Szenenposition und ein Szenenbegrenzungsrechteck (QGraphicsItem::scenePos(), QGraphicsItem::sceneBoundingRect()). Die Szenenposition beschreibt die Position des Elements in Szenekoordinaten, und sein Szenenbegrenzungsrechteck bildet die Grundlage dafür, wie QGraphicsScene ermittelt, welche Bereiche der Szene sich verändert haben. Änderungen in der Szene werden über das Signal „ QGraphicsScene::changed()“ mitgeteilt, wobei das Argument eine Liste von Szenenrechtecken ist.

Ansichtskoordinaten

Ansichtskoordinaten sind die Koordinaten des Widgets. Jede Einheit in den Ansichtskoordinaten entspricht einem Pixel. Das Besondere an diesem Koordinatensystem ist, dass es relativ zum Widget bzw. zum Ansichtsfenster ist und nicht von der beobachteten Szene beeinflusst wird. Die obere linke Ecke des Viewports von „ QGraphicsView “ ist immer (0, 0), und die untere rechte Ecke ist immer (Viewport-Breite, Viewport-Höhe). Alle Mausereignisse sowie Drag-and-Drop-Ereignisse werden ursprünglich als Ansichtskoordinaten empfangen, und Sie müssen diese Koordinaten auf die Szene abbilden, um mit Elementen interagieren zu können.

Koordinatenabbildung

Beim Umgang mit Elementen in einer Szene kann es oft nützlich sein, Koordinaten und beliebige Formen von der Szene auf ein Element, von Element zu Element oder von der Ansicht auf die Szene abzubilden. Wenn Sie beispielsweise mit der Maus in den Ansichtsbereich von „ QGraphicsView “ klicken, können Sie die Szene abfragen, welches Element sich unter dem Cursor befindet, indem Sie „ QGraphicsView::mapToScene()“ aufrufen, gefolgt von „ QGraphicsScene::itemAt()“. Wenn Sie wissen möchten, wo sich ein Element im Ansichtsfenster befindet, können Sie zunächst QGraphicsItem::mapToScene() für das Element und anschließend QGraphicsView::mapFromScene() für die Ansicht aufrufen. Wenn Sie schließlich herausfinden möchten, welche Elemente sich innerhalb einer Ansichtsellipse befinden, können Sie QPainterPath an mapToScene() übergeben und anschließend den abgebildeten Pfad an QGraphicsScene::items() übergeben.

Sie können Koordinaten und Formen in die Szene eines Elements hinein und aus dieser heraus abbilden, indem Sie „ QGraphicsItem::mapToScene()“ und „ QGraphicsItem::mapFromScene()“ aufrufen. Sie können auch eine Abbildung auf das übergeordnete Element eines Elements vornehmen, indem Sie „ QGraphicsItem::mapToParent()“ und „ QGraphicsItem::mapFromParent()“ aufrufen, oder zwischen Elementen, indem Sie „ QGraphicsItem::mapToItem()“ und „ QGraphicsItem::mapFromItem()“ aufrufen. Alle Abbildungsfunktionen können sowohl Punkte, Rechtecke, Polygone als auch Pfade abbilden.

Die gleichen Zuordnungsfunktionen stehen in der Ansicht zur Verfügung, um Zuordnungen zur Szene und aus der Szene heraus vorzunehmen: ` QGraphicsView::mapFromScene()` und ` QGraphicsView::mapToScene()`. Um von einer Ansicht zu einem Element zuzuordnen, führen Sie zunächst eine Zuordnung zur Szene und anschließend eine Zuordnung von der Szene zum Element durch.

Wichtigste Funktionen

Zoomen und Drehen

QGraphicsView unterstützt dieselben affinen Transformationen wie QPainter über QGraphicsView::setMatrix(). Durch Anwenden einer Transformation auf die Ansicht können Sie auf einfache Weise Unterstützung für gängige Navigationsfunktionen wie Zoomen und Drehen hinzufügen.

Hier ist ein Beispiel für die Implementierung von Zoom- und Rotations-Slots in einer Unterklasse von ` QGraphicsView`:

class View : public QGraphicsView
{
Q_OBJECT
    //...
public slots:
    void zoomIn() { scale(1.2, 1.2); }
    void zoomOut() { scale(1 / 1.2, 1 / 1.2); }
    void rotateLeft() { rotate(-10); }
    void rotateRight() { rotate(10); }
    //...
};

Die Slots könnten mit „ autoRepeat “ aktiviert an „ QToolButtons “ angeschlossen werden.

QGraphicsView Hält die Mitte der Ansicht ausgerichtet, wenn Sie die Ansicht transformieren.

Siehe auch das Beispiel „Elastic Nodes“ für Code, der zeigt, wie grundlegende Zoomfunktionen implementiert werden.

Drucken

Die „Graphics View“ ermöglicht über ihre Rendering-Funktionen „ QGraphicsScene::render()“ und „ QGraphicsView::render()“ das Drucken einzelner Zeilen. Die Funktionen bieten dieselbe API: Sie können die Szene oder die Ansicht dazu bringen, ihren gesamten Inhalt oder Teile davon in ein beliebiges Zeichen-Device zu rendern, indem Sie einer der beiden Rendering-Funktionen ein „ QPainter “ übergeben. Dieses Beispiel zeigt, wie man die gesamte Szene mithilfe von „QPrinter“ auf eine ganze Seite druckt.

QGraphicsScene scene;
QPrinter printer;
scene.addRect(QRectF(0, 0, 100, 200), QPen(Qt::black), QBrush(Qt::green));

if (QPrintDialog(&printer).exec() == QDialog::Accepted) {
    QPainter painter(&printer);
    painter.setRenderHint(QPainter::Antialiasing);
    scene.render(&painter);
}

Der Unterschied zwischen den Funktionen zur Darstellung von Szenen und Ansichten besteht darin, dass die eine in Szenekoordinaten und die andere in Ansichts-Koordinaten arbeitet. QGraphicsScene::render() wird oft bevorzugt, um ganze Segmente einer Szene untransformiert auszugeben, beispielsweise zum Plotten geometrischer Daten oder zum Drucken eines Textdokuments. QGraphicsView::render() eignet sich hingegen zum Erstellen von Screenshots; standardmäßig wird dabei der exakte Inhalt des Ansichtsfensters mithilfe des bereitgestellten „Painters“ gerendert.

QGraphicsScene scene;
scene.addRect(QRectF(0, 0, 100, 200), QPen(Qt::black), QBrush(Qt::green));

QPixmap pixmap;
QPainter painter(&pixmap);
painter.setRenderHint(QPainter::Antialiasing);
scene.render(&painter);
painter.end();

pixmap.save("scene.png");

Wenn die Größen des Quell- und des Zielbereichs nicht übereinstimmen, wird der Quellinhalt gestreckt, um in den Zielbereich zu passen. Indem Sie der von Ihnen verwendeten Rendering-Funktion ein ` Qt::AspectRatioMode ` übergeben, können Sie festlegen, ob das Seitenverhältnis der Szene beim Strecken des Inhalts beibehalten oder ignoriert werden soll.

Drag & Drop

Da ` QGraphicsView ` indirekt von ` QWidget ` erbt, bietet es bereits dieselbe Drag-and-Drop-Funktionalität wie ` QWidget `. Darüber hinaus bietet das Graphics-View-Framework als Komfortfunktion Drag-and-Drop-Unterstützung für die Szene sowie für jedes einzelne Element. Wenn die Ansicht einen Drag-Vorgang empfängt, wandelt sie die Drag-and-Drop-Ereignisse in ein ` QGraphicsSceneDragDropEvent` um, das dann an die Szene weitergeleitet wird. Die Szene übernimmt die Koordination dieses Ereignisses und leitet es an das erste Element unter dem Mauszeiger weiter, das das Ablegen zulässt.

Um ein Ziehen von einem Element aus zu starten, erstellen Sie ein ` QDrag `-Objekt und übergeben Sie dabei einen Zeiger auf das Widget, das das Ziehen auslöst. Elemente können gleichzeitig von mehreren Ansichten beobachtet werden, aber nur eine Ansicht kann den Drag-Vorgang starten. Drag-Vorgänge werden in den meisten Fällen durch das Drücken oder Bewegen der Maus ausgelöst; daher können Sie in `mousePressEvent()` oder `mouseMoveEvent()` den Zeiger auf das auslösende Widget aus dem Ereignis abrufen. Zum Beispiel:

void CustomItem::mousePressEvent(QGraphicsSceneMouseEvent *event)
{
    QMimeData *data = new QMimeData;
    QDrag *drag = new QDrag(event->widget());
    drag->setMimeData(data);
    drag->exec();
}

Um Drag-and-Drop-Ereignisse für die Szene abzufangen, implementieren Sie ` QGraphicsScene::dragEnterEvent()` sowie die für Ihre jeweilige Szene erforderlichen Ereignisbehandler in einer Unterklasse von ` QGraphicsItem ` neu. Weitere Informationen zu Drag-and-Drop in der Graphics View finden Sie in der Dokumentation zu den einzelnen Ereignisbehandlern von ` QGraphicsScene`.

Elemente können die Drag-and-Drop-Unterstützung aktivieren, indem sie ` QGraphicsItem::setAcceptDrops()` aufrufen. Um das eingehende Drag-Ereignis zu verarbeiten, implementieren Sie ` QGraphicsItem::dragEnterEvent()`, ` QGraphicsItem::dragMoveEvent()`, ` QGraphicsItem::dragLeaveEvent()` und ` QGraphicsItem::dropEvent()` neu.

Siehe auch das Beispiel „Drag-and-Drop-Roboter“ zur Veranschaulichung der Unterstützung von Drag-and-Drop-Vorgängen durch die Graphics View.

Cursor und Tooltips

Wie „ QWidget “ unterstützt auch „ QGraphicsItem “ Cursor (QGraphicsItem::setCursor()) und Tooltips (QGraphicsItem::setToolTip()). Die Cursor und Tooltips werden von „ QGraphicsView “ aktiviert, sobald der Mauszeiger in den Bereich des Elements gelangt (erkannt durch den Aufruf von „ QGraphicsItem::contains()“).

Sie können einen Standardcursor auch direkt in der Ansicht festlegen, indem Sie QGraphicsView::setCursor() aufrufen.

Siehe auch das Beispiel „Drag-and-Drop-Roboter“ für Code, der Tooltips und die Handhabung von Cursorformen implementiert.

Animation

Graphics View unterstützt Animationen auf mehreren Ebenen. Mithilfe des Animation Framework können Sie Animationen ganz einfach zusammenstellen. Dazu müssen Ihre Elemente von ` QGraphicsObject ` erben und mit ` QPropertyAnimation ` verknüpft sein. ` QPropertyAnimation ` ermöglicht die Animation beliebiger ` QObject `-Eigenschaften.

Eine weitere Möglichkeit besteht darin, ein benutzerdefiniertes Element zu erstellen, das von „ QObject “ und „ QGraphicsItem “ erbt. Das Element kann dann eigene Timer einrichten und Animationen mit inkrementellen Schritten in „ QObject::timerEvent()“ steuern.

Eine dritte Möglichkeit, die vor allem aus Kompatibilitätsgründen mit QCanvas in Qt 3 zur Verfügung steht, besteht darin, die Szene durch den Aufruf von ` QGraphicsScene::advance()` voranzutreiben, wodurch wiederum ` QGraphicsItem::advance()` aufgerufen wird.

OpenGL-Rendering

Um das OpenGL-Rendering zu aktivieren, legen Sie einfach ein neues ` QOpenGLWidget ` als Viewport von ` QGraphicsView ` fest, indem Sie ` QGraphicsView::setViewport()` aufrufen. Wenn Sie OpenGL mit Antialiasing verwenden möchten, müssen Sie ein ` QSurfaceFormat ` mit der erforderlichen Sample-Anzahl festlegen (siehe ` QSurfaceFormat::setSamples()`).

Beispiel:

QGraphicsView view(&scene);
QOpenGLWidget *gl = new QOpenGLWidget();
QSurfaceFormat format;
format.setSamples(4);
gl->setFormat(format);
view.setViewport(gl);

Elementgruppen

Indem Sie ein Element zum Kind eines anderen machen, erreichen Sie die wichtigste Funktion der Elementgruppierung: Die Elemente bewegen sich gemeinsam, und alle Transformationen werden vom übergeordneten Element an das untergeordnete weitergegeben.

Darüber hinaus ist „ QGraphicsItemGroup “ ein spezielles Element, das die Ereignisbehandlung von untergeordneten Elementen mit einer nützlichen Schnittstelle zum Hinzufügen und Entfernen von Elementen zu bzw. aus einer Gruppe kombiniert. Das Hinzufügen eines Elements zu einem „ QGraphicsItemGroup “ bewahrt die ursprüngliche Position und Transformation des Elements, während das Ändern der übergeordneten Ebene bei Elementen im Allgemeinen dazu führt, dass sich das untergeordnete Element relativ zu seinem neuen übergeordneten Element neu positioniert. Der Einfachheit halber können Sie „ QGraphicsItemGroups“ in der Szene erstellen, indem Sie „ QGraphicsScene::createItemGroup()“ aufrufen.

Widgets und Layouts

Qt 4.4 führte die Unterstützung für geometrie- und layoutbewusste Elemente über „ QGraphicsWidget “ ein. Dieses spezielle Basiselement ähnelt „ QWidget “, erbt jedoch im Gegensatz zu „ QWidget “ nicht von „ QPaintDevice “, sondern von „ QGraphicsItem “. Dies ermöglicht es Ihnen, vollständige Widgets mit Ereignissen, Signalen und Slots, Größenhinweisen und Richtlinien zu erstellen, und Sie können die Geometrien Ihrer Widgets in Layouts über „ QGraphicsLinearLayout “ und „ QGraphicsGridLayout “ verwalten.

QGraphicsWidget

Aufbauend auf den Funktionen und dem geringen Speicherbedarf von QGraphicsItem bietet QGraphicsWidget das Beste aus beiden Welten: zusätzliche Funktionen aus QWidget, wie z. B. Stil, Schriftart, Farbpalette, Layout-Richtung und Geometrie, sowie Auflösungsunabhängigkeit und Unterstützung für Transformationen aus QGraphicsItem. Da die Graphics View reale Koordinaten anstelle von Ganzzahlen verwendet, funktionieren die Geometrie-Funktionen von QGraphicsWidget auch mit QRectF und QPointF. Dies gilt auch für Rahmenrechtecke, Ränder und Abstände. Bei QGraphicsWidget ist es beispielsweise nicht ungewöhnlich, Inhaltsränder von (0,5; 0,5; 0,5; 0,5) anzugeben. Sie können sowohl Unterwidgets als auch „Top-Level“-Fenster erstellen; in einigen Fällen können Sie nun Graphics View für fortgeschrittene MDI-Anwendungen verwenden.

Einige Eigenschaften von „ QWidget “ werden unterstützt, darunter Fensterflags und -attribute, jedoch nicht alle. Einen vollständigen Überblick darüber, was unterstützt wird und was nicht, finden Sie in der Klassendokumentation zu „ QGraphicsWidget “. So können Sie beispielsweise verzierte Fenster erstellen, indem Sie das Fensterflag „ Qt::Window “ an den Konstruktor von „ QGraphicsWidget “ übergeben; allerdings unterstützt „Graphics View“ derzeit nicht die unter macOS üblichen Flags „ Qt::Sheet “ und „ Qt::Drawer “.

QGraphicsLayout

QGraphicsLayout ist Teil eines Layout-Frameworks der zweiten Generation, das speziell für „ QGraphicsWidget “ entwickelt wurde. Seine API ähnelt stark der von „ QLayout “. Sie können Widgets und Unterlayouts sowohl innerhalb von „ QGraphicsLinearLayout “ als auch von „ QGraphicsGridLayout “ verwalten. Sie können außerdem ganz einfach ein eigenes Layout erstellen, indem Sie selbst eine Unterklasse von „ QGraphicsLayout “ definieren, oder eigene „ QGraphicsItem “-Elemente zum Layout hinzufügen, indem Sie eine Adapter-Unterklasse von „ QGraphicsLayoutItem “ schreiben.

Unterstützung für eingebettete Widgets

Graphics View bietet nahtlose Unterstützung für die Einbettung beliebiger Widgets in die Szene. Sie können einfache Widgets wie QLineEdit oder QPushButton, komplexe Widgets wie QTabWidget und sogar komplette Hauptfenster einbetten. Um Ihr Widget in die Szene einzubetten, rufen Sie einfach QGraphicsScene::addWidget() auf oder erstellen Sie eine Instanz von QGraphicsProxyWidget, um Ihr Widget manuell einzubetten.

Über ` QGraphicsProxyWidget` ist Graphics View in der Lage, die Funktionen des Client-Widgets tiefgreifend zu integrieren, darunter Cursor, Tooltips, Maus-, Tablet- und Tastaturereignisse, untergeordnete Widgets, Animationen, Popups (z. B. ` QComboBox ` oder ` QCompleter`) sowie den Eingabefokus und die Aktivierung des Widgets. ` QGraphicsProxyWidget ` integriert sogar die Tabulatorreihenfolge des eingebetteten Widgets, sodass Sie mit der Tabulatortaste zwischen eingebetteten Widgets hin- und herwechseln können. Sie können sogar ein neues „ QGraphicsView “ in Ihre Szene einbetten, um komplexe verschachtelte Szenen zu erstellen.

Beim Transformieren eines eingebetteten Widgets stellt die Grafikansicht sicher, dass das Widget auflösungsunabhängig transformiert wird, sodass Schriftarten und Stil auch beim Vergrößern scharf bleiben. (Beachten Sie, dass der Effekt der Auflösungsunabhängigkeit vom jeweiligen Stil abhängt.)

Leistung

Gleitkomma-Befehle

Um Transformationen und Effekte präzise und schnell auf Elemente anzuwenden, basiert die Grafikansicht auf der Annahme, dass die Hardware des Benutzers eine angemessene Leistung für Gleitkomma-Befehle bereitstellen kann.

Viele Workstations und Desktop-Computer sind mit geeigneter Hardware ausgestattet, um diese Art von Berechnungen zu beschleunigen, doch manche eingebetteten Geräte stellen möglicherweise nur Bibliotheken zur Verfügung, um mathematische Operationen zu verarbeiten, oder emulieren Gleitkomma-Befehle in der Software.

Infolgedessen können bestimmte Effekte auf manchen Geräten langsamer sein als erwartet. Es ist unter Umständen möglich, diesen Leistungseinbruch durch Optimierungen in anderen Bereichen auszugleichen, beispielsweise durch die Verwendung von OpenGL zum Rendern einer Szene. Allerdings können solche Optimierungen selbst zu einer Verringerung der Leistung führen, wenn sie ebenfalls auf das Vorhandensein von Gleitkomma-Hardware angewiesen sind.