En esta página

Menu QML Type

Menú emergente que puede utilizarse como menú contextual o menú emergente. Más...

Import Statement: import QtQuick.Controls
Inherits:

Popup

Propiedades

Métodos

  • Action actionAt(int index) (since QtQuick.Controls 2.3 (Qt 5.10))
  • void addAction(Action action) (since QtQuick.Controls 2.3 (Qt 5.10))
  • void addItem(Item item)
  • void addMenu(Menu menu) (since QtQuick.Controls 2.3 (Qt 5.10))
  • void dismiss() (since QtQuick.Controls 2.3 (Qt 5.10))
  • void insertAction(int index, Action action) (since QtQuick.Controls 2.3 (Qt 5.10))
  • void insertItem(int index, Item item)
  • void insertMenu(int index, Menu menu) (since QtQuick.Controls 2.3 (Qt 5.10))
  • Item itemAt(int index)
  • Menu menuAt(int index) (since QtQuick.Controls 2.3 (Qt 5.10))
  • void moveItem(int from, int to)
  • void popup(MenuItem item) (since QtQuick.Controls 2.3 (Qt 5.10))
  • void popup(Item parent, MenuItem item) (since QtQuick.Controls 2.3 (Qt 5.10))
  • void popup(point pos, MenuItem item) (since QtQuick.Controls 2.3 (Qt 5.10))
  • void popup(Item parent, point pos, MenuItem item) (since QtQuick.Controls 2.3 (Qt 5.10))
  • void popup(real x, real y, MenuItem item) (since QtQuick.Controls 2.3 (Qt 5.10))
  • void popup(Item parent, real x, real y, MenuItem item) (since QtQuick.Controls 2.3 (Qt 5.10))
  • void removeAction(Action action) (since QtQuick.Controls 2.3 (Qt 5.10))
  • void removeItem(Item item) (since QtQuick.Controls 2.3 (Qt 5.10))
  • void removeMenu(Menu menu) (since QtQuick.Controls 2.3 (Qt 5.10))
  • Action takeAction(int index) (since QtQuick.Controls 2.3 (Qt 5.10))
  • MenuItem takeItem(int index) (since QtQuick.Controls 2.3 (Qt 5.10))
  • Menu takeMenu(int index) (since QtQuick.Controls 2.3 (Qt 5.10))

Descripción detallada

Menú con las opciones «Nuevo», «Abrir» y «Guardar» en estilo nativo

Menú nativo de macOS.

Menú con las opciones «Nuevo», «Abrir» y «Guardar» en estilo Material

Menú de estilo Material no nativo.

El menú tiene dos usos principales:

  • Menús contextuales; por ejemplo, un menú que aparece al hacer clic con el botón derecho
  • Menús emergentes; por ejemplo, un menú que aparece al hacer clic en un botón

Para los menús contextuales, consulta Context Menus.

Cuando se utiliza como menú emergente, lo más sencillo es especificar la posición indicando las coordenadas deseadas de x y y mediante las propiedades correspondientes, y llamar a open() para abrir el menú.

Button {
    id: fileButton
    text: "File"
    onClicked: menu.open()

    Menu {
        id: menu
        y: fileButton.height

        MenuItem {
            text: "New..."
        }
        MenuItem {
            text: "Open..."
        }
        MenuItem {
            text: "Save"
        }
    }
}

