Notice: Undefined offset: 1 in /home/developpez/www/developpez-com/upload/qt/doc/redir.php on line 39 QGraphicsView
Viadeo Twitter Google Bookmarks ! Facebook Digg del.icio.us MySpace Yahoo MyWeb Blinklist Netvouz Reddit Simpy StumbleUpon Bookmarks Windows Live Favorites 
Logo Documentation Qt ·  Page d'accueil  ·  Toutes les classes  ·  Toutes les fonctions  ·  Vues d'ensemble  · 

QGraphicsView

La classe QGraphicsView fournit un widget pour l'affichage du contenu d'une QGraphicsScene. Plus d'informations...

#include <QGraphicsView>

Voir la position dans l'arbre des classes.

Héritage

Hérite de QAbstractScrollArea.

Hérité par QDeclarativeView.

Cette classe a été introduite dans Qt 4.2.

Description détaillée

La classe QGraphicsView fournit un widget pour l'affichage du contenu d'une QGraphicsScene.

QGraphicsView visualise le contenu d'une QGraphicsScene dans une zone d'affichage, avec gestion du défilement. Pour créer une scène contenant des éléments géométriques, voir la documentation de QGraphicsScene. QGraphicsView fait partie du Framework Graphics View.

Pour visualiser une scène, commencez par construire un objet QGraphicsView, en passant l'adresse de la scène à visualiser au constructeur de QGraphicsView. Vous pouvez aussi appeler setScene() pour spécifier la scène plus tard. Après l'appel de show(), la vue va par défaut se déplacer jusqu'au centre de la scène et afficher tous les éléments visibles à ce stade. Par exemple:

 QGraphicsScene scene;
 scene.addText("Hello, world!");
 
 QGraphicsView view(&scene);
 view.show();

Vous pouvez vous déplacer explicitement jusqu'à une position quelconque sur la scène en utilisant les barres de défilement, ou en appelant centerOn(). En passant un point à centerOn(), QGraphicsView va déplacer sa zone d'affichage afin que le point soit centré dans la vue. Une surcharge permet de passer un QGraphicsItem, auquel cas la QGraphicsView fera en sorte que le centre de l'élément soit centré dans la vue. Si vous voulez simplement qu'une certaine zone soit visible (mais pas forcément centrée), vous pouvez appeler ensureVisible().

QGraphicsView peut être utilisée pour visualiser une scène entière ou une de ses parties. La zone visible est par défaut détectée automatiquement lorsque la vue est affichée pour la première fois (en appelant QGraphicsScene::itemsBoundingRect()). Pour spécifier vous-même le rectangle visualisé, vous pouvez appeler setSceneRect(). Les dimensions des barres de défilement seront ajustées en conséquence. Notez que, bien que la scène gère une taille virtuellement illimitée, les limites des barres de défilement ne peuvent pas dépasser les limites d'un entier (INT_MIN, INT_MAX). Si la scène est plus grande que les valeurs des barres de défilement, vous pouvez leur substituer une navigation avec translate().

QGraphicsView affiche la scène en appelant render(). Par défaut, les éléments sont dessinés en utilisant un QPainter standard et les indications de rendu par défaut. Pour modifier les indications de rendu par défaut que QGraphicsView passe à QPainter pour le dessin des éléments, vous pouvez appeler setRenderHints().

Par défaut, QGraphicsView utilise un QWidget standard pour sa zone d'affichage. Vous pouvez accéder à ce widget en appelant viewport() ou le remplacer en appelant setViewport(). Pour utiliser OpenGL pour le rendu, appelez simplement setViewport(new QGLWidget). QGraphicsView acquiert la propriété du widget d'affichage.

QGraphicsView gère les transformations affines en utilisant QTransform. Vous pouvez passer une matrice à setTransform(), ou bien appeler une des fonctions utilitaires rotate(), scale(), translate() ou shear(). Les deux transformations les plus communes sont la mise à l'échelle (qui est utilisée pour implémenter le zoom) et la rotation. QGraphicsView conserve la position du centre de la vue lors d'une transformation.

Vous pouvez interagir avec les éléments de la scène en utilisant la souris et le clavier. QGraphicsView traduit les événements souris et clavier en événements scène (des événements héritant de QGraphicsSceneEvent), et les transfère à la scène visualisée. Au final, c'est l'élément individuel qui gère les événements et qui y réagit. Par exemple, si vous cliquez sur un élément sélectionnable, celui-ci va généralement informer la scène qu'il a été sélectionné et va aussi se redessiner pour afficher un rectangle de sélection. De la même façon, si vous cliquez et faites glisser la souris pour déplacer un élément déplaçable, c'est l'élément qui gère les mouvements de souris et se déplace lui-même. Les interactions entre éléments sont activées par défaut, vous pouvez les désactiver avec setInteractive().

Vous pouvez créer vos propres interactions personnalisées en dérivant QGraphicsView et en réimplémentant les gestionnaires des événements souris et clavier. Pour simplifier la programmation des manipulations des éléments de la vue, QGraphicsView fournit les fonctions de conversion mapToScene(), mapFromScene() et les accesseurs d'éléments items() et itemAt(). Ces fonctions vous permettent de convertir des points, rectangles, polygones et chemins entre les coordonnées de vue et les coordonnées de scène et de trouver des éléments sur la scène en utilisant des coordonnées de vue.

image

Voir aussi QGraphicsScene, QGraphicsItem et QGraphicsSceneEvent.

Type

enum QGraphicsView::CacheModeFlagflags QGraphicsView::CacheMode

Cette énumération décrit les drapeaux que vous pouvez spécifier pour le mode de cache de QGraphicsView.

Constante Valeur Description
QGraphicsView::CacheNone 0x0 Les dessins sont faits directement sur l'affichage.
QGraphicsView::CacheBackground 0x1 L'arrière-plan est mis en cache. Cela affecte à la fois les arrières-plans personnalisés et les arrières-plans basés sur la propriété backgroundBrush. Lorsque ce drapeau est activé, QGraphicsView va allouer une pixmap ayant la taille totale de l'affichage.

Le type CacheMode est un typedef pour QFlags<CacheModeFlag>. Il enregistre une combinaison OU de valeurs de type CacheModeFlag.

Voir aussi cacheMode.

enum QGraphicsView::DragMode

Cette énumération décrit l'action par défaut pour la vue lorsque la souris est déplacée avec le bouton appuyé.

