QWindow Class

Fonction membre Documentation

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

Crée une fenêtre de premier niveau sur le site targetScreen.

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

Voir aussi setScreen().

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

Crée une fenêtre en tant qu'enfant de la fenêtre parent donnée.

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

L'écran est hérité du parent.

Voir aussi setParent().

[virtual noexcept] QWindow::~QWindow()

Détruit la fenêtre.

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

Provoque l'affichage d'une alerte pendant msec millisecondes. Si msec est 0 (valeur par défaut), l'alerte est 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 demande de l'attention, par exemple en faisant clignoter ou rebondir l'entrée de 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()

Fermer la fenêtre.

Ceci ferme la fenêtre, en appelant effectivement destroy(), et en quittant éventuellement l'application. Retourne true en cas de succès, false si la fenêtre a un parent (dans ce cas, la fenêtre de niveau supérieur doit être fermée à la place).

Voir aussi destroy(), QGuiApplication::quitOnLastWindowClosed() et closeEvent().

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

Surchargez cette fonction pour gérer les événements de fermeture (ev).

La fonction est appelée lorsque la fermeture de la fenêtre est demandée. Appelez QEvent::ignore() sur l'événement si vous voulez empêcher la fermeture de la fenêtre.

Voir aussi close().

void QWindow::create()

Alloue les ressources de la plate-forme associées à la fenêtre.

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

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 qui nécessitent un accès aux ressources de la plate-forme.

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

Voir aussi destroy().

QCursor QWindow::cursor() const

la forme du curseur pour cette fenêtre

Voir aussi setCursor() et unsetCursor().

void QWindow::destroy()

Libère les ressources de la plate-forme native 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 changer lorsque la fenêtre est déplacée.

L'instance QWindow reçoit un événement de type QEvent::DevicePixelRatioChange lorsque le rapport de pixels du périphérique change.

Les valeurs courantes sont 1,0 sur les écrans normaux et 2,0 sur les écrans Apple "retina".

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

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

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

Surcharge cette fonction pour gérer tout événement (ev) envoyé à la fenêtre. Retourne true si l'événement a été reconnu et traité.

N'oubliez pas d'appeler la version de la classe de base si vous souhaitez que les événements liés à la souris, aux touches, au redimensionnement, etc. soient traités comme d'habitude.

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

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

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 totalement masquée par une autre fenêtre, si elle est réduite, etc., cette fonction peut être appelée et la valeur de isExposed() peut passer à false. Vous pouvez utiliser cet événement pour limiter l'exécution d'opérations coûteuses, telles que des animations, au moment où la fenêtre est exposée.

Cet événement ne doit pas être utilisé pour peindre. Pour gérer la peinture, utilisez plutôt paintEvent().

Un événement de redimensionnement sera toujours envoyé avant l'événement d'exposition la première fois qu'une fenêtre est affichée.

Voir aussi paintEvent() et isExposed().

QString QWindow::filePath() const

le nom du fichier que cette fenêtre représente.

Voir aussi setFilePath().

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

Surchargez cette fonction pour gérer les événements de mise au point (ev).

Les événements "Focus in" sont envoyés lorsque la fenêtre reçoit le focus du clavier.

Voir également focusOutEvent().

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

Renvoie l'adresse QObject qui sera le destinataire final des événements liés à la focalisation, tels que les événements clés.

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

Ce signal est émis lorsque le récepteur final des événements liés à la focalisation passe à object.

Voir également focusObject().

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

Cette option est surchargée pour gérer les événements de focus out (ev).

Les événements "focus out" sont envoyés lorsque la fenêtre perd le focus clavier.

Voir également focusInEvent().

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

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

Renvoie le format actuel de cette fenêtre.

Après la création de la fenêtre, cette fonction renvoie le format réel de la surface de la fenêtre. Il peut différer du format demandé si ce dernier n'a pas pu être respecté par la plateforme. Il peut également s'agir d'un surensemble, par exemple certaines tailles de tampon peuvent être plus grandes que celles demandées.

Voir aussi 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 en relation avec la virtualGeometry() de son écran.

Voir aussi geometry() et frameMargins().

QMargins QWindow::frameMargins() const

Renvoie les marges du cadre de la fenêtre entourant la fenêtre.

Voir aussi geometry() et frameGeometry().

QPoint QWindow::framePosition() const

Renvoie la position supérieure gauche de la fenêtre, y compris son cadre.

La valeur renvoyée est identique à celle de 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 en utilisant des bibliothèques natives inférieures à Qt.

Étant donné l'identifiant 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'invocation de méthodes telles que setParent() et setTransientParent().

