QWindow Class

Documentation des fonctions membres

[explicit] QWindow::QWindow(QScreen *targetScreen = nullptr)

Crée une fenêtre de niveau supérieur sur targetScreen.

La fenêtre n'est pas affichée tant que la fonction setVisible(true), show() ou une fonction similaire n'a pas été appelée.

Voir également setScreen().

[explicit] QWindow::QWindow(QWindow *parent)

Crée une fenêtre en tant que fenêtre fille de la fenêtre « parent » indiquée.

La fenêtre sera intégrée à l'intérieur de la fenêtre parente, ses coordonnées étant relatives à celles de la fenêtre parente.

L'écran est hérité de la fenêtre parente.

Voir aussi setParent().

[virtual noexcept] QWindow::~QWindow()

Supprime la fenêtre.

[slot] void QWindow::alert(int msec)

Affiche une alerte pendant msec millisecondes. Si la valeur de « msec » est « 0 » (valeur par défaut), l'alerte reste affichée indéfiniment jusqu'à ce que la fenêtre redevienne active. Cette fonction n'a aucun effet sur une fenêtre active.

En état d'alerte, la fenêtre indique qu'elle requiert une attention particulière, par exemple en faisant clignoter ou rebondir son icône dans la barre des tâches.

QSize QWindow::baseSize() const

Renvoie la taille de base de la fenêtre.

Voir aussi setBaseSize().

[slot] bool QWindow::close()

Fermez la fenêtre.

