Popup QML Type

Type de base des contrôles d'interface utilisateur de type « popup ». En savoir plus...

• 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 fenêtre contextuelle. 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
    }
}

Popup ne fournit pas de mise en page propre, mais vous oblige à positionner son contenu, par exemple en créant un RowLayout ou un ColumnLayout.

Les éléments déclarés comme enfants d’un Popup sont automatiquement rattachés à l’ contentItem du Popup. Les éléments créés dynamiquement doivent être explicitement rattachés à l’ contentItem.

Disposition d’une fenêtre contextuelle

Le schéma suivant illustre la disposition d’une fenêtre contextuelle au sein d’une fenêtre :

Les propriétés « 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, auxquelles s’ajoutent les marges intérieures et extérieures. Ces propriétés déterminent la taille de la fenêtre contextuelle lorsqu’aucune propriété explicite « width » ou « height » n’est spécifiée.

La géométrie de l’ contentItem est déterminée par le padding. L’exemple suivant réserve un padding de 10 px entre les bords de la fenêtre contextuelle et son contenu :

Popup {
    padding: 10

    contentItem: Text {
        text: "Content"
    }
}

L’élément « background » occupe toute la largeur et toute la hauteur de la fenêtre contextuelle, sauf si des marges intérieures ou une taille explicite lui ont été attribuées.

Des insets négatifs peuvent être utilisés pour agrandir l’arrière-plan au-delà de la fenêtre contextuelle. L’exemple suivant utilise des insets négatifs pour placer une ombre à l’extérieur 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 fenêtre contextuelle

Depuis Qt 6.8, certaines fenêtres contextuelles, telles que ` Menu`, proposent trois implémentations différentes selon la plateforme. Vous pouvez choisir celle que vous préférez en définissant ` popupType`.

La possibilité pour une fenêtre contextuelle d’utiliser le type préféré dépend de la plateforme. ` Popup.Item ` est pris en charge sur toutes les plateformes, mais ` Popup.Window ` et ` Popup.Native ` ne sont normalement pris en charge que sur les plateformes de bureau. De plus, 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éterminera le type.

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

En définissant ` popupType ` sur ` Popup.Item`, la fenêtre contextuelle ne s’affichera pas dans une fenêtre distincte, mais sous forme d’élément au sein de la même scène que son parent. Cet élément est rattaché à l’ overlay de cette scène et stylisé pour ressembler à une véritable fenêtre.

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

Afin de garantir qu’une fenêtre contextuelle s’affiche au-dessus des autres éléments de la scène, il est recommandé d’utiliser ` ApplicationWindow`. ` ApplicationWindow ` offre également des effets de gradation de l’arrière-plan.

Afficher une fenêtre contextuelle dans une fenêtre distincte

En définissant ` popupType ` sur ` Popup.Window`, la fenêtre contextuelle s'affichera à l'intérieur d'une ` window ` de niveau supérieur configurée avec l'indicateur ` Qt::Popup `. L'utilisation d'une fenêtre pour afficher une fenêtre contextuelle présente l'avantage que celle-ci flottera au-dessus de la fenêtre parente et pourra être placée en dehors de sa géométrie. Sinon, la fenêtre contextuelle aura le même aspect que lors de l’utilisation de ` Popup.Item`, c’est-à-dire qu’elle utilisera les mêmes délégués QML et le même style que lors de l’utilisation de ` Popup.Item`.

Affichage d’une fenêtre contextuelle native

En définissant popupType sur Popup.Native, la fenêtre contextuelle s’affichera à l’aide d’une fenêtre contextuelle native de la plateforme. Cette fenêtre, ainsi que tout son contenu, sera rendue par la plateforme, et non par QML. Cela signifie que les délégués QML attribués à la fenêtre contextuelle ne seront pas utilisés pour le rendu. Si, par exemple, vous utilisez cette option sur un « Menu », celui-ci sera implémenté à l’aide d’API de menu spécifiques à la plateforme. Cela conférera généralement à la fenêtre contextuelle un aspect et un comportement plus natifs que, par exemple, Popup.Window, mais elle sera en revanche soumise aux limitations et différences de la plateforme en matière d’apparence et de comportement. Ces limitations sont documentées plus en détail dans les sous-classes concernées, comme par exemple pour Menu.

