Popup QML Type

Type de base des contrôles d'interface utilisateur de type popup. Plus d'informations...

• Liste de tous les membres, y compris les membres hérités

Propriétés

• activeFocus : bool
• anchors.centerIn : Item (since QtQuick.Controls 2.5 (Qt 5.12))
• availableHeight : real
• availableWidth : real
• background : Item
• bottomInset : real (since QtQuick.Controls 2.5 (Qt 5.12))
• bottomMargin : real
• bottomPadding : real
• clip : bool
• closePolicy : enumeration
• contentChildren : list<Item>
• contentData : list<QtObject>
• contentHeight : real
• contentItem : Item
• contentWidth : real
• dim : bool
• enabled : bool (since QtQuick.Controls 2.3 (Qt 5.10))
• enter : Transition
• exit : Transition
• focus : bool
• font : font
• height : real
• horizontalPadding : real (since QtQuick.Controls 2.5 (Qt 5.12))
• implicitBackgroundHeight : real (since QtQuick.Controls 2.5 (Qt 5.12))
• implicitBackgroundWidth : real (since QtQuick.Controls 2.5 (Qt 5.12))
• implicitContentHeight : real (since QtQuick.Controls 2.5 (Qt 5.12))
• implicitContentWidth : real (since QtQuick.Controls 2.5 (Qt 5.12))
• implicitHeight : real
• implicitWidth : real
• leftInset : real (since QtQuick.Controls 2.5 (Qt 5.12))
• leftMargin : real
• leftPadding : real
• locale : Locale
• margins : real
• mirrored : bool (since QtQuick.Controls 2.3 (Qt 5.10))
• modal : bool
• opacity : real
• opened : bool (since QtQuick.Controls 2.3 (Qt 5.10))
• padding : real
• palette : palette (since QtQuick.Controls 2.3 (Qt 5.10))
• parent : Item
• popupType : enumeration (since 6.8)
• rightInset : real (since QtQuick.Controls 2.5 (Qt 5.12))
• rightMargin : real
• rightPadding : real
• scale : real
• spacing : real (since QtQuick.Controls 2.1 (Qt 5.8))
• topInset : real (since QtQuick.Controls 2.5 (Qt 5.12))
• topMargin : real
• topPadding : real
• transformOrigin : enumeration
• verticalPadding : real (since QtQuick.Controls 2.5 (Qt 5.12))
• visible : bool
• width : real
• x : real
• y : real
• z : real

Signaux

• void aboutToHide()
• void aboutToShow()
• void closed()
• void opened()

Méthodes

• void close()
• void forceActiveFocus(enumeration reason)
• void open()

Description détaillée

Popup est le type de base des contrôles d'interface utilisateur de type popup. Il peut être utilisé avec Window ou ApplicationWindow.

import QtQuick.Window
import QtQuick.Controls

ApplicationWindow {
    id: window
    width: 400
    height: 400
    visible: true

    Button {
        text: "Open"
        onClicked: popup.open()
    }

    Popup {
        id: popup
        x: 100
        y: 100
        width: 200
        height: 300
        modal: true
        focus: true
        closePolicy: Popup.CloseOnEscape | Popup.CloseOnPressOutsideParent
    }
}

La Popup ne fournit pas de mise en page propre, mais nécessite que vous positionniez son contenu, par exemple en créant une RowLayout ou une ColumnLayout.

Les éléments déclarés comme enfants d'une fenêtre contextuelle sont automatiquement rattachés à la fenêtre contentItem. Les éléments créés dynamiquement doivent être explicitement rattachés à la page contentItem.

Disposition des fenêtres pop-up

Le diagramme suivant illustre la disposition d'une fenêtre contextuelle à l'intérieur d'une fenêtre :

Les pages implicitWidth et implicitHeight d'une fenêtre contextuelle sont généralement basées sur les tailles implicites de l'arrière-plan et de l'élément de contenu, ainsi que sur les encarts et les encadrements éventuels. Ces propriétés déterminent la taille de la fenêtre contextuelle lorsqu'aucune width ou height explicite n'est spécifiée.

La géométrie de la page contentItem est déterminée par le remplissage. L'exemple suivant réserve une marge de 10 px entre les limites de la fenêtre contextuelle et son contenu :

Popup {
    padding: 10

    contentItem: Text {
        text: "Content"
    }
}

L'élément background occupe toute la largeur et la hauteur de la fenêtre contextuelle, sauf si des encarts ou une taille explicite lui ont été attribués.

Des encarts négatifs peuvent être utilisés pour que l'arrière-plan soit plus grand que la fenêtre contextuelle. L'exemple suivant utilise des encarts négatifs pour placer une ombre en dehors des limites de la fenêtre contextuelle :

Popup {
    topInset: -2
    leftInset: -2
    rightInset: -6
    bottomInset: -6

    background: BorderImage {
        source: ":/images/shadowed-background.png"
    }
}

Type de popup

Depuis la version 6.8 de Qt XML, certaines fenêtres contextuelles, telles que Menu, offrent trois implémentations différentes, en fonction de la plate-forme. Vous pouvez choisir celle que vous préférez en définissant popupType.

