Por ello hemos decidido actualizar las compilaciones de los plugins de QML que tenemos disponibles para dar soporte a 32 y 64 bits.

En esta compilación se han usado las versiones Qt 5.9.5, compiladores C y C++ de Microsoft en sus versiones 2015 de 32 y 64 bits.

Para aquellos que os perdisteis que son, y como se compilan los plugins QML para Velneo, os refrescamos los artículos donde hablamos de ello:

• Compilar plugins QML para Velneo
• Desarrollar plugins QML para Velneo
• Qué es un Plugin QML

Para descargar los plugins, tenéis que registraros y proceder a su descarga desde los siguientes botones de descarga:

QtAV

Artículos originales:

• QtAV en Velneo
• QtAV Video Player para Velneo

Box2D

Artículo original:

• Box2D en Velneo

QZXing

Artículo original:

• QZXing en Velneo

QtRecorder

Artículo original:

• QtRecorder en Velneo

VNC Viewer

Artículo original:

• VNC Viewer en Velneo

Esperamos que los probéis y uséis en vuestras aplicaciones Velneo. Si detectáis algún problema no tardéis en reportarlo mediante los comentarios en este mismo hilo.

The post Plugins QML para Velneo 7.24, 32 y 64 bits first appeared on TipeSoft.

• API Restful para PaaSOS
• Novedades en PaaSOS POS
• Novedades en PaaSOS Cloud
• Más soft, menos hard.

Todas ellas nos han permitido crecer en distintas funcionalidades del producto (especialmente en el área de desarrollo de aplicaciones móviles e integración de aplicaciones).

Durante todo este tiempo hemos recibido vuestros comentarios y errores detectados. Gracias a ello, hemos podido corregir todas las áreas funcionales que habéis requerido.

Por otro lado, hemos visto y aprendido de las limitaciones tecnológicas de nuestro producto en áreas geográficas dispersas. La latencia ha sido uno de los grandes problemas a los que los desarrolladores de PaaSOS se han enfrentado.

Trabajando en todas estas cuestiones durante dos años, hemos conseguido mejorar el producto en todas las áreas, ahora es momento de que los usuarios puedan disfrutar de todas estas mejoras.

Cambios fundamentales

Después de dos años de estabilidad y balance de uso, es hora de tomar decisiones importantes respecto al futuro de PaaSOS.

Como cuestión fundamental hemos concluido que la comunidad de desarrolladores Velneo no le gusta lo “colaborativo”, a los resultados nos remitimos. Solo algunas empresas (a las que damos un soporte muy personal) han aprovechado la oportunidad (gracias especialmente a aquellas que han desarrollado su modelo de negocio en base a nuestros productos, estar tranquilos, os seguiremos apoyando en vuestros proyectos).

Es por ello que el fondo de los cambios es la reorientación de nuestros servicios a empresas finales. Para conseguir este objetivo hemos decidido acometer los siguientes cambios:

• “No al Open Source”. No habrá soporte EUPL v1.1 en la nueva versión 1.8 o posteriores. No tiene sentido si la comunidad no aprovecha esta ventaja.
• “No queremos nuevos colaboradores”. No se firmarán nuevos contratos de colaboración con desarrolladores. El contrato de colaboración ha sido un fracaso.
• “Pago anual”. No se aceptarán pagos mensuales de las licencias para uso comercial. En adelante el pago será anual para simplificar la gestión de los pagos (se mantienen los precios y servicios).
• “Solo cloud”. No habrá instalables en local de nuestras demos de producto, solo podrás probarlos en la nube.

Mejoras de arquitectura

Desde hace unos años se ha estado imponiendo 64bits como arquitectura mayoritaria en el mercado. A día de hoy ya es una realidad. No podemos retrasar más el cambio de arquitectura.

• Soporte a arquitectura de 64bits. Ahora el cliente de ejecución y los servidores en la nube funcionan únicamente en 64 bits.
• Nuevos servidores Linux de 64 bits. Se ha procedido a migrar y actualizar la infraestructura cloud de todos los nodos.
• Soporte a la última versión de Velneo (7.23.1) con mejoras considerables respecto a la anterior (7.19.1) que usábamos en PaaSOS v1.7.

Mejoras de producto

Por otro lado, otro de los caballos de batalla, ha sido el menú de inicio. Hoy podemos disfrutar de una mejora considerable del mismo en la nueva versión.

• Nuevo diseño del menú de inicio
• Nuevo diseño del lanzador de favoritos

• Rediseño del TPV en base a los nuevos patrones facilitados en el vERP

• Mejoras de estilo en Windows
• Mejoras de estilo en Linux
• Mejoras en los dashboards y mayor integración con el escritorio
• Mejoras de rendimiento en la carga e inicio de las aplicaciones

Mejoras de PaaSOS Cloud

• Soporte completo para 64 bits
• Nuevos servidores en la nube (más rápidos y mejorados)
• Mejoras en el sistema de actualización de aplicaciones
• Mejoras en el sistema de backups de aplicaciones y datos
• Disponibles dos nuevos pack de productos en el procedimiento de instalación:
  • Pack – Facturación y administración
  • Pack – Gestión de clientes e incidencias
  • Pack – Gestión de personal y contratación
    
