Framework de la vue graphique

La vue graphique fournit une interface permettant de gérer et d’interagir avec un grand nombre d’éléments graphiques 2D personnalisés, ainsi qu’un widget de vue pour visualiser ces éléments, avec prise en charge du zoom et de la rotation.

Le framework intègre une architecture de propagation des événements qui permet des interactions précises en double précision pour les éléments de la scène. Les éléments peuvent gérer les événements de touche, les événements de clic, de déplacement, de relâchement et de double-clic de la souris, et ils peuvent également suivre les mouvements de la souris.

Graphics View utilise un arbre BSP (Binary Space Partitioning) pour permettre une détection très rapide des éléments, ce qui lui permet de visualiser en temps réel des scènes de grande envergure, même comptant des millions d'éléments.

Graphics View a été introduit dans Qt 4.2, en remplacement de son prédécesseur, QCanvas.

L’architecture de Graphics View

Graphics View propose une approche de la programmation modèle-vue basée sur les éléments, à l’instar des classes de commodité d’InterView : QTableView, QTreeView et QListView. Plusieurs vues peuvent observer une même scène, et celle-ci contient des éléments de formes géométriques variées.

La classe Scene

QGraphicsScene fournit la scène de Graphics View. La scène a les responsabilités suivantes :

• Fournir une interface rapide pour gérer un grand nombre d’éléments
• Propager les événements vers chaque élément
• Gérer l’état des éléments, notamment la sélection et la gestion du focus
• Fournir une fonctionnalité de rendu non transformé, principalement destinée à l’impression

La scène sert de conteneur pour les objets « QGraphicsItem ». Les éléments sont ajoutés à la scène en appelant la fonction ` QGraphicsScene::addItem()`, puis récupérés en appelant l'une des nombreuses fonctions de recherche d'éléments. La fonction ` QGraphicsScene::items()` et ses surcharges renvoient tous les éléments contenus dans ou coupant un point, un rectangle, un polygone ou un tracé vectoriel général. La fonction ` QGraphicsScene::itemAt` () renvoie l’élément situé tout en haut à un point donné. Toutes les fonctions de détection d’éléments renvoient les éléments par ordre d’empilement décroissant (c’est-à-dire que le premier élément renvoyé est celui situé tout en haut, et le dernier celui situé tout en bas).

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

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

QGraphicsSceneL'architecture de propagation des événements de gère la distribution des événements de la scène aux éléments et gère également la propagation entre les éléments. Si la scène reçoit un événement de clic de souris à une certaine position, elle transmet cet événement à l'élément qui se trouve à cette position.

QGraphicsScene QGraphicsScene gère également certains états des éléments, tels que la sélection et le focus. Vous pouvez sélectionner des éléments de la scène en appelant ` ()` et en lui transmettant une forme arbitraire. Cette fonctionnalité sert également de base à la sélection « à l'élastique » dans . Pour obtenir la liste de tous les éléments actuellement sélectionnés, appelez ` ()`. Un autre état géré par est le fait qu'un élément dispose ou non du focus clavier. Vous pouvez placer le focus sur un élément en appelant () ou (), ou obtenir l’élément actuellement en focus en appelant (). QGraphicsScene::setSelectionArea QGraphicsView QGraphicsScene::selectedItems QGraphicsScene::setFocusItem QGraphicsItem::setFocus QGraphicsScene::focusItem

Enfin, ` QGraphicsScene ` vous permet de rendre des parties de la scène dans un périphérique de dessin via la fonction ` QGraphicsScene::render()`. Vous trouverez plus d’informations à ce sujet dans la section « Impression » plus loin dans ce document.

La vue

QGraphicsView fournit le widget de vue, qui permet de visualiser le contenu d’une scène. Vous pouvez associer plusieurs vues à une même scène, afin de disposer de plusieurs fenêtres d’affichage pour un même ensemble de données. Le widget de vue est une zone de défilement et dispose de barres de défilement permettant de naviguer dans des scènes volumineuses. Pour activer la prise en charge d’OpenGL, vous pouvez définir un QOpenGLWidget comme fenêtre d’affichage en appelant la fonction QGraphicsView::setViewport().

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

La vue reçoit les événements d’entrée provenant du clavier et de la souris, et les traduit en événements de scène (en convertissant les coordonnées utilisées en coordonnées de scène le cas échéant), avant d’envoyer ces événements à la scène visualisée.

