Qt QML Type

Fournit un objet global contenant des énumérations et des fonctions utiles issues de Qt. En savoir plus…

• Liste de tous les membres, y compris les membres hérités
• Membres obsolètes

Propriétés

• application : Application
• inputMethod : InputMethod
• platform : var
• styleHints : QtObject
• uiLanguage : string

Méthodes

• string QT_TRANSLATE_NOOP(string context, string sourceText, string disambiguation)
• string QT_TRID_NOOP(string id)
• string QT_TR_NOOP(string sourceText, string disambiguation)
• color alpha(color baseColor, real value)
• ArrayBuffer atob(ArrayBuffer data) (since 6.11)
• var atob(var data) (since 6.11)
• var binding(var function)
• ArrayBuffer btoa(ArrayBuffer data) (since 6.11)
• var btoa(var data) (since 6.11)
• void callLater(function)
• void callLater(function, argument1, argument2, ...)
• color color(string name)
• color colorEqual(color lhs, string rhs)
• Component createComponent(url url, enumeration mode, QtObject parent)
• Component createComponent(string moduleUri, string typeName, enumeration mode, QtObject parent) (since 6.5)
• QtObject createQmlObject(string qml, QtObject parent, url url)
• color darker(color baseColor, real factor)
• real enumStringToValue(enumType, keyName)
• string enumValueToString(enumType, keyValue)
• list<string> enumValueToStrings(enumType, keyValue)
• string escapeHtml(string data) (since 6.12)
• void exit(int retCode)
• font font(var fontSpecifier)
• list<string> fontFamilies()
• string formatDate(datetime date, variant format, variant localeFormatOption)
• string formatDateTime(datetime dateTime, variant format, variant localeFormatOption)
• string formatTime(datetime time, variant format, variant localeFormatOption)
• void gc()
• color hsla(real hue, real saturation, real lightness, real alpha)
• color hsva(real hue, real saturation, real value, real alpha)
• bool isQtObject(object)
• color lighter(color baseColor, real factor)
• locale locale(name)
• string md5(data)
• matrix4x4 matrix4x4()
• matrix4x4 matrix4x4(var values)
• matrix4x4 matrix4x4(real m11, real m12, real m13, real m14, real m21, real m22, real m23, real m24, real m31, real m32, real m33, real m34, real m41, real m42, real m43, real m44)
• bool openUrlExternally(url target)
• point point(real x, real y)
• string qsTr(string sourceText, string disambiguation, int n)
• string qsTrId(string id, int n)
• string qsTranslate(string context, string sourceText, string disambiguation, int n)
• quaternion quaternion(real scalar, real x, real y, real z)
• void quit()
• rect rect(real x, real y, real width, real height)
• url resolvedUrl(url url)
• url resolvedUrl(url url, object context)
• color rgba(real red, real green, real blue, real alpha)
• size size(real width, real height)
• color tint(color baseColor, color tintColor)
• url url(url url)
• vector2d vector2d(real x, real y)
• vector3d vector3d(real x, real y, real z)
• vector4d vector4d(real x, real y, real z, real w)

Description détaillée

Qt est un type singleton qui fournit des fonctions utilitaires, des propriétés et des énumérations. Voici un exemple illustrant comment utiliser ce type :

import QtQuick 2.0

Text {
    color: Qt.rgba(1, 0, 0, 1)
    text: Qt.md5("hello, world")
}

Énumérations

L'objet Qt contient les énumérations disponibles dans la classe ` Qt Namespace`. Par exemple, vous pouvez accéder aux valeurs d'énumération ` Qt::LeftButton ` et ` Qt::RightButton ` respectivement sous les noms ` Qt.LeftButton ` et ` Qt.RightButton`.

Types

L’objet Qt contient également des fonctions d’aide permettant de créer des objets de types de données spécifiques. Cela s’avère particulièrement utile lors de la définition des propriétés d’un élément lorsque la propriété est de l’un des types suivants :

• rect - utiliser ` Qt.rect()`
• point - utiliser Qt.point()
• size - utiliser Qt.size()

Si le module QtQuick a été importé, les fonctions d'aide suivantes permettant de créer des objets de types de données spécifiques sont également à la disposition des clients :

• color - use Qt.rgba(), Qt.hsla(), Qt.darker(), Qt.lighter() ou Qt.tint()
• font - utiliser Qt.font()
• vector2d - utilisez Qt.vector2d()
• vector3d - utiliser Qt.vector3d()
• vector4d - utiliser Qt.vector4d()
• quaternion - utiliser Qt.quaternion()
• matrix4x4 - utiliser Qt.matrix4x4()

Formateurs de date et d'heure

L'objet Qt contient plusieurs fonctions permettant de formater les valeurs de type QDateTime, QDate et QTime.

• string Qt.formatDateTime(datetime date, variant format)
• string Qt.formatDate(datetime date, variant format)
• string Qt.formatTime(datetime date, variant format)

La spécification de format est décrite à l'adresse Qt.formatDateTime.

