Archivo

Archivos de la categoria ‘Delphi’

Firemonkey Mobile Application (XE4 / iOS)

Viernes, 24 de mayo de 2013

Continuando con la última entrada dónde vimos cómo configurar el entorno de desarrollo para generar aplicaciones móviles para iOS, vamos a realizar una primera aplicación paso a paso para ver algunas funcionalidades básicas.

En este caso testearemos el componente TWebBrowser, que hasta esta versión sólo estaba disponible para la plataforma Windows, y que ahora ya se puede utilizar en iOS.

Para empezar seleccionamos el tipo de proyecto “Firemonkey Mobile Application – Delphi”. Una vez en el asistente podemos escoger (y probar) entre los diferentes tipos de aplicaciones prediseñadas, que ya nos crearán un esqueleto de una “aplicación tipo” con unos determinados componentes, según lo que escojamos.

Imagen504

En nuestro caso, para el ejemplo, puesto que quiero varias pestañas, seleccionaré “Tabbed with Navigation” y me bastará con eliminar algún componente para empezar con la estructura que necesito. Se nos solicitará una carpeta para guardar el proyecto y una vez hecho esto ya estaremos en el IDE con el simulador del dispositivo como se ve en la imagen inferior.

Imagen507

Tal y como podemos ver en la parte izquierda de la imagen, por defecto se crea el proyecto con las “plataformas destino” que tenemos definidas en la configuración (vimos cómo añadirlas en la entrada anterior) y en la parte central tenemos el simulador con el proyecto generado. En este caso se crea un componente TTabControl, con cuatro elementos (pestañas). Con la aplicación tal y como está, ya podemos ejecutar la aplicación y podemos ver el funcionamiento.

Test aplicacion iOS Delphi XE4 1

Para continuar vamos a añadir a la primera pestaña un componente TWebBrowser y a la segunda componentes que nos permitan buscar una dirección y mostrarla sobre un mapa. Para aprovechar el ejemplo vamos a utilizar un componente TSensorLocation, que nos permitirá conocer la ubicación actual del dispositivo y mostrarla en el mapa, si el equipo cuenta con un sistema de posicionamiento GPS.

NOTA: Para el ejemplo y dado de que el simulador no dispone de él, he añadido un código al programa de forma que si no se detecta GPS, se calcula una posición (latitud y longitud) aleatoria, para poder así probar el código. Si el dispositivo contara con GPS, ambas coordenadas se obtendrían del evento OnLocationChanges del componente TSensorLocation, cuya cabecera es la siguiente:

0
1
procedure TTabbedwithNavigationForm.LocationSensor1LocationChanged(
Sender: TObject; const OldLocation, NewLocation: TLocationCoord2D);

 

Imagen511En la segunda pestaña añadiremos componentes para poder buscar una dirección y a partir de los datos mostrar la ubicación en el mapa.

Una de las propiedades nuevas que podemos encontrar en los componentes de edición es KeyboardType, que permite definir el teclado por defecto que aparecerá en el dispositivo cuando sea necesario. De forma que para un campo que sabemos que será numérico (teléfono, código postal,…) podemos seleccionar que el teclado sea vkPhonePad/vkNumberPad, o en el caso de una web podemos seleccionar el tipo vkURL.

 

Test aplicación iOS Delphi XE4 2

Por último y para las “Tabs” asignaremos iconos/imágenes mediante la propiedad CustomIcon de los TabItem; Estos iconos cogerán el estilo según el estado (activada/desactivada).

Test aplicación iOS Delphi XE4 3

Para mostrar las direcciones y ubicaciones en el componente TWebBrowser, utilizaremos parámetros en la URL. De esta forma, para mostrar unas coordenadas concretas en un mapa utilizaremos la siguiente dirección:

https://maps.google.com/maps?q=<LAT>,<LONG>&z=<ZOOM>

Para mostrar una dirección se puede usar de la suiguiente forma:

https://maps.google.com/?q=<DIRECCION>

Por lo demás el proyecto no incluye mucho más código.

Comentar que se puede añadir en este caso (aunque parece que está destinado más que nada para temas de debug) la plataforma windows 32 como plataforma destino. Esto nos permite probar la aplicación y el código en el entorno de Windows (sin tener que hacer el cambio a OSX en cada prueba), aunque desgraciadamente, en este caso, parece que el componente TWebBrowser no acaba de funcionar del todo bien con esta configuración.

Por último un vídeo más con la aplicación completa funcionando.

Test aplicacion iOS Delphi XE4 4

El código fuente del proyecto podéis descargarlo desde este enlace.

<CODIGO FUENTE PROYECTO>

Un saludo y hasta la próxima.

Delphi, iOS, XE4 , , ,

Configuración del entorno de trabajo iOS/OSX (Delphi XE4)

Lunes, 29 de abril de 2013

Las últimas versiones de Delphi incluyen, tal y como podéis leer en las características del producto, soporte para dispositivos iOS y OSX (MAC). Hace tiempo que deseaba probar estas características, así que aprovechando que estos día he tenido acceso a una máquina Apple, he probado a “poner en marcha” el entorno de desarrollo y a hacerlo funcionar.

En general el proceso ha sido más sencillo de lo que pensaba (aunque tal vez también con más pasos de los que esperaba…). Hay que realizar varias operaciones, pero en sí, ninguno complicada.

Todavía no dispongo de un dispositivo iOS, así que me he tenido que quedar (conformar) en el punto de ejecutar la aplicación en OSX (en la versión 10.8) utilizando los simuladores correspondientes a estos dispositivos.

Según la documentación necesitamos tener instalada una versión OS X 10.7 Lion o 10.8 Mountain Lion en nuestro MAC. A partir de ahí, para dispositivos móviles, es necesario contar con una versión iOS 5.1 o superior.

 

Instalación de XCode en MAC

Imagen404Para iniciar la configuración de nuestro equipo, lo primero que debemos instalar es XCode. El entorno de desarrollo en MAC. En mi caso lo he  descargado directamente de “Apple  App Store”, aunque si disponéis del DVD de instalación, es posible que podáis instalarlo desde allí.

Imagen405

En mi caso he descargado la versión 4.6.2, que es la que actualmente se encuentra en la App Store y me está funcionando sin problemas.

Para poder completar el proceso de descarga se os pedirá el ID de Apple. Si no lo tenéis llegados a este punto, desde aquí mismo podéis creároslo. Una vez completado comenzará el proceso de descarga.

Imagen407

 

Instalación de PAServer

Una vez instalado XCode, lo siguiente que necesitamos es la aplicación Platform Assitant (PAServer) que nos ayudará a desarrollar aplicaciones multiplataforma. Es el servidor remoto de que necesitamos instalar para poder comunicar nuestro IDE (windows) con nuestro MAC. Por defecto PAServer trabaja con el puerto 64211, como veremos en la instalación.  Si deseamos podemos cambiarlo, y tanto en un caso como en otro, tendremos que tener presente esto a la hora de trabajar en Windows con él.
Es lógico que antivirus y firewalls pueden bloquear o avisar en algún momento del uso de este puerto y en caso de fallos de comunicación, podemos iniciar por revisar estos programas (si los tenemos instalados).

Para la instalación de PAServer necesitamos el fichero RADPAServerXE4.pkg, que podemos conseguir de varias formas:

 

OPCIÓN 1: Si hemos realizado la instalación de XE4 en Windows, junto con la instalación, se copia este fichero dentro de la estructura de carpetas de la instalación. En mi máquina, por ejemplo (Windows 7), se encuentra en:

"C:\Program Files (x86)\Embarcadero\RAD Studio\11.0\PAServer\RADPAServerXE4.pkg"

Bastará con copiarlo a nuestro MAC e instalarlo.

En Windows Vista o en XP el directorio de instalación es muy similar a este, modificando la primera carpeta de la ruta.

OPCIÓN 2: La otra opción, es directamente descargarlo desde la página de Embarcadero e instalarlo directamente desde la máquina OSX. Se puede encontrar en:

http://installers.codegear.com/release/radstudio/11.0/PAServer/RADPAServerXE4.pkg

Una vez que iniciamos la instalación, basta con seguir los pasos del asistente para instalar la aplicación. Una vez finalizada tendremos la aplicación RAD PAServer XE4.

 Imagen408Imagen409Imagen410Imagen411

Al ejecutarla, la aplicación nos pedirá un password para posteriormente poder conectarse (podemos dejarlo en blanco) y nos solicitará permisos de root para poder continuar. Una vez en marcha, podremos ver el puerto por el que la aplicación está esperando conexiones, que si no hemos modificado, será el 64211, como hemos comentado anteriormente.

Imagen412

Otras configuraciones

Dentro de XCode, necesitaremos instalar algunos “componentes” adicionales, si no están instalados, necesarios para poder trabajar y para poder acceder a los simuladores de los diferentes dispositivos.

