Archivo

Entradas Etiquetadas ‘XE2’

Testeando XE2 (aplicación FireMonkey…)

miércoles, 9 de noviembre de 2011 9 comentarios
Share Button

Hace unas semanas comencé a “trastear” con XE2, con FireMonkey, con los liveBindings, estilos y algunas características más…  Estuve posteando aquí las primeras impresiones y los resultados de esas  primeras pruebas.

En esas entradas he realizado un primer acercamiento a estas tecnologías, he dado un repaso y he testeado por encima algunas de sus características. La idea ahora, es ir un poco más allá.

He leído en algunos foros opiniones sobre que FireMonkey está “a medias” o “incompleto”. Respeto esas opiniones, pero personalmente no estoy de acuerdo. Creo (y aquí es donde puede estar el error ) que se compara a FireMonkey con la VCL y las características que posee esta. Desde ese punto de vista sí puede parecer que  “le faltan cosas” y eso puede dar una sensación de que es una tecnología inacabada.

Pienso que el objetivo final de FireMokey no es, llegar a conseguir todas las características con las que cuenta la VCL. Es algo totalmente nuevo que avanza en una dirección paralela, algunas cosas tendrá sentido “adoptarlas” y otras no, pero a mi entender eso es “añadir” no “completar”.

Hace tiempo publiqué en el blog un pequeño ejemplo de cómo cargar ficheros  GPX  (alternativa generando KML) procedentes de dispositivos GPS y visualizar esos tracks o rutas en una Aplicación  Delphi. Me he decidido por intentar realizar esta pequeña aplicación utilizando FireMonkey.


TActionList, ¿dónde está?

Lo primero que me he encontrado, aunque en realidad ya lo había visto en las primeras pruebas, es que no puedo utilizar un TActionList.  Este componente no está en la paleta donde debería estar o donde uno esperaría encontrarlo. Una cosa que sorprende es que los componentes estandard de FireMonkey sí poseen la propiedad Action para poder asignar un elemento. No es que sea imprescindible, pero es muy cómodo.

Lo siguiente que me planteo es la importación de datos desde un fichero GPX. En su día la hice utilizando el XMLmapper, pues los ficheros GPX son en realidad ficheros XML. Me propongo utilizar el mismo modelo utilizado anteriormente;  Importar el fichero GPX a un TClientDataset para getionarlo después de forma local.

TXMLTransformProvider, ¿dónde está?

Al igual que me ha pasado anteriormente, coloco un TClientDataset y cuando voy a colocar el TXMLTransformProvider no está donde esperaba encontrarlo.

He realizado un par de pruebas y lo más curioso es que creando y configurando el componente “a mano” funciona perfectamente. Con un código como este y configurando los campos apropiados en diseño el componente funciona perfectamente, importa los datos e incluso se pueden configurar LiveBindings para mostrar el resultado en un Grid.

0
1
2
3
4
5
6
  XMLTransform := TXMLTransformProvider.Create(nil);
  XMLTransform.TransformRead.TransformationFile :=
    'd:\Ficheros GPX\GPX_To_DP.xtr';
  XMLTransform.XMLDataFile :=
    'd:\Ficheros GPX\Ruta3.gpx';
  ClientDataSet1.SetProvider(XMLTransform);
  ClientDataSet1.Active := True;

Una vez activado el componente la importación se realiza sin problemas.

He dejado de lado esta cuestión por ahora; Tal vez más adelante me detenga para probar más cosas, pero para seguir adelante he realizado la importación de datos “manualmente”, de forma que una vez conseguidos los datos en el TClientDataSet y puedo continuar a tratarlos.

El siguiente paso es colocar los elementos en el formulario, tal como van a ir distribuidos. Una cosa a la que hay que acostumbrarse es que los componentes de FireMonkey no poseen la propiedad

Anchors, que tan útil nos es utilizando componentes de la VCL. A cambio podemos ver que la propiedad Align posee una cantidad de valores superior que nos permite realizar más cosas. En este caso utilizamos la propiedad Align y la propiedad Padding para ir fijando los controles al formulario tal y como deseamos.

Se trata de conseguir lo mismo, pero por un camino diferente…

Una vez que los componentes básicos ya están colocados necesito plasmar en pantalla una serie de coordenadas. Para ello he escogido el componente TPath. La idea es que permite representar una serie de puntos que forman una línea o camino.
La potencia y la velocidad llaman la atención, pero también la sencillez.

 

Basta con soltar el componente en pantalla y utilizando la propiedad Data, colocar lo siguiente para conseguir una imagen (o path) como el que veis más abajo (se puede hacer en diseño utilizando un pequeño formulario de edición):

M 0,2 L 1,2 L 1,5 L 2,5 L 2,2 L 3,2 L 1.5 0 L 0,2

Si lo pensáis un poco, no son más que coordenadas precedidas por el tipo de “unión” o “elemento” que queremos utilizar entre ellas; la Primera M se refiere a MOVER, las L se refieren a LINEA.

Es así de sencillo y así de potente.

Un código como este, os podéis imaginar lo que dará como resultado:

0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
for I := -360 to 360 do begin
    n := DegToRad(i);
    res := Sin(n);
    //res := Sin(n) * Sin(n);
    //res := Tan(n);
    if (Str = '') then begin
      Str := 'M ' + FloatToStrF(n, ffFixed, 35, 10) +
              ' ' + FloatToStrF(res, ffFixed, 35, 10);
    end
    else begin
      Str := Str + ',' + 'L ' + FloatToStrF(n, ffFixed, 35, 10) +
             ' ' + FloatToStrF(res, ffFixed, 35, 10);
    end;
  end;
  Path1.Data.Data := Str;

Con esto más o menos ya está todo completo. Los componente básicos ya están escogidos.

He utilizado LiveBindings para poder mostrar los datos en de las coordenadas en un TStringGrid; También he aplicado un estilo visual a la aplicación y por último una par de animaciones para dar más vistosidad a la visualización del track.

La conclusión que saco, es que  sí se pueden hacer aplicaciones con FireMonkey, lo que pasa que tal vez en algunos aspectos debamos pensar las cosas con otro enfoque o hacerlas de otra manera. Seguramente está en los planes de Embarcadero (eso espero) ampliar sus funcionalidades y el número de componentes.

Por último comentar que me he quedado con la ganas de poder compilar la aplicación y generarla para iOS, pero por ahora, no dispongo de los medios para hacerlo. Sobre todo me queda la duda de qué hubiera pasado con una aplicación, de un programador como yo con “visión de Windows”, al compilarla en MAC.

¿Algun error? ¿Algun problema? ¿Warinigs? ¿Algun elemento que no puedo utilizar?  ¿?¿?¿?

Si alguien se anima a hacerlo, le agradecería que nos comunicara el resultado y me enviara alguna pantallita.   ;-)

Os dejo los enlaces al código fuente y al ejecutable (este último comprimido con UPX) junto con algunos ficheros GPX que podéis usar para las pruebas.

