Qt QML Type

Fournit un objet global avec des enums et des fonctions utiles de Qt. Plus d'informations...

• Liste de tous les membres, y compris les membres hérités
• Membres dépréciés

Propriétés

• application : Application
• inputMethod : InputMethod
• platform : object
• styleHints : object
• 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)
• object createQmlObject(string qml, object parent, url url)
• color darker(color baseColor, real factor)
• real enumStringToValue(enumType, keyName)
• string enumValueToString(enumType, keyValue)
• list<string> enumValueToStrings(enumType, keyValue)
• void exit(int retCode)
• font font(object 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 enums. Voici un exemple montrant comment utiliser ce type :

import QtQuick 2.0

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

Enums

L'objet Qt XML contient les énumérations disponibles sur le site Qt Namespace. Par exemple, vous pouvez accéder aux valeurs des énumérations Qt::LeftButton et Qt::RightButton en tant que Qt.LeftButton et Qt.RightButton.

Types d'objets

L'objet Qt contient également des fonctions d'aide pour créer des objets de types de données spécifiques. Ces fonctions sont principalement utiles pour définir les propriétés d'un élément lorsque la propriété a l'un des types suivants :

• rect - use Qt.rect()
• point - use Qt.point()
• size - use Qt.size()

Si le module QtQuick a été importé, les fonctions d'aide suivantes pour la création d'objets de types de données spécifiques sont également disponibles pour les clients :

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

Formatage de la date et de l'heure

L'objet Qt contient plusieurs fonctions de formatage des valeurs 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 du 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. Voir Création dynamique d'objets QML à partir de JavaScript pour une vue d'ensemble de leur utilisation.

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

Autres fonctions

Les fonctions suivantes sont également présentes dans l'objet Qt.

• Qt.quit()
• Qt.md5(chaîne)
• 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 globales de l'état de l'application partagées par de nombreux composants QML.

Il est identique au 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 est identique au singleton InputMethod.

L'objet inputMethod permet d'accéder à l'objet QInputMethod de l'application et à toutes ses propriétés et emplacements. Voir la documentation de QInputMethod pour plus de détails.

platform : object

L'objet platform fournit des informations sur la plate-forme sous-jacente.

Ses propriétés sont les suivantes :

styleHints : object

L'objet styleHints fournit des conseils et des paramètres de style spécifiques à la plate-forme. Voir la documentation QStyleHints pour plus de détails.

Vous devriez plutôt accéder aux StyleHints via Application::styleHints, qui fournit de meilleures informations sur les types pour des outils tels que le compilateurQt Quick .

uiLanguage : string

La propriété uiLanguage contient le nom de la langue à utiliser pour la traduction des chaînes de l'interface utilisateur. Elle est exposée en C++ sous la forme d'une propriété QJSEngine::uiLanguage.

Vous pouvez définir la valeur librement et l'utiliser dans les bindings. 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 de la langue utilisée dans le code source n'est prévue.

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

Documentation de la méthode

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

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

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

Renvoie l'adresse sourceText.

QT_TRANSLATE_NOOP est utilisé conjointement avec les fonctions de traduction dynamique qsTr() et qsTranslate(). Elle identifie une chaîne de caractères comme devant être traduite (elle peut donc ê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 la traduction dynamique.

Renvoie l'adresse id.

QT_TRID_NOOP est utilisé conjointement avec la fonction de traduction dynamique qsTrId(). Elle identifie une chaîne de caractères comme devant être traduite (elle peut donc ê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 aussi qsTrId() et Internationalisation avec Qt.

string QT_TR_NOOP(string sourceText, string disambiguation)

Marque sourceText pour la traduction dynamique, c'est-à-dire que le contenu de sourceText ne sera pas modifié.

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

Renvoie l'adresse sourceText.

QT_TR_NOOP est utilisé conjointement avec les fonctions de traduction dynamique qsTr() et qsTranslate(). Elle identifie une chaîne de caractères comme devant être traduite (elle peut donc ê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 réel allant de 0 (complètement transparent) à 1 (complètement opaque).

[since 6.11] ArrayBuffer atob(ArrayBuffer data)

ASCII vers binaire - cette fonction décode le code base64 de data et le renvoie.

Vous pouvez passer n'importe quel type de tableau à data, et la fonction essaiera de le convertir en tableau d'octets. En particulier, cela fonctionne avec une liste de nombres et une liste de chaînes à un caractère. La manière la plus efficace de procéder consiste toutefois à passer un objet QByteArray ou un objet JavaScript ArrayBuffer.

Si la conversion échoue et qu'il s'avère que le data n'a 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 en binaire - cette fonction décode le code base64 de data et le 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 adresse function qui évalue la liaison.

Il existe deux cas d'utilisation principaux pour cette fonction : premièrement, pour appliquer une liaison de propriété impérativement à partir du 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)
}

la sortie 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)

Binary to ASCII - cette fonction renvoie un encodage base64 de data.

Vous pouvez passer n'importe quel type de tableau à data, et la fonction essaiera de le convertir en un tableau d'octets. En particulier, cela fonctionne avec une liste de nombres et une liste de chaînes à un caractère. La manière la plus efficace de procéder consiste toutefois à passer un objet QByteArray ou un objet JavaScript ArrayBuffer.

Si la conversion échoue et qu'il s'avère que le data n'a 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 btoa(var data)

Binary to 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 passée comme premier argument à Qt.callLater() sera appelée plus tard, une fois que le moteur QML retournera à la boucle d'événements.

Lorsque cette fonction est appelée plusieurs fois en succession rapide avec la même fonction comme premier argument, cette fonction ne sera appelée qu'une seule fois.

Par exemple, cette fonction ne sera appelée qu'une seule fois :

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" }
            }
        }
    }
}