Abrimos XCode, accedemos a las preferencias y dentro de la sección Downloads, seleccionamos:

  • Command Line Tools
  • iOS Simulator 5.1 si no está instalado.
  • … si deseaís alguno más, podéis instalarlo opcionalmente.

Imagen413

 

Configuraciones en el IDE (Delphi)

De vuelta en el IDE de Delphi (windows) es necesario realizar algunos cambios relativos a la conexión con el equipo OSX.  Para poder conectar ambos equipos, debemos crear un “Perfil de conexión” (Profile Manager) desde el IDE de Delphi, donde especificaremos los datos de conectividad entre ambos. Desde las opciones (Tools/Options) accederemos a la sección Connection Profile Manager.

 

Imagen414

Crearemos un nuevo “perfil” (“profile”) donde especificaremos el nombre de la conexión, el sistema a conectar (OSX en nuestro caso), la dirección IP de nuestro MAC, el puerto de conexión (por defecto 64211, si no lo hemos modificado) y el password, si es que hemos especificado alguno en la ejecución de PAServer.

Imagen416

Desde esta misma ventana podemos testear la conexión que hemos configurado. Para ello deberemos tener en marcha PAServer en nuestra máquina con OSX. Si hay algún problema de conexión, obtendremos un mensaje de “Connection failed”, si por el contrario, la conexión es correcta obtendremos un mensaje de “Connection succeeded”, como los que aparecen más abajo.

Imagen417Imagen418

Adicionalmente debemos añadir en la Sección “SDK Manager”, los perfiles necesarios para los diferentes dispositivos sobre los que vayamos a desarrollar. Podemos añadir tantos perfiles como necesitemos, seleccionando el sistema (OSX, IOS), la conexión configurada anteriormente en el “Connection Profile Manager” y un SDK entre los disponibles.

Imagen420Imagen419

Si todo esto es correcto, ya deberíamos tener configurada nuestra conexión entre ambos equipos con todo lo necesario para trabajar.

 

Probando el entorno de desarrollo (Windows/OSX)

Imagen421Para probar nuestra configuración. vamos a crear una aplicación básica que podamos ejecutar tanto en nuestro sistema Windows, como en nuestro equipo MAC. Para ello crearemos una nueva “Firemonkey Desktop application” (HD).

Bastará con un simple formulario y un par de botones. en mi caso además he añadido una imagen con una animación (TFloatAnimation) que la hace rotar constantemente y un efecto (TShadowEffect) sobre este mismo componente que le añade una sombra.

El código disponible en el botón es lo suficientemente sencillo para no necesitar grandes explicaciones.

0
1
2
3
4
5
6
7
8
9
10
11
12
procedure TForm1.Button1Click(Sender: TObject);
var
  Str:string;
begin
  Str := 'Hola mundo!!! ;';
{$IFDEF MSWINDOWS}
  Str := Str + ' (ejecutando en MS Windows)';
{$ELSE}
  Str := Str + ' (ejecutando en OSX)';
{$ENDIF}
 
  ShowMessage(Str);
end;

He añadido un condicional (MSWINDOWS) simplemente para distinguir el mensaje que aparecerá en la ejecución en Windows con el que aparecerá en la ejecución en OSX. Hay muchos más condicionales que se pueden utilizar referentes a la plataforma de despliegue, a la versión del sistema, al procesador,… que se pueden consultar aquí.

Si ejecutamos el programa, el resultado es el esperado. Nuestra aplicación Windows que cuando se pulsa el botón, muestra un mensaje de sistema con el mensaje “Hola Mundo !!!”, seguido del texto condicional.

Imagen422

Para poder ejecutar este mismo programa en OSX y comprobar si nuestra configuración es correcta, necesitamos añadir como plataforma de despliegue OSX. En el IDE basta con Imagen423seleccionar en el “Project Manager” que deseamos añadir esta nueva “Target platform”. Si las configuraciones anteriores (SDK) se han realizado correctamente, en el desplegable ya aparecerá la opción OSX, para seleccionar.

Basta con crear esta nueva “target platform” y seleccionarla como la predeterminada (doble click).

Si compilamos y ejecutamos ahora nuestra aplicación, y pasamos a nuestra máquina OSX (con PAServer ejecutando), veremos cómo la aplicación se ejecuta sin problemas. Si en este caso pulsamos sobre el botón, comprobaremos que el mensaje se despliega en pantalla con un par de diferencias. El estilo es nativo de OSX (como es de esperar) y el mensaje en el que hemos usado el condicional, ahora muestra el correspondiente a OSX.

reflectedImage (1)

 

Probando el entorno de desarrollo (iOS)

Finalmente, aunque no pueda probarlo en un dispositivo real (que necesitaría estar conectado por USB al MAC) puedo testear algo similar con un dispositivo iOS, en este caso utilizando los simuladores.

A diferencia de versiones anteriores de Delphi, en XE4 ya dispongo de los simuladores en el entorno de desarrollo, de forma que puedo diseñar mi aplicación de una forma más cómoda.

Imagen426

Es este caso desde el menú Nuevo, voy a seleccionar “Firemonkey mobile Application”. Una vez que accedo al asistente de aplicaciones móviles (que se ve en la imagen que hay encima de este párrafo) podemos seleccionar entre alguna plantillas ya existentes de aplicaciones, o simplemente la opción de “Blank Application”.

Para mi ejemplo voy a seleccionar “Header/Footer with Navigation”, que me creo una aplicación en blanco, con la plantilla seleccionada (añade paneles en la parte superior e inferior de la pantalla.)

Ahora podemos ver en el IDE de Delphi el simulador y podemos seleccionar entre los diferentes dispositivos (a la derecha) que podemos utilizar; iPad, iPhone, iPhone 5 y Custom device. También tenemos un botón (primero a la izquierda) con el que podemos rotar la vista del dispositivo para comprobar como se ve la aplicación, en todas las orientaciones.

Imagen428

Si ejecutamos la aplicación y cambiamos a la máquina OSX, veremos como se pone en marcha el simulador de iOS y podemos probar nuestra aplicación. El este caso, como era de esperar, el mismo código utilizando antes sigue funcionando y en este caso el mensaje mostrado sale con el estilo del sistema utilizado.

Imagen429

De igual modo podríamos seleccionar diferentes dispositivos en el “Project manager” para poder probar la aplicación en Imagen430diferentes “targets”.

Una vez que ejecutamos la aplicación desde la máquina destino (OSX) podemos modificar el comportamiento de esta en el momento de ejecutar. Podemos seleccionar diferentes escalas de visualización y tenemos opciones para girar el dispositivo, agitarlo, pulsar los botones, simular teclado, activar/desactivar la barra de estado y en general, simular todos los comportamientos posibles del aparato.

Con esto, doy por completado este primer artículo introductorio. Espero que sirva como una guía, junto con la documentación existente en Embarcadero, para aquellas personas que quieran iniciar las pruebas con Delphi para desarrollar en iOS/OSX.

Como siempre, los comentarios, sugerencias, críticas y demás serán bienvenidos.

Un saludo y hasta la próxima.

Delphi, iOS, OSX, XE4 , ,

Embarcadero Delphi XE4

Miércoles, 24 de abril de 2013

A estas alturas seguro que ya estáis al corriente de que ya está disponible la nueva versión de Delphi. XE4. Aquí podéis acceder a la página oficial de Rad Studio XE4, donde se encuentra la información oficial de embarcadero de esta nueva versión.

Esta entrada pretende ser una recopilación de datos y enlaces sobre esta nueva presentación.

 

Shopsite_Header2_734x189_EN

Personalmente creo que es una versión como “de transición”, pero eso no impide que traiga bastantes mejoras y algunos nuevos detalles muy interesantes. No voy a entrar en la discusión de si es mejor sacar versiones más a menudo y con periodos “más dilatados”, y sé que cada una de estas opciones tiene defensores y detractores. Personalmente prefiero la primera, como ya he dicho otras veces, ya que la última desición (la de adquirir una versión o no) siempre estará en nuestra mano.

Si queréis ver algunas de las novedades que se introducen en el IDE con los nuevos asistentes de plataforma, podéis echarle un vistazo a este video de EmbarcaderoTechNet, que hace incapié en ellos.

Webminar de presentación

Para los que deseéis “asistir” a la presentación “oficial” del nuevo XE4, desde embarcadero se ha organizado un webminar para el día 24 de Abril (hoy).
Podéis apuntaros en la siguiente dirección y recibiréis un correo con el enlace correspondiente para poder conectaros. Se realizan varias sesiones a diferentes horas, cuya correspondencia con la franja horaria aquí en España son las 15:00, 20:00 del día 24 y 02:00 de 25 de Abril.

Qué podemos esperar de esta versión

300px-FireMonkey_Mobile_Application_WizardRev3Desde la página web de embarcadero podemos ver una descripción “comercial” de las novedades que incluye esta versión, aunque si buscamos un poco más podemos entrar en más detalle en las cosas nuevas que podemos esperar.

