Mostrando entradas con la etiqueta Qt Quick 2. Mostrar todas las entradas
Mostrando entradas con la etiqueta Qt Quick 2. Mostrar todas las entradas

lunes, 16 de junio de 2014

Lógica de aplicación en QtQuick con JavaScript.

QtQuick es una biblioteca del framework Qt para el desarrollo de aplicaciones con QML. En este artículo veremos cómo implementar la lógica de una aplicación con interfaz gráfica desarrollada en QML mediante un fichero JavaScript, para esto emplearemos un ejemplo desarrollado con la versión 5.2 de Qt. Lo primero que haremos será crear un proyecto de QtQuick. En la pantalla de bienvenida de Qt Creator seleccionamos “New Project”.

clip_image001

Luego en el asistente de nuevo proyecto escogemos la plantilla “Applications” y de las opciones escogemos “Qt Quick Application

clip_image003 clip_image004

Al seleccionar esta plantilla aparece el asistente para llenar los datos del proyecto. Introducimos el nombre, la ubicación, la selección de componentes de Qt Quick (dejamos por defecto Qt Quick 2), el kit de compilación (por defecto) y por último seleccionamos “Finish”. Una vez creado el proyecto se abre el “main.qml” que debe verse así:

clip_image006

Ahora vamos a crear el fichero JavaScript, para esto damos clic derecho en la raíz del árbol del proyecto y seleccionamos “Add new…”. Al abrir el asistente escogemos como plantilla “Qt” y en las opciones seleccionamos “JS File”:

clip_image008 clip_image010

Al abrir el asistente para crear el fichero ponemos el nombre, por ejemplo “logic”, y en la ubicacion seleccionamos la carpeta donde se encuentran los QML del proyecto; esto facilita la localizacion del fichero a la hora de importarlo. Dejamos las opciones por defecto y damos clic en “Finish”. Ya está creado el fichero, ahora vamos a diseñar una inerfaz sencilla para calcular el cuadrado de un número entrado por el usuario. Para esto sustituimos el código del main.qml por esto:

Rectangle {
width: 360
height: 200

Column{
anchors.centerIn: parent
spacing: 10

Rectangle{
anchors.horizontalCenter: parent.horizontalCenter
color: "lightgrey"; width: 40; height: 20

TextInput{
id: inputNum
anchors.fill: parent; color: "black"
font.pointSize: 15.0
}
}

Text { id: result; text: qsTr("El cuadrado es: ")
anchors.horizontalCenter: parent.horizontalCenter }

Text {
text: qsTr("CALCULAR")
anchors.horizontalCenter: parent.horizontalCenter

MouseArea {
anchors.fill: parent
onClicked: {

}
}
}
}
}

Se utiliza un elemento TextInput para obtener la entrada del usuario, un elemento Text para mostrar el resultado y otro para ejecutar el método que implementaremos más adelante. Es importante señalar aquí la propiedad “id” del TextInput y del Text que mostrará el resultado. Esta propiedad es el identificador mediante el cual se puede acceder a todas las propiedades del objeto desde el fichero JavaScript o desde los métodos de los otros elementos en el mismo QML; por eso es necesario que sea único para cada objeto que se declare en el fichero. Ahora, vamos a escribir la directiva que permite importar el fichero JavaScript desde el código QML, en la parte superior del código agregar:

import "logic.js" as Logic

Esto significa que vamos a utilizar los métodos implementados en el fichero “logic.js” a través del id “Logic”. La manera específica de hacerlo lo veremos más adelante. Ahora, abrimos el fichero JavaScript e implementamos el método para calcular el cuadrado del número entrado por el usuario:

function square(num) {
var r = num * num
result.text = "EL cuadrado es: " + r
}

Es un método sencillo, pero lo importante aquí es notar que podemos cambiar la propiedad “text” del elemento Text del fichero QML a través del identificador definido. Lo mismo podemos hacer con cualquiera de sus otras propiedades.

Ya podemos usar el método implementado, para esto vamos al método onClicked del elemento MouseArea y escribimos lo siguiente:

Logic.square(inputNum.text)

Aquí notar dos cosas: primero, que podemos acceder a los métodos del fichero JavaScript a través del id definido en la directiva import como si fuera un objeto y segundo, que desde aquí también podemos acceder a las propiedades de los elementos QML mediante su identificador. En este caso el texto del TextInput.

