En esta página

qt_add_qml_module

Define un módulo QML.

Este comando se introdujo en Qt 6.2.

El comando está definido en el componente « Qml » del paquete « Qt6 », que se puede cargar de la siguiente manera:

find_package(Qt6 REQUIRED COMPONENTS Qml)

Sinopsis

qt_add_qml_module(
    target
    URI uri
    [VERSION version]
    [PAST_MAJOR_VERSIONS ...]
    [STATIC | SHARED]
    [PLUGIN_TARGET plugin_target]
    [OUTPUT_DIRECTORY output_dir]
    [RESOURCE_PREFIX resource_prefix]
    [CLASS_NAME class_name]
    [TYPEINFO typeinfo]
    [IMPORTS ...]
    [OPTIONAL_IMPORTS ...]
    [DEFAULT_IMPORTS ...]
    [DEPENDENCIES ...]
    [IMPORT_PATH ...]
    [SOURCES ...]
    [QML_FILES ...]
    [RESOURCES ...]
    [OUTPUT_TARGETS out_targets_var]
    [DESIGNER_SUPPORTED]
    [FOLLOW_FOREIGN_VERSIONING]
    [NAMESPACE namespace]
    [NO_PLUGIN]
    [NO_PLUGIN_OPTIONAL]
    [NO_CREATE_PLUGIN_TARGET]
    [NO_GENERATE_PLUGIN_SOURCE]
    [NO_GENERATE_QMLTYPES]
    [NO_GENERATE_QMLDIR]
    [NO_GENERATE_EXTRA_QMLDIRS]
    [NO_GENERATE_QTCONF]                          # since Qt 6.12
    [NO_GENERATE_AOT_VALIDATION]                  # since Qt 6.12
    [NO_LINT]
    [NO_CACHEGEN]
    [NO_RESOURCE_TARGET_PATH]
    [NO_IMPORT_SCAN]
    [DISCARD_QML_CONTENTS]
    [ENABLE_TYPE_COMPILER]
    [TYPE_COMPILER_NAMESPACE namespace]
    [QMLTC_EXPORT_DIRECTIVE export_macro]
    [QMLTC_EXPORT_FILE_NAME header_defining_export_macro]

)

Si los comandos sin versión están desactivados, utiliza en su lugar qt6_add_qml_module(). Admite el mismo conjunto de argumentos que este comando.

Consulte «Compilación de una aplicación QML » y «Compilación de un módulo QML reutilizable» para ver ejemplos que definen módulos QML.

Descripción

Este comando define un módulo QML que puede estar compuesto por fuentes en C++, archivos « .qml » o ambos. Garantiza que se proporcionen los detalles esenciales del módulo y que estos sean coherentes. Además, configura y coordina aspectos como la compilación en caché de fuentes « .qml », la incrustación de recursos, las comprobaciones de linting y la generación automática de algunos archivos clave del módulo.

Para obtener una visión general conceptual con ejemplos de uso habituales, consulta «Integrarlo todo con CMake». Para temas avanzados, como las estructuras de directorios personalizadas y el control de versiones, consulta «Escribir módulos QML».

Estructura del destino

Un módulo QML puede estructurarse de varias formas diferentes. Los siguientes son los esquemas más habituales:

Objetivos de soporte y de complemento independientes

Esta es la configuración recomendada para la mayoría de los módulos QML. Toda la funcionalidad del módulo se implementa en el objetivo de soporte, que se indica como primer argumento del comando. Los archivos fuente de C++, los archivos « .qml » y los recursos deben añadirse al objetivo de soporte. El objetivo de soporte es una biblioteca que debe instalarse en la misma ubicación que cualquier otra biblioteca definida por el proyecto.

La estructura del directorio de fuentes en el que se crea el objetivo de soporte debe coincidir con la ruta de destino del módulo QML (la ruta de destino es el URI del módulo con los puntos sustituidos por barras). Si la estructura del directorio de fuentes no coincide con la ruta de destino, qt_add_qml_module() emitirá una advertencia.

El siguiente ejemplo muestra una estructura de directorios de origen adecuada para un módulo QML con un URI de MyThings.Panels. La llamada a qt_add_qml_module() se encontraría en el archivo CMakeLists.txt que se muestra.

src
 +-- MyThings
      +-- Panels
           +-- CMakeLists.txt

Al módulo QML se le asocia un objetivo de complemento independiente. Se utiliza en tiempo de ejecución para cargar el módulo de forma dinámica cuando la aplicación aún no está enlazada al objetivo subyacente. El objetivo de complemento también será una biblioteca y, normalmente, se instala en el mismo directorio que el archivo `qmldir` del módulo.

Lo ideal es que el objetivo del complemento no contenga nada más que una implementación trivial de la clase del complemento. Esto permite que el complemento se designe como opcional en el archivo ` qmldir `. De este modo, otros objetivos pueden vincularse directamente al objetivo de soporte y el complemento no será necesario en tiempo de ejecución, lo que puede mejorar el rendimiento en el tiempo de carga. Por defecto, se generará automáticamente un archivo fuente en C++ que defina una clase de complemento mínima y se añadirá al objetivo del complemento. En los casos en que el módulo QML necesite una implementación personalizada de la clase de complemento, serán necesarias las opciones NO_GENERATE_PLUGIN_SOURCE y, normalmente, NO_PLUGIN_OPTIONAL.

Los módulos QML « STATIC » también generan los complementos QML estáticos si no se especifica « NO_PLUGIN ». Los objetivos que importan dichos módulos QML « STATIC » también deben vincularse explícitamente a los complementos QML correspondientes.

Nota: Al utilizar el enlace estático, puede ser necesario utilizar Q_IMPORT_QML_PLUGIN para garantizar que el complemento QML se enlace correctamente.

Objetivo de complemento sin objetivo de respaldo

Un módulo QML puede definirse de modo que el objetivo «plugin» sirva como su propio objetivo de respaldo. En este caso, el módulo debe cargarse dinámicamente en tiempo de ejecución y no puede ser enlazado directamente por otros objetivos. Para crear esta configuración, debe utilizarse la palabra clave « PLUGIN_TARGET », repitiendo « target » como nombre del objetivo «plugin». Por ejemplo:

qt_add_qml_module(someTarget
    PLUGIN_TARGET someTarget
    ...
)

Aunque esta configuración puede parecer ligeramente más sencilla de implementar, es preferible utilizar un objetivo de respaldo independiente siempre que sea posible, debido a que puede ofrecer un mejor rendimiento en el tiempo de carga.

Ejecutable como módulo QML