À l’aide de sa matrice de transformation, ` QGraphicsView::transform()`, la vue peut transformer le système de coordonnées de la scène. Cela permet des fonctionnalités de navigation avancées telles que le zoom et la rotation. Pour plus de commodité, ` QGraphicsView ` fournit également des fonctions permettant de convertir les coordonnées de la vue en coordonnées de la scène et inversement : ` QGraphicsView::mapToScene()` et ` QGraphicsView::mapFromScene()`.

La classe Item

QGraphicsItem est la classe de base des éléments graphiques d’une scène. Graphics View fournit plusieurs éléments standard correspondant à des formes courantes, telles que les rectangles (QGraphicsRectItem), les ellipses (QGraphicsEllipseItem) et les éléments de texte (QGraphicsTextItem), mais les fonctionnalités les plus puissantes de QGraphicsItem sont accessibles lorsque vous créez un élément personnalisé. Entre autres, QGraphicsItem prend en charge les fonctionnalités suivantes :

• les événements de clic, de déplacement, de relâchement et de double-clic de la souris, ainsi que les événements de survol, de molette et de menu contextuel.
• Focalisation du clavier et événements de touches
• Glisser-déposer
• Le regroupement, à la fois via des relations parent-enfant et avec QGraphicsItemGroup
• la détection de collision

Les éléments évoluent dans un système de coordonnées local et, à l’instar de QGraphicsView, cette bibliothèque fournit également de nombreuses fonctions permettant de mapper les coordonnées entre l’élément et la scène, ainsi que d’un élément à l’autre. De même, à l’instar de QGraphicsView, elle permet de transformer son système de coordonnées à l’aide d’une matrice : QGraphicsItem::transform(). Cette fonctionnalité est utile pour faire pivoter et mettre à l’échelle des éléments individuels.

Les éléments peuvent contenir d’autres éléments (enfants). Les transformations des éléments parents sont héritées par tous leurs enfants. Cependant, quelle que soit la transformation cumulée d’un élément, toutes ses fonctions (par exemple, ` QGraphicsItem::contains()`, ` QGraphicsItem::boundingRect()`, `QGraphicsItem::collidesWith()`) continuent de fonctionner dans le système de coordonnées local.

QGraphicsItem QGraphicsItem prend en charge la détection de collision via les fonctions QGraphicsItem::shape() et QGraphicsItem::collidesWith(), qui sont toutes deux des fonctions virtuelles. En renvoyant la forme de votre élément sous forme d’ QPainterPath de coordonnées locales à partir de QGraphicsItem::shape(), QGraphicsItem se chargera de toute la détection de collision à votre place. Si vous souhaitez toutefois mettre en place votre propre détection de collision, vous pouvez réimplémenter QGraphicsItem::collidesWith().

Classes du Graphics View Framework

Ces classes fournissent un framework permettant de créer des applications interactives.

Le système de coordonnées de la vue graphique

La vue graphique repose sur le système de coordonnées cartésiennes ; la position et la géométrie des éléments sur la scène sont représentées par des paires de nombres : la coordonnée x et la coordonnée y. Lorsque l'on observe une scène à l'aide d'une vue non transformée, une unité sur la scène correspond à un pixel à l'écran.

Trois systèmes de coordonnées distincts sont utilisés dans Graphics View : les coordonnées des éléments, les coordonnées de la scène et les coordonnées de la vue. Pour simplifier votre implémentation, Graphics View fournit des fonctions pratiques qui vous permettent d'établir des correspondances entre ces trois systèmes de coordonnées.

Lors du rendu, les coordonnées de scène de Graphics View correspondent aux coordonnées logiques d’ QPainter, et les coordonnées de vue sont identiques aux coordonnées du périphérique. Dans la documentation relative au système de coordonnées, vous pouvez en savoir plus sur la relation entre les coordonnées logiques et les coordonnées du périphérique.

Coordonnées des éléments

Les éléments évoluent dans leur propre système de coordonnées local. Leurs coordonnées sont généralement centrées sur leur point central (0, 0), qui sert également de centre pour toutes les transformations. Les primitives géométriques dans le système de coordonnées de l’élément sont souvent appelées « points d’élément », « lignes d’élément » ou « rectangles d’élément ».

