QGraphicsLayoutItem

La classe QGraphicsLayoutItem peut être héritée pour permettre à vos éléments personnalisés d'être gérés par les layouts. Plus d'informations...

#include <QGraphicsLayoutItem>

Voir la position dans l'arbre des classes.

Héritage

Hérité par QGraphicsLayout et QGraphicsWidget.

Cette classe a été introduite dans Qt 4.4.

Description détaillée

La classe QGraphicsLayoutItem peut être héritée pour permettre à vos éléments personnalisés d'être gérés par les layouts.

QGraphicsLayoutItem est une classe abstraite qui définit un ensemble de fonctions virtuelles informant des tailles, de la politique de dimension et des indices de dimensions pour n'importe quel objet arrangé par QGraphicsLayout. L'API contient des fonctions pertinentes pour l'élément en lui-même et l'utilisateur de l'élément comme la plupart des fonctions de QGraphicsLayoutItem font aussi partie de l'API publique de la sous-classe.

Dans la plupart des cas, les classes conscientes du layout telles que QGraphicsWidget et QGraphicsLayout fournissent déjà les fonctionnalités que vous désirez. Ainsi, hériter de ces classes va vous permettre de créer des éléments graphiques qui fonctionnent parfaitement avec les layouts (QGraphicsWidget) ou les layouts personnalisés (QGraphicsLayout).

Hériter QGraphicsLayoutItem

Si vous héritez de QGraphicsLayoutItem et que vous réimplémentez ses fonctions virtuelles, vous allez permettre au layout de redimensionner et de positionner votre élément avec les autres QGraphicsLayoutItems ainsi que QGraphicsWidget et QGraphicsLayout.

Vous pouvez commencer par réimplémenter les fonctions importantes : la fonction protégée sizeHint(), tout comme la fonction publique setGeometry(). Si vous souhaitez que vos éléments soient notifiés immédiatement des changements géométriques, vous pouvez aussi réimplementer updateGeometry().

La géométrie, le dimensionnement conseillé et la politique de redimensionnement affectent la taille et la position de l'élément. L'appel à setGeometry() va toujours redimensionner et repositionner immédiatement l'élément. Normalement, la fonction est appelée par QGraphicsLayout après que le layout ait été activé mais elle peut tout aussi bien être appelée par l'utilisateur de l'élément à n'importe quel moment.

La fonction sizeHint() retourne les tailles minimale, privilégiée et maximale conseillées de l'élément. Vous pouvez surcharger ces propriétés en utilisant setMinimumSize(), setPreferredSize() ou setMaximumSize(). Si vous le désirez, vous pouvez aussi utiliser les fonctions telles que setMinimumWidth() ou setMaximumHeight() pour définir seulement la largeur ou la hauteur.

La fonction effectiveSizeHint(), en opposition avec les fonctions vues précédemment, retourne la taille conseillée pour n'importe quel Qt::SizeHint et garantit que la taille retournée est comprise entre la taille minimale et maximale ainsi que les dimensionnements conseillés. Vous pouvez définir les politiques de dimensionnement pour les orientations verticale et horizontale de l'élément en appelant setSizePolicy(). La propriété sizePolicy est utilisée par le système de layout pour décrire comment cet élément préfère être agrandi ou rétréci.

Intégrer QGraphicsLayoutItems dans un autre

Les QGraphicsLayoutItems peuvent être intégrés dans d'autres QGraphicsLayoutItems, similairement aux layouts qui peuvent contenir des sous-layouts. Cela peut être réalisé soit en passant un pointeur sur QGraphicsLayoutItem pointer à un constructeur protégé de QGraphicsLayoutItem ou soit en appelant setParentLayoutItem(). La fonction parentLayoutItem() retourne un pointeur sur le layout parent layoutItem de l'élément. Si le parent de l'élément est 0, ou si le parent n'hérite pas de QGraphicsItem, la fonction parentLayoutItem() retourne alors 0. isLayout() retourne true si la sous-classe de QGraphicsLayoutItem est elle-même un layout, sinon la fonction retourne false.

Qt utilise QGraphicsLayoutItem pour fournir les fonctionnalités des layouts dans le framewotk de la Vue Graphique mais dans le futur son utilisation pourrait être répandue dans Qt lui-même.

Voir aussi QGraphicsWidget, QGraphicsLayout, QGraphicsLinearLayout et QGraphicsGridLayout.

Fonctions membres

QGraphicsLayoutItem::QGraphicsLayoutItem ( QGraphicsLayoutItem * parent = 0, bool isLayout = false )

Construit un objet QGraphicsLayoutItem. Le parent devient le parent de l'objet. Si isLayout est true l'élément est un layout, sinon isLayout est false.

QGraphicsLayoutItem::~QGraphicsLayoutItem () [virtual]

Détruit l'objet QGraphicsLayoutItem.