Le fait qu'une fenêtre contextuelle puisse utiliser le type préféré dépend de la plate-forme. Popup.Item est pris en charge sur toutes les plates-formes, mais Popup.Window et Popup.Native ne sont normalement pris en charge que sur les plates-formes de bureau. En outre, si une fenêtre contextuelle est un Menu à l'intérieur d'un native menubar, le menu sera également natif. Et si le menu est un sous-menu à l'intérieur d'un autre menu, c'est le menu parent (ou racine) qui décidera du type.

Afficher une fenêtre contextuelle en tant qu'élément

En réglant popupType sur Popup.Item, la fenêtre contextuelle ne sera pas affichée comme une fenêtre séparée, mais comme un élément dans la même scène que le parent. Cet élément est rattaché à la scène overlay et est stylisé de manière à ressembler à une véritable fenêtre.

Cette option est particulièrement utile sur les plates-formes qui ne prennent pas en charge les fenêtres multiples. C'était également la seule option avant Qt 6.8.

Afin de s'assurer qu'une fenêtre contextuelle est affichée au-dessus des autres éléments de la scène, il est recommandé d'utiliser ApplicationWindow. ApplicationWindow fournit également des effets d'assombrissement de l'arrière-plan.

Afficher une fenêtre contextuelle dans une fenêtre séparée

En réglant popupType sur Popup.Window, la fenêtre contextuelle sera affichée à l'intérieur d'une fenêtre de niveau supérieur window configurée à l'aide de l'indicateur Qt::Popup. L'utilisation d'une fenêtre pour afficher une fenêtre contextuelle présente l'avantage que la fenêtre contextuelle flotte au-dessus de la fenêtre parentale et peut être placée en dehors de sa géométrie. Pour le reste, la fenêtre contextuelle aura le même aspect que lorsqu'on utilise Popup.Item, c'est-à-dire qu'elle utilisera les mêmes délégués QML et le même style que lorsqu'on utilise Popup.Item.

Afficher une fenêtre contextuelle native

En réglant popupType sur Popup.Native, la fenêtre contextuelle sera affichée à l'aide d'une fenêtre contextuelle native de la plate-forme. Cette fenêtre, et tout son contenu, seront rendus par la plateforme, et non par QML. Cela signifie que les délégués QML affectés à la fenêtre contextuelle ne seront pas utilisés pour le rendu. Si vous utilisez par exemple cette option sur un site Menu, elle sera mise en œuvre à l'aide d'API de menu spécifiques à la plate-forme. En règle générale, la fenêtre contextuelle aura un aspect et une convivialité plus natifs que, par exemple, sur Popup.Window, mais elle souffrira en même temps des limitations de la plate-forme et des différences liées à l'aspect et au comportement. Ces limitations sont documentées plus en détail dans les sous-classes concernées, comme par exemple Menu).

Taille des fenêtres contextuelles

Si un seul élément est utilisé dans une fenêtre contextuelle, celle-ci sera redimensionnée pour s'adapter à la taille implicite de l'élément qu'elle contient. Cela la rend particulièrement adaptée à une utilisation avec des mises en page.

Popup {
    ColumnLayout {
        anchors.fill: parent
        CheckBox { text: qsTr("E-mail") }
        CheckBox { text: qsTr("Calendar") }
        CheckBox { text: qsTr("Contacts") }
    }
}

Il peut arriver que la fenêtre contextuelle contienne deux éléments :

Popup {
    SwipeView {
        // ...
    }
    PageIndicator {
        anchors.horizontalCenter: parent.horizontalCenter
        anchors.bottom: parent.bottom
    }
}

Dans ce cas, la fenêtre contextuelle ne peut pas calculer une taille implicite raisonnable. Comme nous ancrons la page PageIndicator sur la page SwipeView, nous pouvons simplement fixer la taille du contenu à la taille implicite de la vue :

Popup {
    contentWidth: view.implicitWidth
    contentHeight: view.implicitHeight

    SwipeView {
        id: view
        // ...
    }
    PageIndicator {
        anchors.horizontalCenter: parent.horizontalCenter
        anchors.bottom: parent.bottom
    }
 }

Window {
    property double scaleFactor: 2.0

    Scale {
        id: scale
        xScale: scaleFactor
        yScale: scaleFactor
    }
    Item {
        id: scaledContent
        transform: scale

        ComboBox {
            id: combobox
            // ...
        }
    }

    Overlay.overlay.transform: scale
}

Positionnement de la fenêtre contextuelle

Comme pour les éléments de Qt Quick, les coordonnées x et y de la fenêtre contextuelle sont relatives à son parent. Cela signifie que l'ouverture d'une fenêtre contextuelle qui est un enfant d'un bouton Button, par exemple, entraînera le positionnement de la fenêtre contextuelle par rapport au bouton.

L'exemple suivant utilise la propriété attachée Overlay.overlay pour positionner une fenêtre contextuelle au centre de la fenêtre, malgré la position du bouton qui ouvre la fenêtre contextuelle :