Por ejemplo, Jose Leon publica este video “What’s new in the IDE (I)”, donde podemos apreciar cómo lucirá el entorno la primera vez que entremos en la versión XE4. En él se pueden ver algunas imágenes del Firemonkey iOS mobile Application Wizard, una de las mejoras que encontraremos y que podéis ver en la imagen de la derecha.

FireDAC

Como ya comenté en una entrada anterior, una de las cosas que ya viene (no hace falta instalar nada aparte) incluido en XE4 en FireDAC. Una biblioteca de acceso a datos para múltiples Base de Datos y sobre diferentes dispositivos.

FireDAC-Architecture

Permite acceso nativo desde Delphi y C ++ Builder a InterBase, SQLite, MySQL, SQL Server, Oracle, PostgreSQL, DB2, SQL Anywhere, ventaja DB, Firebird, Access, Informix, DataSnap,…

La documentación completa se puede consultar aquí.

Aquí podéis ver un vídeo de Marco Cantú titulado “Introduction to FireDAC” donde podéis ver en funcionamiento estos componentes.

Además hay nuevos soportes para Bases de datos en iOS:

  • Añadido soporte para InterBase ToGo en XE4; Se puede usar InterBase en su versión en  las aplicaciones iOS.
  • Añadido soporte para SQLite en iOS.
  • Añadido soporte para IBExpress en iOS.
  • Añadido un componente MIDAS (cliente) para iOS.
  • Añadido el soporte para los conectores DataSnap para las últimas plataformas.

Por último hacer referencia a esta entrada en el blog de Cadetill, donde se explica las modificaciones necesarias a realizar para poder acceder a FireBird con FireDAC.

 

Firemonkey FM3

speedometer_icon336x330La nueva versión de Firemonkey (FM3) incluye nuevos componentes y clases para iOS y mejoras en los existentes; Entre ellos podemos encontrar:

  • TCameraComponent: Incluye acceso a las cámaras del dispositivo, tanto frontal como trasera y también acceso al flash.
  • TMagnifierGlass: Permite utilizar una “lupa” tanto para texto como para imágenes en el dispositivo.
  • Soporte para el Marcador telefónico de iOS.
  • Componentes de selección: Componentes para selección de fechas (DatePicker) y componentes de selección genéricos y configurables.
  • Componentes de edición: Ahora soportan nuevas funciones y el teclado virtual está más integrado con los componentes de edición. Disponemos ahora de varios teclados virtuales y la posibilidad de crear toolsbars de teclado y configurar los botones que se añaden.
  • TWebBrowser: Equivalente al componente de la VCL, para mostrar contenido web o local en aplicaciones iOS.
  • TListView component.

Firemonkey además ahora soporta Frames e incorpora el soporte para “touch & gestures” en iOS que se pueden configurar desde el Oject inspector. Los elementos soportados se pueden revisar aquí. Mejoras en los estilos para iOS y ampliación de las clases para trabajar con sensores.

El listado completo de mejoras y ampliaciones se puede consultar aquí.

Enlaces de descarga

descargaAquí en el blog Delphi-Insider, podéis acceder a una tabla con todos los enlaces de descarga de los productos de la nueva versión, junto con una pequeña descripción de cada uno de ellos. RAD Studio XE4, Delphi XE4, y C++Builder XE4.

Link a los Enlaces de descarga

Otros enlaces…

Podemos encontrar una lista de los nuevos ejemplos disponibles para XE4 relacionados con las nuevas funcionalidades en esta dirección. En Sourceforge podéis encontrar el repositorio SVN para descargar todo el código fuente.

La documentación online al respecto se puede encontrar aquí.

En esta dirección podéis encontrar amplia documentación referente al desarrollo con iOS, La lista os la amplio a continuación:

Setup

  • Set Up Your Development Environment on the Mac
  • Set Up Your Development Environment on Windows PC

Using Basic User Interface Elements

  • Creating a FireMonkey iOS Application
  • Using a Button Component with Different Styles in an iOS Application
  • Using a Calendar Component to Pick a Date in an iOS Application
  • Using Combo Box Components to Pick Items from a List in an iOS Application
  • Using the Web Browser Component in an iOS Application
  • Using Tab Components to Display Pages in an iOS Application
  • Using ListBox Components to Display a Table View in an iOS Application
  • Using Layout to Adjust Different Form Sizes or Orientations in an iOS Application

Using Device Functionality

  • Taking and Sharing a Picture in an iOS Application
  • Using Location Sensors on the iOS Device
  • Using the Notification Center on the iOS Device

Accessing a Dabatase

  • Using InterBase ToGo in an iOS Application
  • Using SQLite in an iOS Application
  • Connecting to an Enterprise Database from an iOS Client Application

Win2Mac2

En este link de la documentación online, podéis encontrar el tutorial “iOS Tutorial: Set Up Your Development Environment on the Mac”, donde se explica paso a paso, el proceso de instalación y configuración de ambas plataformas (tanto windows como MAC) para poder hacerlas funcionar.

Más información…

Seguro que si buscáis por la web encontraréis muchos otros enlaces que os permitan completar esta información.

Os recomiendo visitar el blog de Salvador Jover, Delphi básico, donde podéis encontrar la entrada “Bienvenido RadStudio XE4” sobre el tema.

También podéis revisar esta entrada de Andreano Lanusse donde se entra en más profundidad en las mejoras.

Y por ultimo esta titulada “Announcing RAD Studio XE4, Delphi XE4 and C++Builder XE4” de Tim Del Chiaro en Delphi Insider (de la que ya he hablado más arriba).

Radxe4top

Por último, remitiros a la página de Danysoft, distribuidor oficial en la península de Embarcadero, donde podéis encontrar información práctica sobre las diferentes ediciones disponibles y sobre todas las posibilidades a la hora de adquirir licencias, ya sean nuevas o actualizaciones del producto.

Un saludo y hasta la próxima.

Delphi, Embarcadero, Offtopic , ,

Persistencia de una estructura de clases.

Viernes, 8 de marzo de 2013

core_data_image_1Esta entrada nace de una necesidad, la que he intentado explicar en el título, pero que tal vez, por la falta de espacio ha quedado “parca” y poco clara. Se trata de una estructura de clases almacenada en memoria y que utilizo en una de mis aplicaciones. Llegado a este punto tengo la necesidad de “respaldar” esta estructura  en disco, para posteriormente, desde este mismo programa o desde otro, poder recuperarla. Lo que comúnmente podemos llamar como un backup/restore.

Se trata de una estructura jerárquica de clases, en la que unas incluyen a otras y en la que además podemos encontrar listas de elementos. En una clase podemos encontrar propiedades de tipos simples (string, cadena), propiedades con objetos de otras clases y listas que almacenan objetos de otras clases.

Se verá más claro con un ejemplo. Pensad en una estructura de clases como la que se muestra a continuación:

0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
type
 
TTrackData = class;
TPointInfo = class;
TSegmentList = class;
 
{Clase para encapsular la información de un punto.}
TPointInfo = class(TObject)
private
  FEle: string;
  FLon: string;
  FLat: string;
  FTime: string;
  FLatF: Double;
  FLonF: Double;
  FTrack:TSegmentList;
public
  property Lat:string read FLat write FLat;
  property Lon:string read FLon write FLon;
  property Ele:string read FEle write FEle;
  property Time:string read FTime write FTime;
 
  property LatF:Double read FLatF write FLatF;
  property LonF:Double read FLonF write FLonF;
 
  property Track:TSegmentList read FTrack write FTrack;
 
  constructor Create(ATrack:TSegmentList;
                     ALat, ALon, AEle, ATime: string;
                     ALatF, ALonF:Double); overload; virtual;
end;
 
{: Clase para encapsular la información de un WayPoint.}
TWayPoint = class(TPointInfo)
private
  FNombre: string;
  FDesc: string;
  FSimbolo: string;
 
public
  property Nombre:string read FNombre write FNombre;
  property Desc:string read FDesc write FDesc;
  property Simbolo:string read FSimbolo write FSimbolo;
 
  constructor Create(ATrack:TTrackData; AWPNombre, AWPDesc:string;
                     ASimbolo:string; ALat, ALon, AEle, ATime: string;
                     ALatF, ALonF:Double); overload;
end;
 
{: Clase para las opciones de "pintado" de una lista de puntos.}
TPaintOptions = record
  Width:Integer;
  Color:TColor;  
end;
 
{: Clase para almacenar una lista de puntos.}
TPointList = Class(TList)
private
  FPaintOptions: TPaintOptions;
  function GetPoint(index: integer): TPointInfo; // Segment
public
  procedure AddPoint(pointInfo:TPointInfo); overload;
  procedure AddPoint(ATrack:TSegmentList;
                     ALat, ALon, AEle, ATime: string;
                     ALatF, ALonF:Double); overload;
 
  property Point[index:integer]:TPointInfo read GetPoint;
  property PaintOptions:TPaintOptions read FPaintOptions write FPaintOptions;
