Qt QML Type
Fournit un objet global avec des enums et des fonctions utiles de Qt. Plus d'informations...
| Import Statement: | import QtQml |
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)
- string atob(data)
- binding(function)
- string btoa(data)
- callLater(function)
- 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)
- enumStringToValue(enumType, keyName)
- enumValueToString(enumType, keyValue)
- enumValueToStrings(enumType, keyValue)
- 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(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)
- 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 :
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.
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 } }
Remarque : si vous utilisez QML sans QGuiApplication, les propriétés suivantes ne seront pas définies :
- 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 :
platform.os | Cette propriété en lecture seule contient le nom du système d'exploitation. Les valeurs possibles sont les suivantes :
Note : La valeur de la propriété sur macOS est "osx", indépendamment de la convention de nommage d'Apple. La valeur retournée sera mise à jour à "macos" pour Qt 7. |
platform.pluginName | Il s'agit du nom de la plate-forme définie sur l'instance QGuiApplication, tel qu'il est renvoyé par QGuiApplication::platformName(). |
styleHints : object |
L'objet styleHints fournit des conseils et des paramètres de style spécifiques à la plate-forme. Voir la documentation de QStyleHints pour plus de détails.
Il est préférable d'accéder aux StyleHints via Application::styleHints, qui fournit de meilleures informations sur les types pour les outils tels que la fonction Qt Quick Compiler.
Remarque : l'objet styleHints n'est disponible que si vous utilisez le module Qt Quick.
uiLanguage : string |
L'objet uiLanguage contient le nom de la langue à utiliser pour les traductions des chaînes de l'interface utilisateur. Il est exposé en C++ en tant que propriété QQmlEngine::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
callLater(function) |
callLater(function, argument1, argument2, ...) |
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.
Marque sourceText pour la 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.
Marque id pour la traduction dynamique.
Renvoie l'adresse id.
QT_TRID_NOOP est utilisé en conjonction 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 :
Voir aussi qsTrId() et Internationalisation avec Qt.
Marque sourceText pour une traduction dynamique ; c'est-à-dire que le texte stocké 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 passée 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 :
Voir aussi Internationalisation avec Qt.
Retourne baseColor avec une valeur alpha de value.
value est un réel allant de 0 (complètement transparent) à 1 (complètement opaque).
string atob(data) |
ASCII vers binaire - cette fonction décode la chaîne data encodée en base64 et la renvoie.
binding(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, appliquer une liaison de propriété impérativement à partir du code JavaScript, et deuxièmement, 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és (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.
string btoa(data) |
Binary to ASCII - cette fonction renvoie un encodage base64 de data.
Renvoie la couleur correspondant à l'adresse name donnée (c'est-à-dire rouge ou #ff0000). Si cette couleur n'existe pas, null est renvoyé.
Retourne 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.
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().
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).
Remarque : dans certains cas, passer Component.Asynchronous n'aura aucun effet :
- 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.
Il s'agit d'une fonction surchargée.
Cette méthode a été introduite dans Qt 6.5.
Compile la chaîne qml donnée en un composant, puis 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.
Attention : Le nouveau composant éclipsera tout composant existant ayant la même URL. Vous ne devez pas transmettre l'URL d'un composant existant. En particulier, en passant l'URL du fichier QML environnant, vous empêchez l'accès au composant environnant à partir du nouveau composant.
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""}.
Remarque : cette fonction est renvoyée immédiatement et peut donc ne pas fonctionner si la chaîne qml charge de nouveaux composants (c'est-à-dire des fichiers QML externes qui n'ont pas encore été chargés). Dans ce cas, envisagez d'utiliser Qt.createComponent() à la place.
Attention : Cette fonction est extrêmement lente car elle doit compiler la chaîne QML passée à chaque fois qu'elle est invoquée. De plus, il est très facile de produire du QML invalide lors de la construction programmatique du code QML. Il est préférable de conserver vos composants QML dans des fichiers séparés et d'ajouter des propriétés et des méthodes pour personnaliser leur comportement plutôt que de produire de nouveaux composants en manipulant des chaînes de caractères.
Voir Création dynamique d'objets QML à partir de JavaScript pour plus d'informations sur l'utilisation de cette fonction.
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 est trois fois moins lumineuse. Si le facteur est inférieur à 1,0, la couleur retourné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).
enumStringToValue(enumType, keyName) |
Renvoie la valeur numérique de la clé keyName dans l'enum enumType. Si l'énumération n'a 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é.
enumValueToString(enumType, keyValue) |
Renvoie la représentation sous forme de chaîne de caractères d'une clé de l'enum enumType ayant 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é.
Remarque : si plusieurs clés correspondent à la valeur de keyValue, la clé qui sera renvoyée n'est pas spécifiée. Dans ce cas, utilisez enumValueToStrings.
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é.
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 ayant 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.
Renvoie une liste des familles de polices disponibles pour l'application.
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 également Locale.
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.RFC2822DateouQt.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 :
| Expression | Sortie |
|---|---|
| d | le jour sous forme de nombre sans zéro initial (1 à 31) |
| dd | le jour sous forme de nombre avec un zéro en tête (01 à 31) |
| ddd | le nom abrégé du jour localisé (par exemple de 'Mon' à 'Sun'). Utilise QDate::shortDayName(). |
| dddd | le nom long du jour localisé (par exemple, de 'Monday' à 'Qt::Sunday'). Utilise QDate::longDayName(). |
| M | le mois sous forme de nombre sans zéro initial (1-12) |
| MM | le mois sous forme de nombre avec un zéro en tête (01-12) |
| MMM | le nom abrégé du mois localisé (par exemple de 'Jan' à 'Dec'). Utilise QDate::shortMonthName(). |
| MMMM | le nom long du mois localisé (par exemple, de 'janvier' à 'décembre'). Utilise QDate::longMonthName(). |
| yy | l'année sous la forme d'un nombre à deux chiffres (00-99) |
| yyyy | l'année sous la forme d'un nombre à quatre chiffres |
En outre, les expressions suivantes peuvent être utilisées pour spécifier l'heure :
| Expression | Sortie |
|---|---|
| h | l'heure sans le zéro initial (0 à 23 ou 1 à 12 pour l'affichage AM/PM) |
| hh | l'heure avec un zéro en tête (00 à 23 ou 01 à 12 si affichage AM/PM) |
| m | la minute sans le zéro initial (0 à 59) |
| mm | la minute avec un zéro en tête (00 à 59) |
| s | la seconde sans le zéro initial (0 à 59) |
| ss | la seconde avec un zéro en tête (00 à 59) |
| z | les millisecondes sans zéro initial (0 à 999) |
| zzz | les millisecondes avec des zéros en tête (000 à 999) |
| AP | utiliser l'affichage AM/PM. AP sera remplacé par "AM" ou "PM". |
| ap | utiliser l'affichage am/pm. ap sera remplacé par "am" ou "pm". |
| t | inclut un indicateur de fuseau horaire. |
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 :
| Format | Résultat |
|---|---|
| "dd.MM.yyyy" | 21.05.2001 |
| "ddd MMMM d yy | Tue May 21 01 |
| "hh:mm:ss.zzz | 14:13:09.042 |
| "h:m:s ap" | 2:13:9 pm |
Voir aussi Locale.
Renvoie une représentation sous forme de chaîne de caractères de time, éventuellement formatée à l'aide de format, et, si elle est fournie, 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.
Renvoie une couleur avec les composants hue, saturation, lightness, et alpha spécifiés. Toutes les composantes doivent être comprises entre 0 et 1 (inclus).
Renvoie une couleur avec les composants hue, saturation, value et alpha spécifiés. 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.
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. En fixant le facteur à 1,5, la fonction renvoie une couleur 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(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ù :
languageest un code de langue ISO 639 à deux lettres minuscules,territoryest un code de pays ISO 3166 à deux lettres majuscules, etcodesetetmodifiersont 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.
Voir aussi Locale.
string md5(data) |
Renvoie une chaîne hexadécimale du hachage md5 de data.
matrix4x4 matrix4x4() |
Renvoie une matrice4x4 d'identité.
Renvoie une matrice4x4 avec la valeur spécifiée values. values est censé être un tableau JavaScript à 16 entrées.
Les indices du tableau correspondent aux positions dans la matrice comme suit :
| 0 | 1 | 2 | 3 |
| 4 | 5 | 6 | 7 |
| 8 | 9 | 10 | 11 |
| 12 | 13 | 14 | 15 |
Renvoie une matrice4x4 avec les valeurs spécifiées.
Les arguments correspondent à leur position dans la matrice :
| m11 | m12 | m13 | m14 |
| m21 | m22 | m23 | m24 |
| m31 | m32 | m33 | m34 |
| m41 | m42 | m43 | m44 |
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.
Attention : Une valeur de retour de true indique que l'application a demandé avec succès au système d'exploitation d'ouvrir l'URL dans une application externe. Il se peut que l'application externe ne se lance pas ou n'ouvre pas l'URL demandée. Ce résultat ne sera pas communiqué à l'application.
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.
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, 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.
Renvoie une version traduite de sourceText à l'intérieur 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.
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 également exit().
Renvoie un rectangle dont le coin supérieur gauche se trouve à x, y et les valeurs spécifiées width et height.
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, 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().
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().
Renvoie une couleur avec les composants spécifiés red, green, blue, et alpha. Tous les composants doivent être compris entre 0 et 1 (inclus).
Cette fonction permet de teinter une couleur (baseColor) avec une autre (tintColor).
La couleur de la 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 faisant en sorte que la couleur de la teinte soit un 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.
Renvoie url mot pour mot. Ceci peut être utilisé pour forcer une coercion de type à url. Contrairement à Qt.resolvedUrl() ceci 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().
Renvoie un vecteur3d avec les valeurs spécifiées x, y, et z.
Renvoie un vecteur4d avec les valeurs spécifiées x, y, z, et w.
© 2025 The Qt Company Ltd. Documentation contributions included herein are the copyrights of their respective owners. The documentation provided herein is licensed under the terms of the GNU Free Documentation License version 1.3 as published by the Free Software Foundation. Qt and respective logos are trademarks of The Qt Company Ltd. in Finland and/or other countries worldwide. All other trademarks are property of their respective owners.