Un objetivo ejecutable puede actuar como objetivo de respaldo para un módulo QML. En este caso, no habrá biblioteca de complementos, ya que el módulo QML siempre se cargará directamente como parte de la aplicación. El comando « qt_add_qml_module() » detectará cuándo se utiliza un ejecutable como objetivo de respaldo y desactivará automáticamente la creación de un complemento independiente. No utilices ninguna de las opciones que incluyan « PLUGIN » en su nombre cuando utilices esta configuración.

Cuando se utiliza un ejecutable como destino de respaldo, no se espera que la estructura del directorio de fuentes coincida con la ruta de destino del módulo QML. Consulte Almacenamiento en caché de fuentes QML compiladas para conocer otras diferencias en la ruta de destino de los recursos compilados.

Generación automática de archivos « qmldir » y «typeinfo»

Por defecto, se generarán automáticamente un archivo «qmldir» y un archivo «typeinfo» para el módulo QML que se esté definiendo. El contenido de dichos archivos viene determinado por los distintos argumentos proporcionados a este comando, así como por los archivos fuente y « .qml » añadidos al destino de respaldo. El argumento OUTPUT_DIRECTORY determina dónde se escribirán los archivos « qmldir » y «typeinfo». Si el módulo QML tiene un complemento, dicho complemento también se creará en el mismo directorio que el archivo « qmldir ».

Si la política QTP0004 se establece en « NEW », por cada directorio adicional que contenga archivos « .qml » se generará otro archivo « qmldir ». Estos archivos « qmldir » adicionales se limitan a redirigir al directorio base del módulo mediante una directiva « prefer ». De este modo, todos los componentes QML de un módulo pueden acceder entre sí, independientemente del directorio en el que estén almacenados.

Si se utiliza un Qt compilado estáticamente, los archivos .qml del objetivo de respaldo se analizarán durante la ejecución de la configuración de CMake para determinar las importaciones utilizadas por el módulo y establecer las relaciones de enlace (se puede especificar la palabra clave NO_IMPORT_SCAN para desactivar esto). Cuando se añade o se elimina un archivo ` .qml ` del módulo, CMake normalmente se volverá a ejecutar automáticamente y se volverán a analizar los archivos pertinentes, ya que se habrá modificado un archivo ` CMakeLists.txt `. Durante el desarrollo, un archivo .qml ya existente puede añadir o eliminar una importación o un tipo. Por sí solo, esto no provocaría que CMake se volviera a ejecutar automáticamente, por lo que debes volver a ejecutar CMake de forma explícita para forzar la regeneración del archivo qmldir y la actualización de cualquier relación de enlace.

Los fuentes C++ del objetivo de respaldo se analizan en el momento de la compilación para generar un archivo «typeinfo» y un archivo C++ que registre los tipos asociados. El archivo C++ generado se añade automáticamente al objetivo de respaldo como fuente. Para ello, es necesario que la opción « AUTOMOC » esté habilitada en el objetivo. El proyecto es responsable de garantizarlo, normalmente estableciendo la variable « CMAKE_AUTOMOC » en « TRUE » antes de llamar a « qt_add_qml_module() », o pasando un destino existente con la propiedad de destino « AUTOMOC » ya establecida en « TRUE ». No es un error tener « AUTOMOC » desactivado en el destino, pero en ese caso el proyecto es responsable de gestionar las consecuencias. Esto puede implicar tener que generar manualmente el archivo «typeinfo» en lugar de permitir que se genere automáticamente con detalles que faltan, así como añadir código C++ para registrar los tipos.

Los proyectos deberían dar prioridad al uso de los archivos «typeinfo» y « qmldir » generados automáticamente siempre que sea posible. Son más fáciles de mantener y no son tan propensos a errores como los archivos escritos a mano. No obstante, en situaciones en las que el proyecto necesite proporcionar estos archivos por sí mismo, se puede desactivar la generación automática. La opción « NO_GENERATE_QMLDIR » desactiva la generación automática de « qmldir », y la opción « NO_GENERATE_QMLTYPES » desactiva la generación automática de «typeinfo» y del registro de tipos en C++. Si el archivo «typeinfo» generado automáticamente es aceptable, pero el proyecto desea utilizar un nombre diferente para dicho archivo, puede anular el nombre predeterminado con la opción « TYPEINFO » (aunque esto no suele ser necesario).

Almacenamiento en caché de fuentes QML compiladas

Todos los archivos .qml, .js y .mjs añadidos al módulo mediante el argumento QML_FILES se compilarán a bytecode y se almacenarán en caché directamente en el destino de respaldo. Esto mejora el rendimiento del módulo durante la carga. Los archivos originales sin compilar también se almacenan en los recursos del destino de respaldo, ya que el motor QML podría seguir necesitándolos en determinadas situaciones.

La ruta de recurso de cada archivo viene determinada por su ruta relativa al directorio fuente actual (CMAKE_CURRENT_SOURCE_DIR). Esta ruta de recurso se añade a un prefijo formado al concatenar RESOURCE_PREFIX y la ruta de destino (pero véase NO_RESOURCE_TARGET_PATH para conocer una excepción a esta regla).

Si la política QTP0001 se establece en NEW, el valor predeterminado de RESOURCE_PREFIX es /qt/qml/, que es la ruta de importación predeterminada del motor QML. Esto garantiza que los módulos se coloquen en la ruta de importación de QML y puedan localizarse sin necesidad de configuraciones adicionales.

Normalmente, el proyecto debería intentar colocar los archivos .qml en la misma ubicación relativa que tendrían en los recursos. Si el archivo .qml se encuentra en un directorio relativo diferente al de su ruta de recursos deseada, es necesario especificar explícitamente su ubicación en los recursos. Esto se hace configurando la propiedad del archivo fuente QT_RESOURCE_ALIAS, que debe establecerse antes de añadir el archivo .qml. Por ejemplo:

set_source_files_properties(path/to/somewhere/MyFrame.qml PROPERTIES
    QT_RESOURCE_ALIAS MyFrame.qml
)

qt_add_qml_module(someTarget
    URI MyCo.Frames
    RESOURCE_PREFIX /my.company.com/imports
    QML_FILES
        path/to/somewhere/MyFrame.qml
        AnotherFrame.qml
)

En el ejemplo anterior, la ruta de destino será MyCo/Frames. Tras tener en cuenta las propiedades del archivo de origen, los dos archivos « .qml » se encontrarán en las siguientes rutas de recursos:

  • /my.company.com/imports/MyCo/Frames/MyFrame.qml
  • /my.company.com/imports/MyCo/Frames/AnotherFrame.qml