<Descargar el código fuente>

<Descargar binario – EXE>

[wpfilebase tag=file id=1 /]

[wpfilebase tag=file id=2 /]

NOTA: Acabo de corregir un par de errores en el código y añadida la DLL (midas.dll) porque quien no la tenga no podrá ejecutar la demo (gracias Rafa).

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

Un saludo y hasta la próxima.

Share Button
Categories: Aplicación, Delphi, FireMonkey, XE2 Tags: ,

Entrevista con Pawel Glowacki

lunes, 17 de octubre de 2011 2 comentarios
Share Button

A finales de Septiembre se celebraron las presentaciones de RAD Studio XE2 en Barcelona, Madrid y Lisboa. Como siempre, organizadas por DanySoft (partner oficial en la península) y en este caso con la presencia y colaboración de Pawel Glowacki.

1109ba04g
Foto de Pawel y Daniel Valenzuela de Danysoft, durante las presentaciones.

Si queréis saber más de las presentaciones, podéis ver un resumen de cómo fueron las conferencias (sobre todo la de Barcelona) en las entradas de nuestros blogs, y también podéis encontrar más información y fotos en el grupo de Facebook (Delphi Solidario).

danylogo Desde hace un tiempo, Danysoft, como partner de Embarcadero, está haciendo un esfuerzo importante por fomentar las webs, blogs y foros españoles, de sus herramientas de desarrollo; Un esfuerzo por fomentar ”La Comunidad Hispana”, como nos gusta llamarlo a nosotros, y también un esfuerzo para que encontremos ese apoyo que en ocasiones les hemos reclamado. A raíz de esto, y cuando ya se estaban preparando las presentaciones (en concreto la de Barcelona), tanto a Salvador como a mi, nos brindaron la oportunidad/posibilidad de mantener una breve y amistosa charla con Pawel (como representante de Embarcadero) y con ellos, los chicos de Danysoft en Barcelona, aprovechando el encuentro.

Una oportunidad inmejorable para plantear algunas preguntas e inquietudes y para transmitir algunos “pareceres” como usuarios y como parte de una comunidad, directamente a una persona de Embarcadero.

A través de los blogs y de los foros, algunos de vosotros nos habéis hecho llegar algunas preguntas y temas de interés. Así que intentamos recopilarlos y entre los dos transmitirles algunos de los más significativos.

No quiero alargarme más, sólo comentar que sobre la marcha, minutos antes de que Pawel pudiera atendernos, valoramos la idea de adjuntar a este resumen el audio de la entrevista; pero por diversos motivos ajenos a nosotros, el resultado de la grabación fue tan defectuoso que no quedó en condiciones de ser compartido (se grabó con lo que en ese momento teníamos a mano -un pequeño teléfono que hizo de grabadora-), y las circunstancias especiales del retraso horario (que obligaban a los técnicos de Danysoft a iniciar las labores de desalojo del salón para volver a Madrid) y finalmente por la estructura de la sala, en la que había bastante eco y ruido de fondo – y nuestra falta todavía de experiencia y pericia como “periodistas”, que acabo haciendo el resto…-  ;-D);

Igualmente nos hubiera gustado transcribirla de forma “literal”, pero por la misma razón expuesta,  no nos ha sido posible. Utilizando las partes de audio “aceptables” y las notas que tomamos, hemos intentado plasmar en las respuestas las contestaciones de la forma más fiel posible a lo que Pawel nos comentó. Os pedimos perdón por ello y aprendemos esta lección para próximas oportunidades que puedan surgir.

____________________________________________________________________

Pawel

PREGUNTA: (general)

Actualmente Embarcadero posee muchos “frentes” abiertos con la nueva versión de RAD Studio (muchas tecnologías diferentes están involucradas).

¿Hacia dónde va encaminado el futuro de RAD Studio/ Delphi?

En general, ¿cual cree que es el futuro de estas herramientas de desarrollo (multiplataforma, desarrollo en la nube, interconexión entre aplicaciones heterogéneas, desarrollo web,…)?

En lo que se refiere a Delphi (RAD Studio), FireMonkey es un avance tecnológico muy grande, un enfoque diferente que coloca a RADStudio por delante de otras herramientas similares del mercado a la hora de realizar un desarrollo de aplicaciones con un interface rico, de forma rápida y ágil. Las características que ofrece FireMonkey con compilación nativa en los diferentes sistemas operativos, y la potencia gráfica junto con la facilidad de desarrollo, lo posicionan en un lugar único frente al resto.

En cuanto al futuro, nos ha comentado que apuesta mucho por DataSnap. Es una tecnología que tiene grandes posibilidades y que Embarcadero está mejorando en cada versión.

Conectividad

PREGUNTA: (general)

Esta versión de RAD Studio/Delphi ha generado muchísima expectación (mucha más que cualquier otra de las anteriores). Muchas cosas nuevas se han introducido en las 2 o 3 últimas versiones y muchas se están mejorando. DataSnap, compilación 64b, multipltaforma, DBExpres, mejoras en el IDE,…

¿Porqué cree esta está siendo tan especial? ¿Cual es la clave? ¿Cual es la “tecla que ha pulsado” Embarcadero esta vez para conseguir ese cambio?

La respuesta de Pawel (que además ya se intuía después de haber escuchado la presentación) ha sido muy “visual”. Sin decir palabra lo primero que ha hecho ha sido señalarse con el dedo el logotipo que llevaba su camiseta. Seguidamente ha pronunciado una sola palabra: ¡FIREMONKEY!

PREGUNTA: (FireMonkey) FireMonkeyLogo

¿Cual es el futuro de FireMonkey? ¿Cuales son las ampliaciones más cercanas? ¿Muchos usuarios preguntan si estas librerías son ampliables a otras plataformas? ¿Está esto en la mente (planes de futuro) de Embarcadero?

 A esta pregunta nos contestó que FireMonkey no deja de ser “una primera versión”; Ellos lo saben y los desarrolladores deben ser conscientes de ello. Es un “comienzo”, una versión inicial que va a abrir un nuevo frente en el desarrollo. Tienen en mente ampliarlo a más plataformas y ampliar la biblioteca en sí. Por supuesto mejorar la librería, ampliarla y corregir de errores y bugs.

 

FireMonkey-Medium

PREGUNTA (FireMonkey)

En algunos foros se ha leído que FireMonkey va a suponer la “muerte” y el abandono de la VCL; A partir de estos comentarios surgió la siguiente pregunta:

¿La introducción de Firemonkey puede implicar que se abandone finalmente la VCL?

 En esta caso nos comentó que desde Embarcadero no tienen ninguna intención de abandonar el desarrollo y las mejoras de la VCL. Su idea es seguir desarrollando y manteniendo ambos desarrollos (tanto la VCL como FMX).


documentosPREGUNTA (Documentación)

Una de las “quejas” y/o coment