Cet objet peut être utilisé, sur les plates-formes qui le prennent en charge, pour intégrer une fenêtre QWindow dans une fenêtre native, ou pour intégrer une fenêtre native dans une fenêtre 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 en relation avec la virtualGeometry() de son écran.

Voir aussi setGeometry(), frameMargins() et frameGeometry().

[slot] void QWindow::hide()

Cache la fenêtre.

Équivaut à appeler setVisible(false).

Voir aussi show() et setVisible().

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

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

Cette fonction est appelée lorsque la fenêtre a demandé à être masquée dans le système de fenêtrage.

QIcon QWindow::icon() const

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

Voir aussi setIcon().

bool QWindow::isActive() const

Renvoie true si la fenêtre est active.

C'est le cas pour la fenêtre qui a le focus d'entrée ainsi que pour les fenêtres qui sont dans la même chaîne parentale / parentale transitoire que la fenêtre du focus.

En règle générale, les fenêtres actives doivent apparaître actives 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 la fenêtre donnée child. Si mode est IncludeTransients, les parents transitoires sont également considérés comme des ancêtres.

bool QWindow::isExposed() const

Retourne si cette fenêtre est exposée dans le système de fenêtrage.

Lorsque la fenêtre n'est pas exposée, elle est affichée par l'application, mais elle n'est toujours pas affichée dans le système de fenêtrage, de sorte que l'application doit minimiser les animations et autres activités graphiques.

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

Voir aussi 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 données.

Voir également 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)

Surchargez ceci pour gérer les événements d'appui sur une touche (ev).

Voir également keyReleaseEvent().

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

Remplacer cette fonction pour gérer les événements de relâchement des touches (ev).

Voir également keyPressEvent().

[slot] void QWindow::lower()

Abaisser la fenêtre dans le système de fenêtrage.

Demande que la fenêtre soit abaissée pour apparaître sous les autres fenêtres.

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

Traduit 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

Traduit les coordonnées de la fenêtre pos en coordonnées globales de l'écran. Par exemple, mapToGlobal(QPointF(0,0)) donne les coordonnées globales du pixel supérieur gauche de la fenêtre.

Cette fonction a été introduite dans Qt 6.0.

Voir aussi 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 fenêtrage que l'application ne veut pas recevoir d'entrée de souris ou de toucher en dehors de la région donnée.

Voir aussi setMask().

QSize QWindow::maximumSize() const

Renvoie la taille maximale de la fenêtre.

Voir également setMaximumSize().

QSize QWindow::minimumSize() const

Renvoie la taille minimale de la fenêtre.

Voir également 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)

Surchargez cette fonction 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)

Cette option est surchargée pour gérer les événements de déplacement de la souris (ev).

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

Surchargez ceci pour gérer les événements de pression de la souris (ev).

Voir également mouseReleaseEvent().

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

Surchargez ceci pour gérer les événements de relâchement de la souris (ev).

Voir également mousePressEvent().

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

Surcharge cette fonction 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)

Surchargez ceci pour gérer les événements dépendant de la plate-forme. Il sera donné eventType, message et result.

Cela pourrait rendre votre application non portable.

Ne doit renvoyer true que si l'événement a été traité.

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

L'événement de peinture (ev) est envoyé par le système de fenêtres chaque fois qu'une zone de la fenêtre doit être repeinte, par exemple lors de l'affichage initial de la fenêtre ou lorsque des parties de la fenêtre sont découvertes par le déplacement d'une autre fenêtre.

L'application est censée effectuer un rendu dans la fenêtre en réponse à l'événement de peinture, quel que soit l'état d'exposition de la fenêtre. Par exemple, un événement de peinture peut être envoyé avant que la fenêtre ne soit exposée, pour la préparer à être montré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 parent, s'il y en a une.

Si mode est IncludeTransients, le parent transitoire est renvoyé s'il n'y a pas de parent.

Une fenêtre sans parent est appelée fenêtre de premier niveau.

Voir également setParent().

QPoint QWindow::position() const

Renvoie la position de la fenêtre sur le bureau, à l'exclusion de tout cadre de fenêtre.

Voir également setPosition().

[slot] void QWindow::raise()

Relever la fenêtre dans le système de fenêtrage.

Demande que la fenêtre soit relevée pour apparaître au-dessus des autres fenêtres.

[slot] void QWindow::requestActivate()

Demande à la fenêtre d'être activée, c'est-à-dire de recevoir le focus clavier.

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

[slot] void QWindow::requestUpdate()

Planifie un événement QEvent::UpdateRequest qui sera envoyé à cette fenêtre.