Button {
    onClicked: popup.open()

    Popup {
        id: popup

        parent: Overlay.overlay

        x: Math.round((parent.width - width) / 2)
        y: Math.round((parent.height - height) / 2)
        width: 100
        height: 100
    }
}

Une autre façon de centrer une fenêtre contextuelle dans la fenêtre, indépendamment de son élément parent, consiste à utiliser la propriété anchors.centerIn:

ApplicationWindow {
    id: window
    // ...

    Pane {
        // ...

        Popup {
            anchors.centerIn: Overlay.overlay
        }
    }
}

Pour s'assurer que la fenêtre contextuelle est positionnée dans les limites de la fenêtre qui l'entoure, la propriété margins peut être réglée sur une valeur non négative.

Utilisation de la superposition

Dans les cas où popup windows n'est pas utilisé, Popup définit le parent visuel de contentItem comme étant le overlay de la fenêtre, afin de s'assurer que la fenêtre contextuelle apparaît devant tout ce qui se trouve dans la scène. Sa tâche principale consiste à intercepter les événements qui empêchent la livraison d'éléments situés sous une fenêtre contextuelle modal et à fermer la fenêtre contextuelle conformément à son adresse closePolicy.

Dans certains cas, il peut être utile de placer un élément devant une fenêtre contextuelle, par exemple une fenêtre virtual keyboard. Pour ce faire, il faut définir le parent de l'élément comme étant le recouvrement et s'assurer que l'élément est empilé avant tout élément de la fenêtre contextuelle, ce qu'une valeur positive de z permet de garantir.

Il n'est généralement pas recommandé d'utiliser le recouvrement de cette manière, car il n'a pas été conçu à cette fin et le comportement ne sera pas cohérent si l'on modifie la valeur de popupType.

Popup {
    id: popup
    visible: true
    anchors.centerIn: parent
    margins: 10
    closePolicy: Popup.CloseOnEscape
    ColumnLayout {
        TextField {
            placeholderText: qsTr("Username")
        }
        TextField {
            placeholderText: qsTr("Password")
            echoMode: TextInput.Password
        }
    }
}
InputPanel {
    parent: Overlay.overlay
    width: parent.width
    y: popup.y + popup.topMargin + (window.activeFocusItem?.y ?? 0) + (window.activeFocusItem?.height ?? 0)
    z: 1
}

Transitions de type popup

Une fois la transition de sortie terminée, ces propriétés sont remises à leur valeur d'avant le début de la transition d'entrée.

• opacity
• scale

Cela permet aux styles intégrés d'animer ces propriétés sans perdre aucune valeur explicitement définie.

Gestion de l'événement Retour/Escape

Par défaut, une fenêtre contextuelle se ferme si :

• Elle a activeFocus,
• Son adresse closePolicy est Popup.CloseOnEscape, et
• l'utilisateur appuie sur la séquence de touches correspondant à QKeySequence::Cancel (généralement la touche Echap).

Pour éviter que cela ne se produise, il faut soit

• Ne pas donner à la fenêtre contextuelle focus.
• Définissez la valeur de closePolicy de la fenêtre contextuelle de manière à ce qu'elle n'inclue pas Popup.CloseOnEscape.
• Traiter le signal Keys'escapePressed dans un élément enfant de la fenêtre contextuelle de manière à ce qu'il reçoive l'événement avant la fenêtre contextuelle.

Propagation des propriétés

La fenêtre contextuelle hérite des polices, des palettes et des propriétés attachées par l'intermédiaire de sa fenêtre parente, et non de son objet ou de son parent visuel:

import QtQuick.Controls.Basic

ApplicationWindow {
    width: 500
    height: 500
    visible: true
    font.pixelSize: 20
    palette.windowText: "steelblue"

    // This will have a pixelSize of 20 and be "steelblue" in color.
    header: Label {
        text: "ApplicationWindow Label"
        leftPadding: 20
        topPadding: 20
    }

    Pane {
        width: 400
        height: 400
        anchors.centerIn: parent
        palette.window: "#edf3f8"
        palette.windowText: "tomato"

        // This will have a pixelSize of 20 and be "tomato" in color.
        Label {
            text: "Pane Label"
        }

        Popup {
            width: 300
            height: 300
            anchors.centerIn: parent
            font.pixelSize: 10
            visible: true

            // This will have a pixelSize of 10 and "steelblue" in color.
            Label {
                text: "Popup Label"
            }

            Popup {
                width: 200
                height: 200
                anchors.centerIn: parent
                visible: true

                // This will have a pixelSize of 20 and be "steelblue" in color.
                Label {
                    text: "Child Popup Label"
                }
            }
        }
    }
}

En outre, les popups ne propagent pas leurs propriétés aux popups enfants. Ce comportement est calqué sur Qt Widgets, où un widget Qt::Popup est une fenêtre de premier niveau. Les fenêtres de premier niveau ne propagent pas leurs propriétés aux fenêtres enfants.