Dimensionnement de la fenêtre contextuelle

Si un seul élément est utilisé dans une fenêtre contextuelle, celle-ci s’adaptera à 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 parfois y avoir deux éléments dans la fenêtre contextuelle :

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

Dans ce cas, la fenêtre contextuelle ne peut pas calculer de taille implicite pertinente. Puisque nous ancrons la balise ` PageIndicator ` au-dessus de la balise ` SwipeView`, nous pouvons simplement définir la taille du contenu sur 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

À l’instar des éléments décrits dans Qt Quick, les coordonnées x et y d’une fenêtre contextuelle sont relatives à son élément 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 à ce bouton.

L'exemple suivant utilise la propriété Overlay.overlay ci-jointe pour positionner une fenêtre contextuelle au centre de la fenêtre, quelle que soit la position du bouton qui l'ouvre :

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, quel que soit son élément parent, consiste à utiliser ` anchors.centerIn` :

ApplicationWindow {
    id: window
    // ...

    Pane {
        // ...

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

Pour s’assurer que la fenêtre contextuelle soit positionnée dans les limites de la fenêtre qui l’entoure, la propriété ` margins ` peut être définie sur une valeur non négative.

Utilisation de l’overlay

Lorsque l’ popup windows n’est pas utilisé, Popup définit le parent visuel de son contentItem comme étant le overlay de la fenêtre, afin de garantir que la fenêtre contextuelle s’affiche devant tous les autres éléments de la scène. Sa tâche principale consiste à intercepter les événements pour empêcher leur transmission aux éléments situés sous une fenêtre contextuelle modal, et à fermer la fenêtre contextuelle conformément à son closePolicy.

Dans certains cas, il peut s’avérer utile de placer un élément devant une fenêtre contextuelle, comme par exemple un virtual keyboard. Actuellement, cela ne peut être réalisé qu’en définissant le parent de l’élément comme étant la superposition (overlay) et en s’assurant que l’élément est superposé avant tout élément de la fenêtre contextuelle, ce que garantit une valeur positive de z.

Il n’est généralement pas recommandé d’utiliser la superposition de cette manière, car elle n’a pas été conçue à cette fin et le comportement ne sera pas cohérent en cas de modification de l’ 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 des fenêtres contextuelles

Une fois la transition de sortie terminée, ces propriétés seront réinitialisées à leurs valeurs antérieures au 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 des événements « Retour » et « Échap »

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

• elle possède l'attribut « activeFocus »,
• son « closePolicy » est défini sur « Popup.CloseOnEscape », et
• l'utilisateur appuie sur la combinaison de touches correspondant à l'QKeySequence::Cancel (généralement la touche Échap).

Pour éviter cela, procédez de l’une des deux manières suivantes :

• Ne pas attribuer d’ focus à la fenêtre contextuelle.
• Définissez l’ closePolicy de la fenêtre contextuelle sur une valeur qui n’inclut pas Popup.CloseOnEscape.
• Gérez le signal « Keys » ( escapePressed ) dans un élément enfant de la fenêtre contextuelle afin 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 associées via sa fenêtre parente, et non via son objet ou 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"
                }
            }
        }
    }
}

De plus, les fenêtres contextuelles ne propagent pas leurs propriétés aux fenêtres contextuelles enfants. Ce comportement s’inspire d’ Qt Widgets, où un widget Qt::Popup est une fenêtre de niveau supérieur. Les fenêtres de niveau supérieur ne propagent pas leurs propriétés aux fenêtres enfants.

Certains types dérivés, comme ComboBox, sont généralement implémentés de telle sorte que la fenêtre contextuelle soit considérée comme faisant partie intégrante du contrôle et, à ce titre, puisse hériter d’éléments tels que les propriétés associées. Par exemple, dans la fenêtre contextuelle de style Material ComboBox, le thème et d’autres propriétés associées sont explicitement hérités par la fenêtre contextuelle de l’ ComboBox elle-même :