De esta manera se ha implementado un método sencillo, pero en una aplicación más compleja donde se necesiten más métodos la manera de llamarlos es la misma. Una vez terminado todo solo falta probarlo, para esto compilamos la aplicación y comprobamos que todo funcione bien.

Hasta aquí el artículo de hoy, en resumen hemos visto cómo utilizar los métodos de un fichero JavaScript en el código QML y como acceder a las propiedades de los elementos QML a través de su identificador.

{ Leer Más }


viernes, 28 de febrero de 2014

Desarrollo de videojuegos con Qt Quick + QML

 

image

Qt es un framework que consta de herramientas destinadas a la creación rápida y eficiente de aplicaciones e interfaces de usuario para escritorio, sistemas embebidos y plataformas móviles. Con Qt es posible reutilizar el código de forma eficiente para ser desplegado en diferentes plataformas con un mismo código base. La biblioteca de clases en C++ y las diferentes herramientas permiten al programador crear aplicaciones en una plataforma y compilarla y distribuirlas en otras.

Entre los diferentes módulos de Qt se encuentra Qt Quick el cual es una biblioteca estándar para el desarrollo de aplicaciones con QML. Mientras el módulo QML brinda el motor y la infraestructura del lenguaje, Quick brinda todos los tipos básicos necesarios para la creación de interfaces gráficas. Posee un canvas para mostrar el contenido y diferentes tipos de datos para la creación y animación de componentes visuales, procesamiento de la entrada de teclado y ratón, creación de modelos y vistas de datos y la creación retardada de objetos. El módulo Quick brinda una API QML la cual provee los tipos de datos QML para la creación de interfaces gráficas y una API C++ para extender las aplicaciones QML con código C++.

Qt Quick provee todo lo necesario para crear aplicaciones potentes con una interfaz gráfica dinámica y fluida. Las animaciones y los efectos de transición entre estados son elementos de vital importancia para este módulo. Los efectos visuales pueden ser complementados con componentes especiales como sistemas de partículas y shaders. A continuación se muestran algunas características de Qt Quick que lo convierten en una buena elección para el desarrollo de videojuegos sencillos:

Alto rendimiento con grafo de escena: Qt Quick (versión 2.0) requiere OpenGL 3.0 (u OpenGL 2.x con la extensión framebuffer_object) para renderizar la ventana diseñada en QML. El módulo define un grafo de escena que es luego renderizado. Mediante el uso de la GPU se logra mucho mayor rendimiento que en la versión anterior.

Entradas de usuarios: Qt Quick brinda los siguientes elementos para procesar entradas:

  • Táctil: Qt Quick fue diseñado teniendo en mente las pantallas táctiles y por esto cuenta con eventos táctiles soportados por diferentes elementos visuales.
  • Ratón: el módulo cuenta con el elemento MouseArea el cual recibe automáticamente eventos de ratón (como clicks y eventos de rueda).
  • Teclado: cualquier elemento visual recibe entradas de teclados a través del tipo Key.
  • Gestos de movimientos en dispositivos: Qt Quick por si mismo no ofrece soporte de nativo para gestos físicos de dispositivos pero el módulo Qt Sensors provee tipos QML los cuales soportan dichos gestos.

Estados, transiciones y animaciones: un aspecto llamativo de los juegos son las transiciones entre estados y las animaciones que brindan un atractivo visual al usuario, en Qt Quick estos son conceptos de máxima importancia.

· Estados: el estado de un elemento visual es el conjunto de informaciones que describe cómo y dónde se muestran las diferentes partes que conforman el elemento y todos los datos asociados al estado. Qt Quick provee el elemento State que contiene propiedades que definen su semántica y se puede utilizar para desencadenar comportamiento o animaciones.

· Transiciones: cuando un elemento cambia de un estado a otro su apariencia cambia, una transición es lo que separa dos estados. Qt Quick provee el elemento Transition el cual define lo que ocurre cuando se pasa de un estado a otro.

· Animaciones: cuando se pasa de un estado a otro se puede utilizar una animación para suavizar la transición. Cambios abruptos de la interfaz resultan en una mala experiencia visual y deben ser evitados utilizando animaciones.