Certains types dérivés tels que ComboBox sont généralement mis en œuvre de telle sorte que la fenêtre contextuelle est considérée comme faisant partie intégrante du contrôle et, à ce titre, peut hériter d'éléments tels que les propriétés attachées. Par exemple, dans le style Material ComboBox, le thème et les autres propriétés attachées sont explicitement hérités par la fenêtre contextuelle à partir de ComboBox:

popup: T.Popup {
    // ...

    Material.theme: control.Material.theme
    Material.accent: control.Material.accent
    Material.primary: control.Material.primary
}

Ainsi, pour s'assurer qu'une fenêtre contextuelle enfant a les mêmes valeurs de propriété que sa fenêtre parentale, il faut définir explicitement ces propriétés :

Popup {
    id: parentPopup
    // ...

    Popup {
        palette: parentPopup.palette
    }
}

Comportement polonais des fenêtres pop-up fermées

Lorsqu'une fenêtre contextuelle est fermée, elle n'a pas de fenêtre associée, pas plus que ses éléments enfants. Cela signifie que les éléments enfants ne seront pas polished tant que la fenêtre contextuelle ne sera pas affichée. C'est pourquoi vous ne pouvez pas, par exemple, compter sur une ListView à l'intérieur d'une Popup fermée pour mettre à jour sa propriété count:

import QtQuick
import QtQuick.Controls

ApplicationWindow {
    width: 640
    height: 480
    visible: true

    SomeModel {
        id: someModel
    }

    Button {
        text: view.count
        onClicked: popup.open()
    }

    Popup {
        id: popup
        width: 400
        height: 400
        contentItem: ListView {
            id: view
            model: someModel
            delegate: Label {
                text: display

                required property string display
            }
        }
    }
}

Dans l'exemple ci-dessus, le texte du bouton ne sera pas mis à jour lorsque des lignes seront ajoutées ou supprimées de someModel après component completion alors que la fenêtre contextuelle est fermée.

Au lieu de cela, il est possible d'ajouter à SomeModel une propriété count qui est mise à jour chaque fois que les signaux rowsInserted, rowsRemoved et modelReset sont émis. Le site Button peut alors lier cette propriété à son site text.

Voir également Contrôles des fenêtres contextuelles, Personnalisation des fenêtres contextuelles et ApplicationWindow.

Documentation sur les propriétés

activeFocus : bool [read-only]

Cette propriété indique si la fenêtre popup a le focus actif.

Voir également focus et Keyboard Focus dans Qt Quick.

anchors.centerIn : Item [since QtQuick.Controls 2.5 (Qt 5.12)]

Les ancres permettent de positionner un élément en spécifiant sa relation avec d'autres éléments.

Un cas d'utilisation courant consiste à centrer une fenêtre contextuelle à l'intérieur de son parent. Les propriétés x et y constituent un moyen d'y parvenir. Les ancres offrent une approche plus pratique :

Pane {
    // ...

    Popup {
        anchors.centerIn: parent
    }
}

Il est également possible de centrer la fenêtre contextuelle dans la fenêtre en utilisant Overlay:

ApplicationWindow {
    id: window
    // ...

    Pane {
        // ...

        Popup {
            anchors.centerIn: Overlay.overlay
        }
    }
}

Cela permet de centrer facilement une fenêtre contextuelle dans la fenêtre à partir de n'importe quel composant.

Cette propriété a été introduite dans QtQuick.Controls 2.5 (Qt 5.12).

Voir aussi Popup Positioning, anchors, et Using Qt Quick Controls types in property declarations.

availableHeight : real [read-only]

Cette propriété indique la hauteur disponible pour contentItem après déduction de l'espacement vertical de height de la fenêtre contextuelle.

Voir également padding, topPadding, et bottomPadding.

availableWidth : real [read-only]

Cette propriété indique la largeur disponible pour contentItem après déduction de l'espacement horizontal de width de la fenêtre contextuelle.

Voir également padding, leftPadding, et rightPadding.

background : Item

Cette propriété contient l'élément d'arrière-plan.

Voir aussi Personnalisation de la fenêtre contextuelle.

bottomInset : real [since QtQuick.Controls 2.5 (Qt 5.12)]

Cette propriété définit l'encart inférieur de l'arrière-plan.

Cette propriété a été introduite dans QtQuick.Controls 2.5 (Qt 5.12).

Voir aussi Popup Layout et topInset.

bottomMargin : real

Cette propriété indique la distance entre le bord inférieur de la fenêtre contextuelle et le bord inférieur de sa fenêtre.

Une fenêtre contextuelle dont la marge inférieure est négative n'est pas repoussée jusqu'au bord inférieur de la fenêtre qui l'entoure. La valeur par défaut est -1.

Voir également margins, topMargin, et Popup Layout.

bottomPadding : real

Cette propriété définit la marge inférieure. Si elle n'est pas explicitement définie, sa valeur est égale à verticalPadding.

Les propriétés de remplissage sont utilisées pour contrôler la géométrie de la fenêtre content item.

Popup utilise la même approche que Control. Pour une explication visuelle du système de remplissage, voir la section Control Layout de la documentation.