Tout argument supplémentaire passé à Qt.callLater() sera 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 à name (c'est-à-dire rouge ou #ff0000). Si cette couleur n'existe pas, null est renvoyé.

color colorEqual(color lhs, string rhs)

Renvoie true si lhs et rhs donnent des valeurs de couleur égales. Les deux arguments peuvent être des valeurs de couleur ou des valeurs de chaîne. Si une valeur de chaîne est fournie, elle doit être convertible en couleur, comme décrit pour le type de valeur color.

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

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

La propriété Component::status du composant retourné indique si le composant a été créé avec succès. Si le statut est Component.Error, voir Component::errorString() pour une description de l'erreur.

Si le paramètre optionnel mode est défini à Component.Asynchronous, le composant sera chargé dans un thread d'arrière-plan. La propriété Component::status sera Component.Loading pendant le chargement. L'état devient Component.Ready si le composant est chargé avec succès, ou Component.Error si le chargement échoue. Ce paramètre prend par défaut la valeur Component.PreferSynchronous s'il est omis.

Si mode est défini sur Component.PreferSynchronous, Qt XML tentera de charger le composant de manière synchrone, mais peut finir par le charger de manière asynchrone si nécessaire. Les scénarios susceptibles de provoquer un chargement asynchrone comprennent, sans s'y limiter, les éléments 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é transmis, il peut s'agir du deuxième argument.

Appelez Component.createObject() sur le composant retourné pour créer une instance d'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()
}