arios que más se repiten entre los usuarios es la falta de documentación sobre las nuevas características que incluye esta versión; Algunas tan importantes como FireMonkey, DataSnap o LiveBindings,…. De algunas de ellas, cuando accedes a la ayuda del IDE (F1) apenas encuentras una pequeña descripción y el esqueleto de las clases.

¿Qué opina sobre esto? ¿Y qué solución hay a esto? ¿Está Embarcadero trabajando para mejorar esto?

Para un usuario avanzado puede ser más o menos fácil navegar por Internet y encontrar ejemplos, videos, artículos,… (Inglés),  ¿Qué pasa con los usuarios noveles? ¿O no tan avanzados?

Sobre este tema nos comentó que son conscientes de que es bastante mejorable (es otra pregunta posterior volvió a mencionarlo).

Nos comentó que en tiempos de Borland, la compañia había reducido bastante el equipo de personas que estaban encargadas de la documentación, y que ahora poco a poco, desde la empresa están intentando recuperar a gente para mejorar ese aspecto. Están “recuperando” especialistas para formar un equipo en esa dirección.

También hizo referencia a que se está haciendo el esfuerzo por publicar mucho material “electrónico”.

Además ya hemos comentado, que en breve estarán disponibles en castellano (de que se traduzcan son directamente responsables la gente de Danysoft) dos libros sobre XE2. Uno sobre FireMonkey de Marco Cantú y otro sobre Delphi XE2  de Francisco Charte.

 

documentacion-proyectoPREGUNTA (Documentación)

Falta de más documentación en general castellano.

En la DocWiki, por ejemplo, de Embarcadero podemos encontrar traducciones (además del Inglés) en Francés, Alemán y Japonés. Muchos de los usuarios de la comunidad Hispana (que es muy amplia) se preguntan si hay posibilidad de que esto cambie. ¿Hay intención de ampliar estos idiomas con el Español?

¿De quién depende esto?  ¿Hay posibilidad de que la comunidad ayude en esto?

En este caso Pawel, al ver nuestro interés especial en este tema, se dirigió hacia sus notas de mesa y cogiendo bolígrafo y papel nos hizo un gesto similar a “¡contadme!, ¡estoy escuchando!”  lo cual nos dejó un poco descolocados porque se nos estaba dando a entender su interés por conocer realmente esas inquietudes, y de hecho, fue apuntando los comentarios que iban siendo asistidos por la traducción de Daniel Valenzuela. En ese punto, salieron temas como la necesidad de que al menos una pequeña parte de la documentación se suministrara en español -Salvador mencionó la Guia de Object Pascal, algo que a Salvador le parecía importante ya que entendía que era la base del lenguaje-. De igual forma se sugirió a Pawel que muchos de los vídeos que se producen desde Embarcadero se podrían subtitular, si no al castellano por no haber recursos humanos suficientes para ello, al menos al inglés, intentado favorecer a un grupo mas o menos numeroso de desarrolladores hispanos, que si bien no tienen problema en la lectura del inglés sí carecen de la habilidad lingüística necesaria para entenderlos. Y además mencionamos las wikys de nuestros respectivos entornos, que podrían representar un primer paso para que miembros de nuestra Comunidad también participaran y apoyaran la traducción.

Esa actitud receptiva, para ser justos, no era nueva. Desde Danysoft, han mostrado interés por apoyar este tipo de iniciativas. Si desde la Comunidad hay propuestas firmes y concretas en este sentido, ellos están dispuestos a mediar con Embarcadero para ver la viabilidad de realizarlas, nos decían.

En este punto, charlamos un rato, y la conclusión que yo pude extraer, es que no es algo que pueda hacer Danysoft por cuenta propia, ni la Comunidad Hispana de forma independiente, sino que parece que la solución vendría en colaborar de forma conjunta.

¿Cómo? Es algo que habría que discutir.

vclPREGUNTA (VCL)

Ya había salido el tema en una pregunta anterior, pero volvimos a incidir en el tema, pues actualmente todos nuestros proyectos están basados en ellas.

Muchos usuarios están preocupados por el futuro de la VCL. Ahora con las nuevas librerías FireMonkey multiplatarforma ¿Qué pasará con la VCL? ¿Pueden las nuevas librerías sustituir a la VCL?

Ya lo comentó antes y también durante la presentación, volvió a realizar hincapié en ello. Ellos van a seguir trabajando como hasta ahora en la VCL. Van a seguir ampliándola, mejorándola, corrigiendo bugs,… 

Sin ir más lejos, ya se está preparando el soporte y todo lo necesario para que funcione sobre Windows 8, la próxima versión de Windows.

 

embarcadero-delphi PREGUNTA (IDE)

Si un usuario tuviera que escoger una herramienta de desarrollo.

(a) ¿Porqué debería escoger a día de hoy RAD Studio, respecto a otras?

Si tuviera que destacar una característica (sólo 1) de RAD Studio/Delphi, ¿Cual escogería?

(b) Por el contrario, si tuviera que escoger una caraterística o un aspecto a mejorar ¿Cual escogería?

Él escogería RAD Studio por ser un verdadero Rapid Application Development. Realmente el IDE de Delphi es muy potente y como característica positiva y que a Pawel le parece destacada respecto a otros, ha hablado de ObjectPascal; Como lenguaje le parece “agradable/amigable”.

En contrapartida, como característica a mejorar (y que lo pone en desventaja frente a otros entornos de desarrollo) nos ha comentado que la documentación sería un claro apartado a mejorar.

 

PREGUNTA (VCL)

vcl_cODEMuchos usuarios consideran que los componentes de la VCL no han sufrido cambios ni mejoras significativas desde que se incorporaron a las paletas de componentes desde las primeras versiones de Delphi.  El caso de las rejillas de datos, podría ser uno de los ejemplos mas claros de ello. No sabemos si estarás de acuerdo o si Embarcadero piensa que esto es así.

En esta pregunta nos respondió que no estaba de acuerdo en eso y que sí se habían hecho cambios, se habían añadidos propiedades y mejorado con los cambios que el entorno recogía.

____________________________________________________________________

Hasta aquí es lo que dió de si la charla con Pawel.

La verdad es que nos hubiera gustado plantearle muchas más cuestiones y charlar más rato con él (a mi personalmente me resultó muy agradable y comunicativo), pero hay que reconocer que la presentación fue muy “densa” (para todos) y en estos momentos ya estábamos “fuera de hora”. Ellos debían recoger el material para coger el vuelo y se trataba de “charlar” un rato y no de realizar un “interrogatorio” exhaustivo.  ;-)

Antes de marchar, también tuvimos oportunidad de hablar de forma distendida con Daniel Valenzuela de Embarcadero, sobre el tema de la Comunidad Hispana, de los recursos existentes (o no existentes) y de que pueda realmente cambiar esto. La idea extraída de la conversación, es que ellos están dispuestos a apoyar cualquier iniciativa que podamos llevar a cabo desde la Comunidad, dentro lógicamente de sus posibilidades.

