<qqmlintegration.h>

Header: #include <QtQmlIntegration/qqmlintegration.h>

Macros

Descripción detallada

Este encabezado proporciona macros que se pueden utilizar para registrar tipos de C++ en QML.

Véase también qt_generate_foreign_qml_types(), Descripción general: integración de QML y C++, y qmltyperegistrar.

Documentación de las macros

QML_ADDED_IN_VERSION(MAJOR, MINOR)

Declara que el tipo o espacio de nombres envolvente se añadió en la versión especificada en MAJOR.MINOR. Se supone que la versión se ajusta a las revisiones indicadas por las macros Q_REVISION() en métodos, ranuras o señales, así como a los atributos REVISION() en propiedades declaradas con Q_PROPERTY().

QML_ADDED_IN_VERSION() solo surte efecto si el tipo o el espacio de nombres está disponible en QML, al tener una macro QML_ELEMENT, QML_NAMED_ELEMENT(), QML_ANONYMOUS o QML_INTERFACE.

Si el módulo QML al que pertenece el tipo se importa con una versión inferior a la determinada de esta manera, el tipo QML no será visible.

Véase también QML_ELEMENT y QML_NAMED_ELEMENT.

QML_ANONYMOUS

Declara que el tipo contenedor está disponible, pero es anónimo en QML. El tipo no se puede crear ni utilizar para declarar propiedades en QML, pero cuando se pasa desde C++, se reconoce. En QML, puedes utilizar propiedades de este tipo si están declaradas en C++.

Véase también QML_ELEMENT, QML_NAMED_ELEMENT(), QML_UNCREATABLE() y QML_INTERFACE.

QML_ATTACHED(ATTACHED_TYPE)

Declara que el tipo contenedor adjunta « ATTACHED_TYPE » como propiedad adjunta a otros tipos. Esto surte efecto si el tipo se expone a QML mediante una macro « QML_ELEMENT » o « QML_NAMED_ELEMENT()».

Nota: El nombre de la clase debe estar completamente calificado, incluso si ya te encuentras dentro del espacio de nombres.

Véase también QML_ELEMENT, QML_NAMED_ELEMENT(), qmlAttachedPropertiesObject() y Proporcionar propiedades adjuntas.

[since 6.5] QML_CONSTRUCTIBLE_VALUE

Marca el tipo de valor circundante como «constructible». Es decir, cualquier constructor de « Q_INVOKABLE » de ese tipo que admita exactamente un argumento puede utilizarse al asignar un valor de JavaScript a una propiedad de este tipo.

Puedes declarar un tipo de valor constructible de la siguiente manera:

class MyValueType
{
    Q_GADGET
    QML_VALUE_TYPE(myValueType)
    QML_CONSTRUCTIBLE_VALUE
public:
    Q_INVOKABLE MyValueType(double d);

    // ...
};

Con el tipo anterior, el siguiente código QML generará un valor de MyValueType utilizando el constructor dado y lo asignará a la propiedad.

QtObject {
    property myValueType v: 5.4
}

También se pueden construir listas de valores de esta manera:

QtObject {
    property list<myValueType> v: [5.4, 4.5, 3.3]
}

Desde Qt 6.8, si se importa el módulo QML al que pertenece el tipo de valor a un espacio de nombres, se puede utilizar el operador « new » de JavaScript para instanciarlo.

import MyModule as MM

QtObject {
    function process(d: real) {
        let v = new MM.myValueType(d);
        // v is a myValueType now
    }
}

Esta macro se introdujo en Qt 6.5.

Véase también QML_VALUE_TYPE.

QML_ELEMENT

Declara que el tipo o espacio de nombres contenedor está disponible en QML, utilizando el nombre de su clase o espacio de nombres como nombre del elemento QML.

Por ejemplo, esto hace que la clase de C++ ` Slider ` esté disponible como un tipo de QML denominado ` Slider`. Se exponen todas sus propiedades, métodos invocables y enumeraciones.

class Slider : public QObject
{
    Q_OBJECT
    QML_ELEMENT
    Q_PROPERTY(int value READ value WRITE setValue NOTIFY valueChanged FINAL)
    // ...
public:
    enum Slippiness {
        Dry, Wet, Icy
    };
    Q_ENUM(Slippiness)

    Q_INVOKABLE void slide(Slippiness slippiness);

    // ...
}

Puedes utilizar el sistema de compilación para registrar el tipo en el espacio de nombres de tipos com.mycompany.qmlcomponents con la versión principal 1. Para qmake, especifica lo siguiente en tu archivo de proyecto:

