Developpez.com - Qt
X

Choisissez d'abord la catégorieensuite la rubrique :

Viadeo Twitter Facebook Share on Google+   
Logo Documentation Qt ·  Page d'accueil  ·  Toutes les classes  ·  Toutes les fonctions  ·  Vues d'ensemble  · 

La vue graphique : Graphics View

La vue graphique (Graphics View) fournit une surface permettant de gérer et d'interagir avec un grand nombre d'éléments graphiques 2D personnalisés, ainsi qu'un widget d'affichage (intégrant zoom et rotation), pour visualiser ces éléments.

  

Le framework inclut une architecture de propagation d'événements qui autorise des interactions précises (calculs en double précision) avec les éléments de la scène. Les éléments peuvent traiter les événements clavier, souris (clics, mouvements) et peuvent suivre les mouvements de la souris.

Graphics View utilise un arbre BSP (Binary Space Partitioning) pour trouver très rapidement les éléments et, en conséquence, peut afficher de très grandes scènes en temps réel, même avec des millions d'éléments.

Graphics View a été introduite avec Qt 4.2, remplaçant son prédécesseur, QCanvas. Si vous effectuez un portage depuis QCanvas, voir Porting to Graphics View.

L'architecture de Graphics View

Graphics View fournit une approche basée sur les éléments de la programmation modèle-vue, similaire à ce que font les classes QTableView, QTreeView et QListView dans InterView. Plusieurs vues peuvent observer la même scène et la scène contient des éléments de formes géométriques variées.

La scène

QGraphicsScene est 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 les événements à chaque objet ;
  • gérer les états des éléments, comme la sélection et le focus ;
  • fournir une fonction de rendu non transformé, principalement pour l'impression.