Creo que tanto Salvador como yo, quedamos satisfechos de cómo se había desarrollado la charla y de que se hubieran mostrados receptivos a conocer los problemas de la Comunidad Hispana, aunque somos conscientes de que esto tan solo es un pequeño paso y que todavía pasará tiempo hasta que podamos ver cumplidos muchos de estos deseos y necesidades.

sjbar011
Foto de Salvador y yo con Pawel, una vez finalizada la charla.

Existe algún fragmento sonoro de sus respuestas, y en el caso de que alguno de vosotros me haga llegar su interés por escucharlo se lo puedo enviar, pero ya os anticipo que su mala calidad me hizo valorar no exponerlos públicamente ni recomendarlos.

Esperamos que os haya parecido interesante, para nosotros sí lo fue. Gracias desde aquí a la gente de Danysoft y hasta la próxima.

NOTA: Aquí podéis ver otra de las fotos (esa bastante simpática).

Un saludo.

Share Button
Categories: Delphi, Offtopic, XE2 Tags: , , ,

VCL y FireMonkey

martes, 4 de octubre de 2011 10 comentarios
Share Button

imagen1

Está claro que FireMonkey (FM) es una tecnología súmamente atractiva y desde el mismo día que llegó (y vimos los primeros vídeos), la mayoría de nosotros está deseando poder integrarla en nuestras aplicaciones.

En el momento en que nos planteamos desarrollar aplicaciones nuevas, podemos tomar la decisión de escoger FireMonkey, si nuestras necesidades están cubiertas por esta librería (componentes y funcionalidad),  pero la pregunta que nos hacemos muchos de nosotros es:

¿Y qué hay con las aplicaciones que ya tenemos?

Está claro que no podemos “mezclar” en un proyecto formularios de la VCL y de FireMonkey. La ayuda nos dice lo siguiente (docwiki):

______________________________________________________________________
Caution:
FireMonkey (FMX) and the Visual Component Library (VCL) are not compatible and cannot be used in the same project or application. That is, an application must be exclusively one or the other, either FireMonkey or VCL. The incompatibility is caused by framework differences between FireMonkey (FMX) and VCL.
______________________________________________________________________

¿O si? (bueno luego hablaremos de esto…)

Sólo basta con intentarlo en el IDE; Creamos un proyecto/aplicación VCL e intentamos añadir un formulario “tipo FireMonkey”; Instantáneamente obtendremos un mensaje como este:

Imagen907