CONFIG += qmltypes
QML_IMPORT_NAME = com.mycompany.qmlcomponents
QML_IMPORT_MAJOR_VERSION = 1

Con CMake, se pasan el URI y la versión a ` qt_add_qml_module()`

qt_add_qml_module(myapp
  URI com.mycompany.qmlcomponents
  VERSION 1.0
)

Una vez registrado, el tipo se puede utilizar en QML importando el mismo espacio de nombres de tipo y el mismo número de versión:

import com.mycompany.qmlcomponents 1.0

Slider {
    value: 12
    Component.onCompleted: slide(Slider.Icy)

    // ...
}

También puedes hacer que los espacios de nombres etiquetados con Q_NAMESPACE estén disponibles de esta manera, con el fin de exponer cualquier enumeración etiquetada con Q_ENUM_NS que contengan:

namespace MyNamespace {
  Q_NAMESPACE
  QML_ELEMENT

  enum MyEnum {
      Key1,
      Key2,
  };
  Q_ENUM_NS(MyEnum)
}

En QML, ya puedes utilizar las enumeraciones:

Component.onCompleted: console.log(MyNamespace.Key2)

NOTA: Cuando las clases tienen el mismo nombre pero se encuentran en espacios de nombres diferentes, el uso de `QML_ELEMENT` en ambas provocará un conflicto. Asegúrate de utilizar ` QML_NAMED_ELEMENT()` para una de ellas en su lugar.

Nota: El nombre de la clase debe estar completamente calificado, incluso si ya te encuentras dentro del espacio de nombres.

Véase también «Cómo elegir el método de integración correcto entre C++ y QML», « QML_NAMED_ELEMENT()», « Q_REVISION()» y « QML_ADDED_IN_VERSION()».

QML_EXTENDED(EXTENDED_TYPE)

Declara que el tipo contenedor utiliza « EXTENDED_TYPE » como extensión para proporcionar propiedades, métodos y enumeraciones adicionales en QML. Esto entra en vigor si el tipo se expone a QML mediante una macro « QML_ELEMENT » o « QML_NAMED_ELEMENT()».

Advertencia: Los miembros de EXTENDED_TYPE se tratan implícitamente como FINAL.

Nota: El nombre de la clase debe estar completamente calificado, incluso si ya te encuentras dentro del espacio de nombres.

Véase también QML_ELEMENT, QML_NAMED_ELEMENT(), QML_EXTENDED_NAMESPACE() y Registro de objetos de extensión.

QML_EXTENDED_NAMESPACE(EXTENSION_NAMESPACE)

Declara que el tipo contenedor utiliza « EXTENSION_NAMESPACE » como extensión para proporcionar enumeraciones adicionales en QML. Esto surte efecto si el tipo se expone a QML mediante una macro « QML_ELEMENT » o « QML_NAMED_ELEMENT()». Para que esto funcione, las enumeraciones deben estar expuestas al sistema de metaobjetos.

Por ejemplo, consideremos el siguiente código C++

namespace MyNamespace {
    Q_NAMESPACE
    enum MyEnum { MyEnumerator = 10 };
    Q_ENUM_NS(MyEnum)
}

class QmlType : public QObject
{
    Q_OBJECT
    QML_ELEMENT
    QML_EXTENDED_NAMESPACE(MyNamespace)
}

podemos acceder a la enumeración en QML:

QmlType {
    property int i: QmlType.MyEnumerator // i will be 10
}

Nota: « EXTENSION_NAMESPACE » también puede ser un « QObject » o un «QGadget»; en ese caso —y a diferencia de « QML_EXTENDED », que también expone métodos y propiedades— solo se exponen sus enumeraciones.

Nota: EXTENSION_NAMESPACE debe tener un metaobjeto; es decir, debe ser un espacio de nombres que contenga la macro Q_NAMESPACE o bien un QObject/QGadget.

Nota: El nombre de la clase debe estar completamente calificado, incluso si ya te encuentras dentro del espacio de nombres.

Véase también QML_NAMESPACE_EXTENDED(), QML_ELEMENT, QML_NAMED_ELEMENT(), QML_EXTENDED(), «Registro de objetos de extensión», Q_ENUM y Q_ENUM_NS.

QML_EXTRA_VERSION(MAJOR, MINOR)

Declara que el tipo también debe estar disponible en la versión MAJOR.MINOR. Esto puede resultar útil si un tipo debe estar disponible en varias versiones principales.