Voir également padding, topPadding, verticalPadding, et availableHeight.

clip : bool

Cette propriété indique si l'écrêtage est activé. La valeur par défaut est false. L'écrêtage ne fonctionne que lorsque la fenêtre contextuelle ne se trouve pas dans sa propre fenêtre.

closePolicy : enumeration

Cette propriété détermine les circonstances dans lesquelles la fenêtre contextuelle se ferme. Les drapeaux peuvent être combinés pour permettre plusieurs façons de fermer la fenêtre contextuelle.

Les valeurs disponibles sont les suivantes

Les règles CloseOnPress* et CloseOnRelease* ne s'appliquent qu'aux événements extérieurs aux fenêtres contextuelles. En d'autres termes, si deux fenêtres contextuelles sont ouvertes et que la première a pour politique Popup.CloseOnPressOutside, le fait de cliquer sur la deuxième fenêtre contextuelle n'entraînera pas la fermeture de la première.

La valeur par défaut est Popup.CloseOnEscape | Popup.CloseOnPressOutside.

contentChildren : list<Item>

Cette propriété contient la liste des enfants du contenu.

La liste contient tous les éléments qui ont été déclarés en QML en tant qu'enfants de la fenêtre contextuelle.

Voir également Item::children et contentData.

contentData : list<QtObject> [default]

Cette propriété contient la liste des données de contenu.

La liste contient tous les objets qui ont été déclarés en QML en tant qu'enfants de la fenêtre contextuelle.

Voir également Item::data et contentChildren.

contentHeight : real

Cette propriété contient la hauteur du contenu. Elle est utilisée pour calculer la hauteur totale implicite de la fenêtre contextuelle.

Pour plus d'informations, voir Popup Sizing.

Voir également contentWidth.

contentItem : Item

Cette propriété contient l'élément de contenu de la fenêtre contextuelle.

L'élément de contenu est l'implémentation visuelle de la fenêtre contextuelle. Lorsque la fenêtre contextuelle est rendue visible, l'élément de contenu est automatiquement réparti sur le site overlay item.

Voir aussi Personnalisation de la fenêtre contextuelle.

contentWidth : real

Cette propriété contient la largeur du contenu. Elle est utilisée pour calculer la largeur totale implicite de la fenêtre contextuelle.

Pour plus d'informations, voir Popup Sizing.

Voir également contentHeight.

dim : bool

Cette propriété indique si la fenêtre contextuelle atténue l'arrière-plan.

À moins qu'elle ne soit explicitement définie, cette propriété suit la valeur de modal. Pour revenir à la valeur par défaut, définissez cette propriété à undefined.

Voir également modal et Overlay.modeless.

enabled : bool [since QtQuick.Controls 2.3 (Qt 5.10)]

Cette propriété indique si la fenêtre contextuelle est activée. La valeur par défaut est true.

Cette propriété a été introduite dans QtQuick.Controls 2.3 (Qt 5.10).

Voir également visible et Item::enabled.

enter : Transition

Cette propriété contient la transition appliquée à l'élément de la fenêtre contextuelle lorsque celle-ci est ouverte et entre dans l'écran.

L'exemple suivant anime l'opacité de la fenêtre contextuelle lorsqu'elle entre dans l'écran :

Popup {
    enter: Transition {
        NumberAnimation { property: "opacity"; from: 0.0; to: 1.0 }
    }
}

Voir aussi exit.

exit : Transition

Cette propriété contient la transition appliquée à l'élément de la fenêtre contextuelle lorsque celle-ci est fermée et quitte l'écran.

L'exemple suivant anime l'opacité de la fenêtre contextuelle lorsqu'elle quitte l'écran :

Popup {
    exit: Transition {
        NumberAnimation { property: "opacity"; from: 1.0; to: 0.0 }
    }
}

Voir aussi enter.

focus : bool

Cette propriété indique si la fenêtre popup souhaite être mise en avant.

Lorsque la fenêtre contextuelle reçoit effectivement le focus, activeFocus sera true. Pour plus d'informations, voir Keyboard Focus à l'adresse Qt Quick.

La valeur par défaut est false.

Voir également activeFocus.

font : font

Cette propriété contient la police de caractères actuellement définie pour la fenêtre contextuelle.

La fenêtre popup propage les propriétés de police explicites à ses enfants. Si vous modifiez une propriété spécifique de la police d'une fenêtre contextuelle, cette propriété se propage à tous les enfants de la fenêtre contextuelle, en remplaçant les valeurs par défaut du système pour cette propriété.

Popup {
    font.family: "Courier"

    Column {
        Label {
            text: qsTr("This will use Courier...")
        }

        Switch {
            text: qsTr("... and so will this")
        }
    }
}

Voir également Control::font et ApplicationWindow::font.

height : real

Cette propriété définit la hauteur de la fenêtre contextuelle.

horizontalPadding : real [since QtQuick.Controls 2.5 (Qt 5.12)]

Cette propriété définit le remplissage horizontal. Si elle n'est pas explicitement définie, sa valeur est égale à padding.