El mensaje es claro. No podemos añadir a un “proyecto VCL” un formulario FireMonkey.   ;-(
Bueno, no desesperemos; Delphi es mucho Delphi y ofrece “otras” posibilidades… (Packages)

Me he planteado este problema, mi cabeza ha empezado a dar vueltas y he comenzado a “trastear”…  ;-D

NOTA: Estoy pensando en aplicaciones que tenemos funcionando en Windows y que queremos que sigan así (descartando características de Multiplatarforma –al menos a priori-).

NOTA2: Como en las últimas entradas, he cogido Delphi XE2 y he empezado desde cero.

PRIMERA CUESTIÓN

Crear un package con un formulario FireMonkey.

Pues me he puesto manos a la obra…
He abierto un nuevo package y he añadido un formulario de FireMonkey; Un par de controles, un Timer y una vez compilado, se ha generado el package correspondiente (sin aparentes problemas).

Imagen908

Como veis a la izquierda la estructura del formulario es sencilla y es lo único que posee el package.

SEGUNDA CUESTIÓN:

¿Podré cargar este package desde una aplicación Delphi (VCL)?

Bueno, si el package se ha generado sin problemas, cargarlo de forma dinámica desde una aplicación no tendría porque fallar.

Creo un proyecto VCL estándar y utilizo el procedimiento LoadLibrary para cargar una BPL de disco; La BPL en la que he añadido el formulario FireMonkey. El código de la carga es el mismo que para cualquier otro package.

 

0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
var
  H: Thandle;
  fName:String;
begin
  // Nombre del package
  fName := Edit1.Text;
  // existe el fichero?
  if not FileExists(fName) then begin
    Memo1.Lines.Add('Error al cargar el package; Fichero inexistente: ' +
      fName);
    Exit;
  end;
 
  Memo1.Lines.Add('Se va a cargar el package...');
  // Cargando
  H := LoadPackage(Edit1.Text);
  // Cargado correctamente?
  if (H &gt; 0) then begin
    Memo1.Lines.Add('El package se ha cargado correctamente (' +
       IntToStr(h) + ')');
  end
  else begin
    Memo1.Lines.Add('Error, no se ha cargado el packae');
  end;

 

En este caso el nombre del package lo “pasamos” utilizando un componente de edición. Además he añadido al packages un par de procedimientos de INITIALIZATION y FINALIZATION; El de inicialización se encarga de crear una instancia del formulario y mostrarla por pantalla, mientras que el de finalización lo libera. El código que añadiríamos al final del .PAS sería este:

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
procedure Start_Pack();
begin
  // Crear el formulario
  FormMainFM := TFormMainFM.Create(nil);
  FormMainFM.ShowModal;
end;
 
procedure Finish_Pack();
begin
  // Liberar el form
  FormMainFM.Free;
end;
 
//=========================================================================
// I N I T I A L I Z A T I O N
//=========================================================================
initialization
  Start_Pack();
  RegisterClass(TFormMainFM);
 
//=========================================================================
// F I N A L I Z A T I O N
//=========================================================================
finalization
  Finish_Pack();
  UnregisterClass(TFormMainFM);

Si ejecutamos el programa podemos ver que el Package se carga correctamente y que en ese momento se ejecuta el procedimiento de inicialización, con lo que se crea el formulario (FMX). He añadido estilos a ambos formularios para que se aprecie la diferencia; Al formulario de la VCL con los Visual Styles y al de FireMonkey con el componente TStyleBook. El resultado es el que véis aquí:

Imagen909

Llegados a este punto. Pues he de decir que yo personalmente me he llevado una sorpresa. Ya se lo que dice la ayuda (lo he vuelto a leer), pero la aplicación se ha ejecutado y aunque es sencilla, aparentemente no parece tener problemas (he realizado la prueba en XP, en Windows Server y en Windows 7) .

Resumiendo… Lo que he hecho hasta ahora es generar un proyecto en Delphi (VCL) compilarlo sin runtime packages y cargar una BPL de forma dinámica (como si fuera una DLL) que a su vez muestra un formulario “FireMonkey” cuando se Inicializa. No está mal, aunque podemos ir un poco más allá.

¿Me pregunto qué pasará cuando intente acceder por RTTI a la información del package?

TERCERA CUESTIÓN:

Acceder por RTTI desde una aplicación “VCL” a los métodos de un form “FireMonkey” almacenado en una BPL.

Para ello lo primero que debemos hacer algunos cambios:

  1. Nuestra aplicación  VCL, ahora debe compilar con “runtime packages” para poder compartir la información RTTI con los packages dinámicos.
  2. En nuestro package que contiene el formulario “FireMonkey” vamos a Registrar la clase del formulario, para poder acceder a ella posteriormente con GetClass. Para ello utilizaremos los procedimientos de Inicialización y Finalización vistos anteriormente.
    0
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    
    //=========================================================================
    // I N I T I A L I Z A T I O N
    //=========================================================================
    initialization
      //-- Start_Pack();  // Lo crearemos “manualmente”
      RegisterClass(TFormMainFM);
     
    //=========================================================================
    // F I N A L I Z A T I O N
    //=========================================================================
    finalization
      //-- Finish_Pack();
      UnregisterClass(TFormMainFM);
  3. A nuestro formulario vamos a añadir en la parte published, varios métodos de clase (aunque esto último no es necesario) a los que accederemos vía RTTI. Un Timer y un par de procedimientos para controlar una animación. Además de un procedimiento que creará el formulario (ExecForm).
  4. Por último vamos a eliminar la creación del formulario en la carga del package, para hacerlo nosotros vía RTTI. Si os fijáis en el código superior, he comentado los procedimientos Start_Pack y Finish_Packque se encargaban de la creación y destrucción.
    0
    1
    2
    3
    4
    5
    
      // en la parte published del formualrio
      published
        // Método de clase para crear y visualizar
        class procedure ExecForm();
        class procedure Start();
        class procedure Stop();

     

    0
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    
      // Y la implementación (asumimos que el formulario ya estará creado)
      //...// Actiar el Timer para iniciar la animación
    class procedure TFormMainFM.Start;
    begin
      FormMainFM.TimerRot.Enabled := True;
    end;
     
    // Para el Timer y detener la animación
    class procedure TFormMainFM.Stop;
    begin
      FormMainFM.TimerRot.Enabled := False;
    end;
     
    // Crear el formulario y visualizarlo
    class procedure TFormMainFM.ExecForm();
    begin 
      FormMainFM := TFormMainFM.Create(nil); 
      FormMainFM.Show;
    end;

Hecho esto, nuestro método de carga ahora es un poco más complejo. Una vez cargado el package de forma dinámica, busco mediante RTTI la clase del formulario e intento crearlo. El código es el siguiente:

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
var
  H: Thandle;
  res:integer;
  fName:string;
  AClass:TPersistentClass;
begin
 
  fName := Edit1.Text;
 
  // existe el fichero?
  if not FileExists(fName) then begin
    Memo1.Lines.Add('Error al cargar el package; Fichero inexistente: ' +
       fName);
    Exit;
  end;
 
  Memo1.Lines.Add('El fichero de package existe en disco');
  Memo1.Lines.Add('Se va a cargar el package...');
 
  // Cargando
  H := LoadPackage(Edit1.Text);
 
  // Cargado correctamente?
  if (H &gt; 0) then begin
    Memo1.Lines.Add('El package se ha cargado correctamente (' +
         IntToStr(h) + ')');
 
    // Acceder a la clase del form
    AClass := GetClass('TFormMainFM');
    // encontrada
    if Assigned(AClass) then begin
      Memo1.Lines.Add('AClass&lt;&gt;nil; Encontrada la referencia' +
          ' al formulario');
      // Crear el form
      F := TFormClass(AClass).Create(nil);
      Memo1.Lines.Add('Creado el form correctamente; Accediendo ' +
        ' a los métodos');
      // Acceder al método
      Routine.Data := Pointer(F);
      // Ejecutar al código
      Routine.Code := (F).MethodAddress('ExecForm');
 
      // No ha encontrado el código de la rutina...
      if (Routine.Code &lt;&gt; nil) then begin
        Memo1.Lines.Add('Se ha encontrado el punto de entrada del método ');
        Memo1.Lines.Add('Se va a ejecutar el método...');
        // Ejecutarlo
        TExecuteExecForm(Routine);
        Memo1.Lines.Add('Ejecutado OK. Form visible');
 
        btnStart.Visible := True;
        btnStop.Visible := True;
        Button1.Enabled := False;
      end
      else  begin
        Memo1.Lines.Add('No se ha encontrado el punto de entrada del método ');
      end;
    end
    else begin
      Memo1.Lines.Add('Error, no se ha encontrado la referencia a la ' +
        'clase en el package ' + fName);
    end;
  end
  else begin
    Memo1.Lines.Add('Error, no se ha cargado el package');
  end;
end;

 

He utilizado un Memo en el formulario principal para ir mostrando los diferentes mensajes (los pasos que se van realizando). Una vez que ejecutamos el código, podemos ver que la salida de LOG es la esperada y el formulario se visualiza correctamente.

 

Imagen910

 

De la misma manera, si ejecutamos los métodos Start y Stop (vía RTTI) funcionan de forma correcta.

CONCLUSIÓN:

La primera conclusión que extraigo de todo esto (contando que las pruebas que he realizado son bastante sencillas), es que utilizando packages (creo que es la mejor forma), tenemos la posibilidad de utilizar FireMonkey en una aplicación “VCL”. Está claro que esto invalida la posibilidad de utilizar la “multiplataforma” con esa aplicación, pero tal y como os he comentado, no era ese el objetivo de estas pruebas.

¿Para qué puede servir esto?

Se me ocurren a priori 2 situaciones donde esto podría ser “utilizable”.

La primera es que tengamos aplicaciones antiguas desarrolladas en Delphi y a las que queramos “añadir” alguna característica donde FireMonkey pueda aplicar su potencial. Por ejemplo, un módulo donde tengamos que realizar animaciones o visualizaciones 3D; Incluso sacar partido de la facilidad que FireMonkey tiene para trabajar con modelos importador de herramientas de modelado (3DS).

La segunda, es la de poder “migrar” de forma paulatina aplicaciones que tengamos funcionando; Si cumplen unos determinados requisitos, puede ser que la migración se pueda hacer de forma escalonada. En este caso ya deberían trabajar con packages y facilitaría mucho si la lógica de negocio la tenemos “independiente” a la parte de Interficie.

Todo esto con la RESERVA de ver qué otras implicaciones más profundas puede tener este diseño. El hecho de que Embarcadero diga que es incompatible utilizarlos en el mismo proyecto, debe ser por algo, aunque en este momento no se porqué.  ¿?¿?¿?

 

BONUS TRACK:

Por último se me ha ocurrido hacer una prueba más. Probar, por probar,…    ;-)

Crear un proyecto “VCL”, y añadir directamente un formulario FMX al proyecto. Aunque en IDE avisa con un Warninig, deja hacerlo.
Compilas, ejecutas y ¡Voilà! ¡Sorpresa!

Se ejecuta perfectamente.

En este punto he buscado por Internet si a alguien más se le ha ocurrido hacer esto mismo y he encontrado algunas referencias. La más interesante en StackOverFlow (y con esto completo la entrada) es que apenas con 3 líneas, podemos conseguir, no sólo abrir un formulario FireMonkey como os he mostrado, sino “incrustarlo” dentro de uno “VCL”.