QRectF QGraphicsLayoutItem::contentsRect () const

Retourne le rectangle du contenu dans l'espace de coordonnées locales.

Le rectangle du contenu définit un sous-rectangle utilisé par un layout associé lors de l'arrangement des sous-éléments. Cette fonction est une fonction de commodité qui ajuste les geometry() des éléments avec les marges des contenus. Notez que getContentsMargins() est une fonction virtuelle que vous pouvez réimplementer pour retourner les marges de l'élément.

Voir aussi getContentsMargins() et geometry().

QSizeF QGraphicsLayoutItem::effectiveSizeHint ( Qt::SizeHint which, const QSizeF & constraint = QSizeF() ) const

Retourne les tailles conseillées effectives pour ce QGraphicsLayoutItem.

which est la taille conseillée en question. constraint est un argument optionnel qui définit une contrainte spécifique lors du calcul de la taille conseillée effective. Par défaut, constraint est QSizeF(-1, -1), ce qui signifie qu'il n'y a pas de contrainte pour la taille conseillée.

Si vous souhaitez spécifier la taille conseillée du widget à une largeur ou hauteur donnée, vous pouvez passer une dimension fixe pour constraint. Cela est utile pour les widgets qui peuvent s'agrandir seulement verticalement ou horizontalement et qui nécessitent d'avoir leur taille avec une largeur ou hauteur à une valeur spécifique.

Par exemple, un élément de paragraphe de texte s'intègre dans une colonne de largeur 200 et peut s'agrandir verticalement. Vous pouvez passer QSizeF(200, -1) comme contrainte pour avoir une hauteur minimale, privilégiée et maximale utilisable).

Vous pouvez ajuster la taille conseillée effective en réimplémentant sizeHint() dans une sous-classe de QGraphicsLayoutItem ou en appelant l'une des fonctions suivantes : setMinimumSize(), setPreferredSize ou setMaximumSize() (ou une combinaison des deux).

Cette fonction met en cache chacune des tailles conseillées et garantit que sizeHint() va être appelé seulement une fois pour chaque valeur de which - si constraint n'est pas spécifié et que updateGeometry() a été appelé.

Voir aussi sizeHint().

QRectF QGraphicsLayoutItem::geometry () const

Retourne la géométrie de l'élément (par exemple : la position et la taille) dans un QRectF. Cette fonction est équivalente à QRectF(pos(), size()).

Voir aussi setGeometry().

void QGraphicsLayoutItem::getContentsMargins ( qreal * left, qreal * top, qreal * right, qreal * bottom ) const [virtual]

Cette fonction virtuelle fournit les marges left, top, right et bottom pour ce QGraphicsLayoutItem. L'implémentation par défaut suppose que toutes les marges sont à 0. Les paramètres pointent sur des valeurs en qreal. Si l'un des pointeurs est 0, cette valeur ne va pas être mise à jour.

Voir aussi QGraphicsWidget::setContentsMargins().

QGraphicsItem * QGraphicsLayoutItem::graphicsItem () const

Retourne le QGraphicsItem que cet élément layout représente. Pour QGraphicsWidget cela va retourner lui-même. Pour un élément personnalisé, elle peut retourner une valeur agrégée.

Voir aussi setGraphicsItem().

bool QGraphicsLayoutItem::isLayout () const

Retourne true si ce QGraphicsLayoutItem est un layout (par exemple : il est hérité par un objet qui organise les autres objets QGraphicsLayoutItem) ; sinon retourne false.

Voir aussi QGraphicsLayout.

qreal QGraphicsLayoutItem::maximumHeight () const

Retourne la hauteur maximale.

Voir aussi setMaximumHeight(), setMaximumSize() et maximumSize().

QSizeF QGraphicsLayoutItem::maximumSize () const

Retourne la taille maximale.

Voir aussi setMaximumSize(), minimumSize(), preferredSize(), Qt::MaximumSize et sizeHint().

qreal QGraphicsLayoutItem::maximumWidth () const

Retourne la largeur maximale.

Voir aussi setMaximumWidth(), setMaximumSize() et maximumSize().

qreal QGraphicsLayoutItem::minimumHeight () const

Retourne la hauteur minimale.

Voir aussi setMinimumHeight(), setMinimumSize() et minimumSize().

QSizeF QGraphicsLayoutItem::minimumSize () const

Retourne la taille minimale.

Voir aussi setMinimumSize(), preferredSize(), maximumSize(), Qt::MinimumSize et sizeHint().

qreal QGraphicsLayoutItem::minimumWidth () const

Retourne la largeur minimale.

Voir aussi setMinimumWidth(), setMinimumSize() et minimumSize().

bool QGraphicsLayoutItem::ownedByLayout () const