• Mejoras de rendimiento en entornos Cloud
• Soporte a la nueva API de SendGrid. Mejoras en las notificaciones por email

Correcciones

• Soporte a Google Maps v3
• Soporte a nueva API de Twitter para el cliente PaaSOS NET
• Soporte a nueva API de Facebook para el cliente PaaSOS NET (mejora continua)
• Correcciones en PaaSOS API
• Correcciones en los productos PaaSOS ERP y TPV

Esperamos que todas estas novedades sean de vuestro agrado. Seguimos trabajando para mejorar día a día este gran producto.

The post Nueva versión de PaaSOS 1.8 first appeared on TipeSoft.

https://es.wikipedia.org/wiki/VNC

VNC son las siglas en inglés de Virtual Network Computing (Computación Virtual en Red).

VNC es un programa de software libre basado en una estructura cliente-servidor que permite observar las acciones del ordenador servidor remotamente a través de un ordenador cliente. VNC no impone restricciones en el sistema operativo del ordenador servidor con respecto al del cliente: es posible compartir la pantalla de una máquina con cualquier sistema operativo que admita VNC conectándose desde otro ordenador o dispositivo que disponga de un cliente VNC portado.

La versión original del VNC se desarrolló en el Reino Unido, concretamente en los laboratorios AT&T Olivetti Research Laboratory, en Cambridge. El programa era de código abierto, por lo que cualquiera podía modificarlo, y existen hoy en día varios programas para el mismo uso. Muchos derivados modernos de él son software libre con licencia GPL.

…

Simple de instalar, de configurar y de usar, nos permite conectar remotamente a un ordenador que tenga instalado VNC Server (el servidor VNC que soporte este protocolo).

Partiendo del código fuente del plugin QmlVncViewer  https://github.com/heroyin/qmlvncviewer con licencia https://github.com/heroyin/qmlvncviewer/blob/master/LICENSE hemos compilado para Win32 obteniendo un plugin sencillo y funcional. No hemos necesitado realizar ninguna modificación en el mismo.

Este plugin usa las librerías de http://www.tightvnc.com/ con licencia GNU GPL v2 https://www.gnu.org/licenses/old-licenses/gpl-2.0.html. Esta licencia nos obliga a liberar todo el código fuente de las aplicaciones donde se integre con la misma licencia (o licencia abierta equivalente).

En caso de querer usarlas para uso comercial tienes una segunda opción, la licencia comercial. La puedes solicitar en https://www.tightvnc.com/licensing.php. Esta licencia os permitiría incluirla en productos comerciales.

Compilar QmlVncViewer para Velneo

La compilación no es especialmente compleja, aunque lo cierto es que no hay nada de documentación al respecto.

Primero tienes que compilar la solución tightvnc.sln, para Win32 en modo Release desde Visual Studio 2013. Es importante que marques todos los proyectos para que se compilen en modo Multi-threaded DLL (/MD)

Después abre desde QtCreator el fichero vncroot.pro y procede a la compilación en modo Release. Recuerda que el entorno requerido es el que os explicamos en el artículo https://tipesoft.com/compilar-plugins-qml-para-velneo/. Poco más que añadir.

Ejemplo del Plugin QML VncViewer

A partir de ahora podrás disfrutar de ella en Velneo gracias a este nuevo plugin que os presentamos hoy.

Como veis, podemos conectarnos sin ningún problema desde Velneo a nuestros servidores VNC gracias a este nuevo plugin.

Desde el punto de vista de la implementación QML, poco que decir. Disponemos de un Elemento QML llamado VncViewer donde establecemos el host, port y password. Por otro lado, usamos la función adjustView() para ajustar el scrollView que nos permite acceder a todo el escritorio de la máquina a la que estamos conectados.

Para iniciar el visor, usamos vncViewer.start(). Para cerrar la visualización usamos vncViewer.stop() y para refrescar la misma vncViewer.refresh(). Es importante la parada de la visualización ya que es un raw abierto en un socket.