0
1
2
3
4
5
6
procedure TForm3.Button1Click(Sender: TObject);
begin
  FormMainFM := TFormMainFM.Create(nil);
  FormMainFM.Show;
  Panel1.Form := FormMainFM;
  FormMainFM.Start;
end;

 

     

Aquí os enseño las imágenes en diseño y en ejecución.

Vuelvo a decir, que todo esto no creo que se pueda tomar como base para diseño de aplicaciones, entre otras cosas porque las pruebas son bastantes  “simples” y porque desde Embarcadero lo desaconsejan, pero se puede tener en cuenta como alternativa puntual.

Os adjunto los enlaces a los proyectos con código y a los ejecutable compilados por si queréis verlos funcionando. Los segundos están comprimidos con UPX para reducir su tamaño.

Aunque ya he comentado el enlace, os animo a revisar la entrada en Stackoverflow, ” Delphi XE2: Possible to instantiate a FireMonkey Form in VCL application?”

Os añado también un enlace al blog de RemObjects, donde aparece una referenca a esta cuestión; “Hydra and FireMonkey – Best Friends Forever”.

Como siempre, comentarios, quejas, críticas, sugerencias,…  serán bienvenidas.

Un saludo.

Share Button
Categories: FireMonkey, OOP, XE2 Tags: , ,

RAD Studio XE2 World Tour: Barcelona

lunes, 3 de octubre de 2011 Sin comentarios
Share Button

Esta semana pasada ha sido “intensa”. Se han celebrado las presentaciones de RAD Studio XE2 en Barcelona (que es a la que ha asistido yo), en Madrid y en Lisboa. En este caso de la mano de DanySoft (partner oficial en la península) y con la colaboración de Pawel Glowacki.

Interesantes, como siempre, aunque esta vez ha sido “algo especial”, por varias razones.

   276472_113760532059812_562257430_n No cabe duda de que esta versión de Delphi (Rad Studio), es la que más expectación ha generado desde hace mucho tiempo. No hay más que ver los foros, las páginas web, los blogs y las salas de las presentaciones. Llenas, como yo no había visto en ninguna presentación antes. Conozco compañeros que este año se han quedado sin poder asistir debido a que se ha completado el cupo de asistentes (*).

   En mi caso, aprovecho las presentaciones para ver y saludar a antiguos compañeros y gente que conozco que trabaja como yo,con Delphi. En esta ocasión además, ha estado en Barcelona Salvador Jover (Delphi Solidario), con el que tengo una estrecha relación por temas blogs y relacionados con la Comunidad Hispana de Delphi.

   Especial también, en este caso, porque gracias a la gente de Danysoft,Salvador y yo, hemos tenido la oportunidad de charlar un rato con Pawel Glowacki después de las presentaciones; Hemos podido formularle algunas preguntas y trasladarle algunas inquietudes que vosotros nos habéis transmitido (ya sea a través de los blogs, como a través de los foros del Clubdelphi) tanto a mi, como a Salvador (**).

Recopilando información del evento aquí os dejo algunos enlaces.

El tema de la entrevista con Pawel, es un tema aparte. Salvador y yo tenemos a nuestros mejores hombres trabajando en ella (es decir, estamos él y yo     ;-D  ). En cuanto la tengamos disponible la publicaremos en los blogs y en los foros.

FOTOS:

 

MATERIAL Y DOCUMENTACIÓN:

Danysoft ha publicado ya, en su página web, las presentaciones (documentos) que han utilizado en las presentaciones. Echadles un vistazo. Interesantes sin duda,tanto para los que hemos podido asistir, como los que no habéis tenido oportunidad de hacerlo.

    • Sesión 1 | RAD Studio XE2. Dirección del producto
    • Sesión 2 | Demo – FireMonkey
    • Sesión 3 | LiveBindings
    • Sesión 4 | Delphi 64-bit, VCL Styles
    • Sesión 5 | DataSnap y la Nube
    • Sesión 6 | Movilidad y Conectores

Página y links de descarga.

IMAGENES:

    Por último as adjunto algunas capturas, de las presentaciones (tal vez algunas de ellas ya las podáis encontrar en los documentos PDF), otras son capturas de las demostraciones.
    Aplicando estilos a aplicaciones existentes:

Result

Result2b

    Una del diseñador de estilos:

DisenyadorEstilos

Código de ejemplo, para ejecutar animaciones en FireMonkey. Como veis aunque las animaciones son bastante complejas, el código por el contrario, es bastante simple.

AplicandoAnimaciones

      Una imagen de un proyecto generado en Delphi, cuando se está ejecutando (compilado con

XCode)

    en OSX y generando salida para iPhone, con el “IPhone Simulator”.

Compila_OSX

En este caso otra de las herramientas de RAD Studio (se trata de RAD PHP) con el diseñador para iPhone; Aquí desde el entorno RADPHP.

RADPHP_iphone

Vista en diseño de Delphi XE2 cuando estamos trabajando con elementos 3D. Los Layer3D nos permiten en diseño modificar las vistas en 3 dimensiones de los elementos que tenemos en el formulario (arrastrando esos elementos de color que hay en la imagen inferior).

trabajo_3d

Aquí podéis ver una imagen de la pantalla (y parámetros de configuración) del acceso a OSX desde el entorno de Delphi.

Config_OSX

Por último, una imagen de la aplicación que hemos visto antes, ejecutando en un entorno OSX.

Ejecutando

La mayoría de los ejemplos de las presentaciones se pueden encontrar en los que se adjuntan con RAD Studio XE2 o desde el repositorio de Embarcadero.

(*) Hoy mismo Danysoft ha realizado online la presentación de la versión XE2, para la gente que no pudo asistir “en vivo”; Supongo que en breve la tendrán disponible como video en su canal de youtube.

(**) Espero que en breve, podamos tener disponible para publicar, la entrevista con Pawel Glowacki. La publicaremos en los Blog, en Facebook y en los foros.  Paciencia….  ;-D

 

Un saludo.

Share Button

Testeando XE2; (LiveBindings) – Parte 1

miércoles, 21 de septiembre de 2011 Sin comentarios
Share Button

imagesEsta es otra de las nuevas características que se anuncian en el nuevo Delphi XE2. A priori con  el nombre me hago una idea de lo que puede ser y se que hay otros lenguajes que poseen características similares (si es lo que yo me pienso).

De todas formas, como no lo tengo claro, me he puesto a buscar qué hay sobre esta palabra…

______________________________________________

“…permite conectar cualquier elemento visual a cualquier tipo de datos utilizando LiveBindings ™”

______________________________________________

“LIBÉRATE DE LAS REJILLAS | VISUALIZA DATOS VIVOS
El nuevo LiveBindings de Delphi te permite conectar cualquier fuente de datos a cualquier interfaz de usuario o elemento gráfico VCL o FireMonkey.
LiveBindings te da la potencia y libertad creativa para presentar datos a usuarios en las formas más intuitivas e interactivas.
LiveBindings también incluye expresiones, dándote la increíble potencia y flexibilidad para construir “dinámicamente” enlaces a datos calculados y actualizados.”