Los tipos se registran automáticamente para:

  • La versión principal en la que se introdujeron; véase QML_ADDED_IN_VERSION.
  • Cualquier versión principal en la que se introdujeran cualquiera de sus miembros.
  • La versión principal actual de su módulo, a menos que ya estuvieran QML_REMOVED_IN_VERSION antes de esa.

Cabe destacar que no se registran automáticamente en ninguna de las PAST_MAJOR_VERSIONS comprendidas entre las mencionadas anteriormente. Puedes utilizar QML_EXTRA_VERSION para registrar manualmente tus tipos en otras versiones principales.

Nota: Mantener múltiples PAST_MAJOR_VERSIONS supone un gran coste computacional.

Véase también QML_ELEMENT y QML_ADDED_IN_VERSION.

QML_FOREIGN(FOREIGN_TYPE)

Declara que cualquier macro del tipo QML_ELEMENT, QML_NAMED_ELEMENT(), QML_ANONYMOUS, QML_INTERFACE, QML_UNCREATABLE(), QML_SINGLETON, QML_ADDED_IN_VERSION(), QML_REMOVED_IN_VERSION(), QML_ADDED_IN_MINOR_VERSION(), QML_REMOVED_IN_MINOR_VERSION(), QML_EXTENDED(), QML_EXTENDED_NAMESPACE() o QML_NAMESPACE_EXTENDED() presente en el tipo C++ contenedor no se aplica a dicho tipo, sino a FOREIGN_TYPE. El tipo contenedor debe registrarse igualmente en el sistema de metobjetos mediante una macro « Q_GADGET » o « Q_OBJECT ».

Esto resulta útil para registrar tipos a los que no se les pueden añadir las macros, por ejemplo, porque pertenecen a bibliotecas de terceros. Para registrar un espacio de nombres, consulta QML_FOREIGN_NAMESPACE().

Nota: Es posible que prefieras utilizar ` QML_NAMED_ELEMENT()` en lugar de ` QML_ELEMENT`. Con ` QML_ELEMENT`, el elemento recibe el nombre de la estructura en la que está contenido, no del tipo externo. El capítulo «Integración de objetos externos» de «Escritura de extensiones avanzadas de QML con C++» lo ilustra.

Nota: Actualmente,QML_ATTACHED() no se puede redirigir de esta forma. Debe especificarse en el mismo tipo que implementa qmlAttachedProperties().

Nota: El nombre de la clase debe estar completamente calificado, incluso si ya te encuentras dentro del espacio de nombres.

Véase también QML_ELEMENT, QML_NAMED_ELEMENT() y QML_FOREIGN_NAMESPACE().

QML_FOREIGN_NAMESPACE(FOREIGN_NAMESPACE)

Declara que cualquier macro QML_ELEMENT, QML_NAMED_ELEMENT(), QML_ANONYMOUS, QML_INTERFACE, QML_UNCREATABLE(), QML_SINGLETON, QML_ADDED_IN_VERSION(), QML_REMOVED_IN_VERSION(), QML_ADDED_IN_MINOR_VERSION() o QML_REMOVED_IN_MINOR_VERSION() presente en el espacio de nombres C++ envolvente no se aplica al tipo envolvente, sino a FOREIGN_NAMESPACE. El espacio de nombres envolvente debe registrarse igualmente en el sistema de metaobjetos mediante una macro ` Q_NAMESPACE `.

Esto resulta útil para registrar espacios de nombres que no pueden modificarse para añadir las macros, por ejemplo, porque pertenecen a bibliotecas de terceros.

Véase también QML_ELEMENT, QML_NAMED_ELEMENT() y QML_FOREIGN().

QML_IMPLEMENTS_INTERFACES(interfaces)

Esta macro indica a Qt qué QML interfaces implementa la clase. Esta macro solo debe utilizarse para interactuar con clases que utilicen QML_INTERFACE; en los demás casos, utilice Q_INTERFACES. Es necesaria para que el registro declarativo a través de QML_ELEMENT funcione correctamente.

Véase también QML_INTERFACE y Q_INTERFACES.

QML_INTERFACE

Esta macro registra el tipo C++ contenedor en el sistema QML como una interfaz.

Los tipos registrados como interfaz en QML también deben declararse como interfaz en el sistema de metobjetos. Por ejemplo:

struct FooInterface
{
    QML_INTERFACE
public:
    virtual ~FooInterface();
    virtual void doSomething() = 0;
};

Q_DECLARE_INTERFACE(FooInterface, "org.foo.FooInterface")

