En esta página

Notas sobre la plataforma: iOS

Implementación

El desarrollo, la compilación, la ejecución y la depuración de una aplicación Qt para iOS se pueden realizar con Qt Creator en macOS. La cadena de herramientas la proporciona Xcode de Apple, y al ejecutar qmake o CMake en un proyecto destinado a iOS también se generará un archivo de proyecto de Xcode (.xcodeproj), con la configuración inicial de la aplicación. Dado que Qt Creator no ofrece una interfaz para gestionar todos los ajustes específicos de la plataforma iOS, a veces es necesario modificarlos directamente en Xcode. Es especialmente importante comprobar que la aplicación esté configurada correctamente antes de enviarla para su publicación en la App Store de Apple.

Paquetes de aplicaciones

Las aplicaciones para iOS suelen implementarse como paquetes de aplicación autónomos. El paquete de aplicación contiene el ejecutable de la aplicación, así como las dependencias, tales como las bibliotecas Qt, los complementos, las traducciones y otros recursos que la aplicación pueda necesitar.

Para compilar tu aplicación como un paquete de aplicación con CMake, configura la MACOSX_BUNDLE propiedad en tu objetivo ejecutable, de la siguiente manera:

qt_add_executable(MyApp)
if(APPLE)
    set_target_properties(MyApp PROPERTIES MACOSX_BUNDLE TRUE)
endif()

Con qmake, los paquetes son la opción predeterminada. Establece « CONFIG -= app_bundle » en tu archivo de proyecto (.pro) para desactivarlo.

Archivos de lista de propiedades de información

El archivo de lista de propiedades de información (Info.plist) en iOS y macOS se utiliza para configurar el paquete de una aplicación. Estos ajustes de configuración incluyen:

  • Nombre visible e identificador de la aplicación
  • Capacidades requeridas del dispositivo
  • Orientaciones de la interfaz de usuario compatibles
  • Iconos e imágenes de inicio

Consulta la documentación sobre el archivo de lista de propiedades de información en la Biblioteca para desarrolladores de iOS para obtener más detalles.

Info.plist con CMake

CMake genera un archivo « Info.plist » predeterminado si un objetivo tiene la propiedad « MACOSX_BUNDLE » establecida en « TRUE ». Lamentablemente, ese archivo no es adecuado para proyectos de iOS.

En su lugar, los proyectos pueden utilizar `qt_add_executable`, que generará automáticamente un archivo ` Info.plist ` con valores predeterminados adecuados para proyectos de iOS.

Para especificar un archivo « Info.plist » personalizado, los proyectos pueden establecer la propiedad « MACOSX_BUNDLE_INFO_PLIST » del objetivo tal y como se muestra a continuación. Al hacerlo, se desactivará la generación automática de archivos que ofrece «qt_add_executable» y, en su lugar, se utilizará el manejo nativo de CMake para el archivo « Info.plist » proporcionado por el proyecto.

qt_add_executable(app)
if(IOS)
    set_target_properties(app
        PROPERTIES MACOSX_BUNDLE_INFO_PLIST "${CMAKE_CURRENT_SOURCE_DIR}/ios/Info.plist")
endif()

Consulte la documentación de CMake sobre MACOSX_BUNDLE_INFO_PLIST para obtener información sobre qué propiedades de destino y variables se pueden especificar para la sustitución de plantillas realizada por CMake.

Info.plist con QMake

Al ejecutar qmake, se genera un archivo « Info.plist » con los valores predeterminados adecuados.

Es recomendable sustituir el archivo Info.plist generado por tu propia copia, para evitar que se sobrescriba la próxima vez que se ejecute qmake. Puedes definir una lista de propiedades de información personalizada mediante la variable QMAKE_INFO_PLIST en tu archivo .pro.

ios {
    QMAKE_INFO_PLIST = ios/Info.plist
}

Recursos de la aplicación

Para los archivos que no se pueden incluir en los recursos de Qt, la variable de qmake QMAKE_BUNDLE_DATA permite especificar un conjunto de archivos que se copiarán en el paquete de la aplicación. Por ejemplo:

