QQmlEngine Class
La clase QQmlEngine proporciona un entorno para instanciar componentes QML. Más información...
| Encabezado: | #include <QQmlEngine> |
| CMake: | find_package(Qt6 REQUIRED COMPONENTS Qml) target_link_libraries(mytarget PRIVATE Qt6::Qml) |
| qmake: | QT += qml |
| Heredado de: | QJSEngine |
| Heredado por: |
Propiedades
- offlineStoragePath : QString
Funciones públicas
| QQmlEngine(QObject *parent = nullptr) | |
| virtual | ~QQmlEngine() override |
| void | addImageProvider(const QString &providerId, QQmlImageProviderBase *provider) |
| void | addImportPath(const QString &path) |
| void | addPluginPath(const QString &path) |
| void | addUrlInterceptor(QQmlAbstractUrlInterceptor *urlInterceptor) |
| QUrl | baseUrl() const |
| void | clearComponentCache() |
| void | clearSingletons() |
| QQmlImageProviderBase * | imageProvider(const QString &providerId) const |
| QStringList | importPathList() const |
| QQmlIncubationController * | incubationController() const |
| QUrl | interceptUrl(const QUrl &url, QQmlAbstractUrlInterceptor::DataType type) const |
(since 6.6) void | markCurrentFunctionAsTranslationBinding() |
| QNetworkAccessManager * | networkAccessManager() const |
| QQmlNetworkAccessManagerFactory * | networkAccessManagerFactory() const |
| QString | offlineStorageDatabaseFilePath(const QString &databaseName) const |
| QString | offlineStoragePath() const |
| bool | outputWarningsToStandardError() const |
| QStringList | pluginPathList() const |
| void | removeImageProvider(const QString &providerId) |
| void | removeUrlInterceptor(QQmlAbstractUrlInterceptor *urlInterceptor) |
| QQmlContext * | rootContext() const |
| void | setBaseUrl(const QUrl &url) |
(since 6.12) bool | setExternalSingletonInstance(QAnyStringView moduleName, QAnyStringView typeName, QObject *instance) |
| void | setImportPathList(const QStringList &paths) |
| void | setIncubationController(QQmlIncubationController *controller) |
| void | setNetworkAccessManagerFactory(QQmlNetworkAccessManagerFactory *factory) |
| void | setOfflineStoragePath(const QString &dir) |
| void | setOutputWarningsToStandardError(bool enabled) |
| void | setPluginPathList(const QStringList &paths) |
| T | singletonInstance(int qmlTypeId) |
(since 6.5) T | singletonInstance(QAnyStringView uri, QAnyStringView typeName) |
| void | trimComponentCache() |
| QList<QQmlAbstractUrlInterceptor *> | urlInterceptors() const |
Ranuras públicas
| void | retranslate() |
Señales
| void | exit(int retCode) |
(since 6.5) void | offlineStoragePathChanged() |
| void | quit() |
| void | warnings(const QList<QQmlError> &warnings) |
Miembros públicos estáticos
| QQmlContext * | contextForObject(const QObject *object) |
| void | setContextForObject(QObject *object, QQmlContext *context) |
Funciones protegidas reimplementadas
| virtual bool | event(QEvent *e) override |
Elementos no miembros relacionados
| QQmlContext * | qmlContext(const QObject *object) |
| QQmlEngine * | qmlEngine(const QObject *object) |
Macros
| QML_NAMESPACE_EXTENDED(EXTENSION_NAMESPACE) |
Descripción detallada
Un QQmlEngine se utiliza para gestionar los « components » y los objetos creados a partir de ellos, así como para ejecutar sus enlaces y funciones. QQmlEngine también hereda de « QJSEngine », lo que permite una integración perfecta entre los componentes QML y el código JavaScript.
Cada componente QML se instancia en un « QQmlContext ». En QML, los contextos se organizan jerárquicamente y esta jerarquía la gestiona el QQmlEngine. Por defecto, los componentes se instancian en el « root context ».
Véase también « QQmlComponent» , « QQmlContext », «QML Global Object» y « QQmlApplicationEngine ».
Documentación de propiedades
offlineStoragePath : QString
Esta propiedad contiene el directorio en el que se almacenan los datos de los usuarios sin conexión
Devuelve el directorio en el que se ubican las bases de datos SQL y otros almacenes sin conexión.
Las bases de datos SQL creadas con openDatabaseSync() se almacenan aquí.
El valor por defecto es QML/OfflineStorage, en el directorio estándar de datos de aplicaciones de usuario de la plataforma.
Ten en cuenta que es posible que la ruta no exista actualmente en el sistema de archivos, por lo que quienes deseen crear nuevos archivos en esta ubicación deben crearla primero; consulta QDir::mkpath().
Funciones de acceso:
| QString | offlineStoragePath() const |
| void | setOfflineStoragePath(const QString &dir) |
Señal de notificador:
| void | offlineStoragePathChanged() |
Véase también Qt Quick Local Storage QML Types.
Documentación de las funciones de miembro
[explicit] QQmlEngine::QQmlEngine(QObject *parent = nullptr)
Crea un nuevo QQmlEngine con el parent indicado.
[override virtual noexcept] QQmlEngine::~QQmlEngine()
Elimina el QQmlEngine.
Cualquier objeto ` QQmlContext` creado en este motor quedará invalidado, pero no se destruirá (a menos que esté vinculado al objeto ` QQmlEngine `).
Consulta ~QJSEngine() para obtener más detalles sobre cómo limpiar el motor JS.
void QQmlEngine::addImageProvider(const QString &providerId, QQmlImageProviderBase *provider)
Establece el proveedor de imágenes ( provider ) que se utilizará para las imágenes solicitadas a través del esquema de URL «image:», con el host providerId. El proveedor de imágenes QQmlEngine asume la responsabilidad de provider.
Los proveedores de imágenes permiten la compatibilidad con solicitudes de imágenes tipo pixmap y en subprocesos. Consulta la documentación de QQuickImageProvider para obtener más detalles sobre la implementación y el uso de proveedores de imágenes.
Todos los proveedores de imágenes necesarios deben añadirse al motor antes de que se carguen los archivos fuente QML.
Véase también removeImageProvider(), QQuickImageProvider y QQmlImageProviderBase.
void QQmlEngine::addImportPath(const QString &path)
Añade path como un directorio en el que el motor busca los módulos instalados en una estructura de directorios basada en URL. Qt da por hecho que todos los archivos y carpetas que se encuentran en path proceden de una fuente de confianza.
path puede ser un directorio del sistema de archivos local, una ruta de recursos de Qt (:/imports), una URL de recursos de Qt (qrc:/imports) o una URL.
La « path » se convertirá a su forma canónica antes de añadirse a la lista de rutas de importación.
El path recién añadido será el primero en la lista de rutas de importación ( importPathList()).
Véase también setImportPathList(), Módulos QML y Ruta de importación de QML
void QQmlEngine::addPluginPath(const QString &path)
Añade path como directorio en el que el motor busca complementos nativos para los módulos importados (a los que se hace referencia en el archivo qmldir ). Qt da por hecho que todos los archivos y carpetas que se encuentran en path proceden de una fuente de confianza.
Por defecto, la lista solo contiene ., es decir, el motor busca en el propio directorio del archivo qmldir.
El archivo path recién añadido aparecerá en primer lugar en pluginPathList().
Véase también setPluginPathList().
void QQmlEngine::addUrlInterceptor(QQmlAbstractUrlInterceptor *urlInterceptor)
Añade un interceptor de URL ( urlInterceptor ) que se utiliza al resolver direcciones URL en QML. Esto también se aplica a las URL utilizadas para cargar archivos de script y tipos QML. Los interceptores de URL no deben modificarse mientras el motor está cargando archivos, ya que la selección de URL podría resultar inconsistente. Si se especifican varios interceptores de URL, se llamarán en el orden en que se hayan añadido para cada URL.
QQmlEngine No asume la propiedad del interceptor y no lo eliminará.
QUrl QQmlEngine::baseUrl() const
Devuelve la URL base de este motor. La URL base solo se utiliza para resolver componentes cuando se pasa una URL relativa al constructor de ` QQmlComponent `.
Si no se ha establecido explícitamente una URL base, este método devuelve el directorio de trabajo actual de la aplicación.
Véase también setBaseUrl().
void QQmlEngine::clearComponentCache()
Borra la caché de componentes internos del motor.
Esta función provoca que se eliminen los metadatos de las propiedades de la mayoría de los componentes cargados previamente por el motor. Para ello, elimina del caché de componentes del motor aquellos a los que ya no se hace referencia. No elimina los componentes a los que aún se hace referencia, ya que eso provocaría casi con toda seguridad fallos más adelante.
Si no hay componentes a los que se haga referencia, esta función devuelve el motor a un estado en el que no contiene ningún dato de componentes cargados. Esto puede resultar útil para volver a cargar un subconjunto más reducido del conjunto de componentes anterior, o para cargar una nueva versión de un componente cargado previamente.
Una vez vaciada la caché de componentes, es necesario cargar los componentes antes de poder crear cualquier objeto nuevo.
Nota: Cualquier objeto existente creado a partir de componentes QML conserva su tipo, incluso si se vacía la caché de componentes. Esto incluye los objetos singleton. Si se crean más objetos a partir del mismo código QML tras vaciar la caché, los nuevos objetos serán de tipos diferentes a los antiguos. Asignar uno de estos nuevos objetos a una propiedad de su tipo declarado que pertenezca a un objeto creado antes de vaciar la caché no funcionará.
Como regla general, asegúrate de que no haya ningún objeto creado a partir de componentes QML activo cuando vacíes la caché de componentes.
Véase también trimComponentCache() y clearSingletons().
void QQmlEngine::clearSingletons()
Elimina todas las instancias singleton que posee el motor.
Esta función elimina todas las instancias de singleton, borrando entre ellas cualquier QObject del que sea propietario el motor. Esto resulta útil para asegurarse de que no quede ningún objeto creado por QML antes de llamar a ` clearComponentCache()`.
Las propiedades QML que contienen instancias de singleton basadas en ` QObject` pasan a ser nulas si el motor es propietario del singleton, o conservan su valor si el motor no lo es. Los singletons no se recrean automáticamente al acceder a objetos existentes creados por QML. Solo cuando se instancian nuevos componentes, se recrean los singletons.
Véase también ` clearComponentCache()`.
[static] QQmlContext *QQmlEngine::contextForObject(const QObject *object)
Devuelve el ` QQmlContext ` correspondiente al ` object`, o `nullptr` si no se ha establecido ningún contexto.
Cuando el ` QQmlEngine ` instancia un ` QObject`, se le asigna automáticamente un contexto interno. Dichos contextos internos son de solo lectura. No es posible establecer propiedades de contexto en ellos.
Véase también setContextForObject(), qmlContext(), qmlEngine() y QQmlContext::setContextProperty().
[override virtual protected] bool QQmlEngine::event(QEvent *e)
Reimplementa: QObject::event(QEvent *e).
[signal] void QQmlEngine::exit(int retCode)
Esta señal se emite cuando el QML cargado por el motor desea salir del bucle de eventos con el código de retorno especificado retCode.
Véase también quit().
QQmlImageProviderBase *QQmlEngine::imageProvider(const QString &providerId) const
Devuelve el proveedor de imágenes configurado para providerId si lo encuentra; en caso contrario, devuelve nullptr.
Véase también QQuickImageProvider.
QStringList QQmlEngine::importPathList() const
Devuelve la lista de directorios en los que el motor busca los módulos instalados en una estructura de directorios basada en URL.
Por ejemplo, si /opt/MyApp/lib/imports se encuentra en la ruta, entonces el QML que importe com.mycompany.Feature hará que el QQmlEngine busque en /opt/MyApp/lib/imports/com/mycompany/Feature/ los componentes proporcionados por ese módulo. Se requiere un archivo qmldir para definir la correspondencia de versiones de tipos y, posiblemente, los complementos de extensiones de QML.
Por defecto, esta lista contiene las rutas mencionadas en «Ruta de importación de QML».
Véase también addImportPath() y setImportPathList().
QQmlIncubationController *QQmlEngine::incubationController() const
Devuelve el controlador de incubación establecido actualmente, o 0 si no se ha establecido ningún controlador.
Véase también setIncubationController().
QUrl QQmlEngine::interceptUrl(const QUrl &url, QQmlAbstractUrlInterceptor::DataType type) const
Ejecuta los interceptores de URL actuales en la dirección url del dominio type y devuelve el resultado.
[since 6.6] void QQmlEngine::markCurrentFunctionAsTranslationBinding()
Si este método se invoca desde el interior de una función que forma parte de un enlace en QML, dicho enlace se tratará como un enlace de traducción.
class I18nAwareClass : public QObject {
//...
QString text() const
{
if (auto engine = qmlEngine(this))
engine->markCurrentFunctionAsTranslationBinding();
return tr("Hello, world!");
}
};Nota: Esta función resulta especialmente útil si deseas proporcionar tu propia alternativa a la función `qsTr`. Para garantizar que las propiedades expuestas desde clases de C++ se actualicen ante cambios de lenguaje, se recomienda, en su lugar, reaccionar ante los eventos ` LanguageChange `. Se trata de un mecanismo más general que también funciona cuando la clase se utiliza en un contexto ajeno a QML y que supone una sobrecarga ligeramente menor. No obstante, el uso de « markCurrentFunctionAsTranslationBinding » puede ser aceptable cuando la clase ya está estrechamente vinculada al motor QML. Para más detalles, véase «Prepararse para cambios dinámicos de lenguaje».
Esta función se introdujo en Qt 6.6.
Véase también « QQmlEngine::retranslate ».
QNetworkAccessManager *QQmlEngine::networkAccessManager() const
Devuelve un « QNetworkAccessManager » común que puede ser utilizado por cualquier tipo QML instanciado por este motor.
Si se ha establecido un ` QQmlNetworkAccessManagerFactory ` y aún no se ha creado un ` QNetworkAccessManager `, se utilizará el ` QQmlNetworkAccessManagerFactory ` para crear el ` QNetworkAccessManager`; de lo contrario, el ` QNetworkAccessManager ` devuelto no tendrá ningún proxy ni caché establecidos.
Véase también setNetworkAccessManagerFactory().
QQmlNetworkAccessManagerFactory *QQmlEngine::networkAccessManagerFactory() const
Devuelve el ` QQmlNetworkAccessManagerFactory` actual.
Véase también setNetworkAccessManagerFactory().
QString QQmlEngine::offlineStorageDatabaseFilePath(const QString &databaseName) const
Devuelve la ruta del archivo donde se encuentra (o se encontraría) una base de datos de Local Storage con el identificador databaseName.
Véase también LocalStorage.openDatabaseSync().
[signal, since 6.5] void QQmlEngine::offlineStoragePathChanged()
Esta señal se emite cuando cambia offlineStoragePath.
Nota: Señalde notificación para la propiedad offlineStoragePath.
Esta función se introdujo en Qt 6.5.
bool QQmlEngine::outputWarningsToStandardError() const
Devuelve «true» si los mensajes de advertencia se enviarán a stderr además de emitirse mediante la señal warnings(), y «false» en caso contrario.
El valor por defecto es «true».
Véase también setOutputWarningsToStandardError().
QStringList QQmlEngine::pluginPathList() const
Devuelve la lista de directorios en los que el motor busca complementos nativos para los módulos importados (a los que se hace referencia en el archivo qmldir ).
Por defecto, la lista contiene únicamente ., es decir, el motor busca en el propio directorio del archivo qmldir.
Véanse también addPluginPath() y setPluginPathList().
[signal] void QQmlEngine::quit()
Esta señal se emite cuando el QML cargado por el motor desea cerrarse.
Véase también exit().
void QQmlEngine::removeImageProvider(const QString &providerId)
Elimina el proveedor de imágenes de providerId.
Véase también addImageProvider() y QQuickImageProvider.
void QQmlEngine::removeUrlInterceptor(QQmlAbstractUrlInterceptor *urlInterceptor)
Elimina un interceptor de URL ( urlInterceptor ) que se haya añadido previamente mediante addUrlInterceptor. Los interceptores de URL no deben modificarse mientras el motor está cargando archivos, ya que la selección de URL podría resultar inconsistente.
Esto no elimina el interceptor, sino que simplemente lo retira del motor. Posteriormente, podrás volver a utilizarlo en el mismo motor o en uno diferente.
[slot] void QQmlEngine::retranslate()
Actualiza todas las expresiones de enlace que utilizan cadenas marcadas para su traducción.
Llama a esta función después de haber instalado un nuevo traductor con ` QCoreApplication::installTranslator`, para asegurarte de que tu interfaz de usuario muestre traducciones actualizadas.
QQmlContext *QQmlEngine::rootContext() const
Devuelve el contexto raíz del motor.
El contexto raíz lo crea automáticamente el ` QQmlEngine`. Los datos que deben estar disponibles para todas las instancias de componentes QML instanciadas por el motor deben colocarse en el contexto raíz.
Los datos adicionales que solo deben estar disponibles para un subconjunto de instancias de componentes deben añadirse a subcontextos subordinados al contexto raíz.
void QQmlEngine::setBaseUrl(const QUrl &url)
Establece la URL base de este motor en url.
Véase también baseUrl().
[static] void QQmlEngine::setContextForObject(QObject *object, QQmlContext *context)
Establece el « QQmlContext » del « object » en « context ». Si el « object » ya tiene un contexto, se muestra una advertencia, pero el contexto no se modifica.
Cuando la clase ` QQmlEngine ` crea una instancia de ` QObject`, el contexto se establece automáticamente.
Véase también contextForObject().
[since 6.12] bool QQmlEngine::setExternalSingletonInstance(QAnyStringView moduleName, QAnyStringView typeName, QObject *instance)
Establece la instancia singleton que se utilizará para el tipo indicado en el motor QML.
Esta función te permite establecer manualmente una instancia derivada de ` QObject` para utilizarla como singleton en QML para este motor. Esto te permite controlar la creación de la instancia. Puede resultar útil en varios casos, entre ellos aquellos en los que tu singleton necesite comunicarse con componentes del backend.
Esta función toma los parámetros ` moduleName ` y ` typeName ` para indicar el tipo de singleton que se desea configurar, y el parámetro ` instance ` para establecerlo. El tipo debe estar ya registrado como tipo de singleton de QML, idealmente mediante ` QML_ELEMENT ` y `QML_SINGLETON`. Si el módulo aún no se ha cargado, se cargará en este momento.
La función devuelve «true» en caso de éxito o «false» en caso de fallo. Si se produce un fallo, se emite una advertencia detallando el mismo.
A modo de ejemplo, es posible que el singleton necesite un servicio de fondo para funcionar, en cuyo caso podría declararse de la siguiente manera:
class CppSingleton: public QObject {
Q_OBJECT
QML_ELEMENT
QML_SINGLETON
QML_UNCREATABLE("Provided via QQmlEngine::setExternalSingletonInstance")
// Q_PROPERTY(...)
public:
explicit CppSingleton(BackendService *service); // constructor taking a reference to something MySingleton needs
// members, Q_INVOKABLE functions, etc.
};Tras la inicialización de la aplicación, se puede hacer lo siguiente:
// create and setup the backend service
BackendService service;
// create your singleton instance
CppSingleton singleton(&service);
QQmlApplicationEngine engine;
engine.setExternalSingletonInstance("com.company.myApp", "MySingleton", &singleton);
engine.loadFromModule("com.company.myApp", "Main");Obsérvese que, en lugar de proporcionar un constructor por defecto o una función de creación estática, se ha utilizado la macro QML_UNCREATABLE() para indicar que este elemento no puede ser creado por el motor QML.
Las instancias de singleton solo se pueden establecer una vez por tipo y motor, y deben establecerse antes de cualquier uso. Una vez creada o establecida una instancia de singleton, ya no es posible establecerla mediante esta función, por lo que debes establecer las instancias antes de que se utilicen por primera vez desde QML.
El motor no asumirá la propiedad de la instancia que se le pase, a menos que se le indique explícitamente que lo haga mediante QJSEngine::setObjectOwnership().
Advertencia: Asegúrate de que ` instance ` tenga una vida útil superior a la del motor.
Esta función se introdujo en Qt 6.12.
void QQmlEngine::setImportPathList(const QStringList &paths)
Establece « paths » como la lista de directorios en los que el motor busca los módulos instalados en una estructura de directorios basada en URL. Qt da por hecho que todos los archivos y carpetas que se encuentran en « paths » proceden de una fuente de confianza.
Por defecto, esta lista contiene las rutas mencionadas en «QML Import Path».
Advertencia: Al llamar a setImportPathList no se conservan las rutas de importación predeterminadas.
Véase también « importPathList()» y « addImportPath()».
void QQmlEngine::setIncubationController(QQmlIncubationController *controller)
Establece el controlador de incubación del motor controller. El motor solo puede tener un controlador activo y no asume la propiedad del mismo.
Véase también incubationController().
void QQmlEngine::setNetworkAccessManagerFactory(QQmlNetworkAccessManagerFactory *factory)
Establece el objeto ` factory ` que se utilizará para crear uno o varios objetos ` QNetworkAccessManager`.
QNetworkAccessManager Se utiliza para todo el acceso a la red por parte de QML. Al implementar una fábrica, es posible crear un « QNetworkAccessManager » personalizado con funciones especializadas de almacenamiento en caché, proxy y gestión de cookies.
La fábrica debe configurarse antes de ejecutar el motor.
Nota: ` QQmlEngine ` no asume la propiedad de la fábrica.
Véase también ` networkAccessManagerFactory()`.
void QQmlEngine::setOutputWarningsToStandardError(bool enabled)
Establece si los mensajes de advertencia se enviarán a stderr en « enabled ».
Si enabled es true, cualquier mensaje de advertencia generado por QML se enviará a stderr y se emitirá mediante la señal warnings(). Si enabled es false, solo se emitirá la señal warnings(). Esto permite a las aplicaciones gestionar por sí mismas la salida de las advertencias.
El valor por defecto es «true».
Véase también ` outputWarningsToStandardError()`.
void QQmlEngine::setPluginPathList(const QStringList &paths)
Establece la lista de directorios en los que el motor busca complementos nativos para los módulos importados (a los que se hace referencia en el archivo qmldir ) en paths. Qt da por hecho que todos los archivos y carpetas que se encuentran en paths proceden de una fuente de confianza.
Por defecto, la lista contiene únicamente ., es decir, el motor busca en el propio directorio del archivo qmldir.
Véanse también pluginPathList() y addPluginPath().
template <typename T> T QQmlEngine::singletonInstance(int qmlTypeId)
Devuelve la instancia de un tipo singleton que se ha registrado en qmlTypeId.
El argumento de plantilla T puede ser « QJSValue » o un puntero a un tipo derivado de « QObject », y depende de cómo se haya registrado el singleton. Si aún no se ha creado ninguna instancia de T, se crea en ese momento. Si « qmlTypeId » no representa un tipo de singleton válido, se devuelve un « QJSValue » construido por defecto o un « nullptr ».
QObject* Ejemplo:
class MySingleton : public QObject {
Q_OBJECT
// Register as default constructed singleton.
QML_ELEMENT
QML_SINGLETON
static int typeId;
// ...
};
MySingleton::typeId = qmlTypeId(...);
// Retrieve as QObject*
QQmlEngine engine;
MySingleton* instance = engine.singletonInstance<MySingleton*>(MySingleton::typeId);QJSValue ejemplo:
// Register with QJSValue callback
int typeId = qmlRegisterSingletonType(...);
// Retrieve as QJSValue
QQmlEngine engine;
QJSValue instance = engine.singletonInstance<QJSValue>(typeId);Se recomienda almacenar el identificador de tipo QML, por ejemplo, como miembro estático en la clase singleton. La búsqueda mediante qmlTypeId() es costosa.
Véase también QML_SINGLETON, qmlRegisterSingletonType() y qmlTypeId().
[since 6.5] template <typename T> T QQmlEngine::singletonInstance(QAnyStringView uri, QAnyStringView typeName)
Devuelve la instancia de un tipo singleton denominado « typeName » del módulo especificado por « uri ».
Este método puede utilizarse como alternativa a llamar a ` qmlTypeId ` seguido de la sobrecarga basada en el identificador de `singletonInstance`. Resulta conveniente cuando solo es necesario configurar un singleton una vez; si se requiere un acceso repetido al singleton, almacenar en caché su `typeId` permitirá un acceso posterior más rápido a través de ` type-id based overload`.
El argumento de plantilla T puede ser « QJSValue » o un puntero a un tipo derivado de « QObject », y depende de cómo se haya registrado el singleton. Si aún no se ha creado ninguna instancia de T, se crea en ese momento. Si « typeName » no representa un tipo de singleton válido, se devuelve un « QJSValue » construido por defecto o un « nullptr ».
QQmlEngine engine;
MySingleton *singleton = engine.singletonInstance<MySingleton *>("mymodule", "MySingleton");Esta es una función sobrecargada.
Esta función se introdujo en Qt 6.5.
Véase también QML_SINGLETON, qmlRegisterSingletonType() y qmlTypeId().
void QQmlEngine::trimComponentCache()
Limpia la caché de componentes internos del motor.
Esta función provoca que se destruyan los metadatos de propiedad de cualquier componente cargado que no esté actualmente en uso.
Se considera que un componente está en uso si existen instancias del propio componente, instancias de otros componentes que lo utilicen o cualquier objeto instanciado por cualquiera de esos componentes.
Véase también clearComponentCache().
QList<QQmlAbstractUrlInterceptor *> QQmlEngine::urlInterceptors() const
Devuelve la lista de interceptores de URL activos en este momento.
[signal] void QQmlEngine::warnings(const QList<QQmlError> &warnings)
Esta señal se emite cuando QML genera mensajes « warnings ».
Relacionado: No miembros
QQmlContext *qmlContext(const QObject *object)
Devuelve el objeto ` QQmlContext ` asociado a ` object`, si existe. Esto equivale a ` QQmlEngine::contextForObject(object)`.
Nota: Añade #include <QtQml> para utilizar esta función.
Véase también contextForObject() y qmlEngine().
QQmlEngine *qmlEngine(const QObject *object)
Devuelve el objeto « QQmlEngine » asociado a « object », si existe. Esto equivale a « QQmlEngine::contextForObject(object)->engine()», pero es más eficiente.
Nota: Añade ` #include <QtQml> ` para utilizar esta función.
Véase también contextForObject() y qmlContext().
Documentación de macros
QML_NAMESPACE_EXTENDED(EXTENSION_NAMESPACE)
Se comporta igual que QML_EXTENDED_NAMESPACE, con la diferencia de que lo que se amplía es un espacio de nombres y no un tipo.
Declara que el espacio de nombres envolvente utiliza EXTENSION_NAMESPACE como extensión para proporcionar nuevas enumeraciones en QML. Esto surte efecto si el espacio de nombres ampliado 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, en el siguiente código C++,
namespace NS2 {
Q_NAMESPACE
enum class E2 { D = 3, E, F };
Q_ENUM_NS(E2)
}
namespace NS1 {
Q_NAMESPACE
QML_ELEMENT
enum class E1 { A, B, C };
Q_ENUM_NS(E1)
// Extends NS1 with NS2
QML_NAMESPACE_EXTENDED(NS2)
}el espacio de nombres NS1 se amplía con NS2 y la enumeración E2 pasa a estar disponible en NS1 desde QML.
Item {
Component.onCompleted: console.log(NS1.E1.A, NS1.E2.D)
}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 un « QObject » o «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_EXTENDED_NAMESPACE(), QML_ELEMENT, QML_NAMED_ELEMENT(), QML_EXTENDED(), «Registro de objetos de extensión», Q_ENUM y Q_ENUM_NS.
© 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.