Cuando se registran en QML de esta manera, pueden utilizarse como tipos de propiedad:

Q_PROPERTY(FooInterface *foo READ foo WRITE setFoo)

Al asignar una subclase de ` QObject ` a esta propiedad, el motor de QML realiza automáticamente la conversión de la interfaz a ` FooInterface* `.

Los tipos de interfaz son implícitamente anónimos y no se pueden crear en QML.

NOTA: Al heredar de tipos que utilizan QML_INTERFACE, utilice QML_IMPLEMENTS_INTERFACES en lugar de Q_INTERFACES.

Véase también QML_IMPLEMENTS_INTERFACES(), QML_ELEMENT, QML_NAMED_ELEMENT(), QML_UNCREATABLE() y QML_ANONYMOUS.

QML_NAMED_ELEMENT(name)

Declara que el tipo o espacio de nombres envolvente está disponible en QML, utilizando « name » como nombre del elemento. Por lo demás, se comporta igual que « QML_ELEMENT ».

class SqlEventDatabase : public QObject
{
    Q_OBJECT
    QML_NAMED_ELEMENT(EventDatabase)

    // ...
};

Véase también «Cómo elegir el método de integración correcto entre C++ y QML » y « QML_ELEMENT ».

QML_REMOVED_IN_VERSION(MAJOR, MINOR)

Indica que el tipo o el espacio de nombres contenedor se ha eliminado en la versión especificada de MAJOR.MINOR. Esto resulta especialmente útil a la hora de sustituir la implementación de un tipo QML. Si existe una llamada correspondiente a QML_ADDED_IN_VERSION() en un tipo o espacio de nombres diferente con el mismo nombre QML, se utilizará el tipo eliminado al importar versiones del módulo inferiores a MAJOR.MINOR, y se utilizará el tipo añadido al importar versiones del módulo mayores o iguales a MAJOR.MINOR.

QML_REMOVED_IN_VERSION() solo surte efecto si el tipo o el espacio de nombres está disponible en QML, mediante las macros QML_ELEMENT, QML_NAMED_ELEMENT(), QML_ANONYMOUS o QML_INTERFACE.

Véase también QML_ELEMENT y QML_NAMED_ELEMENT.

QML_SEQUENTIAL_CONTAINER(VALUE_TYPE)

Esta macro declara el tipo envolvente o al que se hace referencia como un contenedor secuencial que gestiona una secuencia de elementos de tipo ` VALUE_TYPE `. ` VALUE_TYPE ` puede ser un tipo de valor real o un puntero a un tipo de objeto. Rara vez podrás añadir esta macro a la declaración real del contenedor, ya que los contenedores suelen ser plantillas. Debes utilizar ` QML_FOREIGN ` para asociar el registro del tipo a una instanciación de plantilla. Con esta técnica puedes, por ejemplo, declarar contenedores secuenciales de la siguiente manera:

class IntDequeRegistration
{
  Q_GADGET
  QML_FOREIGN(std::deque<int>)
  QML_ANONYMOUS
  QML_SEQUENTIAL_CONTAINER(int)
};

A continuación, puedes utilizar el contenedor como si fuera una matriz de JavaScript en QML.

class Maze
{
  Q_OBJECT
  Q_ELEMENT
  // 0: North, 1: East, 2: South, 3: West
  Q_PROPERTY(std::deque<int> solution READ solution CONSTANT FINAL)
  [...]
}
Item {
  Maze {
    id: maze
  }

  function showSolution() {
      maze.solution.forEach([...])
  }
}

Nota: Para los tipos de valor de QML, ` QList ` se registra automáticamente como contenedor secuencial. Para los tipos de objeto de QML, se registra ` QQmlListProperty `. No es necesario añadir estos registros.

Nota: Actualmente noes posible asignar un nombre personalizado al contenedor. Se ignora cualquier argumento que se pase a QML_NAMED_ELEMENT. Los contenedores secuenciales registrados automáticamente están disponibles bajo los nombres habituales de tipo list<...>, por ejemplo, list<QtObject> o list<font>.

Nota: El nombre de la clase debe ser completo, incluso si ya te encuentras dentro del espacio de nombres.

Véase también QML_ANONYMOUS y QML_FOREIGN().

QML_SINGLETON