Les propriétés de remplissage sont utilisées pour contrôler la géométrie de la fenêtre content item.

Popup utilise la même approche que Control. Pour une explication visuelle du système de remplissage, voir la section Control Layout de la documentation.

Cette propriété a été introduite dans QtQuick.Controls 2.5 (Qt 5.12).

Voir également padding, leftPadding, rightPadding, et verticalPadding.

implicitBackgroundHeight : real [read-only, since QtQuick.Controls 2.5 (Qt 5.12)]

Cette propriété contient la hauteur implicite de l'arrière-plan.

La valeur est égale à background ? background.implicitHeight : 0.

Cette propriété a été introduite dans QtQuick.Controls 2.5 (Qt 5.12).

Voir également implicitBackgroundWidth et implicitContentHeight.

implicitBackgroundWidth : real [read-only, since QtQuick.Controls 2.5 (Qt 5.12)]

Cette propriété définit la largeur implicite de l'arrière-plan.

La valeur est égale à background ? background.implicitWidth : 0.

Cette propriété a été introduite dans QtQuick.Controls 2.5 (Qt 5.12).

Voir également implicitBackgroundHeight et implicitContentWidth.

implicitContentHeight : real [read-only, since QtQuick.Controls 2.5 (Qt 5.12)]

Cette propriété indique la hauteur implicite du contenu.

La valeur est calculée en fonction des enfants du contenu.

Cette propriété a été introduite dans QtQuick.Controls 2.5 (Qt 5.12).

Voir aussi implicitContentWidth et implicitBackgroundHeight.

implicitContentWidth : real [read-only, since QtQuick.Controls 2.5 (Qt 5.12)]

Cette propriété indique la largeur implicite du contenu.

La valeur est calculée en fonction des enfants du contenu.

Cette propriété a été introduite dans QtQuick.Controls 2.5 (Qt 5.12).

Voir aussi implicitContentHeight et implicitBackgroundWidth.

implicitHeight : real

Cette propriété indique la hauteur implicite de la fenêtre contextuelle.

implicitWidth : real

Cette propriété indique la largeur implicite de la fenêtre contextuelle.

leftInset : real [since QtQuick.Controls 2.5 (Qt 5.12)]

Cette propriété définit l'encart gauche de l'arrière-plan.

Cette propriété a été introduite dans QtQuick.Controls 2.5 (Qt 5.12).

Voir aussi Popup Layout et rightInset.

leftMargin : real

Cette propriété indique la distance entre le bord gauche de la fenêtre contextuelle et le bord gauche de sa fenêtre.

Une fenêtre contextuelle dont la marge gauche est négative n'est pas repoussée à l'intérieur du bord gauche de la fenêtre qui l'entoure. La valeur par défaut est -1.

Voir également margins, rightMargin, et Popup Layout.

leftPadding : real

Cette propriété définit la marge de gauche. Si elle n'est pas explicitement définie, sa valeur est égale à horizontalPadding.

Les propriétés de remplissage sont utilisées pour contrôler la géométrie de la fenêtre content item.

Popup utilise la même approche que Control. Pour une explication visuelle du système de remplissage, voir la section Control Layout de la documentation.

Voir également padding, rightPadding, horizontalPadding, et availableWidth.

locale : Locale

Cette propriété indique le lieu d'affichage de la fenêtre contextuelle.

Voir également mirrored et LayoutMirroring.

margins : real

Cette propriété indique la distance entre les bords de la fenêtre contextuelle et les bords de sa fenêtre.

Une fenêtre contextuelle dont les marges sont négatives n'est pas repoussée dans les limites de la fenêtre qui l'entoure. La valeur par défaut est -1.

Voir également topMargin, leftMargin, rightMargin, bottomMargin, et Popup Layout.

mirrored : bool [read-only, since QtQuick.Controls 2.3 (Qt 5.10)]

Cette propriété indique si la fenêtre contextuelle est en miroir.

Cette propriété est fournie pour des raisons de commodité. Une fenêtre contextuelle est considérée comme miroir lorsque sa disposition visuelle est de droite à gauche, c'est-à-dire lorsque l'on utilise une locale de droite à gauche.

Cette propriété a été introduite dans QtQuick.Controls 2.3 (Qt 5.10).

Voir aussi locale et Interfaces utilisateur de droite à gauche.

modal : bool

Cette propriété indique si la fenêtre contextuelle est modale.

Les fenêtres contextuelles modales ont souvent un effet d'assombrissement de l'arrière-plan défini à l'adresse Overlay.modal, et ne permettent pas aux événements de pression ou de relâchement d'atteindre les éléments qui se trouvent en dessous. Par exemple, si l'utilisateur clique accidentellement à l'extérieur d'une fenêtre contextuelle, tout élément situé sous cette fenêtre à l'endroit du clic ne recevra pas l'événement.