Constante Valeur Description
QGraphicsView::NoDrag   Rien ne se passe ; l'événement souris est ignoré.
QGraphicsView::ScrollHandDrag 1 Le curseur prend la forme d'une main et les déplacements de la souris déplacent les barres de défilement. Ce mode fonctionne à la fois en mode interactif et non-interactif.
QGraphicsView::RubberBandDrag 2 Un rectangle de sélection apparaît. Les déplacements de la souris vont modifier la géométrie du rectangle de sélection et tous les éléments recouverts par le rectangle seront sélectionnés. Ce mode est désactivé pour les vues non-interactives.

Voir aussi dragMode et QGraphicsScene::setSelectionArea().

enum QGraphicsView::OptimizationFlagflags QGraphicsView::OptimizationFlags

Cette énumération décrit les drapeaux que vous pouvez activer pour améliorer les performances de rendu dans QGraphicsView. Par défaut, aucun de ces drapeaux n'est actif. Notez que l'activation d'un drapeau impose généralement un effet secondaire et cet effet peut varier suivant les périphériques de dessin et les plateformes.

Constante Valeur Description
QGraphicsView::DontClipPainter 0x1 Cette valeur est obsolète et n'a pas d'effet.
QGraphicsView::DontSavePainterState 0x2 Pendant le rendu, QGraphicsView protège l'état du painter (voir QPainter::save()) pour le rendu de l'arrière-plan ou de l'avant-plan et pendant le rendu de chaque élément. Ceci vous permet de laisser le painter dans un état modifié (c'est-à-dire que vous pouvez appeler QPainter::setPen() ou QPainter::setBrush() sans restaurer l'état après le dessin). Cependant, si les éléments restaurent systématiquement l'état, vous pouvez activer ce drapeau pour éviter que QGraphicsView refasse le même travail.
QGraphicsView::DontAdjustForAntialiasing 0x4 Désactive l'ajustement automatique de l'anticrénelage des zones exposées de QGraphicsView. Des éléments effectuant un rendu de lignes lissées aux limites de leur QGraphicsItem::boundingRect() peuvent se trouver à dessiner une partie de la ligne à l'extérieur. Pour prévenir les artefacts de rendu QGraphicsView étend toutes les régions exposées de deux pixels dans toutes les directions. Si vous activez ce drapeau, QGraphicsView n'effectuera plus ces ajustements, ce qui minimisera les zones à redessiner, et donc améliorera les performances. Un effet secondaire courant est que les éléments qui dessinent avec un anticrénelage peuvent laisser des traces derrière eux lorsqu'ils sont déplacés.
QGraphicsView::IndirectPainting 0x8 Depuis Qt 4.6, rétablit les anciens algorithmes de dessin appelant QGraphicsView::drawItems() et QGraphicsScene::drawItems(). À utiliser exclusivement pour compatibilité avec du code ancien.

Cette énumération a été introduite dans Qt 4.3.

Le type OptimizationFlags est un typedef pour QFlags<OptimizationFlag>. Il enregistre une combinaison OU de valeurs OptimizationFlag.

enum QGraphicsView::ViewportAnchor

Cette énumération décrit les ancrages possibles que QGraphicsView peut appliquer lorsque l'utilisateur redimensionne la vue ou que la vue est transformée.

Constante Valeur Description
QGraphicsView::NoAnchor   Pas d'ancrage, c'est-à-dire que la vue laisse la position de la scène inchangée.
QGraphicsView::AnchorViewCenter 1 Le point de la scène situé au centre de la vue sert de point d'ancrage.
QGraphicsView::AnchorUnderMouse 2 Le point de la scène situé sous la souris sert de point d'ancrage.

Voir aussi resizeAnchor et transformationAnchor.

enum QGraphicsView::ViewportUpdateMode

Cette énumération décrit la manière dont QGraphicsView rafraîchit son affichage lorsque le contenu de la scène change ou est ré-exposé.

Constante Valeur Description
QGraphicsView::FullViewportUpdate   Lorsqu'une partie de la scène change ou est ré-exposée, QGraphicsView va rafraîchir l'affichage entier. Cette approche est la plus rapide dans les cas où QGraphicsView passerait plus de temps à estimer ce qui doit être dessiné qu'à réaliser le dessin lui-même (par exemple si de nombreux petits éléments sont mis à jour de façon répétée). C'est la méthode privilégiée pour des afficheurs ne gérant pas les mises à jour partielles, comme QGLWidget et pour des afficheurs qui doivent désactiver l'optimisation du défilement.
QGraphicsView::MinimalViewportUpdate 1 QGraphicsView va déterminer la région minimale devant être redessinée, réduisant le temps de traitement en évitant de dessiner les régions qui n'ont pas été modifiées. C'est le mode par défaut de QGraphicsView. Bien que cette méthode donne en général les meilleures performances, s'il y a de nombreux petits changements visibles sur la scène, QGraphicsView peut finir par passer plus de temps à trouver la zone minimale qu'à dessiner.
QGraphicsView::SmartViewportUpdate 2 QGraphicsView va essayer de déterminer un mode de mise à jour optimal en analysant les zones devant être redessinées.
QGraphicsView::BoundingRectViewportUpdate 4 Le rectangle englobant tous les changements de la zone visible sera redessiné. Ce mode a l'avantage de limiter les recherches de changements faites par QGraphicsView à une seule région, ce qui minimise le temps passé à déterminer les parties à redessiner. L'inconvénient est que des zones qui n'ont pas été modifiées doivent être redessinées.
QGraphicsView::NoViewportUpdate 3 QGraphicsView ne mettra jamais à jour l'affichage lorsque la scène change ; l'utilisateur doit contrôler toutes les mises à jour. Ce mode désactive tous les tests de visibilité des éléments dans QGraphicsView et convient aux scènes qui requièrent une fréquence de rafraîchissement fixe ou dont l'affichage est mis à jour par un mécanisme externe.

Cette énumération a été introduite ou modifiée dans Qt 4.3.

Voir aussi viewportUpdateMode.

Propriétés

alignment : Qt::Alignment

Cette propriété représente l'alignement de la scène dans la vue lorsque la scène complète est visible.