End;
 
{: Clase para encapsular datos de puntos de un track.}
TTrack = class (TObject)
  private
    FTrackPoints: TPointList;
    FTrackName: string;
  public
    constructor Create(AOwner: TComponent); override;
    procedure _debug(TS:TStrings);
  published
    //: Lista de puntos del track
    property TrackPoints:TPointList read FTrackPoints write FTrackPoints;
    //: Nombre del track
    property TrackName:string read FTrackName write FTrackName;
  end;

Como se puede ver, hay varias clases implicadas en la estructura, algún record y listas de elementos, ya sea utilizando TList o TStringList para las que almacenan junto al elemento un identificativo de tipo string.

La primera idea ha sido volcar el contenido a un fichero XML o JSON utilizando alguno de los muchos interfaces y clases que existen. No debería haber mayor problema en hacer eso. Basta con codificar el SaveToFile y el LoadFromFile correspondiente en cada una de las clases y debería funcionar sin mayores problemas que lo farragoso de codificar las clases y los recorridos de las listas.

Antes de empezar a codificar, me he parado a pensar si no habría alguna forma de ahorrarme todo ese trabajo de codificación. La idea de un DFM se me ha venido a la cabeza. Al final, es algo similar. Se trata de clases (en el caso de un formularios son componentes) que están “anidadas” y que dentro de algunas de ellas podemos encontrar listas de elementos (por ejemplos las columnas de los DBGrid) que a su vez son otras clases. La idea bien merecía dedicarle un poco de tiempo, así que he abierto este hilo en el ClubDelphi  para obtener ideas y sugerencias sobre el tema. Y de esta inquietud surge esta entrada.

Después de leer algunas ideas similares a las comentadas antes sobre los recorridos, mi enfoque ahora ya estaba claro. Se trataba de intentar conseguir esto a través de los métodos que se utilizan para trabajar con Streams (persistencia) y a través de RTTI.

En la propia ayuda/referencia de delphi (RAD Studio) he encontrado estos 2 métodos de la clase TMemoryStream que permiten, utilizando ReadComponent y WriteComponent, convertir un Componente a String y viceversa.

0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
function ComponentToStringProc(Component: TComponent): string;
var
  BinStream:TMemoryStream;
  StrStream: TStringStream;
  s: string;
begin
  BinStream := TMemoryStream.Create;
  try
    StrStream := TStringStream.Create(s);
    try
      BinStream.WriteComponent(Component);
      BinStream.Seek(0, soFromBeginning);
      ObjectBinaryToText(BinStream, StrStream);
      StrStream.Seek(0, soFromBeginning);
      Result:= StrStream.DataString;
    finally
      StrStream.Free;
    end;
  finally
    BinStream.Free
  end;
end;
 
function StringToComponentProc(Value: string): TComponent;
var
  StrStream:TStringStream;
  BinStream: TMemoryStream;
begin
  StrStream := TStringStream.Create(Value);
  try
    BinStream := TMemoryStream.Create;
    try
      ObjectTextToBinary(StrStream, BinStream);
      BinStream.Seek(0, soFromBeginning);
      Result:= BinStream.ReadComponent(nil);
    finally
      BinStream.Free;
    end;
  finally
    StrStream.Free;
  end;
end;

A partir de aquí, el planteamiento era cómo modificar (porque estaba claro que había que modificarlas) las estructura de las clases para adecuarlas a poder utilizar estos métodos de forma eficaz. Lo primero, tal como indicaban en el hilo Al González y Román, es que para poder utilizar estos métodos debemos añadir posibilidades de “persistencia” a las clases de la estructura anterior. TComponent y TPersistent serían dos de las clases que nos permiten hacer eso. TComponent la más conocida (y que deriva de la otra) y TPersistent la básica, tal como explica la propia ayuda de Delphi.

“The TPersistent class defined in the Classes unit of the VCL and CLX is declared in the {$M+} state, so any class derived from TPersistent will have RTTI generated for its published sections.”

La información de RTTI es la “poción mágica” que posibilita el poder generar los DFM o el poder visualizar las propiedades de los objetos en el Inspector de Objetos del IDE. Y es jústamente lo que necesitamos para que todo esto tenga posibilidades de éxito.

Para probar el planteamiento a ver si hay posible solución voy a empezar con alguna de las clases finales. La clase TWaypoint, que a su vez deriva de TPointInfo. No poseen ninguna complicación (aunque TPointInfo posee una referencia a otra clase, pero por ahora no se usa y no la tendremos en cuenta), así que no debería haber problemas si la teoría funciona. El único cambio a realizar es que voy a derivar TPointInfo de TComponent, en lugar de TObject. Además la mayoría de clases poseen un método _debug, que me permite ver el contenido de cada objeto y que me será muy útil para comprobar si el objeto creado corresponde con el original.

Ahora las clases quedarán así:

 

0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
  {Clase para encapsular la información de un punto.}
  TPointInfo = class(TComponent)
  private
    ...
  published
    property Lat:string read FLat write FLat;
    property Lon:string read FLon write FLon;
    property Ele:string read FEle write FEle;
    property Time:string read FTime write FTime;
    property LatF:Double read FLatF write FLatF;
    property LonF:Double read FLonF write FLonF;
    property Track:TSegmentList read FTrack write FTrack;
    ...
    function _debug(TS:TStrings):string; virtual;
  end;
 
  {: Clase para encapsular la información de un WayPoint.}
  TWayPoint = class(TPointInfo)
  private
    ...
  published
    property Nombre:string read FNombre write FNombre;
    property Desc:string read FDesc write FDesc;
    property Simbolo:string read FSimbolo write FSimbolo;
    ...
    function _debug(TS:TStrings):string; override;
  end;

Como ya hemos comentado, vamos a hacer uso de RTTI (internamente los métodos comentados la usan), por lo tanto es indispensable que las propiedades que nos interesa “respaldar” pasen a ser Published. De ahí que también haya cambiado la sección public por published en las definiciones.

Para probarlo he realizado un pequeño programa que muestra 2 paneles. A la izquierda el resultado de convertir las clases en texto, y a la derecha, una vez recuperado y convertido de nuevo el string en componente, el _debug de ese componente. De esta forma podré comprobar si el resultado recuperado se asemeja al original. El código es muy básico, sólo posee la llamada  los 2 métodos de conversión y las líneas para mostrar el resultado en los memos.

0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
procedure TForm1.Button2Click(Sender: TObject);
var
  way, way2:TWayPoint;
begin
  // Creamos y rellenamos un objeto de la clase
  way := TWayPoint.Create(nil, 'Way1', 'Waypoint 1 -Sendero-', 'Icon1', 
                          '2.3455678', '4.123456', '123' ,
                          '01/01/2013 10:10:10', 2.3455678, 4.123456);
  // Convertimos el objeto a string (Memo1 para el componente original)
  Memo1.Lines.Add(ComponentToStringProc(way));
  // Recuperamos desde el original y creamos de nuevo el componente/clase
  way2 := TWayPoint(StringToComponentProc(Memo1.Lines.Text));
  // Hacemos el debug del componente creado para comprobar (memo2)
  way2._debug(Memo2.Lines);
end;

Una vez ejecutado el programa el resultado ha sido el de la imagen inferior (izquierda); A priori el primer paso se ha realizado con éxito, aunque el segundo (la restauración) ha fallado, obteniendo un error de “Class not found”. Fallo mío. Está claro que para usar RTTI y para que sea posible generar la nueva instancia de la nueva clase, ésta debe estar registrada. Es el mismo error que obtenemos cuando intentamos utilizar la función GetClass de Delphi, sobre una clase no registrada. Basta con añadir la línea necesaria para registrarla y la cosa cambia (como se ve en la imagen de la derecha)…

RESULTADO

Como podemos ver en la imagen de la derecha, los valores del objeto recuperado son los correctos. De forma que la recuperación se ha realizado con éxito. +1

El siguiente “escollo” era gestionar las propiedades de tipo “Lista”. La propiedad Segment de una de las clases que utilizo está definida como TPointList que a su vez es una lista de TPointInfo (una lista de puntos) que actualmente deriva de TList.

De forma similar a como hemos hecho antes con las clases que hemos transformado en derivadas de TComponent, ahora se trata de utilizar TCollection y TCollectionItem, para obtener ventajas similares y ver si utilizando los mismos métodos podemos almacenar y recuperar las estructura de clases. Algunos cambios que he tenido que realizar son los siguientes:

  • La clase TPointInfo ahora ha pasado a derivar de TCollectionItem y será unos de los elementos de nuestras listas de puntos.
  • La clase TPointList pasa de derivar de TList a derivar de TCollection.
  • Como hemos hecho anteriormente las propiedades definidas como public que nos interesan pasan a la sección published.
  • La clase TTrack al igual que hicimos antes pasa a derivar de TComponent para poder añadirle “persistencia”.
  • Algunos pequeños cambios en la implementación, necesarios para adecuar código al cambios de definición, pero que no han sido nada importantes .
  • Registrar la clase TTrack al igual que hicimos anteriormente con TWayPoint.