En el caso excepcional de que desee anular la selección automática del programa qmlcachegen que se va a utilizar, puede establecer la propiedad de destino QT_QMLCACHEGEN_EXECUTABLE en el destino del módulo. Por ejemplo:

set_target_properties(someTarget PROPERTIES
    QT_QMLCACHEGEN_EXECUTABLE qmlcachegen
)

Esto selecciona explícitamente qmlcachegen como el programa que se va a utilizar, incluso si hay mejores alternativas disponibles.

Además, puedes pasar argumentos adicionales a `qmlcachegen` configurando la opción ` QT_QMLCACHEGEN_ARGUMENTS `. En concreto, la opción ` --only-bytecode ` desactivará la compilación del código de script QML a C++. Por ejemplo:

set_target_properties(someTarget PROPERTIES
    QT_QMLCACHEGEN_ARGUMENTS "--only-bytecode"
)

Otro argumento importante es ` --direct-calls`. Se puede utilizar para habilitar el modo directo del compilador de scripts QML en caso de que estén instaladas las extensiones del compilador ` Qt Quick `. Si las extensiones no están instaladas, el argumento se ignora. Existe una forma abreviada para ello: ` QT_QMLCACHEGEN_DIRECT_CALLS `.

set_target_properties(someTarget PROPERTIES
    QT_QMLCACHEGEN_DIRECT_CALLS ON
)

Por último, el argumento --verbose se puede utilizar para ver la salida de diagnóstico de qmlcachegen:

set_target_properties(someTarget PROPERTIES
    QT_QMLCACHEGEN_ARGUMENTS "--verbose"
)

Con esta opción activada, qmlcachegen mostrará advertencias para cada función que no pueda compilar a C++. Algunas de estas advertencias señalarán problemas en tu código QML y otras te indicarán que ciertas características del lenguaje QML no están implementadas en el generador de código C++. En ambos casos, qmlcachegen seguirá generando código byte para dichas funciones. Si solo quieres ver los problemas en tu código QML, deberías utilizar qmllint y los objetivos generados para él.

Análisis de código fuente QML

Se creará automáticamente un objetivo de análisis de código independiente si se añaden archivos ` .qml ` al módulo mediante la palabra clave ` QML_FILES `, o mediante una llamada posterior a `qt_target_qml_sources()`. El nombre del objetivo de análisis de código será ` target ` seguido de ` _qmllint`. También se proporciona, para mayor comodidad, un objetivo ` all_qmllint ` que depende de todos los objetivos individuales ` *_qmllint `.

Se crea automáticamente un objetivo de compilación global dump_qml_context_properties que ejecuta qmlcontextpropertydump cuando aún no existe ningún archivo de volcado de propiedades de contexto QML. qmlcontextpropertydump crea un archivo de volcado de propiedades de contexto QML que qmllint lee para advertir sobre los usos de las propiedades de contexto en QML.

Un objetivo de compilación global « clean_qml_context_properties » permite eliminar un archivo de volcado de propiedades de contexto QML ya existente y puede utilizarse para volver a calcular dicho archivo en una futura compilación del objetivo de compilación global « dump_qml_context_properties ».

Los objetivos de linting dependen del objetivo de compilación « dump_qml_context_properties » cuando la variable QT_QMLLINT_CONTEXT_PROPERTY_DUMP está habilitada.

Convenciones de nomenclatura para los archivos « .js »

Los nombres de los archivos JavaScript que estén destinados a ser tratados como componentes deben comenzar con una letra mayúscula.

Como alternativa, puedes utilizar nombres de archivo en minúsculas y establecer la propiedad del archivo fuente QT_QML_SOURCE_TYPENAME con el nombre del tipo deseado.

Singletons

Si un módulo QML contiene archivos « .qml » que proporcionan tipos singleton, es necesario que la propiedad de origen « QT_QML_SINGLETON_TYPE » de dichos archivos se establezca en « TRUE », para garantizar que el comando « singleton » se escriba en el archivo «qmldir ». Esto debe hacerse además de incluir en el archivo QML la instrucción « pragma Singleton ». La propiedad de origen debe establecerse antes de crear el módulo al que pertenece el singleton.

Consulte qt_target_qml_sources() para ver un ejemplo de cómo configurar la propiedad « QT_QML_SINGLETON_TYPE ».

Compilación de QML a C++ con el compilador de tipos QML

Nota: El compilador de tipos QML qmltc no garantiza que el código C++ generado mantenga la compatibilidad de API, código fuente o binario entre versiones pasadas o futuras, ni siquiera entre versiones de parche. Además, las aplicaciones compiladas con qmltc que utilicen módulos Qt Qml requerirán la vinculación con la API privada de Qt; véase también Compilación de código QML con qmltc.

Si un módulo QML contiene archivos .qml, puedes compilarlos a C++ utilizando qmltc. A diferencia de la compilación de bytecode, debes habilitar qmltc explícitamente mediante el argumento ENABLE_TYPE_COMPILER. En ese caso, se compilarían los archivos .qml especificados en QML_FILES. Los archivos que terminan en .js y .mjs se ignoran, ya que qmltc no compila código JavaScript. Además, también se omiten los archivos marcados con la propiedad de archivo fuente QT_QML_SKIP_TYPE_COMPILER.

Por defecto, qmltc crea archivos en minúsculas .h y .cpp para un archivo .qml determinado. Por ejemplo, Foo.qml acaba compilándose como foo.h y foo.cpp.

Los archivos C++ creados se colocan en un subdirectorio específico, « .qmltc/<target>/ », dentro del directorio « BINARY_DIR » del archivo « target ». A continuación, estos archivos se añaden automáticamente a las fuentes de destino y se compilan como código Qt C++ junto con otros archivos fuente.