La scène est un contenant pour les éléments de type QGraphicsItem. Ces éléments sont ajoutés à la scène par l'appel de QGraphicsScene::addItem() et ensuite retrouvés par une des nombreuses fonctions de recherche d'éléments. QGraphicsScene::items() et ses surcharges renvoient tous les éléments contenus par (ou ayant une intersection avec) un point, un rectangle, un polygone ou un chemin vectoriel quelconque. QGraphicsScene::itemAt() renvoie l'élément du dessus en un point particulier. Toutes les fonctions de recherche d'éléments renvoient les éléments dans l'ordre d'empilement descendant (c'est-à-dire que le premier renvoyé est au-dessus, le dernier en dessous).

 QGraphicsScene scene;
 QGraphicsRectItem *rect = scene.addRect(QRectF(0, 0, 100, 100));
 
 QGraphicsItem *item = scene.itemAt(50, 50);
 // item == rect

L'architecture de propagation d'événements de QGraphicsScene gère la transmission des événements de la scène aux éléments et propage également les événements entre éléments. Si la scène reçoit un événement de clic de souris à une position donnée, la scène envoie l'événement à l'objet situé à cette position.

QGraphicsScene gère aussi certains états d'éléments comme la sélection et le focus. Vous pouvez sélectionner des éléments de la scène en appelant QGraphicsScene::setSelectionArea(), en passant une forme arbitraire. Cette fonction est aussi utilisée pour la sélection rectangulaire dans QGraphicsView. Pour obtenir la liste de tous les éléments actuellement sélectionnés, appelez QGraphicsScene::selectedItems(). Un autre état traité par QGraphicsScene est le suivi de l'élément ayant le focus pour l'entrée au clavier. Vous pouvez donner le focus à un élément par QGraphicsScene::setFocusItem() ou utiliser QGraphicsItem::setFocus() pour connaître l'élément ayant le focus par QGraphicsScene::focusItem().

Enfin, QGraphicsScene vous permet un rendu de parties de la scène dans un QPainter par la fonction QGraphicsScene::render(). Vous pourrez en lire davantage sur ce sujet dans la section Impression plus loin dans ce document.

La vue graphique

QGraphicsView est le widget vue, qui affiche le contenu d'une scène. Vous pouvez attacher plusieurs vues à la même scène, pour fournir plusieurs affichages du même jeu de données. Le widget vue est une zone de défilement (scroll) et fournit des barres de défilement pour naviguer dans de grandes scènes. Pour activer le support OpenGL, vous pouvez choisir un visualiseur QGLWidget en appelant QGraphicsView::setViewport().

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

La vue reçoit des événements d'entrée depuis le clavier et la souris et les traduit en événements de la scène (en convertissant les coordonnées en coordonnées de la scène si nécessaire), avant d'envoyer les événements à la scène visualisée.

En utilisant sa matrice de transformation, QGraphicsView::transform(), la vue peut transformer le système de coordonnées de la scène. Ceci permet des fonctions de navigation avancées comme le zoom et la rotation. Par commodité, QGraphicsView fournit aussi des fonctions pour la conversion entre coordonnées de la vue et de la scène : QGraphicsView::mapToScene() et QGraphicsView::mapFromScene().

image

L'élément graphique

QGraphicsItem est la classe de base pour tous les éléments graphiques dans une scène. La vue graphique fournit plusieurs éléments standards pour des formes typiques, comme des rectangles (QGraphicsRectItem), ellipses (QGraphicsEllipseItem) et textes mais en créant des QGraphicsItem personnalisés on accède aux fonctions les plus puissantes. Parmi d'autres, QGraphicsItem fournit les fonctions suivantes :

  • événements souris : mouvements, clic, double clic, appui et relâchement de boutons, survol, molette et menu contextuel ;
  • clavier : focus et événements des touches ;
  • glisser-déposer ;
  • groupement, à la fois par la relation parent-enfant et QGraphicsItemGroup ;
  • détection de collision.

Un QGraphicsItem réside dans un système de coordonnées local et, comme QGraphicsView, il fournit des fonctions pour convertir des coordonnées entre l'élément et la scène et d'élément à élément. Comme QGraphicsView, il peut transformer son système de coordonnées avec une matrice QGraphicsItem::transform(), ce qui est utile pour des rotations et changements d'échelle d'éléments individuels.

Les éléments peuvent contenir des éléments enfants. Les transformations de l'élément parent sont héritées par les enfants. Cependant, indépendamment des transformations successives d'un élément, toutes ses fonctions (comme QGraphicsItem::contains(), QGraphicsItem::boundingRect() ou QGraphicsItem::collidesWith()) opèrent toujours en coordonnées locales.

QGraphicsItem gère la détection de collision en utilisant la fonction QGraphicsItem::shape() et QGraphicsItem::collidesWith(), qui sont toutes deux des fonctions virtuelles. En renvoyant la forme de votre élément sous forme de QPainterPath en coordonnées locales depuis QGraphicsItem::shape(), QGraphicsItem se chargera pour vous de la détection de collision. Si vous voulez gérer vous-même la détection de collision, vous pouvez réimplémenter QGraphicsItem::collidesWith().

image

Les classes de la vue graphique

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

QAbstractGraphicsShapeItem Base commune pour toutes les formes
QGraphicsAnchor Représente une ancre entre deux éléments dans un QGraphicsAnchorLayout
QGraphicsAnchorLayout Layout qui permet d'ancrer ensemble des widgets dans une vue graphique
QGraphicsEffect La classe de base pour les effets graphiques
QGraphicsEllipseItem Ellipse ajoutable à une QGraphicsScene
QGraphicsGridLayout Layout grille pour des widgets dans une vue graphique
QGraphicsItem La classe de base pour tous les éléments graphiques d'une QGraphicsScene
QGraphicsItemAnimation Gestion simple d'une animation d'un QGraphicsItem
QGraphicsItemGroup Contenant traitant un groupe d'éléments comme un seul élément
QGraphicsLayout La classe de base pour tous les layouts d'une vue graphique
QGraphicsLayoutItem Peut être hérité pour autoriser l'intégration d'éléments personnalisés dans un layout
QGraphicsLineItem Ligne ajoutable à une QGraphicsScene
QGraphicsLinearLayout Layout horizontal ou vertical pour des widgets d'une vue graphique
QGraphicsObject Classe de base pour tous les éléments graphiques nécessitant signaux, slots et propriétés
QGraphicsPathItem Chemin ajoutable à une QGraphicsScene
QGraphicsPixmapItem Pixmap ajoutable à une QGraphicsScene
QGraphicsPolygonItem Polygone ajoutable à une QGraphicsScene
QGraphicsProxyWidget Proxy pour l'intégration d'un QWidget dans une QGraphicsScene
QGraphicsRectItem Rectangle ajoutable à une QGraphicsScene
QGraphicsScene Surface pour la gestion d'un grand nombre d'objets graphiques 2D
QGraphicsSceneContextMenuEvent Événements de menu contextuel dans le framework Graphics View
QGraphicsSceneDragDropEvent Événements de glisser-déposer dans le framework Graphics View
QGraphicsSceneEvent Classe de base pour tous les événements liés à la vue graphique
QGraphicsSceneHelpEvent Événements sur demande d'infobulle (tooltip)
QGraphicsSceneHoverEvent Événements survol dans le framework Graphics View
QGraphicsSceneMouseEvent Événements souris dans le framework Graphics View
QGraphicsSceneMoveEvent Événements pour les mouvements de widgets dans le framework Graphics View
QGraphicsSceneResizeEvent Événements pour les redimensionnements de widgets dans le framework Graphics View
QGraphicsSceneWheelEvent Événements molette dans le framework Graphics View
QGraphicsSimpleTextItem Chemin de texte simple ajoutable à une QGraphicsScene
QGraphicsSvgItem QGraphicsItem pour l'affichage du contenu de fichiers SVG
QGraphicsTextItem Texte formaté ajoutable à une QGraphicsScene
QGraphicsTransform Classe de base abstraite pour construire des transformations avancées sur des QGraphicsItems
QGraphicsView Widget affichant le contenu d'une QGraphicsScene
QGraphicsWidget La classe de base pour tous les widgets QGraphicsScene
QStyleOptionGraphicsItem Utilisé pour décrire les paramètres requis pour dessiner un QGraphicsItem

Le système de coordonnées

Graphics View est basée sur le système de coordonnées cartésien : la position et la géométrie des éléments de la scène sont représentés par des couples de coordonnées x et y. Lorsqu'on observe une scène dans une vue non transformée, une unité de la scène est représentée par un pixel de l'écran.

Note : le système avec l'axe Y inversé (où y augmente vers le haut) n'est pas géré étant donné que les vues graphiques utilisent le système de coordonnées de Qt.

Trois systèmes de coordonnées coexistent dans Graphics View : les coordonnées élément, scène et vue. Pour simplifier votre travail, Graphics View fournit des fonctions utilitaires qui vous permettent diverses conversions entre les trois systèmes de coordonnées.

Pendant le rendu, les coordonnées scène correspondent au coordonnées logiques de QPainter et les coordonnées vue correspondent aux coordonnées du dispositif de rendu (appelées coordonnées physiques ou device). La description de la relation entre coordonnées logiques et physiques se trouve dans la documentation du système de coordonnées.

image

Les éléments vivent dans leur propre système de coordonnées local. L'origine des coordonnées est généralement leur point central

(0, 0)

, qui est aussi l'axe des transformations. Les primitives géométriques dans le système de coordonnées local sont souvent appelées points, lignes ou rectangles de l'élément.

À la création d'un élément personnalisé, vous ne vous préoccupez que des coordonnées locales, QGraphicsScene et QGraphicsView effectueront toutes les transformations pour vous. Cela rend l'implémentation d'éléments personnalisés très simple. Par exemple, si vous recevez un événement clic ou glissement de souris, la position de l'événement est fournie en coordonnées locales. La fonction virtuelle QGraphicsItem::contains(), qui renvoie vrai si un point donné est à l'intérieur de votre élément et faux sinon, prend un argument point en coordonnées locales. De la même façon, le rectangle (ou la forme) frontière sont en coordonnées locales.

La position d'un élément correspond aux coordonnées de son centre dans le système de coordonnées de son parent ; elle est parfois appelée coordonnées parent. Dans ce sens la scène est considérée comme le « parent » de tous les objets sans parent : la position des objets de premier niveau est en coordonnées de scène.

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

Étant donné que la position et les transformations d'un élément sont relatives à son parent, les coordonnées locales de l'enfant ne sont pas affectées par les transformations du parent, bien que les transformations du parent transforment implicitement l'enfant. Dans l'exemple précédent, même si le parent est agrandi ou tourné, le point (0,10) de l'enfant correspondra toujours au point (10 ,10) du parent. Cependant, relativement à la scène, l'enfant va suivre les transformations du parent : si le parent est agrandi d'un facteur 2, la position de l'enfant sera (20, 0) en coordonnées de scène et son point (10, 0) correspondra au point (40, 0) de la scène.

Avec QGraphicsItem::pos(), l'une des seules exceptions, les fonctions de QGraphicsItem opèrent en coordonnées locales, indépendamment des transformations de l'élément ou de ses parents. Par exemple, le rectangle frontière d'un élément (soit QGraphicsItem::boundingRect()) est toujours donné en coordonnées locales de l'élément.

Les coordonnées de 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 tous les éléments de premier niveau et forme également la base pour tous les événements de scène envoyés à la scène par la vue. Chaque élément de la scène a une position dans la scène (QGraphicsItem::scenePos(), QGraphicsItem::sceneBoundingRect()), en plus de sa position et sa frontière locales. La position de scène décrit la position d'un élément en coordonnées de scène et son rectangle frontière forme la base à partir de laquelle QGraphicsScene détermine quelles parties de la scène ont changé. Les changements de la scène sont communiqués par le signal QGraphicsScene::changed(), dont les arguments sont une suite de rectangles dans la scène.

Coordonnées de vue

Les coordonnées de vue sont les coordonnées du widget, avec comme unité le pixel. La particularité de ce système de coordonnées est qu'il est relatif au widget ou à la zone d'affichage et non affecté par la scène observée. Le coin supérieur gauche de la zone d'affichage du QGraphicsView est toujours (0, 0) et le coin inférieur droit est toujours (largeur de la zone, hauteur de la zone). Tous les événements souris et glisser-déposer sont originellement reçus en coordonnées de vue et vous devez les convertir en coordonnées de scène pour interagir avec les éléments de la scène.

Conversion de coordonnées

Souvent, lors de la manipulation d'éléments d'une scène, il peut être utile de convertir des coordonnées ou des formes arbitraires de la scène vers un élément ou inversement ou entre éléments. Par exemple, quand vous cliquez dans la zone d'affichage d'une 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ù un élément se trouve dans la zone d'affichage, vous pouvez appeler QGraphicsItem::mapToScene() sur l'élément, puis QGraphicsView::mapFromScene() sur la vue. Autre exemple, si vous voulez savoir quels éléments se trouvent dans une ellipse de la vue, vous pouvez passer un QPainterPath à mapToScene() et ensuite passer le chemin converti à QGraphicsScene::items().

Vous pouvez convertir des coordonnées et des formes vers et depuis la scène d'un élément en appelant QGraphicsItem::mapToScene() et QGraphicsItem::mapFromScene(). Vous pouvez aussi convertir vers/depuis le parent en appelant QGraphicsItem::mapToParent() et QGraphicsItem::mapFromParent() ou entre éléments en appelant QGraphicsItem::mapToItem() et QGraphicsItem::mapFromItem(). Toutes les fonctions de conversion peuvent convertir points, rectangles, polygones et chemins.

Les mêmes fonctions de conversion sont disponibles dans la vue, pour convertir vers/depuis la scène. Il s'agit de QGraphicsView::mapFromScene() et QGraphicsView::mapToScene(). Pour convertir depuis une vue vers un élément, vous devez convertir vers la scène, puis de la scène vers l'élément.

Fonctions principales

Zoom et rotation

QGraphicsView permet les mêmes transformations affines que QPainter à travers QGraphicsView::setMatrix(). En appliquant une transformation à une vue, vous pouvez facilement ajouter des fonctions de navigation courantes comme le zoom et la rotation.

Voici un exemple d'implémentation de 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 pourraient être connectés à des QToolButtons avec autoRepeat activé.

QGraphicsView conserve la position du centre de la vue quand vous la transformez.

Voir aussi les exemples Elastic Nodes pour du code montrant l'implémentation de fonctions de zoom.

Impression

La vue graphique permet d'imprimer avec une seule ligne de code à travers ses fonctions de rendu, QGraphicsScene::render() et QGraphicsView::render(). Les fonctions fournissent la même API : la scène ou la vue peuvent rendre tout ou partie de leur contenu sur n'importe quelle surface de dessin en passant un QPainter à l'une des fonctions de rendu. Cet exemple montre comment imprimer la scène entière dans une pleine page, utilisant QPrinter.

 QGraphicsScene scene;
 scene.addRect(QRectF(0, 0, 100, 200), QPen(Qt::black), QBrush(Qt::green));
 
 QPrinter printer;
 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, l'autre en coordonnées de vue. QGraphicsScene::render() est souvent préférée pour imprimer des segments entiers non transformés, comme pour le tracé de données géométriques, ou pour imprimer un document texte. QGraphicsView::render(), de son côté, est adapté pour la copie d'écran ; son comportement par défaut est de rendre le contenu exact de la zone d'affichage en utilisant le QPainter 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 destination ne correspondent pas, le contenu de la source est étiré pour remplir la zone destination. En passant un Qt::AspectRatioMode à la fonction de rendu que vous utilisez, vous pouvez choisir de conserver ou d'ignorer les proportions de la scène quand le contenu est étiré.

Glisser-déposer

Comme QGraphicsView dérive indirectement de QWidget, elle fournit déjà les mêmes fonctions de glisser-déposer que QWidget. De plus, par commodité, le framework Graphics View fournit une gestion de glisser-déposer pour la scène et pour chacun de ses éléments. Quand la vue reçoit un début de glissement, elle traduit les événements de glisser-déposer en QGraphicsSceneDragDropEvent, qui sont transmis à la scène. La scène prend le relai de la gestion de cet événement et l'envoie au premier élément sous le curseur acceptant les déposes.

Pour commencer le glissement d'un élément, créez un objet QDrag en lui passant un pointeur sur le widget à glisser. Les éléments peuvent être observés par plusieurs vues simultanément mais une seule peut initier le glissement. Les glissements sont en général initiés par un clic ou un mouvement de souris et, dans ce cas, vous pouvez obtenir le widget source dans mousePressEvent() ou mouseMoveEvent(). Par exemple :

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

Pour intercepter les événements de glisser-déposer pour une scène, réimplémentez QGraphicsScene::dragEnterEvent() et les gestionnaires d'événements dont votre scène a besoin dans une sous-classe de QGraphicsItem. Vous pourrez en lire davantage sur les glisser-déposer dans la documentation de chaque gestionnaire d'évènements de QGraphicsScene.

Les éléments peuvent aussi activer la gestion du glisser-déposer en appelant QGraphicsItem::setAcceptDrops(). Pour traiter les demandes de glissement, réimplémentez QGraphicsItem::dragEnterEvent(), QGraphicsItem::dragMoveEvent(), QGraphicsItem::dragLeaveEvent() et QGraphicsItem::dropEvent().

Voir aussi l'exemple Drag and Drop Robot pour une démonstration des opérations de glisser-déposer.

Pointeurs de souris et infobulles

Comme QWidget, QGraphicsItem gère les pointeurs de souris (QGraphicsItem::setCursor()) et les infobulles (QGraphicsItem::setToolTip()). Pointeurs et infobulles sont activés par QGraphicsView quand le pointeur de la souris entre dans le périmètre de l'élément (détecté par QGraphicsItem::contains()).

Vous pouvez aussi définir un pointeur par défaut pour la vue en appelant QGraphicsView::setCursor().

Voir aussi Drag and Drop Robot pour un exemple de code implémentant infobulles et gestion de forme de pointeur.

Animations

La vue graphique gère les animations à différents niveaux. Vous pouvez facilement assembler des animations en utilisant le framework Animation. Pour cela vos éléments doivent hériter de QGraphicsObject et s'associer avec QPropertyAnimation. QPropertyAnimation permet d'animer toutes les propriétés d'un QObject.

Une autre option est de créer un objet personnalisé héritant de QObject et QGraphicsItem. L'objet peut alors créer ses propres timers et contrôler des animations avec des étapes incrémentales dans QObject::timerEvent().

Une troisième option, principalement disponible pour la compatibilité avec QCanvas de Qt 3, est d?avancer la scène en appelant QGraphicsScene::advance(), qui, à son tour, appelle QGraphicsItem::advance().

Rendu OpenGL

Pour activer le rendu OpenGL, définissez simplement un QGLWidget comme afficheur de QGraphicsView en appelant QGraphicsView::setViewport(). Si vous voulez un OpenGL avec antialiasing, il vous faut activer la gestion multi-échantillons d'OpenGL (voir QGLFormat::sampleBuffers()).

Exemple :

 QGraphicsView view(&scene);
 view.setViewport(new QGLWidget(QGLFormat(QGL::SampleBuffers)));

Groupes d'éléments

En rendant un élément l'enfant d'un autre élément, vous pouvez obtenir la fonction essentielle du groupement d'éléments : les éléments vont se déplacer ensemble et toutes les transformations sont propagées de parent à enfant.

De plus, QGraphicsItemGroup est un élément spécial qui combine la gestion d'événements des enfants avec une interface utile pour ajouter des éléments à un groupe ou en retirer. L'ajout d'un élément à un QGraphicsItemGroup conserve la position et les transformations de l'élément, alors que le changement de parent provoque en général un repositionnement de l'enfant relativement à son nouveau parent. Il est commode de créer des QGraphicsItemGroup à partir de la scène en appelant QGraphicsScene::createItemGroup().

Widgets et Layouts

Qt 4.4 a introduit la gestion de la géométrie et de la disposition (layout) des éléments avec QGraphicsWidget. Cet élément de base spécial est similaire à QWidget mais, contrairement à QWidget, il ne dérive pas de QPaintDevice mais de QGraphicsItem. Ceci permet d'écrire des widgets complets, avec événements, signaux et slots, indications de taille et permet également de gérer la géométrie de vos widgets dans des layouts à travers QGraphicsLinearLayout et QGraphicsGridLayout.

QGraphicsWidget

Profitant des capacités et de la faible consommation en ressources de QGraphicsItem, QGraphicsWidget fournit le meilleur des deux mondes : des fonctions supplémentaires de QWidget, comme le style, la police, la palette, le layout et la géométrie ainsi que la gestion des transformations de QGraphicsItem. Comme la vue graphique utilise des coordonnées flottantes au lieu d'entiers, les fonctions géométriques de QGraphicsWidget opèrent également sur QRectF et QPointF. Ceci s'applique aussi aux bordures, marges et espacements. Avec QGraphicsWidget, il n'est pas rare de spécifier des marges 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 utiliser la vue graphique pour des applications multi-documents (MDI) avancées.

Certaines propriétés de QWidget sont gérées, dont les drapeaux et attributs de fenêtre, mais pas toutes. Référez-vous à la documentation de la classe QGraphicsWidget pour une vue d'ensemble de ce qui est ou n'est pas géré. 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 la vue graphique ne connaît pas les drapeaux Qt::Sheet et Qt::Drawer qui sont courants sur Mac OS X.

Les capacités de QGraphicsWidget devraient augmenter en fonction des retours de la communauté.

QGraphicsLayout

QGraphicsLayout fait partie d'un framework de layout de deuxième génération conçu spécialement pour QGraphicsWidget. Son API ressemble beaucoup à celle de QLayout. Vous pouvez gérer des widgets et des sous-layouts dans QGraphicsLinearLayout ou dans QGraphicsGridLayout. Vous pouvez également écrire votre propre layout facilement en dérivant QGraphicsLayout ou ajouter vos propres QGraphicsItem au layout en écrivant une classe dérivée de QGraphicsLayoutItem.

Inclusion de widgets

La vue graphique permet l'inclusion transparente de widgets quelconques dans la scène. Vous pouvez inclure des widgets simples comme QLineEdit ou QPushButton, des widgets complexes comme QTabWidget et même des fenêtres principales complètes. Pour intégrer vos widgets dans la scène, appelez simplement QGraphicsScene::addWidget() ou créez une instance de QGraphicsProxyWidget pour ajouter vos widgets manuellement.

Avec QGraphicsProxyWidget, la vue graphique est capable d'intégrer complètement les fonctions du widget client, y compris ses pointeurs, infobulles, événements souris, clavier et tablette, widgets enfants, animations, pop-ups (par exemple QComboBox ou QCompleter), l'activation et le focus de saisie. QGraphicsProxyWidget intègre aussi l'ordre de tabulation du widget inclus afin que vous puissiez tabuler vers et depuis ce widget. Vous pouvez même inclure une nouvelle QGraphicsView dans votre scène pour créer des scènes imbriquées complexes.

Lorsqu'elle transforme un widget inclus, la vue graphique s'assure de ce que le widget est transformé indépendamment de la résolution, ce qui permet aux polices et aux styles de rester nets en cas d'agrandissement (notez que l'effet de l'indépendance vis-à-vis de la résolution dépend du style).

Performance

Instructions en virgule flottante

Pour pouvoir précisément et rapidement appliquer des transformations et des effets aux éléments, la vue graphique suppose 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 de composants adéquats pour accélérer ce type de calcul mais certains appareils embarqués peuvent ne disposer que d'une émulation logicielle des opérations mathématiques ou des instructions en virgule flottante.

En conséquence, certains effets peuvent être plus lents qu'attendu sur certains appareils. Il peut être possible de compenser cette baisse de performances en réalisant des optimisations dans d'autres domaines ; par exemple, en utilisant OpenGL pour rendre une scène. Cependant, de telles optimisations peuvent elles-mêmes réduire les performances si elles comptent sur la présence de composants calculant en virgule flottante.

Remerciements

Merci à <!idiallo!> pour la traduction et à <!dourouc!> ainsi qu'à <!jacques_jean!> pour leur relecture !

Cette page est une traduction d'une page de la documentation de Qt, écrite par Nokia Corporation and/or its subsidiary(-ies). Les éventuels problèmes résultant d'une mauvaise traduction ne sont pas imputables à Nokia. Qt 4.7
Copyright © 2018 Developpez LLC. Tous droits réservés Developpez LLC. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents et images sans l'autorisation expresse de Developpez LLC. Sinon, vous encourez selon la loi jusqu'à 3 ans de prison et jusqu'à 300 000 E de dommages et intérêts. Cette page est déposée à la SACD.
Vous avez déniché une erreur, une redirection cassée ou tout autre problème, quel qu'il soit ? Ou bien vous désirez participer à ce projet de traduction ? N'hésitez pas à nous contacter ou par MP !
Responsable bénévole de la rubrique Qt : Thibaut Cuvelier -