Lorsque vous créez un élément personnalisé, vous n’avez qu’à vous soucier des coordonnées de l’élément ; les méthodes ` QGraphicsScene ` et ` QGraphicsView ` se chargent de toutes les transformations à votre place. Cela facilite grandement la mise en œuvre d’éléments personnalisés. Par exemple, si vous recevez un événement de clic ou de glisser-déposer, la position de l’événement est indiquée en coordonnées de l’élément. La fonction virtuelle ` QGraphicsItem::contains()` (qui renvoie ` true ` si un point donné se trouve à l’intérieur de votre élément, et `false` dans le cas contraire) prend un argument de type point exprimé en coordonnées de l’élément. De même, le rectangle englobant et la forme d’un élément sont exprimés en coordonnées de l’élément.

La position de l’élément correspond à la coordonnée du point central de l’élément dans le système de coordonnées de son parent ; on parle parfois de « coordonnées du parent ». La scène est, en ce sens, considérée comme le « parent » de tous les éléments sans parent. La position des éléments de niveau supérieur est exprimée en coordonnées de la scène.

Les coordonnées d’un enfant sont relatives à celles de son parent. Si l’enfant n’est pas transformé, la différence entre une coordonnée de l’enfant et une coordonnée du parent correspond à la distance entre les éléments dans les coordonnées du parent. Par exemple : si un élément enfant non transformé est positionné exactement au point central de son parent, alors les systèmes de coordonnées des deux éléments seront identiques. Si la position de l’élément enfant est (10, 0), en revanche, le point (0, 10) de l’élément enfant correspondra au point (10, 10) de son élément parent.

La position et la transformation des éléments étant relatives au parent, les coordonnées des éléments enfants ne sont pas affectées par la transformation du parent, bien que celle-ci transforme implicitement l’enfant. Dans l’exemple ci-dessus, même si le parent subit une rotation et une mise à l’échelle, le point (0, 10) de l’enfant correspondra toujours au point (10, 10) du parent. Par rapport à la scène, cependant, l’enfant suivra la transformation et la position du parent. Si le parent est mis à l’échelle (2x, 2x), la position du fils se situera aux coordonnées (20, 0) de la scène, et son point (10, 0) correspondra au point (40, 0) sur la scène.

QGraphicsItem::pos() constituant l’une des rares exceptions, les fonctions de QGraphicsItem opèrent en coordonnées d’élément, indépendamment de l’élément lui-même ou de la transformation de l’un de ses parents. Par exemple, le rectangle englobant d’un élément (c’est-à-dire QGraphicsItem::boundingRect()) est toujours exprimé en coordonnées d’élément.

Coordonnées de la scène

La scène représente le système de coordonnées de base pour tous ses éléments. Le système de coordonnées de la scène décrit la position de chaque élément de niveau supérieur et sert également de base à tous les événements de scène transmis à la scène depuis la vue. Chaque élément de la scène possède une position de scène et un rectangle englobant (QGraphicsItem::scenePos(), QGraphicsItem::sceneBoundingRect()), en plus de sa position locale et de son rectangle englobant. La position de scène décrit la position de l’élément dans les coordonnées de la scène, et son rectangle englobant de scène sert de base à la fonction QGraphicsScene pour déterminer quelles zones de la scène ont changé. Les modifications apportées à la scène sont signalées via le signal « QGraphicsScene::changed() », dont l’argument est une liste de rectangles de la scène.

Coordonnées de la vue

Les coordonnées de la vue sont les coordonnées du widget. Chaque unité des coordonnées de la vue correspond à un pixel. La particularité de ce système de coordonnées est qu’il est relatif au widget, ou à la fenêtre d’affichage, et qu’il n’est pas affecté par la scène observée. Le coin supérieur gauche de la fenêtre d'affichage de QGraphicsView est toujours (0, 0), et le coin inférieur droit est toujours (largeur de la fenêtre d'affichage, hauteur de la fenêtre d'affichage). Tous les événements de souris et les événements de glisser-déposer sont initialement reçus sous forme de coordonnées de la fenêtre d'affichage, et vous devez mapper ces coordonnées à la scène afin d'interagir avec les éléments.

Mappage des coordonnées