Declara que el tipo contenedor es un singleton en QML. Esto solo surte efecto si el tipo es un « Q_OBJECT » y está disponible en QML (mediante la presencia de una macro « QML_ELEMENT » o « QML_NAMED_ELEMENT()»). A menos que el tipo esté marcado explícitamente como no creable mediante la macro QML_UNCREATABLE(), cada QQmlEngine intentará crear una instancia singleton utilizando bien el constructor por defecto del tipo, bien una función de fábrica estática con la firma T *create(QQmlEngine *, QJSEngine *) cuando se acceda al tipo por primera vez. Si ambos existen y son accesibles, se da preferencia al constructor por defecto.

Si no hay ningún constructor por defecto ni función de fábrica, y no se ha establecido ninguna instancia en el motor de forma explícita mediante ` QQmlEngine::setExternalSingletonInstance `, no se podrá acceder al singleton. Si el motor QML ha instanciado el singleton, por lo general asume la propiedad del mismo y lo eliminará cuando el propio motor sea destruido. Por el contrario, el motor no asume la propiedad de los singletons externos a menos que se le indique explícitamente que lo haga. Puedes controlar este comportamiento llamando a ` QJSEngine::setObjectOwnership()` en el singleton para especificar explícitamente el comportamiento deseado.

Para declarar como singleton una clase que se puede construir de forma predeterminada, basta con añadir QML_SINGLETON:

class MySingleton : public QObject
{
    Q_OBJECT
    QML_ELEMENT
    QML_SINGLETON
    // Q_PROPERTY( ... )
public:
    // members, Q_INVOKABLE functions, etc.
};

Si la clase singleton no es constructible por defecto, pero se puede modificar, puedes añadirle una función de fábrica para que sea accesible:

class MySingleton : public QObject
{
    Q_OBJECT
    QML_ELEMENT
    QML_SINGLETON
    // Q_PROPERTY( ... )

public:
    static MySingleton *create(QQmlEngine *qmlEngine, QJSEngine *jsEngine)
    {
        MySingleton *result = nullptr;
        // Create the object using some custom constructor or factory.
        // The QML engine will assume ownership and delete it, eventually.
        return result;
    }

    // members, Q_INVOKABLE functions, etc
};

Si quieres proporcionar una instancia al motor en lugar de dejar que este la instancie cuando sea necesario, puedes utilizar la macro ` QML_UNCREATABLE()`. En ese caso, el tipo no tiene por qué ser constructible por defecto ni tener una función de fábrica:

class MySingleton : public QObject
{
    Q_OBJECT
    QML_ELEMENT
    QML_SINGLETON
    QML_UNCREATABLE("Provided by C++")
    // Q_PROPERTY( ... )
public:
    MySingleton(BackendObject* backend, QObject* parent);

    // members, Q_INVOKABLE functions, etc
};

Para ello, es necesario establecer una instancia de ` MySingleton ` en el motor mediante ` QQmlEngine::setExternalSingletonInstance() ` antes de acceder por primera vez al singleton desde QML. Esto sustituye a la función ` qmlRegisterSingletonInstance `.

Si no puedes modificar la clase y esta no tiene un constructor por defecto ni una función de fábrica adecuada, puedes proporcionar un envoltorio ` QML_FOREIGN ` para definir la función de fábrica:

struct SingletonForeign
{
    Q_GADGET
    QML_FOREIGN(MySingleton)
    QML_SINGLETON
    QML_NAMED_ELEMENT(MySingleton)
public:

    static MySingleton *create(QQmlEngine *, QJSEngine *engine)
    {
        MySingleton *result = nullptr;
        // Create the instance using some custom constructor or factory.
        // The QML engine will assume ownership and delete it, eventually.
        return result;
    }
};

El enfoque de QML_FOREIGN para declarar un singleton que no se puede modificar también funciona en combinación con QML_UNCREATABLE(). En ese caso no se necesita ninguna función de fábrica, pero, al igual que antes, la instancia debe configurarse en el motor antes de su primer uso:

struct SingletonForeign
{
    Q_GADGET
    QML_FOREIGN(MySingleton)
    QML_SINGLETON
    QML_NAMED_ELEMENT(MySingleton)
    QML_UNCREATABLE("Provided from C++")
};

Véase también QML_ELEMENT, QML_NAMED_ELEMENT(), qmlRegisterSingletonInstance(), QQmlEngine::singletonInstance(), QQmlEngine::setExternalSingletonInstance() y Singletons en QML.

[since 6.5] QML_STRUCTURED_VALUE