Una vez realizados los cambios he lanzado el siguiente código, que crea e inicializa con datos 1 objeto de la clase TTrack y sigue los mismo pasos que hemos realizado anteriormente. Volcar el contenido a un string y posteriormente recuperarlo sobre otro objeto de la clase.

0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
procedure TForm1.Button3Click(Sender: TObject);
var
  tr1, tr2:TTrack;
  po:TPaintOptions;
begin
  // crear un objeto TTrack
  tr1 := TTrack.Create(nil);
  // Rellenar la lista de puntos (TCollection)
  tr1.TrackPoints.AddPoint(nil, '2.345677', '4.123450', '123', '01/01/2013 10:10:10', 2.345677, 4.123450);
  tr1.TrackPoints.AddPoint(nil, '2.345678', '4.123460', '130', '01/01/2013 10:10:15', 2.345678, 4.123460);
  tr1.TrackPoints.AddPoint(nil, '2.345679', '4.123470', '134', '01/01/2013 10:10:20', 2.345679, 4.123470);
  // Asignar valores a PaintOptions (record)
  tr1.TrackPoints.PaintOptions.Width := 3;  
  list.TrackPoints.PaintOptions.Color := clNavy;
  // Asignar prop. TrackName
  tr1.TrackName := 'Track de ejemplo';
  // Volcar el contenido a String (Memo1 para el componente original)
  Memo1.Lines.Add(ComponentToStringProc(tr1));
 
  // recuperar el contenido y generar las clases
  tr2 := TTrack(StringToComponentProc(Memo1.Lines.Text));
  // debug del elemento creado (Memo2 para el objeto generado)
  tr2._debug(Memo2.lines);
end;

El resultado ha sido bastante parecido al esperado y además bastante aceptable.

Imagen335

Podemos ver en la imagen que a la hora de convertir el objeto, hemos “perdido” la información definida en el record TPaintOptions.  Para solventarlo basta convertir el record en una clase  (como hemos hecho con las otras), o en mi caso, pasar las dos propiedades a la clase, puesto que el hecho de que estuvieran dentro de un record era una simple cuestión “organizativa” y no “funcional”.

Por último, he completado el proceso con a estructura de clases completa y el resultado ha sido el esperado.

Os adjunto la estructura completa de clases tal y como ha quedado finalmente; Como podéis ver, no es algo simple, sino que se incluyen varios niveles. Lo que más me gusta de este método es que es independiente de la estructura de las clases. Es decir, si yo añado varias propiedades nuevas (y siempre que mantenga los normas que he comentado al crear las clases), sin ningún cambio el código seguirá grabando y recuperando el contenido de las clases sin problemas.

 

0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
  TTrackData = class;
  TPointInfo = class;
  TTrack = class;
 
  {Clase para encapsular la información de un punto.}
  TPointInfo = class(TCollectionItem)
  private
    FEle: string;
    FLon: string;
    FLat: string;
    FTime: string;
    FLatF: Double;
    FLonF: Double;
  public
    // constructor de la clase
    constructor Create(ACol:TCollection; ALat, ALon, AEle, ATime: string;
                       ALatF, ALonF:Double); overload; virtual;
  published
    property Lat:string read FLat write FLat;
    property Lon:string read FLon write FLon;
    property Ele:string read FEle write FEle;
    property Time:string read FTime write FTime;
    property LatF:Double read FLatF write FLatF;
    property LonF:Double read FLonF write FLonF;
  end;
 
  {: Clase para encapsular la información de un WayPoint.}
  TWayPoint = class(TPointInfo)
  private
    FNombre: string;
    FDesc: string;
    FSimbolo: string;
  public
    // constructor de la clase
    constructor Create(ATrack:TTrackData;
                       AWPNombre, AWPDesc:string;
                       ASimbolo:string;
                       ALat, ALon, AEle, ATime: string;
                       ALatF, ALonF:Double); overload;
    function _debug(TS:TStrings):string; override;
  published
    property Nombre:string read FNombre write FNombre;
    property Desc:string read FDesc write FDesc;
    property Simbolo:string read FSimbolo write FSimbolo;
  end;
 
  {: Clase para almacenar una lista de puntos.}
  TPointList = Class(TCollection)
  private
    function GetPoint(index: integer): TPointInfo;
  public
    procedure AddPoint(pointInfo:TPointInfo); overload;
    procedure AddPoint(ALat, ALon, AEle, ATime: string;
                       ALatF, ALonF:Double); overload;
    property Point[index:integer]:TPointInfo read GetPoint;
  published
    procedure _debug(TS:TStrings);
  end;
 
  TTrack = class(TCollectionItem)
  private
    FTrackPoints: TPointList;
    FPaintColor: Integer;
    FPaintWidth: Integer;
    FTrackName: string;
  public
    // constructor de la clase
    constructor Create(Collection: TCollection); override;
    destructor Destroy; override;
    procedure _debug(TS:TStrings);
  published
    property TrackPoints:TPointList read FTrackPoints write FTrackPoints;
    property TrackName:string read FTrackName write FTrackName;
    property PaintWidth:Integer read FPaintWidth write FPaintWidth;
    property PaintColor:Integer read FPaintColor write FPaintColor;
  end;
  {: Clase para encapsular datos de un segmento que forma un track.}
  TTrackList = class (TCollection)
  private
  public
    constructor Create(ItemClass: TCollectionItemClass);
    procedure _debug(TS:TStrings);
  end;
 
  {: Clase para encapsular los Waypoints de un Track.}
  TWayPointList = class (TCollection)
  private
  public
    procedure _debug(TS:TStrings);
  end;
 
  {: Clase para encapsular toda la información de un track.}
  TTrackData = class(TComponent)
  private
    FVersion: string;
    FXsi: string;
    FMaxLon: string;
    FMaxLat: string;
    FCreator: string;
    FHRef: string;
    FTime: string;
    FMinLon: string;
    FMinLat: string;
    FText: string;
    FTrackList: TTrackList;
    FWayPointList: TWaypointList;
  public
    procedure _debug(TS:TStrings);
    // Limpiar el contenido de la clase
    procedure Clear;
    // constructor de la clase
    constructor Create(AOwner: TComponent); override;
    destructor Destroy();
  published
    // Datos
    property Creator:string read FCreator write FCreator;
    property Version:string read FVersion write FVersion;
    property Xsi:string read FXsi write FXsi;
    property HRef:string read FHRef write FHRef;
    property Text:string read FText write FText;
    property Time:string read FTime write FTime;
    property MinLat:string read FMinLat write FMinLat;
    property MinLon:string read FMinLon write FMinLon;
    property MaxLat:string read FMaxLat write FMaxLat;
    property MaxLon:string read FMaxLon write FMaxLon;
 
    // Lista de tracks
    property TrackList:TTrackList read FTrackList write FTrackList;
    // Lista de WayPoints
    property WayPointList:TWaypointList read FWayPointList write FWayPointList;
  end;

La última prueba que he realizado con datos de ejemplo, es la que podéis ver en la imagen inferior, donde se ve la estructura completa de las clases.

result

La conclusión es que modificando levemente las clases originales hemos conseguido hacer un Backup/Restore sin necesidad de programar las correspondientes operaciones. Tal vez no sea

Os adjunto el ejemplo que incluye tanto los fuentes como la units con la estructura de clases completa. El ejemplo con los datos y en un fichero diferente el ejemplo compilado (Delphi 6).

<Código fuente del ejemplos -sources->
<Ejemplo compilado EXE>

Delphi, OOP, RTTI , ,

Una quincena más… (28/09/2012)

Jueves, 27 de septiembre de 2012

Ahora que estamos envueltos en mitad de las presentaciones del nuevo RAD Studio XE3, y que las novedades del nuevo RAd Studio se están comentando en la mayoría de blogs sobre Delphi y C++, yo estoy todavía aterrizando, con la vuelta al cole, la llegada de mis vacaciones y los cambios laborales.

Utilizaré esta entrada para “poner” un poco al día el blog y como siempre repasar las últimas noticias y reseñas, aunque en este caso seguramente de más de 15 días…

Ya he hablado antes del proyecto “Embarcadero MVP”; He añadido a los miembros existentes en el programa, los últimos nueve integrantes que han formado parte de él, tal y como informó Anders Ohlsson, en su blog. Entre ellos está Xavi Martínez, que muchos de vosotros conoceréis como Cadetill, y al que tuve el placer de conocer hace un par de días en la presentación de RadStudio XE3 en Barcelona.

Otro tema del que ya he hablado es la iniciativa de un “StackOverflow en castellano”; Recordaros que para esta iniciativa aun faltan algunos votos, animaros ver si entre todos lo conseguimos.