Retourne si un layout doit détruire cet élément dans son destructeur. Si c'est true, alors le layout va le détruire. Si c'est false, alors il suppose qu'un autre objet est le propriétaire et donc ne va pas détruire l'élément.

Si l'élément hérite de QGraphicsItem et de QGraphicsLayoutItem (comme le fait QGraphicsWidget) l'élément fait vraiment partie de deux hiérarchies. Cette propriété indique ce que le layout devrait faire avec ses éléments enfants lors de sa destruction. Dans le cas du QGraphicsWidget, il est préféré que lors de la destruction du layout, il ne détruise pas ses enfants (car ils font aussi partie de la hiérarchie graphique).

Par défaut cette valeur est initialisée à false dans QGraphicsLayoutItem mais est surchargée par QGraphicsLayout pour retourner true, car QGraphicsLayout n'est normalement pas dans la hiérarchie des QGraphicsItem. Donc le layout parent devrait le détruire. Les sous-classes peuvent surcharger ce comportement par défaut en appelant setOwnedByLayout(true).

Cette fonction a été introduite dans Qt 4.6.

Voir aussi setOwnedByLayout().

QGraphicsLayoutItem * QGraphicsLayoutItem::parentLayoutItem () const

Retourne le parent de ce QGraphicsLayoutItem ou 0 s'il n'y a pas de parent ou si le parent n'hérite pas de QGraphicsLayoutItem (QGraphicsLayoutItem est souvent utilisé à travers plusieurs héritages avec des classes dérivées de QObject).

Voir aussi setParentLayoutItem().

qreal QGraphicsLayoutItem::preferredHeight () const

Retourne la hauteur privilégiée.

Voir aussi setPreferredHeight(), setPreferredSize() et preferredSize().

QSizeF QGraphicsLayoutItem::preferredSize () const

Retourne la taille privilégiée.

Voir aussi setPreferredSize(), minimumSize(), maximumSize(), Qt::PreferredSize et sizeHint().

qreal QGraphicsLayoutItem::preferredWidth () const

Retourne la largeur privilégiée.

Voir aussi setPreferredWidth(), setPreferredSize() et preferredSize().

void QGraphicsLayoutItem::setGeometry ( const QRectF & rect ) [virtual]

Cette fonction virtuelle définit la géométrie du QGraphicsLayoutItem à rect, qui est compris dans l'espace de coordonnées du parent (par exemple : le coin supérieur gauche de rect est équivalent à la position de l'élément dans l'espace de coordonnées du parent).

Vous devez réimplementer cette fonction dans les sous-classes de QGraphicsLayoutItem pour recevoir les mises à jour des géométries. Le layout va appeler cette fonction lorsqu'il réarrange.

Si rect est en dehors des limites de minimumSize et de maximumSize, il va être redimensionné à la taille la plus proche pour correspondre aux limites.

Voir aussi geometry().

void QGraphicsLayoutItem::setGraphicsItem ( QGraphicsItem * item ) [protected]

Si le QGraphicsLayoutItem représente un QGraphicsItem et qu'il veut utiliser les avantages de la redéfinition automatique des parents du QGraphicsLayout alors il devrait définir cette valeur. Notez que si vous supprimez l'élément item et que vous ne supprimez pas l'élément layout, vous êtes responsable de l'appel à setGraphicsItem(0) afin d'éviter un pointeur invalide.

Voir aussi graphicsItem().

void QGraphicsLayoutItem::setMaximumHeight ( qreal height )

Définit la hauteur maximale à height.

Voir aussi maximumHeight(), setMaximumSize() et maximumSize().

void QGraphicsLayoutItem::setMaximumSize ( const QSizeF & size )

Définit la taille maximale à size. La propriété surcharge sizeHint() pour Qt::MaximumSize et assure que effectiveSizeHint() ne va jamais retourner une taille plus grande que size. Pour retirer une taille maximale, utilisez une taille invalide.

Voir aussi maximumSize(), minimumSize(), preferredSize(), Qt::MaximumSize et sizeHint().

void QGraphicsLayoutItem::setMaximumSize ( qreal w, qreal h )

Cette fonction de commodité équivaut à appeler setMaximumSize(QSizeF(w, h)).

Voir aussi maximumSize(), setMinimumSize(), setPreferredSize() et sizeHint().

void QGraphicsLayoutItem::setMaximumWidth ( qreal width )

Définit la largeur maximale à width.

Voir aussi maximumWidth(), setMaximumSize() et maximumSize().

void QGraphicsLayoutItem::setMinimumHeight ( qreal height )

Définit la hauteur minimale à height.

Voir aussi minimumHeight(), setMinimumSize() et minimumSize().

void QGraphicsLayoutItem::setMinimumSize ( const QSizeF & size )

Définit la taille minimale à size. La propriété surcharge sizeHint() pour Qt::MinimumSize et assure que effectiveSizeHint() ne va jamais retourner une taille plus petite que size. Pour enlever la taille minimale, utilisez une taille invalide.

