Quantcast
Channel: AprendeXojo
Viewing all 461 articles
Browse latest View live

Bases de Datos: Guardar y Recuperar Imágenes

$
0
0

Cuadro

Xojo es un entorno de desarrollo multiplataforma excelente para crear todo tipo de aplicaciones; y si se trata de aplicaciones que deban de trabajar con bases de datos, entonces encontraremos que podremos crear nuestras soluciones en un abrir y cerrar de ojos, ya sea usando SQLite o los motores de bases de datos cliente/servidor PostgreSQL, MySQL (MariaDB), Microsoft SQL Server, Oracle o cualquier otra a la que podamos acceder mediante un controlador compatible ODBC.

Ahora bien, quizá en tu proyecto contemples la posibilidad de guardar imágenes en una o más columnas de la base de datos y, en este caso, siempre suele aparecer la misma pregunta en los foros de Xojo: ¿cómo puede guardarse una imagen y recuperarla posteriormente? ¿Cuál es el mejor método para hacerlo?

Pues bien, esto es lo que veremos en esta entrada, aplicado sobre una base de datos SQLite, si bien lo explicado en este caso también es aplicable sobre cualquier otro de los motores de bases de datos soportados simplemente cambiando algunas de las clases utilizadas en este ejemplo para que se correspondan con la base de datos utilizada en su caso (por ejemplo MySQLPreparedStatment en vez de SQLitePreparedStatment).

Diseño de la base de datos

Si bien en esta entrada veremos como podemos guardar y recuperar imágenes hacia y desde una base de datos, es necesario preguntarse en primer lugar si es imperativo guardar la información propiamente dicha (los datos de la imagen) sobre la tabla de la base de datos o si simplemente es suficiente con que guardemos la ruta hacia la imagen en cuestión.

Hay que tener en cuenta que si guardamos un gran volumen de imágenes de gran tamaño en la base de datos esta incrementará su tamaño de forma notable, algo que puede llegar a suponer un problema en el caso de que vayamos a desplegar nuestras aplicaciones Xojo como ejecutables de 32 bits (dado que, en tal caso, el tamaño máximo soportado rondará los 4 GB). Igualmente, y en función del tamaño de las imágenes almacenadas, también podríamos penalizar las transaciones realizadas hacia y desde la base de datos en cuestión, sobretodo si vamos a utilizar motores de bases de datos remotas. Ahora bien, en el lado positivo, el almacenamiento de las imágenes nos garantizará el acceso a las mismas dado que sabremos que, efectivamente, están almacenadas en la base de datos.

Mi recomendación: procura usar el almacenamiento de imágenes en la base de datos cuando se trate de imágenes de un tamaño (o peso) pequeño, procurando que no excedan 1 MB.

La otra alternativa supone almacenar en la tabla de la base de datos únicamente las referencias sobre la ubicación (ruta) donde se encuentren almacenadas. Esto permite trabajar con bases de datos de menor tamaño y también agilizar las transferencias. En el aspecto “negativo”, sólo obtendremos los resultados esperados si las imágenes se van a encontrar en todo momento en la ubicación o ruta almacenada en la base de datos; de lo contrario, la app fallará o deberá de implementar otros mecanismos para recuperar la imagen “extraviada”.

Definición de columna BLOB en tabla de Base de Datos SQLite.

 

En este tutorial veremos únicamente la primera de las opciones: guardar la imagen efectivamente en la base de datos. En este sentido, nos aseguraremos de definir en nuestra base de datos las columnas que vayan a contener los datos de las imágenes con el tipo BLOB (objeto de gran tamaño o datos en “crudo”). Esto es fundamental como veremos posteriormente en el uso de la instrucción SQL encargada de crear el nuevo registro empleando los datos de imágen (o actualizar el registro, según sea el caso).

De imagen… a texto

Antes de que podamos realizar la transacción de una imagen hacia la base de datos con la que estemos trabajando, es imprescindible convertir previamente la imagen en cuestión (una instancia de la clase Picture) a formato de texto, de modo que podamos almacenar sus contenidos por ejemplo en una variable de tipo String y, así, incorporarla como parte de la composición SQL en una instrucción Insert o Update.

Lo cierto es que Xojo nos lo pone realmente sencillo también en esto al proporcionarnos el método GetData que podemos invocar sobre cualquier instancia de tipo Picture.

Como puedes ver en la documentación, este método espera dos parámetros obligatorios. El primero de ellos es el formato en el que deseamos obtener los datos de la imagen; por ejemplo, JPEG, PNG, BMB, etc. El segundo de los parámetros indicará la calidad (nivel de compresión) que deseamos aplicar durante dicho proceso de conversión. Como resultado de la ejecución del método obtendremos una instancia de un MemoryBlock. Por ejemplo, si partimos de que la variabla “P” apunte a una instancia válida de Picture, el siguiente código:

Dim mb As MemoryBlock = p.getData(Picture.FormatJPEG, Picture.QualityHigh)

La variable mb contendrá los datos correspondientes a la imagen apuntada por la variable “p” con el formato apuntado durante la conversión.

Ahora bien, podemos sacar ventaja de la relación directa de asignación que existe entre los bloques de memoria y las string, de modo que sustituyendo la anterior sentencia por la siguiente:

Dim data as String = p.getData(Picture.FormatJPEG, Picture.QualityHigh)

Nos proporcionará en la variable “data” la cadena de texto correspondiente a los datos de la imagen contenida por la instancia de tipo Picture apuntada por la variable “p”. ¡Listo!

Trabajar con BLOB: ¡PreparedStatments al rescate!

Ya hemos visto en otras entradas la utilidad principal de los PreparedStatments a la hora de trabajar con los diferentes tipos de bases de datos soportados, dado que nos permiten evitar ataques de inyección SQL. Pero además también suponen la forma más directa de pasar los datos de nuestra imagen, almacenados en una variable de tipo String, ¡para que se guarden en efecto en la columna de tipo BLOB de la base de datos!

Pongamos por caso que la propiedad “db” apunta a una instancia válida de una base de datos SQLite. Así, mediante el siguiente fragmento de código insertaremos un nuevo registro en el que uno de sus campos es de tipo BLOB:

dim ps as SQLitePreparedStatement = app.db.Prepare("insert into imagenes(nombre,imagen) values(?,?)")
ps.BindType(0, SQLitePreparedStatement.SQLITE_TEXT)
ps.BindType(1, SQLitePreparedStatement.SQLITE_BLOB)

ps.Bind(0,name)
ps.Bind(1,data)

ps.SQLExecute

Así, no sólo estaremos sanitizando nuestra entrada de datos hacia la base de datos (algo que hemos de acostumbrarnos a hacer en todos los casos), sino que también lograremos guardar los datos de la imagen correctamente.

Generar la imagen a partir de los datos BLOB

Ya hemos visto cómo guardar la imagen en la base de datos… ¿y para recuperarla? Seguramente lo habrás averiguado: ¡sólo hay que invertir el proceso!

De igual modo que la clase Picture cuenta con el método GetData, también nos ofrece el método FromData. En este caso se toma como único parámetro un bloque de memoria y nos devolverá como resultado una instancia válida (entendiendo que se pueda generar una imagen a partir de los datos contenidos en el bloque de memoria, claro). Obviamente, en este caso también podemos sustituir el bloque de memoria por una cadena, facilitando así aun más las cosas al obtener los datos a partir de la consulta realizada sobre la base de datos.

Por tanto, con la siguiente línea de código:

Dim p As Picture = Picture.FromData(rc.Field("imagen").StringValue)

Estaremos obteniendo en la variable “p” una instancia de imagen válida a partir de los datos almacenados en la columna “imagen” del cursor (RecordSet) obtenido a partir de una consulta SQL válida contra la base de datos. A partir de ahí, ya podremos utilizar la imagen sobre cualquier elemento de nuestra interfaz de usuario, como pueda ser un Canvas o un control ImageWell, por ejemplo.

Conclusiones

Como has podido comprobar, guardar y recuperar imágenes en una base de datos no es particularmente complejo gracias a las ayudas que, como siempre, nos procuran el propio Framework. Y, lo mejor de todo, es que no tendrás que modificar ni una línea de código para que funcione bajo cualquiera de los sitemas operativos de despliegue soportados.

Y si bien en este texto hemos visto los aspectos clave sobre el tema expuesto, te recomiendo que reproduzcas el vídeo que acompaña este tutorial para que veas su funcionamiento en la práctica sobre una aplicación de ejemplo.

The post Bases de Datos: Guardar y Recuperar Imágenes appeared first on AprendeXojo.


Optimización de Aplicaciones Web

$
0
0

Gauge
A diferencia de lo que ocurre con las aplicaciones de escritorio, que se ejecutan sobre el mismo ordenador en el que se encuentra el usuario, las aplicaciones web pueden encontrarse a una distancia de varios cientos de kilómetros del usuario.
Además, en las aplicaciones web también se encontrarán conectados varios usuarios empleando diferentes velocidades de conexión. Es posible que algunos estén utilizando el mejor tipo de conexión posible, mientras que otros lo harán a una velocidad inferior a la de una conexión móvil óptima.

Por tanto, es importante que tengas en cuenta como creas tu app para optimizar el rendimiento en Internet. A continuación encontrarás algunas técnicas que puedes usar para optimizar tu aplicación web con vistas a que proporcione un mejor rendimiento.

Gráficos

Usa PNG

Si bien las imágenes en formato JPEG pueden ser más pequeñas en comparación con el formato PNG, el formato JPEG tiende a ensuciar el texto y suavizar el color, además de que no soporta transparencia y también conlleva posibles problemas de licencias.

Puedes crear una WebPicture en formato PNG pasando Picture.PNGFormat como segundo parámetro del constructor WebPicture. Este sería un ejemplo:

' source es una instancia de Picture disponible en el proyecto
' o bien que se ha podido cargar desde disco
WebImageView.Picture = New WebPicture(source, Picture.FormatPNG)

Almacena los objetos Picture en Propiedades

Los objetos Picture almacenados en Propiedades de una aplicación web están cacheados por el navegador web, de modo que sólo se envían una vez desde la app hacia el navegador. Como resultado, el almacenaje de las imágenes como propiedades de la app reduce la cantidad de datos transmitidos entre la app y el navegador. El hecho de guardar las imágenes en Módulos como propiedades también permitirá que el navegador pueda cachearlas.

Usa Rectangles

En vez de crear imágenes (instancias de Picture), utiliza instancias de la clase Rectangle siempre que sea posible. Pueden modificarse de forma significativa mediante el uso de estilos. Por ejemplo, ajustando el radio de las esquinas a 50 permite convertir el rectángulo en un círculo. Los  rectángulos tienen muy poco peso en cuanto a la cantidad de datos que se han de enviar desde la app hacia el navegador, haciendo que sean rápidos de dibujar.

Usa el Editor de Estilos para Crear Estilos

Los Estilos tienen un peso pequeño, en cuanto a la cantidad de datos que se han de enviar desde la app hacia el navegador, de modo que suponen un modo muy eficiente a la hora de realizar cambios visuales.

Latencia

Elimina los Manejadores de Evento no Utilizados

Los manejadores de evento causan la comunicación entre el navegador y la app web en el servidor, incluso cuando no existe código en ellos. Por tanto, elimina cualquier evento que no contenga código.

Envía los Objetos de gran tamaño en segundo plano

Si tu app contiene objetos de gran tamaño que sabes que vas a necesitar, puedes utilizar un control Timer o utilizar Push para asignarlos a propiedades de la página mientras que el usuario está haciendo cualquier otra cosa. Por ejemplo, Google Maps envía en segundo plano segmentos del mapa ubicados en torno al área que se está mostrando, sólo en previsión de que puedas desplazarte por el mapa. Puedes utilizar esta misma técnica en tus aplicaciones.

Cautela con los resultados de las consultas

Si estás accediendo a una base de datos y cargando los resultados en un ListBox, ten cuidado con obtener un número elevado de registros. Cuantos más registros cargues, se precisará también más tiempo para enviar la información hacia el navegador, y también será preciso que el navegador utilice una mayor cantidad de memoria. Evitar llenar los ListBoxes con una gran cantidad de filas y considera en su caso cargar filas bajo demanda o utilizar un sistema de paginación.

Ten cuidado con las pulsaciones de tecla y los MouseEvent

Cada evento provoca el envío de datos entre el navegador y tu app. Eso significa que debes evitar el uso de aquello que provoque eventos frecuentes, como pueda ser KeyUp, KeyDown y MouseMove. Si tu aplicación está ejecutándose en una red local, estos eventos probablemente no causen un gran impacto, pero si el ususario está accediendo a la aplicación a través de Internet y tienes una gran cantidad de usuarios simultáneos, entonces esto causará un elevado retardo en la respuesta. ¡Prueba y experimenta!

Uso del Framework

No uses nombres de página implícitos

Guarda la referencia a una página en una variable o propiedad en vez de usar el nombre de la página como referencia implícita. Las referencias implícitas deben ser examinadas por el framework, lo que requiere más tiempo en comparación con el acceso directo a una referencia que está almacenada en cualquier otra parte. Por ejemplo, en vez de hacer esto:

WebPage1.Show

Crea una propiedad (customerPage As WebPage1) y entonces usa la propiedad:

customerPage.Show

Usa InsertText/AppendText al actualizar TextAreas

Cada vez que actualizas la propiedad Text de una TextArea se envía todo el texto desde tu app hacia el navegador. Si sólo necesitas añadir texto o insertar algo de texto, usa los métodos AppendText e InsertText. Estos envían al navegador sólo el texto que se está insertando o añadiendo.

Despliegue y DesarrolloU

Uso de CGI frente a Standalone frente a Carga Balanceada

Puedes compilar tu app como CGI o servidor HTTP autónomo. Una app CGI se comunica con un servidor web (por lo general Apache). Dado que Apache es un servidor web completo, puede gestionar significativamente más tráfico y también es más configurable en comparación con una app web Autónoma (Standalone). Sin embargo, Apache ha de comunicarse con la app web mediante CGI, lo que puede resultar en un rendimiento más lento.

Una app Autónoma incorpora su propio servidor web, pero no es completo. Las pruebas sugieren que un Servidor HTTP autónomo puede gestionar unos cuantos cientos de usuarios sin problema, en función siempre del tipo de aplicación de la que se trate.

Puedes hallar que usando un balanceador de carga, como HAproxy, puede gestionar grandes cantidades de usuarios direccionándolos a múltiples copias de la app web.

Fugas de Memoria

Se producen fugas de memoria cuando se crean objetos pero no llegan a destruirse. A medida que se crean más objetos y no se destruyen, también aumentará en igual medida la cantidad de memoria utilizada. Como resultado, la app se colgará dado que el equipo se quedará sin memoria disponible.

En una app de escritorio puede que no sea un gran problema porque el usuario saldrá de la aplicación y eso limpiará la memoria utilizada. Sin embargo, en una app web es más serio dado que la app web puede estar ejecutándose durante días, meses o incluso más.

Si tu app está ejecutándose como CGI, una vez que la cantidad de usuarios (sesiones) que están accediendo a la app llegue a cero, la app saldrá y se liberará la memoria utilizada. Sin embargo, es posible que tu app nunca alcance el punto en el que no haya usuarios accediendo, de modo que has de tener mucho cuidado con las posibles fugas de memoria.

Leyes Locales

Las aplicaciones web se ven en ocasiones afectadas por las leyes locales de cada área. Por ejemplo, la Unión Europea requiere que los sitios web soliciten permiso a los usuarios antes de instalar la mayoría de las cookies.

The post Optimización de Aplicaciones Web appeared first on AprendeXojo.

Despliegue de App Web en Linux

$
0
0

open container pallets with boxes and hand truck isolated on white background

Las aplicaciones web son en general más sencillas para tus usuarios y clientes en comparación con las aplicaciones de escritorio. No tienen que preocuparse en instalar software o las actualizaciones. En vez de que tus clientes deban de desplegar tu software en sus ordenaadores, tu has de desplegar en software en tus servidores web.

En general, estos son los pasos que has de llevar a cabo para desplegar una app web Xojo en un servidor Linux:

  1. Compila tu app web para Linux.
  2. Conecta a tu servidor web utilizando tu cliente FTP preferido (usando el modo Binario).
  3. Sube tu app web (incluyendo las carpetas Libs y Resources)
  4. Verifica que el bit de ejecución está definido para los archivos recién subidos; algunos clientes FTP tienen la mala costumbre de cambiar este bit en la subida de archivos.