L'événement est transmis en synchronisation avec l'affichage vsync sur les plates-formes où cela est possible. Sinon, l'événement est transmis après un délai d'au plus 5 ms. Si l'écran associé à la fenêtre signale un refresh rate supérieur à 60 Hz, l'intervalle est réduit à une valeur inférieure à 5. Le délai supplémentaire est là pour donner à la boucle d'événements un peu de temps mort pour rassembler les événements du système, et peut être surchargé en utilisant la variable d'environnement QT_QPA_UPDATE_IDLE_TIME.

Lors de la conduite d'animations, cette fonction ne doit être appelée qu'une fois le dessin terminé. Si vous appelez cette fonction plusieurs fois, un seul événement sera transmis à la fenêtre.

Les sous-classes de QWindow doivent réimplémenter event(), intercepter l'événement et 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é sera différent du format réel de la fenêtre.

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

Voir également setFormat() et format().

void QWindow::resize(const QSize &newSize)

fixer la taille de la fenêtre, à l'exclusion de tout cadre de fenêtre, à newSize

Voir également size() et geometry().

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

définir la taille de la fenêtre, à l'exclusion de tout cadre, à l'aide d'une adresse QSize construite à partir de la largeur w et de la hauteur h

Pour le redimensionnement interactif des fenêtres, voir startSystemResize().

Voir également size() et geometry().

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

Cette fonction est remplacée pour gérer les événements de redimensionnement (ev).

L'événement de redimensionnement est appelé chaque fois que la fenêtre est redimensionnée dans le système de fenêtrage, soit directement par le système de fenêtrage qui accuse réception d'une demande setGeometry() ou resize(), soit indirectement par l'utilisateur qui redimensionne la fenêtre manuellement.

[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é représente 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 du système, ou d'entrer en conflit avec eux.

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 aussi 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é sont passées à margins.

Cette fonction a été introduite dans Qt 6.9.

Voir aussi 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 aussi setScreen() et QScreen::virtualSiblings().

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

Ce signal est émis lorsque l'adresse screen d'une fenêtre change, soit parce qu'elle a été définie explicitement avec setScreen(), soit automatiquement lorsque l'écran de la fenêtre est supprimé.

void QWindow::setBaseSize(const QSize &size)

Définit la base size 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 sizeIncrement().

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

void QWindow::setCursor(const QCursor &cursor)

définit la forme du curseur pour cette fenêtre

La souris cursor prendra cette forme lorsqu'elle se trouvera au-dessus de cette fenêtre, à moins qu'un curseur de remplacement ne soit défini. Voir list of predefined cursor objects pour une gamme de formes utiles.

Si aucun curseur n'a été défini, ou après un appel à unsetCursor(), le curseur de la fenêtre parente 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 saisie. Si vous souhaitez qu'un curseur soit défini pour toutes les fenêtres, même en dehors de la fenêtre, envisagez QGuiApplication::setOverrideCursor().

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

void QWindow::setFilePath(const QString &filePath)

définit le nom du fichier que cette fenêtre représente.

Le système de fenêtrage peut utiliser filePath pour afficher le chemin du document que cette fenêtre représente dans la barre des tuiles.

Voir également filePath().

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

Définit l'indicateur de fenêtre flag sur cette fenêtre si on est vrai ; sinon, efface l'indicateur.

Voir aussi setFlags(), flags() et type().

void QWindow::setFormat(const QSurfaceFormat &format)

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

Le format détermine des propriétés telles que la profondeur de couleur, l'alpha, la profondeur et la taille de la mémoire tampon du pochoir, etc. Par exemple, pour donner à une fenêtre un arrière-plan transparent (à condition que le système de fenêtres prenne en charge la composition et que d'autres contenus dans la fenêtre ne la rendent pas à nouveau opaque) :

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

Le format de la surface sera résolu dans la fonction create(). L'appel de cette fonction après l'appel de create() ne résoudra pas à nouveau le format de la surface native.

Si le format n'est pas explicitement défini par cette fonction, c'est le format renvoyé par QSurfaceFormat::defaultFormat() qui sera utilisé. Cela signifie qu'en cas de fenêtres multiples, les appels individuels à cette fonction peuvent être remplacés par un appel unique à QSurfaceFormat::setDefaultFormat() avant la création de la première fenêtre.

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

void QWindow::setFramePosition(const QPoint &point)

Définit la position supérieure gauche de la fenêtre (point), y compris son cadre.

La position est en relation avec la virtualGeometry() de son écran.

Voir aussi framePosition(), 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, à rect.

La géométrie est en relation avec la 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 aussi 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, comme un rectangle construit à partir de posx, posy, w et h.

La géométrie est en relation avec la 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 aussi geometry().