Souvent, lorsque l’on manipule des éléments dans une scène, il peut être utile de mapper des coordonnées et des formes arbitraires de la scène vers un élément, d’un élément à un autre, ou de la vue vers la scène. Par exemple, lorsque vous cliquez avec la souris dans la fenêtre d’affichage d’ QGraphicsView, vous pouvez demander à la scène quel élément se trouve sous le curseur en appelant ` QGraphicsView::mapToScene()``, puis ` QGraphicsScene::itemAt()`. Si vous souhaitez savoir où se trouve un élément dans la fenêtre d’affichage, vous pouvez appeler la méthode QGraphicsItem::mapToScene() sur l’élément, puis QGraphicsView::mapFromScene() sur la vue. Enfin, si vous souhaitez déterminer quels éléments se trouvent à l’intérieur d’une ellipse de vue, vous pouvez passer un objet QPainterPath à la méthode mapToScene(), puis transmettre le chemin mappé à la méthode QGraphicsScene::items().

Vous pouvez effectuer un mappage de coordonnées et de formes vers et depuis la scène d’un élément en appelant QGraphicsItem::mapToScene() et QGraphicsItem::mapFromScene(). Vous pouvez également effectuer un mappage vers l’élément parent d’un élément en appelant QGraphicsItem::mapToParent() et QGraphicsItem::mapFromParent(), ou entre des éléments en appelant QGraphicsItem::mapToItem() et QGraphicsItem::mapFromItem(). Toutes les fonctions de mappage peuvent mapper à la fois des points, des rectangles, des polygones et des chemins.

Les mêmes fonctions de mappage sont disponibles dans la vue, pour effectuer des mappages vers et depuis la scène : ` QGraphicsView::mapFromScene()` et ` QGraphicsView::mapToScene()`. Pour effectuer un mappage depuis une vue vers un élément, vous devez d’abord effectuer un mappage vers la scène, puis un mappage depuis la scène vers l’élément.

Fonctionnalités clés

Zoom et rotation

QGraphicsView prend en charge les mêmes transformations affines que QPainter via QGraphicsView::setMatrix(). En appliquant une transformation à la vue, vous pouvez facilement ajouter la prise en charge de fonctionnalités de navigation courantes telles que le zoom et la rotation.

Voici un exemple d’implémentation des slots de zoom et de rotation dans une sous-classe de 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); }
    //...
};

Les slots peuvent être connectés à ` QToolButtons ` avec l'option « autoRepeat » activée.

QGraphicsView permet de maintenir le centre de la vue aligné lorsque vous la transformez.

Consultez également l’exemple « Elastic Nodes » pour découvrir le code illustrant la mise en œuvre des fonctionnalités de zoom de base.

Impression

Graphics View permet l’impression sur une seule ligne grâce à ses fonctions de rendu, QGraphicsScene::render() et QGraphicsView::render(). Ces fonctions fournissent la même API : vous pouvez demander à la scène ou à la vue de rendre tout ou partie de leur contenu sur n’importe quel périphérique de dessin en passant un objet QPainter à l’une ou l’autre de ces fonctions de rendu. Cet exemple montre comment imprimer la scène entière sur une page complète, à l’aide de QPrinter.

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);
}

La différence entre les fonctions de rendu « scène » et « vue » réside dans le fait que l'une opère dans le système de coordonnées de la scène, tandis que l'autre utilise celui de la vue. QGraphicsScene::render() est souvent privilégiée pour afficher des segments entiers d’une scène sans transformation, par exemple pour tracer des données géométriques ou pour afficher un document texte. La fonction QGraphicsView::render(), en revanche, est adaptée à la capture d’écran ; par défaut, elle affiche le contenu exact de la fenêtre d’affichage à l’aide du « peintre » fourni.

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");

Lorsque les tailles des zones source et cible ne correspondent pas, le contenu source est étiré pour s’adapter à la zone cible. En transmettant un Qt::AspectRatioMode à la fonction de rendu que vous utilisez, vous pouvez choisir de conserver ou d’ignorer le rapport d’aspect de la scène lorsque le contenu est étiré.

Glisser-déposer

Comme ` QGraphicsView ` hérite indirectement de ` QWidget `, il offre déjà les mêmes fonctionnalités de glisser-déposer que ` QWidget `. De plus, pour plus de commodité, le framework Graphics View prend en charge le glisser-déposer pour la scène et pour chaque élément. Lorsqu’une vue reçoit un glissement, elle convertit les événements de glisser-déposer en un ` QGraphicsSceneDragDropEvent`, qui est ensuite transmis à la scène. La scène prend en charge la gestion de cet événement et l’envoie au premier élément situé sous le curseur de la souris qui accepte les déposes.

Pour lancer un glissement à partir d’un élément, créez un objet ` QDrag ` en lui transmettant un pointeur vers le widget qui initie le glissement. Un élément peut être observé par plusieurs vues simultanément, mais une seule vue peut déclencher le glissement. Dans la plupart des cas, les glissements sont déclenchés par une pression ou un déplacement de la souris ; ainsi, dans les méthodes `mousePressEvent()` ou `mouseMoveEvent()`, vous pouvez récupérer le pointeur du widget d’origine à partir de l’événement. Par exemple :

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

Pour intercepter les événements de glisser-déposer de la scène, vous devez réimplémenter la méthode ` QGraphicsScene::dragEnterEvent()` ainsi que les gestionnaires d’événements spécifiques à votre scène, dans une sous-classe de ` QGraphicsItem `. Vous trouverez plus d’informations sur le glisser-déposer dans Graphics View dans la documentation relative à chacun des gestionnaires d’événements de ` QGraphicsScene`.

Les éléments peuvent activer la prise en charge du glisser-déposer en appelant QGraphicsItem::setAcceptDrops(). Pour gérer le glisser-déposer entrant, réimplémentez QGraphicsItem::dragEnterEvent(), QGraphicsItem::dragMoveEvent(), QGraphicsItem::dragLeaveEvent() et QGraphicsItem::dropEvent().

Consultez également l’exemple « Drag and Drop Robot » pour une démonstration de la prise en charge des opérations de glisser-déposer par Graphics View.

Curseurs et info-bulles

Tout comme QWidget, QGraphicsItem prend également en charge les curseurs (QGraphicsItem::setCursor()) et les infobulles (QGraphicsItem::setToolTip()). Les curseurs et les infobulles sont activés par QGraphicsView lorsque le curseur de la souris entre dans la zone de l'élément (détectée en appelant QGraphicsItem::contains()).

Vous pouvez également définir un curseur par défaut directement sur la vue en appelant QGraphicsView::setCursor().

Voir également l’exemple « Drag and Drop Robot » pour le code implémentant les infobulles et la gestion de la forme des curseurs.

Animation

Graphics View prend en charge l’animation à plusieurs niveaux. Vous pouvez facilement créer des animations à l’aide du framework d’animation. Pour cela, vos éléments doivent hériter de QGraphicsObject et être associés à QPropertyAnimation. QPropertyAnimation permet d’animer n’importe quelle propriété QObject.

Une autre option consiste à créer un élément personnalisé héritant de ` QObject ` et de ` QGraphicsItem`. Cet élément peut alors configurer ses propres temporisateurs et contrôler les animations par incréments à l’aide de la méthode ` QObject::timerEvent()`.

Une troisième option, principalement disponible pour des raisons de compatibilité avec QCanvas dans Qt 3, consiste à faire avancer la scène en appelant ` QGraphicsScene::advance()`, qui à son tour appelle ` QGraphicsItem::advance()`.

Rendu OpenGL

Pour activer le rendu OpenGL, il suffit de définir une nouvelle instance de ` QOpenGLWidget ` comme fenêtre de rendu de ` QGraphicsView ` en appelant ` QGraphicsView::setViewport()`. Si vous souhaitez utiliser OpenGL avec l’anticrénelage, vous devez définir une instance de ` QSurfaceFormat ` avec le nombre d’échantillons requis (voir ` QSurfaceFormat::setSamples()`).

Exemple :

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

Groupes d’éléments

En faisant d’un élément un enfant d’un autre, vous pouvez bénéficier de la fonctionnalité la plus essentielle du regroupement d’éléments : les éléments se déplacent ensemble, et toutes les transformations sont propagées du parent vers l’enfant.

De plus, l’« QGraphicsItemGroup » est un élément spécial qui combine la gestion des événements des enfants avec une interface pratique pour ajouter et retirer des éléments d’un groupe. L’ajout d’un élément à un « QGraphicsItemGroup » conservera la position et la transformation d’origine de l’élément, alors que le changement de parent d’un élément entraînera généralement le repositionnement de l’enfant par rapport à son nouveau parent. Pour plus de commodité, vous pouvez créer des « QGraphicsItemGroups » dans la scène en appelant la fonction ` QGraphicsScene::createItemGroup()`.

Widgets et mises en page

Qt 4.4 a introduit la prise en charge des éléments tenant compte de la géométrie et de la mise en page via QGraphicsWidget. Cet élément de base spécial est similaire à QWidget, mais contrairement à QWidget, il n’hérite pas de QPaintDevice; il hérite plutôt de QGraphicsItem. Cela vous permet d’écrire des widgets complets avec des événements, des signaux et des slots, des indications de taille et des politiques, et vous pouvez également gérer la géométrie de vos widgets dans les mises en page via QGraphicsLinearLayout et QGraphicsGridLayout.

QGraphicsWidget

S’appuyant sur les capacités et l’empreinte mémoire réduite de QGraphicsItem, QGraphicsWidget offre le meilleur des deux mondes : les fonctionnalités supplémentaires de QWidget, telles que le style, la police, la palette, le sens de mise en page et la géométrie, ainsi que l’indépendance vis-à-vis de la résolution et la prise en charge des transformations de QGraphicsItem. Comme Graphics View utilise des coordonnées réelles plutôt que des entiers, les fonctions géométriques de QGraphicsWidget s’appliquent également à QRectF et QPointF. Cela s’applique également aux rectangles de cadre, aux marges et aux espacements. Avec QGraphicsWidget, il n’est pas rare de spécifier des marges de contenu de (0,5 ; 0,5 ; 0,5 ; 0,5), par exemple. Vous pouvez créer à la fois des sous-widgets et des fenêtres « de premier niveau » ; dans certains cas, vous pouvez désormais utiliser Graphics View pour des applications MDI avancées.

Certaines propriétés d’ QWidget sont prises en charge, notamment les indicateurs et les attributs de fenêtre, mais pas toutes. Vous devriez vous reporter à la documentation de la classe QGraphicsWidget pour obtenir un aperçu complet de ce qui est pris en charge et de ce qui ne l’est pas. Par exemple, vous pouvez créer des fenêtres décorées en passant l’indicateur de fenêtre « Qt::Window » au constructeur de QGraphicsWidget, mais Graphics View ne prend actuellement pas en charge les indicateurs « Qt::Sheet » et « Qt::Drawer », courants sous macOS.

QGraphicsLayout

QGraphicsLayout fait partie d’un framework de mise en page de deuxième génération conçu spécifiquement pour QGraphicsWidget. Son API est très similaire à celle de QLayout. Vous pouvez gérer des widgets et des sous-mises en page à la fois dans QGraphicsLinearLayout et QGraphicsGridLayout. Vous pouvez également créer facilement votre propre mise en page en sous-classant vous-même QGraphicsLayout, ou ajouter vos propres éléments QGraphicsItem à la mise en page en écrivant une sous-classe adaptatrice de QGraphicsLayoutItem.

Prise en charge des widgets intégrés

Graphics View offre une prise en charge transparente de l’intégration de n’importe quel widget dans la scène. Vous pouvez intégrer des widgets simples, tels que QLineEdit ou QPushButton, des widgets complexes tels que QTabWidget, et même des fenêtres principales complètes. Pour intégrer votre widget à la scène, il suffit d’appeler QGraphicsScene::addWidget() ou de créer une instance de QGraphicsProxyWidget pour intégrer votre widget manuellement.

Grâce à QGraphicsProxyWidget, Graphics View est capable d’intégrer en profondeur les fonctionnalités du widget client, notamment ses curseurs, ses infobulles, les événements liés à la souris, à la tablette et au clavier, ses widgets enfants, ses animations, ses fenêtres contextuelles (par exemple, QComboBox ou QCompleter), ainsi que le focus et l’activation du widget. QGraphicsProxyWidget intègre même l’ordre de tabulation du widget intégré, ce qui vous permet de naviguer entre les widgets intégrés à l’aide de la touche Tab. Vous pouvez même intégrer un nouveau QGraphicsView dans votre scène pour créer des scènes imbriquées complexes.

Lors de la transformation d’un widget intégré, Graphics View veille à ce que celui-ci soit transformé indépendamment de la résolution, ce qui permet aux polices et au style de rester nets lors d’un zoom avant. (Notez que l’effet de l’indépendance vis-à-vis de la résolution dépend du style.)

Performances

Instructions en virgule flottante

Afin d’appliquer avec précision et rapidité des transformations et des effets aux éléments, Graphics View est conçu en partant du principe que le matériel de l’utilisateur est capable de fournir des performances raisonnables pour les instructions en virgule flottante.

De nombreuses stations de travail et ordinateurs de bureau sont équipés d’un matériel adapté pour accélérer ce type de calculs, mais certains appareils embarqués peuvent ne fournir que des bibliothèques permettant de gérer des opérations mathématiques ou d’émuler des instructions en virgule flottante par voie logicielle.

Par conséquent, certains types d’effets peuvent s’avérer plus lents que prévu sur certains appareils. Il est parfois possible de compenser cette perte de performances en procédant à des optimisations dans d’autres domaines ; par exemple, en utilisant OpenGL pour le rendu d’une scène. Cependant, de telles optimisations peuvent elles-mêmes entraîner une baisse des performances si elles reposent également sur la présence de matériel de calcul en virgule flottante.