Estos días he leído una entrada interesante (como casi siempre) de Zarko Gajic sobre la clase TScreen, en esta entrada que titula “TScreen Object Desmytified”. Puedes leer la entrada y descargar los fuentes de los ejemplos.

Una de las nuevas características del nuevo Delphi XE3, es la creación de aplicaciones cuyo estilo se asemeja a “metro” de Windows 8. Desde esta web podéis descargar un set de iconos con estilo Metro de forma gratuita. Aquí podéis ver un ejemplo de los iconos disponibles (click sobre la imagen para verla a tamaño natural).

 

 

Como ya he comentado, estos días los blogs “echan humo” en cuanto a noticias  relacionadas con RAD Studio XE3; Entre todas ellas resalto la entrada en Delphi Insider con la esta tabla, donde se pueden ver de forma bastante esquemática las nuevas mejoras y cambios introducidos dependiendo de la versión del producto seleccionada…

Ayer leí en el blog de Fernando Rizzato,  que están disponibles para Delphi XE3 y para C++ Builder XE3 las JVCL en su versión 3.46.  JVCL es uno de los paquetes de componentes más ricos que existen para la la VCL con más de 600 componentes entre visuales y no visuales. Seguramente el mejor entre los paquetes gratuitos.

Igualmente ya está disponible, aunque no en versión definitiva (unstable version), la versión v. 0.9.9.635 de los cnPack,  que corresponde a la compatible con XE3. Para los que no los conozcáis, cnPack son una serie de addins para el IDE que enriquecen enormemente las posibilidades del entorno de desarrollo. Con las versiones más nuevas de los IDE’s, estas mejoras son menores (ya que los IDE’s van avanzando), pero si aun tenéis que trabajar en algunos proyectos con Delphi 6, por ejemplo (como es mi caso) entenderéis lo que os digo cuando los tengáis funcionando.

 

Ya comenté hace unos días en la entrada referente a la presentación de RAD Studio en Barcelona algo sobre el “RAD Studio Mobile”, uno de los elementos más importante del RoadMap de RADStudio. Aquí se puede ver el Roadmap concreto de  RAD Studio Mobile y descargar esa información en PDF si lo preferís.

Entrando en el terreno de los Offtopic, en lo que se refiere a la temática central del blog, estos últimos días, he leído sobre la compra de VirusTotal. para los que no lo conocéis, VirusTotal es una web que permite scannear en busca de virus un fichero que se suba, con los antivirus más conocidos del mercado. Es como tener la posibilidad de instalar 20 antivirus en tu propio equipo y utilizarlos de forma simultánea. Muy útil cuando se realizan descargas o cuando te envían ficheros por correo de los que quieres estar seguro 100%. Segun esta noticia Google la ha comprado. Hay webs parecidas, aunque a mi personalmente es la que más me gusta.

Si queréis probar podéis echarle un vistazo también a Jotti o a VirScan que tienen funcionalidades similares.

 

He actualizado el contenido de la web en DropBox para que estén en todo momento accesibles los ejemplos, artículos, documentación,… Más detalles de todo ello en esta entrada.
Si os vais a dar de alta os agradecería que usarais esta invitación, de esta forma a ambos nos ofrecen un poco más de espacio, que nunca va mal…  ;-)

Por último, una curiosidad. Si no tenéis claro qué significa el concepto de Recursividad, podéis buscarlo en Google y mirar qué palabra os propone realmente Google en el “Quizás quisiste decir…”, que aparece al inicio de los resultados. Al final resulta ser una gran explicación…  ;-)

Como siempre son bienvenidos los comentarios, correcciones, sugerencias, críticas,..

Un saludo y hasta la próxima.

 

Delphi, Resumen ,

Presentación RAD Studio XE3 en Barcelona.

Miércoles, 26 de septiembre de 2012

 

  Como en los últimos años, hoy he asistido a la presentación de la última versión de RAD Studio en Barcelona, que organiza Danysoft. Luis Alfonso Rey, Embarcadero MVP ha sido el encargado de hacer un repaso por la diferentes novedades y cambios que se incluyen en la nueva versión del paquete de desarrollo de Embarcadero.

IMAG0408

La presentación ha comenzado con un repaso por la nuevas características de esta versión.

  • metrostyleLa nuevas posibilidades para gestionar aplicaciones estilo “metrópolis” del nuevo Windows 8.
  • Novedades en Firemonkey (FM2), que incluye muchas mejoras a nivel interno pensando en las futuras aplicaciones que se le van a dar a esta librería. esas necesidades han obligado a realizar cambios en el código existente y no sólo mejoras (aunque también tiene de estas ultimas). Se han añadido características que en la versión inicial echábamos en falta en comparación con la VCL. Actions y actionList, los Anchors para ajustar a diferentes resoluciones de pantalla, mejoras en referencia a audio y vídeo, soporte para las últimas versiones de los sistemas operativos donde se “despliega”.
  • FM2El nuevo diseñador de LiveBindings. Cuyo nombre engaña, ya que no sólo se ha creado un diseñador visual, sino que junto con él, llegan importantes mejoras en las funcionalidades de los LiveBindings. Importantes las mejoras que tienen que ver con la visualización de datos en listas y grids. ahora mucho más sencillas de realizar y mucho más potentes que en la versión inicial.
    LB
  • Además se han comentado también los avances en C++ Builder para añadirle muchas de las características que hasta ahora le faltaban para igualarse en funcionalidades a la personalidad de Delphi.
  • HTML5Por último, como gran novedad la presentación de HTML5 Builder. La herramienta que “hereda” del antiguo RADPhp, aunque remodelada por completo. Nuevo IDE de desarrollo y nuevas tecnologías que utilizan al máximo las posibilidades de HTML5 y CSS3. Posibilidad para generar aplicaciones cliente y servidor que corran en dispositivos con Windows Phone, Android, iPhone, Symbian y Blackberry, utilizando phoneGAP.

   Aparte de dar el repaso por la novedades (las comentadas como más importantes y algunas menos transcendentes) también se han visto algunas de las cosas que podremos ver en próximas versiones o en actualizaciones que verán la luz antes de la aparición de la próxima versión. En concreto muy interesantes los minutos dedicados a “Mobile Studio”, que nos permitirá finalmente desarrollar con Delphi para dispositivos móviles.

IMAG0412

 

   Como siempre, además de lo que aporta la presentación en sí, las novedades, las demos, incluso la información de primera mano que se puede obtener, siempre es agradable encontrarse con amigos y antiguos compañeros de trabajo con los que vengo coincidiendo los últimos años.

   Este año además, hemos coincidido en Barcelona (me ha faltado de Salvador Jover), tres de los cuatro “Embarcadero MVP” que hay en España. También he tenido la oportunidad de conocer a Cadetill, del que muchas veces he comentado entradas aquí en mi blog. Hemos podido conocernos, conversar un rato, y comentar algunos aspectos relacionados con Delphi, los Blogs, la Comunidad,…

Estas son las cosas que “enriquecen” las presentaciones.

IMAG0418

   Las fotos como veis no son de mucha calidad ya que están hechas con mi teléfono, que tampoco es que sea una maravilla, pero al menos dan para hacerse una imagen de la sala y de algunas de las cosas vistas en la presentación.

IMAG0407

Un saludo y hasta la próxima.

Danysoft, Delphi, XE3 ,

XE3 y más allá: Mirando hacia la movilidad

Miércoles, 22 de agosto de 2012

Algunas veces compañeros y usuarios de los foros me comentan la dificultad de acceder a la información en los foros y blogs de Embarcadero, puesto que la mayoría de información está en Inglés. Algunos tienen más o menos problemas con el idioma y aunque muchos de nosotros nos ayudamos de los traductores automáticos, no siempre es fácil entender el “resultado”.

Hace un par de día apareció este artículo en los blogs de Embarcadero y me ha parecido muy interesante, para todos los desarrolladores que trabajamos con Delphi, porque aclara mucho hacia dónde se están dirigiendo los esfuerzos de Embarcadero y los que nos pueden deparar las futuras versiones de Delphi/C++.

La versión de Delphi que está a punto de salir (XE3) ”parece” que trae pocos cambios y mejoras, que poco a poco iremos conociendo, pero la realidad es que hay una “revolución en los bajos fondos” enfocada a las futuras versiones y a las próximas características

He dedicado un rato a traducirlo y publicarlo.
Valga decir que no soy ningún experto en estos temas; Leo sin problemas, pero no soy experto en el idioma, así que es bastante probable que la traducción no sea perfecta ni mucho menos. Sólo espero a que sea un poco más clara que la que ofrece cualquier traductor automático…  ;-D

___________________________________________________________________________

Link al artículo original (J T @ Embarcadero).