Pero los detalles pueden ser algo más puntillosos.

Puedes desplegar tus apps web en Servidores Privados Virtuales  con la configuración adecuada (VPS por sus siglas en inglés). Los hosting compartidos no funcionan por lo general, debido a la ausencia de capacidades de configuración. Si buscas la solución de hosting con la experiencia de despliegue más sencilla, deberías de tener en cuenta Xojo Cloud.

App Web Autónoma (Standalone)

Si estás subiendo una app web autónoma, entonces deberías seguir estos pasos:

  1. Compila tu aplicación web para Linux con el ajuste de compilación Standalone seleccionado.
  2. Conecta a tu servidor web usando tu cliente FTP preferido.
  3. Navega hasta la carpeta en la que quieras tener tu aplicación web.
  4. Sube tu aplicación web (incluyendo las carpetas Libs y Resources) en modo Binario.
  5. Verifica el bit de ejecución de los archivos recién subidos.

Ahora has de ejecutar la aplicación web autónoma en el servidor. Tendrás que conectare al servidor para ello usando ssh (Secure Shell). El Shell seguro (y el comando ssh) están disponibles desde la línea de comandos del terminal en Windows, OS X y Linux.

  1. Conecta al servidor usando ssh (Shell seguro) con este comando: ssh login@misitioweb.es
  2. Introduce la contraseña cuando se solicite.
  3. Navega hasta la carpeta a la que hayas subido tu app web.
  4. Ejecuta la app usando este comando: ./TestApp

Ahora puedes acceder a la app web en tu navegador web usando el nombre de dominio y el puerto. Si has compilado “TestApp” para que use el puerto 8080, entonces puedes acceder a ella usando un URL como este: http://www.mywebsite.com:8080

Ten en cuenta que si sales de ssh, entonces tu aplicación web finalizará su ejecución excepto que la hayas “daemonizado”. Utiliza este código en el evento App.Open para “daemonizar” una aplicación web autónoma:

Call Daemonize

En OS X, el uso de Daemonize está desaconsejado por Apple. Deberías de usar launchd en vez de ello.

Aplicación Web CGI

Si estás subiendo una aplicación web CGI, entonces deberías de seguir estos pasos:

  1. Compila tu aplicación web para Linux con el ajuste de compilación CGI seleccionado.
  2. Conecta con tu servidor web usando FTP.
  3. Navega hasta la carpeta en la que tu servidor web espera encontrar la app CGI. Por lo general es la carpeta con el nombre cgi-bin
  4. Sube tu aplicación web (incluyendo la carpeta Libs, la carpeta Resources, y los archivos config.cfg y cgi). Usa el modo Binario.
  5. Verifica el bit de ejecución.

Si tu servidor web ya está configurado correctamente para la ejecución de aplicaciones CGI con Apache, entonces sólo tendrás que escribir el URL en tu navegador. Por ejemplo, para una aplicación web llamada “TestApp”, deberías usar un URL como este:

http://www.mywebsite.com/cgi-bin/testapp.cgi

Resolución de problemas

Sin embargo, las cosas no siempre van bien a la primera. Esta sección incluye algunos consejos que te permitirán solucionar los problemas de despliegue más comunes.

Librerías de 32 bits

Por defecto, las versiones de Linux de 64 bits no incluyen las librerías de 32 bits que se precisan por las aplicaciones web Xojo de 32 bits. Por favor, consulta los Requerimientos del Sistema para obtener los detalles sobre como obtener e instalar las librerías de 32 bits en tu distribución Linux. Asegúrate también de que esté disponible la librería libicu. Puedes evitar este paso compilando tu app web como aplicación de 64 bits.

Dependencias

No todas las instalaciones de Linux tienen preinstaladas las dependencias necesarias para las aplicaciones Xojo. Consulta los Requerimientos del Sistema para obtener los detalles. Para determinar cuáles son las librerías utilizadas por Xojo, puedes utilizar el comando ldd:

ldd Xojo

Logs Web

Si obtienes un “Internal Server Error” o cualquier error, has de comprobar el log del servidor web para obtener los detalles. Una fuente común de problemas el ajuste incorrecto de los permisos.

Permisos

Tu app web necesita tener definidos los permisos correctos, de modo que el servidor web pueda ejecutar la aplicación. Esto se realiza mediante el uso de los comandos chown y chmod. Los permisos necesarios varían en función de la distribución de Linux y la instalación de Apache. Un buen punto de partida son los permisos “755”.

No se puede ejecutar la aplicación

Este error indica que el CGI (un script Perl) se ha ejecutado correctamente, pero no ha podido ejecutar tu aplicación web. Este error ofrecerá más información, por lo general el mensaje “Permiso Denegado”. Algunos usuarios de hosting compartidos reciben el mensaje “Connection refused”. Este mensaje significa, por lo general, que el proveedor del hosting tiene una política de seguridad que evita la ejecución de tu app. Deberás de verificarlo con tu proveedor de hosting en el caso de que recibas dicho mensaje.

Ajustes del Ejecutable

Cuando subes tu aplicación al servidor, asegúrate de que la aplicación y su carpeta libs se suban en modo binario, y todo lo demás en modo ASCII. Muchos clientes FTP lo hacen automáticamente de forma correcta, pero otros no.

Si obtienes un error que indica “Application launched, but unable to connect on port #”, significa que el CGI puede ejecutar tu app, pero no ha podido conectarse con ella utilizando el puerto especificado. El firewall de tu host podría estar bloqueando dicho puerto. Tendrás que desplegar la app usando un puerto estático y pedir a tu proveedor de alojamiento que abra un puerto que puedas usar.

No se puede ubicar una Librería en la Carpeta Libs

Asegúrate en primer lugar de haber subido todos los contenidos de la carpeta Libs en modo Binario.

Comprueba la entrada Options FollowSymLinks en tu configuración Apache.

Error Interno del Servidor

Esto puede significar una amplia variedad de cosas. Consulta los logs del servidor web. Algunas cosas a verificar:

Asegúrate de que Apache esté configurado para que permita las aplicaciones CGI

Asegúrate de que Perl está instalado y configurado correctamente.

The post Despliegue de App Web en Linux appeared first on AprendeXojo.

Uso de Bases de Datos en Apps Web

$
0
0

WebDatabase

Usar bases de datos con apps web no es muy distinto de hacerlo con las aplicaciones de escritorio, si bien hay algunas cosas que conviene tener en cuenta. El cambio más importante es que la app web permite el acceso de múltiples usuarios.

Esto significa que querrás que la conexión con la base de datos sea única para cada uno de los usuarios que conecte con la app web, en vez de que sea una conexión global a la app propiamente dicha (tal y como ocurre en el caso de las apps de escritorio). El modo más simple de asegurarlo es creando una conexión a la base de datos en el manejador de evento WebSession.Open, guardando así una referencia a la conexión en una propiedad añadida a WebSession.

Añade esta propiedad en el objeto Session:

DB As SQLiteDatabase

En el manejador de evento Open, conecta con la base de datos:

Dim dbFile As FolderItem = GetFolderItem("MiBaseDeDatos.sqlite")
DB = New SQLiteDatabase
DB.DatabaseFile = dbFile
If Not db.Connect Then
' Muestra una página de error y registra el error
' Dado que no deberías de mostrar los detalles al usuario
PaginaDeError.Show
End If

Si bien el anterior fragmento de código conecta con una base de datos SQLite, puedes utilizar la misma técnica para conectar a una base de datos diferente, como pueda ser PostgreSQL o MySQL.

Al disponer de la propiedad DB como una propiedad de la sesión, te asegurarás de que las transacciones con la base de datos son específicas para cada uno de los usuarios conectados como sesión, reduciendo así el riesgo de que los datos queden expuestos a la sesión errónea.

Con SQLIte, el archivo de base de datos se encuentra generalmente en el mismo servidor en el que también está ubicada la app web (o en una carpeta relacionada). Asegúrate de haber aplicado los permisos correctos al archivo de base de datos o, de lo contrario, no podrás guardar los cambios sobre ella. En la mayoría de los servidores Linux, has de utilizar generalmente los permisos “755”, pero esto puedo variar en cada servidor. Una vez que estés conectado al servidor, podrás realizar este cambio con un comando del terminal como este:

chmod 755 MiBaseDeDatos.sqlite

Una vez hayas configurado tu proyecto de esta forma, podrás referenciar la base de datos así:

Session.DB

De modo que, para recuperar datos, podrías utilizar un fragmento de código similar a este:

Dim rs As RecordSet
rs = Session.DB.SQLSelect("SELECT * FROM Person")
If Session.DB.Error Then
' Guarda y registra los errores de Session.DB.Error y Session.DB.ErrorMessage
' No deberías de mostrar este tipo de información a tus usuarios
​Return
End If

While Not rs.EOF
ListBox1.AddRow(rs.idxField(1).StringValue)
rs.MoveNext
Wend
rs.Close

Instrucciones Preprocesadas (Prepared Statements)

Para evitar un riesgo de seguridad denominado inyección SQL, deberías de utilizar siempre las Instrucciones Preprocesadas (Prepared Statements) con aquellas instrucciones que incorporen parámetros proporcionados como entradas del usuario.

The post Uso de Bases de Datos en Apps Web appeared first on AprendeXojo.

Aplicaciones Web: Crear un Login seguro

$
0
0

candado
Cada vez son más los desarrolladores que usan Xojo para crear aplicaciones que pueden contener información privada. Esto significa que cada vez es más importante asegurarse de que las aplicaciones web desarrolladas estén protegidas con un certificado SSL y algún tipo de autenticación que garantice que el usuario es realmente quien dice ser.

Nota: Para seguir este tutorial, tendrás que crear una aplicación CGI y ejecutarla sobre un servidor que tenga un certificado SSL instalado. De lo contrario, obtendrás un error.

Por lo general, una pantalla de acceso solicita un ID de usuario de algún tipo, ya se trate de una dirección de correo electrónico o cualquier otro tipo de identificación única, como pueda ser un número de cuenta), así como una contraseña introducida por el propio usuario o bien generada automáticamente.

Un buen método de crear pantallas de acceso en Xojo es mediante el uso del Diálogo Modal sobre una página en blanco, dado que no hay duda de qué precisas que haga el usuario a conteinuación. Esto también te permite lidiar con las complejidades asociadas con el proceso de acceso sin que se vea interferido por algún otro código.

WebLoginDialog

Algo a tener en cuenta: Las conexiones SSL son notablemente más lentas en comparación con las conexiones no SSL debido que a no se permite el cacheado de los datos, de modo que probablemente no quieras que toda tu aplicación sea segura (como si estuvieses creando un sitio web de acceso público con determinadas funciones disponibles sólo para los miembros de pago). Lo que necesitas es la capacidad de cambiar de no SSL a SSL cuando un usuario llegue a la pantalla de acceso.

Cambiar seguridad SSL

En este ejemplo, la pantalla de acceso es simplemente una página vacía que muestra un diálogo web en el evento Shown. Antes de llegar a ese punto, has de comprobar si la conexión es segura. Para ello, introduce el siguiente fragmento en el evento LoginPage.Open:

' Asegúrate de que la conexión del usuario es segura,
' Si no es así, deja que el navegador cargue la aplicación de forma segura
If Not Session.Secure Then
Dim host As String = Session.Header("Host")
Dim url As String = "https://" + host
ShowURL(url)
End If

La anterior acción llevará al usuario nuevamente a la página web por defecto y no a la página de acceso, de modo que has de indicar a la sesión como gestionarlo. En el evento WebSession.Open():

If Self.Secure Then
LoginPage.Show
End If

En este caso el código asume que un usuario final está accediendo a la app (es decir, creando una nueva sesión) y que se está conectando de forma segura, de modo que se redirige a la página de acceso.

Gestión de Cookies: Recuérdame

Si observas la captura de pantalla, verás la casilla de verificación “Recuérdame”. Por lo general, esto se utiliza para recordar el ID del usuario y facilitarle así próximas conexiones recordándole cual era la contraseña. Esta función utiliza una característica del navegador denominada Cookies y que almacena un fragmento de información en el ordenador que esté usando el usuario (asuminedo que las Cookies estén activadas, claro está).

NOTA: Es mejor no recordar la contraseña del usuario, dado que si se selecciona esta casilla de verificación en un equipo público (como en una Biblioteca o en una cafetería que proporcione ordenadores para conectar a Internet), la cuenta del usuario podría verse comprometida.

Para añadir funcionalidad a la casilla de verificación, es preciso utilizar dos fragmentos de código. En LoginDialog.Shown:

If Session.Cookies.Value("username") <> "" Then
UserNameField.Text = Session.Cookies.Value("username")
RememberMeCheck.Value = True
PasswordField.SetFocus
End If

En primer lugar se comprueba si se ha definido la cookie “username”, y en caso de que así sea se copia su valor en el campo de texto Username, se activa la casilla de verificación RememberMe y se pasa el foco al campo Password, básicamente como facilidad al usuario y que no precisen hacerlo manualmente.

A continuación, en el evento Action() del botón Login:

DoLogin

Entonces se crea el método DoLogin en LoginDialog:

If RememberMeCheck.Value Then
Session.Cookies.Set("username", UserNameField.Text)
Else
Session.Cookies.Remove("username")
End If