______________________________________________

“¡Nuevo! Conecta cualquier elemento visual a cualquier tipo de dato con LiveBindings”

______________________________________________

Bueno, no se si con eso os he aclarado algo más. Al menos una idea sí parece que nos da de los que pueden ser.

Los LiveBindings permiten completar y ampliar las posibilidades de visualizar datos que nos provee la VCL (y sobre todo los componentes de Base de Datos). Hace unos años, arrastrar un componente DBEdit sobre un formulario, asignarle un DataSource y desde ahí “engancharlo” a un campo de una tabla/consulta era lo más. Ha pasado el tiempo y las tecnologías van cambiando (y también las necesidades).

No es que este modelo ya no sirva, pero sí que en algunas ocasiones queda un poco “corto” o un poco “cuadriculado” (pensemos en desarrollos por capas). La solución en estos casos pasaba por utilizar código para salvar esas limitaciones. Ahora esa parte puede quedar mucho más simplificada.

Sirve además para “completar” todo lo que nos ofrece la librería FireMonkey (de la que ya he hablado a modo de introducción antes), ya que los LiveBindings están tanto en la VCL como en FireMonkey.

Podemos dividir los LiveBindings (LB) en tres varios tipos, dependiendo de los tipos de elementos que vayan a relacionar.

TIPOS DE LIVEBINDINGS

TBindScopeDB

Nos permite “conectar” componentes con DataSets; Utilizando el Inspector de objetos o el asistente, podemos definir como “proveedor de datos” los elementos de un Dataset y como “destino” cualquier componente.

Un ejemplo pasa a paso de utilización de TBindScopeDB podría ser el de un formulario con componentes DB (pero sin ellos –vamos a utilizar los estándar-).

Imagen869

Para ellos crearemos una nueva aplicación FireMonkey y colocaremos los componentes normales para realizar una conexión a Base de Datos (en mi caso he utilizado ADO). Para mostrar los Datos utilizaremos un TStringGrid.

Para mostrar los datos utilizaremos un TBindScopeDB, aunque no hace falta arrastrar el componente desde la paleta (aunque se puede hacer) porque podemos hacerlo utilizando las opciones del menú utilizando el asistente.

 Imagen870Si seleccionamos en Grid, tanto en el menú contextual, como en la parte inferior del “Object Instector” aparece la opción “Link to DB DataSource”. El propio wizard ya nos muestra las fuentes de datos disponibles para poder seleccionar la que queramos.

Imagen871

Una vez  hecho esto, veremos que el asistente ha hecho todo trabajo por nosotros.

Imagen872

Por un lado ha creado 2 componentes nuevos:

  • BindingScopeDB1: El comentado que nos permite “linkar” una fuente de datos con componentes de edición estándar (en nuestro caso).
  • BindingsList1: Es el componente que almacena toda la lista de “Bindings” que vamos a ir creando para este formulario.  En este momento sólo posee uno, pero añadiremos más (más adelante los veremos en detalle).

Vamos ahora a utilizar componentes de edición estándar para mostrar los datos que aparecen en el grid; En este caso 2 TLabel y dos TEdit (TEdit y TCalendar) para los campos de código de empleado y fecha. Los labels los utilizaremos para visualizar el título de los campos (propiedad DisplayLabel –no sólo los podemos utilizar con los datos, sino con cualquier otra propiedad-) de cada campo.

Imagen873

Imagen875Para el Label, lo que necesitamos hacer es “linkar” la propiedad Text del Label, con la propiedad DisplayLabel del campo EmpNo de la Base de Datos (cuya propiedad DisplayLabel tiene el valor “Código”, como se puede ver en la imagen del Grid).

Para esto utilizaremos un TBindExpression.

Desde el propio “Object Inspector” podemos configurar cómo queremos que funcione. Por un lado El TLabel y su propiedad Text y por otro lado el TField EmpNo y su propiedad DisplayLabel, tal y como se ve en la imagen siguiente.

Una vez configuradas las opciones, ya vemos que automáticamente el cambio se ve reflejado en el Label. Si modificamos la propiedad del TField (por ejemplo para mostrarla en otro idioma), automáticamente se modificará el texto del Label.

Imagen874

Para el campo de Edición podemos seguir los mismos pasos que hemos realizado para el Grid, seleccionando el campo que queremos mostrar; Y de la misma forma para el segundo Label y para el TCalendarEdit que mostrará la fecha.

Una vez concluido esto, podemos revisar qué contiene nuestro componente BindingsList1.

Imagen876

Como era de esperar, contiene los 5 “Links” que hemos realizado en nuestro formulario. Podemos ver el nombre del componente y a la derecha una pequeña descripción de cada unos de ellos; Si accedemos (para ver más detalles) por ejemplo, al “binding” del componente de Fecha, veremos la siguiente pantalla (corresponde a lo que hemos configurado en el Inspector de objetos).

Imagen877

Nos dice que el control CalendarEdit1, en su propiedad Text, recibe notificaciones (assign to control -operation-) desde BindScopeDB1,HireDate en su propiedad DisplayText.

El resultado es bastante simple y en este caso no os puedo poner código de ejemplo, Al menos aquí pegado, porque todo se hace sin teclear nada (eso es bueno ¿no?  ;-))

Todo el proyecto posee las siguientes líneas:

0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
procedure TForm1.Button1Click(Sender: TObject);
begin
  // cerrar
  Self.Close;
end;
 
procedure TForm1.Edit3Click(Sender: TObject);
begin
  // Abrir una web
  ShellExecute(Handle, 'open', PChar(Edit3.Text), nil, nil, 0);
end;
 
procedure TForm1.Image1Click(Sender: TObject);
begin
  // Animación del titulo
  Layer3D1.AnimateFloat('RotationAngle.Y', 360, 6);
end;

Os animo a que reviséis el proyecto y hagáis vuestras pruebas. Al principio es todo nuevo y cuesta un poco, pero a medida que uno se acostumbra el procedimiento se vuelve bastante ágil.

Os dejo los fuentes del proyecto y el ejecutable.

<DESCARGAR FUENTES>

<DESCARGAR BINARIO>

Un Saludo.

Share Button

Testeando XE2… (soporte nativo para ficheros ZIP)

miércoles, 14 de septiembre de 2011 16 comentarios
Share Button

ZIPFile   Otra de las nuevas funcionalidades que trae la versión de XE2 es el soporte para ficheros ZIP. No es que sea especialmente transcendental, pero en mi caso la he utilizado bastante en mis desarrollos y hasta ahora lo había tenido que hacer mediante componentes externos (he  probado varios paquetes).

   Para ello se ha añadido a la unit System.ZIP, todo lo necesario para el trabajo con este tipo de ficheros.

   En sistema de trabajo es bastante sencillo. Para trabajar con un fichero de este tipo tenemos que crear un objeto de la clase TZIPFile y abrirlo (utilizando la función Open). Tenemos diferentes modos de apertura dependiendo de las operaciones a realizar con el fichero (read,write o readwrite).