· Animación de propiedades: las animaciones no solo están relacionadas con estados y transiciones entre estados. A veces es útil animar el cambio de ciertas propiedades de los elementos, por ejemplo la opacidad. Qt Quick provee el elemento PropertyAnimation que se puede utilizar para este fin.

· Animadores: el tipo Animator es un tipo especial de animación el cual sobrepasa el objeto QML y opera directamente en las primitivas del grafo de escena. Entre los animadores se encuentran: XAnimator, YAnimator, ScaleAnimator, RotationAnimator, OpacityAnimator y UniformAnimator.

Datos, Modelos, Vistas y Almacenamiento de datos: la mayoría de los juegos tienen datos guardados que necesitan mostrar al usuario, estos datos pueden venir de la red, ficheros locales o bases de datos.

· Modelos y vistas: a veces es útil mostrar un mismo dato de diferentes maneras, de esta manera surge la idea de tener un modelo que contiene los datos y las vistas las cuales muestran los datos. El paradigma Modelo/Vista está implementado en Qt Quick el cual puede ser utilizado en el juego.

· Almacenamiento y acceso a datos: las bases de datos son utilizados comúnmente para almacenar información en los juegos, como por ejemplo los records de puntos o de tiempo alcanzados por los jugadores en los diferentes niveles. El módulo Qt Quick local storage provee acceso simplificado a bases de datos relacionales.

Partículas y efectos gráficos: los juegos con interfaces gráficas llamativas resultan más interesantes. El módulo Qt Quick provee herramientas para lograr una aplicación visualmente atractiva pero manteniendo la experiencia de usuario.

  • Transformación visual: los elementos visuales pueden ser transformados, por ejemplo escalados o rotados.
  • Efectos de shader: los efectos de shader permiten utilizar al máximo la capacidad de procesamiento de la tarjeta grafica mediante vextex o fragment shaders.
  • Partículas: el sistema de partículas permite crear explosiones, fuegos artificiales, humo, niebla, efectos de viento incluso gravedad y turbulencia.
  • Sprites: un sprite es un tipo de imagen animada constituida por frames. Qt Quick provee un tipo de dato visual para visualizar sprites los cuales pueden ser utilizados en juegos.
  • Opacidad: los objetos pueden ser opacos o traslucidos, por ejemplo se puede hacer un objeto opaco y otro transparente para centrar la atención del usuario en el opaco.

Tipos de datos convenientes: en un juego muchas veces el programador necesita reaccionar a eventos y desencadenar varias respuestas. QML tiene soporte para estos conceptos a través de enlaces, señales, gestores de señales e inicialización dinámica de objetos.

  • Inicialización dinámica de objetos: QML provee varias maneras de crear y gestionar objetos. Se pueden crear dinámicamente mediante Javascript o utilizando los tipos de datos Loader, Repeater, ListView, GridView y PathView.
  • Conexión dinámica de señales: QML soporta la conexión dinámica de señales a través del método connect().
  • Eventos basados en timers: otro caso común es desencadenar una funcionalidad un periodo de tiempo después de que un evento ocurra. Qt Quick provee el tipo Timer, el cual posee soporte para eventos simples o recurrentes.

Lógica del juego en Javascript: la lógica del juego se puede programar mediante un fichero Javascript. Este es un lenguaje mucho más sencillo que C++ pero que tiene todas las herramientas para desarrollar un juego de calidad. Para llamar a las funciones desde la interfaz solo basta con importar el fichero, y para acceder a los elementos de la interfaz desde el fichero Javascript simplemente hay que utilizar el id de cada elemento. Además el código puede ser depurado mediante Qt Creator solo hay que poner un breakpoint en la función y ejecutar la aplicación con F5. En el modo de depuración se puede ir observando el valor de las variables y así encontrar errores que de otra manera serían difíciles de detectar.

Todas las características de Qt Quick mencionadas anteriormente demuestran que es un módulo muy potente para la creación de juegos. Con relativamente poco código haciendo uso del lenguaje declarativo QML se puede lograr un juego atractivo y tan complejo como se quiera. En la ayuda de Qt se pueden encontrar varios ejemplos de todo lo que se puede lograr con este módulo. Es recomendable utilizarlo en juegos 2D y aplicaciones para pantallas táctiles para sacarle el máximo provecho a todas las características que posee.