void QWindow::setIcon(const QIcon &icon)

Définit l'icône de la fenêtre icon dans le système de fenêtrage

L'icône de la fenêtre peut être utilisée par le système de fenêtrage, 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éfinit si la saisie clavier doit être activée ou non (grab).

Si la valeur retournée est true, la fenêtre reçoit tous les événements de touches jusqu'à ce que setKeyboardGrabEnabled(false) soit appelé ; les autres fenêtres ne reçoivent aucun événement de touches. Les événements souris ne sont pas affectés. Utilisez setMouseGrabEnabled() si vous voulez les récupérer.

Voir aussi setMouseGrabEnabled().

void QWindow::setMask(const QRegion &region)

Définit le masque de la fenêtre.

Le masque indique au système de fenêtrage que l'application ne souhaite pas recevoir de données de la souris ou du toucher en dehors de la zone donnée region.

Le gestionnaire de fenêtres peut choisir ou non d'afficher les zones de la fenêtre qui ne sont pas incluses dans le masque, et 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)

Fixe la taille maximale de la fenêtre.

Il s'agit d'une indication au gestionnaire de fenêtres pour empêcher le 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 au gestionnaire de fenêtres pour empêcher le redimensionnement en dessous de la taille spécifiée size.

Voir également setMaximumSize() et minimumSize().

bool QWindow::setMouseGrabEnabled(bool grab)

Définit si la saisie de la souris doit être activée ou non (grab).

Si la valeur de retour est true, la fenêtre reçoit tous les événements de souris jusqu'à ce que setMouseGrabEnabled(false) soit appelé ; 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 voulez les récupérer.

Voir aussi setKeyboardGrabEnabled().

void QWindow::setParent(QWindow *parent)

Définit la fenêtre parent. Le système de fenêtrage gérera le clip de la fenêtre, qui sera donc rattaché à la fenêtre parent.

En remplaçant parent par nullptr, la fenêtre devient une fenêtre de premier niveau.

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

Voir également parent().

void QWindow::setPosition(const QPoint &pt)

fixe la position de la fenêtre sur le bureau à pt

La position est en relation avec la virtualGeometry() de son écran.

Pour le déplacement interactif des fenêtres, voir startSystemMove(). Pour le redimensionnement interactif des fenêtres, voir startSystemResize().

Voir également position() et startSystemMove().

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

fixe la position de la fenêtre sur le bureau à posx, posy

La position est en relation avec la virtualGeometry() de son écran.

Voir aussi position().

void QWindow::setScreen(QScreen *newScreen)

Définit l'écran sur lequel la fenêtre doit être affichée.

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

Cette fonction ne fonctionne que pour les fenêtres de premier niveau.

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 se déplace par pas de sizeIncrement().width() pixels horizontalement et sizeIncrement().height() pixels verticalement, avec baseSize() comme base.

Par défaut, cette propriété contient une taille dont la largeur et la hauteur sont nulles.

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'adresse surfaceType de la fenêtre.

Spécifie si la fenêtre est destinée à un rendu matriciel avec QBackingStore, ou à un rendu OpenGL avec QOpenGLContext.

L'adresse surfaceType sera utilisée lors de la création de la surface native dans la fonction create(). L'appel de cette fonction après la création de la surface native nécessite l'appel de destroy() et create() pour libérer l'ancienne surface native et en créer une nouvelle.

Voir aussi surfaceType(), QBackingStore, QOpenGLContext, create() et destroy().

void QWindow::setVulkanInstance(QVulkanInstance *instance)

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

instance doit rester valide tant que l'instance QWindow existe.

Voir également vulkanInstance().

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

définir 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 fenêtrage comme maximisée, minimisée, plein écran ou normale.

La valeur enum 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

La fenêtre state indique si la fenêtre apparaît dans le système de fenêtrage comme maximisée, minimisée et/ou en plein écran.

La fenêtre peut être dans une combinaison de plusieurs états. Par exemple, si la fenêtre est à la fois réduite et maximisée, elle apparaîtra réduite, mais un clic sur l'entrée de la barre des tâches la ramènera à l'état maximisé.

La valeur enum 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 enfant, cela équivaut à appeler showNormal(). Sinon, cela équivaut à appeler showFullScreen(), showMaximized() ou showNormal(), en fonction du comportement par défaut de la plateforme pour le type de fenêtre et les drapeaux.

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

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

Surchargez cette fonction 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 fenêtrage, elle sera suivie d'un événement de redimensionnement et d'exposition.

[slot] void QWindow::showFullScreen()

Affiche la fenêtre en plein écran.