Voir 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 arbitraire de QML (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 principalement comme la version basée sur url, mais peut être utilisée pour instancier des types qui n'ont 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 en ligne.

Si le paramètre optionnel 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é transmis, il peut s'agir du deuxième argument.

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

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

Compile la chaîne qml donnée en un composant et renvoie un nouvel objet créé à partir de ce composant. Le nouvel objet aura la chaîne 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é, il sera utilisé comme URL du composant. Cette fonction est utile pour signaler les 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 généré. Cet objet possède une propriété supplémentaire, qmlErrors, qui est un tableau des erreurs rencontrées. Chaque objet de ce tableau a pour membres lineNumber, columnNumber, fileName et message. Par exemple, si l'extrait ci-dessus avait mal orthographié "color" en "colro", le tableau contiendrait un objet comme le suivant : {"lineNumber" : 1, "columnNumber" : 32, "fileName" : "dynamicSnippet1", "message" : "Cannot assign to non-existent property "colro""}.

Voir 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 par le facteur factor fourni.

Si le facteur est supérieur à 1,0, cette fonction renvoie une couleur plus foncée. Si le facteur est fixé à 3,0, la couleur retournée est trois fois moins lumineuse. 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 de retour n'est pas spécifiée.

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

Si factor n'est pas fourni, la fonction renvoie une couleur 50 % plus foncée 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 n'a pas pu être trouvée, un message TypeError est envoyé. Si la clé n'est pas une entrée de l'énumération, un message ReferenceError est envoyé.

string enumValueToString(enumType, keyValue)

Renvoie la représentation sous forme de chaîne de caractères d'une clé de l'énumération enumType qui a la valeur keyValue. Si l'énumération n'a pas pu être trouvée, un message TypeError est envoyé. Si la valeur ne correspond à aucune clé de l'énumération, un message ReferenceError est envoyé.

list<string> enumValueToStrings(enumType, keyValue)

Renvoie une liste de la représentation sous forme de chaîne de toutes les clés de l'énumération enumType qui ont la valeur keyValue. Si l'énumération n'a pas pu être trouvée, un message TypeError est envoyé. Si aucune clé de l'énumération n'a la valeur keyValue, un message ReferenceError est envoyé.

void exit(int retCode)

Cette fonction provoque l'émission du signal QQmlEngine::exit(int). Dans l'outil qml, cela entraîne la sortie de l'application de lancement avec le code de retour spécifié (retCode). Pour quitter 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) à l'emplacement QCoreApplication::exit(int).

Voir également quit().

font font(object fontSpecifier)

Renvoie une police avec les propriétés spécifiées dans l'objet fontSpecifier ou la police la plus proche. L'objet fontSpecifier doit contenir des paires clé-valeur où les clés valides sont les noms des sous-propriétés du type font et les valeurs sont les valeurs valides pour chaque sous-propriété. Les clés non valides sont 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, éventuellement formatée à l'aide de format.

Le paramètre date peut être un objet JavaScript Date, une propriété date, une valeur QDate ou QDateTime. Les paramètres format et localeFormatOption peuvent correspondre à l'une des valeurs de format possibles décrites pour Qt.formatDateTime().

Si format n'est pas spécifié, date est formaté à l'aide de Locale.ShortFormat en utilisant la locale par défaut.

Voir aussi Locale.

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

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

Le paramètre dateTime peut être un objet JavaScript Date, une propriété date, une valeur 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. Dans le cas contraire, format doit être soit

• Une des valeurs de l'énumération Qt::DateFormat, telle que Qt.RFC2822Date ou Qt.ISODate.
• Une chaîne de caractères spécifiant le format de la chaîne renvoyée, comme indiqué ci-dessous.
• Un objet locale.

Si format spécifie un objet locale, dateTime est formaté avec QLocale::toString. Dans ce cas, localeFormatOption peut contenir une valeur de type QLocale::FormatType pour affiner le formatage. Si aucune valeur n'est fournie, Locale.ShortFormat est utilisé.

Si format spécifie une chaîne de formatage, il doit utiliser les expressions suivantes pour spécifier la date :

En outre, 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 entre guillemets simples sera traitée comme du texte et ne sera pas utilisée comme une expression. Deux guillemets simples consécutifs ("''") sont remplacés par un guillemet simple dans le résultat.

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

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

Cette valeur dateTime peut être transmise à Qt.formatDateTime(), Qt.formatDate() ou Qt.formatTime() avec les valeurs 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, éventuellement formatée à l'aide de format et, le cas échéant, de localeFormatOption.

Le paramètre time peut être un objet JavaScript Date, une valeur QTime ou QDateTime. Les paramètres format et localeFormatOption peuvent correspondre à l'une des valeurs de format possibles décrites pour 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 aussi Locale.

void gc()

Exécute le ramasse-miettes.

Cela équivaut à appeler QJSEngine::collectGarbage().

Voir aussi Garbage Collection.

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

Renvoie une couleur avec les composantes spécifiées 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 avec les composantes spécifiées 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, false sinon.

color lighter(color baseColor, real factor)

Renvoie une couleur plus claire que baseColor par le facteur factor fourni.

Si le facteur est supérieur à 1,0, cette fonction renvoie une couleur plus claire. Si le facteur est de 1,5, la couleur retournée est 50 % plus claire. Si le facteur est inférieur à 1,0, la couleur retourné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 de retour n'est pas spécifiée.

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

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

locale locale(name)

Renvoie un objet JS représentant la locale avec le name spécifié, qui a le format "language[_territory][.codeset][@modifier]" ou "C", où :

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

Si la chaîne ne respecte pas le format des paramètres régionaux, ou si la langue n'est pas un code ISO 369 valide, les paramètres régionaux "C" sont utilisés à la place. Si le pays 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 un type QML anonyme soutenu par QLocale.

Voir aussi Locale.

string md5(data)

Renvoie une chaîne hexagonale du hachage md5 de data.

matrix4x4 matrix4x4()

Renvoie une matrice d'identité4x4.

matrix4x4 matrix4x4(var values)

Renvoie une matrice4x4 avec la valeur spécifiée values. values est censé être un tableau JavaScript avec 16 entrées.

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 matrice4x4 avec les valeurs spécifiées.

Les arguments correspondent à leurs positions dans la matrice :

bool openUrlExternally(url target)

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

point point(real x, real y)

Renvoie un point avec les coordonnées x et y spécifiées.

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

Renvoie une version traduite de sourceText, éventuellement basée sur une chaîne disambiguation et une 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 le même sourceText est utilisé dans différents rôles dans le même contexte de traduction, une chaîne d'identification supplémentaire peut être transmise pour disambiguation. Pour plus d'informations et d'exemples, voir Désambiguïser un texte identique.

Voir aussi qsTranslate(), Internationalisation avec Qt XML, et Écrire le code source pour 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. En outre, en fonction de la valeur de n, le texte de la traduction peut varier.

Exemple :

Text { text: qsTrId("hello_id") }

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

//% <string>

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

ou

/*% <string> */

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

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

Voir aussi QT_TRID_NOOP() et Internationalisation avec Qt.

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

Renvoie une version traduite de sourceText dans le cadre de context, éventuellement basée sur une chaîne disambiguation et 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 de la même traduction context, une chaîne d'identification supplémentaire peut être transmise pour disambiguation.

Exemple :

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

A utiliser si vous avez une traduction context qui diffère du fichier context.

Voir aussi Internationalisation avec Qt et qsTr().

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

Renvoie un quaternion avec les valeurs spécifiées scalar, x, y, et z.

void quit()

Cette fonction provoque l'émission du signal QQmlEngine::quit(). Dans l'outil qml, cela entraîne la sortie de l'application de lancement ; pour quitter une application C++ lorsque cette méthode est appelée, connectez le signal QQmlEngine::quit() à l'emplacement QCoreApplication::quit().

Voir aussi exit().

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

Renvoie un rectangle dont le coin supérieur gauche se trouve à x, y et les valeurs spécifiées width et height.

url resolvedUrl(url url)

Renvoie url résolu par rapport à l'URL de l'appelant.

S'il n'y a pas d'appelant ou si l'appelant n'est pas associé à un contexte QML, il renvoie url résolu par rapport à l'URL de base du moteur QML. Si le moteur QML n'a pas d'URL de base, il 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, il renvoie simplement url.

Voir aussi url().

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

Renvoie une couleur avec les composantes spécifiées 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 valeurs spécifiées width et height.

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 transparente, sinon vous ne pourrez pas voir la couleur sous-jacente. L'exemple ci-dessous donne une légère teinte rouge en choisissant comme couleur de teinte le rouge pur, qui n'est opaque qu'à 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'un changement subtil doit être communiqué à la suite d'un événement ; vous pouvez alors utiliser la teinte pour ajuster plus efficacement la couleur visible.

url url(url url)

Retourne url mot pour mot. Ceci peut être utilisé pour forcer une coercion de type à url. Contrairement à Qt.resolvedUrl(), cette fonction conserve toutes les URL relatives. Comme les chaînes sont implicitement converties en urls, la fonction peut être appelée avec une chaîne comme argument, et renverra alors une url.

Voir aussi resolvedUrl().

vector2d vector2d(real x, real y)

Renvoie un vecteur2d avec les valeurs x et y spécifiées.

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

Renvoie un vector3d avec les valeurs spécifiées x, y, et z.

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

Renvoie un vector4d avec les valeurs spécifiées x, y, z, et w.