Création dynamique d'objets

Les fonctions suivantes de l’objet global vous permettent de créer dynamiquement des éléments QML à partir de fichiers ou de chaînes de caractères. Consultez la section « Création dynamique d’objets QML à partir de JavaScript » pour un aperçu de leur utilisation.

• object Qt.createComponent(url)
• object Qt.createQmlObject(string qml, object parent, url url)

Autres fonctions

Les fonctions suivantes sont également disponibles sur l'objet Qt.

• Qt.quit()
• Qt.md5(chaîne de caractères)
• string Qt.btoa(string)
• string Qt.atob(string)
• object Qt.binding(function)
• object Qt.locale()
• string Qt.resolvedUrl(string)
• Qt.openUrlExternally(chaîne de caractères)
• list<string> Qt.fontFamilies()

Documentation sur les propriétés

application : Application

L'objet ` application ` permet d'accéder aux propriétés d'état globales de l'application, partagées par de nombreux composants QML.

Il s'agit du même objet que le singleton ` Application `.

L'exemple suivant utilise l'objet ` application ` pour indiquer si l'application est actuellement active :

import QtQuick

Rectangle {
    width: 300; height: 55
    color: Qt.application.active ? "white" : "lightgray"
    Text {
        text: "Application " + (Qt.application.active ? "active" : "inactive")
        opacity: Qt.application.active ? 1.0 : 0.5
        anchors.centerIn: parent
    }
}

• application.active
• application.state
• application.layoutDirection
• application.font

inputMethod : InputMethod

Il s'agit du même objet que le singleton « InputMethod ».

L'objet ` inputMethod ` permet d'accéder à l'objet ` QInputMethod ` de l'application ainsi qu'à toutes ses propriétés et ses slots. Pour plus de détails, consultez la documentation relative à ` QInputMethod `.

platform : var

L'objet « platform » fournit des informations sur la plateforme sous-jacente.

Ses propriétés sont les suivantes :

styleHints : QtObject

L'objet ` styleHints ` fournit des conseils de style et des paramètres spécifiques à chaque plateforme. Consultez la documentation de ` QStyleHints ` pour plus de détails.

Il est préférable d’accéder à StyleHints via Application::styleHints, car cela fournit de meilleures informations de type pour les outils tels que le Qt Quick Compiler.

uiLanguage : string

La propriété `uiLanguage` contient le nom de la langue à utiliser pour la traduction des chaînes de l'interface utilisateur. En C++, elle est accessible via la propriété ` QJSEngine::uiLanguage `.

Vous pouvez définir librement sa valeur et l'utiliser dans les liaisons. Il est recommandé de la définir après avoir installé les traducteurs dans votre application. Par convention, une chaîne vide signifie qu'aucune traduction n'est prévue à partir de la langue utilisée dans le code source.

Si vous utilisez ` QQmlApplicationEngine ` et que la valeur change, la méthode ` QQmlEngine::retranslate()` sera appelée.

Documentation de la méthode

string QT_TRANSLATE_NOOP(string context, string sourceText, string disambiguation)

Marque l’ sourceText pour une traduction dynamique dans l’ context donnée ; c’est-à-dire que l’ sourceText stockée ne sera pas modifiée.

Si la même sourceText est utilisée dans différents rôles au sein d’un même contexte de traduction, une chaîne d’identification supplémentaire peut être transmise à disambiguation.

Renvoie l’ sourceText.

QT_TRANSLATE_NOOP est utilisé conjointement avec les fonctions de traduction dynamique qsTr() et qsTranslate(). Il identifie une chaîne comme nécessitant une traduction (afin qu’elle puisse être identifiée par lupdate), mais laisse la traduction proprement dite aux fonctions dynamiques.

Exemple :

Item {
    property string greeting: QT_TRANSLATE_NOOP("CustomContext", "hello")

    Text { text: qsTranslate("CustomContext", greeting) }
}

Voir aussi Internationalisation avec Qt.

string QT_TRID_NOOP(string id)

Marque ` id ` pour une traduction dynamique.

Renvoie l'id.

