Sur cette page

QGraphicsProxyWidget Class

La classe QGraphicsProxyWidget fournit une couche proxy pour intégrer une page QWidget dans une page QGraphicsScene. Plus....

En-tête : #include <QGraphicsProxyWidget>
CMake : find_package(Qt6 REQUIRED COMPONENTS Widgets)
target_link_libraries(mytarget PRIVATE Qt6::Widgets)
qmake : QT += widgets
Héritages : QGraphicsWidget

Types publics

enum { Type }

Fonctions publiques

QGraphicsProxyWidget(QGraphicsItem *parent = nullptr, Qt::WindowFlags wFlags = Qt::WindowFlags())
virtual ~QGraphicsProxyWidget()
QGraphicsProxyWidget *createProxyForChildWidget(QWidget *child)
void setWidget(QWidget *widget)
QRectF subWidgetRect(const QWidget *widget) const
QWidget *widget() const

Fonctions publiques réimplémentées

virtual void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget) override
virtual void setGeometry(const QRectF &rect) override
virtual int type() const override

Fonctions protégées réimplémentées

virtual void contextMenuEvent(QGraphicsSceneContextMenuEvent *event) override
virtual void dragEnterEvent(QGraphicsSceneDragDropEvent *event) override
virtual void dragLeaveEvent(QGraphicsSceneDragDropEvent *event) override
virtual void dragMoveEvent(QGraphicsSceneDragDropEvent *event) override
virtual void dropEvent(QGraphicsSceneDragDropEvent *event) override
virtual bool event(QEvent *event) override
virtual bool eventFilter(QObject *object, QEvent *event) override
virtual void focusInEvent(QFocusEvent *event) override
virtual bool focusNextPrevChild(bool next) override
virtual void focusOutEvent(QFocusEvent *event) override
virtual void grabMouseEvent(QEvent *event) override
virtual void hideEvent(QHideEvent *event) override
virtual void hoverEnterEvent(QGraphicsSceneHoverEvent *event) override
virtual void hoverLeaveEvent(QGraphicsSceneHoverEvent *event) override
virtual void hoverMoveEvent(QGraphicsSceneHoverEvent *event) override
virtual void inputMethodEvent(QInputMethodEvent *event) override
virtual QVariant inputMethodQuery(Qt::InputMethodQuery query) const override
virtual QVariant itemChange(QGraphicsItem::GraphicsItemChange change, const QVariant &value) override
virtual void keyPressEvent(QKeyEvent *event) override
virtual void keyReleaseEvent(QKeyEvent *event) override
virtual void mouseDoubleClickEvent(QGraphicsSceneMouseEvent *event) override
virtual void mouseMoveEvent(QGraphicsSceneMouseEvent *event) override
virtual void mousePressEvent(QGraphicsSceneMouseEvent *event) override
virtual void mouseReleaseEvent(QGraphicsSceneMouseEvent *event) override
virtual void resizeEvent(QGraphicsSceneResizeEvent *event) override
virtual void showEvent(QShowEvent *event) override
virtual QSizeF sizeHint(Qt::SizeHint which, const QSizeF &constraint = QSizeF()) const override
virtual void ungrabMouseEvent(QEvent *event) override
virtual void wheelEvent(QGraphicsSceneWheelEvent *event) override

Emplacements protégés

QGraphicsProxyWidget *newProxyWidget(const QWidget *child)

Description détaillée

QGraphicsProxyWidget intègre des widgets basés sur QWidget, par exemple, un QPushButton, QFontComboBox, ou même QFileDialog, dans QGraphicsScene. Il transmet les événements entre les deux objets et traduit la géométrie basée sur les nombres entiers de QWidget en géométrie basée sur les nombres réels de QGraphicsWidget. QGraphicsProxyWidget prend en charge toutes les fonctionnalités de base de QWidget, y compris la focalisation sur les onglets, la saisie au clavier, le glisser-déposer et les fenêtres contextuelles. Vous pouvez également intégrer des widgets complexes, par exemple des widgets avec des sous-widgets.