{ Leer Más }


martes, 16 de julio de 2013

Desarrollando Ventanas y Menús de nivel superior con Qt Quick.

clip_image001

La versión actual de Qt Quick provee funcionalidades para adicionar a nuestras aplicaciones QML ventanas de nivel superior.

clip_image003

La funcionalidad proporcionada incluye:

  • Creación de ventanas del nivel superior directamente en QML
  • Definir modalidad de ventana y decoración de las ventanas
  • Utilización de los enlaces QML para redimensionar / minimizar / maximizar una ventana principal
  • Adición de menús con accesos directos a la ventana principal usando elementos QML
  • Recopilar información sobre la geometría de la pantalla
  • Crear enlaces de propiedades a través de varias ventanas

Vamos a echar un vistazo a estas características.

Una Ventana de nivel superior.

Así es como se puede crear una ventana principal para su aplicación:

clip_image004

Si desea crear una ventana secundaria, basta con crear otro elemento de ventana dentro de la primera de ellas y establecer visible en true. Por supuesto, la ventana secundaria se borra automáticamente cuando se cierra la ventana padre.

Modalidad y Decoración de ventanas

La modalidad o decoraciones de las ventanas se pueden definir así:

clip_image005

Restricciones de tamaño

Si la ventana debe tener ciertas limitaciones de tamaño que puede aplicarlos de la siguiente manera:

clip_image006

Geometría de escritorio

Para muchas aplicaciones el tamaño máximo de la ventana está obviamente ligado a la resolución de pantalla y el espacio disponible en pantalla. Por lo tanto, también la exportación de un elemento de escritorio que ofrece screenGeometry y availableGeometry por pantalla, así como un screenCount global. Si usted está interesado en esta información, por favor, eche un vistazo al ejemplo Gallery.qml.

Minimizar, Maximizar y normalizar

En caso de que usted quiera que su ventana se minimice, se normalice o se maximice en un evento determinado, puede utilizar la propiedad WindowState del elemento Window para lograr esto:

clip_image007

Vinculación de propiedad a través de varias ventanas

Debido al hecho de que las escenas de diferentes ventanas todavía comparten el mismo motor declarativo, es perfectamente viable para crear enlaces de propiedades a través de varias ventanas. Basta con referirse a un objeto en una ventana diferente, como ya está acostumbrado a ver con elementos QML.

clip_image008

clip_image009

Menús, submenús y accesos directos

Usando los elementos QML MenuBar, Menu y MenuItem en realidad se puede crear barras de menús y menús nativos en plataformas de escritorio. Un menú puede tener varios MenuItems y por supuesto también menús anidados.

clip_image010

Menús contextuales

A veces también es bueno tener un ContextMenu para determinadas opciones. En ese caso, sin duda tiene que estar involucrado algún código javascript.

clip_image011

Deshacerse del MainWindow de QmlViewer

Al utilizar qmlviewer siempre estará visible la ventana principal de qmlviewer en la pantalla, que no puede ser estilizada con menús adicionales.

Esto se puede evitar mediante el uso de la aplicación qmldesktopviewer en su lugar. Si usted decide utilizar qmldesktopviewer para ello, asegúrese de que su principal elemento de raíz del archivo QML es una ventana.

$ ./qmldesktopviewer/qmldesktopviewer examples/TopLevel.qml

Esperamos que le haya resultado interesante, envíenos sus comentarios.

{ Leer Más }


lunes, 1 de julio de 2013

Visión general de nuevas características de Qt Quick.

clip_image001

Muchas son las nuevas funcionalidades que se han adicionado al módulo Qt Quick en Qt 5.1, y en esta entrada queremos compartirlas con nuestros lectores. La mayor parte de las funcionalidades que previamente formaban parte del Proyecto de Componentes de Escritorio (Desktop Components Project) ahora son oficialmente parte de Qt Quick [1]. El aporte con mayor impacto es la inclusión del módulo QtQuick.Controls, pero además se han adicionado otras funcionalidades que continuación se resumen.

Layouts

clip_image002