Voir aussi minimumSize(), maximumSize(), preferredSize(), Qt::MinimumSize, sizeHint(), setMinimumWidth() et setMinimumHeight().

void QGraphicsLayoutItem::setMinimumSize ( qreal w, qreal h )

Cette fonction de commodité équivaut à appeler setMinimumSize(QSizeF(w, h)).

Voir aussi minimumSize(), setMaximumSize(), setPreferredSize() et sizeHint().

void QGraphicsLayoutItem::setMinimumWidth ( qreal width )

Définit la largeur minimale à width.

Voir aussi minimumWidth(), setMinimumSize() et minimumSize().

void QGraphicsLayoutItem::setOwnedByLayout ( bool ownership ) [protected]

Définit si un layout doit détruire ou non cet élément dans son destructeur. ownership doit être à true pour ordonner au layout de détruire cet élément.

Cette fonction a été introduite dans Qt 4.6.

Voir aussi ownedByLayout().

void QGraphicsLayoutItem::setParentLayoutItem ( QGraphicsLayoutItem * parent )

Définit le parent de ce QGraphicsLayoutItem à parent.

Voir aussi parentLayoutItem().

void QGraphicsLayoutItem::setPreferredHeight ( qreal height )

Définit la hauteur privilégiée à height.

Voir aussi preferredHeight(), preferredWidth(), setPreferredSize() et preferredSize().

void QGraphicsLayoutItem::setPreferredSize ( const QSizeF & size )

Définit la taille privilégiée à size. La propriété surcharge sizeHint() pour Qt::PreferredSize et fournit une valeur par défaut pour effectiveSizeHint(). Pour enlever la taille privilégiée, utilisez une taille invalide.

Voir aussi preferredSize(), minimumSize(), maximumSize(), Qt::PreferredSize et sizeHint().

void QGraphicsLayoutItem::setPreferredSize ( qreal w, qreal h )

Cette fonction de commodité équivaut à appeler setPreferredSize(QSizeF(w, h)).

Voir aussi preferredSize(), setMaximumSize(), setMinimumSize() et sizeHint().

void QGraphicsLayoutItem::setPreferredWidth ( qreal width )

Définit la largeur privilégiée à width.

Voir aussi preferredWidth(), preferredHeight(), setPreferredSize() et preferredSize().

void QGraphicsLayoutItem::setSizePolicy ( const QSizePolicy & policy )

Définit la politique de dimensionnement à policy. La politique de dimensionnement décrit la façon dont les éléments doivent s'agrandir horizontalement ou verticalement lorsqu'ils sont organisés par le layout.

La politique de dimensionnement par défaut de QGraphicsLayoutItem est (QSizePolicy::Fixed, QSizePolicy::Fixed, QSizePolicy::DefaultType) mais il est d'usage pour les sous-classes de changer cette valeur par défaut. Par exemple, QGraphicsWidget utilise (QSizePolicy::Preferred, QSizePolicy::Preferred, QSizePolicy::DefaultType).

Voir aussi sizePolicy() et QWidget::sizePolicy().

void QGraphicsLayoutItem::setSizePolicy ( QSizePolicy::Policy hPolicy, QSizePolicy::Policy vPolicy, QSizePolicy::ControlType controlType = QSizePolicy::DefaultType )

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

Cette fonction équivaut à appeler setSizePolicy(QSizePolicy(hPolicy, vPolicy, controlType)).

Voir aussi sizePolicy() et QWidget::sizePolicy().

QSizeF QGraphicsLayoutItem::sizeHint ( Qt::SizeHint which, const QSizeF & constraint = QSizeF() ) const [pure virtual protected]

Cette fonction virtuelle retourne la taille conseillée du QGraphicsLayoutItem pour which, en utilisant la largeur et hauteur constraint pour contraindre la valeur retournée.

Réimplementez cette fonction dans une sous-classe de QGraphicsLayoutItem pour fournir les tailles conseillées nécessaires pour vos éléments.

Voir aussi effectiveSizeHint().

QSizePolicy QGraphicsLayoutItem::sizePolicy () const

Retourne la politique de dimensionnement actuelle.

Voir aussi setSizePolicy() et QWidget::sizePolicy().

void QGraphicsLayoutItem::updateGeometry () [virtual]

Cette fonction virtuelle annule toutes les tailles conseillées auparavant mises en cache. Vous devez toujours appeler cette fonction si vous modifiez la valeur de retour de la fonction sizeHint(). Les sous-classes doivent toujours appeler l'implémentation de base lors de la réimplémentation de cette fonction.

Voir aussi effectiveSizeHint().

Remerciements

Merci à Alexandre Laurent pour la traduction ainsi qu'à Jonathan Courtois et Claude Leloup pour leur relecture !