' Ahora valida las credenciales y, si son correctas, puedes cerrar el diálogo
' y mostrar la página principal.
If ValidateCredentials Then
Self.Close
MainPage.Show
Else
MsgBox(“El nombre de usuario y contraseña no coinciden.")
End If

Puede que te estés preguntando por qué deberías crear un método separado para lo que podría estar perfectamente en el evento Action. El motivo es que puede que quieras cerrar este diálogo desde otra ubicación (ver más adelante); pero primero, cuando el usuario hace clic en el botón de acceso, compruebas el valor de la casilla de verificación RememberMe. En el caso de que sea True, entonces se define la Cookie Username con lo que se haya introducido como nombre de usuario. Si es False se elimina la cookie (de otro modo los usuarios no podrían eliminar la cookie al desactivar la casilla de verificación).

Capturar el retorno

Una última cosa, los usuarios esperan que las cosas funcionen tal y como ocurre en el resto de las aplicaciones web, y eso significa que cuando pulsas la tecla de Retorno en el teclado, por lo general se espera que ocurra la acción de login. Puedes hacer eso añadiendo el siguiente fragmento de código al evento KeyPressed de la ventana:

If Details.KeyCode = 13 Then
LoginDialog1.DoLogin
End If

¡Y esto es por lo que pones el código del evento Action en un método separado! Ahora, cuando el usuario escriba su nombre de usuario y/o contraseña y pulse la tecla retorno, el diálogo se cerrará tal y como si hubiesen pulsado el botón de Login ellos mismos.

The post Aplicaciones Web: Crear un Login seguro appeared first on AprendeXojo.

Tablas en iOS: celdas con iOSCustomTableCell

$
0
0

iOSCustomTableCellCon Xojo 2016r2 se han incrementado notablemente las capacidades a la hora de crear y desplegar aplicaciones nativas iOS (iPhone, iPad y iPod touch); y una de las parcelas en las que se reflejan dichas mejoras es en uno de los controles de UI más utilizados en cualquier aplicación: las tablas. Ahora es posible reordenarlas, editarlas… ¡y también utilizar celdas personalizadas con iOSCustomTableCell! A continuación te cuento como.

A partir de Xojo 2016r2 podemos utilizar en nuestras tablas tantas celdas personalizadas como deseemos, ¡e incluso combinar varias celdas personalizadas en una misma tabla! La libertad de utilizar celdas personalizadas es que estas podrán contener cualquier combinación de controles y elementos en sí mismas, ampliando así notablemente la representación de información más allá de una simple etiqueta de texto y/o imagen o casilla de verificación.

iOSCustomTableCell: diseña tus celdas personalizadas

El diseño de las celdas personalizadas en las aplicaciones iOS es posible gracias a la disponibilidad de la nueva clase iOSCustomTableCell y que podemos añadir a nuestro proyectos tal y como haríamos en el caso de cualquier otro control, simplemente arrastrándolo desde la Biblioteca hacia el Navegador de Proyecto (la columna situada más a la izquierda en el IDE).

Como resultado, crearemos una subclase cuya clase superior será iOSCustomTableCell y sobre la que podremos añadir código en los eventos Open y Close, así como definir o acceder a la información correspondiente en las propiedades expuestas: Visible, AccessibilityHint y AccessibilityLabel.

iOS Custom Table Cell

En cuanto a la parte visual, y si ya estás acostumbrado a trabajar con los ContainerControl en las aplicaciones Xojo Desktop (OS X, Windows y Linux), entonces encontrarás que las clases derivadas de iOSCustomTableCell proporcionan en cierto modo la misma funcionalidad: una vista, lienzo o “espacio” sobre el cual puedes añadir y disponer cualquier otro de los controles UI disponible, incluyendo aquellos diseñados por nosotros mismos.

Al seleccionar cualquiera de las subclases añadidas al proyecto accederemos al conocido Editor de Diseño, sobre el cual podemos ajustar el tamaño de vista propiamente dicho para nuestra iOSCustomTableCell y también disponer del resto de controles tal y como deseemos presentar la información en nuestras tablas. Por supuesto, cualquiera de los controles añadidos responderá a los eventos ejecutando el código asociado.

Edición de diseño para un iOSCustomTableCell

 

Pintar las celdas en la tabla

Como se ha visto, el diseño de las celdas personalizadas no plantea ningún problema. Ahora bien, ¿cómo podemos indicar a la tabla cuál de las celdas personalizadas queremos utilizar en cada caso, además de actualizar la información propiamente dicha para cada uno de los controles incluidos en las celdas? La respuesta se encuentra en la interface de clase iOSTableDataSource cuya implementación ya se pudo ver en una entrada anterior del blog.

Es decir, si bien podemos trabajar con las celdas personalizadas añadiéndolas manualmente desde código, lo más eficiente consiste en definir un objeto que actúe como fuente de datos y que sea interrogado por la propia tabla cada vez que esta requiera el pintado de una celda en concreto. Esta orientación es realmente mejor desde el punto de vista de la OOP (programación orientada a objetos), donde nuestra clase —actuando como proveedora de información— adopta un papel pasivo y ejecutando el código sólo en los casos en los que sea preciso.

Dicho enfoque también es más eficiente en cuanto a la gestión de los recursos consumidos por la tabla propiamente dicha, ¡ya que esta reutilizará la misma celda siempre que sea posible! Esto significa, por tanto, que cada vez que la tabla nos solicite la devolución de una nueva celda hemos de asegurarnos de actualizar correctamente todos los controles de la celda personalizada. De lo contrario, es probable que una celda mostrase algún dato asociado a cualquier celda anterior.

Tal y como vimos en su día, cuando añadimos la interfaz iOSTableDataSource a una clase hemos de implementar obligatorio los métodos RowCount, RowData, SectionCount y SectionTitle. En definitiva, estos son los métodos que invocará la tabla cada vez que necesite consultar información para su dibujado.

De entre todos estos métodos, el que nos interesa particularmente para utilizar las celdas personalizadas es RowData; es decir, el invocado por la tabla cada vez que necesita dibujar una nueva celda. De hecho, puedes comprobar que en la signatura de dicho método recibiremos como argumentos una variable que apunta a la tabla propiamente dicha, así como el valor entero de la sección bajo la cual se va a pintar la celda y también el número entero de la fila (celda) que se va a pintar. El método espera que le devolvamos, por tanto, una instancia de iOSTableCellData como resultado.

¿Cómo obtenemos una instancia de iOSTableCellData a partir de nuestro control personalizado iOSCustomTableCell? La respuesta se encuentra en el método CreateCustomCell de la clase iOSTable. Dicho método espera que le pasemos como parámetro la información de Tipo correspondiente a nuestro control, algo que podemos lograr ejecutando la siguiente instrucción de código:

GetTypeInfo(MyCustomCell)

Donde “MyCustomCell” se correspondería con una subclase de iOSCustomTableCell que hayamos añadido al proyecto. Por tanto, la instrucción completa para obtener la iOSTableCellData propiamente dicha sería:

dim cell as iOSTableCellData = table.CreateCustomCell(GetTypeInfo(MyCustomCell))

Acceder a los controles de una iOSCustomTableCell

Ahora bien, al ejecutar la anterior línea de código obtendremos una variable que apunta a una instancia de iOSTableCellData… y eso significa que no podríamos acceder a los controles específicos que hubiésemos definido sobre nuestra clase iOSCustomTableCell. ¿Cómo solucionamos el problema? La respuesta está en la proyección de clases (o Cast).

La proyección de clases consiste en indicar al compilador que deseamos utilizar una instancia de una clase determinada como si fuese de otra. Esto supone un riesgo importante en tiempo de ejecución si no estamos seguros de que la clase sobre la cual deseamos realizar la proyección “encierra” en realida la estructura de objeto correspondiente a la clase sobre la que deseamos trabajar.

En este caso nosotros sabemos con certeza el nombre de las clases que hemos definido como iOSCustomTableCell, y que, de hecho, hemos utilizado su Información de Tipo para generar una instancia de iOSTableCellData. Por tanto, no ningún problema en realizar la proyección de clase y almacenar el resultado en una nueva variable, ahora sí, como una instancia de la celda de personalizada que hemos creado. Para ello, hemos de realizar el cast sobre el objeto apuntado por la popiedad Control de la instancia iOSTableCellData:

dim CustomCell as MyCustomCell = MyCustomCell(cell.Control)

A partir de aquí ya utilizaríamos nuestro objeto DataSource en combinación con los controles embebidos en la instancia de nuestra celda personalizada, apuntada por la variable “CustomCell” en este ejemplo, para actualizar toda la información que deseemos dibujar en la celda ¡y listo!

Una vez finalizado, sólo tendremos que devolver el resultado con un sencillo:

return cell

¿Tienes dudas sobre cualquiera de los términos utilizados en este tutorial? Recuerda que en el eBook “Programación Multiplataforma Xojo” se explica esto y mucho más ¡desde cero! para que aprendas a crear programas multiplataforma con el lenguaje de programación Xojo a tu ritmo y sin conocimientos previos de programación.

The post Tablas en iOS: celdas con iOSCustomTableCell appeared first on AprendeXojo.

Ubicación iOS en Xojo con iOSLocation

$
0
0

iOSLocation for iOS with XojoEn un tutorial anterior mostraba como crear y utilizar las celdas personalizadas en las tablas de las aplicaciones nativas iOS creadas con Xojo; una de las novedades introducidas en Xojo 2016r2. En esta ocasión veremos cuan sencillo nos resulta añadir capacidades de ubicación en tiempo real utilizando el control iOSLocation, otra de las novedades disponibles en esta misma release del producto.

Para ver como podemos aplicarlo crearemos una aplicación de ejemplo iOS tremendamente sencilla, para lo cual necesitarás crear un nuevo proyecto iOS —disponible en las licencia de Xojo para iOS, Xojo Pro y Xojo Enterprise—. De hecho, sólo utilizaremos una jerarquía de vista, la disponible de serie en la propia plantilla de proyecto por omisión.

Sobre dicha plantilla, y seleccionando la vista por omisión, añadiremos una serie de etiquetas: a la izquierda bastará con incluir el texto descriptivo del dato de localización que van a mostrar, y a su derecha las etiquetas sobre las que mostraremos los valores propiamente dichos. El resultado del diseño de este ejemplo es el siguiente, si bien puedes acomodarlo a tus necesidades:

Diseño de aplicación iOS de ejemplo con iOSLocation

Eso sí, utiliza el panel Inspector sobre cada una de las etiquetas que mostrarán los datos de localización para que tengan nombres descriptivos, de modo que posteriormente podamos referirnos a dichos controles desde código con mayor sencillez. Puedes usar por ejemplo una nomenclatura similar a esta:

Asignación de nombre en etiqueta para ejemplo iOSLocation.

Control iOSLocation

Evidentemente es más que probable que tus diseños sean más complejos, no importa. Viendo lo sencillo que resulta añadir y activar el componente de localización podrás adaptarlo sin ningún tipo de problema a cualquier clase de aplicación que necesites crear con Xojo para iOS.

Control iOSLocation en el Panel Librería del IDE de Xojo.

De hecho, tan fácil como arrastrar el control iOSLocation desde el panel Librería del IDE de Xojo hacia el Editor de Vista en el Editor. Este se añadirá sobre la bandeja (la franja en la parte inferior).

Instancia de iOSLocation añadida a la Bandeja del Editor de Vistas.

Una vez añadido al proyecto, selecciona la instancia en el Navegador de Proyecto y accede al menú contextual para seleccionar la opción ‘Add to “NombreControl” Event Handler…’, y en el panel resultante has de seleccionar los eventos correspondientes a LocationChanged y AuthorizationChanged, confirmando la acción.

Selección de Manejadores de Eventos para iOSLocation.

Como ya habrás supuesto, la ubicación del evento LocationChanged es bastante obvia; este es el que se dispara cada vez que el control ha de notificarnos de nuevos cambios en los valores de localización. De heho, al examinar la signatura del evento observamos que nos pasa como argumentos las variables que almacenan los valores correspondientes a latitud, longitud, precisión, altitud, precisión en la altitud, grados sobre el Norte real y también la velocidad como metros por segundo (la fórmula para pasar a Km/h es realmente sencilla). En definitiva, toda la información de utilidad que puedas necesitar para crear aplicaciones complejas basadas en la localización del dispositivo.

Selecciona el evento LocationChanged y añade el siguiente código, teniendo en cuenta que tendrás que cambiar el nombre de los controles de etiqueta que hayas utilizado en tu diseño para mostrar los valores:

lAltitud.Text = altitude.ToText
lLatitud.Text = latitude.ToText
lLongitud.Text = longitude.ToText
lGrados.Text = course.ToText

dim velocidad as double = (speed / 1000) * 3600

lVelocidad.Text = velocidad.ToText + " Km/h"

Activar iOSLocation

Ahora bien, si ejecutas la aplicación iOS en el simulador comprobarás que no se actualizan los valores incluso cuando eliges cualquiera de las opciones disponibles bajo el menú Debug > Location. Esto se debe a que todas las aplicaciones que utilicen los servicios de Ubicación en iOS han de solicitar previamente autorización al usuario. Y esto es de lo que nos vamos a encargar ahora.

Empezaremos por introducir el código en el segundo de los eventos que añadimos en el paso anterior: AuthorizationChanged. Este es el evento que se dispara en la instancia de iOSLocation cada vez que se produzca algún cambio en el estado de autorización asociado.

Selecciona por tanto el evento AuthorizationChanged para acceder al Editor de Código e introduce la siguiente línea:

if me.AuthorizationState = iOSLocation.AuthorizationStates.AuthorizedWhenInUse then me.Enabled = true

En la documentación de Xojo podrás comprobar que AuthorizationStates es un enumerador que incluye también Restricted, Denied o AuthorizedAlways, entre otras. Como puedes ver, si el valor disponible es AuthorizedWhenInUse, entonces se activa el control propiamente dicho para que comience a recibir e interceptar los cambios en los valores de ubicación.

Ahora nos hace falta el código que solicite la autorización propiamente dicha y que produzca la ejecución del anterior evento en base a la respuesta realizada por el usuario de la aplicación. Esto es lo que incluiremos en el evento Open que has de añadir a la vista por omisión del proyecto. Una vez añadido, selecciónalo e introduce el siguiente código:

Location1.Accuracy = iOSLocation.Accuracies.Best
if Location1.AuthorizationState = iOSLocation.AuthorizationStates.AuthorizedWhenInUse then
Location1.Enabled = True
else
location1.RequestInUseAuthorization
end if

En la primera línea simplemente nos limitamos a establecer la frecuencia con la que deseamos recibir los cambios de ubicación; nuevamente se trata de un enumerador cuyos valores puedes constatar en la documentación de Xojo. Simplemente indicar que la opción ‘Best’ suele ser la mejor relación entre frecuencia de actualizaciones, precisión y consumo de la batería en el dispositivo. De hecho esto es algo que has de tener en cuenta a la hora de diseñar aplicaciones iOS en las que se utilicen servicios de ubicación.

En el bloque de decisión “if” comprobamos en un primer lugar si nuestra aplicación ya cuenta con la autorización necesaria, en cuyo caso nos limitamos a activarla sin más para comenzar a recibir los datos periódicos correspondientes a los cambios en la ubicación.

Si nunca antes se ha solicitado autorización o si esta ha sido denegada en anteriores ejecuciones, entonces se ejecutará el segundo bloque, siendo el método RequestInUseAuthorization el encargado de mostrar el diálogo pertinente al usuario.

Archivo .plist para la autorización

¡Falta un último detalle! Un archivo Plist que contenga el texto (mensaje) a mostrar, bajo la clave NSLocationWhenInUseUsageDescription por el diálogo encargado de solicitar permiso para utilizar los servicios de ubicación en nuestra aplicación iOS. Para ello puedes utilizar la siguiente plantilla, guardándolo como archivo de texto con extensión “.plist” e importando el archivo resultante al proyecto de Xojo.

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
<key>NSLocationWhenInUseUsageDescription</key>
<string>Esta app necesita acceso a los servicios de Ubicación para su funcionamiento.</string>
</dict>
</plist>

¡Listo! Ejecuta la aplicación (recuerda que has de tener instalado Xcode en tu equipo) en el simulador o bien sobre un dispositivo físico y comienza a ver como se actualizan los valores de localización. Por ejemplo, en el Simulador de iOS puedes seleccionar Debug > Location > City Bicycle Ride.

The post Ubicación iOS en Xojo con iOSLocation appeared first on AprendeXojo.

Desplegar aplicaciones Web Xojo en NAS Synology

$
0
0

Synology ServerEl despligue de aplicaciones Web es uno de los temas que suscitan más preguntas por parte de quienes han de realizar el proceso por primera vez; y si bien en una entrada anterior ya se indicaba como desplegar las aplicaciones web bajo servidor Linux (algo en lo que ahondaremos en próximas entradas), en esta veremos como podemos hacerlo en los servidores NAS Synology.

Los servidores NAS Synology son tremendamente versátiles, al proporcionar en un único conjunto no sólo las capacidades de almacenamiento en red sino también una serie de servicios realmente interesantes para nosotros como desarrolladores, desde el servidor Git hasta la capacidad de servir bases de datos MariaDB/MySQL, e incluso nuestros propios sitios web.

Además, también es posible utilizarlos para servir nuestras aplicaciones Web creadas con Xojo… siempre y cuando no utilicemos una release posterior a Xojo 2014r3.2.

Preparar el producto Web

Para desplegar las aplicaciones web creadas con Xojo en servidores Synology has de tener en cuenta que sólo es posible en aquellos modelos del NAS que utilicen procesadores Intel, algo que puedes comprobar fácilmente consultando las características técnicas de los diferentes modelos. Por ejemplo, el Synology DS415 utiliza procesador Intel. Adicionalmente, todos los servidores Synology que utilicen sistema operativo Linux también son compatibles con el despliegue de aplicaciones web Xojo.

Lo anterior ya nos da dos pistas fundamentales sobre las opciones de compilación que hemos de elegir para realizar el despliegue sobre estos dispositivos: Linux e Intel de 32 bits. Sin embargo existe una limitación fundamental sobre la versión de Xojo que podrás utilizar a la hora de crear y preparar el desplegable, y por tanto sobre las capacidades y características que puedes emplear en el desarrollo de tu aplicación Web.

No podrás utilizar Xojo 2015 y posteriores, dado que con la primera Release de Xojo 2015 las aplicaciones web precisan que la librería LibICU esté presente en el sistema operativo Linux de destino; y no es el caso en los servidores Synology. Esto también es lo que limita los despliegues a la arquitectura de 32 bits de Intel, puesto que las releases de 2014 y anteriores no pueden compilar para 64 bits.

Teniendo lo anterior en cuenta, la creación del producto en Xojo y el despliegue son realmente sencillos. Del lado del IDE sólo has de asegurarte de marcar Linux como plataforma de destino en el apartado Build Settings del Navegador de Proyecto. Posteriormente selecciona el elemento Shared bajo el mismo apartado y, en el Panel Inspector, asegúrate de elegir “Stand Alone” en el apartado “Deployment Type”, así como el puerto en el que nuestra aplicación web debe de escuchar las peticiones del usuario.

Ajustes de despliegue Stand Alone para aplicación Web Xojo.

Hay que tener en cuenta que si se elige el puerto 80 indicado por omisión, entonces entrará en conflicto con cualquier otra opción de servidor (Apache) que pueda estar activada en el Synology. Si no es el caso, entonces todas las peticiones HTTP aceptadas por el servidor Synology se tramitarán a través del puerto 80 estándar y, por tanto, serán recibidas por la aplicación Web.

Adicionalmente, asegúrate de que el evento Open del objeto App incluya la siguiente línea:

Call Daemonize

De este modo, una vez que ejecutes la aplicación web desde el servidor Synology no será preciso que mantengas abierta la sesión de terminal (Shell) o la sesión SSH, en función de cuál de las dos vías hayas utilizado para acceder al servidor.

Copiar los archivos al servidor Synology

Si se tienen activados los servicios de archivos compartidos para OS X y/o Windows en el NAS Synology, entonces la copia de los archivos es algo tan sencillo como arrastrar la carpeta que contiene el ejecutable, las librerías y recursos desde su ubicación original hacia la carpeta de destino en el Synology.

Opciones de Archivos para OS X y Windows en Synology

 

Este proceso de copia debería de respetar los privilegios de los archivos esenciales; es decir, tanto el ejecutable propiamente dicho como las librerías guardadas en la carpeta “nombre-aplicacion Libs”, Esto mismo también es válido en el caso de utilizar un cliente FTP moderno, capaz de conmutar entre los modos de transferencia Binario y ASCII en función de cual sea el tipo de archivo a transferir.

Ejecutar y acceder a la app en Synology

Una vez copiados los archivos, es preciso habilitar el acceso por SSH en el NAS Synology, de modo que se pueda poner en funcionamiento la aplicación propiamente dicha. Esto es algo que s epuede hacer en

Habilitar Servicio SSH en Synolgy.

Por último, sólo restará abrir una ventana de terminal para establecer una sesión SSH con el NAS Synology, navegar hasta el directorio que contiene la aplicación en cuestión y ejecutarla; utilizando generalmente la sintaxis:

> ./miAplicacion

Si se ha utilizado “Call Daemonize” en el evento Open de la aplicación Web Xojo, entonces se ejecutará en segundo plano devolviendo el símbolo del cursor. Esto nos permitirá finalizar la sesión SSH y salir del terminal al tiempo que se mantiene la ejecución de la aplicación.

Ejecución de aplicación Xojo Web desde NAS Synology.

Ahora, al abrir una ventana del navegador sólo tendremos que introducir la dirección IP del NAS Synology en combinación con el puerto que hayamos indicado para nuestra aplicación y esta responderá a las peticiones.

The post Desplegar aplicaciones Web Xojo en NAS Synology appeared first on AprendeXojo.


Desplegar apps Web en Linux: CGI y Standalone

$
0
0

En una entrada anterior ya vimos de qué forma tan sencilla se pueden desplegar las aplicaciones web Standalone creadas con Xojo sobre servidores NAS Synology. Esta entrada se centra en el despliegue de las aplicaciones bajo servidor Apache como CGI, y también como aplicaciones autónomas (Standalone). En ambos casos bajo Linux.

Si bien el tutorial utiliza una distribución Ubuntu 14.x de Linux de 64 bits, y la aplicación web de ejemplo utilizada en el tutorial también se compila en modo de 64 bits, lo expuesto en el vídeo es perfectamente válido para el resto de las distribuciones Linux soportadas por Xojo, tanto en ejecutables de 32 como de 64 bits. En el caso de las aplicaciones Web compiladas en Xojo en modo de 32 bits, es preciso asegurarse previamente de que estén correctamente instaladas las librerías requeridas y que se pueden encontrar en este enlace.

Por lo demás, como puedes comprobar en el vídeo, es una simple cuestión básicamente de que los archivos ejecutables generados por Xojo cuenten con los privilegios correctos una vez que se pasan al servidor Linux, para lo cual puedes utilizar cualquier cliente FTP de tu elección.

En el caso del despliegue de aplicaciones web en modo CGI has de asegurarte, eso sí, de que esté correctamente configurado el servidor Apache; por lo demás, sólo resta copiar los archivos a la ubicación esperada en el archivo de configuración de Apache (por lo general es cgi-bin), ¡y listo!

The post Desplegar apps Web en Linux: CGI y Standalone appeared first on AprendeXojo.

Como comenzar con Xojo

$
0
0

Editor de Xojo

Si eres un recién llegado a Xojo, o incluso a la programación por completo, entonces hay una ampia variedad de caminos que te permitirán avanzar con rapidez.

Puedes utilizar Xojo de forma gratuita para desarrollar, realizar pruebas y depurar. Para comenzar:

  1. Descarga Xojo
  2. Ejecuta Xojo e Ingresa utilizando tu Xojo ID (es decir, el nombre de usuario y contraseña creados en Xojo.com)

Si tienes alguna duda sobre cómo utilizar estos recursos, envía un email (asegurándote de incluir tu Xojo ID) a hello@xojo.com

Guías

Si prefieres leer, entonces deberías de comenzar con las Guías de Inicio Rápido, las cuales te proporcionarán un vistazo general rápido de la interfaz de usuario de Xojo y también de cómo crear una aplicación simple funcional. Deberías de poder realizar cada una de estas Guías de Inicio Rápido en 30 minutos o menos. Incluso si estás familiarizado con otras herramientas de desarrollo, te animo a que tomes el tiempo necesario para realizar como mínimo una Guía Rápida de modo que estés más familiarizado con el modo en el que funciona Xojo.

Una vez las hayas completado, puedes continuar con el Tutorial, el cual te muestra como crear una app ligeramente más sofisticada con más código. Podrás completar cada Tutorial en aproximadamente una hora.

A continuación deberías de proseguir con el libro en español Programación Multiplataforma Xojo. Repletos de ejemplos, el completar este libro te proporcionará un conocimiento funcional sobre los fundamentos de la programación; y si bien estarás utilizando Xojo, los conceptos presentados en dicho libro también se pueden aplicar a cualquier otro lenguaje que desees aprender.

Puedes finalizar tu viaje para descubrir Xojo mediante la lectura de los cuatro libros que conforman la Guía del Usuario:

  • Fundamentos. Cubre el IDE de Xojo, sus editores, los conceptos del lenguaje de programación y la programación orientada a objetos.
  • Interfaz del Usuario Cubre los controles de interfaz de usuario usados por los proyectos iOS, de Escritorio y Web.
  • Framework Cubre el framework “Clásico”, incluyendo temas como los archivos, textos, gráficos, bases de datos, redes y más. Además, también incluye temas sobre depuración y perfilado, así como temas sobre la migración al nuevo framework de Xojo.
  • Despliegue Cubre aspectos relacionados con el despliegue específico sobre cada una de las plataformas para OS X, Windows y Raspberry Pi.
  • Información Técnica Cubre temas relacionados con el control de código fuente, la migración desde otras herramientas (como FileMaker, Visual Basic y FoxPro), etc.

Vídeos

Si eres más el tipo de persona que le gusta la práctica, entonces puedes ver cualquiera de los vídeos publicados en las siguientes categorías, y que están disponibles en español.

  • Bases de Datos
  • Web
  • Desktop
  • iOS
  • OOP
  • IDE de Xojo

La cantidad de vídeos crece semanalmente, abarcando los temas que suelen generar más dudas a quienes empiezan a crear sus aplicaciones con Xojo. Estos vídeos se corresponden con los diferentes tutoriales publicados, de hecho, en AprendeXojo.com; de modo que sólo tienes que navegar por las entradas para encontrar los textos y vídeos que explican de forma práctica, sencilla y ágil diferentes aspectos relacionados con la programación en Xojo.

¿Tienes dudas?

El mejor lugar para plantear tus preguntas es el Foro de Xojo en Español. Este foro no es como cualquier otro que hayas podido visitar. En Xojo creemos verdaderamente en que nuestra comunidad es nuestro gran recurso. El Foro de Xojo está repleto de usuarios realmente activos y dispuestos a ayudar, además de los propios ingenieros de Xojo quienes responden dudas todo el tiempo. Una búsqueda rápida suele proporcionar generalmente una buena cantidad de soluciones a preguntas frecuentes, de modo que asegúrate de echar un vistazo antes de publicar tu duda… ¡porque es probable que alguien la haya contestado ya con anterioridad!

Ingresa en el foro utilizando tu Xojo ID y publica tu pregunta en el “canal” (es decir, tema) apropiado.

¿Como puedo aprender más?

Utiliza la Búsqueda en el Xojo Dev Center para encontrar más información sobre tus temas de interés. Es probable que también quieras buscar en el Wiki de Xojo para obtener más información sobre el framework clásico utilizado por las apps Desktop y Web.

Regístrate en los webinars Xojo para proseguir con tu aprendizaje. Y asegúrate de echar un vistazo a los más de 60 webinars ya grabados y que están disponibles en la sección de Vídeos. ¿Quieres sugerir algún tema para un Webinar? Asegúrate de enviar un correo a paul@xojo.com.

El Blog de Xojo es un buen lugar para conocer trucos, consejos e información sobre Xojo; al igual que también lo es este mismo sitio, el blog de AprendeXojo, en español, donde encontrarás completos tutoriales, artículos y todo tipo de información sobre Xojo.

También puedes suscribirte a la xDev Magazine, la cual publica seis números cada año, cada uno de ellos con unas 80 páginas de contenido sobre Xojo. xDev se publica desde 2002 y dispone de una gran colección de números atrasados.

Para una compresión más profunda de los conceptos de programación, es probable que quieras realizar el curso Standford Programming Methodology course en iTunes U. Este es un curso gratuito con una duración de 21 horas sobre diversos conceptos de programación, incluyendo: diseño orientado a objetos, descomposición, encapsulación, abstracción y testing.

Quiero crear mi app, ¿ahora qué?

Necesitarás comprar una licencia para compilar tus apps y compartirlas con otros. Las licencias parten desde los $99, y pueden comprarse en la Xojo Store. Una licencia Xojo te proporciona acceso a las nuevas revisiones de Xojo durante un periodo de 12 meses. Una vez que tu licencia Xojo expire, podrás seguir compilando con todas las releases publicadas durante ese periodo de 12 meses, de forma indefinida. Jamás estarás obligado a renovar tu licencia Xojo y puedes hacerlo en cualquier momento, ya sea antes o después de que expire.

¿Necesitas ayuda?

Por último, si quieres dar un empujón en tu formación Xojo o necesitas ayuda para llevar a cabo un proyecto, no lo dudes y ponte en contacto conmigo. Si lo que deseas es aprender, entonces comprobarás como en unas pocas horas de formación personalizada lograrás unos resultados realmente notables. Y si requieres de ayuda y colaboración para crear una aplicación desde cero o avanzar en un proyecto en curso, entonces también te animo a que contactes conmigo y compruebes la calidad del trabajo y nivel de colaboración. ¡Tu proyecto es lo primero!

The post Como comenzar con Xojo appeared first on AprendeXojo.

Tutorial iOS: Crear un acortador de URL

$
0
0

Acortar URLEn este tutorial vamos a ver cuan sencillo resulta crear una app iOS que sea un acortador de URLs utilizando la API pública de Bit.ly; y empleando para ello nuestra propia subclase heredada de Xojo.Net.HTTPSocket, así como la instrucción Declare mediante la cual podemos realizar llamadas directas a las API de Cocoa Touch en este caso.De hecho, el uso de los Declare es fundamental aquí dado que contamos únicamente con el conjunto de clases y funciones disponibles en el nuevo Framework de Xojo, lo que significa que no podemos emplear por ejemplo la función EncodeURLComponent disponible en el antiguo framework, y que resulta imprescindible a la hora de sustituir los caracteres no permitidos en la formación de los URL por su valor equivalente en notación hexadecimal.

Además, también utilizaremos la instrucción Declare para acceder al Portapapeles general de iOS de modo que podamos copiar sobre él el URL acortado por nuestra aplicación, para que pueda utilizarse en el resto de aplicaciones instaladas sobre el dispositivo.

Eso sí, antes de empezar asegúrate de que tienes instalado Xcode en tu Mac, dado que es imprescindible para que puedas ejecutar la aplicación sobre el Simulador de iOS (Xcode es gratuito y se puede descargar desde la Mac App Store). También has de contar con tu propia clave OAuth general, empleada a la hora de acceder a los métodos expuestos por la API web de Bit.ly, y que has de generar creando una cuenta en el servicio Bit.ly. Es un proceso sumamente sencillo y que puedes realizar desde este enlace.

Por supuesto, si quieres seguir el tutorial también has de tener instalado Xojo en tu Mac. Recuerda que siempre puedes descargar y utilizar de forma gratuita la versión más reciente de Xojo desde este enlace.

Con estos requisitos cumplidos, ¡es el momento de ponernos en marcha!

Diseñar la Interfaz iOS

Ejecuta Xojo y en el Selector de Aplicaciones, elige la plantilla para crear una nueva aplicación iOS. Como resultado, se abrirá el IDE presentando todos los elementos que permiten tener una aplicación completamente funcional. De hecho, si pulsas el botón de ejecutar, esta se ejecutará sin ningún problema utilizando el propio Simulador de Xcode. Eso sí, no hará nada puesto que carece de funcionalidad real.

Selecciona el elemento View1 en el Navegador de Proyecto (la columna vertical situada a la izquierda de la ventana del IDE). Dicha acción presentará como resultado la Vista añadida por omisión al proyecto en el Editor de Plantillas. A continuación, pulsa sobre el botón Library, lo cual te permitirá obtener un vistazo de todos los objetos (componentes) gráficos disponibles a la hora de crear una interfaz de usuario para tu app iOS, tal y como se muestra en la siguiente imagen.

Componentes gráficos para crear Interfaz de Usuario en apps iOS.

Componentes gráficos para crear Interfaz de Usuario en apps iOS.

Arrastra el control TextField (lo encontrarás en el apartado Inputs) desde la Librería sobre la parte superior de la vista mostrada en el editor de plantillas. Puedes utilizar el apuntador y las guías para ajustar su posición y tamaño de modo que quede de forma similar a como se presenta en la siguiente imagen.

Campo de Texto añadido a la vista del proyecto iOS.

Campo de Texto añadido a la vista del proyecto iOS.

Selecciona el TextField recién añadido y pulsa sobre el botón Inspector para acceder al panel que presenta las propiedades asociadas. Aquí, por ejemplo, podemos cambiar atributos como su nombre (el que emplearemos para referirnos al control desde el código), el color del texto, etc. En concreto, utiliza los siguientes valores:

  • Name: txtURL
  • KeyboardType: URL
  • PlaceHolder: http://
  • Text: http://

Añade a continuación un botón (Button) desde la Librería y sitúalo justo al costado derecho del campo de texto añadido en el paso anterior. Utiliza los manejadores del control para ajustar su tamaño, y pulsa sobre el icono con imagen de lápiz para modificar el texto de la etiqueta mostrada por el de “Go!”, tal y como se muestra en la siguiente imagen.

BotonGo

Aprovecharemos para que nuestra app muestre la página web correspondiente al URL utilizado, y para ello utilizaremos el componente HTMLViewer que puedes añadir también a la vista arrastrándolo desde la Librería y ajustando su posición tal y como se muestra en la siguiente imagen.

HTMLViewer

Por último, añadiremos un par de etiquetas de texto (Label) y un botón adicional (Button) en la franja inferior de la Vista. Estas serán las etiquetas encargadas de mostrar el URL acortado y el botón será el encargado de copiarlo al Portapapeles general de iOS en el dispositivo. Para ello, arrastra dichos controles desde la Librería, ajustando sus tamaños y posición tal y como se muestra en la siguiente imagen:

ShortenedArea

Selecciona la etiqueta central, que utilizaremos para mostrar el URL acortado, y cambia los siguientes valores en el Panel Inspector asociado:

  • Name: lblShortURL
  • Text: (vacío)

Con esto hemos completado el diseño de la interfaz de usuario de la aplicación. De hecho puedes pulsar sobre el botón Run del IDE de Xojo para ejecutarla sobre el Simulador de Xojo. Comprobarás que es totalmente funcional, pero que no hace nada de interés puesto que aun no hemos escrito ni una sola línea de código.

SimuladorVuelve al IDE de Xojo, detén la ejecución de la aplicación y vamos a encargarnos de la lógica de la aplicación escribiendo para ello la clase encargada de comunicar con la API de Bit.ly.

Comunicar con la API de Bit.ly

Es el momento de crear nuestra clase de comunicación la API de Bit.ly. Es decir, la responsable de realizar la petición web (vía protocolo HTTP) al método expuesto por la API remota y también de recibir los resultados. Y cuando se trata de comunicaciones web en las que deseamos trabajar con la respuesta recibida debemos de utilizar una subclase derivada de la clase Xojo.Net.HTTPSocket, dado que es en nuestra subclase donde añadiremos el comportamiento específico sobre el encontrado en la clase base.

Selecciona Insert > Class para añadir una nueva clase al proyecto. En el Navegador de Proyecto, selecciona la clase recién añadida para acceder al Panel Inspector asociado y cambia los siguientes parámetros:

  • Name: BITLYSocket
  • Super: Xojo.Net.HTTPSocket

A continuación pulsa sobre el icono ‘+’ de la barra de herramientas del IDE y elige la opción Event Handler, tal y como se muestra en la siguiente imagen:

SocketEventHandler

En la ventana resultante, selecciona el evento PageReceived y pulsa OK. La acción presentará el evento recién añadido bajo el apartado Event Handlers de nuestra clase BITLYSocket. En concreto, este es el evento que se disparará y cuyo código se ejecutará cada vez que nuestro socket reciba datos como resultado de nuestras petiticiones HTTP.

Introduce el siguiente código en el Editor de Código asociado con dicho manejador de evento:

if HTTPStatus = 200 then
dim data as Dictionary = xojo.data.ParseJSON( xojo.core.TextEncoding.UTF8.ConvertDataToText(content))
dim dataurl as Dictionary = data.Value("data")

raiseevent URLShortened(dataurl.Value("url"))
end

Lo primero que comprobamos es el código de estado devuelto para ver si el resultado a nuestra petición es correcto (200). A continuación asiganamos a la variable de diccionario ‘data’ el resultado de parsear los datos devueltos a nuestra petición en formato JSON.

La tercera línea es la encargad de crear una nueva variable de diccionario, ‘dataurl’, a la cual se asigna el contenido en el que realmente estamos interesados, y al cual podemos acceder utilizando la clave “data”. Por último, lanzamos un nuevo evento sobre nuestra propia clase (no definido aún, lo haremos a continuación), pasando como parámetro el URL acortado que podemos obtener utilizando la clave “url” sobre el diccionario “dataurl”.

Ten en cuenta que estas claves se corresponden a la estructura de los datos devueltos en el bloque JSON proporcionado por Bit.ly, cuya estructura está documentada y puedes consultar en el sitio web de la API para cada uno de los métodos soportados.

Para añadir un nuevo evento a nuestra clase, vuelve a pulsar el botón ‘+’ en la barra de herramientas, eligiendo en esta ocasión la opción de menú Event Definition, tal y como se muestra en la siguiente imagen:

SocketEventDefinition

A diferencia de lo que ocurre con los métodos, la definición de eventos sólo permite indicar su signatura. Es decir, el nombre del evento creado así como la cantidad, nombre y tipo de los parámetros recibidos y el tipo devuelto (si procede). Después de todo, la implementación del código será independiente y, por lo general, única para cada uno de los “consumidores” de la clase; es decir, las instancias u objetos creados a partir de la clase que decidan implementar dicho evento.

En nuestro caso, el evento recién añadido será el responsable de pasar al consumidor de la clase el URL acortado (tal y como hemos visto en el código anterior) para que este decida qué quiere hacer con él. En nuestra aplicación, asignarlo al atributo de texto de la etiqueta central en la parte inferior de nuestra interfaz de usuario.

Selecciona el evento recién añadido para acceder al Panel Inspector asociado y modifica los siguientes atributos:

  • Event Name: URLShortened
  • Parameters: URL as Text

Realizar la petición HTTP en iOS

Con la clase BITLYSocket aun seleccionada, es el momento de añadir un nuevo método que nos servirá como punto de entrada para que el consumidor de la clase nos indique qué URL desea acortar. Para ello, vuelve a pulsar sobre el botón “+” de la barra de herramientas del IDE, seleccionando en esta ocasión la opción Method del menú.

SocketMethod

Utiliza los siguientes valores en el Panel Inspector asociado:

  • Method Name: ShortURL
  • Parameters: URL as Text

E introduce el siguiente código en el Editor de Código asociado con el método recién creado:

Declare Function CFURLCreateStringByAddingPercentEscapes lib "Foundation" (allocator as Ptr, origString as CFStringRef , charactersToLeaveUnescaped as CFStringRef , legalURLCharactersToBeEscaped as cfStringRef,encoding as uint32) as CFStringRef

dim encodedURL as text = CFURLCreateStringByAddingPercentEscapes(nil,url,nil,nil,&h08000100)

dim compossedURL as text = "https://api-ssl.bitly.com/v3/shorten?access_token="+kToken+"&longUrl="+encodedURL

me.Send("GET", compossedURL)

Aquí nos encontramos con el primer Declare. En concreto es el que nos permite llamar a la función CFURLCreateStringByAddingPercentEscapes para sustituir los caracteres no permitidos en URL por su valor de escape correspondiente, tarea que hacemos precisamente en la segunda línea del código llamando a dicha función y guardando el resultado en la variable encodedURL.

La tercera línea es donde componemos el URL para llamara a la API de Bit.ly, pasando nuestra clave OAuth general (representada aquí mediante la constante kToken (crea tu propia constante en la clase y asigna el valor), y añadiendo en la parte final de la cadena la variable con el URL a acortar debidamente tratado con los caracteres de escape.

Por último, la petición propiamente dicha se realiza utilizando el método Send de la clase HTTPSocket, donde el primer parámetro se corresponde con el método que deseamos utilizar (“GET”, en este caso), y el segundo parámetro es el URL de la petición HTTP.

Con esto, ¡hemos completado la definición de nuestra clase!

¡Poniendo todo en marcha!

Tan solo quedan los detalles, y el primero es añadir una instancia (objeto de clase) de nuestra recién creada clase. Para ello vuelve a seleccionar el objeto View1 en el editor de plantillas y, a continuación, arrastra el icono de nuestra clase BITLYSocket desde el Navegador de Proyecto hacia la parte inferior del Editor de Plantillas. Al soltar verás que se habrá creado una nueva instancia BITLYSocket1 y que, de hecho, también figura bajo la jerarquía Controls de la Vista “View1″.

Selecciona precisamente la instancia BITLYSocket1 bajo Controls en View1 y accede al menú para añadir un nuevo Manejador de Evento. Verás que ahora también figura en el listado el evento creado por nosotros. Selecciónalo y confirma para que se añada sobre la instancia.

BITLYSocketEvent

En el Editor de Código resultante, introduce la siguiente línea:

lblShortURL.Text = url

De esta forma estaremos asignando a la propiedad Text de la etiqueta el texto recibido como resultado de nuestra petición a la API de Bit.ly; en definitiva, el URL acortado.

Pero para que este evento llegue a dispararse en algún momento, lo primero que tenemos que realizar es la petición propiamente dicha. Selecciona el botón Button1, añade el Manejador de Evento Action (este es el que se dispara cuando se pulsa sobre él), e introduce el siguiente código:

  HTMLViewer1.LoadURL(txtURL.Text)
  
  BITLYSocket1.shortURL(txtURL.Text)

En primer lugar cargamos la página web correspondiente al URL introducido y, en la segunda línea de código, invocamos el método ShortURL pasando como parámetro el URL introducido por el usuario en el campo de texto. ¡Esta línea de código es lo que pone en marcha el funcionamiento de nuestro socket de comunicación!

Prueba a ejecutar el proyecto e introducir un URL. ¡Verás como se carga la página web correspondiente y se muestra el URL acortado en la parte inferior de la interfaz!

AppWorkingCopiar al Portapapeles

Queda un último detalle. Si pulsas sobre el botón Copy… simplemente no hace nada, puesto que no hemos añadido ningún evento de acción.

Selecciona el elemento Button2 en el Navegador de Proyecto y añade el Manejador de Evento Action, escribiendo el siguiente código en el Editor de Código asociado:

declare sub setValue lib "UIKit" selector "setValue:forPasteboardType:" (obj_id as ptr, value as ptr, pasteboardType as CFStringRef)
declare function generalPasteboard lib "UIKIt" selector "generalPasteboard" (clsRef as ptr) as ptr
declare function NSClassFromString lib "Foundation" (clsName as cfstringref) as ptr
declare function stringWithString lib "Foundation" selector "stringWithString:" (clsRef as ptr, str as cfstringref) as ptr

setValue(generalPasteboard(NSClassFromString("UIPasteboard")), stringWithString(NSClassFromString("NSString"),lblShortURL.Text), "public.text")

Esta es la solución que te permite copiar el texto del URL acortado en el Portapepeles del sistema bajo iOS. Dicha solución, construida a base de Declare con llamadas a las API nativas Cocoa Touch y Foundation está extraída de este hilo del foro de Xojo.

Ahora, cuando pulses el botón Copy ya contarás con el URL acortado en el Portapapeles.

En definitiva, a lo largo de este tutorial hemos podido ver lo sencillo que resulta comunicar en nuestras apps iOS con API Web que devuelvan los datos en formato JSON; así como lo potente y útil que resulta la instrucción Declare para llamar a métodos y funciones específicos de los frameworks nativos desde nuestro código Xojo, capturando así aquellas capacidades que aun no están implementadas en el propio framework de Xojo.

The post Tutorial iOS: Crear un acortador de URL appeared first on AprendeXojo.

Disponible Xojo 2016r3

$
0
0

Xojo ha anunciado la disponibilida de una nueva revisión de la herramienta de programación multiplataforma, cargada de interesantes novedades y también de mejoras y soluciones de problemas detectados.Si bien puedes consultar el listado completo en las Notas de Revisión que acompañan a cada liberación del producto, me gustaría hacer hincapié en las que me parecen más relevantes.

La primera de ellas no es otra si no la capacidad de ajustar el nivel de optimización utilizado por el compilador de Xojo. Como seguramente ya sepas, Xojo destaca, entre otras muchas cualidades, por tratarse de una solución de desarrollo que produce como resultado final aplicaciones nativas con código compilado, y no interpretado o que deban de pasar por máquinas virtuales, tal y como es el caso de una amplia mayoría de lenguajes de programación. Por tanto, son aplicaciones más rápidas y también más seguras a la hora de ocultar el código en ejecución frente a fisgones que quieran examinar como funcionan nuestras aplicaciones.

Optimización del Compilador

Ahora, tanto en las aplicaciones de escritorio de 64 bits como en las desplegadas para iOS y Raspberry Pi podemos ajustar el nivel de optimización del compilador entre Agresivo o Moderado. Con el primero de ellos obtendremos aplicaciones aun más rápidas, especialmente las que realicen un uso intensivo de cálculos numéricos; mientras que la segunda consumirá menos tiempo de compilación, estará “menos optimizada” y será más conveniente para ciclos de compilación más cortos durante las fases de Depuración; especialmente adecuado si estamos trabajando con proyectos Xojo complejos compuestos por multitud de módulos, componentes gráficos, etc.

Opciones de Optimización del Compilador.

Opciones de Optimización del Compilador.

Refactorización de código

La segunda de las capacidades que llaman gratamente la atención son la correspondientes a la ampliación de características dirigidas a refactorizar nuestro código. Por ejemplo, el proceso para extraer las constantes permite ahora cambiar el nombre sugerido, así como el tipo, ámbito y valor. También se incluyen ahora las opciones “Wrap in #if false / #endif” y “Wrap in For Next” en el menú contextual del Editor de Código.

En esta misma área, también es destacable la sencillez con la que podemos crear ahora un nuevo evento (Definición de Evento) a partir de un evento ya existente; algo que es probable que queramos hacer cuando creamos una subclase y consumimos el evento en cuestión. Si bien anteriormente debíamos de definir el evento e introducir su signatura en el Panel Inspector (nombre, parámetros y tipo devuelto), ahora sólo hemos de acceder al menú contextual sobre el evento en cuestión para crear una nueva definición de evento a partir de él, manteniendo tanto el nombre como los parámetros y tipo devuelto.

Crear Definición de Evento a partir de un Evento consumido.

Crear Definición de Evento a partir de un Evento consumido.

Por otra parte, cuando ahora queramos extraer una nueva superclase a partir de una subclase, el IDE insertará una nueva clase entra la antigua superclase y la clase actual, facilitando así el trabajo. En esta misma línea, la opción “Extract Super” permite ahora extraer todo los “ítems de código”, incluyendo los métodos, las propiedades, constantes, delegados, enumeraciones, métodos externos, manejadores de menú, métodos compartidos, propiedades compartidas, estructuras y claúsulas “using”.

Crear subclase a partir del elemento seleccionado en la Librería.

Crear subclase a partir del elemento seleccionado en la Librería.

Y mientras que no puede considerarse una opción de refactorización propiamente dicha, también encuentro tremendamente útil la capacidad de crear una nueva subclase a partir de cualquiera de los elementos disponibles en la Librería con solo acceder al menú contextual sobre el elemento en cuestión.

Búsqueda completa de textos en SQLite

Xojo 2016r3 también incorpora una nueva actualización del motor de bases de datos SQLite utilizado a lo largo y ancho de todas las licencias disponibles, y ahora se corresponde con la versión v3.14.1; lo que significa que podremos utilizar FTS5 para la bísqueda de texto completo entre los registros (columnas) de cualquiera de las tablas de la base de datos. Si quieres saber por qué debérias de utilizar FTS5 a la hora de buscar texto en tus consultas SQL, te recomiendo que eches un vistazo a esta entrada publicada en el blog de Xojo. Y para ver los cambios y mejoras introducidos con FTS5, nada mejor que la documentación oficial de SQLite.

¡Librería ICU integrada en despliegues Linux!

Estoy convencido de que, así enunciado, probablemente no te diga mucho… pero lo que esto significa es que volvemos a ganar la capacidad de crear y desplegar nuestras aplicaciones Web autónomas (Standalone) sobre los servidores Synology compatibles (basados en Linux y procesadores Intel, por ejemplo).

Dicha capacidad se perdió en las releases posteriores a Xojo 2014r3.2, dado que en estos casos se dependía de la librería ICU instalada por cada una de las diferentes variaciones de los sistemas operativos Linux soportados. Sin embargo, en el caso de los servidores NAS Synology, el inconveniente es que no había una forma factible de compilar e instalar una versión compatible de la librería ICU en cuestión. Como resultado, no se podían ejecutar las aplicaciones web creadas con Xojo sobre dichos NAS.

Ahora Xojo vuelve a incluir de forma estática la librería ICU en las compilaciones de todas las aplicaciones generadas para Linux y, por tanto, esto no solo mejora la compatibilidad (uniformidad) a la hora de distribuir nuestras aplicaciones Linux entre todos los sabores o ediciones soportados, sino que también incumbe la capacidad de ejecutar las aplicaciones web sobre los mencionados servidores NAS; algo tremendamente conveniente no sólo para realizar pruebas in-house antes de desplegar sobre un servidor VPS más potente (por ejemplo), sino porque también permite instalar y ejecutar sobre dichos servidores apps que no requieran de más potencia, ofreciendo así servicios a clientes finales o como parte de una solución más compleja.

Esquemas de Color

Como ya sabes, una de las nuevas capacidades en Snippery 1.2 es la de crear, aplicar, exportar e importar Esquemas de Color. ¡Ahora también disponemos de esta posibilidad en el IDE de Xojo! Si bien hasta ahora podíamos modificar los colores correspondientes al fondo del Editor de Código, así como cada uno de los colores correspondientes a los diferentes elementos identificables del lenguaje, no había un modo sencillo de compartir dichos esquemas de color o bien variarlos por otros sin perderlos.

 

Anteriores opciones del Editor de Código de Xojo (Izquierda) y nuevas capacidades de Exportación (Derecha)

Anteriores opciones del Editor de Código de Xojo (Izquierda) y nuevas capacidades de Exportación (Derecha).

Mediante la nueva capacidad podemos generar tantos esquemas de color como deseemos y guardarlos en formato XML para su posterior importación. ¡Bien en aras de la personalización del IDE!

Ajustes para el Navegador en el IDE de Xojo.

Ajustes para el Navegador en el IDE de Xojo.

Precisamente, es en la ventana de Preferencias donde también encontramos un nuevo apartado, Navegador, en el que podemos ajustar diferentes comportamientos sobre el tipo de información a mostrar, además de sobre cómo mostrarlo.

En definitiva, si bien estos son sólo algunos de los cambios, la nueva revisión Xojo 2016r3 es un buen paso hacia delante; y esto y convencido de que en la XDC 2016 se producirán grandes anuncios también en esta dirección.

Si aún no la has descargado, puedes descargar y usar Xojo de forma gratuita desde aquí. Ten en cuenta que sólo necesitas de una licencia una vez que quieras compilar las aplicaciones para su distribución; entre tanto, puedes usarlo para aprender, ejecutar tus proyectos e incluso depurarlos utilizando el excelente depurador incluido en el IDE.

The post Disponible Xojo 2016r3 appeared first on AprendeXojo.

ListBox Desktop: Ordenar columnas

$
0
0

Ordenar ListBox en XojoEl control ListBox es uno de los más completos en su versión para aplicaciones Desktop (macOS, Windows y Linux) creadas con Xojo; y como probablemente ya sepas, dicho control incluye por omisión la capacidad de reordenar cualquiera de las columnas seleccionadas cuando se hace clic sobre sus encabezados (propiedad que puedes activar en el panel Inspector).

Ahora bien, por omisión Xojo realizará la ordenación de los elementos correspondientes a la columna pulsada atendiendo a su orden lexicográfico y no numérico; es decir, tratando los contenidos disponibles en cada una de las celdas de la columna como si fueran cadenas de texto, aunque estos se correspondan realmente con valores numéricos. Después de todo, cuando añades dichos valores a la columna… tendrás que hacerlo como si fueran texto.

Otras formas de ordenar un ListBox

La buena noticia es que Xojo proporciona para el control ListBox el evento CompareRows, y mediante su implementación podemos añadir nuestro propio sistema de comparación de valores.

Como parte de la signatura del evento, recibiremos las dos filas que se están comparando, así como la columna correspondiente y el resultado que, pasado por referencia, deberá contener el resultado de nuestra comparación personalizada:

  • -1 En el caso de que el valor de la primera celda sea inferior al de la segunda
  • 1 En el caso de que el valor de la primera celda sea superior al de la segunda
  • 0 Si ambos valores son idénticos

Por último, el evento debe devolver el valor booleano True si deseamos que el listado utilice nuestro resultado de comparación, o bien False si deseamos que se proceda a ordenar las filas atendiendo al orden lexicográfico utilizado por omisión.

En el siguiente vídeo puedes ver de qué modo tan sencillo puedes, por tanto, establecer que la columna de un ListBox ordene sus contenidos atendiendo a sus valores numéricos reales, ya sea de forma ascendente o descendente.

The post ListBox Desktop: Ordenar columnas appeared first on AprendeXojo.

Stamp 1.0.3 released!

$
0
0

Stamp received today a little update in order to fix a nasty bug related to the way it was blocking the automated logout process on macOS.

As probably you know, this was due to the fact that Stamp opens a final window showing the amount of characters you don’t have to type thanks to his functionality (and that offers you to buy the license in case you are running it in trial mode).

Well, that isn’t a problem when you’re the one who decided to exit the app using, probably, the Quit option from the file Menu; but it is a real pain in those cases where the Mac has to reset or power off, probably due to a software installation process or automated power off mode. In these cases, Stamp was interrupting the process due to that last window… sorry for that, I have to say that I has been the first one suffering from this problem (eating my own food, you know). But I hadn’t the time to fix the bug… until today!

Under the hood

The way to fix that problem is dealing with the macOS Events (aevt)! From the app execution point of view, this is not the same you closing the app that the macOS ordering every open app to close, because the System has something more important to do, as powering off or reseting the computer.

Xojo, the excellent multiplatform development tool I use on most of my apps, is really good by giving you access to all kind of events you can catch in order to put there the code to execute as response. And that is what I do, using the CancelClose event from the App object in order to decide the information and controls to show on that last window when closing the App.

But the way to fix the problem has been to differentiate between the user exiting the App or the System asking the app to close. And for that, there is another Event we can add to the App object on Xojo: HandleAppleEvent. Once added, it is a simple matter of inspect the ‘EventID’ argument value to see if it matches the “quit” string. In that case, the app change the state of a property that is then used on the CloseCancel event code to see if the App exiting process comes from the user or from the System.

Easy!

So, no more cancelled macOS logouts pointing to Stamp as the culprit!

As for the minimum requirements, Stamp works on Mac OS 10.7 and later including the most recent macOS Sierra.

Of course, Stamp is an Apple Developer Signed app, so you can run it on your Mac with absolute confidence.

*This blog entry has been writen in Markdown and exported to HTML using Snippery

The post Stamp 1.0.3 released! appeared first on AprendeXojo.

Canvas: Crea tus propios controles con Xojo

$
0
0

Xojo incluye de serie una buena biblioteca de controles gráficos listos para usar. Ya sabes, se trata de las piezas mediante las cuales puedes diseñar las interfaces de usuario de tus aplicaciones, repletas de propiedades, métodos y eventos que te permiten añadir el comportamiento específico que esperas de ellos para tus proyectos. Pero si lo que necesitas es crear tus propios controles, la respuesta está en el control Canvas.

Además, al tratarse de un entorno de desarrollo multiplataforma, verás que Xojo adapta en muchos casos cada uno de los controles a su función específica sobre la plataforma de despliegue; tal y como ocurre, por ejemplo, con el ListBox, los botones o incluso los campos de texto. Pero, ¿qué ocurre cuando lo que deseamos es crear nuestros propios controles, desde cero? Pues bien, a continuación veremos como hacerlo basándonos en dicho control Canvas.

Como su propio nombre indica, el control Canvas de Xojo —disponible en las ediciones Desktop, Web, iOS y Raspberry Pi— es un verdadero lienzo en el que puedes dibujar su aspecto gráfico sobre la marcha, utilizando para ello el evento Paint y el conjunto de clases gráficas disponibles en Xojo, o bien asignando simplemente una imagen como fondo del control y que puedes cambiar en función de cada uno de los posibles estados, como por ejemplo cuando el apuntador del ratón está sobre el área del control, el apuntador ha abandonado dicha área, o bien se ha hecho clic sobre el control propiamente dicho.

Canvas: cuestión de eventos

Es por ello que el control Canvas proporciona todo tipo de eventos, de modo que tu control personalizado pueda implementarlos para reaccionar antes las acciones realizadas por los usuarios; solo has de echar un vistazo a la documentación disponible para darte cuenta de ello.

Ahora bien, si bien puedes arrastrar controles Canvas directamente sobre tu proyecto, implementar los eventos que deseas capturar y escribir el código que ha de ejecutar en respuesta cada uno de ellos, lo más razonable es que si estás utilizando un Canvas es porque quieras crear un control personalizado… que utilices en más de un proyecto, ¿cierto? Y esto nos lleva a la creación de tu propia subclase a partir del Canvas.

Tal y como hemos visto en otras entradas, la creación de una subclase responde a la necesidad de implementar un comportamiento específico para un control o clase ya existente, y en el caso de los Canvas no es distinto.

Crear una subclase en Xojo no puede ser más sencillo. Puedes arrastrar un elemento Canvas desde el panel Library sobre el Navegador de Proyecto (la columna situada más a la izquierda en el IDE) o bien elegir Insert > Class desde la barra de herramientas del IDE o desde el menú Insert.

Añadir clase Canvas a proyecto

Puntos, no píxeles: HiDPI y Retina

En cualquiera de los casos, una vez añadida la nueva clase al proyecto, has de seleccionar el elemento recién añadido, cambiar al panel Inspector, asignar el nombre que tendrá tu nueva clase y definir la clase superior a Canvas. De este modo nuestra nueva clase heredará todas las propiedades, métodos y eventos definidos sobre dicha clase.

Definición de subclase en el panel Inspector de Xojo

Esto es lo que haremos en este tutorial para crear un botón personalizado que varía su imagen en función de que el ratón entre sobre el área del botón, salga de dicha área o bien se haga clic sobre el control, cambiando en este caso no solo la imagen sino también el estado interno del botón almacenado mediante una propiedad de tipo Booleano.

Dado que nuestro control personalizado no va a dibujarse sobre la marcha mediante el evento Paint, tendremos que diseñar las imágenes de forma concreta al tamaño exacto que tendrá el control que diseñemos (en este ejemplo 32 x 32 puntos).

Diseño de gráficos con Sketch para macOS

Y sí, hay que hablar de puntos en vez de píxeles dado que las aplicaciones Xojo soportan HiDPI sobre Windows y Retina en macOS; es decir, gráficos de alta resolución. Por ello es importante que a la hora de diseñar las imágenes a utilizar en tus controles personalizados emplees una herramienta de diseño gráfico que simplifique el proceso. Personalmente utilizo Sketch para macOS, dado que es vectorial y permite generar automáticamente las versiones de doble densidad de píxeles que utilizará automáticamente Xojo cuando se ejecute la app sobre equipos compatibles HiDPI/Retina. (Dicha capacidad está disponible para cualquier aplicación en la que se active el soporte HiDPI/Retina desde los ajustes de Compilación en el IDE de Xojo.)

¿Qué ocurriría con el soporte HiDPI/Retina en el caso de que fuésemos nosotros mismos los responsables de dibujar los gráficos sobre la marcha? Pues bien, en tal caso estaríamos dibujando siempre en puntos de modo que Xojo continuaría realizando los cálculos de dibujado correctamente sobre el evento Paint, y en el caso de que necesitásemos acceder realmente a cada uno de los píxeles de las imágenes, entonces tendríamos que utilizar la clase RGBSurface, para lo cual también nos vendrá de perlas implementar el evento ScaleFactorChanged de la clase Canvas.

A eventos consumidos… eventos definidos

Dado que la clase en cuestión consume los eventos Open, MouseEnter, MouseExit y MouseDown, hemos de asegurarnos de definir esos mismos eventos sobre la clase, replicando los parámetros pasados y también los tipos devueltos (cuando proceda), de modo que los consumidores de nuestra clase puedan utilizarlos también para ajustar aun más el comportamiento del control a las necesidades específicas de la aplicación que estén creando.

Por tanto, una vez definidos los eventos consumidos, hemos de asegurarnos de llamarlos mediante la palabra clave RaiseEvent al final del código que ejecutaremos sobre el evento consumido. Por ejemplo, así quedaría la implementación del evento MouseDown en nuestra subclase de Canvas:

me.Backdrop = if(me.state = false, ShellRunSelected, ShellRun)

me.state = not me.state

return RaiseEvent mousedown(X, y)

Observa que en este caso, nuestra implementación del evento MouseDown devolverá el valor especificado por quien vaya a implementar nuestro control sobre el proyecto. Es decir, por omisión el evento MouseDown de la clase Canvas espera que se devuelva un valor booleano, del cual dependerá de la gestión del mismo evento en la cadena de eventos formada por la disposición de los controles sobre la ventana. Por tanto, nuestra responsabilidad será la de devolver el valor más neutro que podamos, y este es el que decida el programador que utilice nuestra subclase en cada uno de los proyectos. Quizá en algunos casos precise devolver ‘True’ (el control captura y trata el evento), mientras que en otros puede devolver ‘False’ (deja en manos del sistema el evento para que de la oportunidad de su tratamiento en el resto de los controles).

Unir todas las piezas

Con la anterior información en nuestras manos, y los conceptos básicos ya indicados, en el siguiente vídeo puedes ver como unimos todas las piezas: gráficos, eventos, definición de eventos y propiedades, para crear un control desde cero. Obviamente, a partir de aquí te sugiero que consultes la documentación sobre el control Canvas para ver en qué medida puedas emplear las Propiedades, Eventos y Métodos de la clase en el diseño de tus propios controles. Por ejemplo, desde los más sencillos botones personalizados a la creación de gráficas que representen de forma dinámica los valores recibidos. ¡Las posibilidades son infinitas!

*Esta entrada ha sido escrita en Markdown y exportada como HTML para este blog con Snippery

The post Canvas: Crea tus propios controles con Xojo appeared first on AprendeXojo.


Roadmap Xojo 2017

$
0
0

 

androidComo seguramente sepas, durante estas fechas se está celebrando la XDC 2016. Se trata del mayor evento Xojo del año en el que se presentan una serie de sesiones técnicas, de negocio de desarrollo y, quizá también lo más importante, aglutina a decenas de desarrolladores Xojo procedenetes de todas las partes del mundo. A continuación encontrarás un resumen de lo que ha dado de sí la conferencia inaugural realizada por Geoff Perlman, Fundador y CEO de Xojo.

Precisamente esta conferencia inaugural de la XDC es la que sirve para ver en perspectiva todos los logros recientes de la compañía, tal y como puede ser por ejemplo el hecho de proporcionar despliege nativo para la plataforma Raspberry Pi durante 2016, así como el soporte del despliegue de apps en 64 bits, la implementación de HiDPI/Retina en nuestras aplicaciones y el hecho de que Xojo Cloud, la plataforma de despliegue Web de la compañía, continúa siendo infranqueable.

Ahora bien, además de repasar lo ya hecho, dicha conferencia inaugural también pone sobre el papel lo que Xojo tiene previsto implementar a lo largo de 2017, ¡y te anticipio que no es poco!

Por ejemplo, a lo largo del primer trimestre de 2017 las compilaciones de 64 bits realizadas con Xojo ya no estará en fase beta, lo que entre otras cosas significa que las aplicaciones Windows ya contarán con iconos e información de versión, así como el soporte de tecnologías propias del entorno de desarrollo, tal y como es el caso de XojoScript y la Depuración Remota sobre 64 bits. Este será el trimestre en el que también llegará la Depuración Remota para Raspberry Pi.

Otras áreas que se verán mejoradas notablenente en cuanto a su rendimiento en las compilaciones de 64 bits son el manejo de las cadenas y las operaciones Join con cadenas.

De hecho, durante el segundo y tercer trimestres los nuevos proyectos pasarán a ser en 64 bits por omisión; si bien siempre existe la posibilidad de generar los desplegables (aplicaciones compiladas) en 32 bits. De hecho se mantendrá el soporte de 32 bits por una buena cantidad de tiempo, aunque ciertamente probablemente querrás migrar tus aplicaciones a 64 bits tarde o temprano por cuestión de rendimiento y para sacar provecho de las capacidades de Xojo.

También será durante el tercer trimestre cuando llegue a Xojo un nuevo formato para los plugins que actualmente deben escribirse en C o C++. Tal y como ocurre con el despliegue de 32 bits, Xojo continuará soportando dichos lenguajes y el SDK para la escritura de plugins, además de que podrán cargarse en el IDE y compilarse junto con las aplicaciones tal y como se hace actualmente. Pero lo importante es que, a partir de ese momento se podrán escribir los plugins directamente en Xojo. De hecho se podrán incluir junto con los plugins recursos como imágenes, sonidos, ventanas, etc; algo que no es posible en el anterior formato. Eso sí, dicha capacidad de escritura de plugins en Xojo sólo estará disponible para los usuarios que cuenten con una licencia Xojo Pro.

Por último, durante el último trimestre de 2017 Xojo cambiará radicalmente el modo en el que utilizaremos las llamadas a las API (SDK) nativos de las plataformas, y que actualmente se realiza mediante el uso de los Declare. La respuesta es Interops, capacidad que permitirá utilizar autocompletado de las funciones de los SDK directamente en Xojo, además de permitir el uso de los tipos nativos de Xojo en las llamadas de los SDK y, por tanto, también realizar comprobación de tipos en el compilador lo que resulta en una mayor flexibilidad a la hora de depurar también esas partes del código.

Pero no cabe duda de que el anuncio estrella de esta XDC 2016 para muchas personas, incluido yo mismo, es la llegada de Android como nueva plataforma de despliegue nativo, tal y como es el caso actualmente de iOS, OS X, Windows, Linux o Raspberry Pi (Linux también, en cualquier caso). De hecho, salvo un pequeño bridge Java, la implementación del SDK se realizará totalmente en Xojo. De este modo, Xojo da un gran paso hacia adelante a la hora de que podamos crear y desplegar nuestras aplicaciones móviles sobre las dos plataformas que tienen más sentido actualmente.

En cuanto al sistema operativo mínimo que se soportará en el despliegue de las aplicaciones Android, este es JellyBean (versión 4.1) y posteriores; lo que significa que se cubrirá el 97% de los usuarios.

Sin duda, ¡el próximo año será genial para continuar desarrollando con Xojo!

*Esta entrada ha sido escrita en Markdown y exportada como HTML para este blog con Snippery

The post Roadmap Xojo 2017 appeared first on AprendeXojo.

Listados jerárquicos en ListBox

$
0
0

Probablemente el control ListBox es uno de los más importante en el diseño de cualquiera de nuestras aplicaciones y, de hecho, también es uno de los más completos. Tanto es así, que no es realista cubrir todas sus capacidades en una sola entrada de AprendeXojo. De hecho, en una entrada anterior ya vimos de qué modo podemos ordenar las columnas de un ListBox por el valor numérico de sus datos. En esta ocasión veremos de qué modo tan sencillo podemos crear listados jerárquicos.

Los listados jerárquicos son aquellos en los que podemos alternar filas de datos normales con aquellas que presentan un elemento gráfico —por lo general un triángulo— que al ser pulsado despliega la ‘rama’ de la fila seleccionada para mostrar los valores agrupados bajo dicha entrada y que, una vez que volvemos a pulsar sobre dicho elemento, repliega nuevamente los contenidos agrupados bajo dicha rama.

Por tanto, los listados jerárquicos son un excelente modo de presentar información agrupada bajo una misma categoría en nuestras aplicaciones, así como la forma habitual de presentar cualquier otro tipo de información jerarquizada en la típica estructura de árbol, tal y como ocurre por ejemplo a la hora de mostrar los archivos y directorios de nuestros dispositivos de almacenamiento. Por supuesto, podemos presentar varios niveles jerárquicos en nuestros ListBox, si bien a partir de cierto nivel probablemente deje de ser una interfaz útil o manejable.

listboxjerarquico

Definir ListBox como jerárquico

Lo primero que debemos hacer para que nuestros controles ListBox puedan presentar y trabajar con información jerarquizada (esto es, filas capaces de desplegar y replegar datos agrupados), es definir la propiedad Hierarchical a true. Esto es algo que podemos hacer desde código, por ejemplo utilizando el Manejador de Evento Open sobre la propia instancia del ListBox o, más sencillo, seleccionando la instancia del ListBox sobre el Editor de Diseño en el IDE de Xojo, activando el Inspector y cambiando a On el control de tipo switch Hierarchical bajo el apartado Behavior.

AddFolder, el método para crear ‘grupos’

El segundo aspecto que hemos de tener en cuenta es que hemos de emplear el método AddFolder del ListBox en vez de AddRow a la hora de añadir aquellas entradas que deban de tratarse por el control como filas jerárquicas; es decir, acompañadas de la pequeña pieza gráfica triangular de despliegue/repliegue de datos.

La forma en la que debas de utilizar AddFoder o AddRow dependerá de la lógica de tu aplicación, así como del modelo de datos que vayas a utilizar en cada caso. Es decir, quizá el ListBox presente únicamente un primer nivel cuyas filas serán todas de tipo desplegable (jerárquicas), o bien debas de alternar filas jerárquicas con filas de datos no desplegables.

Un aspecto importante de AddFolder es que añadirá la nueva entrada al final de las existentes, actuando únicamente sobre la primera de las columnas. ¿Y cómo puedes añadir entonces jerarquías anidadas? La respuesta se encuentra en el evento ExpandRow.

ExpandRow: añadir elementos al grupo

Cuando añades filas con AddFolder, y ejecutas la aplicación, verás que el control ListBox hace su trabajo cambiando las entradas entre los estados de desplegado y replegado cuando pulsamos sobre ellas. Ahora bien, para añadir los datos que han de presentarse cuando desplegamos una fila en concreto hemos de acudir al evento ExpandRow. Una vez que añadimos dicho evento a nuestra instancia de ListBox veremos que se pasa como argumento el número entero correspondiente a la fila sobre la que se ha pulsado; es decir, la fila desplegada. Y, de hecho, lo más probable es que utilicemos dicho valor para conocer en nuestro modelo de datos cuál es grupo de nuevas filas que hemos de añadir bajo la entrada seleccionada. Por lo general, puede ser el propio texto de la celda pulsada en el ListBox o bien cualquier otro dato que hayamos añadido previamente mediante CellTag.

En cualquier caso, será nuevamente en este evento cuando utilizaremos los métodos AddRow o AddFolder para añadir las nuevas celdas que han de aparecer bajo la entrada desplegada.

Una consideración especialmente interesante es que, si bien cuando aplicamos estos métodos directamente sobre la instancia de ListBox, las nuevas entradas se añaden al final del listado, cuando se utilizan en este evento será el propio ListBox quien se encargue de añadir las nuevas filas bajo la fila desplegada, facilitando así enormemente la programación y reduciendo la cantidad de código necesario.

ListBox jerárquico, en la práctica

Es el momento de poner en práctica lo visto hasta ahora. Ejecuta Xojo y crea un nuevo proyecto de tipo escritorio. A continuación sigue estos pasos:

  • Selecciona el objeto Window1 en el Navegador de Proyectos (la columna situada más a la izquierda en el IDE de Xojo).
  • Añade una instancia del control ListBox desde Library sobre la ventana Window1 mostrada en el Editor de Diseño.
  • Selecciona la nueva instancia de ListBox, ListBox1 y accede al Panel Inspector para poner en On la propiedad Hierarchical. También puedes aprovechar para anclar el control sobre los cuatro márgenes de la ventana.

Con esto habremos terminado con el diseño de nuestra interfaz de usuario. A continuación crearemos un modelo de datos para nuestra aplicación de ejemplo. Esto es, los datos que mostrará la instancia del ListBox en su primer nivel (todas ellas serán filas desplegables), así como cuando se despliegue cada una de las entradas:

  • Selecciona el objeto App en el Navegador de Proyectos y añade una nueva propiedad. Con la nueva propiedad seleccionada, utiliza el panel Inspector para asignar los valres contenidos y Dictionary en los campos Name y Type, respectivamente.
  • A continuación, añade el evento Open al objeto App y añade el siguiente código en dicho evento. Será el encargado de crear el modelo de datos propiamente dicho:


dim primero() as string = Array("Uno", "Dos", "Tres", "Cuatro")
dim segundo() as string = Array("Cinco", "Seis", "Siete", "Ocho")
dim tercero() as string = Array("Nueve", "Diez", "Once", "Doce")
contenidos = New Dictionary("Primero":primero, "Segundo":segundo, "Tercero":tercero, "Cuarto":cuarto)

  • Seleccionar ahora la instancia ListBox1 en el Navegador de Proyectos y añade el evento Open. Aquí es donde aprovecharemos para presentar nuestro control ListBox con las filas correspondientes a los primeros niveles de nuestra jerarquía. Introduce el siguiente código en el Editor de Código resultante:

dim elementos() as variant = app.contenidos.keys
for each item as string in elementos
me.addfolder item
next

Si ejecutas la aplicación de ejemplo en este punto comprobarás que puedes desplegar y replegar cada una de las entradas del ListBox pero no se muestran los datos asociados. Esto es lo que haremos a continuación.

  • Con la instancia ListBox1 seleccionada, añade en esta ocasión el manejador de evento ExpandRow, e introduce el siguiente código en el Editor de Código resultante:

dim elementos() as String = app.contenidos.Value(me.list(row))
for each item as string in elementos
me.AddRow item
next

Ejecuta de nuevo la aplicación y, en este caso, comprobarás como cada grupo muestra los elementos asociados y que, cuando repliegas cada una de las entradas estas desaparecen del listado correctamente sin necesidad de que debamos de encargarnos de escribir código adicional.

*Esta entrada ha sido escrita en Markdown y exportada como HTML para este blog con Snippery

The post Listados jerárquicos en ListBox appeared first on AprendeXojo.

iOS: Selección de Imágenes y Acceso a cámara

$
0
0

iphonecamara

En esta entrada veremos otra de las capacidades disponibles en Xojo desde la edición Xojo 2016r2. Se trata de la capacidad de recibir en nuestro proyecto la imagen que haya seleccionado el usuario de entre las disponibles en el Carrete Fotográfico de iOS, en cualquiera de sus álbumes, o bien que haya realizado utilizando cualquiera de las cámaras disponibles (frontal o posterior).

Y para todo lo anterior sólo tenemos que añadir a nuestro proyecto Xojo de iOS una instancia de iOSPicturePicker. Eso sí, su funcionamiento viene determinado por la propiedad Source y que puede corresponderse con cualquiera de los valores Enumerados Camera, CameraRoll y PhotoLibrary. Lo que conviene tener en cuenta es que no se pueden combinar entre sí. Es decir, no podrás presentar un iOSPicturePicker que muestre el selector de fotografías del carrete o los álbumes disponibles y, al mismo tiempo, permita realizar fotografías.

Lo que sí puedes hacer es poner a True la propiedad IsEditable, en cuyo caso el usuario podrá editra la imagen capturada mediante la cámara incorporada o bien aquella que haya seleccionado desde el carrete o el álbum fotográfico seleccioando. Dichas capacidades de edición se limitan a reencuadrar la imagen capturada o seleccionada.

Por otra parte, el funcionamiento del iOSPicturePicker es asíncrono, lo que significa que una vez que hayamos invocado el método Show sobre la instancia, nuestra aplicación continuará ejecutando la línea de código inmediatamente posterior. Ahora bien, la interfaz de usuario presentada por el selector de imágen —o para la captura de una nueva fotografía— es de tipo modal, impidiendo que el usuario pueda llevar a cabo alguna otra acción sobre la interfaz de usuario de nuestra aplicación.

¿Y como recibe nuestra aplicación la imagen seleccionada? Pues bien, las instancias de iOSPicturePicker pueden instalar cualquiera de los dos eventos disponibles: Cancelled y Selected. El primero es el que se invocará en el caso de que el usuario haya cancelado la acción, mientras que el segundo será el invocado pasando como parámetro la imágen seleccionada por el usuario como una instancia de iOSImage. Es decir, a partir de ese momento ya podrás asignarla a tu modelo de datos o cualquiera de los controles compatibles disponibles en la interfaz de usuario de tu aplicación para iOS.

Depurar iOSPicturePicker

Lo único que has de tener en cuenta a la hora de depurar aplicaciones que hagan uso de instancias de iOSPicturePicker, es que el Simulador iOS no permite acceder a la Cámara. Es decir, sólo podrás depurar en el Simulador las aplicaciones que presenten el selector de imágenes para el Carrete o los Álbumes fotográficos. Si tu aplicación hace uso de la Cámara, deberás de compilarla y copiarla a un dispositivo físico (iPhone, iPad o iPod touch), utilizando por ejemplo la sincronización de iTunes. Recuerda que, en este caso, deberás de contar también con un perfil para firmar el Código.

iOSPicturePicker en la práctica

Para ponerlo en la práctica vamos a ver como podemos crear una sencilla aplicación iOS en la que vamos añadiendo imágenes capturadas con el dispositivo a una tabla (iOSTable). Para ello abre el IDE de Xojo y en el Selector de Proyectos crea un nuevo proyecto de tipo iOS. Ya sabes que, como se ha indicado anteriormente, deberás de contar con un dispositivo iOS físico conectado al Mac, así como una cuenta de desarrollador para la cual dispongas de los perfiles de firmado de código.

Para comenzar, nos vamos a encargar de la sencilla interfaz de usuario. Selecciona el objeto View1 en el Navegador de Proyecto (la columna situada más a la izquierda en el IDE). Dicha acción mostrará el Editor de Plantillas.

Con la Librería (Library) seleccionada, arrastra sobre el Editor de plantillas el componente correspondiente al iOSPicturePicker. Como resultado, este se añadirá al Tray, en la parte inferior del Editor de Plantillas y también quedará reflejado en la jerarquía de controles que cuelga de View1. Utiliza el Panel Inspector para cambiar su nombre por el de MyPicturePicker. A continuación añade sobre el Editor de Plantillas un control iOSTable, también desde la librería. Por último, añade desde la librería un Botón (iOSButton) y utiliza un texto descriptivo para su etiqueta, como por ejemplo “Take Photo”. El resultado debería ser similar al mostrado en la siguiente imagen:

iostakephoto

Crear Modelo de Datos

Ahora nos encargaremos de crear el modelo de datos que alimentará a la tabla. Añade una nueva Clase al proyecto (Insert > Class). Selecciona la clase recién creada y asígnale un nombre utilizando para ello el Panel Inspector. En nuestro ejemplo llamaremos a dicha clase MyDataSource.

Ahora bien, para poder utilizarla como modelo de datos de la tabla, es necesario que nuestra clase implemente la Interface de Clase iOSTableDataSource, tal y como ya hemos explicado en otro tutorial.

captura-de-pantalla-2016-10-17-a-las-17-19-58

Con la clase seleccionada en el Navegador de Proyectos, accede al Panel Inspector y pulsa sobre el botón Interfaces. Dicha acción presentará un listado en el que hemos de marcar la entrada correspondiente a iOSTableDataSource para añadir dicha interface a nuestra clase. Confirma la selección y comprobarás que Xojo añadirá automáticamente a la clase las signaturas de los métodos exigidos.

  • En el método correspondiente a RowCount utiliza la siguiente línea de código: Return me.Images.Ubound + 1
  • En el método correspondiente a SectionCount inserta el siguiente código: Return 1
  • En el método SectionTitle, utiliza el siguiente código: Return "Custom Photo Album"
  • Finalmente, inserta el siguiente fragmento de código en el método RowData
dim cell as iOSTableCellData = table.CreateCustomCell(GetTypeInfo(MyCustomCell))

dim customCell as MyCustomCell = MyCustomCell(cell.Control)

customCell.ImageView1.Image = me.Images(row)

Return cell

Como habrás observado, se hacen referencia a un par de elementos que aun no hemos añadido. Por un lado se encuentra la propiedad Images, y por otro la Celda Personalizada para la tabla MyCustomCell. Comienza por añadir la propiedad Images sobre la clase que estamos editando, utilizando para ello Insert > Property con los siguientes valores en el Panel Inspector asociado:

  • Name: Images()
  • Type: iOSImage

Como puedes observar, la clase es bastante simple. Se limita a proporcionar los métodos requeridos para actuar como Modelo de Datos de una iOSTable, al tiempo que establece como una propiedad de tipo Array para ir almacenando todas las imágenes que vayamos capturando mediante la cámara.

Definir la Celda Personalizada de la Tabla

En una entrada anterior ya vimos qué son y como se crean, en detalle, las celdas personalizadas que podemos crear para su uso en cualquier instancia de una Tabla (iOSTable). Por tanto, te recomiendo que leas dicha entrada para refrescar los conceptos en el caso de que lo veas necesario. A continuación nos limitaremos a indicar como crear la necesaria para este tutorial.

captura-de-pantalla-2016-10-17-a-las-17-37-06

Desde la Libería, Arrastra un control iOS Custom Table Cell sobre el Navegador de Proyecto y selecciónalo. Dicha acción presentará el Editor de Plantillas para que puedas diseñar el tamaño y elementos de la celda personalizada. En primer lugar, cambia la vista al Panel Inspector y cambia su nombre por el de MyCustomCell. A continuación, vuelve a seleccionar la Librería y arrastra sobre un Control ImageWell sobre el contenedor mostrado por el Diseñador de Plantillas. El resultado debería de ser similar al mostrado en la imagen. También has de fijarte en seleccionar ScaleAspectFit en el menú ContentMode del apartado Behavior correspondiente al ImageWell:

captura-de-pantalla-2016-10-17-a-las-19-10-48

¡Poniéndolo todo en marcha!

Con el Modelo de Datos creado, así como la celda personalizada que utilizará la tabla, es el momento de escribir el código restante.

Bajo View1, selecciona Button1 y añade el Manejador de Evento Action (Insert > Event Handler…). Escribe el siguiente código en el Editor de Código resultante:

MyPicturePicker.Source = iOSPicturePicker.Sources.Camera

MyPicturePicker.Editable = true

MyPicturePicker.Show(self)

¡Esto es todo lo necesario para presentar el Selector de Imágenes (o cámara) en nuestros proyectos iOS! De hecho, en tus proyectos puedes omitir la segunda de las líneas y cambia la vista padre (self, en este ejemplo) por cualquier otra en uso.

Elige a continuación el objeto MyPicturePicker en el Navegador de Proyectos y utiliza Insert > Event Handler… para añadir el evento Selected. Escribe el siguiente código en el Editor de Código resultante:

self.DatosTabla.Images.Append pic

table1.ReloadData

La primera línea se encarga de añadir la imagen seleccionada (en este caso, capturada) por el usuario al array de nuestro modelo de datos, forzando a continuación la recarga de datos en la tabla mediante la segunda línea de código.

Copiar la App en el dispositivo

Como se ha indicado anteriormente, al hacer uso de la Cámara del dispositivo no es posible ejecutarla en el Simulador de XCode, sino que hemos de instalar nuestra app sobre un dispositivo físico.

Para ello, conecta tu iPhone, iPad o iPod touch al Mac y abre la aplicación iTunes. A continuación, sigue estos pasos:

captura-de-pantalla-2016-10-17-a-las-17-55-12

  • En el IDE de Xojo, selecciona la entrada iOS bajo el apartado Build Settings. En el Panel Inspector resultante, elige tu perfil de Desarrollador Apple para iOS en el menú desplegable Team bajo el apartado Code Signing. También puedes aprovechar para indicar si deseas compilar la App como 32 o 64 bits.
  • En iTunes, selecciona en la parte superior de la ventana el icono correspondiente a tu dispostiivo para acceder a sus ajustes de sincronización. Selecciona la entrada Aplicaciones bajo el apartado Ajustes de la columna situada a la izquierda en la interfaz.
  • Regresa al IDE de Xojo y pulsa sobre el botón Build para generar el ejecutable. Una vez Xojo haya finalizado con la compilación, mostrará el archivo ejecutable resultante en la carpeta de destino.
  • Arrastra el icono correspondiente al ejecutable de la App y suéltalo en la ventana de iTunes bajo el apartado En mi dispositivo para que se añada a la lista de Apps sincronizadas.
  • Por último, pulsa sobre el botón Sincronizar en la ventana de iTunes para que se transfiera la App al dispositivo.

Conclusiones

Una vez que ejecutes la app en tu dispositivo iOS, comprobarás que al pulsar sobre el botón Take Photo de la parte inferior de la pantalla aparecerá la interfaz estándar de iOS para la captura de fotografías con la cámara. Cada vez que saques una nueva fotografía podrás hacer zoom y moverla para modificar el encuadre y, una vez que confirmes los cambios, verás que esta pasa a mostrarse en el listado tal y como hemos indicado mediante nuestra sencilla aplicación.

img_0123

En definitiva, mediante este tutorial has visto de qué modo tan sencillo puede crear apps en las que se pueda trabajar o tratar las imágenes seleccionadas o capturadas por el usuario.

Además, y gracias al AutoLayout realizado por omisión por el IDE de Xojo habrás comprobado que la interfaz de usuario de la app se adapta correctamente cuando cambias la orientación del dispositivo entre vertical y apaisado.

¿Te atreves a ampliar el programa de ejemplo para que guarde las imágenes a una base de datos SQLite?

*Esta entrada ha sido escrita en Markdown y exportada como HTML para este blog con Snippery

The post iOS: Selección de Imágenes y Acceso a cámara appeared first on AprendeXojo.

El “nuevo” Framework de Xojo

$
0
0

Framework en XojoCoincidiendo con la release de Xojo 2014.r3, Xojo incorporó en el RAD multiplataforma la capacidad de crear aplicaciones nativas para dispositivos basados en el sistema operativo iOS; y también aprovechó la ocasión para darle una vuelta de hoja a lo que venía siendo el Framework (conjunto de librerías y clases) disponibles hasta el momento para facilitarnos la vida como desarrolladores.Desde dicha release, se utilizan dos frameworks en nuestras apliaciones Xojo: el clásico, correspondiente a todo el conjunto de librerías y clases que se venían utilizando hasta la fecha; y el nuevo Framework, en el que se introducen nuevos tipos de datos (clases), se mejoran otras ya existentes y también se introducen los espacios de nombre directamente en su uso.

En gran parte, el framework Classic se mantiene con el objetivo de no romper la compatibilidad con los millones de líneas de código existentes en las aplicaciones que se habían creado hasta la fecha, y de hecho se puede continuar utilizando sin mayor problema teniendo en consideración, eso sí, que en algún momento del futuro quedará obsoleto.

¿Cuáles son los cambios más sustanciales y en qué medida afecta todo ello?

El nuevo Framework de Xojo se ha diseñado para sustituir en algún momento del futuro al framework clásico. El Framework clásico ha sido el utilizado por los usuarios de Xojo durante más de 15 años y está mostrando su antiguedad en varias áreas, lo cual limita también la capacidad de proporcionar actualizaciones y resolver los problemas detectados. Con el “nuevo” Framework, disponible desde 2014, se proporciona un modo más consistente y eficiente que permitirá a Xojo continuar evolucionando en el futuro.

El resumen podría ser que el Framework Clásico ha existido desde la primera versión (en torno a 1998) y ha acumulado unas cuantas verrugas. Hay inconsistencias como por ejemplo que no todas las funciones estén basadas en cero o en la gestión de errores. También existen algunas áreas en las que el diseño tenía su lógica originalmente, pero los sistemas operativos han ido en diferentes direcciones (acceso aleatorio por índice en los contenidoss de una carpeta, por ejemplo). O peor aún, hay áreas en las cuales el framework pone demasiado fácil hacer mal las cosas.

Durante la planifficación del soporte para iOS, el equipo de Xojo llegó a la conclusión de que sería una buena oportunidad para un comienzo desde cero en el cual resolver estos problemas (entre otros). El hecho de compartir código entre los frameworks Desktop, Web y Consola también es muy importante, de modo que el nuevo framework también se aplica sobre estas plataformas de despliegue.

En la mayoría de los casos los dos frameworks son similares, donde las principales diferencias se encuentran en el uso de los tipos de datos Text y Auto. Por otra parte, el nuevo Framework se encuentra, relativamente, en sus primeras etapas de vida, de modo que no dispone de toda la funcionalidad sobre el clásico, si bien se irá mejorando con el paso del tiempo.

Ventajas del nuevo Framework Xojo

Además de ser más moderno, una de las ventajas se encuentra en el uso de los nombres de espacio, de modo que las clases y métodos del nuevo framework no colisionan con las clases y métodos del framework clásico. Un nombre de espacio permite que ambos frameworks coexistan, haciendo posible que se pueda continuar utilizando el framework clásico al tiempo que se va aprendiendo como utilizar el nuevo framework.

Si no se hiciese uso de los nombres de espacio, entonces todas las clases del nuevo framework también serían globales y se requeriría del uso de nombres únicos. Así, Xojo.Core.Dictionary precisaría de un nuevo nombre; o quizá hubiese sido necesario el uso de un prefijo o sufijo. En Xojo pensaron que pocos desarrolladores preferirían que el nuevo Diccionario (Dictionary) se llamase XojoDictionary o DictionaryXojo, por ejemplo.

Además, con los nombres de espacio puedes añadir simplemente la instrucción Using a tu código (o bien añadirla a la ventana/clase/módulo/etc.) de modo que no tengas que utilizar el nombre completo:

Using Xojo.Core
Dim d As New Dictionary ' Uses Xojo.Core.Dictionary

El código anterior no habría sido posible si se hubiese utilizado el prefijo/sufijo.

Y mediante el uso de nombres de espacio sabes que tienes un modo más sencillo de aprender sobre nuevas características. Por ejemplo, todas las entradas/salidas sobre archivos radican en el nombre de espacio Xojo.IO. En el Framework Clásico debías de aprender sobre todo tipo de clases que no están agrupadas de forma lógica.

De igual modo que la programación orientada a objetos ha sustituido en gran parte a la programación procedural, los nombres de espacio son un mejor modo de organizar los frameworks. Y a diferencia de lo que hizo Microsoft con .NET, Xojo ha mantenido el lenguaje igual, los espacios de nombre reducidos con un único nivel y también ha mantenido el framework clásico disponible junto con el nuevo framework, de modo que se puede seguir utilizando aquello con lo que se está familiarizado mientras que se aprende el nuevo framework.

Componentes del Framework Xojo

¿Qué hay en el framework? En primer lugar, has de entender los principales componentes de Xojo:

Lenguaje Xojo

El lenguaje Xojo no ha cambiado de forma sustancial. Para soportar el nuevo Framework de Xojo, se han realizado algunos pequeños cambios consistentes en la incorporación de varias palabras clave:

Estos cambios del lenguaje están disponibles para todos los tipos de proyecto, incluídos iOS, desktop, web y consola.

Por lo demás, el lenguajes es el mismo con el mismo modelo de programación orientada a objetos que has utilizado siempre. De hecho, el libro electrónico “Programación Multiplataforma Xojo” enseña desde cero a programar utilizando el lenguaje, los tipos de datos y también la Programación Orientada a Objetos utilizando el lenguaje Xojo.

Framework Consola

El framework de consola es la colección de clases y métodos que suplementan el lenguaje y que no están relacionados con la interfaz de usuario. Estas son cosas como Date, Dictionary, FolderItem, etc. El Framework de Consola que siempre ha sido parte de Xojo se denomina ahora Framework Clásico. Continúa estando disponible para los proyectos de escritorio, web y consola. Sin embargo, los proyectos iOS sólo pueden usar el nuevo Framework Xojo.

El Framework Xojo tiene una amplia variedad de clases, como por ejemplo Dictionary, FolderItem, Date, TCPSocket, etc., y que están organizadas en nombres de espacio. Los nombres de espacio son simplemente módulos que se utilizan como vía para contener la funcionalidad relacionada. Todas las características del Framework de Xojo están contenidas en el nombre de espacio Xojo, en el que se incluyen los siguientes nombres de espacio:

De modo que para usar una clase del nombre de espacio Core, como por ejemplo Date, te referirás a ella como “Xojo.Core.Date”. Pero iOS incorpora un ajuste en ‘Shared Build’ (está a ON por defecto) que activa las “Referencias simples”. Cuando dicho ajuste está activado, simplemente has de referenciar a las clases por su nombre, sin tener que utilizar el prefijo del nombre de espacio.

Puedes utilizar tanto el framework Clásico como el framework Xojo (sólo el nombre de espacio Core) en tus proyectos desktop, web y de consola. Dado que muchas de las clases del Framework Xojo comparten el mismo nombre que las clases del Framework Clásico, tendrás que ser específico sobre cuál deseas usar.

Por ejemplo en un proyecto desktop, si quieres usar la nueva clase Date en Xojo.Core, podrías referirte a ella como:

Dim d As New Xojo.Core.Date

Lo que resulta un poco largo de escribir si has de hacerlo con frecuencia, de modo que puedes utilizar el comando Using para simplificarlo así:

Using Xojo.Core

Dim d As Date ' en realidad usa Xojo.Core.Date

También puedes utilizar Using para toda una clase o módulo seleccionando “Insert > Using Clause” e introduciendo a continuación el nombre de espacio en el Inspector.

Recuerda que puedes mezclar y combinar clases del Framework Clásico y del Framework Xojo en el mismo método. Para casos en los que debas de hacerlo, tendrás usar bien el nombre de espacio completo para la clase del Framework Xojo o bien usar el comando Using en un ámbito local. He aquí algunos ejemplos:

Dim d1 As Date ' Date del framework clásico

Dim d2 As Xojo.Core.Date ' Date del framework Xojo

If True Then
Using Xojo.Core
d = Date ' Date del framework Xojo
End If

Frameworks de UI

Los frameworks del UI son los controles específicos de la UI (Interfaz de usuario) y las clases relacionadas para crear la interfaz de usuario de tus apps desktop, web y iOS. Este framework es específico para cada target (plataforma de despliegue), de modo que el Framework de la UI para los proyectos desktop no es la misma que el Framework UI para los proyectos web o iOS.

Advertirás que el nombre de las clases difieren entre cada una de las plataformas de despliegue. Por ejemplo, un botón en desktop se llama PushButton, en la web se llama WebButton y en iOS se llama iOSButton. Generalmente, estos controles funcionan de un modo similar, pero puede que tengan una cantidad diferente de eventos, propiedades y métodos.

El framework de UI para las apps desktop y web no ha variado. Para las apps iOS, necesitas utilizar las nuevas clases del Framework iOS.

The post El “nuevo” Framework de Xojo appeared first on AprendeXojo.

Compartir en iOS: iOSSharingPanel

$
0
0

En un tutorial anterior ya vimos de qué forma tan sencilla podemos acceder tanto a la cámara fotográfica de los dispositivos basados en iOS como al carrete fotográfico y, por tanto, a los álbumes de imágenes. Ahora veremos de qué forma tan simple podemos compartir contenidos de imagen de nuestras apps creadas con Xojo con otras aplicaciones y servicios de iOS mediante iOSSharingPanel.

Si quieres completar el tutorial de principio a fin tendrás que comenzar por el anterior tutorial, puesto que será el que usemos como punto de partida. Si sólo estás interesado en ver cómo funciona el Panel Compartir de Xojo para iOS entonces no es necesario.

iOSSharingPanel

La primera consideración es que, al igual que ocurre con otras muchas clases de Xojo, el control iOSSharingPanel no dispone de representación gráfica cuando se arrastra desde el panel Librería sobre el Editor de Diseños, sino que este queda reflejado como instancia en el Tray —la franja inferior en el Editor de Diseños—, así como en la propia jerarquía de controles que cuelga de la vista editada en el Navegador de Proyectos (la columna situada más a la izquierda en el IDE de Xojo).

iOSSharingPanel en el Tray

En cualquiera de los casos, el resultado es el mismo: habrás creado una nueva instancia cuyo nombre por omisión será SharingPanel1. Ya sabes que puedes modificar dicho nombre en el campo name panel Inspector correspondiente tras seleccionar la instancia. Este será el nombre de la instancia que utilizaremos en el código para identificar (referirnos) al objeto.

Con la instancia añadida a la única vista de nuestro proyecto iOS (por omisión View1), el siguiente paso consiste en añadir la acción que provoque la aparición del panel de compartir. En nuestro ejemplo se tratará de compartir la imagen correspondiente a la celda de la tabla sobre la que pulsemos. Es decir, la celda o entrada seleccionada de la tabla. Y si bien en este ejemplo compartiremos una imagen, hay que indicar que el panel iOSSharingPanel también puede compartir textos y URLs.

Presentar el panel iOSSharingPanel

Empecemos por añadir una acción a la tabla; y como probablemente habrás imaginado, consiste en añadir el oportuno Evento. Selecciona la tabla Table1 en el proyecto y utiliza Insert > Event Handler para añadir el evento Action. Al hacerlo, verás que en el Editor de Código asociado se presenta la signatura Action(section As Integer, Row As Integer). Es decir, recibiremos como parámetros tanto la sección y fila de la tabla sobre la que se ha pulsado.

En nuestro caso todo lo que necesitaremos será la fila, de modo que podamos recuperar la imagen (instancia de iOSImage) desde nuestro modelo de datos, presente como la propiedad DatosTabla que cuelta de la vista View1. Nuevamente, para conocer qué es este modelo de datos y como se ha creado la clase que la representa, te recomiendo que eches un vistazo a la anterior entrada del tutorial.

El código para recuperar la imagen correspondiente a la celda pulsada de la tabla es el siguiente:

dim p as iOSImage = datostabla.Images(row)

Y una vez que ya tenemos la imagen a compartir, sólo nos queda presentar el panel de compartir propiamente dicho. Algo para lo que sólo necesitamos esta línea de código:

SharingPanel1.SharePicture(p,self,me)

Como puedes observar, en este caso se está invocando el método SharePicture, dado que es el tipo de dato que deseamos compartir. Los otros dos métodos presentes en esta clase son:

  • ShareText. Para compartir texto.
  • ShareURL. Si lo que deseamos compartir es un URL.

El resto de los parámetros que pasamos al método son los siguientes:

  • P. Se trata de la instancia de tipo iOSImage recuperada en la línea anterior desde nuestro modelo de datos.
  • self. Se corresponde con la instancia de tipo iOSView (en este caso la vista View1) que utilizará el panel como anclaje para sumarse en la jerarquía de vistas.
  • me. Se corresponde con una instancia de tipo iOSControl y que proporcionará al panel las coordenadas más precisas sobre las cuales presentar el panel, especialmente relevante en las aplicaciones iPad.iOSSharingPanel en app iOS de ejemplo

¡Y eso es todo! Para que puedas ejecutar y probar el proyecto en el Simulador de iOS en vez de tener que utilizar un dispositivo físico, selecciona el control Button1 del proyecto, y en su evento Action cambia la primera línea de código por la siguiente:

MyPicturePicker.Source = iOSPicturePicker.Sources.PhotoLibrary

Ejecuta el proyecto, utiliza el botón para seleccionar cualquier imagen de entre las disponibles en el Álbum Fotográfico del carrete y, a continuación, pulsa sobre la celda de la tabla. Al hacerlo verás como se muestra el Panel Compartir de iOS presentando todas las opciones aplicables (aplicaciones y servicios) que pueden compartir y/o utilizar la imagen seleccionada.

En definitiva, tremendamente sencillo y rápido, ¿verdad?

*Esta entrada ha sido escrita en Markdown y exportada como HTML para este blog con Snippery

The post Compartir en iOS: iOSSharingPanel appeared first on AprendeXojo.

Viewing all 461 articles
Browse latest View live