Estoy seguro que a estas alturas muchos de ustedes ya han visto los eventos programados del World Tour, sobre el próximo lanzamiento de XE3. Hay una gran cantidad de emocionantes novedades en XE3, que no podemos esperar a compartir con ustedes. Por ello le invitamos a alguno de los eventos del World Tour para que pueda descubrirlas. Con XE3 al caer, quiero detenerme un momento para hablarle de algunas cosas interesantes en las que estamos trabajando ya, para las versiones siguientes a XE3 -para ello XE3 y FireMonkey 2 (FM2) han sentado las bases.

Nuestros equipos están trabajando duro en la construcción de un nuevo conjunto de tecnologías y productos que traerán C++, Delphi, y FireMonkey a los dispositivos móviles, en la que será una solución diferente a cualquier otra del mercado. Esta solución incluirá un nuevo conjunto de herramientas para Delphi y C++ (frontend, backend, linker, debugger, run-time library, etc) dirigidas a conseguir que FireMonkey FM2 tenga una nueva plataforma de ejecución final dirigida a dispositivos móviles, junto con un entorno de diseño y desarrollo dirigido específicamente para plataformas móviles.

El lenguaje Delphi (front-end) está siendo mejorado para generar aplicaciones adaptadas para dispositivos móviles, añadiendo características de administración de memoria, tales como el contador de referencias automático. El nuevo backend de Delphi para tecnología móvil, es una novedad pensada y diseñada para generar binarios altamente optimizados para ARMv7. Esto incluye un nuevo linker y un nuevo debugger para trabajar con los formatos de objetos nuevos. Y, por último, tanto la biblioteca en tiempo de ejecución y el framework FireMonkey, están siendo optimizado para dispositivos móviles, con la eliminación de funcionalidades de escritorio innecesarias y añadiendo características específicas para dispositivos móviles.

Si bien hay una gran cantidad de nuevas funcionalidades que vendrán en las herramientas de compilación, en el nuevo framework FireMonkey para móviles, se aprovecharán las nuevas características del lenguaje Delphi en gestión de memoria y las características específicas para móviles; Como interfaces de usuario nativos para iOS y Android con una visualización perfecta de los controles a nivel de pixel, así como interfaces de usuario personalizadas (que pueden compartir estilos personalizados con la aplicaciones de escritorio de XE3), y un conjunto de servicios para los sensores de hardware, tales como GPS, acelerómetros, giroscopios, y cámaras, y los servicios del sistema operativo, como la ubicación, la publicidad, y las aplicaciones de pago. Y aunque los nuevos productos para dispositivos móviles incluirán nuevas herramientas específicas, FireMonkey FM2 para móviles, y un entorno de desarrollo específico para móviles, estos productos están siendo diseñados para poder aprovechar de forma fácil, los proyectos para MAC y para Windows ya existentes.

En XE2, entregamos las herramientas para ayudar a migrar aplicaciones FireMonkey de Windows a XCode y FPC, lo que permitió a los desarrolladores migrar proyectos de escritorio a XCode y recompilar estos para generar binarios dirigidos a dispositivos basados iOS. Con algunos ajustes, un desarrollador podía coger una aplicación de escritorio FireMonkey y generarla para iOS sin una cantidad significativa de esfuerzo. La desventaja de este enfoque es que las aplicaciones que se ejecutan en dispositivos móviles utilizan el marco FireMonkey diseñado para las aplicaciones de escritorio, por lo que las experiencias de usuario y el rendimiento no estaban a la altura a menos que los controles se adaptaran por completo. Algunos desarrolladores han creado aplicaciones increíbles para móviles basadas en XE2, pero con un esfuerzo significativo. Además, no había ninguna experiencia de desarrollo integrando el IDE de Xcode. Las herramientas de migración en XE2 son una prueba de la capacidad multiplataforma de FireMonkey. En lo que estamos trabajando ahora para nuestro desarrollo móvil de próxima generación, es en ofrecer la mejor solución de desarrollo para dispositivos móviles a los desarrolladores.

Como resultado de los cambios en el lenguaje enfocado a dispositivos móviles y los cambios en FireMonkey (que se ejecutará en los dispositivos móviles), FireMonkey FM2 ya no es compatible con el conjunto de herramientas FreePascal utilizado para compilar aplicaciones para iOS con XCode. Por lo tanto, las herramientas de migración entregados en XE2 ya no se incluyen en XE3 y las aplicaciones FireMonkey FM2 de escritorio no serán compatibles con FreePascal y XCode. Sin embargo, como cliente de XE3 usted tendrá acceso al producto XE2 que puede seguir utilizando con FireMonkey XE2 para crear aplicaciones para iOS con Xcode y FreePascal.

Nuestras soluciones para dispositivos móviles de próxima generación, están todavía en desarrollo y serán la primera y única solución nativa de tanto para iOS y Android, que compartirán un código común (también con los proyectos de escritorio de XE3). Esta será una solución revolucionaria para los desarrolladores, que ofrecerá el mejor rendimiento en las plataformas móviles más importantes; Con un único entorno de desarrollo, un solo lenguaje (Delphi o C++), un framework y un único código para todos. Creemos que usted estará muy contento con las capacidades de ejecución y flujo de trabajo de desarrollo para dispositivos móviles; Y si usted está interesado en formar parte de la fase de pruebas (beta), recoja su copia de XE3* para poder acceder a la beta móvil, y verá que estamos muy entusiasmados con todo esto.

Mientras tanto, nos vemos en la gira mundial!

 

* El acceso a la beta móvil requiere una licencia “Professional” de XE3 o posterior.

__________________________________________________________________________

Como siempre se aceptan correcciones y sugerencias.

Si alguien considera que alguna frase no es del todo correcta o no refleja fielmente la explicación ariginal, el comentario será bienvenido.

Un saludo.

 

Delphi, Embarcadero, Traducciones , ,

Una quincena más… (17/08/2012)

Viernes, 17 de agosto de 2012

Una semana más estamos con el repaso habitual de los últimos días.

Es estas fechas, todo (o casi todo) se ralentiza, los que no están de vacaciones, están con el ritmo de Agosto y de las vacaciones, al menos por aquí.  Uno de los pocos que no descansa es Salvador, que justo el día después  de publicar mi última entrada de resumen donde comentaba sus 2 primeros artículos sobre el componente TTreeView en FMX, publicaba la tercera y última entrega.

Las dos primeras:

costesmac En esta tercera entrega, se completa la serie sobre este componente ampliando lo visto en las dos anteriores. Se muestra un ejemplo completo de trabajo, nuevas clases, creación de Interfaz común a varios objetos, estilos personalizados y algunas cosas más.
Fantástica entrada para acabar la serie sobre este componente.

Arbol TTreeView en Firemonkey (y III)

Para complementar el artículo, podéis ver un video comentado y descargar todo el código fuente del proyecto.

Esta semana me  encuentro con el proyecto DelphiUnitSize, programado en Delphi XE2 y utilizando FireMonkey. Con él podemos conocer el tamaño exacto de las units que se incluyen en nuestro proyecto (EXE). Además nos da un tamaño aproximado de los símbolos (classes, métodos, procedimientos,…) contenidos en cada unit.

delphiunitsizes

En la página del proyecto podéis ver unas pequeñas guías para su utilización y configuración.

Es bueno ver que poco a poco se van viendo más programas que utilizan FireMonkey; Eso es una señal inconfundible que marca si una tecnología es “utilizable” en el mundo real o no.

images La técnica de “Class Helpers” es muy interesante y sencilla, a la vez que polivalente. Ya Salvador habló algo de ella en alguna de sus entradas sobre TreeView (link), haciendo a su vez referencia a un entrada de Carlos García (link). Desde Embarcadero podéis revisar este artículo titulado “Class Helper’s with Firemonkey” que aplica esta misma técnica a FireMonkey y revisar la DocWiki de Embarcadero donde se explica de forma sencilla cómo aplicarla a clases y a records (que también la admiten).

fm

Desde la página de Embarcadero, se han publicado una serie de documentos sobre desarrollo de FireMonkey en Windows y MAc, con el título “Get Started with Windows and Mac development”, que incluye una serie de PDF’s y videos para desarrollar con FMX.

Recordaros, desde este resumen, aunque ya lo he comentado en el blog, la iniciativa  de conseguir un “StackOverflow in SPanish”. Creo que es una buena iniciativa para la Comunidad y podeís leer toda la historia desde el Blog de Jachguate.

sigue-la-propuesta

 

Una vez más en estos resúmenes (ya es habitual) una reseña a los componentes de Cadetill para trabajo con Google Maps; La librería GMLib en su versión 0.1.6a, que se ha publicado estos días.

Aquí podeís revisar la lista de novedades de la última versión que no son pocas.

images (2) A través de un enlace que me facilita Salvador, accedo a una interesante (muy interesante) serie de tutoriales (step-by-step) de Pawel Glowacki sobre DataSnap. Muy completos con Video, WhitePaper y Código fuente necesario.