Équivaut à appeler setWindowStates(Qt::WindowFullScreen) puis setVisible(true).

Voir la documentation de QWidget::showFullScreen() pour les considérations et limitations spécifiques à la plate-forme.

Voir également setWindowStates() et setVisible().

[slot] void QWindow::showMaximized()

Affiche la fenêtre comme étant maximisée.

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

Voir aussi setWindowStates() et setVisible().

[slot] void QWindow::showMinimized()

Affiche la fenêtre comme étant réduite.

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

Voir aussi setWindowStates() et setVisible().

[slot] void QWindow::showNormal()

Affiche la fenêtre normalement, c'est-à-dire ni maximisée, ni minimisée, ni en plein écran.

Cela équivaut à appeler setWindowStates(Qt::WindowNoState) puis setVisible(true).

Voir aussi setWindowStates() et setVisible().

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

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

Renvoie la taille de la fenêtre à l'exclusion de tout cadre de fenêtre

Voir aussi resize().

QSize QWindow::sizeIncrement() const

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

Voir également setSizeIncrement().

[slot] bool QWindow::startSystemMove()

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

L'appel de cette fonction lance une opération de déplacement interactive sur la fenêtre pour les plates-formes qui la prennent en charge. Le comportement réel peut varier en fonction de la plate-forme. En général, la fenêtre suit le curseur de la souris jusqu'à ce que le bouton de la souris soit relâché.

Sur les plates-formes qui la prennent en charge, cette méthode de déplacement des fenêtres est préférée à setPosition, car elle permet d'obtenir un aspect et une sensation plus natifs du déplacement des fenêtres, par exemple en permettant au gestionnaire de fenêtres d'accrocher cette fenêtre à d'autres fenêtres, ou un comportement spécial de tuilage ou de redimensionnement avec des animations lorsqu'elle est déplacée jusqu'au bord de l'écran. En outre, sur certaines plateformes telles que Wayland, setPosition n'est pas pris en charge, et c'est donc le seul moyen pour l'application d'influencer sa position.

Retourne vrai si l'opération a été 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 option lance une opération interactive de redimensionnement de la fenêtre sur les plates-formes qui la prennent en charge. Le comportement réel peut varier en fonction de la plate-forme. En général, la fenêtre est redimensionnée de manière à ce que son bord suive le curseur de la souris.

Sur les plates-formes qui la prennent en charge, cette méthode de redimensionnement des fenêtres est préférée à setGeometry, car elle permet de redimensionner les fenêtres de manière plus native, par exemple en permettant au gestionnaire de fenêtres d'accrocher cette fenêtre à d'autres fenêtres, ou en adoptant un comportement de redimensionnement spécial avec des animations lorsque la fenêtre est déplacée jusqu'au bord de l'écran.

edges doit être soit un bord unique, soit deux bords adjacents (un coin). Les autres valeurs ne sont pas autorisées.

Retourne vrai si l'opération a été 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 également setSurfaceType().

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

Remplacer ce paramètre pour gérer les événements d'appui, de déplacement et de relâchement de la tablette (ev).

Les événements d'entrée et de sortie de proximité ne sont pas envoyés aux fenêtres, ils sont transmis à l'instance d'application.

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

Cette fonction est surchargée pour gérer les événements tactiles (ev).

Qt::WindowType QWindow::type() const

Renvoie le type de la fenêtre.

Ceci renvoie la partie des drapeaux de la fenêtre qui indique si la fenêtre est une boîte de dialogue, une infobulle, une fenêtre contextuelle, une fenêtre normale, etc.

Voir également flags() et setFlags().

void QWindow::unsetCursor()

Rétablit le curseur fléché par défaut pour cette fenêtre.

QVulkanInstance *QWindow::vulkanInstance() const

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

Voir également setVulkanInstance().

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

Cette option est surchargée pour gérer les événements liés à la roue de la souris ou à d'autres roues (ev).

WId QWindow::winId() const

Renvoie l'identifiant de la plate-forme de la fenêtre.

Pour les plates-formes où cet identifiant peut être utile, la valeur renvoyée représentera de manière unique la fenêtre dans l'écran correspondant.

Voir également screen().

Qt::WindowState QWindow::windowState() const

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

Voir également setWindowState() et windowStates().

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

Ce signal est émis lorsque le site windowState change, soit en étant défini explicitement avec setWindowStates(), soit automatiquement lorsque l'utilisateur clique sur l'un des boutons de la barre de titre ou par d'autres moyens.

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 réduite et maximisée, elle apparaîtra réduite, mais un clic sur l'entrée de la barre des tâches la ramènera à l'état maximisé.

Voir également setWindowStates().