Exemple :

int main(int argc, char **argv)
{
    QApplication app(argc, argv);

    QTabWidget *tabWidget = new QTabWidget;

    QGraphicsScene scene;
    QGraphicsProxyWidget *proxy = scene.addWidget(tabWidget);

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

    return app.exec();
}

QGraphicsProxyWidget se charge d'intégrer automatiquement les fenêtres contextuelles des widgets intégrés en créant un proxy enfant pour chaque fenêtre contextuelle. Cela signifie que lorsqu'un widget intégré QComboBox affiche sa liste de fenêtres contextuelles, un nouveau QGraphicsProxyWidget est créé automatiquement, intégrant la fenêtre contextuelle et la positionnant correctement. Cela ne fonctionne que si la fenêtre contextuelle est un enfant du widget intégré (par exemple, QToolButton::setMenu() exige que l'instance QMenu soit un enfant de QToolButton).

Intégration d'un widget avec QGraphicsProxyWidget

Il existe deux façons d'intégrer un widget à l'aide de QGraphicsProxyWidget. La méthode la plus courante consiste à transmettre un pointeur de widget à QGraphicsScene::addWidget() ainsi que toute information pertinente à Qt::WindowFlags. Cette fonction renvoie un pointeur vers un QGraphicsProxyWidget. Vous pouvez alors choisir de répartir ou de positionner soit le proxy, soit le widget intégré lui-même.

Par exemple, dans l'extrait de code ci-dessous, nous intégrons une boîte de groupe dans le proxy :

QGroupBox *groupBox = new QGroupBox("Contact Details");
QLabel *numberLabel = new QLabel("Telephone number");
QLineEdit *numberEdit = new QLineEdit;

QFormLayout *layout = new QFormLayout(groupBox);
layout->addRow(numberLabel, numberEdit);

QGraphicsScene scene;
QGraphicsProxyWidget *proxy = scene.addWidget(groupBox);

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

L'image ci-dessous est le résultat obtenu avec sa marge de contenu et son rectangle de contenu étiquetés.

widget proxy et widget intégré avec leurs positions

Vous pouvez également commencer par créer un nouvel élément QGraphicsProxyWidget, puis appeler setWidget() pour intégrer un QWidget plus tard. La fonction widget() renvoie un pointeur vers le widget intégré. QGraphicsProxyWidget partage la propriété avec QWidget, de sorte que si l'un des deux widgets est détruit, l'autre widget sera automatiquement détruit aussi.

Synchronisation des états des widgets

QGraphicsProxyWidget synchronise son état avec celui du widget intégré. Par exemple, si le proxy est caché ou désactivé, le widget incorporé sera également caché ou désactivé, et vice versa. Lorsque le widget est incorporé en appelant addWidget(), QGraphicsProxyWidget copie l'état du widget dans le proxy, et par la suite, les deux resteront synchronisés dans la mesure du possible. Par défaut, lorsque vous intégrez un widget dans un proxy, le widget et le proxy sont visibles car QGraphicsWidget est visible dès sa création (vous n'avez pas besoin d'appeler show()). Si vous cachez explicitement le widget incorporé, le proxy deviendra également invisible.

Exemple :

QGraphicsScene scene;

QLineEdit *edit = new QLineEdit;
QGraphicsProxyWidget *proxy = scene.addWidget(edit);

edit->isVisible();  // returns true
proxy->isVisible(); // also returns true

edit->hide();

edit->isVisible();  // returns false
proxy->isVisible(); // also returns false

QGraphicsProxyWidget maintient la symétrie pour les états suivants :

QWidget étatQGraphicsProxyWidget étatNotes
QWidget::enabledQGraphicsProxyWidget::enabled
QWidget::visibleQGraphicsProxyWidget::visibleL'état explicite est également symétrique.
QWidget::geometryQGraphicsProxyWidget::geometryLa symétrie de la géométrie n'est garantie que lorsque le widget intégré est visible.
QWidget::layoutDirectionQGraphicsProxyWidget::layoutDirection
QWidget::styleQGraphicsProxyWidget::style
QWidget::paletteQGraphicsProxyWidget::palette
QWidget::fontQGraphicsProxyWidget::font
QWidget::cursorQGraphicsProxyWidget::curseurLe widget intégré remplace le curseur du widget proxy. Le curseur du proxy change en fonction du sous-budget intégré qui se trouve actuellement sous la souris.
QWidget::sizeHint()QGraphicsProxyWidget::sizeHint()Toutes les fonctionnalités d'indication de taille du widget intégré sont transmises par le proxy.
QWidget::getContentsMargins()QGraphicsProxyWidget::getContentsMargins()Mis à jour une fois par setWidget().
QWidget::windowTitleQGraphicsProxyWidget::windowTitleMis à jour une fois par setWidget().

Note : QGraphicsScene maintient le widget incorporé dans un état spécial qui l'empêche de perturber les autres widgets (incorporés ou non) pendant que le widget est incorporé. Dans cet état, le widget peut avoir un comportement légèrement différent de celui qu'il a lorsqu'il n'est pas incorporé.

Attention : Cette classe est fournie pour des raisons de commodité lorsqu'il s'agit de relier QWidgets et QGraphicsItems ; elle ne doit pas être utilisée pour des scénarios de haute performance. En particulier, l'intégration de widgets dans une scène qui est ensuite affichée par l'intermédiaire d'un site QGraphicsView qui utilise une fenêtre OpenGL ne fonctionnera pas pour toutes les combinaisons.

Voir également QGraphicsScene::addWidget() et QGraphicsWidget.

Documentation sur les types de membres

[anonymous] enum

Valeur renvoyée par la fonction virtuelle type().

ConstanteValeurDescription de l'objet
QGraphicsProxyWidget::Type12Un widget proxy graphique

Documentation des fonctions membres

QGraphicsProxyWidget::QGraphicsProxyWidget(QGraphicsItem *parent = nullptr, Qt::WindowFlags wFlags = Qt::WindowFlags())

Construit un nouveau widget QGraphicsProxy. parent et wFlags sont transmis au constructeur de QGraphicsItem.

[virtual noexcept] QGraphicsProxyWidget::~QGraphicsProxyWidget()

Détruit le widget proxy et tout widget intégré.

[override virtual protected] void QGraphicsProxyWidget::contextMenuEvent(QGraphicsSceneContextMenuEvent *event)

Réimplémente : QGraphicsItem::contextMenuEvent(QGraphicsSceneContextMenuEvent *event).

QGraphicsProxyWidget *QGraphicsProxyWidget::createProxyForChildWidget(QWidget *child)

Crée un widget proxy pour l'adresse child du widget contenu dans ce proxy.

Cette fonction permet d'acquérir des mandataires pour des widgets qui ne sont pas de niveau supérieur. Par exemple, vous pouvez intégrer un dialogue et ne transformer qu'un seul de ses widgets.

Si le widget est déjà intégré, la fonction renvoie le widget proxy existant.

Voir également newProxyWidget() et QGraphicsScene::addWidget().

[override virtual protected] void QGraphicsProxyWidget::dragEnterEvent(QGraphicsSceneDragDropEvent *event)

Réimplémente : QGraphicsItem::dragEnterEvent(QGraphicsSceneDragDropEvent *event).

[override virtual protected] void QGraphicsProxyWidget::dragLeaveEvent(QGraphicsSceneDragDropEvent *event)

Réimplémente : QGraphicsItem::dragLeaveEvent(QGraphicsSceneDragDropEvent *event).

[override virtual protected] void QGraphicsProxyWidget::dragMoveEvent(QGraphicsSceneDragDropEvent *event)

Réimplémente : QGraphicsItem::dragMoveEvent(QGraphicsSceneDragDropEvent *event).

[override virtual protected] void QGraphicsProxyWidget::dropEvent(QGraphicsSceneDragDropEvent *event)

Réimplémente : QGraphicsItem::dropEvent(QGraphicsSceneDragDropEvent *event).

[override virtual protected] bool QGraphicsProxyWidget::event(QEvent *event)

Réimplémente : QGraphicsWidget::event(QEvent *event).

[override virtual protected] bool QGraphicsProxyWidget::eventFilter(QObject *object, QEvent *event)

Réimplémente : QObject::eventFilter(QObject *watched, QEvent *event).

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

Réimplémente : QGraphicsWidget::focusInEvent(QFocusEvent *event).

[override virtual protected] bool QGraphicsProxyWidget::focusNextPrevChild(bool next)

Réimplémente : QGraphicsWidget::focusNextPrevChild(bool next).

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

Réimplémente : QGraphicsWidget::focusOutEvent(QFocusEvent *event).

[override virtual protected] void QGraphicsProxyWidget::grabMouseEvent(QEvent *event)

Réimplémente : QGraphicsWidget::grabMouseEvent(QEvent *event).

[override virtual protected] void QGraphicsProxyWidget::hideEvent(QHideEvent *event)

Réimplémente : QGraphicsWidget::hideEvent(QHideEvent *event).

[override virtual protected] void QGraphicsProxyWidget::hoverEnterEvent(QGraphicsSceneHoverEvent *event)

Réimplémente : QGraphicsItem::hoverEnterEvent(QGraphicsSceneHoverEvent *event).

[override virtual protected] void QGraphicsProxyWidget::hoverLeaveEvent(QGraphicsSceneHoverEvent *event)

Réimplémente : QGraphicsWidget::hoverLeaveEvent(QGraphicsSceneHoverEvent *event).

[override virtual protected] void QGraphicsProxyWidget::hoverMoveEvent(QGraphicsSceneHoverEvent *event)

Réimplémente : QGraphicsWidget::hoverMoveEvent(QGraphicsSceneHoverEvent *event).

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

Réimplémente : QGraphicsItem::inputMethodEvent(QInputMethodEvent *event).

[override virtual protected] QVariant QGraphicsProxyWidget::inputMethodQuery(Qt::InputMethodQuery query) const

Réimplémente : QGraphicsItem::inputMethodQuery(Qt::InputMethodQuery query) const.

[override virtual protected] QVariant QGraphicsProxyWidget::itemChange(QGraphicsItem::GraphicsItemChange change, const QVariant &value)

Réimplémente : QGraphicsWidget::itemChange(QGraphicsItem::GraphicsItemChange change, const QVariant &value).

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

Réimplémente : QGraphicsItem::keyPressEvent(QKeyEvent *event).

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

Réimplémente : QGraphicsItem::keyReleaseEvent(QKeyEvent *event).

[override virtual protected] void QGraphicsProxyWidget::mouseDoubleClickEvent(QGraphicsSceneMouseEvent *event)

Réimplémente : QGraphicsItem::mouseDoubleClickEvent(QGraphicsSceneMouseEvent *event).

[override virtual protected] void QGraphicsProxyWidget::mouseMoveEvent(QGraphicsSceneMouseEvent *event)

Réimplémente : QGraphicsItem::mouseMoveEvent(QGraphicsSceneMouseEvent *event).

[override virtual protected] void QGraphicsProxyWidget::mousePressEvent(QGraphicsSceneMouseEvent *event)

Réimplémente : QGraphicsItem::mousePressEvent(QGraphicsSceneMouseEvent *event).

[override virtual protected] void QGraphicsProxyWidget::mouseReleaseEvent(QGraphicsSceneMouseEvent *event)

Réimplémente : QGraphicsItem::mouseReleaseEvent(QGraphicsSceneMouseEvent *event).

[protected slot] QGraphicsProxyWidget *QGraphicsProxyWidget::newProxyWidget(const QWidget *child)

Crée un widget proxy pour l'adresse child du widget contenu dans ce proxy.

Vous ne devez pas appeler cette fonction directement ; utilisez plutôt QGraphicsProxyWidget::createProxyForChildWidget().

Cette fonction est un faux slot virtuel que vous pouvez réimplémenter dans votre sous-classe afin de contrôler la façon dont les nouveaux widgets proxy sont créés. L'implémentation par défaut renvoie un proxy créé avec le constructeur QGraphicsProxyWidget() avec ce widget proxy comme parent.

Voir aussi createProxyForChildWidget().

[override virtual] void QGraphicsProxyWidget::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)

