Cadre de la vue graphique

Graphics View fournit une surface pour gérer et interagir avec un grand nombre d'éléments graphiques 2D personnalisés, ainsi qu'un widget de vue pour visualiser les éléments, avec prise en charge du zoom et de la rotation.

Le cadre comprend une architecture de propagation d'événements qui permet des capacités d'interaction à double précision pour les éléments de la scène. Les éléments peuvent gérer les événements liés aux touches, à l'appui sur la souris, au déplacement, au relâchement et au double clic, et ils peuvent également suivre les mouvements de la souris.

Graphics View utilise un arbre BSP (Binary Space Partitioning) pour assurer une découverte très rapide des éléments, ce qui lui permet de visualiser de grandes scènes en temps réel, même avec 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 fournit une approche basée sur les éléments pour la programmation de la vue-modèle, tout comme les classes de commodité d'InterView QTableView, QTreeView et QListView. Plusieurs vues peuvent observer une seule scène, et la scène contient des éléments de formes géométriques variées.

La scène

QGraphicsScene fournit la scène de la vue graphique. La scène a les responsabilités suivantes

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

La scène sert de conteneur pour les objets QGraphicsItem. Les éléments sont ajoutés à la scène en appelant QGraphicsScene::addItem(), puis récupérés en appelant l'une des nombreuses fonctions de découverte d'éléments. QGraphicsScene::items() et ses surcharges renvoient tous les éléments contenus dans un point, un rectangle, un polygone ou une trajectoire vectorielle générale, ou qui les croisent. QGraphicsScene::itemAt() renvoie l'élément le plus élevé en un point donné. Toutes les fonctions de découverte d'éléments renvoient les éléments dans l'ordre d'empilement décroissant (c'est-à-dire que le premier élément renvoyé est le plus haut et le dernier le plus bas).

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

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

QGraphicsSceneL'architecture de propagation d'événements d'EMC planifie les événements de la scène pour qu'ils soient transmis aux éléments et gère également la propagation entre les éléments. Si la scène reçoit un événement de pression de la souris à une certaine position, elle transmet l'événement à l'élément qui se trouve à cette position.

QGraphicsScene gère également certains états des éléments, tels que la sélection et le focus. Vous pouvez sélectionner des éléments sur la scène en appelant QGraphicsScene::setSelectionArea(), en passant une forme arbitraire. Cette fonctionnalité est également utilisée comme base pour la sélection par élastique dans QGraphicsView. Pour obtenir la liste de tous les éléments actuellement sélectionnés, appelez QGraphicsScene::selectedItems(). Un autre état géré par QGraphicsScene est le fait qu'un élément ait ou non le focus sur l'entrée clavier. Vous pouvez mettre l'accent sur un élément en appelant QGraphicsScene::setFocusItem() ou QGraphicsItem::setFocus(), ou obtenir l'élément d'attention actuel en appelant QGraphicsScene::focusItem().

Enfin, QGraphicsScene vous permet de rendre des parties de la scène dans un dispositif de peinture grâce à 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 visualise le contenu d'une scène. Vous pouvez attacher plusieurs vues à la même scène, afin de disposer de plusieurs fenêtres de visualisation dans le même ensemble de données. Le widget de vue est une zone de défilement et fournit des barres de défilement pour naviguer dans les grandes scènes. Pour activer le support OpenGL, vous pouvez définir une page QOpenGLWidget comme fenêtre de visualisation en appelant QGraphicsView::setViewport().

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

La vue reçoit des événements d'entrée 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 les é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 fonctions de navigation avancées telles que le zoom et la rotation. Pour plus de commodité, QGraphicsView fournit également des fonctions de conversion entre les coordonnées de la vue et celles de la scène : QGraphicsView::mapToScene() et QGraphicsView::mapFromScene().

La classe Item

QGraphicsItem est la classe de base pour les éléments graphiques d'une scène. Graphics View fournit plusieurs éléments standard pour les formes typiques, 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 disponibles lorsque vous écrivez un élément personnalisé. QGraphicsItem prend notamment en charge les fonctions suivantes :

• Événements d'appui, de déplacement, de relâchement et de double clic de la souris, ainsi que les événements de survol de la souris, les événements de la roue et les événements du menu contextuel.
• Mise au point de l'entrée clavier et événements liés aux touches
• Glisser-déposer
• Regroupement, à la fois par le biais des relations parent-enfant et avec les événements du menu contextuel. QGraphicsItemGroup
• Détection de collision

Les éléments vivent dans un système de coordonnées local et, comme QGraphicsView, il fournit également de nombreuses fonctions de mappage des coordonnées entre l'élément et la scène, et d'un élément à l'autre. De plus, comme QGraphicsView, il peut transformer son système de coordonnées à l'aide d'une matrice : QGraphicsItem::transform(). Cette fonction 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 les éléments enfants. Indépendamment de la transformation accumulée d'un élément, toutes ses fonctions (par exemple, QGraphicsItem::contains(), QGraphicsItem::boundingRect(), QGraphicsItem::collidesWith()) opèrent toujours en coordonnées locales.

QGraphicsItem prend en charge la détection des collisions par l'intermédiaire de la fonction QGraphicsItem::shape() et de QGraphicsItem::collidesWith(), qui sont toutes deux des fonctions virtuelles. En renvoyant la forme de votre élément sous forme de coordonnées locales QPainterPath à partir de QGraphicsItem::shape(), QGraphicsItem se chargera de la détection des collisions pour vous. Cependant, si vous souhaitez fournir votre propre détection de collision, vous pouvez réimplémenter QGraphicsItem::collidesWith().

Classes du cadre de travail des vues graphiques

Ces classes fournissent un cadre pour la création d'applications interactives.

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

Graphics View est basé 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 ensembles de deux nombres : la coordonnée x et la coordonnée y. Lorsque l'on observe une scène en utilisant une vue non transformée, une unité sur la scène est représentée par un pixel à l'écran.

Il existe trois systèmes de coordonnées effectifs en jeu dans Graphical Effects : Les coordonnées de l'élément, les coordonnées de la scène et les coordonnées de la vue. Pour simplifier votre mise en œuvre, Graphics View fournit des fonctions de commodité qui vous permettent de passer d'un système de coordonnées à l'autre.

Lors du rendu, les coordonnées de la scène de Graphics View correspondent aux coordonnées logiques de QPainter, et les coordonnées de la vue sont les mêmes que les coordonnées du périphérique. La documentation sur le système de coordonnées explique la relation entre les coordonnées logiques et les coordonnées du périphérique.

Coordonnées des éléments

Les éléments vivent dans leur propre système de coordonnées local. Leurs coordonnées sont généralement centrées autour de leur point central (0, 0), qui est également le centre de toutes les transformations. Les primitives géométriques dans le système de coordonnées de l'élément sont souvent appelées points de l'élément, lignes de l'élément ou rectangles de l'élément.

Lorsque vous créez un objet personnalisé, vous n'avez qu'à vous préoccuper des coordonnées de l'objet ; QGraphicsScene et QGraphicsView effectuent toutes les transformations pour vous. Il est donc très facile de mettre en œuvre des éléments personnalisés. Par exemple, si vous recevez une pression de la souris ou un événement d'entrée par glisser-déposer, la position de l'événement est donnée en coordonnées de l'élément. La fonction virtuelle QGraphicsItem::contains(), qui renvoie true si un certain point se trouve à l'intérieur de votre élément, et false dans le cas contraire, prend un argument de point dans les coordonnées de l'élément. De même, le rectangle de délimitation et la forme d'un élément sont exprimés en coordonnées de l'élément.

La position d' un élément est 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. Dans ce sens, la scène est considérée comme le "parent" de tous les éléments sans parent. La position des éléments de premier niveau est exprimée en coordonnées de la scène.

Les coordonnées de l'enfant sont relatives aux coordonnées du parent. Si l'enfant n'est pas transformé, la différence entre une coordonnée enfant et une coordonnée parent est la même que la distance entre les éléments en coordonnées parent. Par exemple : Si un élément enfant non transformé est positionné précisément au point central de son parent, les systèmes de coordonnées des deux éléments seront identiques. Si la position de l'enfant est (10, 0), le point (0, 10) de l'enfant correspondra au point (10, 10) de son parent.

Comme la position et la transformation des éléments sont relatives au parent, les coordonnées des éléments enfants ne sont pas affectées par la transformation du parent, bien que la transformation du parent transforme implicitement l'enfant. Dans l'exemple ci-dessus, même si le parent est tourné et mis à 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 de l'enfant sera à la coordonnée de scène (20, 0), et son point (10, 0) correspondra au point (40, 0) de la scène.

À l'exception de QGraphicsItem::pos(), les fonctions de QGraphicsItem opèrent en coordonnées d'élément, quelle que soit la transformation de l'élément ou de ses parents. Par exemple, le rectangle de délimitation d'un élément (i.e. QGraphicsItem::boundingRect()) est toujours donné en coordonnées de l'é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 constitue également la base de tous les événements de scène transmis à la scène par la vue. Chaque élément de la scène possède une position et un rectangle de délimitation (QGraphicsItem::scenePos(), QGraphicsItem::sceneBoundingRect()), en plus de sa position et de son rectangle de délimitation locaux. La position de la scène décrit la position de l'élément dans les coordonnées de la scène, et le rectangle de délimitation de la scène constitue la base permettant à QGraphicsScene de déterminer les zones de la scène qui ont été modifiées. Les modifications de la scène sont communiquées par le signal QGraphicsScene::changed(), et l'argument est une liste de rectangles de scène.

Coordonnées de la vue

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

Mappage des coordonnées

Lorsqu'il s'agit d'éléments dans une scène, il peut être utile de mapper des coordonnées et des formes arbitraires de la scène à un élément, d'un élément à un autre, ou de la vue à la scène. Par exemple, lorsque vous cliquez sur votre souris dans la fenêtre de QGraphicsView, vous pouvez demander à la scène quel élément se trouve sous le curseur en appelant QGraphicsView::mapToScene(), suivi de QGraphicsScene::itemAt(). Si vous voulez savoir où se trouve un élément dans la fenêtre de visualisation, vous pouvez appeler QGraphicsItem::mapToScene() sur l'élément, puis QGraphicsView::mapFromScene() sur la vue. Enfin, si vous voulez savoir quels éléments se trouvent à l'intérieur d'une ellipse de vue, vous pouvez passer un QPainterPath à mapToScene(), puis passer le chemin cartographié à QGraphicsScene::items().

Vous pouvez mapper des coordonnées et des formes depuis et vers la scène d'un élément en appelant QGraphicsItem::mapToScene() et QGraphicsItem::mapFromScene(). Vous pouvez également établir une correspondance avec 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 des points, des rectangles, des polygones et des chemins.

Les mêmes fonctions de mappage sont disponibles dans la vue, pour le mappage depuis et vers la scène. QGraphicsView::mapFromScene() et QGraphicsView::mapToScene(). Pour établir une correspondance entre une vue et un élément, il faut d'abord établir une correspondance avec la scène, puis établir une correspondance entre la scène et l'élément.

Caractéristiques principales

Zoom et rotation

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

Voici un exemple de mise en œuvre de fentes 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 pourraient être connectés à QToolButtons avec autoRepeat activé.

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

Voir également l'exemple des nœuds élastiques pour le code qui montre comment mettre en œuvre les fonctions de zoom de base.

Impression

La vue graphique permet d'imprimer sur une seule ligne grâce à ses fonctions de rendu, QGraphicsScene::render() et QGraphicsView::render(). Les fonctions fournissent la même API : Vous pouvez demander à la scène ou à la vue de rendre tout ou partie de leur contenu dans n'importe quel dispositif de peinture en passant une adresse QPainter à l'une ou l'autre des fonctions de rendu. Cet exemple montre comment imprimer toute la scène sur une page entière, en utilisant 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 de scène et de vue est que l'une opère en coordonnées de scène, et l'autre en coordonnées de vue. QGraphicsScene::render() est souvent préféré pour imprimer des segments entiers d'une scène sans transformation, par exemple pour tracer des données géométriques ou pour imprimer un document texte. QGraphicsView::render(), quant à lui, est adapté à la réalisation de captures d'écran ; son comportement par défaut est de rendre le contenu exact de la fenêtre de visualisation à 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 de la source est étiré pour s'adapter à la zone cible. En passant une adresse Qt::AspectRatioMode à la fonction de rendu que vous utilisez, vous pouvez choisir de conserver ou d'ignorer le rapport hauteur/largeur de la scène lorsque le contenu est étiré.

Glisser-déposer

Comme QGraphicsView hérite indirectement de QWidget, il fournit déjà la même fonctionnalité de glisser-déposer que QWidget. En outre, par commodité, le cadre de la vue graphique fournit un support de glisser-déposer pour la scène et pour chaque élément. Lorsque la vue reçoit un glissement, elle traduit les événements de glissement et de dépôt en une adresse QGraphicsSceneDragDropEvent, qui est ensuite transmise à la scène. La scène prend en charge la programmation de cet événement et l'envoie au premier élément sous le curseur de la souris qui accepte les glissements.

Pour démarrer un déplacement à partir d'un élément, créez un objet QDrag, en transmettant un pointeur au widget qui démarre le déplacement. Les éléments peuvent être observés par plusieurs vues en même temps, mais une seule vue peut démarrer le déplacement. Dans la plupart des cas, les déplacements sont lancés à la suite d'une pression ou d'un déplacement de la souris. Ainsi, dans mousePressEvent() ou mouseMoveEvent(), vous pouvez obtenir 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 réimplémentez QGraphicsScene::dragEnterEvent() et les gestionnaires d'événements dont votre scène particulière a besoin, dans une sous-classe de QGraphicsItem. Pour en savoir plus sur le glisser-déposer dans la vue graphique, consultez 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().

Voir également l'exemple du robot drag and drop pour une démonstration de la prise en charge des opérations de drag and drop par Graphics View.

Curseurs et infobulles

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 du robot de glisser-déposer pour le code qui met en œuvre les info-bulles et la gestion de la forme du curseur.

Animation

La vue graphique prend en charge l'animation à plusieurs niveaux. Vous pouvez facilement assembler des animations en utilisant le cadre d'animation. Pour cela, vos éléments doivent hériter de QGraphicsObject et leur associer QPropertyAnimation. QPropertyAnimation permet d'animer n'importe quelle propriété de QObject.

Une autre option consiste à créer un élément personnalisé qui hérite de QObject et QGraphicsItem. L'élément peut alors définir ses propres minuteries et contrôler les animations par des étapes incrémentielles dans 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 appelle à son tour QGraphicsItem::advance().

Rendu OpenGL

Pour activer le rendu OpenGL, il suffit de définir un nouveau QOpenGLWidget comme fenêtre de visualisation de QGraphicsView en appelant QGraphicsView::setViewport(). Si vous voulez un rendu OpenGL avec anti-crénelage, vous devez définir un QSurfaceFormat avec le nombre d'échantillons nécessaire (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 obtenir la caractéristique la plus essentielle du regroupement d'éléments : les éléments se déplacent ensemble et toutes les transformations sont propagées du parent à l'enfant.

En outre, QGraphicsItemGroup est un élément spécial qui combine la gestion des événements enfant avec une interface utile pour l'ajout et la suppression d'éléments dans un groupe. L'ajout d'un élément à un site QGraphicsItemGroup conserve la position et la transformation d'origine de l'élément, tandis que la répartition des éléments en général entraîne le repositionnement de l'enfant par rapport à son nouveau parent. Pour plus de commodité, vous pouvez créer des QGraphicsItemGroupà travers la scène en appelant QGraphicsScene::createItemGroup().

Widgets et dispositions

Qt 4.4 a introduit la prise en charge des éléments sensibles à la géométrie et à la disposition par le biais de QGraphicsWidget. Cet élément de base spécial est similaire à QWidget, mais contrairement à QWidget, il n'hérite pas de QPaintDevice, mais plutôt de QGraphicsItem. Cela vous permet d'écrire des widgets complets avec des événements, des signaux et des emplacements, des indices de taille et des politiques, et vous pouvez également gérer les géométries de vos widgets dans des dispositions grâce à QGraphicsLinearLayout et QGraphicsGridLayout.

QGraphicsWidget

S'appuyant sur les capacités et l'encombrement réduit de QGraphicsItem, QGraphicsWidget offre le meilleur des deux mondes : des fonctionnalités supplémentaires de QWidget, telles que le style, la police, la palette, la direction de la disposition et sa géométrie, ainsi que l'indépendance de résolution et la prise en charge des transformations de QGraphicsItem. Étant donné que Graphics View utilise des coordonnées réelles au lieu d'entiers, les fonctions de géométrie de QGraphicsWidget fonctionnent également sur QRectF et QPointF. Cela s'applique également aux cadres, aux marges et à l'espacement. 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-groupes et des fenêtres de "niveau supérieur" ; dans certains cas, vous pouvez désormais utiliser la vue graphique pour des applications MDI avancées.

Certaines des propriétés de QWidget sont prises en charge, notamment les drapeaux et les attributs de fenêtre, mais pas toutes. Nous vous conseillons de consulter la documentation de la classe QGraphicsWidget pour avoir une vue d'ensemble 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 le drapeau de fenêtre Qt::Window au constructeur de QGraphicsWidget, mais Graphics View ne prend actuellement pas en charge les drapeaux Qt::Sheet et Qt::Drawer qui sont courants sur macOS.

QGraphicsLayout

QGraphicsLayout fait partie d'un cadre de présentation 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 les widgets et les sous-calques à l'intérieur de QGraphicsLinearLayout et QGraphicsGridLayout. Vous pouvez également écrire facilement votre propre calque en sous-classant QGraphicsLayout vous-même, ou ajouter vos propres éléments QGraphicsItem au calque en écrivant un adaptateur sous-classe 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 dans 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 en mesure d'intégrer en profondeur les fonctionnalités du widget client, y compris ses curseurs, infobulles, événements de souris, de tablette et de clavier, widgets enfants, animations, fenêtres contextuelles (par exemple, QComboBox ou QCompleter), ainsi que le focus et l'activation de l'entrée du widget. QGraphicsProxyWidget intègre même l'ordre de tabulation du widget incorporé afin que vous puissiez entrer et sortir des widgets incorporés par la tabulation. 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 incorporé, Graphics View s'assure que le widget est transformé indépendamment de la résolution, ce qui permet aux polices et au style de rester nets en cas de zoom. (Notez que l'effet de l'indépendance 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, Graphical Effects 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 nombreux postes de travail et ordinateurs de bureau sont équipés du matériel adéquat pour accélérer ce type de calcul, mais certains appareils intégrés ne disposent que de bibliothèques pour traiter les opérations mathématiques ou émuler les instructions en virgule flottante dans le logiciel.

Par conséquent, certains types d'effets peuvent être plus lents que prévu sur certains appareils. Il peut être possible de compenser ce manque de performance en effectuant des optimisations dans d'autres domaines, par exemple en utilisant OpenGL pour le rendu d'une scène. Toutefois, ces optimisations peuvent elles-mêmes entraîner une réduction des performances si elles reposent également sur la présence de matériel à virgule flottante.