XE4 Iberian Tour (Madrid, Lisboa y Barcelona)



Miércoles, 8 de mayo de 2013

XE4 Iberian TourComo ya es habitual, desde Danysoft (distribuidor oficial de Embarcadero en la península ibérica) se organiza la presentación del nuevo RAD Studio XE4.

“El nuevo RAD Studio XE4 sigue renovándose para proporcionar a los desarrolladores una herramienta que responda a los nuevos retos en la creación de aplicaciones, al tiempo que permite mantener y evolucionar proyectos anteriores.

Pero sin duda, la utilización de la plataforma FireMonkey para crear aplicaciones con una sola base de código, que se ejecutan natívamente en distintos dispositivos y plataformas es una de las más importantes.

Además revisaremos las importantes novedades en bases de datos, entre las cuales FireDAC es la principal.”

Si queréis más información del evento visitad la página de presentación.

Danysoft, 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 , ,

Una semana más… (18/04/2012)



Miércoles, 17 de abril de 2013

Retomando la costumbre de analizar cosas relacionadas con este blog que van pasando durante la semana (o la quincena o el mes,…) vuelvo con una entrada más.

PortadaLibroEsta semana me ha llegado el anuncio de un nuevo libro publicado por Danysoft y de la mano de Francisco Charte. Gran noticia, ya no sólo por el libro en sí, sino por lo que significa. Desde hace un tiempo sólo hemos podido disfrutar de buenos libros sobre Delphi en Inglés. De un tiempo acá esa tendencia está cambiando de la mano de Danysoft. Primero con la publicación del libro sobre XE2, “La guía de Delphi” también de Francisco Charte y ahora con la publicación de “La guía de HTML5 Builder”.

47_web20_320x240_gmlib_thumb1Esta semana también se ha publicado la primera versión final (la v.1.0.0) de la librería de componentes GMlib de Cadetill. Para conocer más detalles de esta librería podéis leer la descripción completa (Español / Inglés) en la página de los componentes. Allí podéis ver la descripción, funcionalidades, clases y todo lo necesario para trabajar con ellos. Personalmente he trabajado con ellos y además de que funcionan muy bien, son un gran trabajo de diseño. Muy recomendables y superiores a algunos paquetes comerciales con un objetico similar.

Otra librería que últimamente ha sufrido “cambios” en su estado ha sido GH Freebrary de Alberto González. Renovada y que Al ha publicado con licencia Open Source. En esta publicación en los foros del club delphi, podéis ver la introducción de Alberto e información sobre la librería. En relación con esto, en los propios foros del clubdelphi se ha creado un nuevo espacio dedicado a esta librería, donde poder publicar ejemplos, dudas, mejoras,…

Siempre es bueno ver cómo nacen nuevos espacios de difusión para Delphi. Cuanta más información exista y cuantas más personas se decidan a publicarla mejor para los que trabajamos en Delphi. Y sobre todo, si además es en castellano. Esta semana he llegado a este blog “Aprendiendo Firemonkey”, de José Luis Rocha. Relativamente “joven”, pero espero que siga adelante.

Por último y para cerrar esta entrada, ayer mismo hemos empezado a escuchar campanas sobre la salida de la nueva versión de Delphi (XE4). Andreano Lanusse habla en su blog en que en apenas unos días saldrá esta nueva versión. Las mejoras sobre el compilador para iOS y FireDAC (que promete mucho) parece que serán las novedades más importantes de esta nueva versión.

NOTA: Al poco de cerrar y publicar la entrada, me ha llegado el pedido que tenía hecho. Ya tengo mi copia.  ;-)

HTML5 Builder

Un saludo y hasta la próxima.

Danysoft, Offtopic, Resumen

Juega con esta o cualquier otra web en 3D (Google Labs)



Martes, 16 de abril de 2013

Me encantan estas “cosas” que hacen la gente de Google. Tiene pinta de que se lo pasan bomba…  ;-)


YouTube DirektLa web en Chrome Maze

Enlace: http://www.chrome.com/maze/

Un saludo.

 

Otros ,

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 , ,

Feliz Cumpleaños Delphi!



Jueves, 14 de febrero de 2013

Delphi acaba de cumplir la mayoría de edad. ¡¡Enhorabuena!!

Collage_Delphi2

Offtopic , ,

Felices Fiestas!



Viernes, 21 de diciembre de 2012

Aprovecho la felicitación que hemos realizado las personas que formamos el Proyecto de DelpHispano, para desearos a todos los que visitáis este blog, unas Felices Fiestas.

Felicitación

 

Un saludo.

Otros ,

Programas multiidioma con Delphi



Jueves, 25 de octubre de 2012

flags-all-countries_6130Ya he hablado en otras ocasiones de cómo generar un aplicación multiidioma en Delphi y de paquetes tanto comerciales, como los componentes siComponents, como de código abierto como GNU GetText. En esta entrada hablaba de ambos y explicaba cómo acometer este proceso.

Aplicación multiidioma con GNU GetText

Hace tiempo había revisado el sistema de internacionalizar aplicaciones de Delphi (en este caso en la versión 6) y no me pareció muy intuitivo, tal vez también por falta de algo de documentación. Por lo que he visto en las versiones nuevas, pocas cosas han variado en el proceso y en las herramientas que trae el IDE.