0
1
2
// Abrir un fichero
procedure Open(ZipFileName: string; OpenMode: TZipMode); overload;
procedure Open(ZipFileStream: TStream; OpenMode: TZipMode); overload;

Leer más…

Share Button
Categories: Delphi, Ejemplos, XE2 Tags: , , ,

Testeando XE2… (Estilos)

martes, 13 de septiembre de 2011 13 comentarios
Share Button

Otra de las cosas de las que ya he hablado y que llaman la atención en esta nueva versión de Delphi, son los estilos. Es una primera implementación y es mejorable en muchos aspectos, pero es una paso más y un avance más para poder personalizar nuestras aplicaciones.

Hay que decir que el funcionamiento general es muy sencillo.

estilos1

Estaría bien, por ejemplo, mejorar el generador de estilos para que se pudieran importar estilos desde otros archivos similares. En mi caso el generador se ha mostrado “poco estable” cuando he intentado hacer algo más complejo (cambio de imágenes) que intentar modificar los colores del estilo cargado.

Por internet podéis descargar varios videos sobre el uso del “VCL Style Designer”, que así es como se llama la herramienta para crear y modificar los estilos. Aunque es bastante sencilla e intuitiva. Una vez cargado el estilo, podemos modificar los diferentes elementos. Se puede exportar la imagen del estilo completo, modificarla desde un editor externo y luego volverla a cargar, para poder así asignar elementos de esa nueva imagen a los diferentes componentes. Se pueden cargar varias imágenes y combinar elementos de varias de ellas; Pero como he dicho en estas operaciones se ha mostrado “inestable”

Los componentes que derivan de los estándar cogen de forma correcta los estilos.  Lo que no he podido probar (y no parece que exista ahora solución -digo esto sin habérmelo mirado mucho-) es qué posibilidades hay para componentes “externos” que no deriven de uno estándar.

Una creado o modificado un estilo podemos cambiar los campos que identifican al creador, desde la misma herramienta de creación (autor, versión, página web y correo electrónico). Mientras que la previsualización desde el “Style Designer” funciona bastante bien (salvo cuando hay algun error que no muestra nada -tampoco el error-), desde el IDE de Delphi la previsualización es defectuosa (podrían haber utilizado el mismo método que desde el Designer) o “floja” por decirlo así.

En resumen, aunque el sistema tiene algunos detalles todavía faltos de pulir, en general me parece un acierto el poder dotar de esta posibilidad a las aplicaciones que se realicen. El sistema es muy sencillo de utilizar y aunque tiene algunas limitaciones, funciona bastante bien.

Actualmente al cargar instalar Delphi XE2 contamos contamos con 5 estilos que podemos utilizar.

Desde la web de Rodrigo podeís descargar algunos que él ya ha creado y es de esperar que los miembros de la comunidad vayan “colgando” los suyos propios a medida que los vayan creando (para eso supongo que se ha distribuido). Desde ahí mismo podéis consultar la explicación detallada de cómo crear nuevos estilos a partir de los existentes.

El código para cargar el estilo es bastante simple a partir de su nombre:

0
1
2
3
4
5
6
7
8
9
10
Var
  Estilo:TStyleManager;
  i:integer;
begin
  Estilo := TStyleManager.Create;
  try
    i := Random(6);
    Estilo.SetStyle(lEstilos[i]);
  finally
    Estilo.Free;
  end;</p>

En mi caso cargo los estilos de forma aleatoria a partir de un array donde los tengo definidos.

0
1
2
3
4
5
6
// Ini estilos</p>
lEstilos[0] := 'Windows';
lEstilos[1] := 'Aqua Graphite';
lEstilos[2] := 'Aqua Light Slate';
lEstilos[3] := 'Emerald Light Slate';
lEstilos[4] := 'Golden Graphite';
lEstilos[5] := 'Ruby Graphite';</p>

Hasta aquí esta primera visión. En general me ha parecido positivo. Algunos aspectos por pulir, pero creo que es un detalle más, que hace subir puntos a esta versión.

Un saludo.

Share Button
Categories: Ejemplos, XE2 Tags: , , ,

Testeando XE2… (FireMonkey)

martes, 13 de septiembre de 2011 11 comentarios
Share Button

Pues ya tengo Delphi XE2 en marcha. Que ya lo tengo instalado ¡Vamos!

No se a vosotros, pero a mi me pasa (y no sólo con esta versión) que una vez que la tengo instalada, lo primero que se me ocurre es probarla. Probar las nuevas características y ver qué tal funcionan.

¡¡Eso es lo que hace todo el mundo!! Diréis.

Bueno, sí y no. Me refiero a “probarlas en frío”. Sin saber nada más. Sin leer nada más.
Se trata de abrir un proyecto en blanco y empezar a probar cosas. Cosas totalmente nuevas. Cosas que no existían hasta ahora. Cosas de las que he oído hablar, pero no he leído nada.

Eso me da una idea de cómo son de fáciles a la hora de asimilar. Difíciles, complicadas, rebuscadas,… Busco documentación y veo cómo se llega a ella, si la hay, cómo es de clara,…

Todo el mundo habla estos días de FireMonkey.  ;-D    ¡¡Pues allá que voy yo!!

He ido al menú de fichero y he creado una nueva aplicación de este tipo (Fire Monkey HD Application).

A priori todo parece normal; el formulario se ve algo diferente, pero todo lo demás tiene “la misma pinta”.

Pongo algunos componentes, unos botones, un checkbox, una statusBar y una imagen. Mi primera sorpresa viene cuando voy a buscar la propiedad Caption del botón y no está.   8-|

¡No puede ser! Vuelvo a buscar y efectívamente no está.

En su lugar veo la propiedad Text. Pruebo y efectívamente pertenece al caption del TButton.

No parece que tenga mayor importancia…

Pongo un checkbox y al ir a buscar la propiedad Checked…  ¿??¿?¿   ¡¡No está!!    8-||

Vuelvo a revisar las propiedades y…  encuentro una propiedad IsChecked que pertenece a lo que normalmente se hace con la propiedad Checked.

Dejando de lado esto (cuestión de la adaptación de los nuevos componentes adquiridos por Embarcadero-me imagino-) el resto de cosas que he probado son bastante intuitivas y algunas bastante impresionantes. Aplicar un efecto (para lo que antes necesitábamos bastante código o componentes especializados) o realizar una rotación de una imagen es algo “trivial” (por su sencillez).

La velocidad es muy buena y la primera impresión muy positiva.

Os dejo este primer ejemplo; Bastante “tonto” por su funcionalidad, pero también por la complejidad que me ha conllevado (bastante poca).

Aquí los fuentes y el ejecutable, aunque sinceramente no creo que tengan mucho interés, desde en punto de vista de la codificación.

NOTA: Sigo buscando cómo asignarle un texto a la StatusBar que he puesto en el formulario…    ;-D

Un saludo.

Share Button