Si la scène complète est visible dans la vue (c'est-à-dire si les barres de défilement ne sont pas actives), l'alignement de la vue va déterminer l'endroit où la scène sera affichée dans la vue. Par exemple, si l'alignement est Qt::AlignCenter, qui est la valeur par défaut, la scène sera centrée dans la vue et si l'alignement est (Qt::AlignLeft | Qt::AlignTop), la scène sera affichée dans le coin supérieur gauche de la vue.

Fonctions d'accès

Qt::Alignment alignment () const

void setAlignment ( Qt::Alignment alignment )

backgroundBrush : QBrush

Cette propriété contient la brosse d'arrière-plan de la scène.

Cette propriété spécifie la brosse d'arrière-plan dans cette vue. Elle est utilisée pour modifier l'arrière-plan original de la scène et définit le comportement de drawBackground(). Vous pouvez aussi réimplémenter drawBackground() pour réaliser un dessin personnalisé de l'arrière-plan de la scène.

Par défaut, cette propriété contient une brosse de type Qt::NoBrush.

Fonctions d'accès

QBrush backgroundBrush () const

void setBackgroundBrush ( const QBrush & brush )

Voir aussi QGraphicsScene::backgroundBrush et foregroundBrush.

cacheMode : CacheMode

Cette propriété contient le mode de mise en cache de la vue.

QGraphicsView peut mettre en cache un contenu pré-rendu dans un QPixmap, qui est ensuite dessiné dans l'afficheur. Le but de cette mise en cache est d'accélérer le temps de rendu total pour des zones pour lequel le rendu est lent. Cela peut être le cas pour, par exemple, les textures, les arrière-plans avec gradient ou avec des effets de transparence, en particulier avec une vue transformée. Le drapeau CacheBackground active la mise en cache de l'arrière-plan de la vue. Par exemple :

 QGraphicsView view;
 view.setBackgroundBrush(QImage(":/images/backgroundtile.png"));
 view.setCacheMode(QGraphicsView::CacheBackground);

Le cache est invalidé à chaque fois que la vue est transformée. Cependant, en cas de défilement, l'invalidation est seulement partielle.

Par défaut, la mise en cache est désactivée.

Fonctions d'accès

CacheMode cacheMode () const

void setCacheMode ( CacheMode mode )

Voir aussi resetCachedContent() et QPixmapCache.

dragMode : DragMode

Cette propriété spécifie le comportement de la vue lorsque la souris est déplacée sur la scène avec le bouton de gauche appuyé.

Cette propriété définit ce qui doit se passer lorsque l'utilisateur clique sur l'arrière-plan de la scène et déplace la souris (c'est-à-dire faire défiler la vue en affichant un pointeur en forme de main, ou effectuer une sélection multiple avec un rectangle de sélection). La valeur par défaut, NoDrag, ne fait rien.

Ce comportement ne concerne que les clics de souris qui ne sont gérés par aucun élément. Vous pouvez définir un comportement personnalisé en dérivant QGraphicsView et en réimplémentant mouseMoveEvent().

Fonctions d'accès

DragMode dragMode () const

void setDragMode ( DragMode mode )

foregroundBrush : QBrush

Cette propriété contient la brosse d'avant-plan de la scène.

Cette propriété définit la brosse d'avant-plan dans cette vue. Elle est utilisée pour modifier l'avant-plan original de la scène et définit le comportement de drawForeground(). Vous pouvez aussi réimplémenter drawForeground() pour réaliser un dessin personnalisé de l'avant-plan de la scène.

Par défaut, cette propriété contient une brosse de type Qt::NoBrush.

Fonctions d'accès

QBrush foregroundBrush () const

void setForegroundBrush ( const QBrush & brush )

Voir aussi QGraphicsScene::foregroundBrush et backgroundBrush.

interactive : bool

Cette propriété spécifie si les interactions avec la scène sont autorisées.

Si elle est activée, la vue autorise les interactions. Sinon, les interactions sont interdites et les événements souris ou clavier sont ignorés (la vue sera en lecture seule).

Par défaut, cette propriété est vraie.

Fonctions d'accès

bool isInteractive () const

void setInteractive ( bool allowed )

optimizationFlags : OptimizationFlags

Cette propriété contient des drapeaux influençant les performances de QGraphicsView.

QGraphicsView peut utiliser le clipping, l'ajustement du rectangle à redessiner et d'autres aides pour améliorer la qualité et les performances du rendu pour les types de scène les plus courants. Cependant, en fonction de la plateforme, de la scène et du type d'affichage, certaines de ces opérations peuvent dégrader les performances.

Les effets varient suivant les drapeaux ; voir la documentation de OptimizationFlags pour plus de détails.

Par défaut, les drapeaux d'optimisation sont tous désactivés.

Cette propriété a été introduite dans Qt 4.3.

Fonctions d'accès

OptimizationFlags optimizationFlags () const

void setOptimizationFlags ( OptimizationFlags flags )

Voir aussi setOptimizationFlag().

renderHints : QPainter::RenderHints

Cette propriété contient les indications de rendu par défaut pour la vue.

Ces indications sont utilisées pour initialiser QPainter avant que chaque élément visible soit dessiné. QPainter utilise les indications de rendu pour activer ou désactiver des options de rendu comme l'anticrénelage et la transformation fine des pixmap .

QPainter::TextAntialiasing est activé par défaut.

Exemple :

 QGraphicsScene scene;
 scene.addRect(QRectF(-10, -10, 20, 20));
 
 QGraphicsView view(&scene);
 view.setRenderHints(QPainter::Antialiasing | QPainter::SmoothPixmapTransform);
 view.show();
Fonctions d'accès

QPainter::RenderHints renderHints () const

void setRenderHints ( QPainter::RenderHints hints )

resizeAnchor : ViewportAnchor

Cette propriété spécifie la façon dont la vue doit positionner la scène lorsque la vue est redimensionnée.

QGraphicsView utilise cette propriété pour décider du positionnement de la scène dans l'affichage lorsque la taille du widget d'affichage change. Le comportement par défaut, NoAnchor, ne modifie pas la position de la scène lors d'un redimensionnement ; le coin supérieur gauche de la vue paraît ancré.

Notez que l'effet de cette propriété n'est apparent que si la scène est seulement partiellement visible (c'est-à-dire que des barres de défilement sont affichées). Sinon, si la scène est entièrement affichée dans la vue, QGraphicsScene utilise la propriété alignment pour positionner la scène dans la vue.

Fonctions d'accès

ViewportAnchor resizeAnchor () const

void setResizeAnchor ( ViewportAnchor anchor )

Voir aussi alignment, transformationAnchor et Qt::WNorthWestGravity.

rubberBandSelectionMode : Qt::ItemSelectionMode

Cette propriété spécifie le comportement des éléments sélectionnés par un rectangle de sélection multiple.

Cette propriété définit la façon dont les éléments sont sélectionnés dans le mode RubberBandDrag.

La valeur par défaut est Qt::IntersectsItemShape ; tous les éléments dont la forme est partiellement ou totalement contenue par le rectangle de sélection sont sélectionnés.

Cette propriété a été introduite dans Qt 4.3.

Fonctions d'accès

Qt::ItemSelectionMode rubberBandSelectionMode () const

void setRubberBandSelectionMode ( Qt::ItemSelectionMode mode )

Voir aussi dragMode et items().

sceneRect : QRectF

Cette propriété contient la zone de la scène affichée par cette vue.

Le rectangle de scène définit l'étendue de la scène. Pour la vue, cela correspond à la zone de la scène dans laquelle on peut naviguer avec les barres de défilement.

Si elle est indéfinie ou définie avec un QRectF nul, cette propriété a la même valeur que QGraphicsScene::sceneRect et change avec QGraphicsScene::sceneRect. Sinon, le rectangle de scène de la vue n'est pas affecté par la scène.

Notez que bien que la scène gère une taille virtuellement illimitée, les limites des barres de défilement ne peuvent pas dépasser les limites d'un entier (INT_MIN, INT_MAX). Si la scène est plus grande que les valeurs des barres de défilement, vous pouvez leur substituer une navigation avec translate().

Par défaut, cette propriété contient un rectangle à l'origine avec une longueur et une largeur de zéro.

Fonctions d'accès

QRectF sceneRect () const

void setSceneRect ( const QRectF & rect )

void setSceneRect ( qreal x, qreal y, qreal w, qreal h )

Voir aussi QGraphicsScene::sceneRect.

transformationAnchor : ViewportAnchor

Cette propriété spécifie la façon dont la vue doit positionner la scène lorsque la vue est transformée.

QGraphicsView utilise cette propriété pour décider du positionnement de la scène dans l'affichage lorsque la matrice de transformation change et que le système de coordonnées de la vue est transformé. Le comportement par défaut, AnchorViewCenter, conserve la position du centre de la scène lors d'une transformation (par exemple, en cas de rotation, la scène paraîtra tourner autour du centre de la vue).

Notez que l'effet de cette propriété n'est apparent que si la scène est seulement partiellement visible (c'est-à-dire que des barres de défilement sont affichées). Sinon, si la scène est entièrement affichée dans la vue, QGraphicsScene utilise la propriété alignment pour positionner la scène dans la vue.

Fonctions d'accès

ViewportAnchor transformationAnchor () const

void setTransformationAnchor ( ViewportAnchor anchor )

Voir aussi alignment et resizeAnchor.

viewportUpdateMode : ViewportUpdateMode

Cette propriété spéficie la manière dont la vue doit mettre à jour son contenu.

Cette propriété est utilisée par QGraphicsView pour déterminer la manière de rafraîchir son affichage lorsque le contenu de la scène change ou est ré-exposé. En général vous n'avez pas besoin de modifier cette propriété mais dans certains cas une modification peut améliorer les performances. Voir la documentation ViewportUpdateMode pour plus de détail.

La valeur par défaut est MinimalViewportUpdate, pour laquelle QGraphicsView va mettre à jour une zone la plus petite possible lorsque le contenu change.

Cette propriété a été introduite dans Qt 4.3.

Fonctions d'accès

ViewportUpdateMode viewportUpdateMode () const

void setViewportUpdateMode ( ViewportUpdateMode mode )

Voir aussi ViewportUpdateMode et cacheMode.

Fonctions membres

QGraphicsView::QGraphicsView ( QWidget * parent = 0 )

Construit une QGraphicsView. parent est passé au constructeur de QWidget.

QGraphicsView::QGraphicsView ( QGraphicsScene * scene, QWidget * parent = 0 )

Construit une QGraphicsView et spécifie scene comme scène à visualiser. parent est passé au constructeur de QWidget.

QGraphicsView::~QGraphicsView ()

Détruit l'objet QGraphicsView.

void QGraphicsView::centerOn ( const QPointF & pos )

Fait défiler le contenu de l'affichage afin que les coordonnées de scène pos soit centrées dans la vue.

Étant donné que pos est en virgule flottante et que les barres de défilement opèrent en coordonnées entières, le centrage est une approximation.

Note : si la position demandée est près du bord de la scène ou à l'extérieur, elle sera visible dans la vue mais non centrée.

Voir aussi ensureVisible().

void QGraphicsView::centerOn ( qreal x, qreal y )

Il s'agit d'une fonction surchargée.

Cette fonction est un équivalent plus commode à l'appel de centerOn(QPointF(x, y)).

void QGraphicsView::centerOn ( const QGraphicsItem * item )

Il s'agit d'une fonction surchargée.

Fait défiler le contenu de l'affichage afin que l'élément item soit centré dans la vue.

Voir aussi ensureVisible().

void QGraphicsView::contextMenuEvent ( QContextMenuEvent * event ) [virtual protected]

Réimplémentation de QWidget::contextMenuEvent().

void QGraphicsView::dragEnterEvent ( QDragEnterEvent * event ) [virtual protected]

Réimplémentation de QWidget::dragEnterEvent().

void QGraphicsView::dragLeaveEvent ( QDragLeaveEvent * event ) [virtual protected]

Réimplémentation de QWidget::dragLeaveEvent().

void QGraphicsView::dragMoveEvent ( QDragMoveEvent * event ) [virtual protected]

Réimplémentation de QWidget::dragMoveEvent().

void QGraphicsView::drawBackground ( QPainter * painter, const QRectF & rect ) [virtual protected]

Dessine l'arrière-plan de la scène en utilisant painter, avant que les éléments et l'avant-plan soient dessinés. Réimplémentez cette fonction pour donner un arrière-plan personnalisé à cette vue.

Si vous voulez simplement définir une couleur, une texture ou un gradient pour l'arrière-plan, vous pouvez aussi appeler setBackgroundBrush().

Les dessins sont effectués en coordonnées de scène. rect est le rectangle visible.

L'implémentation par défaut remplit rect en utilisant la brosse backgroundBrush de la vue. Si cette brosse n'est pas définie (ce qui est le cas par défaut), c'est la fonction drawBackground() de la scène qui est appelée.

Voir aussi drawForeground() et QGraphicsScene::drawBackground().

void QGraphicsView::drawForeground ( QPainter * painter, const QRectF & rect ) [virtual protected]

Dessine l'avant-plan de la scène en utilisant painter, après que les éléments et l'arrière-plan aient été dessinés. Réimplémentez cette fonction pour donner un avant-plan personnalisé à cette vue.

Si vous voulez simplement définir une couleur, une texture ou un gradient pour l'arrière-plan, vous pouvez aussi appeler setBackgroundBrush().

Les dessins sont effectués en coordonnées de scène. rect est le rectangle visible.

L'implémentation par défaut remplit rect en utilisant la brosse foregroundBrush de la vue. Si cette brosse n'est pas définie (ce qui est le cas par défaut), c'est la fonction drawForeground() de la scène qui est appelée.

Voir aussi drawBackground() et QGraphicsScene::drawForeground().

void QGraphicsView::dropEvent ( QDropEvent * event ) [virtual protected]

Réimplémentation de QWidget::dropEvent().

void QGraphicsView::ensureVisible ( const QRectF & rect, int xmargin = 50, int ymargin = 50 )

Fait défiler le contenu de l'affichage afin que le rectangle rect de la scène soit visible, avec des marges spécifiées en pixels par xmargin et ymargin. Si le rectangle spécifié ne peut pas être atteint, le contenu défile jusqu'à la position valide la plus proche. La valeur par défaut des deux marges est de 50 pixels.

Voir aussi centerOn().

void QGraphicsView::ensureVisible ( qreal x, qreal y, qreal w, qreal h, int xmargin = 50, int ymargin = 50 )

Il s'agit d'une fonction surchargée.

Cette fonction est un équivalent plus commode à l'appel de ensureVisible(QRectF(x, y, w, h), xmargin, ymargin).

void QGraphicsView::ensureVisible ( const QGraphicsItem * item, int xmargin = 50, int ymargin = 50 )

Fait défiler le contenu de l'affichage afin que le centre de l'élément item soit visible, avec des marges spécifiées en pixels par xmargin et ymargin. Si le point spécifié ne peut pas être atteint, le contenu défile jusqu'à la position valide la plus proche. La valeur par défaut des deux marges est de 50 pixels.

Il s'agit d'une fonction surchargée.

Voir aussi centerOn().

bool QGraphicsView::event ( QEvent * event ) [virtual protected]

Réimplémentation de QObject::event().

void QGraphicsView::fitInView ( const QRectF & rect, Qt::AspectRatioMode aspectRatioMode = Qt::IgnoreAspectRatio )

Redimensionne la vue et déplace les barres de défilement pour rendre entièrement visible le rectangle rect de la scène. rect doit être à l'intérieur de la scène ; sinon, fitInView() ne garantit pas que la totalité du rectangle sera visible.

Cette fonction conserve la rotation, la translation ou le cisaillement de la vue. La vue est redimensionnée suivant aspectRatioMode. rect sera centré dans la vue s'il ne la remplit pas.

Il est courant d'appeler fitInView() depuis une réimplementation de resizeEvent(), pour s'assurer que la scène ou une de ses parties est automatiquement redimensionnée pour s'adapter à la nouvelle taille de l'affichage lorsque la vue est redimensionnée. Notez que l'appel de fitInView() depuis resizeEvent() peut déclencher une récursion accidentelle sur la taille, si la nouvelle transformation entraîne un affichage ou un masquage automatique des barres de défilement. Vous pouvez passer les modes de gestion des barres de défilement à « toujours affichée » ou « toujours masquée » afin d'éviter ce risque (voir horizontalScrollBarPolicy() et verticalScrollBarPolicy()).

Si rect est vide ou si l'affichage est trop petit, cette fonction ne fera rien.

Voir aussi setTransform(), ensureVisible() et centerOn().

void QGraphicsView::fitInView ( qreal x, qreal y, qreal w, qreal h, Qt::AspectRatioMode aspectRatioMode = Qt::IgnoreAspectRatio )

Il s'agit d'une fonction surchargée.

Cette fonction est un équivalent plus commode à l'appel de fitInView(QRectF(x, y, w, h), aspectRatioMode).

Voir aussi ensureVisible() et centerOn().

void QGraphicsView::fitInView ( const QGraphicsItem * item, Qt::AspectRatioMode aspectRatioMode = Qt::IgnoreAspectRatio )

Il s'agit d'une fonction surchargée.

Ajuste la vue à la taille de item, en redimensionnant la vue suivant aspectRatioMode.

Voir aussi ensureVisible() et centerOn().

void QGraphicsView::focusInEvent ( QFocusEvent * event ) [virtual protected]

Réimplémentation de QWidget::focusInEvent().

bool QGraphicsView::focusNextPrevChild ( bool next ) [virtual protected]

Réimplémentation de QWidget::focusNextPrevChild().

void QGraphicsView::focusOutEvent ( QFocusEvent * event ) [virtual protected]

Réimplémentation de QWidget::focusOutEvent().

void QGraphicsView::inputMethodEvent ( QInputMethodEvent * event ) [virtual protected]

Réimplémentation de QWidget::inputMethodEvent().

QVariant QGraphicsView::inputMethodQuery ( Qt::InputMethodQuery query ) const [virtual]

Réimplémentation de QWidget::inputMethodQuery().

void QGraphicsView::invalidateScene ( const QRectF & rect = QRectF(), QGraphicsScene::SceneLayers layers = QGraphicsScene::AllLayers ) [slot]

Invalide et demande à redessiner layers à l'intérieur de rect. rect est en coordonnées de scène. Le contenu de layers à l'intérieur de rect se trouvant en cache sera inconditionnellement invalidé et redessiné.

Vous pouvez appeler cette fonction pour notifier QGraphicsView de changements de l'arrière-plan ou de l'avant-plan de la scène. Elle est couramment utilisée pour les scènes avec un arrière-plan tuilé pour notifier des changements si QGraphicsView a activé la mise en cache de l'arrière-plan.

Notez que QGraphicsView ne gère actuellement que la mise en cache de l'arrière-plan (voir QGraphicsView::CacheBackground). Cette fonction est équivalente à l'appel de update() si une autre couche que QGraphicsScene::BackgroundLayer est passée.

Voir aussi QGraphicsScene::invalidate() et update().

bool QGraphicsView::isTransformed () const

Renvoie true si la vue est transformée (c'est-à-dire si une transformation différente de l'identité a été affectée ou que les barres de défilement ont été ajustées).

Cette fonction a été introduite dans Qt 4.6.

Voir aussi setTransform(), horizontalScrollBar() et verticalScrollBar().

QGraphicsItem * QGraphicsView::itemAt ( const QPoint & pos ) const

Renvoie l'élément à la position pos, qui est en coordonnées de vue. Si plusieurs éléments se trouvent à cette position, la fonction renvoie l'élément du dessus.

Exemple :

 void CustomView::mousePressEvent(QMouseEvent *event)
 {
     if (QGraphicsItem *item = itemAt(event->pos())) {
         qDebug() << "Vous avez cliqué sur l'élément" << item;
     } else {
         qDebug() << "Vous n'avez pas cliqué sur un élément.";
     }
 }

Voir aussi items() et Sorting.

QGraphicsItem * QGraphicsView::itemAt ( int x, int y ) const

Il s'agit d'une fonction surchargée.

Cette fonction est un équivalent plus commode à l'appel de itemAt(QPoint(x, y)).

QList<QGraphicsItem *> QGraphicsView::items () const

Renvoie une liste de tous les éléments de la scène associée, en ordre d'empilement descendant (c'est-à-dire que le premier élément de la liste renvoyée est l'élément du dessus).

Voir aussi QGraphicsScene::items() et Sorting.

QList<QGraphicsItem *> QGraphicsView::items ( const QPoint & pos ) const

Renvoie une liste de tous les éléments à la position pos dans la vue. Les éléments sont triés en ordre d'empilement descendant (c'est-à-dire que le premier élément de la liste renvoyée est l'élément du dessus, le dernier, l'élément du dessous). pos est en coordonnées de vue.

Cette fonction est le plus souvent appelée depuis les gestionnaires d'événements souris dans une classe dérivée de QGraphicsView. pos est en coordonnées de vue non transformées, comme QMouseEvent::pos().

 void CustomView::mousePressEvent(QMouseEvent *event)
 {
     qDebug() << "Il y a" << items(event->pos()).size()
              << "éléments à la position" << mapToScene(event->pos());
 }

Voir aussi QGraphicsScene::items() et Sorting.

QList<QGraphicsItem *> QGraphicsView::items ( int x, int y ) const

Cette fonction est un équivalent plus commode à l'appel de items(QPoint(x, y)).

QList<QGraphicsItem *> QGraphicsView::items ( int x, int y, int w, int h, Qt::ItemSelectionMode mode = Qt::IntersectsItemShape ) const

Cette fonction est un équivalent plus commode à l'appel de items(QRectF(x, y, w, h), mode).

Cette fonction a été introduite dans Qt 4.3.

QList<QGraphicsItem *> QGraphicsView::items ( const QRect & rect, Qt::ItemSelectionMode mode = Qt::IntersectsItemShape ) const

Il s'agit d'une fonction surchargée.

Renvoie une liste des éléments qui, en fonction de mode, sont contenus entièrement ou partiellement dans rect. rect est en coordonnées de vue.

La valeur par défaut de mode est Qt::IntersectsItemShape ; tous les éléments dont la forme exacte est contenue entièrement ou partiellement dans rect sont renvoyés.

Les éléments sont triés en ordre d'empilement descendant (c'est-à-dire que le premier élément de la liste renvoyée est l'élément du dessus).

Voir aussi itemAt(), items(), mapToScene() et Sorting.

QList<QGraphicsItem *> QGraphicsView::items ( const QPolygon & polygon, Qt::ItemSelectionMode mode = Qt::IntersectsItemShape ) const

Il s'agit d'une fonction surchargée.

Renvoie une liste des éléments qui, en fonction de mode, sont contenus entièrement ou partiellement dans polygon. polygon est en coordonnées de vue.

La valeur par défaut de mode est Qt::IntersectsItemShape ; tous les éléments dont la forme exacte est contenue entièrement ou partiellement dans polygon sont renvoyés.

Les éléments sont triés en ordre d'empilement descendant (c'est-à-dire que le premier élément de la liste renvoyée est l'élément du dessus).

Voir aussi itemAt(), items(), mapToScene() et Sorting.

QList<QGraphicsItem *> QGraphicsView::items ( const QPainterPath & path, Qt::ItemSelectionMode mode = Qt::IntersectsItemShape ) const

Il s'agit d'une fonction surchargée.

Renvoie une liste des éléments qui, en fonction de mode, sont contenus entièrement ou partiellement dans path. path est en coordonnées de vue.

La valeur par défaut de mode est Qt::IntersectsItemShape ; tous les éléments dont la forme exacte est contenue entièrement ou partiellement dans path sont renvoyés.

Voir aussi itemAt(), items(), mapToScene() et Sorting.

void QGraphicsView::keyPressEvent ( QKeyEvent * event ) [virtual protected]

Réimplémentation de QWidget::keyPressEvent().

void QGraphicsView::keyReleaseEvent ( QKeyEvent * event ) [virtual protected]

Réimplémentation de QWidget::keyReleaseEvent().

QPoint QGraphicsView::mapFromScene ( const QPointF & point ) const

Renvoie la conversion de point en coordonnées de vue depuis des coordonnées de scène.

Voir aussi mapToScene().

QPolygon QGraphicsView::mapFromScene ( const QRectF & rect ) const

Transforme rect, un rectangle en coordonnées de scène, en polygone en coordonnées de vue.

Voir aussi mapToScene().

QPolygon QGraphicsView::mapFromScene ( const QPolygonF & polygon ) const

Convertit polygon, un polygone en coordonnées de scène, en coordonnées de vue.

Voir aussi mapToScene().

QPainterPath QGraphicsView::mapFromScene ( const QPainterPath & path ) const

Convertit path, un chemin en coordonnées de scène, en coordonnées de vue.

Voir aussi mapToScene().

QPoint QGraphicsView::mapFromScene ( qreal x, qreal y ) const

Cette fonction est un équivalent plus commode à l'appel de mapFromScene(QPointF(x, y)).

QPolygon QGraphicsView::mapFromScene ( qreal x, qreal y, qreal w, qreal h ) const

Cette fonction est un équivalent plus commode à l'appel de mapFromScene(QRectF(x, y, w, h)).

QPointF QGraphicsView::mapToScene ( const QPoint & point ) const

Renvoie la conversion de point en coordonnées de scène depuis des coordonnées de vue.

Note : il peut être utile de convertir tout le rectangle couvert par le pixel au point au lieu du point lui-même. Pour ce faire, vous pouvez appeler mapToScene(QRect(point, QSize(2, 2))).

Voir aussi mapFromScene().

QPolygonF QGraphicsView::mapToScene ( const QRect & rect ) const

Transforme rect, un rectangle en coordonnées de vue, en polygone en coordonnées de scène.

Voir aussi mapFromScene().

QPolygonF QGraphicsView::mapToScene ( const QPolygon & polygon ) const

Convertit polygon, un polygone en coordonnées de vue, en coordonnées de scène.

Voir aussi mapFromScene().

QPainterPath QGraphicsView::mapToScene ( const QPainterPath & path ) const

Convertit path, un chemin en coordonnées de vue, en coordonnées de scène.

Voir aussi mapFromScene().

QPointF QGraphicsView::mapToScene ( int x, int y ) const

Cette fonction est un équivalent plus commode à l'appel de mapToScene(QPoint(x, y)).

QPolygonF QGraphicsView::mapToScene ( int x, int y, int w, int h ) const

Cette fonction est un équivalent plus commode à l'appel de mapToScene(QRect(x, y, w, h)).

QMatrix QGraphicsView::matrix () const

Renvoie la matrice de transformation courante de la vue. Si aucune matrice de transformation n'a été définie, renvoie la matrice unité.

Voir aussi setMatrix(), transform(), rotate(), scale(), shear() et translate().

void QGraphicsView::mouseDoubleClickEvent ( QMouseEvent * event ) [virtual protected]

Réimplémentation de QWidget::mouseDoubleClickEvent().

void QGraphicsView::mouseMoveEvent ( QMouseEvent * event ) [virtual protected]

Réimplémentation de QWidget::mouseMoveEvent().

void QGraphicsView::mousePressEvent ( QMouseEvent * event ) [virtual protected]

Réimplémentation de QWidget::mousePressEvent().

void QGraphicsView::mouseReleaseEvent ( QMouseEvent * event ) [virtual protected]

Réimplémentation de QWidget::mouseReleaseEvent().

void QGraphicsView::paintEvent ( QPaintEvent * event ) [virtual protected]

Réimplémentation de QWidget::paintEvent().

void QGraphicsView::render ( QPainter * painter, const QRectF & target = QRectF(), const QRect & source = QRect(), Qt::AspectRatioMode aspectRatioMode = Qt::KeepAspectRatio )

Effectue un rendu du rectangle source, qui est en coordonnées de vue, depuis la scène vers target, qui est en coordonnées du périphérique de dessin, en utilisant painter. Cette fonction est utile pour capturer le contenu de la vue sur un périphérique de dessin, comme une QImage (par exemple pour faire une copie d'écran) ou pour imprimer vers un QPrinter.

Par exemple :

 QGraphicsScene scene;
 scene.addItem(...
 ...
 
 QGraphicsView view(&scene);
 view.show();
 ...
 
 QPrinter printer(QPrinter::HighResolution);
 printer.setPageSize(QPrinter::A4);
 QPainter painter(&printer);
 
 // impression du contenu de l'affichage sur une pleine page
 view.render(&painter);
 
 // impression de la moitié supérieure de l'affichage 
 // sur la moitié inférieure de la page.
 QRect viewport = view.viewport()->rect();
 view.render(&painter,
             QRectF(0, printer.height() / 2,
                    printer.width(), printer.height() / 2),
             viewport.adjusted(0, 0, 0, -viewport.height() / 2));

Si source est un rectangle nul, cette fonction utilisera viewport()->rect() pour déterminer quoi dessiner. Si target est un rectangle nul, c'est la taille entière du périphérique de dessin du painter (par exemple, pour un QPrinter, la taille de la page) qui sera utilisée.

Le contenu du rectangle source sera transformé conformément à aspectRatioMode pour s'adapter au rectangle cible. Par défaut, les proportions sont conservées et source est redimensionnée pour remplir target.

Voir aussi QGraphicsScene::render().

void QGraphicsView::resetCachedContent ()

Réinitialise le cache. L'appel de cette fonction va vider le contenu du cache de QGraphicsView. Si le mode de cache courant est CacheNone, cette fonction ne fait rien.

Cette fonction est appelée automatiquement lorsque les propriétés backgroundBrush ou QGraphicsScene::backgroundBrush changent ; vous n'avez besoin d'appeler cette fonction que si vous avez réimplémenté QGraphicsScene::drawBackground() ou QGraphicsView::drawBackground() pour dessiner un arrière-plan personnalisé et vous devez redéclencher un rendu complet.

Voir aussi cacheMode().

void QGraphicsView::resetMatrix ()

Réinitialise la matrice de transformation à la matrice unité.

Voir aussi resetTransform().

void QGraphicsView::resetTransform ()

Réinitialise la transformation de la vue à la matrice unité.

Voir aussi transform() et setTransform().

void QGraphicsView::resizeEvent ( QResizeEvent * event ) [virtual protected]

Réimplémentation de QWidget::resizeEvent().

void QGraphicsView::rotate ( qreal angle )

Effectue une rotation de la transformation actuelle de la vue dans le sens horaire de angle degrés.

Voir aussi setTransform(), transform(), scale(), shear() et translate().

void QGraphicsView::scale ( qreal sx, qreal sy )

Applique à la transformation actuelle de la vue un facteur d'échelle (sx, sy).

Voir aussi setTransform(), transform(), rotate(), shear() et translate().

QGraphicsScene * QGraphicsView::scene () const

Renvoie un pointeur vers la scène actuellement affichée dans la vue. Si aucune scène n'est actuellement visualisée, renvoie 0.

Voir aussi setScene().

void QGraphicsView::scrollContentsBy ( int dx, int dy ) [virtual protected]

Réimplémentation de QAbstractScrollArea::scrollContentsBy().

void QGraphicsView::setMatrix ( const QMatrix & matrix, bool combine = false )

Spécifie matrix comme matrice de transformation de la vue.

Si combine est défini à true, matrix est combinée avec la matrice courante ; sinon, matrix remplace la matrice courante. combine est faux par défaut.

La matrice de transformation convertit la scène en coordonnées de vue. Avec la transformation par défaut, correspondant à la matrice identité, un pixel de la vue représente une unité dans la scène (par exemple, un élément rectangulaire de 10 × 10 est représenté par un rectangle de 10 × 10 pixels dans la vue). Si une matrice d'échelle 2 × 2 est appliquée, la scène sera dessinée à l'échelle 1:2 (par exemple, un élément rectangulaire de 10 × 10 sera représenté par un rectangle de 20 × 20 pixels dans la vue).

Exemple :

 QGraphicsScene scene;
 scene.addText("GraphicsView rotated clockwise");
 
 QGraphicsView view(&scene);
 view.rotate(90); // le texte est dessiné avec une rotation horaire de 90 degrés
 view.show();

Pour simplifier les interactions avec les éléments dans une vue transformée, QGraphicsView fournit des fonctions mapTo... et mapFrom... qui peuvent effectuer des conversions entre les coordonnées de scène et de vue. Par exemple, vous pouvez appeler mapToScene() pour convertir des coordonnées de vue en coordonnées de scène en virgule flottante ou mapFromScene() pour convertir des coordonnées de scène en virgule flottante en coordonnées de vue.

Voir aussi matrix(), setTransform(), rotate(), scale(), shear() et translate().

void QGraphicsView::setOptimizationFlag ( OptimizationFlag flag, bool enabled = true )

Active flag si enabled vaut true ; sinon désactive flag.

Voir aussi optimizationFlags.

void QGraphicsView::setRenderHint ( QPainter::RenderHint hint, bool enabled = true )

Si enabled vaut true, l'indication de rendu hint sera activée ; sinon elle sera désactivée.

Voir aussi renderHints.

void QGraphicsView::setScene ( QGraphicsScene * scene )

Spécifie scene comme scène courante. Si scene est déjà la scène courante, cette fonction ne fait rien.

Quand une scène est associée à une vue, le signal QGraphicsScene::changed() est automatiquement connecté au slot updateScene() de cette vue et les barres de défilement de la vue sont ajustées en fonction de la taille de la scène.

Voir aussi scene().

void QGraphicsView::setTransform ( const QTransform & matrix, bool combine = false )

Spécifie matrix comme matrice de transformation de la vue.

Si combine est définie à true, matrix est combinée avec la matrice courante ; sinon, matrix remplace la matrice courante. combine est faux par défaut.

La matrice de transformation convertit la scène en coordonnées de vue. Avec la transformation par défaut, correspondant à la matrice identité, un pixel de la vue représente une unité dans la scène (par exemple, un élément rectangulaire de 10 × 10 est représenté par un rectangle de 10 × 10 pixels dans la vue). Si une matrice d'échelle 2 × 2 est appliquée, la scène sera dessinée à l'échelle 1:2 (par exemple, un élément rectangulaire de 10 × 10 sera représenté par un rectangle de 20 × 20 pixels dans la vue).

Exemple :

 QGraphicsScene scene;
 scene.addText("GraphicsView rotated clockwise");
 
 QGraphicsView view(&scene);
 view.rotate(90); // le texte est dessiné avec une rotation horaire de 90 degrés
 view.show();

Pour simplifier les interactions avec les éléments dans une vue transformée, QGraphicsView fournit des fonctions mapTo... et mapFrom... qui peuvent effectuer des conversions entre les coordonnées de scène et de vue. Par exemple, vous pouvez appeler mapToScene() pour convertir des coordonnées de vue en coordonnées de scène en virgule flottante ou mapFromScene() pour convertir des coordonnées de scène en virgule flottante en coordonnées de vue.

Voir aussi transform(), rotate(), scale(), shear() et translate().

void QGraphicsView::setupViewport ( QWidget * widget ) [protected slot]

Ce slot est appelé par QAbstractScrollArea après que setViewport() ait été appelé. Réimplémentez cette fonction dans une classe dérivée de QGraphicsView pour initialiser le nouveau widget d'affichage avant qu'il soit utilisé.

Voir aussi setViewport().

void QGraphicsView::shear ( qreal sh, qreal sv )

Applique une déformation oblique (cisaillement) de (sh, sv).

Voir aussi setTransform(), transform(), rotate(), scale() et translate().

void QGraphicsView::showEvent ( QShowEvent * event ) [virtual protected]

Réimplémentation de QWidget::showEvent().

QSize QGraphicsView::sizeHint () const [virtual]

Réimplémentation de QWidget::sizeHint().

QTransform QGraphicsView::transform () const

Renvoie la matrice de transformation courante de la vue. Renvoie la matrice identité si aucune transformation n'a été définie.

Voir aussi setTransform(), rotate(), scale(), shear() et translate().

void QGraphicsView::translate ( qreal dx, qreal dy )

Translate la transformation courante de la vue de (dx, dy).

Voir aussi setTransform(), transform(), rotate() et shear().

void QGraphicsView::updateScene ( const QList<QRectF> & rects ) [slot]

Demande une mise à jour des rectangles de scène rects.

Voir aussi QGraphicsScene::changed().

void QGraphicsView::updateSceneRect ( const QRectF & rect ) [slot]

Informe QGraphicsView que le rectangle de la scène a changé. rect est le nouveau rectangle de la scène. Si la vue a déjà un rectangle de scène spécifié explicitement, cette fonction ne fait rien.

Voir aussi sceneRect et QGraphicsScene::sceneRectChanged().

bool QGraphicsView::viewportEvent ( QEvent * event ) [virtual protected]

Réimplémentation de QAbstractScrollArea::viewportEvent().

QTransform QGraphicsView::viewportTransform () const

Renvoie une matrice de conversion des coordonnées de vue vers les coordonnées de scène.

Voir aussi mapToScene() et mapFromScene().

void QGraphicsView::wheelEvent ( QWheelEvent * event ) [virtual protected]

Réimplémentation de QWidget::wheelEvent().

Remerciements

Merci à Ilya Diallo pour la traduction et à Dimitry Ernot, Jonathan Courtois ainsi qu'à Jacques Thery pour leur relecture !

Publicité

Best Of

Actualités les plus lues

Semaine
Mois
Année
  1. Microsoft ouvre aux autres compilateurs C++ AMP, la spécification pour la conception d'applications parallèles C++ utilisant le GPU 22
  2. « Quelque chose ne va vraiment pas avec les développeurs "modernes" », un développeur à "l'ancienne" critique la multiplication des bibliothèques 27
  3. Les développeurs ignorent-ils trop les failles découvertes dans leur code ? Prenez-vous en compte les remarques des autres ? 17
  4. RIM : « 13 % des développeurs ont gagné plus de 100 000 $ sur l'AppWord », Qt et open-source au menu du BlackBerry DevCon Europe 0
  5. BlackBerry 10 : premières images du prochain OS de RIM qui devrait intégrer des widgets et des tuiles inspirées de Windows Phone 0
  6. Adieu qmake, bienvenue qbs : Qt Building Suite, un outil déclaratif et extensible pour la compilation de projets Qt 17
  7. Quelles nouveautés de C++11 Visual C++ doit-il rapidement intégrer ? Donnez-nous votre avis 10
Page suivante

Le blog Digia au hasard

Logo

Déploiement d'applications Qt Commercial sur les tablettes Windows 8

Le blog Digia est l'endroit privilégié pour la communication sur l'édition commerciale de Qt, où des réponses publiques sont apportées aux questions les plus posées au support. Lire l'article.

Communauté

Ressources

Liens utiles

Contact

  • Vous souhaitez rejoindre la rédaction ou proposer un tutoriel, une traduction, une question... ? Postez dans le forum Contribuez ou contactez-nous par MP ou par email (voir en bas de page).

Qt dans le magazine

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 © 2012 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 ? Un bug ? 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 !
 
 
 
 
Partenaires

Hébergement Web