Réimplémente : QGraphicsWidget::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget).

[override virtual protected] void QGraphicsProxyWidget::resizeEvent(QGraphicsSceneResizeEvent *event)

Réimplémente : QGraphicsWidget::resizeEvent(QGraphicsSceneResizeEvent *event).

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

Réimplémente : QGraphicsLayoutItem::setGeometry(const QRectF &rect).

void QGraphicsProxyWidget::setWidget(QWidget *widget)

Insère widget dans ce widget proxy. Le widget incorporé doit résider exclusivement à l'intérieur ou à l'extérieur de la vue graphique. Vous ne pouvez pas intégrer un widget tant qu'il est visible ailleurs dans l'interface utilisateur, au même moment.

widget doit être un widget de niveau supérieur dont le parent est nullptr.

Lorsque le widget est incorporé, son état (par exemple, visible, activé, géométrie, indices de taille) est copié dans le widget proxy. Si le widget incorporé est explicitement caché ou désactivé, le widget proxy deviendra explicitement caché ou désactivé une fois l'incorporation terminée. La documentation de la classe donne un aperçu complet de l'état partagé.

QGraphicsProxyWidgetLes drapeaux de fenêtre de la fonction déterminent si le widget, après l'intégration, recevra des décorations de fenêtre ou non.