Si se desea que el botón también cierre el menú al hacer clic en él, utilice el indicador Popup.CloseOnPressOutsideParent:

    onClicked: menu.visible = !menu.visible

    Menu {
        id: menu
        // ...
        closePolicy: Popup.CloseOnEscape | Popup.CloseOnPressOutsideParent

Puedes crear submenús y declarar objetos Action dentro de Menu:

Menu {
    Action { text: "Cut" }
    Action { text: "Copy" }
    Action { text: "Paste" }

    MenuSeparator { }

    Menu {
        title: "Find/Replace"
        Action { text: "Find Next" }
        Action { text: "Find Previous" }
        Action { text: "Replace" }
    }
}

Los submenús son cascading por defecto en plataformas de escritorio que disponen de cursor de ratón. Los menús no en cascada se muestran de uno en uno y centrados sobre el menú principal.

Normalmente, los elementos del menú se declaran de forma estática como hijos del menú, pero Menu también proporciona una API para añadir dinámicamente elementos mediante « add », « insert », « move » y « remove ». Se puede acceder a los elementos de un menú utilizando « itemAt()» o « contentChildren ».

Aunque MenuItems se utilizan con mayor frecuencia con «Menú», este puede contener cualquier tipo de elemento.

Menús contextuales

Para los menús contextuales, resulta más sencillo utilizar el tipo asociado « ContextMenu », que crea un menú al producirse un evento específico de la plataforma. Además, los controles de edición de texto como « TextField », « TextArea », « SpinBox » y « DoubleSpinBox » proporcionan sus propios menús contextuales de forma predeterminada.

Si no se utiliza ` ContextMenu`, la forma recomendada de abrir el menú es llamar a ` popup()`. A menos que se especifique explícitamente una posición, el menú se coloca en la posición del cursor del ratón en las plataformas de escritorio que dispongan de cursor, y en los demás casos se centra sobre su elemento padre:

    TapHandler {
        acceptedButtons: Qt.RightButton
        onPressedChanged: {
            if (pressed && Application.styleHints.contextMenuTrigger === Qt.ContextMenuTrigger.Press)
                contextMenu.popup()
        }
        onTapped: {
            if (Application.styleHints.contextMenuTrigger === Qt.ContextMenuTrigger.Release)
                contextMenu.popup()
        }
    }
    TapHandler {
        acceptedDevices: PointerDevice.TouchScreen
        onLongPressed: contextMenu.popup()
    }

    Menu {
        id: contextMenu

        MenuItem {
            text: qsTr("Do stuff")
        }
        MenuItem {
            text: qsTr("Do more stuff")
        }
    }

Ten en cuenta que, si estás implementando tu propio menú contextual para controles de edición de texto, solo necesitas mostrarlo en plataformas de escritorio, ya que iOS y Android cuentan con sus propios menús contextuales nativos:

    TextArea {
        text: qsTr("TextArea")

        // Disable the built-in context menu (since Qt 6.9).
        ContextMenu.menu: null

        TapHandler {
            acceptedButtons: Qt.RightButton
            onPressedChanged: {
                if (pressed === (Application.styleHints.contextMenuTrigger === Qt.ContextMenuTrigger.Press))
                    contextMenu.popup()
            }
        }
    }

    Menu {
        id: contextMenu

        MenuItem {
            text: qsTr("Cut")
            // ...
        }
        MenuItem {
            text: qsTr("Copy")
            // ...
        }
        MenuItem {
            text: qsTr("Paste")
            // ...
        }
    }

Márgenes

Al heredarse de `Popup`, `Menu` admite ` margins`. Por defecto, todos los estilos integrados especifican ` 0 ` para los márgenes de `Menu`, con el fin de garantizar que el menú se mantenga dentro de los límites de la ventana. Para permitir que un menú se salga de la ventana (por ejemplo, para animar su entrada en pantalla), establece la propiedad de márgenes en ` -1`.

Generación dinámica de elementos de menú

Puedes crear elementos de menú de forma dinámica mediante « Instantiator » o la creación dinámica de objetos.

Uso de Instantiator

Se pueden generar dinámicamente elementos de menú con ` Instantiator`. El siguiente código muestra cómo se puede implementar un submenú «Archivos recientes», en el que los elementos proceden de una lista de archivos almacenados en la configuración:

Menu {
    title: qsTr("File")

    Menu {
        id: recentFilesMenu
        title: qsTr("Recent Files")
        enabled: recentFilesInstantiator.count > 0

        Instantiator {
            id: recentFilesInstantiator
            model: settings.recentFiles
            delegate: MenuItem {
                text: settings.displayableFilePath(modelData)
                onTriggered: loadFile(modelData)
            }

            onObjectAdded: (index, object) => recentFilesMenu.insertItem(index, object)
            onObjectRemoved: (index, object) => recentFilesMenu.removeItem(object)
        }

        MenuSeparator {}

        MenuItem {
            text: qsTr("Clear Recent Files")
            onTriggered: settings.clearRecentFiles()
        }
    }
}

Uso de la creación dinámica de objetos

También se puede cargar dinámicamente un componente desde un archivo QML utilizando ` Qt.createComponent()` (). Una vez que el componente está listo, se puede llamar a su método ` createObject()` para crear una instancia de dicho componente.

Row {
    anchors.centerIn: parent

    Component {
        id: menuItemComponent

        MenuItem {}
    }

    Button {
        id: button
        text: "Menu"
        onClicked: menu.open()
        Menu {
            id: menu
        }
    }

    Button {
        text: "Add item"
        onClicked: {
            onClicked: {
                let menuItem = menuItemComponent.createObject(
                    menu.contentItem, { text: qsTr("New item") })
                menu.addItem(menuItem)
            }
        }
    }
}

Desde Qt 6.8, un menú ofrece tres implementaciones diferentes, dependiendo de la plataforma. Puedes elegir cuál debe ser la preferida configurando ` popupType`. Esto te permitirá controlar si un menú debe mostrarse como una ventana independiente, como un elemento dentro de la ventana principal o como un menú nativo. Puedes obtener más información sobre estas opciones en ` here`.

El valor predeterminado de ` popupType ` viene determinado por el estilo. El estilo «macOS», por ejemplo, lo establece en ` Popup.Native`, mientras que el estilo «Imagine» utiliza ` Popup.Window ` (que es el valor predeterminado cuando el estilo no especifica un tipo de ventana emergente). Si añades personalizaciones a un menú y quieres que se utilicen independientemente del estilo, debes establecer explícitamente el tipo de menú emergente como « Popup.Window » (o « Popup.Item »). Otra alternativa es establecer el valor de « Qt::AA_DontUseNativeMenuWindows » en « application attribute ». Esto desactivará los menús contextuales nativos para toda la aplicación, independientemente del estilo.

Que un menú pueda utilizar el tipo preferido depende de la plataforma. El tipo « Popup.Item » es compatible con todas las plataformas, pero el tipo « Popup.Window » normalmente solo es compatible con plataformas de escritorio. Además, si el menú se encuentra dentro de un « native menubar », el menú también será nativo. Y si el menú es un submenú dentro de otro menú, el menú padre (o raíz) determinará el tipo.

Limitaciones al utilizar menús nativos

Al establecer ` popupType ` en ` Popup.Native `, existen algunas limitaciones y diferencias en comparación con el uso de ` Popup.Item ` y ` Popup.Window`.

Diferencias en la API

Al utilizar menús nativos, solo se admite un subconjunto de la API de menús en todas las plataformas:

Además, mostrar una ventana emergente (utilizando, por ejemplo, open() o popup()) supondrá una llamada bloqueante en algunas plataformas. Esto significa que la llamada no se completará hasta que se vuelva a cerrar el menú, lo que puede afectar a la lógica de tu aplicación. Es especialmente importante tener esto en cuenta si tu aplicación está destinada a múltiples plataformas y, por lo tanto, a veces se ejecuta en plataformas que no admiten menús nativos. En ese caso, el «popupType» recurrirá a « Popup.Item », por ejemplo, y las llamadas a « open()» no serán bloqueantes.

Elementos como MenuItem seguirán reaccionando a los clics en el elemento correspondiente del menú nativo emitiendo señales, por ejemplo, pero serán sustituidos por su equivalente nativo.

Diferencias de representación

Los menús nativos se implementan utilizando las API de menús nativos disponibles en la plataforma. Por lo tanto, esos menús, y todo su contenido, serán renderizados por la plataforma, y no por QML. Esto significa que el delegate no se utilizará para el renderizado. Sin embargo, siempre se instanciará (aunque estará oculto), de modo que funciones como onCompleted() se ejecuten independientemente de la plataforma y popupType.

Plataformas compatibles

Actualmente, los menús nativos son compatibles con las siguientes plataformas:

  • Android
  • iOS
  • Linux (solo disponible como menú contextual independiente cuando se ejecuta con el tema de la plataforma GTK+)
  • macOS
  • Windows

Véase también Personalización del menú, MenuItem, Controles de menú, Controles emergentes, Creación dinámica de objetos QML desde JavaScript, Popup type, [QML] y popupType.

Documentación de propiedades

cascade : bool [since QtQuick.Controls 2.3 (Qt 5.10)]

Esta propiedad determina si el menú muestra sus submenús en cascada.

El valor por defecto depende de la plataforma. Los menús se muestran en cascada de forma predeterminada en las plataformas de escritorio que disponen de cursor de ratón. Los menús que no se muestran en cascada se visualizan de uno en uno y se centran sobre el menú principal.

Nota: Cambiar el valor de la propiedad no tiene ningún efecto mientras el menú esté abierto.

Nota: Esta propiedad solo es compatible cuando se utiliza un ` non-native Menu`.

Esta propiedad se introdujo en QtQuick.Controls 2.3 (Qt 5.10).

Véase también overlap.

contentData : list<QtObject> [default]

Esta propiedad contiene la lista de datos de contenido.

La lista contiene todos los objetos que se han declarado en QML como hijos del menú, así como los elementos que se han añadido o insertado dinámicamente mediante los métodos addItem() y insertItem(), respectivamente.

Nota: A diferencia de contentChildren, contentData sí incluye objetos QML no visuales. No se reordena cuando se insertan o mueven elementos.

Véase también Item::data y contentChildren.

contentModel : model [read-only]

Esta propiedad contiene el modelo que se utiliza para mostrar los elementos del menú.

El modelo de contenido se proporciona con fines de visualización. Se puede asignar como modelo a un elemento de contenido que presente los contenidos del menú.

Menu {
    id: menu
    contentItem: ListView {
        model: menu.contentModel
    }
}

El modelo permite declarar de forma estática los elementos del menú como hijos del mismo.

count : int [read-only, since QtQuick.Controls 2.3 (Qt 5.10)]

Esta propiedad contiene el número de elementos.

Esta propiedad se introdujo en QtQuick.Controls 2.3 (Qt 5.10).

currentIndex : int [since QtQuick.Controls 2.3 (Qt 5.10)]

Esta propiedad contiene el índice del elemento que está resaltado actualmente.

Los elementos del menú se pueden resaltar al pasar el ratón por encima o mediante la navegación con el teclado.

Nota: Esta propiedad solo es compatible cuando se utiliza un « non-native Menu ».

Esta propiedad se introdujo en QtQuick.Controls 2.3 (Qt 5.10).

Véase también MenuItem::highlighted.

delegate : Component [since QtQuick.Controls 2.3 (Qt 5.10)]

Esta propiedad contiene el componente que se utiliza para crear elementos con los que mostrar acciones.

Menu {
    Action { text: "Cut" }
    Action { text: "Copy" }
    Action { text: "Paste" }
}

Nota: los delegados solo serán visibles cuando se utilice un « non-native Menu ».

El menú no asume la propiedad del delegado.

Esta propiedad se introdujo en QtQuick.Controls 2.3 (Qt 5.10).

Véase también Action.

focus : bool

Esta propiedad indica si la ventana emergente desea recibir el foco.

Cuando la ventana emergente reciba efectivamente el foco, ` activeFocus ` será ` true`. Para obtener más información, consulta «Foco del teclado» en Qt Quick.

El valor predeterminado es true.

Nota: Esta propiedad solo es compatible cuando se utiliza un non-native Menu.

Véase también activeFocus.

icon group

icon.cache : bool [since QtQuick.Controls 6.5]

icon.color : color [since QtQuick.Controls 6.5]

icon.height : int [since QtQuick.Controls 6.5]

icon.name : string [since QtQuick.Controls 6.5]

icon.source : url [since QtQuick.Controls 6.5]

icon.width : int [since QtQuick.Controls 6.5]

NombreDescripción
nombreEsta propiedad contiene el nombre del icono que se va a utilizar.

El icono se cargará desde el tema de la plataforma. Si se encuentra el icono en el tema, siempre se utilizará, incluso si también se ha establecido « icon.source ». Si no se encuentra el icono, se utilizará en su lugar « icon.source ».

Para obtener más información sobre los iconos de los temas, consulta QIcon::fromTheme().

fuenteEsta propiedad contiene el nombre del icono que se va a utilizar.

El icono se cargará como una imagen normal.

Si se ha establecido la propiedad « icon.name » y hace referencia a un icono de tema válido, siempre se utilizará ese en lugar de esta propiedad.

anchuraEsta propiedad indica el ancho del icono.

El ancho del icono nunca superará este valor, aunque se reducirá cuando sea necesario.

alturaEsta propiedad indica la altura del icono.

La altura del icono nunca superará este valor, aunque se reducirá cuando sea necesario.

colorEsta propiedad indica el color del icono.

El icono se tiñe con el color especificado, a menos que el color se establezca en « "transparent" ».

cachéEsta propiedad especifica si el icono debe almacenarse en caché.

El valor por defecto es «true».

Para obtener más información, consulta cache.

Esta propiedad se introdujo en QtQuick.Controls 2.13.

Nota: Esta propiedad solo es compatible cuando se utiliza un non-native Menu.

Estas propiedades se introdujeron en QtQuick.Controls 6.5.

Véase también « AbstractButton::text », « AbstractButton::display » e «Iconos en los controles de Qt Quick ».

overlap : real [since QtQuick.Controls 2.3 (Qt 5.10)]

Esta propiedad indica la cantidad de píxeles en que el menú se superpone horizontalmente al menú principal.

La propiedad solo surte efecto cuando el menú se utiliza como un submenú en cascada.

El valor por defecto depende del estilo.

Nota: Cambiar el valor de la propiedad no tiene ningún efecto mientras el menú está abierto.

Nota: Esta propiedad solo es compatible cuando se utiliza un « non-native Menu ».

Esta propiedad se introdujo en QtQuick.Controls 2.3 (Qt 5.10).

Véase también cascade.

separatorsCollapsible : bool [since QtQuick.Controls 6.12 (Qt 6.12)]

Esta propiedad determina si se deben ocultar los separadores consecutivos.

Cuando esta propiedad tiene el valor « true », el menú ocultará automáticamente los separadores que aparecerían al principio o al final de los elementos visibles, así como los separadores consecutivos entre los que todos los elementos estén ocultos. Esto reproduce el comportamiento de « QMenu::separatorsCollapsible » en Qt Widgets.

El valor por defecto es true.

Esto resulta útil cuando los elementos del menú se muestran u ocultan dinámicamente, ya que evita que se muestren separadores huérfanos.

Nota: Los separadores que tengan un enlace definido por el usuario en la propiedad visible no se ven afectados por este mecanismo y permanecen sin cambios. Para los separadores sin un enlace visible, el menú gestiona tanto la propiedad visible como la height. Cualquier enlace existente en height se sobrescribirá.

Esta propiedad se introdujo en QtQuick.Controls 6.12 (Qt 6.12).

Véase también MenuSeparator.

title : string

Esta propiedad contiene el título del menú.

El título de un menú suele aparecer en el texto de una opción del menú cuando este es un submenú, y en el texto de un botón de herramienta cuando se encuentra en una barra de menús.

Documentación del método

[since QtQuick.Controls 2.3 (Qt 5.10)] Action actionAt(int index)

Devuelve la acción correspondiente al índice index, o null si el índice no es válido o no hay ninguna acción en el índice especificado.

Este método se introdujo en QtQuick.Controls 2.3 (Qt 5.10).

[since QtQuick.Controls 2.3 (Qt 5.10)] void addAction(Action action)

Añade « action » al final de este menú. El menú no asume la propiedad del elemento « action » recién añadido.

Este método se introdujo en QtQuick.Controls 2.3 (Qt 5.10).

void addItem(Item item)

Añade item al final de la lista de elementos. El menú no asume la propiedad de la nueva entrada item.

Véase también Dynamically Generating Menu Items.

[since QtQuick.Controls 2.3 (Qt 5.10)] void addMenu(Menu menu)

Añade « menu » como submenú al final de este menú. El menú no asume la propiedad del elemento « menu » recién añadido.

Este método se introdujo en QtQuick.Controls 2.3 (Qt 5.10).

[since QtQuick.Controls 2.3 (Qt 5.10)] void dismiss()

Cierra todos los menús de la jerarquía a la que pertenece este menú.

Nota: A diferencia de ` close()` —que solo cierra un menú y sus submenús (cuando se utiliza ` non-native menus`)—, ` dismiss() ` cierra toda la jerarquía de menús, incluidos los menús principales. En la práctica, ` close() ` resulta adecuado, por ejemplo, para implementar la navegación en una jerarquía de menús, mientras que ` dismiss() ` es el método adecuado para cerrar toda la jerarquía de menús.

Este método se introdujo en QtQuick.Controls 2.3 (Qt 5.10).

Véase también popup() y Popup::close().

[since QtQuick.Controls 2.3 (Qt 5.10)] void insertAction(int index, Action action)

Inserta action en index. El índice se encuentra entre todos los elementos del menú. El menú no asume la propiedad del elemento action recién insertado.

Este método se introdujo en QtQuick.Controls 2.3 (Qt 5.10).

void insertItem(int index, Item item)

Inserta item en index. El menú no se hace cargo del nuevo elemento insertado item.

Véase también Dynamically Generating Menu Items.

[since QtQuick.Controls 2.3 (Qt 5.10)] void insertMenu(int index, Menu menu)

Inserta menu como un submenú en index. El índice se encuentra entre todos los elementos del menú. El menú no asume la propiedad del elemento menu recién insertado.

Este método se introdujo en QtQuick.Controls 2.3 (Qt 5.10).

Item itemAt(int index)

Devuelve el elemento de index, o null si no existe.

Devuelve el submenú en index, o null si el índice no es válido o no existe ningún submenú en el índice especificado.

Este método se introdujo en QtQuick.Controls 2.3 (Qt 5.10).

void moveItem(int from, int to)

Mueve un elemento from un índice to otro.

Abre el menú en la posición del cursor del ratón en las plataformas de escritorio que dispongan de cursor de ratón; en caso contrario, centra el menú sobre su elemento « parent ».

Opcionalmente, el menú se puede alinear con un elemento específico del menú item. Este elemento se convertirá entonces en current.. Si no se especifica ningún item, currentIndex se establecerá en -1.

Estos métodos se introdujeron en QtQuick.Controls 2.3 (Qt 5.10).

Véase también Popup::open().

Abre el menú en la posición especificada pos en el sistema de coordenadas de las ventanas emergentes, es decir, una coordenada relativa a su elemento parent.

Opcionalmente, el menú se puede alinear con una posición específica del menú item. En ese caso, este elemento pasará a ser current.. Si no se especifica ningún item, currentIndex se establecerá en -1.

Estos métodos se introdujeron en QtQuick.Controls 2.3 (Qt 5.10).

Véase también Popup::open().

Abre el menú en la posición especificada x, y en el sistema de coordenadas de las ventanas emergentes; es decir, una coordenada relativa a su elemento parent.

Opcionalmente, el menú se puede alinear con un menú específico item. En ese caso, este elemento pasará a ser current.. Si no se especifica ningún item, currentIndex se establecerá en -1.

Estos métodos se introdujeron en QtQuick.Controls 2.3 (Qt 5.10).

Véase también dismiss() y Popup::open().

[since QtQuick.Controls 2.3 (Qt 5.10)] void removeAction(Action action)

Elimina y destruye el ` action` especificado.

Este método se introdujo en QtQuick.Controls 2.3 (Qt 5.10).

[since QtQuick.Controls 2.3 (Qt 5.10)] void removeItem(Item item)

Elimina y destruye el ` item` especificado.

Este método se introdujo en QtQuick.Controls 2.3 (Qt 5.10).

[since QtQuick.Controls 2.3 (Qt 5.10)] void removeMenu(Menu menu)

Elimina y destruye el objeto ` menu` especificado.

Este método se introdujo en QtQuick.Controls 2.3 (Qt 5.10).

[since QtQuick.Controls 2.3 (Qt 5.10)] Action takeAction(int index)

Elimina y devuelve la acción situada en index. El índice se encuentra entre todos los elementos del menú.

Nota: La propiedad de la acción se transfiere al llamante.

Este método se introdujo en QtQuick.Controls 2.3 (Qt 5.10).

[since QtQuick.Controls 2.3 (Qt 5.10)] MenuItem takeItem(int index)

Elimina y devuelve el elemento de index.

Nota: La propiedad del elemento se transfiere al llamante.

Este método se introdujo en QtQuick.Controls 2.3 (Qt 5.10).

[since QtQuick.Controls 2.3 (Qt 5.10)] Menu takeMenu(int index)

Elimina y devuelve el menú de index. El índice se encuentra entre todos los elementos del menú.

Nota: La propiedad del menú se transfiere al llamante.

Este método se introdujo en QtQuick.Controls 2.3 (Qt 5.10).

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