Sur les plates-formes de bureau, il est courant que les fenêtres contextuelles modales ne se ferment que lorsque l'utilisateur appuie sur la touche "Echap". Pour obtenir ce comportement, définissez closePolicy sur Popup.CloseOnEscape. Par défaut, closePolicy est défini sur Popup.CloseOnEscape | Popup.CloseOnPressOutside, ce qui signifie qu'un clic à l'extérieur d'une fenêtre contextuelle modale la fermera.

La valeur par défaut est false.

Voir également dim.

opacity : real

Cette propriété définit l'opacité de la fenêtre contextuelle. L'opacité est spécifiée sous la forme d'un nombre compris entre 0.0 (totalement transparent) et 1.0 (totalement opaque). La valeur par défaut est 1.0.

Voir également visible.

opened : bool [since QtQuick.Controls 2.3 (Qt 5.10)]

Cette propriété indique si la fenêtre contextuelle est entièrement ouverte. La fenêtre est considérée comme ouverte lorsqu'elle est visible et que ni les transitions enter ni exit ne sont en cours d'exécution.

Cette propriété a été introduite dans QtQuick.Controls 2.3 (Qt 5.10).

Voir aussi open(), close(), et visible.

padding : real

Cette propriété contient le remplissage par défaut.

Les propriétés de remplissage sont utilisées pour contrôler la géométrie de la fenêtre content item.

Popup utilise la même approche que Control. Pour une explication visuelle du système de remplissage, voir la section Control Layout de la documentation.

Voir également availableWidth, availableHeight, topPadding, leftPadding, rightPadding, et bottomPadding.

palette : palette [since QtQuick.Controls 2.3 (Qt 5.10)]

Cette propriété contient la palette actuellement définie pour la fenêtre contextuelle.

La fenêtre popup propage les propriétés explicites de la palette à ses enfants. Si vous modifiez une propriété spécifique de la palette d'une fenêtre contextuelle, cette propriété se propage à tous les enfants de la fenêtre, en remplaçant les valeurs par défaut du système pour cette propriété.

Popup {
    palette.text: "red"

    Column {
        Label {
            text: qsTr("This will use red color...")
        }

        Switch {
            text: qsTr("... and so will this")
        }
    }
}

Voir aussi Item::palette, Window::palette, ColorGroup, Palette

Cette propriété a été introduite dans QtQuick.Controls 2.3 (Qt 5.10).

parent : Item

Cette propriété contient l'élément parent.

popupType : enumeration [since 6.8]

Cette propriété détermine le type de fenêtre contextuelle préféré.

Options disponibles :

Le fait qu'une fenêtre contextuelle puisse utiliser le type préféré dépend de la plate-forme. Popup.Item est pris en charge sur toutes les plates-formes, mais Popup.Window et Popup.Native ne sont normalement pris en charge que sur les plates-formes de bureau. En outre, si une fenêtre contextuelle est une Menu à l'intérieur d'une native menubar, le menu sera également natif. Et si le menu est un sous-menu à l'intérieur d'un autre menu, c'est le menu parent (ou racine) qui détermine le type.

La valeur par défaut est généralement Popup.Item, à quelques exceptions près, mentionnées ci-dessus. Cela pourrait changer dans les futures versions de Qt, pour certains styles et plateformes qui bénéficient de l'utilisation d'autres types de fenêtres contextuelles. Si vous souhaitez toujours utiliser les menus natifs pour tous les styles sur macOS, par exemple, vous pouvez le faire :

Menu {
    popupType: Qt.platform.os === "osx" ? Popup.Native : Popup.Window
}