Après le retour de cette fonction, QGraphicsProxyWidget gardera son état synchronisé avec celui de widget dans la mesure du possible.

Si un widget est déjà intégré par ce proxy lorsque cette fonction est appelée, ce widget sera d'abord automatiquement désimbriqué. Passer nullptr pour l'argument widget ne désencapsulera que le widget, et la propriété du widget actuellement encapsulé sera transmise à l'appelant. Tous les widgets enfants qui sont incorporés seront également incorporés et leur widget proxy sera détruit.

Notez que les widgets dont l'attribut Qt::WA_PaintOnScreen widget est défini et les widgets qui enveloppent une application ou un contrôleur externe ne peuvent pas être intégrés. Les exemples sont QOpenGLWidget et QAxWidget.

Voir également widget().

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

Réimplémente : QGraphicsWidget::showEvent(QShowEvent *event).

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

Réimplémente : QGraphicsWidget::sizeHint(Qt::SizeHint which, const QSizeF &constraint) const.

QRectF QGraphicsProxyWidget::subWidgetRect(const QWidget *widget) const

Renvoie le rectangle pour widget, qui doit être un descendant de widget(), ou widget() lui-même, dans les coordonnées locales de cet élément proxy.

Si aucun widget n'est intégré, si widget est nullptr ou si widget n'est pas un descendant du widget intégré, cette fonction renvoie un QRectF vide.

Voir aussi widget().

[override virtual] int QGraphicsProxyWidget::type() const

Réimplémente : QGraphicsWidget::type() const.

[override virtual protected] void QGraphicsProxyWidget::ungrabMouseEvent(QEvent *event)

Réimplémente : QGraphicsWidget::ungrabMouseEvent(QEvent *event).

[override virtual protected] void QGraphicsProxyWidget::wheelEvent(QGraphicsSceneWheelEvent *event)

Réimplémente : QGraphicsItem::wheelEvent(QGraphicsSceneWheelEvent *event).

QWidget *QGraphicsProxyWidget::widget() const

Renvoie un pointeur sur le widget intégré.

Voir également setWidget().

© 2026 The Qt Company Ltd. Documentation contributions included herein are the copyrights of their respective owners. The documentation provided herein is licensed under the terms of the GNU Free Documentation License version 1.3 as published by the Free Software Foundation. Qt and respective logos are trademarks of The Qt Company Ltd. in Finland and/or other countries worldwide. All other trademarks are property of their respective owners.