En este caso me he visto obligado por las circunstancias a utilizarlo, y aunque a priori me ha resultado un poco “confuso”, como en su momento, una vez puesto en marcha, el sistema la verdad es que no es complejo y funciona de forma bastante sencilla. Se echa en falta que determinados aspectos sean un poco más potentes, como el editor de traducciones o el repositorio y la forma en que funcionan. Estos dos elementos realizan su función pero son bastante básicos en comparación con otros paquetes que hay en el mercado.

El sistema de traducción de Delphi, se basa en añadir todos los recursos traducidos a una DLL; Una para cada idioma que necesitamos añadir a nuestra aplicación.


EL PROYECTO

Imagen44Para ver el proceso completo de internacionalización crearemos un proyecto sencillo, con dos formularios y veremos que es relativamente rápido montar toda la estructura para que funcione en varios idiomas.

Algunas etiquetas, un memo con algunos strings, unos botones y un segundo formulario para comprobar un ejemplo con más de uno y un TComboBox que nos permitirá modificar el idioma en tiempo de ejecución.

Una vez que tenemos nuestro proyecto funcionando, comencemos el proceso para añadirle dos nuevos idiomas, en este caso el catalán y el inglés, al que ya tiene por defecto (español o castellano).


INTERNACIONALIZACIÓN

Para ello lo primero que debemos hacer es añadir los 2 nuevos idiomas desde el menú de Project.

en la imagen inferior podéis ver las pantallas del asistente, aunque no tiene ninguna complicación y lo que hacemos con él es añadir los idiomas (tantos como necesitemos) a la aplicación.

internacionalizacion

Una vez finalizado el asistente, veremos que el IDE ha generado dos proyectos más (en nuestro caso) correspondientes a los idiomas que hemos seleccionado.

Imagen45

Podemos probar a compilar y grabar todos los proyectos.

Lo siguiente es comenzar a traducir las cadenas para poder utilizar múltiples idiomas en la aplicación. El editor de cadenas es similar a muchas otros aplicaciones que hay para esta función. Se trata de una pantalla que nos muestra las cadenas actuales y donde debemos introducir las cadena introducidas.

Para acceder al “Translation Manager” podemos hacerlo desde el menú en: “Project / Languages / Update resource DLLs”.

Imagen47

En esta pantalla vemos a la izquierda la estructura del proyecto y los diferentes formularios que lo componen. A la derecha la zona que nos permite traducir las diferentes cadenas. Hay columnas que identifican el elemento (ID), la que contiene las cadenas en el lenguaje original de la aplicación y la que contendrá las cadenas traducidas, en este caso con el título de “Inglés (estados Unidos)”.

He marcado en rojo una cadena que ya aparece traducida automáticamente (&Cerrar – &Close).  Este es debido a que esta cadena ya está traducida en el repositorio.


EL REPOSITORIO

El “Transation Repository” o “Repositorio” es como un diccionario de traducciones que podemos ir ampliando a medida que traducimos aplicaciones. De esta forma, podemos reutilizar las cadenas que ya hemos traducido anteriormente (en la misma aplicación o en otras). En el ejemplo que estamos viendo, mi repositorio ya tiene incluida la traducción desde el Español (internacional) al Inglés (Estados unidos) de la palabra &Cerrar. Por eso al acceder a las traducciones, esta palabra ya aparece traducida.

Imagen48El repositorio nos permite acelerar la traducción de términos. Además posee opciones para importar y exportar traducciones, con lo que podemos compartirlos o incluso utilizar herramientas de traducción automáticas externas e importar las traducciones a él.

Una vez que las cadenas están traducidas para los formularios podemos añadirlas al repositorio desde el “Translation Manager” , para tenerlas disponibles más adelante.


EJECUCIÓN

Una vez traducidas y añadidas al repositorio todas las cadenas de los diferentes idiomas, compilamos los proyectos, tanto el original, como los de los diferentes idiomas.

Para probar la ejecución, podemos seleccionar desde el menú de “Project” cual es el idioma que queremos por defecto. Si probamos con alguno de los 2 idiomas y ejecutamos, veremos que efectivamente la aplicación, como era de esperar.

Por último, nos quedaría ver cómo modificar el idioma durante la ejecución de la aplicación. Es bastante simple y para ello hay una sección en la ayuda del propio Delphi a la que podéis acceder; Dentro de la “internacionalización de aplicaciones” hay un tema concreto llamado “Dynamic switching of resource DLLs”. Allí se puede leer que basta con añadir la unit Reinit en el uses, y utilizar una línea como la siguiente para cambiar el idioma.

0
1
2
3
// Cargar los recursos y releer los forms
if (LoadNewResourceModule(lang) &lt; &gt; 0) then begin
  ReinitializeForms;
end;

Comentar que si en alguna versión de Delphi, no encontráis la unit ReInit, podéis buscar dentro del directorio de Demos.

Al final el código que hay más arriba va a ser el único que vamos a necesitar en la aplicación.

Para apoyar la entrada, además del código de ejemplo, he añadido en este caso un vídeo.

 


YouTube Direkt

Como siempre podéis descargar el código del ejemplo desde este link.

<DESCARGAR CÓDIGO FUENTE>

Espero que os haya sido útil y hasta la próxima.

Ejemplos, Multiidioma, XE3 , ,

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 ,