Cela ferme la fenêtre, ce qui revient à appeler destroy(), et peut entraîner la fermeture de l'application. Renvoie true en cas de succès, false s'il existe une fenêtre parente (auquel cas c'est la fenêtre de niveau supérieur qui doit être fermée à la place).

Voir également destroy(), QGuiApplication::quitOnLastWindowClosed() et closeEvent().

[virtual protected] void QWindow::closeEvent(QCloseEvent *ev)

Redéfinissez cette méthode pour gérer les événements de fermeture (ev).

Cette fonction est appelée lorsqu'une demande de fermeture de la fenêtre est émise. Appelez ` QEvent::ignore()` lors de l'événement si vous souhaitez empêcher la fermeture de la fenêtre.

Voir également close().

void QWindow::create()

Alloue les ressources de la plateforme associées à la fenêtre.

C'est à ce stade que le format de surface défini à l'aide de ` setFormat()` est converti en une surface native réelle. Cependant, la fenêtre reste masquée jusqu'à ce que ` setVisible()` soit appelée.

Notez qu’il n’est généralement pas nécessaire d’appeler cette fonction directement, car elle sera implicitement appelée par show(), setVisible(), winId() et d’autres fonctions nécessitant l’accès aux ressources de la plateforme.

Appelez destroy() pour libérer les ressources de la plateforme si nécessaire.

Voir également destroy().

QCursor QWindow::cursor() const

la forme du curseur pour cette fenêtre

Voir également setCursor() et unsetCursor().

void QWindow::destroy()

Libère les ressources natives de la plateforme associées à cette fenêtre.

Voir également create().

qreal QWindow::devicePixelRatio() const

Renvoie le rapport entre les pixels physiques et les pixels indépendants du périphérique pour la fenêtre. Cette valeur dépend de l'écran sur lequel se trouve la fenêtre et peut varier lorsque celle-ci est déplacée.

L'instance ` QWindow ` reçoit un événement de type ` QEvent::DevicePixelRatioChange ` lorsque le rapport de pixels de l'appareil change.

Les valeurs courantes sont 1,0 sur les écrans normaux et 2,0 sur les écrans « Retina » d’Apple.

Voir également QScreen::devicePixelRatio() et QEvent::DevicePixelRatioChange.

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

Réimplémente : QObject::event(QEvent *e).

Redéfinissez cette méthode pour gérer tout événement (ev) envoyé à la fenêtre. Renvoyez true si l'événement a été reconnu et traité.

N'oubliez pas d'appeler la version de la classe parente si vous souhaitez que les événements de souris, de clavier, de redimensionnement, etc. soient distribués comme d'habitude.

[virtual protected] void QWindow::exposeEvent(QExposeEvent *ev)

L'événement « expose » (ev) est émis par le système de fenêtres lorsqu'une fenêtre passe de l'état « non visible » à l'état « visible ».

Une fenêtre exposée est potentiellement visible par l'utilisateur. Si la fenêtre est déplacée hors de l'écran, si elle est entièrement masquée par une autre fenêtre, si elle est réduite ou dans une situation similaire, cette fonction peut être appelée et la valeur de isExposed() peut passer à false. Vous pouvez utiliser cet événement pour limiter les opérations coûteuses, telles que les animations, afin qu'elles ne s'exécutent que lorsque la fenêtre est exposée.

Cet événement ne doit pas être utilisé pour le dessin. Pour gérer le dessin, implémentez plutôt la fonction paintEvent().

Un événement de redimensionnement sera toujours envoyé avant l’événement d’exposition la première fois qu’une fenêtre s’affiche.

Voir également ` paintEvent()` et ` isExposed()`.

QString QWindow::filePath() const

le nom du fichier correspondant à cette fenêtre.

Voir aussi setFilePath().

[virtual protected] void QWindow::focusInEvent(QFocusEvent *ev)

Redéfinissez cette méthode pour gérer le focus dans les événements (ev).

Les événements de focus sont déclenchés lorsque la fenêtre reçoit le focus du clavier.

Voir également focusOutEvent().

[virtual] QObject *QWindow::focusObject() const

Renvoie l'QObject, qui sera le destinataire final des événements liés au focus, tels que les événements liés aux touches.

[signal] void QWindow::focusObjectChanged(QObject *object)

Ce signal est émis lorsque le destinataire final des événements liés au focus est remplacé par object.

Voir également focusObject().

[virtual protected] void QWindow::focusOutEvent(QFocusEvent *ev)

Redéfinissez cette méthode pour gérer les événements de perte de focus (ev).

Les événements de perte de focus sont envoyés lorsque la fenêtre perd le focus du clavier.

Voir également focusInEvent().

[override virtual] QSurfaceFormat QWindow::format() const

Réimplémente : ` QSurface::format()` const.

Renvoie le format réel de cette fenêtre.

Une fois la fenêtre créée, cette fonction renvoie le format de surface réel de la fenêtre. Il peut différer du format demandé si ce dernier n’a pas pu être pris en charge par la plate-forme. Il peut également s’agir d’un sur-ensemble ; par exemple, certaines tailles de tampon peuvent être supérieures à celles demandées.

Voir également setFormat(), create(), requestedFormat() et QOpenGLContext::format().

QRect QWindow::frameGeometry() const

Renvoie la géométrie de la fenêtre, y compris son cadre.

La géométrie est relative à la fonction virtualGeometry() de son écran.

Voir également geometry() et frameMargins().

QMargins QWindow::frameMargins() const

Renvoie les marges du cadre de la fenêtre qui l'entourent.

Voir également geometry() et frameGeometry().

QPoint QWindow::framePosition() const

Renvoie la position du coin supérieur gauche de la fenêtre, cadre de la fenêtre compris.

Cette fonction renvoie la même valeur que ` frameGeometry()`.topLeft().

Voir également setFramePosition(), geometry() et frameGeometry().

[static] QWindow *QWindow::fromWinId(WId id)

Crée une représentation locale d'une fenêtre créée par un autre processus ou à l'aide de bibliothèques natives sous Qt.

À partir du descripteur id d'une fenêtre native, cette méthode crée un objet QWindow qui peut être utilisé pour représenter la fenêtre lors de l'appel de méthodes telles que setParent() et setTransientParent().

Sur les plateformes qui le prennent en charge, cette méthode permet d’intégrer un objet ` QWindow ` dans une fenêtre native, ou d’intégrer une fenêtre native dans un objet ` QWindow`.

Si les fenêtres étrangères ne sont pas prises en charge ou si l’intégration de la fenêtre native a échoué dans le plugin de la plateforme, cette fonction renvoie nullptr.

Voir aussi ` setParent()`.

QRect QWindow::geometry() const

Renvoie la géométrie de la fenêtre, à l'exclusion de son cadre.

La géométrie est définie par rapport à la fonction `virtualGeometry()` de son écran.

Voir également setGeometry(), frameMargins() et frameGeometry().

[slot] void QWindow::hide()

Masque la fenêtre.

Équivaut à l'appel de ` setVisible(false)`.

Voir également show() et setVisible().

[virtual protected] void QWindow::hideEvent(QHideEvent *ev)

Redéfinissez cette fonction pour gérer les événements de masquage (ev).

La fonction est appelée lorsque la fenêtre a demandé à être masquée dans le système de gestion des fenêtres.

QIcon QWindow::icon() const

Renvoie l'icône de la fenêtre dans le système de gestion des fenêtres

Voir aussi setIcon().

bool QWindow::isActive() const

Renvoie « true » si la fenêtre est active.

C'est le cas de la fenêtre qui a le focus, ainsi que des fenêtres qui se trouvent dans la même chaîne parent / parent transitoire que la fenêtre active.

En règle générale, les fenêtres actives doivent apparaître comme telles d’un point de vue stylistique.

Pour obtenir la fenêtre qui a actuellement le focus, utilisez QGuiApplication::focusWindow().

Voir également requestActivate().

bool QWindow::isAncestorOf(const QWindow *child, QWindow::AncestorMode mode = IncludeTransients) const

Renvoie ` true ` si la fenêtre est un ancêtre de l'child` donné. Si ` mode ` est ` IncludeTransients`, les parents transitoires sont également considérés comme des ancêtres.

bool QWindow::isExposed() const

Renvoie une valeur indiquant si cette fenêtre est visible dans le système de gestion des fenêtres.

Lorsque la fenêtre n'est pas exposée, elle est affichée par l'application mais n'apparaît toujours pas dans le système de fenêtrage ; l'application doit donc réduire au minimum les animations et autres activités graphiques.

Un message « exposeEvent() » est envoyé chaque fois que cette valeur change.

Voir également exposeEvent().

bool QWindow::isModal() const

Indique si la fenêtre est modale.

Une fenêtre modale empêche les autres fenêtres de recevoir des entrées.

Voir aussi QWindow::modality.

bool QWindow::isTopLevel() const

Indique si la fenêtre est de niveau supérieur, c'est-à-dire si elle n'a pas de fenêtre parente.

[virtual protected] void QWindow::keyPressEvent(QKeyEvent *ev)

Redéfinissez cette méthode pour gérer les événements liés à la pression d'une touche (ev).

Voir également keyReleaseEvent().

[virtual protected] void QWindow::keyReleaseEvent(QKeyEvent *ev)

Redéfinissez cette méthode pour gérer les événements de relâchement de touche (ev).

Voir également keyPressEvent().

[slot] void QWindow::lower()

Déplacer la fenêtre vers le bas dans le système de gestion des fenêtres.

Demande que la fenêtre soit placée en arrière-plan afin d'apparaître sous les autres fenêtres.

[since 6.0] QPointF QWindow::mapFromGlobal(const QPointF &pos) const

Convertit les coordonnées globales de l'écran pos en coordonnées de la fenêtre.

Cette fonction a été introduite dans Qt 6.0.

Voir également mapToGlobal().

QPoint QWindow::mapFromGlobal(const QPoint &pos) const

[since 6.0] QPointF QWindow::mapToGlobal(const QPointF &pos) const

Convertit les coordonnées de la fenêtre pos en coordonnées globales de l'écran. Par exemple, la fonction ` mapToGlobal(QPointF(0,0)) ` renvoie les coordonnées globales du pixel situé en haut à gauche de la fenêtre.

Cette fonction a été introduite dans Qt 6.0.

Voir également mapFromGlobal().

QPoint QWindow::mapToGlobal(const QPoint &pos) const

QRegion QWindow::mask() const

Renvoie le masque défini sur la fenêtre.

Le masque indique au système de gestion des fenêtres que l'application ne souhaite pas recevoir d'entrée souris ou tactile en dehors de la zone spécifiée.

Voir également setMask().

QSize QWindow::maximumSize() const

Renvoie la taille maximale de la fenêtre.

Voir aussi setMaximumSize().

QSize QWindow::minimumSize() const

Renvoie la taille minimale de la fenêtre.

Voir aussi setMinimumSize().

[signal] void QWindow::modalityChanged(Qt::WindowModality modality)

Ce signal est émis lorsque la propriété Qwindow::modality prend la valeur « modality ».

[virtual protected] void QWindow::mouseDoubleClickEvent(QMouseEvent *ev)

Redéfinissez cette méthode pour gérer les événements de double-clic de la souris (ev).

Voir également mousePressEvent() et QStyleHints::mouseDoubleClickInterval().

[virtual protected] void QWindow::mouseMoveEvent(QMouseEvent *ev)

Redéfinissez cette méthode pour gérer les événements de déplacement de la souris (ev).

[virtual protected] void QWindow::mousePressEvent(QMouseEvent *ev)

Redéfinissez cette méthode pour gérer les événements de clic de souris (ev).

Voir également mouseReleaseEvent().

[virtual protected] void QWindow::mouseReleaseEvent(QMouseEvent *ev)

Redéfinissez cette méthode pour gérer les événements de relâchement de la souris (ev).

Voir également mousePressEvent().

[virtual protected] void QWindow::moveEvent(QMoveEvent *ev)

Redéfinissez cette méthode pour gérer les événements de déplacement de la fenêtre (ev).

[virtual protected] bool QWindow::nativeEvent(const QByteArray &eventType, void *message, qintptr *result)

Redéfinissez cette méthode pour gérer les événements spécifiques à la plateforme. Elle recevra les objets suivants : eventType, message et result.

Cela pourrait rendre votre application non portable.

Ne doit renvoyer « true » que si l'événement a été géré.

[virtual protected, since 6.0] void QWindow::paintEvent(QPaintEvent *ev)

L'événement « paint » (ev) est envoyé par le système de fenêtrage chaque fois qu'une zone de la fenêtre doit être rafraîchie, par exemple lors de l'affichage initial de la fenêtre, ou lorsque certaines parties de celle-ci sont révélées à la suite du déplacement d'une autre fenêtre.

L'application est censée effectuer le rendu dans la fenêtre en réponse à l'événement « paint », quel que soit l'état d'exposition de la fenêtre. Par exemple, un événement « paint » peut être envoyé avant que la fenêtre ne soit exposée, afin de la préparer à être affichée à l'utilisateur.

Cette fonction a été introduite dans Qt 6.0.

Voir également ` exposeEvent()`.

QWindow *QWindow::parent(QWindow::AncestorMode mode = ExcludeTransients) const

Renvoie la fenêtre parente, le cas échéant.

Si ` mode ` est défini sur ` IncludeTransients`, la fenêtre parent transitoire est renvoyée s'il n'y a pas de fenêtre parent.

Une fenêtre sans fenêtre parente est appelée « fenêtre de niveau supérieur ».

Voir aussi ` setParent()`.

QPoint QWindow::position() const

Renvoie la position de la fenêtre sur le bureau, sans tenir compte du cadre de la fenêtre

Voir également setPosition().

[slot] void QWindow::raise()

Afficher la fenêtre au premier plan dans le système de gestion des fenêtres.

Demande que la fenêtre soit placée au premier plan afin qu'elle apparaisse au-dessus des autres fenêtres.

[slot] void QWindow::requestActivate()

Demande que la fenêtre soit activée, c'est-à-dire qu'elle reçoive le focus du clavier.

Voir également isActive() et QGuiApplication::focusWindow().

[slot] void QWindow::requestUpdate()

Planifie la diffusion d'un événement « QEvent::UpdateRequest » vers cette fenêtre.

L’événement est transmis en synchronisation avec le vsync de l’affichage sur les plateformes où cela est possible. Sinon, l’événement est transmis après un délai maximal de 5 ms. Si l’écran associé à la fenêtre signale une fréquence de rafraîchissement ( refresh rate ) supérieure à 60 Hz, l’intervalle est réduit à une valeur inférieure à 5. Ce délai supplémentaire sert à accorder à la boucle d’événements un peu de temps d’inactivité pour collecter les événements système ; il peut être redéfini à l’aide de la variable d’environnement QT_QPA_UPDATE_IDLE_TIME.

Lors du pilotage d’animations, cette fonction doit être appelée une seule fois une fois le dessin terminé. Appeler cette fonction plusieurs fois entraînera l’envoi d’un seul événement à la fenêtre.

Les sous-classes de ` QWindow ` doivent réimplémenter ` event()` : elles doivent intercepter l’événement, appeler le code de rendu de l’application, puis appeler l’implémentation de la classe de base.

QSurfaceFormat QWindow::requestedFormat() const

Renvoie le format de surface demandé pour cette fenêtre.

Si le format demandé n'est pas pris en charge par l'implémentation de la plate-forme, le format demandé (requestedFormat) sera différent du format réel de la fenêtre.

Il s'agit de la valeur définie avec la fonction ` setFormat()`.

Voir également setFormat() et format().

void QWindow::resize(const QSize &newSize)

définir la taille de la fenêtre, sans tenir compte du cadre, à newSize

Voir également size() et geometry().

void QWindow::resize(int w, int h)

définit la taille de la fenêtre, hors cadre, en utilisant un objet ` QSize ` construit à partir de la largeur ` w ` et de la hauteur h

Pour redimensionner les fenêtres de manière interactive, voir startSystemResize().

Voir également size() et geometry().

[virtual protected] void QWindow::resizeEvent(QResizeEvent *ev)

Redéfinissez cette méthode pour gérer les événements de redimensionnement (ev).

L'événement de redimensionnement est déclenché chaque fois que la fenêtre est redimensionnée dans le système de fenêtrage, soit directement lorsque le système de fenêtrage répond à une requête de type ` setGeometry()` ou ` resize()`, soit indirectement lorsque l'utilisateur redimensionne manuellement la fenêtre.

[since 6.9] QMargins QWindow::safeAreaMargins() const

Renvoie les marges de la zone de sécurité de la fenêtre.

La zone de sécurité correspond à la partie de la fenêtre où le contenu peut être placé en toute sécurité, sans risque d'être masqué par d'autres éléments de l'interface utilisateur, tels que les interfaces utilisateur système, ni d'entrer en conflit avec ceux-ci.

Les marges sont relatives à la géométrie interne de la fenêtre, c'est-à-dire QRect(0, 0, width(), height()).

void PaintDeviceWindow::paintEvent(QPaintEvent *)
{
    QPainter painter(this);
    QRect rect(0, 0, width(), height());
    painter.fillRect(rect, QGradient::SunnyMorning);
    painter.fillRect(rect - safeAreaMargins(), QGradient::DustyGrass);
}

Cette fonction a été introduite dans Qt 6.9.

Voir également geometry() et safeAreaMarginsChanged().

[signal, since 6.9] void QWindow::safeAreaMarginsChanged(QMargins margins)

Ce signal est émis lorsque les marges de la zone de sécurité passent à « margins ».

Cette fonction a été introduite dans Qt 6.9.

Voir également safeAreaMargins().

QScreen *QWindow::screen() const

Renvoie l'écran sur lequel la fenêtre est affichée, ou null s'il n'y en a pas.

Pour les fenêtres enfants, cette fonction renvoie l’écran de la fenêtre de niveau supérieur correspondante.

Voir également setScreen() et QScreen::virtualSiblings().

[signal] void QWindow::screenChanged(QScreen *screen)

Ce signal est émis lorsque l'screen e d'une fenêtre change, soit parce qu'elle a été définie explicitement à l'aide de la fonction ` setScreen()`, soit automatiquement lorsque la fenêtre est retirée de l'écran.

void QWindow::setBaseSize(const QSize &size)

Définit l'size de base de la fenêtre.

La taille de base est utilisée pour calculer une taille de fenêtre appropriée si la fenêtre définit la fonction ` sizeIncrement()`.

Voir également setMinimumSize(), setMaximumSize(), setSizeIncrement() et baseSize().

void QWindow::setCursor(const QCursor &cursor)

Définir la forme du curseur pour cette fenêtre

Le curseur de la souris cursor prendra cette forme lorsqu’il se trouvera au-dessus de cette fenêtre, à moins qu’un curseur de remplacement ne soit défini. Consultez la section « list of predefined cursor objects » pour découvrir une gamme de formes utiles.

Si aucun curseur n'a été défini, ou après un appel à la fonction unsetCursor(), c'est le curseur de la fenêtre parente qui est utilisé.

Par défaut, le curseur a la forme « Qt::ArrowCursor ».

Certaines implémentations de fenêtres sous-jacentes réinitialisent le curseur s’il quitte une fenêtre, même si la souris est verrouillée. Si vous souhaitez qu’un curseur soit défini pour toutes les fenêtres, même en dehors de la fenêtre, pensez à utiliser QGuiApplication::setOverrideCursor().

Voir également ` cursor()` et ` QGuiApplication::setOverrideCursor()`.

void QWindow::setFilePath(const QString &filePath)

Définir le nom du fichier représenté par cette fenêtre.

Le système de fenêtrage peut utiliser filePath pour afficher le chemin d'accès du document représenté par cette fenêtre dans la barre de mosaïque.

Voir également filePath().

void QWindow::setFlag(Qt::WindowType flag, bool on = true)

Active l'indicateur de fenêtre « flag » sur cette fenêtre si « on » est vrai ; sinon, désactive cet indicateur.

Voir également setFlags(), flags() et type().

void QWindow::setFormat(const QSurfaceFormat &format)

Définit l'format de la surface de la fenêtre.

Ce format détermine des propriétés telles que la profondeur de couleur, l’alpha, la taille des tampons de profondeur et de stencil, etc. Par exemple, pour donner à une fenêtre un arrière-plan transparent (à condition que le système de fenêtrage prenne en charge la composition et que le reste du contenu de la fenêtre ne la rende pas à nouveau opaque) :

QSurfaceFormat format;
format.setAlphaBufferSize(8);
window.setFormat(format);

Le format de la surface sera déterminé dans la fonction ` create()`. L'appel de cette fonction après l'appel de ` create()` ne redéfinira pas le format de la surface native.

Lorsque le format n’est pas explicitement défini via cette fonction, c’est le format renvoyé par ` QSurfaceFormat::defaultFormat()` qui sera utilisé. Cela signifie que, dans le cas de plusieurs fenêtres, les appels individuels à cette fonction peuvent être remplacés par un seul appel à ` QSurfaceFormat::setDefaultFormat()` avant la création de la première fenêtre.

Voir également format(), create(), destroy() et QSurfaceFormat::setDefaultFormat().

void QWindow::setFramePosition(const QPoint &point)

Définit la position en haut à gauche de la fenêtre (point), cadre compris.

Cette position est définie par rapport à la fonction `virtualGeometry()` de son écran.

Voir également framePosition(), setGeometry() et frameGeometry().

[since 6.12] void QWindow::setFramePosition(int x, int y)

Définit la position en haut à gauche de la fenêtre, cadre compris, à l'adresse x, y

La position est relative à la fonction virtualGeometry() de son écran.

Cette fonction a été introduite dans Qt 6.12.

Voir également ` setGeometry()` et ` frameGeometry()`.

[slot] void QWindow::setGeometry(const QRect &rect)

Définit la géométrie de la fenêtre, à l'exclusion de son cadre, sur ` rect`.

La géométrie est relative à la fonction virtualGeometry() de son écran.

// Connect using qOverload:
connect(sender, &SenderClass::signal,
        window, qOverload(&QWindow::setGeometry));

// Or using a lambda as wrapper:
connect(sender, &SenderClass::signal,
        window, [receiver = window](const QRect &rect) { receiver->setGeometry(rect); });

Voir également ` geometry()`.

[slot] void QWindow::setGeometry(int posx, int posy, int w, int h)

Définit la géométrie de la fenêtre, à l'exclusion de son cadre, sous la forme d'un rectangle construit à partir de posx, posy, w et h.

La géométrie est relative à la fonction virtualGeometry() de son écran.

// Connect using qOverload:
connect(sender, &SenderClass::signal,
        window, qOverload(&QWindow::setGeometry));

// Or using a lambda as wrapper:
connect(sender, &SenderClass::signal,
        window, [receiver = window](int posx, int posy, int w, int h) { receiver->setGeometry(posx, posy, w, h); });

Voir également ` geometry()`.

void QWindow::setIcon(const QIcon &icon)

Définit l'icon e de la fenêtre dans le système de gestion des fenêtres

L'icône de la fenêtre peut être utilisée par le système de gestion des fenêtres, par exemple pour décorer la fenêtre et/ou dans le sélecteur de tâches.

Voir également ` icon()` et ` setFilePath()`.

bool QWindow::setKeyboardGrabEnabled(bool grab)

Détermine si la fonction « keyboard grab » doit être activée ou non (grab).

Si la valeur renvoyée est vraie, la fenêtre reçoit tous les événements de touche jusqu’à ce que la fonction setKeyboardGrabEnabled(false) soit appelée ; les autres fenêtres ne reçoivent aucun événement de touche. Les événements de souris ne sont pas affectés. Utilisez setMouseGrabEnabled() si vous souhaitez les intercepter.

Voir également setMouseGrabEnabled().

void QWindow::setMask(const QRegion &region)

Définit le masque de la fenêtre.

Le masque indique au système de gestion des fenêtres que l'application ne souhaite pas recevoir d'entrée de souris ou tactile en dehors de l'region spécifiée.

Le gestionnaire de fenêtres peut choisir ou non d’afficher les zones de la fenêtre non incluses dans le masque ; il incombe donc à l’application de rendre transparentes les zones qui ne font pas partie du masque.

Voir également ` mask()` ().

void QWindow::setMaximumSize(const QSize &size)

Définit la taille maximale de la fenêtre.

Il s'agit d'une indication donnée au gestionnaire de fenêtres afin d'empêcher tout redimensionnement au-delà de la taille spécifiée size.

Voir également ` setMinimumSize()` et ` maximumSize()`.

void QWindow::setMinimumSize(const QSize &size)

Définit la taille minimale de la fenêtre.

Il s'agit d'une indication donnée au gestionnaire de fenêtres afin d'empêcher tout redimensionnement en dessous de la valeur spécifiée size.

Voir également ` setMaximumSize()` et ` minimumSize()`.

bool QWindow::setMouseGrabEnabled(bool grab)

Détermine si la fonction « mouse grab » doit être activée ou non (grab).

Si la valeur renvoyée est vraie, la fenêtre reçoit tous les événements de souris jusqu’à ce que la fonction setMouseGrabEnabled(false) soit appelée ; les autres fenêtres ne reçoivent aucun événement de souris. Les événements clavier ne sont pas affectés. Utilisez setKeyboardGrabEnabled() si vous souhaitez les intercepter.

Voir également setKeyboardGrabEnabled().

void QWindow::setParent(QWindow *parent)

Définit la fenêtre « parent ». Le système de fenêtrage gérera alors le découpage de la fenêtre, qui sera ainsi ajustée à la fenêtre « parent ».

Si vous définissez ` parent ` sur ` nullptr `, la fenêtre deviendra une fenêtre de niveau supérieur.

Si parent est une fenêtre créée par fromWinId(), alors la fenêtre actuelle sera intégrée à parent, si la plate-forme le prend en charge.

Voir également parent().

void QWindow::setPosition(const QPoint &pt)

définir la position de la fenêtre sur le bureau comme suit : pt

La position est définie par rapport à la fonction virtualGeometry() de son écran.

Pour déplacer des fenêtres de manière interactive, voir startSystemMove(). Pour redimensionner des fenêtres de manière interactive, voir startSystemResize().

Voir également position() et startSystemMove().

void QWindow::setPosition(int posx, int posy)

définir la position de la fenêtre sur le bureau à l'adresse posx, posy

La position est relative à la fonction virtualGeometry() de son écran.

Voir également position().

void QWindow::setScreen(QScreen *newScreen)

Définit l'écran sur lequel la fenêtre doit s'afficher.

Si la fenêtre a déjà été créée, elle sera recréée sur l'newScreen.

Cette fonction ne fonctionne que pour les fenêtres de niveau supérieur.

Voir également ` screen()` et ` QScreen::virtualSiblings()`.

void QWindow::setSizeIncrement(const QSize &size)

Définit l'incrément de taille (size) de la fenêtre.

Lorsque l'utilisateur redimensionne la fenêtre, la taille évolue par incréments de sizeIncrement().width() pixels horizontalement et sizeIncrement().height() pixels verticalement, en prenant baseSize() comme référence.

Par défaut, cette propriété contient une taille avec une largeur et une hauteur égales à zéro.

Il se peut que le système de fenêtrage ne prenne pas en charge les incréments de taille.

Voir également sizeIncrement(), setBaseSize(), setMinimumSize() et setMaximumSize().

void QWindow::setSurfaceType(QSurface::SurfaceType surfaceType)

Définit l'surfaceType de la fenêtre.

Spécifie si la fenêtre est destinée au rendu raster avec QBackingStore, ou au rendu OpenGL avec QOpenGLContext.

La propriété ` surfaceType ` sera utilisée lors de la création de la surface native par la fonction ` create()`. L'appel de cette fonction après la création de la surface native nécessite d'appeler les fonctions ` destroy()` et ` create()` afin de libérer l'ancienne surface native et d'en créer une nouvelle.

Voir également surfaceType(), QBackingStore, QOpenGLContext, create() et destroy().

void QWindow::setVulkanInstance(QVulkanInstance *instance)

Associe cette fenêtre à l'instance Vulkan spécifiée.

instance doit rester valide tant que cette instance d'QWindow existe.

Voir également vulkanInstance().

void QWindow::setWindowState(Qt::WindowState state)

définit l'état d'occupation de l'écran de la fenêtre

La fenêtre « state » indique si la fenêtre apparaît dans le système de gestion des fenêtres en mode maximisé, minimisé, plein écran ou normal.

La valeur d'énumération ` Qt::WindowActive ` n'est pas un paramètre accepté.

Voir également windowState(), showNormal(), showFullScreen(), showMinimized(), showMaximized() et setWindowStates().

void QWindow::setWindowStates(Qt::WindowStates state)

Définir l'état d'occupation de l'écran de la fenêtre

L'state, indique si la fenêtre apparaît dans le système de gestion des fenêtres en mode maximisé, minimisé et/ou plein écran.

La fenêtre peut présenter une combinaison de plusieurs états. Par exemple, si la fenêtre est à la fois minimisée et maximisée, elle s'affichera minimisée, mais un clic sur son icône dans la barre des tâches la restaurera à l'état maximisé.

La valeur d’énumération ` Qt::WindowActive ` ne doit pas être définie.

Voir également windowStates(), showNormal(), showFullScreen(), showMinimized() et showMaximized().

[slot] void QWindow::show()

Affiche la fenêtre.

Pour les fenêtres enfants, cela revient à appeler ` showNormal()`. Sinon, cela revient à appeler ` showFullScreen()`, ` showMaximized()` ou ` showNormal()`, selon le comportement par défaut de la plate-forme pour le type de fenêtre et les indicateurs.

Voir également showFullScreen(), showMaximized(), showNormal(), hide(), QStyleHints::showIsFullScreen() et flags().

[virtual protected] void QWindow::showEvent(QShowEvent *ev)

Redéfinissez cette méthode pour gérer les événements d'affichage (ev).

La fonction est appelée lorsque la fenêtre a demandé à devenir visible.

Si la fenêtre est affichée avec succès par le système de gestion des fenêtres, cela sera suivi d'un événement de redimensionnement et d'un événement d'exposition.

[slot] void QWindow::showFullScreen()

Affiche la fenêtre en plein écran.

Cela revient à appeler ` setWindowStates` (Qt::WindowFullScreen) puis ` setVisible(true)`.

Consultez la documentation relative à la fonction ` QWidget::showFullScreen()` pour connaître les considérations et limitations spécifiques à chaque plateforme.

Voir également setWindowStates() et setVisible().

[slot] void QWindow::showMaximized()

Affiche la fenêtre en mode maximisé.

Cela revient à appeler setWindowStates(Qt::WindowMaximized) puis setVisible(true).

Voir également setWindowStates() et setVisible().

[slot] void QWindow::showMinimized()

Affiche la fenêtre en mode minimisé.

Cela revient à appeler setWindowStates(Qt::WindowMinimized) puis setVisible(true).

Voir également setWindowStates() et setVisible().

[slot] void QWindow::showNormal()

Affiche la fenêtre dans son état normal, c'est-à-dire ni agrandie, ni réduite, ni en plein écran.

Cela revient à appeler ` setWindowStates` (Qt::WindowNoState) puis ` setVisible` (true).

Voir également setWindowStates() et setVisible().

[override virtual] QSize QWindow::size() const

Réimplémente : ` QSurface::size()` const.

Renvoie la taille de la fenêtre, hors cadre.

Voir aussi resize().

QSize QWindow::sizeIncrement() const

Renvoie l'incrément de taille de la fenêtre.

Voir aussi setSizeIncrement().

[slot] bool QWindow::startSystemMove()

Lancer une opération de déplacement spécifique à la plate-forme

L'appel de cette méthode lance une opération de déplacement interactive de la fenêtre sur les plateformes qui la prennent en charge. Le comportement réel peut varier selon la plateforme. En général, la fenêtre suit le curseur de la souris jusqu'à ce qu'un bouton de la souris soit relâché.

Sur les plateformes qui la prennent en charge, cette méthode de déplacement des fenêtres est préférable à ` setPosition`, car elle offre une expérience plus native lors du déplacement des fenêtres. Elle permet notamment au gestionnaire de fenêtres d’aligner cette fenêtre sur d’autres fenêtres, ou d’appliquer des comportements spéciaux de disposition en mosaïque ou de redimensionnement avec des animations lorsque la fenêtre est glissée vers le bord de l’écran. De plus, sur certaines plateformes telles que Wayland, la méthode ` setPosition ` n’est pas prise en charge ; c’est donc le seul moyen pour l’application d’influencer sa position.

Renvoie « true » si l’opération était prise en charge par le système.

[slot] bool QWindow::startSystemResize(Qt::Edges edges)

Lancer une opération de redimensionnement spécifique au système

L'appel de cette méthode lance une opération de redimensionnement interactive de la fenêtre sur les plateformes qui la prennent en charge. Le comportement réel peut varier selon la plateforme. En général, cela redimensionne la fenêtre de manière à ce que son bord suive le curseur de la souris.

Sur les plateformes qui le prennent en charge, cette méthode de redimensionnement des fenêtres est préférable à ` setGeometry`, car elle offre une expérience plus native lors du redimensionnement des fenêtres, par exemple en permettant au gestionnaire de fenêtres d’aligner cette fenêtre sur d’autres fenêtres, ou en proposant un comportement de redimensionnement spécial avec des animations lorsqu’elle est glissée vers le bord de l’écran.

edges doit correspondre soit à un seul bord, soit à deux bords adjacents (un coin). Les autres valeurs ne sont pas autorisées.

Renvoie `true` si l’opération est prise en charge par le système.

[override virtual] QSurface::SurfaceType QWindow::surfaceType() const

Réimplémente : ` QSurface::surfaceType()` const.

Renvoie le type de surface de la fenêtre.

Voir aussi setSurfaceType().

[virtual protected] void QWindow::tabletEvent(QTabletEvent *ev)

Redéfinissez cette méthode pour gérer les événements de pression, de déplacement et de relâchement sur une tablette (ev).

Les événements d'approche et d'éloignement ne sont pas envoyés aux fenêtres, mais à l'instance de l'application.

[virtual protected] void QWindow::touchEvent(QTouchEvent *ev)

Redéfinissez cette méthode pour gérer les événements tactiles (ev).

Qt::WindowType QWindow::type() const

Renvoie le type de la fenêtre.

Cette fonction renvoie la partie des indicateurs de fenêtre qui indique si la fenêtre est une boîte de dialogue, une info-bulle, une fenêtre contextuelle, une fenêtre standard, etc.

Voir également flags() et setFlags().

void QWindow::unsetCursor()

Rétablit le curseur en forme de flèche par défaut pour cette fenêtre.

QVulkanInstance *QWindow::vulkanInstance() const

Renvoie l'instance Vulkan associée si elle a été définie ; sinon, renvoie « nullptr ».

Voir également setVulkanInstance().

[virtual protected] void QWindow::wheelEvent(QWheelEvent *ev)

Redéfinissez cette méthode pour gérer les événements liés à la molette de la souris ou à d'autres molettes (ev).

WId QWindow::winId() const

Renvoie l'identifiant de la plateforme de la fenêtre.

Pour les plateformes où cet identifiant peut s'avérer utile, la valeur renvoyée identifie de manière unique la fenêtre au sein de l'écran correspondant.

Voir également screen().

Qt::WindowState QWindow::windowState() const

l'état d'occupation de l'écran par la fenêtre

Voir également setWindowState() et windowStates().

[signal] void QWindow::windowStateChanged(Qt::WindowState windowState)

Ce signal est émis lorsque l'windowState change, soit parce qu'elle a été définie explicitement à l'aide de la fonction ` setWindowStates()`, soit automatiquement lorsque l'utilisateur clique sur l'un des boutons de la barre de titre ou par tout autre moyen.

Qt::WindowStates QWindow::windowStates() const

l'état d'occupation de l'écran par la fenêtre

La fenêtre peut se trouver dans une combinaison de plusieurs états. Par exemple, si la fenêtre est à la fois minimisée et agrandie, elle apparaîtra minimisée, mais un clic sur son icône dans la barre des tâches la ramènera à l'état agrandi.

Voir également setWindowStates().