Durante el procesamiento de QML_FILES, se respetan las siguientes propiedades de los archivos fuente:

  • QT_QMLTC_FILE_BASENAME: utiliza esta propiedad del archivo fuente para especificar un nombre de archivo .h y .cpp distinto del predeterminado, lo que puede resultar útil, por ejemplo, para resolver conflictos de nombres de archivo (imagina que tienes un archivo main.qml que se está compilando, pero ya existe un archivo main.h, por lo que #include "main.h" podría no funcionar como esperas). Se espera que QT_QMLTC_FILE_BASENAME sea un nombre de archivo (sin extensión), por lo que se ignora cualquier directorio que lo preceda. A diferencia del comportamiento predeterminado, QT_QMLTC_FILE_BASENAME no se escribe en minúsculas.
  • QT_QML_SKIP_TYPE_COMPILER: utiliza esta propiedad del archivo fuente para especificar que qmltc debe ignorar un archivo QML.

Argumentos

Los argumentos de ` qt_add_qml_module ` se organizan en las siguientes categorías:

CategoríaArgumentos
Argumentos esencialestarget, URI, STATIC, SHARED
VersionesVERSION, PAST_MAJOR_VERSIONS, FOLLOW_FOREIGN_VERSIONING
Fuentes y recursosQML_FILES, SOURCES, RESOURCES, RESOURCE_PREFIX, NO_RESOURCE_TARGET_PATH, DISCARD_QML_CONTENTS
Dependencias de módulosIMPORTS, OPTIONAL_IMPORTS, DEFAULT_IMPORTS, DEPENDENCIES, IMPORT_PATH
Configuración del complementoPLUGIN_TARGET, NO_PLUGIN, NO_PLUGIN_OPTIONAL, NO_CREATE_PLUGIN_TARGET, NO_GENERATE_PLUGIN_SOURCE, CLASS_NAME
Generación de código y herramientasNO_GENERATE_QMLTYPES, NO_GENERATE_QMLDIR, NO_GENERATE_EXTRA_QMLDIRS, TYPEINFO, NO_CACHEGEN, NO_LINT, NO_IMPORT_SCAN, NO_GENERATE_AOT_VALIDATION
Salida e instalaciónOUTPUT_DIRECTORY, OUTPUT_TARGETS, NO_GENERATE_QTCONF
OtrosNAMESPACE, DESIGNER_SUPPORTED
Compilador de tipos QML (qmltc)ENABLE_TYPE_COMPILER, TYPE_COMPILER_NAMESPACE, QMLTC_EXPORT_DIRECTIVE, QMLTC_EXPORT_FILE_NAME

Argumentos imprescindibles

El target especifica el nombre del destino de respaldo para el módulo QML. Por defecto, se crea como una biblioteca compartida si Qt se ha compilado como bibliotecas compartidas; en caso contrario, se crea como una biblioteca estática. Esta elección se puede anular explícitamente con las opciones STATIC o SHARED.

Cada módulo QML debe definir un « URI ». Debe especificarse en notación URI con puntos, como QtQuick.Layouts. Cada segmento debe ser un nombre identificador ECMAScript bien formado. Esto significa, por ejemplo, que los segmentos no deben comenzar con un número ni contener caracteres «-» (menos). Dado que el URI se traducirá a nombres de directorios, debes limitarlo a caracteres alfanuméricos del alfabeto latino, guiones bajos y puntos. Otros módulos QML pueden utilizar este nombre en sentencias de importación para importar el módulo. El URI se utilizará en la línea module del archivo qmldir generado. El URI también se utiliza para formar la ruta de destino sustituyendo los puntos por barras inclinadas.

Consulte Módulos identificados para obtener una explicación más detallada sobre el URI del módulo.

Versiones

Un módulo QML también puede definir un identificador de versión ( VERSION ) con el formato Major.Minor, donde tanto Major como Minor deben ser números enteros. Se puede añadir un componente adicional .Patch, pero se ignorará. Opcionalmente, también se puede indicar una lista de versiones principales anteriores para las que el módulo proporciona tipos después de la palabra clave PAST_MAJOR_VERSIONS (véase más abajo). Consulte «Módulos identificados» para obtener una explicación más detallada sobre la numeración de versiones, «Registro de versiones principales anteriores » para registrar versiones principales anteriores y «Mantenimiento de la sincronización de las versiones de los módulos » para mantener sincronizadas las versiones de los módulos.

Si no necesitas versiones, debes omitir el argumento « VERSION ». Por defecto, se establece en la versión más alta posible. El control de versiones interno de los módulos QML presenta algunos defectos fundamentales. Debes utilizar un mecanismo externo de gestión de paquetes para gestionar las diferentes versiones de tus módulos QML.

Añadir fuentes y recursos al módulo

Nota: Un módulo QML es una unidad de funcionalidad autónoma y agrupada lógicamente. Todos los archivos que componen el módulo deben residir en el mismo directorio que el archivo CMakeLists.txt que define el módulo o en uno de sus subdirectorios. Si se requiere una funcionalidad específica en varios módulos, plantéate encapsularla en un módulo independiente. Este módulo se puede importar luego a otros módulos, lo que favorece la reutilización del código y facilita su mantenimiento.

SOURCES especifica una lista de fuentes que no son QML para añadir al objetivo de respaldo. Se proporciona para mayor comodidad y equivale a añadir las fuentes al objetivo de respaldo con el comando integrado de CMake « target_sources() ».

QML_FILES enumera los archivos ` .qml`, ` .js ` y ` .mjs ` del módulo. Estos se compilarán automáticamente en código byte y se integrarán en el destino de respaldo, a menos que se especifique la opción ` NO_CACHEGEN `. El archivo sin compilar siempre se almacena en los recursos integrados del destino de respaldo, incluso si se especifica ` NO_CACHEGEN `. A menos que se especifique la opción ` NO_LINT `, los archivos sin compilar también serán procesados por ` qmllint ` a través de un destino de compilación personalizado independiente. Los archivos también se utilizarán para rellenar la información de tipos en el archivo «qmldir» generado de forma predeterminada. Se puede especificar « NO_GENERATE_QMLDIR » para desactivar la generación automática del archivo « qmldir ». Normalmente, esto debería evitarse, pero en los casos en que el proyecto necesite proporcionar su propio archivo « qmldir », se puede utilizar esta opción. Desde Qt 6.8, cuando QTP0004 está habilitado, qt_add_qml_module creará archivos qmldir adicionales para cada subdirectorio del módulo QML, lo que garantiza que cada archivo QML importe su propio módulo mediante la importación implícita. Este comportamiento se puede desactivar para un módulo QML pasándole el indicador NO_GENERATE_EXTRA_QMLDIRS. El indicador NO_GENERATE_QMLDIR implica NO_GENERATE_EXTRA_QMLDIRS.

Nota: Consulta qt_target_qml_sources() para obtener más detalles sobre cómo añadir archivos QML después de haber llamado a qt_add_qml_module(). Por ejemplo, es posible que desee añadir archivos de forma condicional en función de una expresión «if», o desde subdirectorios que solo se añadirán si se cumplen determinados criterios. Además, los archivos añadidos con qt_target_qml_sources() también pueden especificar si deben omitirse para la revisión de código, la compilación de bytecode o la generación de archivos « qmldir ».

RESOURCES enumera cualquier otro archivo que necesite el módulo, como las imágenes a las que se hace referencia desde el código QML. Estos archivos se añadirán como recursos compilados (véase RESOURCE_PREFIX para obtener una explicación del punto base en el que se ubicarán). Si es necesario, su ubicación relativa se puede controlar configurando la propiedad de fuente « QT_RESOURCE_ALIAS », al igual que con los archivos « .qml » (véase Almacenamiento en caché de fuentes QML compiladas).

RESOURCE_PREFIX está pensado para encapsular un espacio de nombres para el proyecto y, a menudo, será el mismo para todos los módulos QML que defina el proyecto.

Sin embargo, es preferible establecer la política de CMake «QTP0001 ». Esta define un prefijo de recursos predeterminado que garantiza que tu módulo QML termine en una de las rutas de importación predeterminadas del motor QML.

Si configuras un « RESOURCE_PREFIX », también debes añadirlo a las rutas de importación para que el motor QML pueda encontrar el módulo QML.

Si QTP0001 está habilitado (por ejemplo, mediante qt_standard_project_setup(REQUIRES 6.5)), el valor por defecto es "/qt/qml/"; de lo contrario, es "/".

Cuando se añaden varios archivos a los recursos compilados, se colocan en una ruta formada al concatenar RESOURCE_PREFIX y la ruta de destino. En el caso especial en el que el destino subyacente sea un ejecutable, puede ser conveniente colocar los archivos ` .qml ` del módulo y otros recursos directamente bajo ` RESOURCE_PREFIX `. Esto se puede lograr especificando la opción ` NO_RESOURCE_TARGET_PATH `, que solo se puede utilizar si el destino subyacente es un ejecutable.

Nota: La ruta de recursos, el directorio de salida en el disco y la ruta de importación están relacionadas entre sí. Al modificar cualquiera de ellas, asegúrese de que las demás sean coherentes para que el motor QML y las herramientas puedan localizar el módulo. Consulte «Estructuras de directorios personalizadas» en «Cómo escribir módulos QML» para obtener una explicación completa.

Registro de versiones principales anteriores

PAST_MAJOR_VERSIONS contiene una lista de versiones principales adicionales que ofrece el módulo. Para cada una de esas versiones y cada archivo QML que no tenga la configuración « QT_QML_SOURCE_VERSIONS », se generará una entrada adicional en el archivo «qmldir» para especificar la versión extra. Además, el código de registro del módulo generado registrará las versiones principales anteriores utilizando « qmlRegisterModule()» en el lado de C++. El código de registro del módulo se genera automáticamente para tu módulo QML, a menos que especifiques NO_GENERATE_QMLTYPES (aunque se desaconseja encarecidamente el uso de esta opción). El uso de PAST_MAJOR_VERSIONS añade cierta sobrecarga cuando se importa tu módulo. Debes incrementar la versión principal de tu módulo lo menos posible. Una vez que puedas dar por hecho que todos los archivos QML que importan este módulo omiten la versión en sus importaciones, podrás omitir con total seguridad PAST_MAJOR_VERSIONS. De este modo, todos los archivos QML importarán la última versión de tu módulo. Si tienes que admitir importaciones con versión, plantéate admitir solo un número limitado de versiones principales anteriores.

Declaración de dependencias de módulos

IMPORTS proporciona una lista de otros módulos QML que importa este módulo. Cada módulo que aparece aquí se añadirá como una entrada « import » en el archivo «qmldir» generado. Si un archivo QML importa este módulo, también importará todos los módulos enumerados en « IMPORTS ». Opcionalmente, se puede especificar una versión añadiéndola tras una barra, como QtQuick/2.0. Si se omite la versión, se importará la versión más reciente disponible. Solo se puede especificar la versión principal, como en QtQuick/2. En ese caso, se importará la versión secundaria más reciente disponible para la versión principal indicada. Por último, se puede indicar auto como versión (QtQuick/auto). Si se indica auto, la versión con la que se está importando el módulo actual se propaga al módulo que se va a importar. Dada una entrada QtQuick/auto en un módulo YourModule, si un archivo QML especifica import YourModule 3.14, esto da como resultado la importación de la versión 3.14 de QtQuick. Para módulos relacionados que sigan un esquema de versionado común, se debe utilizar auto.

Las entradas de IMPORTS también pueden hacer referencia a objetivos de CMake anteponiendo al nombre del objetivo la palabra clave TARGET. En este caso, el URI del módulo QML se determina automáticamente a partir del objetivo. Esto requiere activar la política de CMake QTP0005.

Por ejemplo, un módulo QML puede importar otro módulo haciendo referencia al objetivo de CMake que lo proporciona:

qt_add_qml_module(my_module
    URI MyModule
    VERSION 1.0
    IMPORTS
        TARGET OtherQmlModule
)

OPTIONAL_IMPORTS proporciona una lista de otros módulos QML que este módulo puede importar en tiempo de ejecución. El motor QML no los importa automáticamente al importar el módulo actual, sino que sirven como indicaciones para herramientas como qmllint. Las versiones se pueden especificar de la misma forma que para IMPORTS. Cada módulo de la lista se añadirá como una entrada optional import en el archivo qmldir generado.

Las entradas de OPTIONAL_IMPORTS también pueden hacer referencia a objetivos de CMake anteponiendo la palabra clave TARGET al nombre del objetivo. En este caso, el URI del módulo QML se determina automáticamente a partir del objetivo. Para ello, es necesario activar la política de CMake QTP0005.

Por ejemplo:

qt_add_qml_module(my_module
    URI MyModule
    VERSION 1.0
    OPTIONAL_IMPORTS
        TARGET OptionalQmlModule
)

DEFAULT_IMPORTS especifica cuáles de las importaciones opcionales son las entradas predeterminadas que deben cargarse mediante las herramientas. Debe especificarse una entrada para cada grupo de OPTIONAL_IMPORTS del módulo. Dado que las importaciones opcionales solo se resuelven en tiempo de ejecución, las herramientas como qmllint no pueden, en general, saber cuál de las importaciones opcionales debe resolverse. Para solucionar esto, puedes especificar una de las importaciones opcionales como importación por defecto; de este modo, las herramientas la seleccionarán. Si tienes una importación opcional que se utiliza en tiempo de ejecución sin necesidad de configuración adicional, esa es una candidata ideal para la importación por defecto.

Las entradas de DEFAULT_IMPORTS también pueden hacer referencia a objetivos de CMake anteponiendo al nombre del objetivo la palabra clave « TARGET ». En este caso, la URI del módulo QML se determina automáticamente a partir del objetivo. Esto requiere activar la política de CMake QTP0005.

Por ejemplo:

qt_add_qml_module(my_module
    URI MyModule
    VERSION 1.0
    OPTIONAL_IMPORTS
        TARGET BackendA
        TARGET BackendB
    DEFAULT_IMPORTS
        TARGET BackendA
)

DEPENDENCIES proporciona una lista de otros módulos QML de los que depende este módulo, pero que no necesariamente importa. Normalmente se utilizaría para dependencias que solo existen a nivel de C++, como un módulo que registra una clase en QML y que utiliza o hereda tipos definidos en C++ en otro módulo.

Por ejemplo, si se quisiera crear una subclase de ` QQuickItem ` de la siguiente manera:

class MyItem: public QQuickItem { ... };

entonces hay que asegurarse de que el módulo que contiene ` QQuickItem`, denominado ` QtQuick`, se declare como dependencia mediante la opción ` DEPENDENCIES `:

qt_add_qml_module(myTarget
    ...
    DEPENDENCIES QtQuick
)

De no hacerlo, podrían producirse errores de linting, errores durante la compilación de tipos con qmltc o durante la compilación de enlaces y funciones a C++ con qmlcachegen.

Otro ejemplo podría ser:

class MyComponent : public QObject {
    Q_OBJECT
    QML_ELEMENT

    // ...

signals:
    void sigZoomAtMousePosition(const QPointF& aMousePos, double aZoomScaleFactor);
};

donde se requiere « DEPENDENCIES QtQml » para que las herramientas de QML puedan encontrar y utilizar « QPointF »:

qt_add_qml_module(myTarget
    ...
    DEPENDENCIES QtQml
)

Las entradas de DEPENDENCIES también pueden hacer referencia a objetivos de CMake anteponiendo la palabra clave TARGET al nombre del objetivo. En este caso, la URI del módulo QML y la ruta de importación se determinan automáticamente a partir del objetivo. Para ello, es necesario activar la política de CMake QTP0005.

Por ejemplo, un módulo QML puede declarar una dependencia de otro módulo haciendo referencia al objetivo de CMake que lo proporciona:

qt_add_qml_module(my_module
    URI MyModule
    VERSION 1.0
    DEPENDENCIES
        TARGET OtherQmlModule
)

Nota: El uso de « TARGET <cmake-target> » en « DEPENDENCIES », « IMPORTS », « OPTIONAL_IMPORTS » o « DEFAULT_IMPORTS » no vincula automáticamente con el objetivo indicado. Solo se utiliza para derivar metadatos QML, rutas de importación y para establecer dependencias en el orden de compilación. Si el módulo QML o su complemento generado requiere símbolos de ese objetivo, dicho objetivo debe vincularse explícitamente utilizando « target_link_libraries() ».

Nota: El « <cmake-target> » utilizado con la palabra clave « TARGET » debe ser un objetivo compilado por tu proyecto (no un objetivo importado proporcionado por find_package).

Nota: Al utilizar ` TARGET <cmake-target> ` en ` DEPENDENCIES`, ` IMPORTS`, ` OPTIONAL_IMPORTS` o ` DEFAULT_IMPORTS`, solo se establece la dependencia directa del objetivo especificado. Las dependencias transitivas de módulos QML del objetivo al que se hace referencia (es decir, los módulos QML de los que depende ese mismo objetivo) no se añaden automáticamente. Cada dependencia de módulo QML debe declararse explícitamente.

Nota: No es necesarioañadir el módulo a DEPENDENCIES si ya se ha importado mediante la opción IMPORTS. Se recomienda utilizar la alternativa más ligera DEPENDENCIES en lugar de IMPORTS.

Cuando el destino de respaldo es un ejecutable y se utilizan dependencias de tipo « TARGET » (requiere QTP0005), « qt_add_qml_module() » genera automáticamente un archivo de tipo « qt.conf » junto al ejecutable en el árbol de compilación. Este archivo configura la ruta de importación de QML para que el motor QML pueda localizar las dependencias del módulo en tiempo de ejecución sin necesidad de realizar entradas manuales de tipo « IMPORT_PATH ». La opción « NO_GENERATE_QTCONF » suprime este comportamiento, lo cual puede ser necesario si el archivo generado entra en conflicto con un archivo « qt.conf » ya presente en el directorio de compilación. Esta opción se introdujo en Qt 6.12.

Advertencia: Al utilizar « NO_GENERATE_QTCONF », es posible que la aplicación no encuentre las dependencias de sus módulos QML en tiempo de ejecución. Debe configurar manualmente la ruta de importación de QML, por ejemplo, añadiendo las rutas de importación adecuadas al archivo « qt.conf » existente.

La versión del módulo de las dependencias debe especificarse junto con el nombre del módulo, en el mismo formato que se utiliza para IMPORTS y OPTIONAL_IMPORTS. Cada módulo que figure aquí se añadirá como una entrada depends en el archivo qmldir generado.

IMPORT_PATH Se puede utilizar para añadir a las rutas de búsqueda los lugares donde se pueden encontrar otros módulos QML de los que depende este. Los demás módulos deben tener su archivo « qmldir » en su propia ruta de destino, situada debajo de una de las rutas de búsqueda. Qt asume que todos los archivos que se encuentran en « IMPORT_PATH » proceden de una fuente de confianza.

Si el destino subyacente es una biblioteca estática y dicha biblioteca se va a instalar, se debe especificar ` OUTPUT_TARGETS ` para proporcionar una variable en la que almacenar una lista de destinos adicionales que también deberán instalarse. Estos destinos adicionales son generados internamente por ` qt_add_qml_module() ` y son referenciados por los requisitos de enlace del destino subyacente como parte del proceso para garantizar que los recursos se configuren y se carguen correctamente.

Objetivos y objetivos de complementos

Las siguientes opciones controlan cómo se crea y configura el objetivo del complemento. Para la mayoría de los módulos, los valores predeterminados son adecuados y no es necesario utilizar ninguna de estas opciones. Casos habituales:

  • Por defecto: se crea automáticamente un objetivo de complemento independiente con un archivo fuente generado. El complemento es opcional (no se carga cuando la biblioteca subyacente se enlaza directamente).
  • Complemento personalizado: utiliza NO_GENERATE_PLUGIN_SOURCE para proporcionar tu propia implementación de la clase del complemento. También debes establecer CLASS_NAME para que coincida con tu clase de complemento personalizada. Normalmente también requiere NO_PLUGIN_OPTIONAL, ya que el complemento contiene entonces código no trivial.
  • Sin complemento: utilice NO_PLUGIN cuando el módulo siempre se vincule directamente y nunca se cargue dinámicamente.
  • Objetivo ejecutable: no se crea ningún complemento automáticamente.

PLUGIN_TARGET Especifica el objetivo del complemento asociado al módulo QML. El « PLUGIN_TARGET » puede ser el mismo que el « target » de respaldo; en ese caso, no habrá un objetivo de respaldo independiente. Si no se proporciona « PLUGIN_TARGET », el valor por defecto es « target » con « plugin » añadido al final. Por ejemplo, un destino de respaldo denominado mymodule tendría un nombre de complemento por defecto de mymoduleplugin. El nombre del destino del complemento se utilizará para completar la línea plugin en el archivo qmldir generado. Por lo tanto, no debes intentar cambiar el nombre de salida del complemento configurando propiedades del destino como OUTPUT_NAME o cualquiera de sus propiedades relacionadas.

El target de soporte y el objetivo del complemento (si son diferentes) se crearán mediante el comando, a menos que ya existan. Por lo general, los proyectos deben permitir que el comando los cree para que se generen con el tipo de objetivo adecuado. Si el target de soporte es una biblioteca estática, el complemento también se creará como una biblioteca estática. Si el target de apoyo es una biblioteca compartida, el complemento se creará como una biblioteca de módulos. Si se pasa un target ya existente y este es un objetivo ejecutable, no habrá complemento. Si se pretende enlazar siempre directamente con el objetivo de apoyo y no se necesita un complemento, este se puede desactivar añadiendo la opción NO_PLUGIN. Especificar tanto NO_PLUGIN como PLUGIN_TARGET es un error.

En determinadas situaciones, es posible que el proyecto quiera retrasar la creación del objetivo del complemento hasta después de la llamada. En ese caso, se puede especificar la opción « NO_CREATE_PLUGIN_TARGET ». Se espera entonces que el proyecto llame a «qt_add_qml_plugin()» en el objetivo del complemento una vez que se haya creado. Cuando se especifica « NO_CREATE_PLUGIN_TARGET », también debe proporcionarse « PLUGIN_TARGET » para nombrar explícitamente el objetivo del complemento.

Por defecto, qt_add_qml_module() generará automáticamente un archivo .cpp que implemente la clase de complemento especificada por el argumento CLASS_NAME. El archivo .cpp generado se añadirá automáticamente al objetivo del complemento como archivo fuente que se debe compilar. Si el proyecto desea proporcionar su propia implementación de la clase del complemento, debe especificarse la opción NO_GENERATE_PLUGIN_SOURCE. Cuando no se proporciona CLASS_NAME, el valor por defecto es URI, sustituyendo los puntos por guiones bajos y añadiendo a continuación Plugin. A menos que el módulo QML no tenga ningún complemento, el nombre de la clase se registrará como una línea classname en el archivo qmldir generado. Debes añadir cualquier archivo C++ con código de complemento personalizado al objetivo del complemento. Dado que es probable que el complemento contenga funcionalidades que vayan más allá de la simple carga de la biblioteca de apoyo, es probable que también quieras añadir NO_PLUGIN_OPTIONAL. De lo contrario, el motor QML podría omitir la carga del complemento si detecta que la biblioteca de apoyo ya está enlazada.

Si se especifica la palabra clave « NO_PLUGIN », no se compilará ningún complemento. Por lo tanto, esta palabra clave es incompatible con todas las opciones que personalizan el objetivo del complemento, en particular NO_GENERATE_PLUGIN_SOURCE, NO_PLUGIN_OPTIONAL, PLUGIN_TARGET, NO_CREATE_PLUGIN_TARGET y CLASS_NAME. Si no se proporciona un complemento para el módulo, este solo será totalmente utilizable si su biblioteca de apoyo se ha vinculado al ejecutable. Por lo general, es difícil garantizar que un enlazador conserve el enlace a una biblioteca que considera que no se utiliza.

Si se especifica la palabra clave « NO_PLUGIN_OPTIONAL », el complemento se registra en el archivo « qmldir » generado como no opcional. Si toda la funcionalidad de un módulo QML se implementa en su objetivo de respaldo y el objetivo del complemento es independiente, entonces el complemento puede ser opcional, lo cual es la configuración predeterminada y recomendada. El archivo fuente del complemento generado automáticamente cumple este requisito. Cuando un proyecto proporciona su propia implementación de ` .cpp ` para el complemento, esto suele significar que también se necesita la palabra clave ` NO_PLUGIN_OPTIONAL `, ya que es casi seguro que el complemento contendrá funcionalidades que el módulo QML requiere.

Registro automático de tipos

qt_add_qml_module genera automáticamente varios archivos. Las siguientes opciones controlan lo que se genera. En la mayoría de los casos, los valores predeterminados son correctos y no se necesita ninguna de estas opciones.

OpciónLo que desactiva
NO_GENERATE_QMLTYPESEl archivo Typeinfo (.qmltypes) y el código de registro de tipos de C++
NO_GENERATE_QMLDIREl archivo de definición del módulo qmldir (implica NO_GENERATE_EXTRA_QMLDIRS)
NO_GENERATE_EXTRA_QMLDIRSArchivos qmldir adicionales para subdirectorios (véase QTP0004)
NO_CACHEGENCompilación de código byte de los archivos .qml, .js y .mjs
NO_LINTEl objetivo de linting « *_qmllint »
NO_IMPORT_SCANEscaneo automático de importaciones (compilaciones estáticas: en el momento de la configuración; ejecutables: en el momento de la compilación)
NO_GENERATE_AOT_VALIDATIONGeneración de código para validar el código nativo generado previamente por el compiladorQt Quick . Esta opción se introdujo en Qt 6.12.

El registro de tipos se realiza automáticamente para los archivos fuente C++ del objetivo de respaldo que son procesados por AUTOMOC. Esto generará un archivo typeinfo en el directorio de salida, cuyo nombre será el nombre de target con .qmltypes añadido al final. Este nombre de archivo se puede cambiar utilizando la opción TYPEINFO si se desea, aunque normalmente no debería ser necesario. El nombre del archivo también se registra como una entrada typeinfo en el archivo qmldir generado. El registro automático de tipos se puede desactivar mediante la opción NO_GENERATE_QMLTYPES; en ese caso, no se generará ningún archivo typeinfo, pero se seguirá esperando que el proyecto genere un archivo typeinfo y lo coloque en el mismo directorio que el archivo qmldir generado.

OUTPUT_DIRECTORY especifica dónde se generan la biblioteca del complemento, los archivos « qmldir » y «typeinfo». Cuando no se proporciona esta palabra clave, el valor por defecto será la ruta de destino (formada a partir de « URI ») añadida al valor de la variable «QT_QML_OUTPUT_DIRECTORY ». Si dicha variable no está definida, el valor por defecto dependerá del tipo de destino subyacente. Para los ejecutables, el valor será la ruta de destino a la que se añade ${CMAKE_CURRENT_BINARY_DIR}, mientras que para otros destinos será simplemente ${CMAKE_CURRENT_BINARY_DIR}. Cuando la estructura del árbol de fuentes coincide con la estructura de las rutas de destino de los módulos QML (lo cual es muy recomendable), a menudo no es necesario utilizar QT_QML_OUTPUT_DIRECTORY. Para que coincida con la estructura de las rutas de destino, debes nombrar tus directorios exactamente igual que los segmentos de la URI de tu módulo. Por ejemplo, si la URI de tu módulo es MyUpperCaseThing.mylowercasething, debes colocarlo en un directorio llamado MyUpperCaseThing/mylowercasething/.

La necesidad de especificar la palabra clave « OUTPUT_DIRECTORY » debería ser poco frecuente, pero si se utiliza, es probable que quien la utilice también tenga que añadirla a IMPORT_PATH para garantizar que el linting, la compilación en caché de las fuentes QML, la importación automática de complementos en compilaciones estáticas y el despliegue de módulos QML importados para compilaciones no estáticas funcionen correctamente.

Qt Quick Compatibilidad con el diseñador

DESIGNER_SUPPORTED debería garantizarse si el módulo QML es compatible con el Diseñador de Qt Quick. Cuando esté presente, el archivo qmldir generado contendrá una línea designersupported. Consulte «Archivos qmldir de definición de módulos» para saber cómo afecta esto a la forma en que el Diseñador de Qt Quick gestiona el complemento.

Mantener sincronizadas las versiones de los módulos

La palabra clave « FOLLOW_FOREIGN_VERSIONING » se refiere a los tipos base de tus propios tipos QML definidos en C++ que residen en diferentes módulos QML. Normalmente, el esquema de versiones de tu módulo no coincide con el del módulo que proporciona los tipos base. Por lo tanto, de forma predeterminada, todas las revisiones de los tipos base están disponibles en cualquier importación de su módulo. Si se especifica ` FOLLOW_FOREIGN_VERSIONING `, se respeta la información de versión asociada a los tipos base y a sus propiedades. Así pues, una importación del tipo ` import MyModule 2.8 ` solo pondrá a disposición las propiedades versionadas hasta la versión ` 2.8 ` de cualquier tipo base ajeno a ` MyModule`. Esto resulta especialmente útil si deseas mantener la versión de tu módulo sincronizada con la de otros módulos en los que basas tus tipos. En ese caso, es posible que desees que tus tipos personalizados no expongan propiedades de una versión del tipo base de un módulo superior a la que se está importando.

Espacios de nombres C++ del código generado

Si se especifica un espacio de nombres con la palabra clave « NAMESPACE », el complemento y el código de registro se generarán en un espacio de nombres de C++ con ese nombre.

qmlimportscanner y NO_IMPORT_SCAN

En las compilaciones estáticas de Qt, qmlimportscanner se ejecuta durante la fase de configuración para analizar los archivos .qml de un módulo QML e identificar las importaciones QML que utiliza (véase qt_import_qml_plugins()). En el caso de las compilaciones no estáticas de Qt, si el objetivo es un ejecutable, se realiza un análisis similar durante la compilación para proporcionar la información necesaria a los scripts de implementación (véase qt_deploy_qml_imports()). Ambos análisis pueden desactivarse especificando la opción « NO_IMPORT_SCAN ». Hacerlo significa que el proyecto asume la responsabilidad de garantizar que todos los complementos necesarios se instancien y se enlacen para las compilaciones estáticas. En el caso de las compilaciones no estáticas, el proyecto debe determinar y desplegar manualmente todos los módulos QML utilizados por un objetivo ejecutable.

DISCARD_QML_CONTENTS

Por defecto, el contenido de los archivos fuente QML y JS se incluye en el sistema de recursos del objetivo. Utiliza DISCARD_QML_CONTENTS para eliminar este contenido y reducir el tamaño del binario.

Nota: Si omites el código fuente del binario, el motor QML tendrá que basarse en las unidades de compilación creadas por qmlcachegen o qmlsc. Estas están vinculadas a la versión específica de Qt con la que se compilaron. Si cambias la versión de Qt que utiliza tu aplicación, ya no se podrán cargar.

Argumentos de qmltc

ENABLE_TYPE_COMPILER pueden utilizarse para compilar archivos « .qml » a código fuente C++ con qmltc. Los archivos con la propiedad «source» QT_QML_SKIP_TYPE_COMPILER no se compilan a C++.

TYPE_COMPILER_NAMESPACE Este argumento permite anular el espacio de nombres en el que qmltc genera el código. Por defecto, el espacio de nombres del código generado sigue la jerarquía de módulos tal y como se muestra en la URI; por ejemplo, MyModule para un módulo con la URI MyModule o com::example::Module para la URI com.example.MyModule. Al especificar la opción TYPE_COMPILER_NAMESPACE, el código generado puede colocarse en su lugar en un espacio de nombres personalizado, en el que los diferentes subespacios de nombres deben separarse mediante «::», por ejemplo, «MyNamespace::MySubnamespace» para el espacio de nombres MySubnamespace que se encuentra dentro de MyNamespace. Aparte del «::», se aplican las reglas de nomenclatura de los espacios de nombres de C++.

QMLTC_EXPORT_DIRECTIVE Se debe utilizar junto con « QMLTC_EXPORT_FILE_NAME » cuando las clases generadas por qmltc deban exportarse desde la biblioteca QML. Por defecto, las clases generadas por qmltc no se exportan desde su biblioteca. El encabezado que define la macro de exportación para la biblioteca actual puede especificarse como un argumento opcional de QMLTC_EXPORT_FILE_NAME, mientras que el nombre de la macro de exportación debe especificarse como un argumento de QMLTC_EXPORT_DIRECTIVE. Si no se requiere ni se desea ninguna inclusión adicional, por ejemplo, cuando el encabezado de la macro de exportación ya está incluido indirectamente por una clase base, entonces se puede omitir la opción QMLTC_EXPORT_FILE_NAME.

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