QT_TRID_NOOP est utilisé conjointement avec la fonction de traduction dynamique qsTrId(). Il identifie une chaîne comme nécessitant une traduction (afin qu'elle puisse être identifiée par lupdate), mais laisse la traduction proprement dite à qsTrId().

Exemple :

Item {
    property string greetingId: QT_TRID_NOOP("hello_id")

    Text { text: qsTrId(greetingId) }
}

Voir également qsTrId() et Internationalisation avec Qt.

string QT_TR_NOOP(string sourceText, string disambiguation)

Indique « sourceText » pour la traduction dynamique ; en d'autres termes, l'sourceText s stockées ne seront pas modifiées.

Si la même sourceText est utilisée dans différents rôles au sein d’un même contexte de traduction, une chaîne d’identification supplémentaire peut être transmise pour l’ disambiguation.

Renvoie l’ sourceText.

QT_TR_NOOP est utilisé conjointement avec les fonctions de traduction dynamique qsTr() et qsTranslate(). Il identifie une chaîne comme nécessitant une traduction (afin qu’elle puisse être identifiée par lupdate), mais laisse la traduction proprement dite aux fonctions dynamiques.

Exemple :

Item {
    property string greeting: QT_TR_NOOP("hello")

    Text { text: qsTr(greeting) }
}

Voir aussi Internationalisation avec Qt.

color alpha(color baseColor, real value)

Renvoie « baseColor » avec une valeur alpha de value.

value est un nombre réel compris entre 0 (totalement transparent) et 1 (totalement opaque).

[since 6.11] ArrayBuffer atob(ArrayBuffer data)

ASCII vers binaire — cette fonction décode l'data encodée en base64 et la renvoie.

Vous pouvez passer n’importe quelle structure de type tableau en tant qu’ data, et la fonction tentera de la convertir en tableau d’octets. Cela fonctionne notamment avec une liste de nombres et une liste de chaînes d’un seul caractère. La manière la plus efficace de procéder consiste toutefois à passer soit un objet ` QByteArray `, soit un objet `ArrayBuffer` de JavaScript.

Si la conversion échoue et qu’il s’avère que l’ data ne présente pas la forme attendue, une exception ` Invalid Character ` est levée et un tableau vide est renvoyé.

Cette méthode a été introduite dans Qt 6.11.

[since 6.11] var atob(var data)

ASCII vers binaire — cette fonction décode l'data, encodée en Base64, et la renvoie.

Cette méthode a été introduite dans Qt 6.11.

var binding(var function)

Renvoie un objet JavaScript représentant une liaison de propriété, avec une fonction ` function ` qui évalue cette liaison.

Cette fonction présente deux cas d’utilisation principaux : d’une part, pour appliquer une liaison de propriété de manière impérative à partir de code JavaScript :

Item {
    property bool someCondition: true
    property int edgePosition

    Component.onCompleted: {
        if (someCondition == true) {
            // bind to the result of the binding expression passed to Qt.binding()
            edgePosition = Qt.binding(function() { return x + width })
        }
    }
}

et deuxièmement, pour appliquer une liaison de propriété lors de l’initialisation des valeurs de propriété d’objets construits dynamiquement (via ` Component.createObject()` ou ` Loader.setSource()`).

Par exemple, en supposant l’existence d’un composant DynamicText :

import QtQuick

Text {
    id: textElement
    width: 200
    height: 200
    text: "Default text"
    property string dynamicText: "Dynamic text"
    onTextChanged: console.log(text)
}

le résultat de :

Item {
    id: root
    property string dynamicText: "Root text"

    Component.onCompleted: {
        var c = Qt.createComponent("DynamicText.qml")

        var obj1 = c.createObject(root, { 'text': Qt.binding(function() { return dynamicText + ' extra text' }) })
        root.dynamicText = "Modified root text"

        var obj2 = c.createObject(root, { 'text': Qt.binding(function() { return this.dynamicText + ' extra text' }) })
        obj2.dynamicText = "Modified dynamic text"
    }
}

et de :

Item {
    id: root
    property string dynamicText: "Root text"

    Loader {
        id: loaderOne
        onLoaded: root.dynamicText = "Modified root text"
    }

    Loader {
        id: loaderTwo
        onLoaded: item.dynamicText = "Modified dynamic text"
    }

    Component.onCompleted: {
        loaderOne.setSource("DynamicText.qml", { 'text': Qt.binding(function() { return dynamicText + ' extra text' }) })
        loaderTwo.setSource("DynamicText.qml", { 'text': Qt.binding(function() { return this.dynamicText + ' extra text' }) })
    }
}

devraient toutes deux être :

Root text extra text
Modified root text extra text
Dynamic text extra text
Modified dynamic text extra text

Cette fonction ne peut pas être utilisée dans les déclarations de liaison de propriété (voir la documentation sur les déclarations de liaison et les affectations de liaison), sauf lorsque le résultat est stocké dans un tableau lié à une propriété var.

Item {
    width: 50
    property var storedBindings: [ Qt.binding(function() { return x + width }) ] // stored
    property int a: Qt.binding(function() { return x + width }) // error!
    property int b

    Component.onCompleted: {
        b = storedBindings[0] // causes binding assignment
    }
}

[since 6.11] ArrayBuffer btoa(ArrayBuffer data)

Binaire vers ASCII — cette fonction renvoie un encodage Base64 de data.

Vous pouvez passer n'importe quelle structure de type tableau en tant que ` data`, et la fonction tentera de la convertir en un tableau d'octets. Cela fonctionne notamment avec une liste de nombres et une liste de chaînes d'un seul caractère. La manière la plus efficace de procéder consiste toutefois à passer soit un objet ` QByteArray `, soit un objet `ArrayBuffer` de JavaScript.

Si la conversion échoue et qu’il s’avère que l’ data n’est pas au format attendu, une exception Invalid Character est levée et un tableau vide est renvoyé.

Cette méthode a été introduite dans Qt 6.11.

[since 6.11] var btoa(var data)

Binaire vers ASCII — cette fonction renvoie un encodage Base64 de data.

Cette méthode a été introduite dans Qt 6.11.

Utilisez cette fonction pour éliminer les appels redondants à une fonction ou à un signal.

La fonction transmise en tant que premier argument à Qt.callLater() sera appelée ultérieurement, une fois que le moteur QML sera revenu à la boucle d'événements.

Lorsque cette fonction est appelée plusieurs fois de suite avec la même fonction comme premier argument, cette dernière ne sera appelée qu'une seule fois.

Par exemple :

import QtQuick

Rectangle {
    width: 480
    height: 320

    property int callsToUpdateMinimumWidth: 0
    property bool optimize: true

    property int currentTextModel: 0
    property var columnTexts: [
        ["Click on either", "rectangle above", "and note how the counter", "below updates", "significantly faster using the", "regular (non-optimized)", "implementation"],
        ["The width", "of this column", "is", "no wider than the", "widest item"],
        ["Note how using Qt.callLater()", "the minimum width is", "calculated a bare-minimum", "number", "of times"]
    ]

    Text {
        x: 20; y: 280
        text: "Times minimum width has been calculated: " + callsToUpdateMinimumWidth
    }

    Row {
        y: 25; spacing: 30; anchors.horizontalCenter: parent.horizontalCenter
        Rectangle {
            width: 200; height:  50; color: "lightgreen"
            Text { text: "Optimized behavior\nusing Qt.callLater()"; anchors.centerIn: parent }
            MouseArea { anchors.fill: parent; onClicked: { optimize = true; currentTextModel++ } }
        }
        Rectangle {
            width: 200; height:  50; color: "lightblue"
            Text { text: "Regular behavior"; anchors.centerIn: parent}
            MouseArea { anchors.fill: parent; onClicked: { optimize = false; currentTextModel++ } }
        }
    }

    Column {
        id: column
        anchors.centerIn: parent

        onChildrenChanged: optimize ? Qt.callLater(updateMinimumWidth) : updateMinimumWidth()

        property int widestChild
        function updateMinimumWidth() {
            callsToUpdateMinimumWidth++
            var w = 0;
            for (var i in children) {
                var child = children[i];
                if (child.implicitWidth > w) {
                    w = child.implicitWidth;
                }
            }

            widestChild = w;
        }

        Repeater {
            id: repeater
            model: columnTexts[currentTextModel%3]
            delegate: Text {
                color: "white"
                text: modelData
                width: column.widestChild
                horizontalAlignment: Text.Center
                Rectangle { anchors.fill: parent; z: -1; color: index%2 ? "gray" : "darkgray" }
            }
        }
    }
}

callLaterTous les arguments supplémentaires passés à Qt XML-ph-0000@deepl.internal seront transmis à la fonction invoquée. Notez que si les appels redondants sont éliminés, seul le dernier ensemble d'arguments sera transmis à la fonction.

color color(string name)

Renvoie la couleur correspondant à l'name donnée (c'est-à-dire « rouge » ou #ff0000). Si cette couleur n'existe pas, la valeur « null » est renvoyée.

color colorEqual(color lhs, string rhs)

Renvoie « true » si « lhs » et « rhs » donnent tous deux des valeurs de couleur identiques. Les deux arguments peuvent être soit des valeurs de couleur, soit des chaînes de caractères. Si une chaîne de caractères est fournie, elle doit pouvoir être convertie en couleur, comme décrit pour le type de valeur « color ».

Component createComponent(url url, enumeration mode, QtObject parent)

Renvoie un objet ` Component ` créé à partir du fichier QML situé à l'adresse spécifiée url, ou null si une chaîne vide a été fournie.

La propriété ` Component::status ` du composant renvoyé indique si la création du composant a réussi. Si le statut est ` Component.Error`, consultez la méthode ` Component::errorString()` pour obtenir une description de l'erreur.

Si le paramètre facultatif mode est défini sur Component.Asynchronous, le composant sera chargé dans un thread d'arrière-plan. La propriété Component::status prendra la valeur Component.Loading pendant le chargement. Le statut passera à Component.Ready si le composant se charge correctement, ou à Component.Error en cas d'échec du chargement. Si ce paramètre est omis, sa valeur par défaut est Component.PreferSynchronous.

Si « mode » est défini sur « Component.PreferSynchronous », Qt tentera de charger le composant de manière synchrone, mais pourra finir par le charger de manière asynchrone si nécessaire. Les scénarios susceptibles d'entraîner un chargement asynchrone incluent, sans s'y limiter, les suivants :

• L’URL fait référence à une ressource réseau
• Le composant est créé à la suite du chargement asynchrone d’un autre composant

Si le paramètre facultatif ` parent ` est fourni, il doit faire référence à l’objet qui deviendra le parent de l’objet ` Component ` créé. Si aucun mode n’a été passé, il peut s’agir du deuxième argument.

Appelez Component.createObject() sur le composant renvoyé pour créer une instance de l'objet du composant.

Par exemple :

import QtQuick

Item {
    id: container
    width: 300; height: 300

    function loadButton() {
        var component = Qt.createComponent("Button.qml");
        if (component.status == Component.Ready) {
            var button = component.createObject(container);
            button.color = "red";
        }
    }

    Component.onCompleted: loadButton()
}

Consultez la section Création dynamique d’objets QML à partir de JavaScript pour plus d’informations sur l’utilisation de cette fonction.

Pour créer un objet QML à partir d’une chaîne de caractères QML arbitraire (au lieu d’un fichier), utilisez ` Qt.createQmlObject()`.

[since 6.5] Component createComponent(string moduleUri, string typeName, enumeration mode, QtObject parent)

Renvoie un objet ` Component ` créé pour le type spécifié par ` moduleUri ` et ` typeName`.

import QtQml
QtObject {
    id: root
    property Component myComponent: Qt.createComponent("QtQuick", "Rectangle", Component.Asynchronous, root)
}

Cette surcharge se comporte globalement comme la version basée sur ` url `, mais peut être utilisée pour instancier des types qui ne disposent pas d'URL (par exemple, les types C++ enregistrés via ` QML_ELEMENT`).

• Le type est implémenté en C++
• Le type est un composant inline.

Si le paramètre facultatif parent est fourni, il doit faire référence à l'objet qui deviendra le parent de l'objet Component créé. Si aucun mode n'a été passé, il peut s'agir du deuxième argument.

Cette méthode a été introduite dans Qt 6.5.

QtObject createQmlObject(string qml, QtObject parent, url url)

Compile la chaîne « qml » fournie en un composant, puis renvoie un nouvel objet créé à partir de ce composant. Le nouvel objet aura l’ parent spécifiée. Renvoie « null » en cas d’erreur lors de la création du composant ou de l’objet.

Si url est spécifiée, elle sera utilisée comme URL du composant. Ceci est utile pour le signalement des erreurs.

Exemple (où ` parentItem ` est l’identifiant d’un élément QML existant) :

const newObject = Qt.createQmlObject(`
    import QtQuick

    Rectangle {
        color: "red"
        width: 20
        height: 20
    }
    `,
    parentItem,
    "myDynamicSnippet"
);

En cas d’erreur, un objet ` QQmlError ` est levé. Cet objet possède une propriété supplémentaire, ` qmlErrors`, qui est un tableau contenant les erreurs rencontrées. Chaque objet de ce tableau possède les membres ` lineNumber`, ` columnNumber`, ` fileName ` et ` message`. Par exemple, si dans l'extrait de code ci-dessus le mot « color » avait été mal orthographié (« colro »), le tableau contiendrait alors un objet similaire à celui-ci : { "lineNumber" : 1, "columnNumber" : 32, "fileName" : "dynamicSnippet1", "message" : "Impossible d’attribuer une valeur à la propriété inexistante « colro »"}.

Consultez la section Création dynamique d’objets QML à partir de JavaScript pour plus d’informations sur l’utilisation de cette fonction.

color darker(color baseColor, real factor)

Renvoie une couleur plus foncée que baseColor, selon l'factor e spécifié.

Si le facteur est supérieur à 1,0, cette fonction renvoie une couleur plus foncée. En définissant le facteur sur 3,0, on obtient une couleur dont la luminosité est réduite d'un tiers. Si le facteur est inférieur à 1,0, la couleur renvoyée est plus claire, mais nous recommandons d'utiliser la fonction Qt.lighter() à cette fin. Si le facteur est égal à 0 ou négatif, la valeur renvoyée n'est pas spécifiée.

La fonction convertit la couleur RVB actuelle en HSV, divise la composante de valeur (V) par le facteur et reconvertit la couleur en RVB.

Si factor n’est pas fourni, la fonction renvoie une couleur 50 % plus sombre que baseColor (facteur 2,0).

real enumStringToValue(enumType, keyName)

Renvoie la valeur numérique de la clé keyName dans l'énumération enumType. Si l'énumération est introuvable, une exception de type « TypeError » est levée. Si la clé ne correspond à aucune entrée de l'énumération, une exception de type « ReferenceError » est levée.

string enumValueToString(enumType, keyValue)

Renvoie la représentation sous forme de chaîne d'une clé de l'énumération enumType dont la valeur est keyValue. Si l'énumération est introuvable, une exception de type « TypeError » est levée. Si la valeur ne correspond à aucune clé de l'énumération, une exception de type « ReferenceError » est levée.

list<string> enumValueToStrings(enumType, keyValue)

Renvoie une liste contenant la représentation sous forme de chaîne de tous les clés de l'énumération enumType qui ont pour valeur keyValue. Si l'énumération est introuvable, une exception de type TypeError est levée. Si aucune clé de l'énumération n'a pour valeur keyValue, une exception de type ReferenceError est levée.

[since 6.12] string escapeHtml(string data)

Renvoie data avec les caractères spéciaux HTML échappés.

Cette fonction convertit la chaîne de texte brut data en une chaîne HTML dans laquelle les méta-caractères HTML <, >, & et " sont remplacés par des entités HTML.

Exemple :

var plain = "<script>alert('XSS')</script>";
var escaped = Qt.escapeHtml(plain);
// escaped is now "&lt;script&gt;alert('XSS')&lt;/script&gt;"

Cette méthode a été introduite dans Qt 6.12.

Voir également ` QString::toHtmlEscaped()`.

void exit(int retCode)

Cette fonction déclenche l'émission du signal ` QQmlEngine::exit(int)`. Dans l'outil QML, cela provoque la fermeture de l'application de lancement avec le code de retour spécifié (retCode). Pour sortir de la boucle d'événements avec un code de retour spécifié lorsque cette méthode est appelée, une application C++ peut connecter le signal ` QQmlEngine::exit(int)` au slot ` QCoreApplication::exit(int)`.

Voir également quit().

font font(var fontSpecifier)

Renvoie une police présentant les propriétés spécifiées dans l'objet ` fontSpecifier `, ou la police la plus proche correspondant à ces propriétés. L'objet ` fontSpecifier ` doit contenir des paires clé-valeur, les clés valides étant les noms des sous-propriétés du type ` font `, et les valeurs étant des valeurs valides pour chaque sous-propriété. Les clés non valides seront ignorées.

list<string> fontFamilies()

Renvoie une liste des familles de polices disponibles pour l'application.

string formatDate(datetime date, variant format, variant localeFormatOption)

Renvoie une représentation sous forme de chaîne de caractères de ` date`, formatée éventuellement à l'aide de ` format`.

Le paramètre ` date ` peut être un objet JavaScript de type ` Date `, une propriété ` date `, une valeur de type ` QDate` ou une valeur de type ` QDateTime `. Le paramètre ` format ` et ` localeFormatOption ` peut prendre n’importe quelle valeur de format possible, telle que décrite pour la fonction ` Qt.formatDateTime()`.

Si format n’est pas spécifié, date est formaté à l’aide de Locale.ShortFormat en utilisant les paramètres régionaux par défaut.

Voir également Locale.

string formatDateTime(datetime dateTime, variant format, variant localeFormatOption)

Renvoie une représentation sous forme de chaîne de caractères de ` dateTime`, formatée de manière facultative à l’aide de ` format ` et ` localeFormatOption`.

Le paramètre ` dateTime ` peut être un objet JavaScript de type ` Date `, une propriété de type ` date `, ou une valeur de type ` QDate`, ` QTime` ou ` QDateTime `.

Si format n’est pas fourni, dateTime est formaté à l’aide de Locale.ShortFormat en utilisant les paramètres régionaux par défaut. Sinon, format doit être l’une des valeurs suivantes :

• L’une des valeurs de l’énumération « Qt::DateFormat », telles que « Qt.RFC2822Date » ou « Qt.ISODate ».
• Une chaîne de caractères spécifiant le format de la chaîne renvoyée, comme détaillé ci-dessous.
• Un objet locale.

Si ` format ` spécifie un objet de paramètres régionaux, ` dateTime ` est formaté à l’aide de ` QLocale::toString`. Dans ce cas, ` localeFormatOption ` peut contenir une valeur de type ` QLocale::FormatType ` pour affiner davantage le formatage. Si aucune valeur n’est fournie, ` Locale.ShortFormat ` est utilisé.

Si format spécifie une chaîne de format, elle doit utiliser les expressions suivantes pour définir la date :

De plus, les expressions suivantes peuvent être utilisées pour spécifier l'heure :

Tous les autres caractères saisis seront ignorés. Toute séquence de caractères placée entre guillemets simples sera traitée comme du texte et ne sera pas utilisée comme expression. Deux guillemets simples consécutifs («''») sont remplacés par un seul guillemet simple dans la sortie.

Par exemple, si la valeur de date/heure suivante a été spécifiée :

// 21 May 2001 14:13:09
var dateTime = new Date(2001, 5, 21, 14, 13, 09)

Cette valeur d'dateTime s pourrait être transmise à Qt.formatDateTime(), Qt.formatDate() ou Qt.formatTime() avec les valeurs d'format ci-dessous pour produire les résultats suivants :

Voir aussi Locale.

string formatTime(datetime time, variant format, variant localeFormatOption)

Renvoie une représentation sous forme de chaîne de caractères de ` time`, formatée de manière facultative à l'aide de ` format` et, si elle est fournie, de ` localeFormatOption`.

Le paramètre ` time ` peut être un objet JavaScript de type ` Date `, une valeur de type ` QTime` ou une valeur de type ` QDateTime `. Les paramètres ` format ` et ` localeFormatOption ` peuvent prendre n’importe quelle valeur de format possible, telle que décrite pour la fonction ` Qt.formatDateTime()`.

Si format n’est pas spécifié, time est formaté à l’aide de Locale.ShortFormat en utilisant les paramètres régionaux par défaut.

Voir également Locale.

void gc()

Lance le ramasse-miettes.

Cela revient à appeler la fonction ` QJSEngine::collectGarbage()`.

Voir aussi «Ramasse-miettes ».

color hsla(real hue, real saturation, real lightness, real alpha)

Renvoie une couleur dont les composantes sont les suivantes : hue, saturation, lightness et alpha. Toutes les composantes doivent être comprises entre 0 et 1 (inclus).

color hsva(real hue, real saturation, real value, real alpha)

Renvoie une couleur dont les composantes sont les suivantes : hue, saturation, value et alpha. Toutes les composantes doivent être comprises entre 0 et 1 (inclus).

bool isQtObject(object)

Renvoie « true » si « object » est une référence valide à un objet Qt ou QML, et « false » dans le cas contraire.

color lighter(color baseColor, real factor)

Renvoie une couleur plus claire qu’ baseColor, selon l’ factor.

Si le facteur est supérieur à 1,0, cette fonction renvoie une couleur plus claire. Si le facteur est défini sur 1,5, la couleur renvoyée est 50 % plus claire. Si le facteur est inférieur à 1,0, la couleur renvoyée est plus foncée, mais nous recommandons d’utiliser la fonction Qt.darker() à cette fin. Si le facteur est égal à 0 ou négatif, la valeur renvoyée n’est pas spécifiée.

La fonction convertit la couleur RVB actuelle en HSV, multiplie la composante de valeur (V) par le facteur et reconvertit la couleur en RVB.

Si factor n’est pas fourni, la fonction renvoie une couleur plus claire de 50 % que baseColor (facteur 1,5).

locale locale(name)

Renvoie un objet JavaScript représentant la locale avec l'name spécifiée, qui se présente sous le format « language[_territory][.codeset][@modifier] » ou « C », où :

• language est un code de langue ISO 639 à deux lettres en minuscules,
• territory est un code de pays ISO 3166 à deux lettres en majuscules, et
• codeset et « modifier » sont ignorés.

Si la chaîne ne respecte pas le format de locale, ou si « language » n’est pas un code ISO 369 valide, la locale « C » est utilisée à la place. Si « country » n’est pas présent, ou n’est pas un code ISO 3166 valide, le pays le plus approprié est choisi pour la langue spécifiée.

L’objet renvoyé est d’un type QML anonyme basé sur QLocale.

Voir également Locale.

string md5(data)

Renvoie une chaîne hexadécimale correspondant au hachage MD5 de data.

matrix4x4 matrix4x4()

Renvoie une matrice identité de taille 4x4.

matrix4x4 matrix4x4(var values)

Renvoie une matrice 4x4 contenant l'values spécifiée. ` values ` doit être un tableau JavaScript comportant 16 éléments.

Les indices du tableau correspondent aux positions dans la matrice comme suit :

matrix4x4 matrix4x4(real m11, real m12, real m13, real m14, real m21, real m22, real m23, real m24, real m31, real m32, real m33, real m34, real m41, real m42, real m43, real m44)

Renvoie une matrice 4x4 contenant les valeurs spécifiées.

Les arguments correspondent à leurs positions dans la matrice :

bool openUrlExternally(url target)

Tente d'ouvrir l'URL spécifiée target dans une application externe, en fonction des préférences du bureau de l'utilisateur. Renvoie true en cas de succès, false dans le cas contraire.

Si target est une URL relative, elle sera résolue. L'URL sera ensuite redirigée vers QDesktopServices::openUrl.

point point(real x, real y)

Renvoie un point dont les coordonnées « x » et « y » sont celles spécifiées.

string qsTr(string sourceText, string disambiguation, int n)

Renvoie une version traduite de sourceText, éventuellement en fonction d’une chaîne fournie par disambiguation et de la valeur de n pour les chaînes contenant des pluriels ; sinon, renvoie sourceText lui-même si aucune chaîne traduite appropriée n’est disponible.

Exemples avec sourceText et n:

    Text { text: qsTr("hello") }

    // Translates the source text into the correct
    // plural form and replaces %n with the value of total.
    Text {
        text: qsTr("%n message(s) saved", "", total)
    }

Si la même sourceText est utilisée dans différents rôles au sein d’un même contexte de traduction, une chaîne d’identification supplémentaire peut être transmise à ` disambiguation`. Pour plus d’informations et d’exemples, consultez la section « Désambiguïser du texte identique ».

Voir également ` qsTranslate()`, « Internationalisation avec Qt » et « Écriture de code source en vue de la traduction ».

string qsTrId(string id, int n)

Renvoie une chaîne traduite identifiée par ` id`. Si aucune chaîne correspondante n'est trouvée, l'identifiant lui-même est renvoyé. Cela ne devrait pas se produire dans des conditions normales.

Si n >= 0, toutes les occurrences de %n dans la chaîne résultante sont remplacées par une représentation décimale de n. De plus, selon la valeur de n, le texte traduit peut varier.

Exemple :

Text { text: qsTrId("hello_id") }

Il est possible de fournir un modèle de chaîne source tel que :

//% <string>

    Text {
        //% "hello"
        text: qsTrId("hello_id")
    }

ou

/*% <string> */

    Text {
        /*% "hello" */
        text: qsTrId("hello_id")
    }

Pour créer des fichiers de traduction binaires (QM) compatibles avec cette fonction, il faut passer l’option -idbased à l’outil lrelease.

Voir également QT_TRID_NOOP() et Internationalisation avec Qt.

string qsTranslate(string context, string sourceText, string disambiguation, int n)

Renvoie une version traduite de sourceText au sein de l'context donné, éventuellement en fonction d'une chaîne disambiguation et de la valeur de n pour les chaînes contenant des pluriels ; sinon, renvoie sourceText lui-même si aucune chaîne traduite appropriée n'est disponible.

Si le même sourceText est utilisé dans différents rôles au sein d’une même context de traduction, une chaîne d’identification supplémentaire peut être transmise pour disambiguation.

Exemple :

Text { text: qsTranslate("CustomContext", "hello") }

À utiliser si vous disposez d’une context de traduction différente de celle du fichier context.

Voir aussi Internationalisation avec Qt et qsTr().

quaternion quaternion(real scalar, real x, real y, real z)

Renvoie un quaternion dont les valeurs d'scalar, x, y et z sont celles spécifiées.

void quit()

Cette fonction déclenche l'émission du signal ` QQmlEngine::quit()`. Dans l'outil QML, cela provoque la fermeture de l'application de lancement ; pour fermer une application C++ lorsque cette méthode est appelée, connectez le signal ` QQmlEngine::quit()` au slot ` QCoreApplication::quit()`.

Voir également exit().

rect rect(real x, real y, real width, real height)

Renvoie un rectangle dont le coin supérieur gauche se trouve à l'adresse x, y et dont les coordonnées de largeur et de hauteur spécifiées sont respectivement width et height.

url resolvedUrl(url url)

Renvoie l'adresse url, résolue par rapport à l'URL de l'appelant.

S'il n'y a pas d'appelant ou si celui-ci n'est pas associé à un contexte QML, renvoie l'url résolue par rapport à l'URL de base du moteur QML. Si le moteur QML n'a pas d'URL de base, renvoie simplement url.

Voir aussi url().

url resolvedUrl(url url, object context)

Renvoie url, résolu par rapport à l'URL du contexte QML de context. Si context n'est pas associé à un contexte QML, renvoie url, résolu par rapport à l'URL de base du moteur QML. Si le moteur QML n'a pas d'URL de base, renvoie simplement url.

Voir également url().

color rgba(real red, real green, real blue, real alpha)

Renvoie une couleur dont les composantes sont les suivantes : red, green, blue et alpha. Toutes les composantes doivent être comprises entre 0 et 1 (inclus).

size size(real width, real height)

Renvoie une taille avec les paramètres « width » et « height » spécifiés.

color tint(color baseColor, color tintColor)

Cette fonction permet de teinter une couleur (baseColor) avec une autre (tintColor).

La couleur de teinte doit généralement être presque transparente, sinon vous ne pourrez pas voir la couleur sous-jacente. L'exemple ci-dessous applique une légère teinte rouge en utilisant une couleur de teinte rouge pur dont l'opacité n'est que de 1/16e.

Item {
    Rectangle {
        x: 0; width: 80; height: 80
        color: "lightsteelblue"
    }
    Rectangle {
        x: 100; width: 80; height: 80
        color: Qt.tint("lightsteelblue", "#10FF0000")
    }
}

La teinte est particulièrement utile lorsqu'il s'agit d'apporter un changement subtil en réponse à un événement ; vous pouvez alors l'utiliser pour ajuster plus efficacement la couleur visible.

url url(url url)

Renvoie la chaîne « url » telle quelle. Cela peut être utilisé pour forcer une coercition de type vers « url ». Contrairement à la fonction Qt.resolvedUrl(), celle-ci conserve toutes les URL relatives. Les chaînes de caractères étant implicitement converties en URL, la fonction peut être appelée avec une chaîne de caractères en argument et renverra alors une URL.

Voir également resolvedUrl().

vector2d vector2d(real x, real y)

Renvoie un vecteur 2D contenant les valeurs spécifiées pour « x » et « y ».

vector3d vector3d(real x, real y, real z)

Renvoie un vecteur 3D contenant les valeurs spécifiées pour les paramètres « x », « y » et « z ».

vector4d vector4d(real x, real y, real z, real w)

Renvoie un vecteur 4D contenant les valeurs spécifiées pour les paramètres « x », « y », « z » et « w ».