Para nuestras pruebas, hemos usado en el lado del servidor UltraVNC Sever (http://www.uvnc.com/). Hemos obtenido buenos resultados, sin ningún problema importante.

Respecto a a la configuración del servidor, es importante fijar el puerto, abrir el firewall y establecer las dos contraseñas requeridas. El resto de los parámetros los podemos dejar por defecto.

Por otro lado, recordaros que VNC no es que sea especialmente seguro, por lo que se recomienda mantener actualizadas las versiones de nuestros servidores VNC. Por otro lado fija contraseñas fuertes y mantenlas actualizadas.

Descargas

Como podéis apreciar, es un plugin fenomenal. Os dejamos disponible todo lo necesario para que podáis disfrutar de el en Velneo 7.22.1.

Descargar código fuente del plugin QML

Recuerda que esta librería tendrás que compilarla para la versión adecuada de tu vClient. Para facilitarte el trabajo, hemos empaquetado la versión para Windows x32 en un descargable. Solo tienes que copiar el contenido dentro de la carpeta Velneo (donde está ubicado el ejecutable del vClient.exe). Asegúrate de que el plugin queda dentro de la carpeta qml del directorio de instalación de Velneo. Recuerda respetar la licencia abierta del mismo, esta librería tiene restricciones importantes de uso, no te las saltes.

Esta vez no os damos acceso al VIN con el ejemplo por cuestiones de licencia, pero no os preocupéis… es tan simple como crear un proyecto Velneo que contenga un fichero QML con el ejemplo incluido en el código fuente anteriormente enlazado. Si tenéis dudas… no tardéis en comentar para aclararlas. Podéis fijaros en los anteriores.

Ante todo, no se te olvide respetar las licencias de todos ellos.

The post VNC Viewer en Velneo first appeared on TipeSoft.

Paco Satué

marzo 8, 2018 | Responder

Hola Jorge.

Las preguntas serían:

– ¿ qué es realmente un plugin QML ?
– ¿ necesito unos conocimientos medios de C++ ?
– ¿ existen en Internet desarrollos en Qt que sean fácilmente importables a Velneo como plugins ?
– ¿ ésta sería una buena forma de extender Velneo y en ese caso, por qué no se hace más a menudo ?

Saludos y gracias por los artículos de excelente nivel.
Paco Satué

Paco tiene razón… y vamos a dársela atendiendo a esta cuestiones y otras que puedan ser necesarias para clarificar que es eso de un plugin QML y como nos afecta a los desarrolladores Velneo.

Qué es un plugin QML

Un plugin QML es una posibilidad de extensibilidad que tiene QML y por ende Velneo. Nos permite extender su funcionalidad de una forma modular (los módulos son los plugins).

Estos plugins pueden contener código C/C++, código javascript y código QML. Se pueden desarrollar combinando las tres tecnologías, haciendo que sea realmente interesante.

Lo habitual es que sea un componente C/C++ con pequeñas partes en QML y javascript.

En caso de requerir solo de capacidades QML y javascript no es necesario desarrollar un plugin c++, con integrarlo como un componente dentro de nuestro desarrollo QML sería suficiente.

Si nos fijamos uno de ellos, veremos que la dispone de funcionalidades desarrolladas de forma mixta (C/C++, código javascript y código QML).

Fíjate en el siguiente directorio de tu instalación de Velneo.

Como puedes observar, el plugin QML QtMultimedia, está formado por una dll (resultado de compilar código c/c++), un fichero QML (Video.qml) y un fichero de configuración (qmldir).

Si abrimos el fichero Video.qml con un editor de texto podemos observar como dentro del mismo hay fragmentos de código JavaScript.

Observar esta cuestión nos permite vislumbrar en que consiste un plugin QML (técnicamente hablando).

Plugins QML en Qt

Dentro de Qt 5 existen multitud de plugins QML. Parte de ellos integrados dentro de la plataforma base, otros como extensiones dentro del proyecto Qt y otros de terceros (de código abierto o cerrado).

En caso de ser plugins QML/C++ requerimos compilarlos para cada plataforma. Esto provoca que sea más complejo técnicamente de lo deseado.

Plugins QML en Velneo

Usarlos dentro de Velneo consiste en poco más que pegarlos en la ubicación correcta (si ya los tienes compilados) e importarlos dentro de tus formularios o listas QML de Velneo.

Actualmente podemos extender el vClient y el vDevelop mediante plugins QML.

En el mundo Velneo, no hay ningún soporte para esta capacidad de extender nuestras herramientas, pero lo cierto es que tampoco es que nos haga demasiada falta.

Necesito saber C++ para desarrollar plugins QML

Sin dudas.

Por desgracia, necesitas algo más que el conocimiento básico:

• Por un lado, necesitas conocer C y C++ (nivel medio).
• Por otro, necesitas conocer QML y JavaScript (no es demasiado complejo, pero requiere de cierto esfuerzo). Recuerda que ya hemos escrito algún artículo sobre como compilar
• Por otro, la forma de declarar un plugin (no es demasiado compleja). Tenemos escrito otro  artículo sobre como crear tus plugins, no dudes en leerlo.
• Por otro, necesitas conocer la plataforma Qt en cada sistema operativo, no es lo mismo compilar en windows, linux o iOS (la verdad es que no es tan simple como puede parecer).
• También necesitas conocer herramientas tales como compiladores, enlazadores, JDK, SDK, XCode, CMake, QMake, Git…

Vamos… que no está al alcance de todo el mundo.

Proyectos Qt que se puedan incorporar como plugins Velneo

Proyectos Qt hay muchos. Que se puedan integrar de forma directa en Velneo, pocos.

Plugins que requieren poco esfuerzo

En los proyectos Qt/QML que hay, el soporte de la comunidad de desarrollo Qt es medio/bajo. Podríamos empezar por esta lista de recursos disponibles Qt/QML:

En algunos de ellos, solo hay que coger la instrucciones del proyecto, compilarlos para cada plataforma y volcar los binarios adecuadamente. En otros… no es tan simple.

Plugins que requieren de esfuerzo medio-alto

Por otro lado, también hay proyectos, que haciendo un esfuerzo medio/alto se podrían convertir en plugins QML. Tendríamos que ver si funcionalmente son necesarios, estudiar el código fuente, desarrollar las clases que intermedien y por último crear y compilar los plugins. De estos hay muchos más.

Plugins que requieren de esfuerzo alto

Y ya puestos… si cogemos C y C++ las posibilidades son infinitas, pero el esfuerzo es mucho mayor.

Es una buena forma de extender Velneo

La verdad es que los plugins QML son una poderosa forma de extender Velneo, tal vez la más poderosa. Pero también es cierto, que los esfuerzos necesarios son medio/altos, y eso echa para atrás a muchos desarrolladores de la comunidad Velneo.

Este es el motivo por el que hemos decidido caminar en esta dirección, para ayudaros a abrir camino en esta difícil tarea. Los resultados saltan a la vista:

• QtRecorder en Velneo
• QZXing en Velneo
• Box2D en Velneo
• QtAV Video Player para Velneo
• QtAV en Velneo
• QtMultimedia en Velneo
• …

Por nuestra parte seguiremos dando luz sobre esta forma de extensión de Qt… ¿Cuál será el siguiente?

The post Qué es un Plugin QML first appeared on TipeSoft.

Por eso he elegido esta vez, un plugin light. Por lo menos esa era la teoría.

He partido de QML Recorder (https://github.com/sverzegnassi/qml-recorder).

Este plugin QML, esencialmente nos permite grabar audio desde QML en distintos formatos y fuentes.

Como a priori parecía muy simple, compilé el plugin e importé los ejemplos a Velneo. El resultado… no funcionaba.

Revisando código, encontré un par de cosas que podían ser las culpables (tratamiento de las rutas y otro detalle menor). Corregidas, compiladas y a funcionar.

Parecía que ya estaba yo contento… hasta que me dio por leer. Terminé leyendo https://github.com/sverzegnassi/qml-recorder/issues y me día cuenta de que era una versión anticuada (no mucho la verdad). Navegando… encontré unas fuentes más actualizadas. Tal vez era más correcto partir de ellas y olvidarnos de las antiguas https://bazaar.launchpad.net/~verzegnassi-stefano/+junk/recorder-test/files.

Al analizar el código fuente, voy y me encuentro dos problemas .

Primer problema

El código fuente está dividido en dos plugins QML.

Vuelta a empezar… no por favor. No quería hacer nada complicado, tengo que leer mucho más sobre de Angular 5 y TypeScript, tengo que revisar el diseño de Arquitectura de otro mega-proyecto, tengo que ofertar un montaje de un CAS, tengo que evitar los rebotes del 4066.

No tengo tiempo para estas cosas…. pufff… dos plugins en vez de uno… pufff…

Pero no lo pude evitar. No quiero que mis compis Velneadores tengan que andar con dos librerías para algo tan sencillo como grabar un audio (conceptualmente están mejor separadas, pero para facilitar el uso, considero que mejor juntas).

El resumen… que he creado un plugin QML que contiene los dos y que hace el trabajo correctamente.

Segundo problema

El ejemplo está desarrollado para Ubuntu…. esto no me lo esperaba.

A revisar el ejemplo y retocar las cosas que no son compatibles. Y todo esto para un simple botón que graba audio.

Moralejas

“No es oro todo lo que reluce”, “No hay mal que por bien no venga”, “Lo barato sale caro”, “El que corre pronto para”… aplicaros el que más os guste. A mi me da, que aplican todos y alguno más en este caso.

QML es dado a la fragmentación por culpa de los fabricantes (como siempre):

• BB10
• Ubuntu
• V-Play
• Jolla
• Nemo
• Qt5
• …

Muchas formas de hacer lo mismo, un sinsentido para un framework tan genial como Qt.

Descargas

Bueno, es hora de publicarlo. Funcionalmente es una librería simple, pero que resuelve una cuestión interesante. Os dejamos disponible todo lo necesario para que podáis disfrutar de ella en Velneo 7.22.1.

Recuerda que esta librería tendrás que compilarla para la versión adecuada de tu vClient. Para facilitarte el trabajo, hemos empaquetado la versión para Windows x32 en un descargable. Solo tienes que copiar el contenido dentro de la carpeta Velneo (donde está ubicado el ejecutable del vClient.exe). Asegúrate de que el plugin queda dentro de la carpeta qml del directorio de instalación de Velneo.

También os damos acceso al VIN de todos los ejemplos funcinando en Velneo V7

La verdad es que no se cual es el uso que la vais a dar, ya me contareis. Recuerda respetar la licencia GNU del mismo.

Aún hay más

Si crees que ya has superado todos los problemas es que aún te queda alguno que superar.

Pues eso, que voy a publicar en WordPress y zasca. Ha dicho que hoy no, tal vez mañana.

Un abrazo… y espero que tengáis un camino más sencillo con las pruebas de este plugin.

The post QtRecorder en Velneo first appeared on TipeSoft.

QZXing es una librería intermediaria entre ZXing y Qt. ZXing, abreviatura de (“Zebra Crossing”), es una librería de procesamiento de imágenes que permite leer y generar códigos de barras 1D y 2D. Es especialmente buena en el proceso de decodificación, no tanto en la codificación. ZXing dispone de soporte para c++, Java y Android https://github.com/zxing/zxing.

Su licencia es Apache 2.0. https://github.com/zxing/zxing/blob/master/LICENSE

Significa que es permisiva, pero tiene que mantener las marcas de uso. También recordaros que QR code está licenciado por Denso Wave, inc.

Por otro lado, QZXing es la librería intermediara entre Qt y ZXing, convirtiéndose en la librería más importante en codificación/decodificación de códigos de barras en Qt https://github.com/ftylitak/qzxing. Su licencia también es Apache 2.0 https://github.com/ftylitak/qzxing/blob/master/LICENSE.

QZXing, en teoría, dispone de soporte para QML (https://github.com/ftylitak/qzxing), pero lo cierto es que hemos tenido que desarrollar un plugin para que funcione correctamente en Velneo. El código fuente del plugin lo podrás encontrar al final del artículo, dentro del fichero comprimido del código fuente, en la carpeta QZXing-master\examples\QMLZXing. De momento solo la hemos probado sobre Win32, por lo que desconocemos como se comportará sobre otras plataformas.

QZXing soporta decodificación de códigos de barra de los siguientes tipos:

• UPC-A
• UPC-E
• EAN-8
• EAN-13
• ITF
• Code 39
• Code 93
• Code 128 (GS1)
• Codabar
• QR Code
• Data Matrix
• Aztec (beta)
• PDF 417

También soporta codificación de tipo:

• QR Code

Véase el siguiente ejemplo de como usar el decodificador desde QML:

import QZXing 2.3

function decode(preview) {
	imageToDecode.source = preview
	decoder.decodeImageQML(imageToDecode);
}

Image {
	id:imageToDecode
}

QZXing{
	id: decoder
	enabledDecoders: QZXing.DecoderFormat_QR_CODE
	onDecodingStarted: console.log("Decoding of image started...")
	onTagFound: console.log("Barcode data: " + tag)
	onDecodingFinished: console.log("Decoding finished " + (succeeded==true ? "successfully" : "unsuccessfully"))
}

Para la codificación de un código Qr usamos un proveedor de imágenes que se registra al iniciar le plugin. Véase el siguiente ejemplo de como usar el codificador de códigos Qr desde QML:

import QZXing 2.3

TextField {
	id: inputField
	text: "Hello world!"
}

Image{
	source: "image://QZXing/encode/" + inputField.text;
	cache: false;
}

Como podéis apreciar es relativamente sencillo de usar. Pero no os engañéis, es realmente poderoso.

Ejemplos de uso de QZXing en Velneo

En la zona de descargas, podrás encontrar un fichero VIN con cuatro los ejemplos funcionales. Trabajo ha costado conseguir que todos ellos funcionen correctamente, algunos de ellos los hemos tenido que revisar y corregir de forma profunda ya que no eran funcionales en primera instancia.

Lector de códigos desde imágenes con soporte Drag N Drop. Permite leer las imágenes mediante Drag N Drop dentro de velneo y obtener el Tag que se encuentre en ellas. Soporta todos los Decorders que veis en la captura.

Lector en vivo de etiquetas Qr. Es una implementación que permite leer códigos Qr en vivo. Acerca uno a tu webcam y verás como funciona.

Codificación de códigos Qr. Como podéis apreciar, es relativamente sencillo, el problema es que solo soporta códigos Qr.

Lector de códigos bajo demanda. Poco que decir… acercas el código a leer, pulsas en Decode y obtendrás un cuadro de dialogo con el código leído.

Descargas

Como podéis apreciar, funcionalmente es una gran librería. Os dejamos disponible todo lo necesario para que podáis disfrutar de ella en Velneo 7.22.1.

Recuerda que esta librería tendrás que compilarla para la versión adecuada de tu vClient. Para facilitarte el trabajo, hemos empaquetado la versión para Windows x32 en un descargable. Solo tienes que copiar el contenido dentro de la carpeta Velneo (donde está ubicado el ejecutable del vClient.exe). Asegúrate de que el plugin queda dentro de la carpeta qml del directorio de instalación de Velneo.

También os damos acceso al VIN de todos los ejemplos funcinando en Velneo V7

Con un poquito de trabajo podrás integrarla en tus desarrollos para conseguir grandes mejoras en tus aplicaciones Velneo. Pero, ante todo, no se te olvide respetar la licencia Apache 2.0.

The post QZXing en Velneo first appeared on TipeSoft.

Hoy toca probar el entorno y desarrollar un primer complemento.

Hello World QML

Antes de aventurarnos con Qt5 es recomendable probar nuestro entorno.

Para ello desarrollaremos un hola mundo con QML, de esta forma garantizaremos que todo está en su sitio.

Dentro del QtCreator pulsamos en File > New Project

Seleccionamos Qt Quick Application – Empty

Establecemos el nombre del proyecto y la ubicación.

Recomiendo una ruta corta para la ubicación de los proyectos (en mi caso uso C:\Qt\Proyectos\). Establécela como la por defecto.

Definimos la herramienta para generar las compilaciones (qmake por compatibilidad).

Establecemos la versión de Qt (no todos los tipos de plantillas permiten 5.6.X).

Seleccionamos el Kit Desktop Qt 5.6.2 MSVC2016 32bit o 64bit (según corresponda)

Y pulsamos en Finish

Debug

Para ejecutar en modo Debug sin depuración pulsamos en el botón Play (no lanza el depurador, solo ejecuta)

Si ya somos capaces de ejecutar nuestra App es que tenemos el compilador en su sitio.

Para ejecutar en modo Debug con depuración pulsamos en el botón Play con cucaracha (lanza el depurador y ejecuta). Un depurador de los de verdad, aunque lo cierto es que los he visto mejores (también peores).

Si lanza el depurador correctamente, ya lo tenemos todo, nos podemos aventurar en algo más complejo.

Release

Para compilar la versión final (la que vamos a desplegar en Velneo) cambiamos el modo a Release.

Para compilar, depurar o ejecutar disponemos del menú Build.

Desarrollando nuestro primer plugin QML

Lo básico ya lo tenemos claro, entorno, compilador y depurador. Ahora toca empezar con la parte dura del asunto, desarrollar un plugin c++/qml. Pero antes de empezar toca aprender un poco, toca leer al respecto http://doc.qt.io/qt-5/qtqml-modules-cppplugins.html

Un plugin QML es una librería que contiene una clase que hereda de QQmlExtensionPlugin. QtCreator dispone de una plantilla para crear extensiones (Qt Quick 2 Extension Plugin), por lo que no nos tenemos que enredar demasiado, deja que QtCreator te ayude.

Le damos nombre a nuestro Plugin. Este nombre se usará como nombre del archivo de nuestra librería y como nombre de plugin.

Creamos una clase que contendrá el elemento QML que usaremos desde Velneo. También tenemos que definir la URI de los componentes. Esta URI se usará como ruta de los ficheros y como nombre del módulo.

Finalizamos el asistente y obtenemos el código de nuestro plugin en base a la plantilla. Observa que la clase de nuestro plugin hereda de QQmlExtensionPlugin. Fíjate en la función registerTypes(). Esta función se encarga de registrar los tipos disponibles en nuestro plugin. Date cuenta de que usa la URI que hemos fijado en el asistente.

En la implementación de la función registerTypes() puedes apreciar como se llama a qmlRegisterType que es la encargada de registrar el tipo de elemento dentro de la ejecución del plugin. En nuestro caso MyHelloWorldItem.

La clase MyHelloWorldItem, es la que contendrá el código de la implementación de nuestro primer componente. Evidentemente, implementaremos algo muy simple, para entender como encajan todas las piezas.

La clase MyHelloWorldItem hereda de QQuickItem (elemento más básico de QtQuick).

Como veis en la propia documentación del código, QtQuickItem no pinta nada. Si quieres que pinte algo, pues toca implementarlo (puede que lo que quieras es hacer algo en C++ en segundo plano, por ejemplo montar un complemento para guardar ficheros en el disco).

Como os podéis imaginar. podemos implementar desde esta clase base o desde una especializada (que herede de ella). Por por poner un ejemplo, si queremos pintar algo en pantalla, podemos partir desde la clase QQuickPaintedItem

Para el ejemplo, vamos a pintar un rectángulo cuadrado de un cierto color. Algo sencillo que todos podamos entender.

La clase QQuickPaintedItem dispone de un método paint() que permite pintar elementos. Si queremos pintar un rectángulo, drawRect() nos valdrá.

Como veis, fijamos el color mediante la función setPen, y lo leemos desde una variable privada llamada m_color.

Si queremos que esta variable pueda ser establecida desde Velneo, tenemos que definir una variable publica llamada color e implementar los métodos Get y Set

Y establecer el comportamiento en el fichero.h de cabeceras de la clase. El fichero de cabeceras quedará tal que así:

A observar… la definición de la señal de control del cambio de color, la variable pública y el método setter. Por último el como establecemos una Q_PROPERTY que se pueda invocar desde QML para que sea capaz de leer y escribir en el color.

Ya tenemos nuestro ejemplo. Ahora toca compilar en modo Release.

Y ya tenemos nuestra DLL. La copiamos a la ruta de Velneo… pero no va sola (la acompaña del fichero qmldir con la definición del plugin y del módulo).

Es importante darse cuenta de que la uri establecida condiciona la carpeta donde tenemos que ubicarla. No podemos dejarla tirada en cualquier sitio. Si la uri es “com.tipesoft.qmlcomponents”, tendremos que crear una estructura de carpetas tal que “com/tipesoft/qmlcomponents” donde dejar nuestra dll y nuestro fichero qmldir

El fichero qmldir lo podemos copiar desde C:\Qt\Proyectos\HelloWorldPlugin (lo creó en base a la plantilla).

Ahora ya podemos implementar en Velneo lo necesario para cargar nuestro plugin.

Fíjate en el import (en base a la uri) y en el nombre del elemento QML (MyHelloWorldItem)

Si no establecemos ningún color… resulta en negro.

Si lo fijamos a “red”

Bueno… parece que ya lo tenemos. Sencillo no es, cierto. Pero estructuralmente son todos iguales.

Os dejamos todo el código necesario descargable desde el siguiente enlace.

Ahora os toca a vosotros

Por nuestro lado, seguiremos aportando nuevos artículos de librerías “open source” que aporten gran valor a Velneo. Si os fijáis en las capturas, tal vez apreciéis cual es la siguiente de la lista.

The post Desarrollar plugins QML para Velneo first appeared on TipeSoft.

Preparación del entorno

El primer paso, y tal vez el más pesado, es la preparación del entorno para compilar las librerías de forma adecuada (para hacerlo compatible con nuestra versión de Velneo).

Para saber que versión estamos usando de las librerías Qt, podemos abrir el cuadro “acerca de” de cualquiera de los productos Velneo. En este cuadro se nos informa de la versión de Velneo, Sistema operativo, arquitectura y versión de Qt.

En la versión v7.22.1 se usa la versión de 5.6.2 de Qt.

Por otro lado necesitamos saber que compilador usa Velneo para esa versión. Como no lo sabemos, tenemos que suponérnoslo. En mi caso he supuesto que compilan con Visual Studio 2013. Con estos primeros dos datos, ya podemos empezar.

Resumiendo (en el escenario windows):

• Plataforma: Windows
• Arquitecturas: x32 y x64
• Compilador: Visual Studio 2013
• Versión de Qt: 5.6.2

Instalar el compilador

Identificada la versión de Qt y el entorno requerido procedemos a instalar el compilador compatible con nuestro entorno.

Por cuestiones de mi trabajo, habitualmente en mis máquinas, están disponibles todos los editores y compiladores de Microsoft. Si en tu caso no dispones de ellos, solo tienes que descargarlos e instalarlos.

Tenéis dos opciones para ello:

• Instalar Visual Studio 2013 Community – Update 5 (opción recomendada)Podemos instalar una versión gratuita de Visual Studio, que Microsoft nos facilita para empresas de pequeño tamaño, desde https://www.visualstudio.com/es/vs/older-downloads/. En el proceso de instalación se requieren unos 10Gb de espacio para los componentes habituales.

• Instalar las Build Tools
  
  Si crees que Visual Studio 2013 es demasiado para tu equipo, hay una segunda opción, instalar las Build Tools https://www.microsoft.com/es-es/download/details.aspx?id=40760 de forma independiente.

Cualquiera de los dos procedimientos de instalación nos instala el comando cl.exe (compilador de nuestro código C++)

Instalar las herramientas de depuración

Lo segundo es instalar las herramientas de depuración. Curiosamente, estas herramientas no vienen incluidas en Visual Studio Community ni en las build tools.

Tenéis tres opciones para instalarlas:

• Mediante las WDK: Las herramientas de depuración están incluidas dentro de las WDK. Puedes descargarlas desde el siguiente enlace https://docs.microsoft.com/es-es/windows-hardware/drivers/download-the-wdk
• Como un paquete independiente (opción recomendada): Puedes instalar solo las herramientas de depuración mediante el instalador de las SDK. Selecciona solo las Herramientas de depuración (Debugging Tools for Windows box) en el asistente de instalación de las SDK para windows (desmarcando todas las demás opciones). Descárgalo desde https://developer.microsoft.com/en-us/windows/downloads/windows-10-sdk
• Como parte de las Windows SDK: Instala de forma completa Windows Software Development Kit (SDK). Las herramiendas de depuración están incluidas dentro de las SDK. Puedes descargarlas desde https://developer.microsoft.com/en-us/windows/downloads/windows-10-sdk

Instalar Qt 5.6.2

Ahora nos toca el tercer paso. Instalar Qt en su versión “open source”. Descargamos desde https://www.qt.io/download pulsando en “Go to open source”

Aceptamos la licencia L(GPL) que nos obliga a que nuestro código sea abierto y por último descargamos el instalador. http://download.qt.io/official_releases/online_installers/qt-unified-windows-x86-online.exe

Abrimos el instalador… siguiente, siguiente… paciencia… le decimos la ruta de instalación… hasta que nos pida los componentes a instalar:

Marcamos Qt 5.6 (equivale a la rama 5.6.2) para msvc2013 en                                                                                                           x32 y si lo deseas en x64

También puedes marcar aquellos plugins QML que deseas incluir en tu instalación (además de los por defecto que ya incluye el instalador de la versión elegida). Los marcados como TP son en fase beta. Los marcados como Deprecated desaparecerán en Qt 6.x

Si para más adelante… deseas compilar y depurar sobre Android necesitas marcar un par de cositas más. El compilador MiniGW y el soporte CDB para el depurador.

Marcado todo lo necesario… procedemos con la instalación.

Arrancamos QtCreator

Cuando tengamos instalado Qt, procedemos a arrancar QtCreator.

Para comprobar que todo ha ido bien, tenemos que entrar en Tools > Options.

Dentro de la sección Build & Run veremos los Kits que están configurados… en vuestro caso Desktop Qt 5.6.2 MSVC2013 32bit y 64bit.

• Si aparecen en rojo o no aparecen… malo, no ha detectado los compiladores.
• Si aparece en amarillo… malo, puede que no haya detectado las herramientas de depuración.
• Si todo está perfecto, ya tienes el entorno preparado para compilar bajo Windows

Para el siguiente artículo, si creéis que es necesario, os cuento como desarrollar un plugin QML para Velneo (comentar en este artículo si consideráis para que así me anime a ello).

The post Compilar plugins QML para Velneo first appeared on TipeSoft.

¿Qué es Box2D?

Es un motor de física 2D (para video juegos entre otras cosas). Box2D ha sido desarrollado por Erin Catto, bajo la licencia zlib. Si bien la licencia zlib no requiere acuse de recibo, informamos públicamente del creador para que conste.

Para más información visita http://www.box2d.org, http://box2d.org/downloads/ y https://github.com/erincatto/Box2D

Entendido… pero a priori este motor de física 2D no está soportado en Velneo V7.

QML Box2D plugin

Como os podéis imaginar, Box2D no lo podemos integrar directamente con Velneo. Pero desde que tenemos QML hay solución para casi cualquier integración con C++.

Para este casos necesitamos un plugin QML… tal como este https://github.com/qml-box2d/qml-box2d. El objetivo de este complemento qml-box2d es exponer la funcionalidad de Box2D (C++) como un complemento QML para facilitar el desarrollo de software basado en física 2D sobre QML.

Pues parece que si es posible soportarlo en Velneo, mediante un plugin QML, de licencia abierta, incluso para uso comercial https://github.com/qml-box2d/qml-box2d/blob/master/COPYING

¿Nos ponemos manos a la obra? Venga va…  veamos si somos capaces de conseguir hacerlo 100% funcional. 20 minutos después…

Cañón:

y unos pocos remates…

Modo debug:

Demolición:

Cuerda de la ropa:

Test con elementos fijos:

Esfuerzo de torsión:

Unión de elementos:

Pues parece que funciona correctamente. Bienvenido sea entonces.

Descargas

Un gran motor 2D para que lo puedas disfrutar o integrar en tus desarrollos de código abierto Velneo:

Recuerda que este motor usa las librerías de Box2D por lo que tendrás que compilarlas para la versión adecuada de tu vClient. Para facilitarte el trabajo, hemos empaquetado la versión para Windows x32 en un descargable. Solo tienes que copiar el contenido dentro de la carpeta Velneo (donde está ubicado el ejecutable del vClient.exe). Asegúrate de que el plugin queda dentro de la carpeta qml del directorio de instalación de Velneo.

Ya tienes una nueva herramienta. ¿Te animas a realizar el primer videojuego en Velneo? o tal vez encuentres un lugar más adecuado en tus desarrollos para este complemento.

The post Box2D en Velneo first appeared on TipeSoft.

Este reproductor es un fork adaptado a Velneo, con decenas de correcciones. Se han implementado para poder adaptarse correctamente a Velneo. En este proceso hemos intentando mantener el 100% de la funcionalidad de la versión original.

Como os podréis imaginar, sigue nuestra política de código abierto respetando la licencia de QtAV. En este caso LGPL v2.1 para las librerías y GPL v3 para el reproductor.

QtAV is a multimedia playback library based on Qt and FFmpeg. It can help you to write a player with less effort than ever before.

QtAV is free software licensed under the term of LGPL v2.1. The player example is licensed under GPL v3. If you use QtAV or its constituent libraries, you must adhere to the terms of the license in question.

Funcionalidades QtAV Video Player para Velneo

Dispone de un panel de información del medio que se está reproduciendo.

Como podéis observar, también dispone de la posibilidad de visualizar el frame de un cierto momento de la reproducción en tiempo real.

Posibilidad de cambiar el Video Codec (si está disponible)

Soporte para efectos y ajustes de imagen.

Historial de reproducción

Soporte de esquemas de audio, audio tracks con soporte interno y externo.

Misceláneos

Captura de frame en reproducción

Cuadro de dialogo Acerca de

Otras funcionalidades:

• Soporte para pantalla completa
• Control de volumen
• Control de reproducción completo

Teclas aceleradoras:

• O: Abrir un fichero
• Espacio: pausa/continua
• F: Pantalla completa on/off
• N/B: muestra el siguiente/anterior frame. Continua la reproducción mediante la tecla “Espacio”
• Q: Sale del reproductor
• R: rota la pantalla 90
• T: rota la pantalla –90
• C: captura de pantalla
• M: muta el sonido on/off
• A: cambia el radio del aspecto
• Arriba / Abajo: sube o baja el volumen + / –
• +/-: Incrementa/decrementa la velocidad de reproducción
• Ir hacia delante/detrás
• Arrastra y suelta un fichero sobre el reproductor para iniciar la reproducción de un nuevo fichero

Un gran reproductor para que lo puedas disfrutar o integrar en vuestros desarrollos de código abierto Velneo:

Recuerda que este reproductor usa las librerías de QtAV por lo que tendrás que compilarlas para la versión adecuada de tu vClient. Para facilitarte el trabajo, hemos empaquetado la versión para Windows x32 en un descargable. Solo tienes que copiar los binarios dentro de la carpeta Velneo (donde está ubicado el ejecutable del vClient.exe):

Código fuente QML del reproductor portado:

The post QtAV Video Player para Velneo first appeared on TipeSoft.