Indica que el tipo de valor circundante es estructurado. Los tipos de valor estructurados pueden construirse —y, preferiblemente, se construirán— propiedad por propiedad a partir de un objeto de JavaScript. Sin embargo, un tipo de valor estructurado siempre es también un QML_CONSTRUCTIBLE_VALUE. Esto significa que aún puedes proporcionar constructores de tipo « Q_INVOKABLE » para gestionar la construcción a partir de tipos primitivos.

Se puede declarar un tipo de valor estructurado de la siguiente manera:

class MyValueType
{
    Q_GADGET
    QML_VALUE_TYPE(myValueType)
    QML_STRUCTURED_VALUE
    Q_PROPERTY(double d READ d WRITE setD)
    Q_PROPERTY(string e READ e WRITE setE)

    // ...
};

A continuación, puedes asignar un valor a una propiedad de este tipo de la siguiente manera:

QtObject {
    property myValueType v: ({d: 4.4, e: "a string"})
}

Los paréntesis adicionales son necesarios para evitar ambigüedades entre el objeto de JavaScript y lo que podría interpretarse como un bloque de código de JavaScript.

También puedes crear listas de valores de esta manera:

QtObject {
    property list<myValueType> v: [
        {d: 4.4, e: "a string"},
        {d: 7.1, e: "another string"}
    ]
}

Esta macro se introdujo en Qt 6.5.

Véase también QML_VALUE_TYPE y QML_CONSTRUCTIBLE_VALUE.

QML_UNAVAILABLE

Esta macro declara que el tipo contenedor no está disponible en QML. Registra un tipo ficticio interno denominado « QQmlTypeNotAvailable » como tipo « QML_FOREIGN()», utilizando cualquier otra macro de QML que se especifique.

Normalmente, los tipos exportados por un módulo deben ser fijos. Sin embargo, si un tipo de C++ no está disponible, deberías, como mínimo, «reservar» el nombre del tipo en QML y mostrar al usuario del tipo no disponible un mensaje de error significativo.

Ejemplo:

#ifdef NO_GAMES_ALLOWED
struct MinehuntGame
{
    Q_GADGET
    QML_NAMED_ELEMENT(Game)
    QML_UNAVAILABLE
    QML_UNCREATABLE("Get back to work, slacker!");
};
#else
class MinehuntGame : public QObject
{
    Q_OBJECT
    QML_NAMED_ELEMENT(Game)
    // ...
};
#endif

Esto hará que cualquier código QML que intente utilizar el tipo «Game» genere un mensaje de error:

fun.qml: Get back to work, slacker!
   Game {
   ^

Con esta técnica, solo necesitas una estructura ` Q_GADGET ` para personalizar el mensaje de error, no un ` QObject` completo. Sin ` QML_UNCREATABLE()`, `QML_UNAVAILABLE` sigue generando un mensaje de error más específico que el habitual «no es un tipo» para tipos completamente desconocidos.

Nota: El nombre de la clase debe estar completamente calificado, incluso si ya te encuentras dentro del espacio de nombres.

Véase también QML_ELEMENT, QML_NAMED_ELEMENT(), QML_UNCREATABLE() y QML_FOREIGN().

QML_UNCREATABLE(reason)

Declara que el tipo contenedor no se podrá crear desde QML. Esto surtirá efecto si el tipo está disponible en QML, al disponer de una macro « QML_ELEMENT » o « QML_NAMED_ELEMENT()». Se mostrará el mensaje de error « reason » si se detecta un intento de crear el tipo desde QML.

Algunos tipos de QML son implícitamente no creables, en particular los tipos expuestos con QML_ANONYMOUS o los espacios de nombres expuestos con QML_ELEMENT o QML_NAMED_ELEMENT().

Si el tipo es un singleton declarado con QML_SINGLETON, añadir QML_UNCREATABLE indica la promesa de que se establecerá explícitamente una instancia del tipo en el motor mediante QQmlEngine::setExternalSingletonInstance.

Desde Qt 6.0 se puede utilizar «» en lugar de un motivo para utilizar un mensaje estándar.

Véase también QML_ELEMENT, QML_NAMED_ELEMENT() y QML_ANONYMOUS.

QML_VALUE_TYPE(name)

Declara que el tipo o espacio de nombres envolvente está disponible en QML, utilizando « name » como nombre. El tipo debe ser un tipo de valor y el nombre debe estar en minúsculas.

class MyValueType
{
    Q_GADGET
    QML_VALUE_TYPE(myValueType)

    // ...
};

Véase también «Cómo elegir el método de integración adecuado entre C++ y QML » y « QML_NAMED_ELEMENT ».

© 2026 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.