Es cierto que los componentes anchors y los posicionadores básicos han permitido gran flexibilidad, pero a veces se tornan tediosos o complejos cuando se usan para manipular interfaces de usuario que pueden cambiar sus dimensiones. Con la adición de QtQuick.Layouts como un complemento para los métodos básicos ya existentes en anchor, usted puede ahora construir capas complejas y que pueden cambiar sus dimensiones.

Controles (Controls).

clip_image003

Los componentes de control (controls) de Qt Quick son equivalentes a los widgets. Estos controles están completamente definidos y listos para su uso. La mayoría de los controles comúnmente usados se encuentran allí, incluyendo buttons, combo box, spin box, group box, sliders, progress bars, text fields y menus. Ellos son construidos desde cero usando Qt Quick, y pueden combinarse con cualquier otro código existente de Qt Quick.

Views

clip_image004

Vista Dividida (SplitView)

Además de los controles básicos, también se incluye un nuevo conjunto de vistas. Como se muestra arriba, SplitView hace que sea posible añadir un controlador de tamaño vertical u horizontal entre elementos en una vista.

ScrollView complementa el componte existente Flickable, pero añade soporte para las barras de desplazamiento y el marco. Se puede utilizar tanto independiente o en combinación con un elemento Flickable existente, por ejemplo con el fin de añadir barras de desplazamiento para un ListView.

clip_image005

TableView

Si bien es cierto que el componente ListView ha dado una gran flexibilidad, a menudo era difícil crear algo parecido a una clásica vista de tabla. Para mejorar esto, se ha añadido TableView que proporciona soporte para un aspecto y comportamiento nativo, así como columnas reajustables y selección de fila.

clip_image006

La mayoría de los controles y las vistas también se pueden personalizar para que usted sea capaz de crear un aspecto totalmente único para su aplicación.

clip_image007

Plataforma expuesta a QML

Un problema común al escribir aplicaciones multiplataforma de Qt Quick ha sido que no se podía adaptar fácilmente su interfaz de usuario o el diseño para adaptarse a diferentes plataformas. Para hacer esto más fácil que ahora se está exponiendo la plataforma directamente a QML través de la propiedad global Qt.platform.os.

Los valores posibles son:

  • "android" - Android
  • "blackberry" - BlackBerry OS
  • "ios" - Apple iOS
  • "linux" - Linux
  • "mac" - Mac OS X
  • "unix" - Other Unix-based OS
  • "windows" - Windows
  • "wince" - Windows CE

Tecla Tab de navegación

Brindar soporte para la navegación con la tecla Tab ha sido previamente bastante difícil debíamos crear un enganche explícito entre cada control en la aplicación. En 5.1, se ha simplificado este proceso de manera significativa por la adición de la propiedad activeFocusOnTab a QQuickItem. Estableciendo esto se adjuntará el control de la cadena de tecla Tab implícita. Dado que todos los controles previstos ya han esta activado por defecto, ahora se puede contar con la tecla de navegación para trabajar fuera de la caja cuando se utilizan controles.

QQmlApplicationEngine

En Qt 5.0 por lo general, creabamos aplicaciones Qt Quick declarando un QQuickView en C++ y establecer la URL base en él. La desventaja de este enfoque es que usted tiene que utilizar C++ para establecer propiedades como anchura, altura, etc En Qt 5.1 animamos a usar Window o ApplicationWindow como el elemento raíz de la aplicación, que proporciona un control completo de Qt Quick, así que ahora se está introduciendo el QQmlApplicationEngine para hacer este caso de uso un poco más simple. El QQmlApplicationEngine es todo lo que necesita para configurar la ventana de Qt Quick, enlazar los archivos de traducción correctos e implícitamente se conecta la señal de salir (application quit ()) a la ventana raíz.

 

clip_image008

   

Empotrando Qt Quick en Widgets.

Por fin se ha agregado una vía compatible para incluir una escena de Qt Quick 2 dentro de una aplicación existente basada en widget. Esto se hace mediante la incorporación de un QQuickWindow usando la nueva función QWidget::createWindowContainer().

Conclusiones

Hay demasiadas cosas nuevas para cubrir realmente todo en este artículo así que animamos a comprobar la documentación. Todas estas funciones están, por supuesto, incluidas en el Qt 5.1 RC así que pueden probarlo. Envíennos sus comentarios.

{ Leer Más }


IconIconIcon