ios {
    fontFiles.files = $$files(fonts/*.ttf)
    fontFiles.path = fonts
    QMAKE_BUNDLE_DATA += fontFiles
}

Con CMake, esto se puede hacer de la siguiente manera:

qt_add_executable(app)
file(GLOB_RECURSE font_files CONFIGURE_DEPENDS "fonts/*.ttf")
if(IOS AND font_files)
    target_sources(app PRIVATE ${font_files})
    set_source_files_properties(
        ${font_files}
        PROPERTIES MACOSX_PACKAGE_LOCATION Resources/fonts)
endif()

En el caso de los recursos de imagen, una alternativa es utilizar los catálogos de activos de Xcode, que se pueden añadir de la siguiente manera con qmake:

ios {
    QMAKE_ASSET_CATALOGS += ios/Assets.xcassets
}

Con CMake:

qt_add_executable(app)
set(asset_catalog_path "ios/Assets.xcassets")
target_sources(app PRIVATE "${asset_catalog_path}")
set_source_files_properties(
    ${asset_catalog_path}
    PROPERTIES MACOSX_PACKAGE_LOCATION Resources)

Iconos

A partir de Xcode 13, los iconos deben añadirse al conjunto de iconos de un catálogo de recursos, que suele denominarse « AppIcon ». A continuación, Xcode se encargará de actualizar el archivo « Info.plist » con las claves y los valores correctos, así como de copiar los archivos de iconos necesarios directamente en el paquete de la aplicación.

A partir de Xcode 14, solo se requiere una imagen de 1024 x 1024 píxeles. Xcode se encarga de generar todos los iconos necesarios a partir de ella. También es posible especificar las imágenes manualmente en el catálogo de recursos.

En «Archivos de iconos» se puede consultar una lista detallada de los iconos que se pueden especificar.

El nombre del archivo no es importante, pero sí lo es el tamaño real en píxeles. Para que una aplicación de iOS sea universal, se requieren las siguientes imágenes:

  • AppIcon60x60@2x.png: 120 x 120 (para iPhone)
  • AppIcon76x76@2x~ipad.png: 152 x 152 (para iPad)
  • AppIcon167x167.png: 167 x 167 (para iPad Pro)
  • AppIcon1024x1024.png: 1024 x 1024 (para la App Store)

Las distribuciones ad hoc también deben incluir los siguientes nombres de archivo en el paquete de la aplicación para poder visualizarla en iTunes:

  • iTunesArtwork 512 x 512
  • iTunesArtwork@2x 1024 x 1024

La forma más sencilla de añadir los iconos es seguir la documentación de Xcode en «Crear catálogos y conjuntos de recursos».

Al compilar un proyecto con CMake, también se debe especificar el siguiente atributo de Xcode para garantizar que Xcode genere los iconos de la aplicación.

set_target_properties(app_target_name PROPERTIES
    XCODE_ATTRIBUTE_ASSETCATALOG_COMPILER_APPICON_NAME AppIcon)

A continuación se muestra un ejemplo de cómo podría ser un archivo « Assets.xcassets/AppIcon.appiconset/Contents.json » para Xcode 14:

{
  "images" : [
    {
      "idiom" : "universal",
      "platform" : "ios",
      "scale" : "2x",
      "size" : "20x20"
    },
    {
      "idiom" : "universal",
      "platform" : "ios",
      "scale" : "3x",
      "size" : "20x20"
    },
    {
      "idiom" : "universal",
      "platform" : "ios",
      "scale" : "2x",
      "size" : "29x29"
    },
    {
      "idiom" : "universal",
      "platform" : "ios",
      "scale" : "3x",
      "size" : "29x29"
    },
    {
      "idiom" : "universal",
      "platform" : "ios",
      "scale" : "2x",
      "size" : "38x38"
    },
    {
      "idiom" : "universal",
      "platform" : "ios",
      "scale" : "3x",
      "size" : "38x38"
    },
    {
      "idiom" : "universal",
      "platform" : "ios",
      "scale" : "2x",
      "size" : "40x40"
    },
    {
      "idiom" : "universal",
      "platform" : "ios",
      "scale" : "3x",
      "size" : "40x40"
    },
    {
      "idiom" : "universal",
      "platform" : "ios",
      "scale" : "2x",
      "size" : "60x60"
    },
    {
      "idiom" : "universal",
      "platform" : "ios",
      "scale" : "3x",
      "size" : "60x60"
    },
    {
      "idiom" : "universal",
      "platform" : "ios",
      "scale" : "2x",
      "size" : "64x64"
    },
    {
      "idiom" : "universal",
      "platform" : "ios",
      "scale" : "3x",
      "size" : "64x64"
    },
    {
      "idiom" : "universal",
      "platform" : "ios",
      "scale" : "2x",
      "size" : "68x68"
    },
    {
      "idiom" : "universal",
      "platform" : "ios",
      "scale" : "2x",
      "size" : "76x76"
    },
    {
      "idiom" : "universal",
      "platform" : "ios",
      "scale" : "2x",
      "size" : "83.5x83.5"
    },
    {
      "filename" : "AppIcon1024x1024.png",
      "idiom" : "universal",
      "platform" : "ios",
      "size" : "1024x1024"
    }
  ],
  "info" : {
    "author" : "xcode",
    "version" : 1
  }
}

Pantallas de inicio e imágenes de inicio

Pantallas de inicio

Todas las aplicaciones de iOS deben incluir una pantalla de inicio que se muestre mientras se inicia la aplicación. Una pantalla de inicio es un archivo « .xib » de Interface Builder, también denominado archivo de storyboard. Para obtener más información, consulta «Especificar la pantalla de inicio de tu aplicación».

La compatibilidad con las pantallas de inicio se introdujo en iOS 9.0.

Tanto qmake como CMake generan una pantalla de inicio predeterminada llamada « LaunchScreen.storyboard ».

Para especificar una pantalla de inicio personalizada, hay que copiarla en el paquete de la aplicación y establecer la clave « UILaunchStoryboardName » con el nombre de la pantalla de inicio en el archivo « Info.plist ».

Qt admite pantallas de inicio personalizadas con CMake desde Qt 6.4 y con qmake desde Qt 6.0.

Suponiendo que el archivo de inicio se llame Launch.storyboard, se puede añadir a Info.plist de la siguiente manera:

<key>UILaunchStoryboardName</key>
<string>Launch</string>

Para copiar la pantalla de inicio en el paquete de la aplicación con qmake, utiliza el siguiente fragmento de código en el archivo .pro de tu proyecto:

ios {
    QMAKE_IOS_LAUNCH_SCREEN = $$PWD/Launch.storyboard
}

Con CMake:

qt_add_executable(app)
if(IOS)
    set_target_properties(app PROPERTIES
        QT_IOS_LAUNCH_SCREEN "${CMAKE_CURRENT_SOURCE_DIR}/Launch.storyboard")
endif()

Imágenes de inicio

También es posible especificar imágenes de inicio (archivos PNG) en lugar de la pantalla de inicio.

Nota: No se recomiendael uso de imágenes de inicio, ya que su compatibilidad ha quedado obsoleta desde iOS 13.0. Plantéate cambiar a pantallas de inicio en su lugar.

Las imágenes de inicio deben copiarse en el paquete de la aplicación y sus nombres deben configurarse en el archivo « Info.plist » utilizando la clave « UILaunchImages ».

Se deben preparar las siguientes imágenes:

  • LaunchImage-iOS7-568h@2x.pngo: 640 x 1136
  • LaunchImage-iOS7-Landscape.png: 1024 x 768
  • LaunchImage-iOS7-Landscape@2x.png: 2048 x 1536
  • LaunchImage-iOS7-Portrait.png: 768 x 1024
  • LaunchImage-iOS7-Portrait@2x.png: 1536 x 2048
  • LaunchImage-iOS7@2x.png: 640 x 960

Las imágenes se pueden añadir a Info.plist de la siguiente manera:

<key>UILaunchImages</key>
<array>
    <dict>
        <key>UILaunchImageMinimumOSVersion</key>
        <string>7.0</string>
        <key>UILaunchImageName</key>
        <string>LaunchImage-iOS7</string>
        <key>UILaunchImageOrientation</key>
        <string>Portrait</string>
        <key>UILaunchImageSize</key>
        <string>{320, 568}</string>
    </dict>
    <dict>
        <key>UILaunchImageMinimumOSVersion</key>
        <string>7.0</string>
        <key>UILaunchImageName</key>
        <string>LaunchImage-iOS7</string>
        <key>UILaunchImageOrientation</key>
        <string>Portrait</string>
        <key>UILaunchImageSize</key>
        <string>{320, 480}</string>
    </dict>
</array>
<key>UILaunchImages~ipad</key>
<array>
    <dict>
        <key>UILaunchImageMinimumOSVersion</key>
        <string>7.0</string>
        <key>UILaunchImageName</key>
        <string>LaunchImage-iOS7-Landscape</string>
        <key>UILaunchImageOrientation</key>
        <string>Landscape</string>
        <key>UILaunchImageSize</key>
        <string>{768, 1024}</string>
    </dict>
    <dict>
        <key>UILaunchImageMinimumOSVersion</key>
        <string>7.0</string>
        <key>UILaunchImageName</key>
        <string>LaunchImage-iOS7-Portrait</string>
        <key>UILaunchImageOrientation</key>
        <string>Portrait</string>
        <key>UILaunchImageSize</key>
        <string>{768, 1024}</string>
    </dict>
    <dict>
        <key>UILaunchImageMinimumOSVersion</key>
        <string>7.0</string>
        <key>UILaunchImageName</key>
        <string>LaunchImage-iOS7</string>
        <key>UILaunchImageOrientation</key>
        <string>Portrait</string>
        <key>UILaunchImageSize</key>
        <string>{320, 568}</string>
    </dict>
    <dict>
        <key>UILaunchImageMinimumOSVersion</key>
        <string>7.0</string>
        <key>UILaunchImageName</key>
        <string>LaunchImage-iOS7</string>
        <key>UILaunchImageOrientation</key>
        <string>Portrait</string>
        <key>UILaunchImageSize</key>
        <string>{320, 480}</string>
    </dict>
</array>

Para copiar las imágenes de inicio en el paquete de la aplicación con qmake, utiliza el siguiente fragmento de código en el archivo .pro de tu proyecto:

ios {
    app_launch_images.files = $$files($$PWD/ios/LaunchImage*.png)
    QMAKE_BUNDLE_DATA += app_launch_images
}

Con CMake:

qt_add_executable(app)
file(GLOB_RECURSE launch_images CONFIGURE_DEPENDS "ios/LaunchImage*.png")
if(IOS AND launch_images)
    target_sources(app PRIVATE ${launch_images})
    set_source_files_properties(
        ${launch_images}
        PROPERTIES MACOSX_PACKAGE_LOCATION Resources)
endif()

Nota: Las versionesanteriores de iOS permitían especificar una única imagen de inicio mediante la clave « UILaunchImageFile » en « Info.plist », pero esta función ha quedado obsoleta desde iOS 10.0.

Selector de imágenes nativo

Si tu archivo ` Info.plist ` contiene una entrada para ` NSPhotoLibraryUsageDescription`, qmake incluirá automáticamente un complemento adicional que permite acceder al selector de imágenes nativo.

En el caso de CMake, vincula manualmente el selector de imágenes nativo con qt_import_plugins:

qt_import_plugins(app INCLUDE Qt6::QIosOptionalPlugin_NSPhotoLibraryPlugin)

Si el directorio de tu archivo ` QFileDialog ` está configurado como:

QStandardPaths::standardLocations(QStandardPaths::PicturesLocation).last();

o, alternativamente, el archivo « currentFolder » en un « FileDialog » en QML a:

shortcuts.pictures

A continuación, se muestra el selector de imágenes nativo para permitir el acceso al álbum de fotos del usuario.

Cómo indicar las versiones de iOS compatibles

Las plataformas de Apple cuentan con un método integrado para indicar las versiones del sistema operativo que admite una aplicación, lo que permite que, en las versiones más antiguas de las plataformas, se muestre automáticamente un mensaje de error claro y sencillo en el que se invita al usuario a actualizar su sistema operativo, en lugar de que la aplicación se cuelgue y muestre un seguimiento de la pila.

Los conceptos principales que intervienen a la hora de indicar la compatibilidad con un rango concreto de versiones del sistema operativo son:

  • El «objetivo de implementación» especifica la versión mínima imprescindible de macOS o iOS que admite tu aplicación.
  • La versión del SDK especifica la versión máxima recomendada de macOS o iOS que admite tu aplicación.

Al desarrollar una aplicación para una plataforma de Apple, siempre debes utilizar la última versión de Xcode y el último SDK disponible en el momento del desarrollo. En algunas plataformas, como iOS, tu aplicación será rechazada en la App Store si no lo haces. Por lo tanto, la versión del SDK siempre es mayor o igual que el objetivo de implementación.

Al desarrollar una aplicación para una plataforma de Apple, debes establecer el objetivo de implementación. Diversas herramientas de compilación de la cadena de herramientas de Xcode disponen de un indicador que puedes utilizar para establecer este valor, entre las que se incluyen, entre otras, el compilador y el enlazador. Al establecer el valor del objetivo de implementación, estás declarando explícitamente que tu aplicación debe funcionar, como mínimo, en esa versión, y que no funcionará con ninguna versión anterior del sistema operativo. Depende entonces de ti asegurarte de que el uso que haces de las API del sistema se ajusta a lo que has declarado. Dado que el compilador sabe lo que has declarado, puede ayudarte a garantizar que así sea.

La versión del SDK se considera una versión máxima «flexible» del sistema operativo con la que una aplicación es compatible, en el sentido de que, si la aplicación se compila con un SDK, seguirá utilizando los comportamientos de ese SDK incluso en versiones más recientes del sistema operativo, ya que el sistema operativo comprueba los comandos de carga del binario y emula la compatibilidad con versiones anteriores del sistema operativo. Por ejemplo, si una aplicación se compila con el SDK de macOS 10.12, seguirá utilizando los comportamientos de la versión 10.12 incluso en 10.13 y versiones posteriores.

Sin embargo, los binarios Mach-O son intrínsecamente compatibles con versiones posteriores. Por ejemplo, una aplicación compilada con el SDK de iOS 9 funcionará perfectamente en iOS 10, pero es posible que no se beneficie de los cambios de comportamiento que se hayan introducido en determinadas funcionalidades de la nueva versión, hasta que dicha aplicación se recompile con ese SDK más reciente.

La versión mínima del sistema operativo puede indicarse al sistema mediante los parámetros del compilador y del enlazador que la incorporan al binario Mach-O. Además, la clave « LSMinimumSystemVersion » debe configurarse en el paquete de la aplicación. Este valor debe ser igual al valor pasado al compilador y al enlazador, ya que en macOS permitirá que el sistema operativo muestre un cuadro de diálogo de error intuitivo que indique que la aplicación requiere una versión más reciente del sistema operativo, en lugar de un cuadro de diálogo de fallo. La clave « LSMinimumSystemVersion » es también la que utiliza la App Store para mostrar la versión del sistema operativo requerida; las opciones del compilador y del enlazador no tienen ninguna influencia en este aspecto.

En la mayoría de los casos, las aplicaciones Qt funcionarán sin problemas. Por ejemplo, en qmake, las especificaciones mkspec de Qt establecen QMAKE_IOS_DEPLOYMENT_TARGET o QMAKE_MACOSX_DEPLOYMENT_TARGET en la versión mínima que el propio Qt admite. Del mismo modo, en Qbs, los módulos de Qt establecen cpp.minimumIosVersion, cpp.minimumMacosVersion, cpp.minimumTvosVersion o cpp.minimumWatchosVersion en la versión mínima que admite el propio Qt.

Sin embargo, hay que tener cuidado al establecer manualmente la propia versión de destino. Si se establece un valor superior al que requiere Qt y se proporciona un archivo « Info.plist » propio, hay que añadir una entrada « LSMinimumSystemVersion » al archivo « Info.plist » que coincida con el valor del destino de implementación, ya que el sistema operativo utilizará el valor de « LSMinimumSystemVersion » como el valor de referencia.

Si se especifica un valor de «deployment target» inferior al que requiere Qt, es casi seguro que la aplicación se bloqueará en algún punto de las bibliotecas de Qt al ejecutarse en una versión más antigua de la que admite Qt. Por lo tanto, asegúrate de que el código real del sistema de compilación refleje la versión mínima del sistema operativo que se requiere realmente.

Publicación en la App Store de Apple

La verificación de que su aplicación Qt para iOS está lista para su publicación en la App Store puede realizarse tal y como se describe en «Envío de la aplicación». Para enviar la aplicación, puede utilizar Xcode o el Application Loader (instalado con Xcode). Qt Creator no proporciona una interfaz para gestionar todos los ajustes de la configuración de un proyecto de Xcode.

La aplicación debe probarse en las versiones de iOS y los dispositivos para los que está diseñada. El objetivo de implementación mínimo para las aplicaciones Qt varía según la versión de Qt. Para obtener más información, consulta las configuraciones compatibles.

El proceso de publicación propiamente dicho implica crear un certificado de distribución y un perfil de provisión, crear un archivo firmado de la aplicación y ejecutar una serie de pruebas de validación en él.

Consulte la Guía de distribución de aplicaciones en la Biblioteca para desarrolladores de iOS para obtener más información.

Advertencias sobre la visibilidad de los símbolos

En el contexto de la vinculación de bibliotecas de C++, las funciones y los objetos se denominan «símbolos». Los símbolos pueden tener visibilidad « default » o « hidden ».

Por motivos de rendimiento, Qt y muchas otras bibliotecas compilan sus fuentes utilizando, por defecto, la visibilidad « hidden », y solo marcan los símbolos con visibilidad « default » cuando están destinados a ser utilizados en proyectos de los usuarios.

Lamentablemente, el enlazador de Apple puede generar advertencias cuando una biblioteca se compila con visibilidad « hidden » y una aplicación o biblioteca de un proyecto de usuario se compila con visibilidad « default ».

Si los desarrolladores del proyecto desean silenciar la advertencia, deben compilar el código de su proyecto también con visibilidad « hidden ».

En CMake, esto se puede hacer añadiendo el siguiente código a tu ` CMakeLists.txt`:

set(CMAKE_CXX_VISIBILITY_PRESET hidden)

En qmake, esto se puede hacer añadiendo el siguiente código a tu archivo ` .pro `:

CONFIG+=hide_symbols

En caso de que un proyecto compile bibliotecas, cualquier símbolo de la biblioteca que esté destinado a utilizarse en otra biblioteca o aplicación deberá marcarse explícitamente con visibilidad « default ». Por ejemplo, esto puede hacerse anotando dichas funciones o clases con « Q_DECL_EXPORT ».

Problema de archivado de productos con CMake

Debido a un problema en CMake, es posible que falle al intentar crear un archivo de producto con una aplicación de iOS.

Esto puede ocurrir tanto al intentar crear el archivo en Xcode mediante la opción de menú «Product» → «Archive», como desde la línea de comandos utilizando el comando « xcodebuild -archivePath ».

El mensaje de error puede hacer referencia a símbolos no definidos o a rutas de archivo inexistentes.

Para solucionar el problema, asegúrate de compilar una versión del proyecto con la opción « Release » antes de intentar crear un archivo.

Falta el paquete dSYM en el archivo xcarchive creado por un proyecto de Xcode con CMake

Debido a un error en Xcode y a ciertas limitaciones de CMake, un proyecto de Xcode generado por CMake no incluirá el paquete « dSYM » de la aplicación en el archivo « xcarchive » durante la tarea de archivado de Xcode.

Qt ofrece una solución alternativa opcional para que el paquete « dSYM » se incluya en el archivo « xcarchive », pero esto conlleva algunas desventajas. Es decir, las siguientes funciones de CMake no funcionarán correctamente:

  • cualquier expresión generadora de « $<TARGET_FILE:app> » podría expandirse a una ruta no válida que no conduzca al binario de la aplicación
  • la variable CMAKE_RUNTIME_OUTPUT_DIRECTORY y su propiedad de destino asociada RUNTIME_OUTPUT_DIRECTORY se ignorarán aunque estén configuradas
  • otros problemas desconocidos

Para mitigar los problemas anteriores, puedes:

  • activar la solución alternativa únicamente cuando se pretenda crear el « xcarchive » y no durante el desarrollo del proyecto
  • asegurarse de añadir solo archivos ejecutables y bibliotecas en el directorio raíz del proyecto, y no en las llamadas a « add_subdirectory ».

Para activar la solución alternativa, configura el proyecto con la siguiente opción:

cmake . -DQT_USE_RISKY_DSYM_ARCHIVING_WORKAROUND=ON

o establece la variable en el proyecto antes de cualquier llamada a qt_add_executable o qt_add_library:

set(QT_USE_RISKY_DSYM_ARCHIVING_WORKAROUND ON)

...

qt_add_executable(app)

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