De même, si vous choisissez de personnaliser une fenêtre contextuelle (par exemple en changeant l'un des délégués), vous devriez envisager de définir le type de fenêtre contextuelle à Popup.Window. Ainsi, vos modifications seront visibles sur toutes les plateformes et pour tous les styles. Sinon, lorsque des menus natifs sont utilisés, les délégués ne seront pas utilisés pour le rendu.

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

Voir aussi Popup type.

rightInset : real [since QtQuick.Controls 2.5 (Qt 5.12)]

Cette propriété définit l'insertion droite de l'arrière-plan.

Cette propriété a été introduite dans QtQuick.Controls 2.5 (Qt 5.12).

Voir aussi Popup Layout et leftInset.

rightMargin : real

Cette propriété indique la distance entre le bord droit de la fenêtre contextuelle et le bord droit de sa fenêtre.

Une fenêtre contextuelle dont la marge droite est négative n'est pas repoussée à l'intérieur du bord droit de la fenêtre qui l'entoure. La valeur par défaut est -1.

Voir également margins, leftMargin, et Popup Layout.

rightPadding : real

Cette propriété contient la marge de droite. Si elle n'est pas explicitement définie, sa valeur est égale à horizontalPadding.

Les propriétés de remplissage sont utilisées pour contrôler la géométrie de la fenêtre content item.

Popup utilise la même approche que Control. Pour une explication visuelle du système de remplissage, voir la section Control Layout de la documentation.

Voir également padding, leftPadding, horizontalPadding, et availableWidth.

scale : real

Cette propriété contient le facteur d'échelle de la fenêtre contextuelle. La valeur par défaut est 1.0.

Une échelle inférieure à 1.0 réduit la taille de la fenêtre contextuelle, tandis qu'une échelle supérieure à 1.0 l'agrandit. Les échelles négatives ne sont pas prises en charge.

spacing : real [since QtQuick.Controls 2.1 (Qt 5.8)]

Cette propriété définit l'espacement.

L'espacement est utile pour les fenêtres pop-up dont les éléments constitutifs sont multiples ou répétitifs. Par exemple, certains styles utilisent l'espacement pour déterminer la distance entre l'en-tête, le contenu et le pied de page de Dialog. L'espacement n'est pas imposé par Popup, de sorte que chaque style peut l'interpréter différemment, et certains peuvent l'ignorer complètement.

Cette propriété a été introduite dans QtQuick.Controls 2.1 (Qt 5.8).

topInset : real [since QtQuick.Controls 2.5 (Qt 5.12)]

Cette propriété définit l'encart supérieur de l'arrière-plan.

Cette propriété a été introduite dans QtQuick.Controls 2.5 (Qt 5.12).

Voir aussi Popup Layout et bottomInset.

topMargin : real

Cette propriété indique la distance entre le bord supérieur de la fenêtre contextuelle et le bord supérieur de sa fenêtre.

Une fenêtre contextuelle dont la marge supérieure est négative n'est pas repoussée à l'intérieur du bord supérieur de la fenêtre qui l'entoure. La valeur par défaut est -1.

Voir également margins, bottomMargin, et Popup Layout.

topPadding : real

Cette propriété définit la marge supérieure. Si elle n'est pas explicitement définie, sa valeur est égale à verticalPadding.

Les propriétés de remplissage sont utilisées pour contrôler la géométrie de la fenêtre content item.

Popup utilise la même approche que Control. Pour une explication visuelle du système de remplissage, voir la section Control Layout de la documentation.

Voir également padding, bottomPadding, verticalPadding, et availableHeight.

transformOrigin : enumeration

Cette propriété contient le point d'origine des transformations dans les transitions d'entrée et de sortie.

Neuf origines de transformation sont disponibles, comme le montre l'image ci-dessous. L'origine de la transformation par défaut est Popup.Center.

Voir aussi enter, exit, et Item::transformOrigin.

verticalPadding : real [since QtQuick.Controls 2.5 (Qt 5.12)]

Cette propriété définit le remplissage vertical. Si elle n'est pas explicitement définie, sa valeur est égale à padding.

Les propriétés de remplissage sont utilisées pour contrôler la géométrie de la fenêtre content item.

Popup utilise la même approche que Control. Pour une explication visuelle du système de remplissage, voir la section Control Layout de la documentation.

Cette propriété a été introduite dans QtQuick.Controls 2.5 (Qt 5.12).

Voir également padding, topPadding, bottomPadding, et horizontalPadding.

visible : bool

Cette propriété indique si la fenêtre contextuelle est visible. La valeur par défaut est false.

Voir également open(), close() et opened.

width : real

Cette propriété définit la largeur de la fenêtre contextuelle.

x : real

Cette propriété contient la coordonnée x de la fenêtre contextuelle.

Voir également y et z.

y : real

Cette propriété contient la coordonnée y de la fenêtre contextuelle.

Voir également x et z.

z : real

Cette propriété contient la valeur z de la fenêtre contextuelle. La valeur z détermine l'ordre d'empilement des fenêtres contextuelles.

Si deux fenêtres contextuelles visibles ont la même valeur z, c'est la dernière à avoir été ouverte qui sera placée au-dessus.

Si une fenêtre popup n'a pas de valeur z explicitement définie lors de son ouverture et qu'elle est l'enfant d'une fenêtre popup déjà ouverte, elle sera empilée au-dessus de son parent. Cela permet de s'assurer que les enfants ne sont jamais cachés sous leurs parents.

Si la fenêtre popup possède sa propre fenêtre, la valeur z déterminera l'ordre d'empilement de la fenêtre.

La valeur z par défaut est 0.

Voir également x et y.

Documentation sur les signaux

void aboutToHide()

Ce signal est émis lorsque la fenêtre contextuelle est sur le point de se cacher.

Voir aussi closed().

void aboutToShow()

Ce signal est émis lorsque la fenêtre contextuelle est sur le point de s'afficher.

Voir aussi opened().

void closed()

Ce signal est émis lorsque la fenêtre popup est fermée.

Voir aussi aboutToHide().

void opened()

Ce signal est émis lorsque la fenêtre contextuelle est ouverte.

Voir aussi aboutToShow().

Documentation de la méthode

void close()

Ferme la fenêtre contextuelle.

Voir aussi visible.

void forceActiveFocus(enumeration reason = Qt.OtherFocusReason)

Force la focalisation active sur la fenêtre contextuelle avec l'objet reason.

Cette méthode met l'accent sur la fenêtre contextuelle et veille à ce que tous les objets ancêtres FocusScope dans la hiérarchie des objets reçoivent également focus.

Voir également activeFocus et Qt::FocusReason.

void open()

Ouvre la fenêtre contextuelle.

Voir aussi visible.