popup: T.Popup {
    // ...

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

Ainsi, pour vous assurer qu’une fenêtre contextuelle enfant possède les mêmes valeurs de propriétés que sa fenêtre contextuelle parente, définissez explicitement ces propriétés :

Popup {
    id: parentPopup
    // ...

    Popup {
        palette: parentPopup.palette
    }
}

Amélioration du comportement des pop-ups fermés

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. Pour cette raison, vous ne pouvez pas, par exemple, compter sur une fenêtre contextuelle de type « ListView » au sein d’une fenêtre contextuelle de type « 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 ` tant que la fenêtre contextuelle est fermée.

À la place, une propriété « count » peut être ajoutée à « SomeModel » ; celle-ci est mise à jour chaque fois que les signaux « rowsInserted », « rowsRemoved » et « modelReset » sont émis. Le « Button » peut alors lier cette propriété à son « text ».

Voir également «Contrôles contextuels », « 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 contextuelle a le focus.

Voir également « focus » et « Keyboard Focus » sur Qt Quick.

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

Les ancrages 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 au sein de son élément parent. Pour ce faire, on peut notamment utiliser les propriétés ` x ` et ` y `. Les ancrages offrent une approche plus pratique :

Pane {
    // ...

    Popup {
        anchors.centerIn: parent
    }
}

Il est également possible de centrer la fenêtre contextuelle dans la fenêtre à l'aide de la propriété ` 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 également Popup Positioning, anchors et Using Qt Quick Controls types in property declarations.

availableHeight : real [read-only]

Cette propriété indique la hauteur dont dispose l'contentItem, une fois le remplissage vertical (padding) soustrait de la hauteur totale ( height ) de la fenêtre contextuelle.

Voir également padding, topPadding et bottomPadding.

availableWidth : real [read-only]

Cette propriété indique la largeur disponible pour l'contentItem, après déduction du remplissage horizontal de l'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 également Personnalisation des fenêtres contextuelles.

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

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

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

Voir également Popup Layout et topInset.

bottomMargin : real

Cette propriété définit la distance entre le bord inférieur de la fenêtre contextuelle et le bord inférieur de la fenêtre qui la contient.

Une fenêtre contextuelle dont la marge inférieure est négative n'est pas déplacée sous le 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 le remplissage inférieur. À moins d'être explicitement définie, sa valeur est égale à verticalPadding.

Les propriétés de remplissage servent à contrôler la géométrie de l'content item.

La fenêtre contextuelle utilise la même approche que ` Control` pour le remplissage. Pour une explication visuelle du système de remplissage, consultez la section « Control Layout » de la documentation.

Voir également padding, topPadding, verticalPadding et availableHeight.

clip : bool

Cette propriété s'applique que le découpage soit activé ou non. La valeur par défaut est « false ». Le découpage ne fonctionne que lorsque la fenêtre contextuelle n'est pas affichée dans sa propre fenêtre.

closePolicy : enumeration

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

Les valeurs disponibles sont les suivantes :

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

contentChildren : list<Item>

Cette propriété contient la liste des éléments enfants de contenu.

Cette liste contient tous les éléments qui ont été déclarés en QML comme 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.

Cette 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 sert à calculer la hauteur implicite totale de la fenêtre contextuelle.

Pour plus d'informations, consultez 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 correspond à la représentation visuelle de la fenêtre contextuelle. Lorsque la fenêtre contextuelle est affichée, l'élément de contenu est automatiquement rattaché à l'overlay item.

Voir également Personnalisation d’une fenêtre contextuelle.

contentWidth : real

Cette propriété contient la largeur du contenu. Elle sert à calculer la largeur implicite totale de la fenêtre contextuelle.

Pour plus d'informations, consultez Popup Sizing.

Voir également contentHeight.

dim : bool

Cette propriété détermine si la fenêtre contextuelle assombrit l'arrière-plan.

Sauf indication contraire, cette propriété reprend la valeur de modal. Pour revenir à la valeur par défaut, définissez cette propriété sur 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é définit la transition appliquée à l'élément contextuel lorsque celui-ci s'ouvre et apparaît à l'écran.

L'exemple suivant anime l'opacité de la fenêtre contextuelle lorsqu'elle apparaît à l'écran :

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

Voir également exit.

exit : Transition

Cette propriété définit la transition appliquée à l'élément contextuel lorsque celui-ci se ferme 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 également enter.

focus : bool

Cette propriété indique si la fenêtre contextuelle souhaite obtenir le focus.

Lorsque la fenêtre contextuelle reçoit effectivement le focus, la valeur de « activeFocus » devient « true ». Pour plus d'informations, consultez la section « Focus clavier » à l'adresse Qt Quick.

La valeur par défaut est ` false`.

Voir également activeFocus.

font : font

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

La fenêtre contextuelle transmet les propriétés de police explicites à ses éléments enfants. Si vous modifiez une propriété spécifique de la police d'une fenêtre contextuelle, cette propriété est transmise à tous les éléments enfants de la fenêtre contextuelle, remplaçant ainsi 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é indique 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. À moins d'être explicitement définie, sa valeur est égale à « padding ».

Les propriétés de remplissage servent à contrôler la géométrie de l'élément « content item ».

La propriété `Popup` utilise la même approche que ` Control` pour le remplissage. Pour une explication visuelle du système de remplissage, consultez 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é définit la hauteur implicite de l'arrière-plan.

Sa 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.

Sa 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é contient la hauteur implicite du contenu.

Sa valeur est calculée en fonction des éléments enfants du contenu.

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

Voir également implicitContentWidth et implicitBackgroundHeight.

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

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

Sa valeur est calculée en fonction des éléments enfants du contenu.

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

Voir également implicitContentHeight et implicitBackgroundWidth.

implicitHeight : real

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

implicitWidth : real

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

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

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

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

Voir également 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 la fenêtre qui la contient.

Une fenêtre contextuelle dont la marge gauche est négative n'est pas décalée vers 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 le remplissage à gauche. Sauf indication contraire, sa valeur est égale à « horizontalPadding ».

Les propriétés de remplissage servent à contrôler la géométrie de l'content item.

La fenêtre contextuelle utilise la même approche que ` Control` pour le remplissage. Pour une explication visuelle du système de remplissage, consultez la section « Control Layout » de la documentation.

Voir également padding, rightPadding, horizontalPadding et availableWidth.

locale : Locale

Cette propriété définit les paramètres régionaux de la fenêtre contextuelle.

Voir également mirrored et LayoutMirroring.

margins : real

Cette propriété définit la distance entre les bords de la fenêtre contextuelle et ceux de la fenêtre qui l'entoure.

Une fenêtre contextuelle dont les marges sont négatives n'est pas déplacée à l'intérieur des 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 inversée.

Cette propriété est fournie à titre pratique. Une fenêtre contextuelle est considérée comme inversée lorsque son sens de mise en page est de droite à gauche, c'est-à-dire lorsqu'on utilise une locale de droite à gauche.

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

Voir également « 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 présentent souvent un effet de gradation de l'arrière-plan caractéristique, défini dans ` Overlay.modal`, et ne laissent pas passer les événements de clic ou de relâchement vers les éléments situés en dessous. Par exemple, si l'utilisateur clique accidentellement en dehors d'une fenêtre contextuelle, aucun élément situé sous cette fenêtre à l'emplacement du clic ne recevra l'événement.

Sur les plateformes de bureau, il est courant que les fenêtres contextuelles modales ne se ferment que lorsque la touche Échap est enfoncée. 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 en dehors 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 (entièrement transparent) et 1.0 (entièrement 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 contextuelle est considérée comme ouverte lorsqu'elle est visible et qu'aucune transition de type « enter » ou « exit » n'est en cours.

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

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

padding : real

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

Les propriétés de remplissage permettent de contrôler la géométrie de l'content item.

La fenêtre contextuelle utilise la même approche que l'Control en matière de remplissage. Pour une explication visuelle du système de remplissage, consultez 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 contextuelle transmet les propriétés explicites de la palette à ses éléments enfants. Si vous modifiez une propriété spécifique de la palette d'une fenêtre contextuelle, cette propriété est transmise à tous les éléments enfants de la fenêtre contextuelle, remplaçant ainsi 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 privilégié.

Options disponibles :

La possibilité pour une fenêtre contextuelle d’utiliser le type préféré dépend de la plateforme. Le type « Popup.Item » est pris en charge sur toutes les plateformes, mais les types « Popup.Window » et « Popup.Native » ne sont généralement pris en charge que sur les plateformes de bureau. De plus, si une fenêtre contextuelle est une « Menu » (fenêtre contextuelle) à l’intérieur d’un « native menubar » (menu), le menu sera également natif. Et si le menu est un sous-menu situé à l'intérieur d'un autre menu, c'est le menu parent (ou racine) qui déterminera 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 certaines plateformes qui tireraient avantage de l’utilisation d’autres types de menus contextuels. Si vous souhaitez toujours utiliser des menus natifs pour tous les styles sous macOS, par exemple, vous pouvez procéder ainsi :

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

De même, si vous choisissez de personnaliser une fenêtre contextuelle (en modifiant par exemple l’un des délégués), vous devriez également envisager de définir le type de fenêtre contextuelle sur « Popup.Window ». Cela garantira que 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 également Popup type.

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

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

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

Voir également 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 décalée vers 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é définit le remplissage à droite. Sauf indication contraire, sa valeur est égale à horizontalPadding.

Les propriétés de remplissage servent à contrôler la géométrie de l'content item.

La fenêtre contextuelle utilise la même approche que « Control » pour le remplissage. Pour une explication visuelle du système de remplissage, consultez la section « Control Layout » de la documentation.

Voir également padding, leftPadding, horizontalPadding et availableWidth.

scale : real

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

Un facteur d'échelle inférieur à 1.0 entraîne l'affichage de la fenêtre contextuelle dans une taille réduite, tandis qu'un facteur d'échelle supérieur à 1.0 entraîne son affichage dans une taille plus grande. Les facteurs d'échelle négatifs ne sont pas pris 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 contextuelles comportant plusieurs éléments constitutifs ou des éléments 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 ; chaque style peut donc l'interpréter différemment, et certains peuvent même 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 le décalage vers le haut de l'arrière-plan.

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

Voir également 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 la fenêtre qui la contient.

Une fenêtre contextuelle dont la marge supérieure est négative n'est pas décalée vers 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 le remplissage supérieur. Sauf indication contraire, sa valeur est égale à « verticalPadding ».

Les propriétés de remplissage servent à contrôler la géométrie de l'content item.

La fenêtre contextuelle utilise la même approche que ` Control` pour le remplissage. Pour une explication visuelle du système de remplissage, consultez la section « Control Layout » de la documentation.

Voir également padding, bottomPadding, verticalPadding et availableHeight.

transformOrigin : enumeration

Cette propriété définit le point d'origine des transformations lors des transitions d'entrée et de sortie.

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

Voir également enter, exit et Item::transformOrigin.

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

Cette propriété définit le remplissage vertical. À moins d'être explicitement définie, sa valeur est égale à « padding ».

Les propriétés de remplissage permettent de contrôler la géométrie de l'content item.

La propriété `Popup` utilise la même approche que ` Control` pour le remplissage. Pour une explication visuelle du système de remplissage, consultez 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étermine 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, celle qui a été ouverte en dernier apparaîtra au premier plan.

Si une fenêtre contextuelle n'a pas de valeur z explicitement définie lors de son ouverture et qu'elle est une fille d'une fenêtre contextuelle déjà ouverte, elle sera alors superposée à sa mère. Cela garantit que les filles ne sont jamais masquées sous leurs mères.

Si la fenêtre contextuelle dispose de sa propre fenêtre, la valeur z déterminera alors l'ordre d'empilement des fenêtres.

La valeur z par défaut est 0.

Voir également x et y.

Documentation Signal

void aboutToHide()

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

Voir également closed().

void aboutToShow()

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

Voir également opened().

void closed()

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

Voir également aboutToHide().

void opened()

Ce signal est émis lorsque la fenêtre contextuelle s'ouvre.

Voir également aboutToShow().

Documentation de la méthode

void close()

Ferme la fenêtre contextuelle.

Voir aussi visible.

void forceActiveFocus(enumeration reason = Qt.OtherFocusReason)

Force le focus sur la fenêtre contextuelle contenant l'reason spécifiée.

Cette méthode place le focus sur la fenêtre contextuelle et garantit que tous les objets FocusScope ancêtres dans la hiérarchie des objets se voient également attribuer la valeur focus.

Voir également activeFocus et Qt::FocusReason.

void open()

Ouvre la fenêtre contextuelle.

Voir aussi visible.