http://www.embarcadero.com/ru/rad-in-action/delphi-labs

Por último y para acabar, supongo que ya lo habréis leído estos días en foros y blogs. Ya se ha anunciado la próxima salida de RAD Studio y el RAD XE3 World Tour con las fechas de todas las presentaciones. Faltan en la lista, las de América Latina que están por concretar, en lugar y día.

La lista completa de presentaciones (países y fechas), a las que ya os podéis apuntar está aquí.

No ha trascendido mucho la lista de novedades (completa, al menos), salvo algún documento que se ha filtrado y que ha aparecido en blogs extranjeros. Está claro que Embarcadero apuesta por la nueva interface Metro o “Modern UI” como le gusta a MS que la llamemos, enfocado a los dispositivos táctiles. La referencia a FM2 nos hace pensar que siguen avanzando en la tecnología FireMonkey y nos prometen una nueva herramienta para incorporar a RAD Studio, HTML5 Builder.
Habrá que ver en acción qué nos depara esta nueva versión.

Para Barcelona y Madrid tendremos que esperar al 25 y 26 de Septiembre. Espero que nos vemos.

Un saludo y hasta la próxima.

Delphi, Embarcadero, Resumen , ,

Una quincena más… (30/07/2012)

Lunes, 30 de julio de 2012

imagesRetomando un poco (o eso espero) el ritmo de las entradas, para los que estéis interesados  en FireMonkey y en las posibilidades de realizar animaciones y aplicaciones con características 3D, os remito al canal de youtube de ketufe. Podéis encontrar desde ejemplos sencillos y algunos no tanto. Los videos dan ideas de las diferentes posibilidades a utilizar. Hay mucho material para revisar, ya que el canal cuenta con más de 100 videos.

Aquí podemos encontrar un pequeño tutorial de Document Insight; La herramienta de documentación de DevJet Software que viene incluida de forma gratuita con Delphi XE2. Es una de aquellas cosas que no son fáciles de encontrar en la documentación (o que no encontramos directamente) pero que son tremendamente útiles, para los que desarrollamos componentes y librerías que luego utilizan otros programadores. En estos casos la documentación en necesaria (obligatoria diría yo) y además a la larga significa una mayor eficiencia a la hora de programar.

No hace muchos días de la publicación en la página de Salvador (Delphi básico) de dos entradas dedicadas al componente TTreeView en Firemonkey; Yo diría que indispensables para los que queráis empezar a trabajar con él y entender bien su funcionamiento.

Las dos entradas hacen un completo repaso de este componente de este componente y su utilización en Firemonkey. Las diferencias que existen entre este y su versión en la VCL, repasando propiedades, métodos y distintos comportamientos. Muy recomendable por lo compleja y extensa que es. La explicación es muy clara y podéis descargar los códigos de ejemplo para poder realizar las pruebas sin problemas. No os desvelo más del contenido del artículo, que lo hay, os invito a que lo reviséis completo. ;-)

 demo3

 

Esta semana, también ha visto la luz la siguiente versión de los componentes de Cadetill para trabajar con Google Maps. La librería GMLib; En este caso la versión 0.1.5a. Añaden bastantes correcciones y nuevas funcionalidades respecto a la anterior versión.

47_web20_320x240_gmlib 

“GMLib (Google Maps Library) son una serie de componentes para Delphi que encapsulan el API de Google Maps y así poder gestionar los mapas de Google de forma sencilla mostrando el resultado en un TWebBrowser.“

 

Siguiendo con el tema de FireMonkey, desde hace unos días podemos descargar desde la web de Embarcadero de una versión “free” de la herramienta de conversión entre VCL y FireMonkey llamada Mida. No he tenido tiempo de probarla, así que si alguien tiene oportunidad estaría bien que compartiera sus experiencias. Trabaja con componentes de terceros, además de los estándard, LiveBindings, Estilos y bastantes cosas más, aunque no todas disponibles en la versión gratuita.

Icarus_48También estos días se ha liberado la versión 3.4.4 de Icarus. Se trata de una utilidad gratuita de la casa Peganza (http://www.peganza.com) la misma que comercializa PAL (Pascal Analizer). Icarus es una “analizados de units”; Permite analizar el código de proyectos Delphi en busca de units no necesarias añadidas al uses o de aquellas que pueden ser movidas entre las secciones de Interface e Implementation.

Hoy mismo leo sobre la La versión 2.6 de las DDevExtensions se ha liberado estos días. Podéis descargarla para las diferentes versiones de los compiladores y leer sobre los cambios y correcciones de la última versión en este link (DDevExtensions 2.6). Gran trabajo que va mejorando versión a versión.

Poco a poco van apareciendo componentes nativos para FireMonkey. Es una tecnología nueva para los que trabajamos con las herramientas de Embarcadero y es normal que el arranque cueste un poco. Ya conocía un paquete de componentes específicos de la mano de TMS y estos días he leído que arcana también ha publicado Apesuite, una serie de componentes para FMX.
Siempre es una buena noticia que las empresas apuesten, se involucren y vaya generando componentes para FMX.

Por último os dejo esta completísima recopilación de reursos para FireMonkey. Si deseáis introduciros en este tema y empezar a hacer “pinitos” con esta tecnología debéis guardaros esta recopilación. Además de la propia documentación de Embarcadero, aquí podéis encontrar una amplia variedad de links que abarcan bastantes aspectos.

Introduction

Styles

What about the VCL?

Networking

IDE

Forms

File I/O

Video and sound

DataSnap

Controlling other programs

Printing

3D animation

Runtime packages and DLLs

Component development

Errors

Bugs

Third Party

 

    Un saludo y hasta la próxima.

Delphi, FireMonkey, Resumen ,

Una quincena más… (27/06/2012)

Martes, 26 de junio de 2012

Perdonad, por la tardanza de esta última entrada; Comencé a crearla hace bastante tiempo (algo más de un mes) y es posible que alguna de las referencias ya esté anticuada (1 mes en un mundo de la “información inmediata” como el nuestro, ya es mucho).

47_web20_320x240_gmlib “Se ha publicado la versión 0.1.4 de los componentes de Cadetill para acceder a Google Maps; GMLib (Google Maps Library) son una serie de componentes que encapsulan el API de Google Maps para poder gestionar los mapas de Google de forma sencilla mostrando el resultado en un TWebBrowser.”

Tienen muy buena pinta. Podéis revisar el diagrama completo de la estructura de clases aquí, y la descripción de todas las clases en la siguiente página.

En la misma página, aunque ya es más antiguo podéis encontrar el componente TWebControl, que engloba y facilita realizar cierta operaciones con el componente WebBrowser de Delphi.

En el Grupo de Delphi Solidario (facebook), salió hace días la referencia a un problema (de nuevo) recurrente que me he encontrado en mi blog, en los foros y en algunas páginas en relación a las RxLib. Se trata de que alguna compilación para Las últimas versiones, incluye un bug (curioso, como mínimo) que hace que los Caption del TLabel sólo admita 2 caracteres. Se ha añadido también un report a QualityCentral de Embarcadero que podéis encontrar aquí.

En el grupo De Facebook, se habla de cómo remediarlo de forma “temporal” (todavía no he tenido tiempo de revisarlo a fondo) comentando la línea que registra el editor de propiedades que posee el problema y se apunta también la función que lo contiene GetEditLimit.

Desde Danysoft leo estos días una promoción/oferta para conseguir RAD Studio por 99€. Podéis leer más detalles aquí.

ltdapigrafg También desde Danysoft leo que se pueden descargar Los tomos de Delphi : El API gráfico Win32 gratis. Visitad el enlace si estáis interesados.

UPDATE: Me ha llegado un correo con enlaces a la lista completa de los libros que se pueden descargar (no sólo el comentado más arriba) y también los links de acceso al código fuente que viene con ellos. Algunos de ellos verdaderas joyas.

Esta semana también he hecho referencia en el Blog a un seminario web gratuito: 4 horas con Delphi para el día 22 de Junio. Revisad la información a aprovechad la oportunidad si podéis.

AÑADO: Ya están disponibles los vídeos (replay) de las sesiones del seminario. Aquí tenéis la página del evento con las descripciones detalladas de cada uno de los vídeos.

Parte 1 : Las nuevas fronteras de la interfaz de usuario.
Parte 2 : ¿Qué puede ganar un desarrollador con FireMonkey?
Parte 3 : Mejorando las aplicaciones cliente/servidor
Parte 4 : La Web y las aplicaciones móviles al alcance de la mano.

Hoy además me ha llegado este enlace para acceder a los contenidos de otros seminarios; Todos los del primer semestre de este año.

276807_120437051391680_417892041_n

Por último, animaros a que si todavía no habéis visitado el grupo de facebook de Delphi Solidario lo hagáis. Ya son 250 personas (hasta el momento) las que lo formas y cada día se suma mas gente.

Un saludo y hasta la próxima.      ;-)

Delphi