Delphi XE2 y Firemonkey (ii) Direct2D y Windows

En post previo sobre Delphi XE2 y Firemonkey expresé mis dudas sobre el uso de Direct2D en Windows previo a Vista.

Como indicara en el mencionado post, la información disponible sobre Firemonkey daba cuenta que en su implmentación para Mac OSX (y iOS? ) usará OpenGL y en Windows usará DirectX para 3D y Direct2D para 2D en plataforma Windows.

Como ya sabemos Direct2D sólo está disponible preinstalado a partir de Windows 7 y disponible en Vista via una actualización. Pero, y en XP (probablemente la base instalada más grande de Windows)???. La pregunta se caía de madura, habrá soporte en esta versión? Asi que le hice la pregunta al propio Andreano Lanusse y la respuesta fue:

Cases where Direct2D is not supported, like Win XP FireMonkey will use GDI+.

Michel Swindell también respondió en el mismo sentido:

on Windows if D2D is not available, FM will use GDI+ for HD vector forms/controls.

Bueno al menos estará disponible, habrá que ver como se comporta ya que GDI+ no es acelerado por hardware, ya que definitivamente las capacidades requeridas para Firemonkey lo hacen inviable con GDI puro.

En un post posterior Andreano Lanusse, contesta las interrogantes surgidas sobre el uso de Firemonkey a través de MS RDP (Remote Desktop), en esta da cuenta de que si el servidor es un un Windows Vista/7  “físico” no tendrá ningún problema ya que estas versiones de Windows soportan 3D en RDP. Si es Wiindows Vista/7 virtualizado en algún entorno sin GPU como XenApp y VmWare ESX, soportará la parte 2D de Firemonkey usando GDI+, la parte 3D se pierde por que no hay una versión de software para estas capacidades. En el caso de un servidor RDP con Windows XP, en esta versión RDP no soporta 3D y la parte 2D como ya dijimos será con GDI+.

Ahora, por que no se usó OpenGL en Windows? pudo ser, pero este no viene preinstalado asi que es una limitante. Además está documentado que los drivers nativos para OpenGL en Windows no son muy pulidos y dan problemas.

DirectX está disponible desde Windows 95, por que no se usó directamente DirectX en lugar de Direct2D para la parte 2D? Bueno me imagino que fue por que hacer 2D con Direct2D es muchisimo más fácil que hacer 2D con DirectX, que si se puede pero la API ya es bastante densa para 3D, usarla para 2D debe ser horrible. Hay que recordar que Direct2D no es si no una capa encima de DirectX. Esto me hace pensar que Embarcadero pudo crear su propia capa 2D, pero realmente seria mucho esfuerzo y encima sujeto a los múltiples mutaciones que Microsoft le ha hecho al DirectX.

Solo nos queda esperar para poder poner a prueba todo el poder de Firemonkey, en todas las plataformas

Delphi XE2 y Multiplataforma

Realmente la nueva versión de Delphi, la XE2, me tiene más que entusiasmado.

Una de las características más saltantes, es en definitiva el soporte multiplataforma.

Delphi no es nuevo en este sentido, ya hace varios años atrás tuvo un ingreso promisorio pero fallido en el terreno de Linux con Kylix, que no era sino Delphi para Linux, toda la IDE completa funcionando sobre esta plataforma. En aquella época la solución a la compatibilidad de entornos gráficos se hizo reemplazando la VCL, que está atada a la API de Windows, con CLX una versión multiplataforma basada en Qt. Sin embargo en ese momento Borland/CodeGear no pudo lograr mantener el producto en el tiempo y finalmente fue dado de baja. Se que hasta hoy hay desarrolladores que siguen trabajando con Kylix, haciendo mantenimiento a software legacy.

Luego de la debacle de Kylix, y como tenía cierta base instalada, surgió un producto llamado CrossKylix, que ofrece desde Delphi para Windows, compilar para Linux usando el compilador por línea de comandos del Kylix. Este tuvo cierta aceptación, pero su creador no fue bien visto a ojos de Borland/CodeGear.

Ya desde el 2008 se vienen escuchando pasos con respecto al soporte multiplataforma. Por supuesto la primera y más obvia petición de los desarrolladores era algo tan sencillo como compilación para Win64, algo que los usuarios de VisualStudio y Java ya gozaban.

En ese momento Delphi toma una decisión interesante: debian cambiar el concepto de su propio compilador, necesitaban un Cross Compiler, es decir que desde el propio Delphi para Windows (x32) se pudiera compilar para diversas plataformas. Es por esto que el soporte para Win64 a demorado tanto tiempo, para que éste encajara en la nueva arquitectura del compilador.

Delphi XE2 viene con esta tecnología de Cross Compiler, ahora uno va a poder programar en el Delphi para Windows de siempre y compilar para:

  • Win32
  • Win64
  • Mac OS X
  • iOS (!!!!)

y producir aplicaciones nativas. Como se ve no hay Delphi para Mac, es el Delphi para Windows compilando para Mac. Nótese que para el caso de Mac y iOS por restricciones (me parece) de Apple es necesario producir el ejecutable final con la herramienta propia de Apple, el XCode, pero sin necesidad de escribir una sola línea en el oscuro Objective-C.

Bajo esta nueva arquitectura la parte visual multiplataforma esta soportada por el nuevo Firemonkey, para poder ver en acción al nuevo Delphi pueden darle una mirada a este video en el blog de Andreano Lanusse:

En el reporte que hiciera Joylon Smith sobre el lanzamiento de Delphi XE2 en Auckland, indica también lo siguiente:

  • Native Android apps – using PhoneGap in RadPHP
  • Native Android apps – to come in the future for Delphi (as well as Linux)

Ajá!!! Con la nueva versión de RadPHP también se podrá compilar para Android, empleando como intermediario PhoneGap, este producto muy interesante permite crear aplicaciones en HTML5 que puedan usar las API nativas de varias plataformas (como Android por ejemplo).

Sin embargo gracias a la tecnología del Cross Compiler, va a ser posible en corto tiempo tener un compilador nativo para Android. Recordemos que si bien la plataforma de desarrollo  de Android es Java, el corazon del robot verde no es si no Linux, y que además Android provee una API para hacer código nativo empleando NDK (Native Development Kit), que es en C o C++.

Mmmm muy interesante, si el Cross Compiler puede generar código nativo para Android y siendo Mac un sobrino de Unix (sus origenes se remontan a FreeBSD y NetBsd), no debería ser ningún problema crear ejecutables nativos para Linux.

Por qué el soporte para Mac llegó antes que el soporte para Linux? bueno acá entramos al terreno de las suposisciones. La mía es primero que Mac tiene desarrolladores más dispuestos a pagar que los de Linux, segundo que Firemonkey (en su encarnación por parte de KSDev) ya estaba maduro en Mac cuando Embarcadero lo adquirió y tercero me parece que hay algunos  desarrolladores en Embarcadero que usan Mac como plataforma principal (aunque trabajan sobre Windows en forma virtualizada).

Se vienen tiempos interesantes para Delphi, el soporte para Mac OS X y especialmente para iOS definitivamente atraerá miradas…

Delphi XE2 y Firemonkey

Bueno, poco a poco van apareciendo más detalles de la nueva versión de Delphi, la XE2.

Ahora tenemos más detalles de Firemonkey y hasta un logo!! FireMonkey-Medium

Andreano Lanusse ha publicado un blog con más detalles interesantes y hasta un par de screenshoots. Por lo que yo entiendo con Firemonkey no tenemos componentes nativos como en la VCL (que seguirá existiendo), si no que todos son dibujados por este framework. Lo bueno de esto es que se consigue libertad absoluta sobre el diseño del control. Otro punto interesante es el soporte en Firemonkey de Styles, que al igual que CSS permitirá crear temas y lo que es mejor aún lograr un look and feel (casi) nativo en cada plataforma, lo cual es muy importante para las aplicaciones para Mac y no herir susceptibilidades. Continúa leyendo Delphi XE2 y Firemonkey

Delphi y UI acelerados por hardware

Tradicionalmente Delphi ha usado las APIs que le provee Windows para dibujar sus controles, es más, los controles propios de Windows son dibujados por el sistema operativo y no por Delphi.

Windows, hasta el Vista usaba GDI para realizar estos dibujos. GDI es una API en C, para gráficos en 2D, es decir líneas, curvas, rectángulos. Internamente esta es la API que usa Windows para dibujar sus controles.  Esta API es rápida pero limitada, ya que no soporta antialiasing, ni transparencias. Sin embargo es muy rápido ya que era (hasta el Windows Vista)  parcialmente “acelerado por hardware”, esto quiere decir que algunas operaciones eran realizadas por el procesador gráfico GPU.

Al salir Windows XP, se creó un nuevo subsistema gráfico llamado GDI+ (GDI plus). Esta API en C++ ofrecía mejoras en la calidad de los gráficos ya que soportaba anitaliasing y transparecias, pero sigue siendo una API para gráficos en 2D. Estas nuevas características son realmente notorias para gráficos de alta calidad, con bordes suavizados tanto en en las lineas y curvas como en el dibujo de las letras (fonts). Sin embargo esta API trabaja integramente por software, es decir no es acelerada por hardware lo que hace que sea mucho más lento que GDI, claro que para gráficos sencillos sin mucha animación como son las interfaces de usuario tradicionales puede no ser muy dramático.

A partir de Windows Vista, Microsoft desarrolló una tecnología diferente para soportar “Aero” que es su nuevo manejador de ventanas “Desktop Window Manager (DWM) composition engine”. Este manejador está basado en DirectX. DirectX es una API de para gráficos 3D y es acelerada por hardware (asumiendo que la tarjeta gráfica soporte DirectX v9, que es el caso de todas las tarjetas modernas). Estas capacidades permiten gráficos de alta calidad usando menos CPU y de forma más rápida.

Continúa leyendo Delphi y UI acelerados por hardware

Delphi XE2

Embarcadero ha anunciado el lanzamiento del nuevo RAD Studio XE2 y con él el nuevo Delphi XE2. Aún no tenemos la fecha en la que estará dispnible al público (noviembre?) pero se esta organizando un World Tour por varias ciudades del mundo incluído Brasil y España (q pena q Perú no este incluído…) entre otros 30 países.

Se anuncia esta nueva versión como la más grande y mejor de todos los tiempos, y es verdad que trae una interesante grupo de novedades entre las que son dignas de mención:

  • Cross compiler para Windows y Mac OSX
  • Compilación para 64bits, con solo definir un nuevo Target de compilación
  • Nuevo motor gráfico Firemonkey, acelerado por GPU
  • VCL styles (temas?)
  • LiveBindings para conectar cualquier tipo de dato a un control
  • entre otros…

Realmente suena interesante!!

Si estas interesado puedes entrar al concurso por un RAD Studio XE2 gartis!! Búsca el banner en la página del Tour.

RAD Studio XE2 World Tour
RAD Studio XE2 World Tour

Dibujando con Delphi (2 – GDI)

La mayoria de los controles visuales de Delphi incluyen un Canvas sonre el que éstos están dibujados.  Muchos controles exponen su propiedad Canvas como Public y otros a través de eventos como OnPaint o CustomDraw o parecidos.

Vamos a ver ahora el ejemplo más fácil de dibujo usando el Canvas del control TPaintBox (en la paleta System). El objeto Canvas de Delphi tiene un conjunto de Propiedades y Métodos que nos permitirán dibujar Línes, Círculos, Rectángulos usando colores y colores de borde.

Coloquemos un control TPaintBox en nuestro formulario y fijemos su tamaño (Height y Width) en 150 x 150. Con el control seleccionado veamos sus Eventos y ubiquemos el evento OnPaint, doble click para entrar a su implementación, luego agreguemos el siguiente código:

procedure TForm1.PaintBox1Paint(Sender: TObject);
begin
 // Fijamos el Color del Brush (el relleno) en verde
 PaintBox1.Canvas.Brush.Color := clGreen;
// Dibujamos un rectángulos desde las coordenadas 10,10 hasta las coordenadas 60,60
 PaintBox1.Canvas.Rectangle(10, 10 , 60, 60);

 // Cambiamos el color del Pen (el borde) a rojo
 PaintBox1.Canvas.Pen.Color := clRed;
 // y fijamos el ancho del la linea de borde a 4 pixeles
 PaintBox1.Canvas.Pen.Width := 4;
 // El color del Brush (relleno) lo ponemos a amarillo
 PaintBox1.Canvas.Brush.Color := clYellow;
 PaintBox1.Canvas.Rectangle(40, 40 , 100, 100);

 // Dibujamos un círculo
 PaintBox1.Canvas.Ellipse(50, 50, 20, 20);
end;

y obtendremos eun resultado como el siguiente:

Muy fácil!! Ahora fijemonos en algunos detalles:

  • Al dibujar el primer rectángulo,  las características del Pen (borde) se dejaron con los valores por defecto (negro, 1 pixel).
  • Al dibujar el círculo se usaron los valores fijados anteriormente tanto para el Pen como para el Brush.

Esta últma observación quiere decir que si no decimos lo contrario se usarán los últimos valores fijados para el canvas.

Otra observación es que el evento OnPaint del control TPaintBox se lanza cada vez que el control deba redibujarse, esto sucede cuando por ejemplo ocultamos la ventana con otra ventana y luego la volvemos a mostrar. Si haces la prueba notarás que el dibujo a cambiado y ahora se ve así:

¿Por qué el borde del primer rectángulo cambió a rojo y es más grueso? La respuesta es que el evento OnPaint se volvió a lanzar y volvió a hacer el dibujo, sólo que las propiedades de Pen han quedado con los últimos valores que le dimos. Para evitar este efecto debes asegurarte de fijar los valores de Pen y Brush tal como quieres que se vean, es decir debimos fijar el color del Pen a clBlack y el Width del Pen a 1 antes de dibujar el primer rectángulo.

Si quieres forzar el repintado de un control puedes llamar al método Invalidate del control, por ejemplo cuando quieres cambiar programáticamente algún color.

Bueno eso es lo básico del Dibujo usando el Canvas, algunos usos interesantes son:

  • Crear tus propios controles con diseños propios.
  • Cambiar los colores en las celdas de una grilla, por ejemplo poner las filas impares de otro color, o los valores negativos con fondo rojo, dibujar indicadores especiales, etc

Más adelante veremos de hacer algunos ejemplos de éstos.

Dibujando con Delphi (1)

Delphi tiene varios mecanismos que permiten dibujar en una aplicación. Para empezar vamos a ver algunas cosas básicas.

Pensando como un niño de 5 años para dibujar necesitamos un papel en blanco un lápiz y crayones. En principio en Delphi es igual, el papel se llama Canvas, al lápiz Pen y a los crayones de colores Brush.

Nota: para avanzados: Canvas, Pen y Brush son conceptos de alto nivel, Windows tiene sus API que son un poco diferentes.

Todo lo que se ve en la pantalla en una aplicación Delphi está dibujado sobre algún Canvas.

Muchos controles tienen su propiedad Canvas como pública, lo que nos permite dibujar directamente sobre ellos. En otros casos podemos sobreescribir la forma como se dibuja un control usando el evento OnCustomDrawCell que pasa como parámetro el Canvas del control. Esto es muy potente y nos permite personalizar el aspecto visual de casi cualquier control.

Existen varias APIs que nos permiten dibujar en Delphi. Cuando usamos los métodos del objeto Canvas estaremos usando GDI de Windows que es la forma básica de dibujar, y nos permite cosas como dibujar lineas, circulos, cuadrados, texto.

Otra API más avanzada es GDI+ (GDI plus), que está disponible desde Windows XP, esta API tiene funciones mucho más avanzadas que GDI, permitiendo degradados, transparencias, dibujar 2D emplenado antaliasing (lo que permite lineas menos pixeleadas),  trasnformaciones y más. Delphi no incluye un componente ni funciones para trabajar con GDI+ directamente, pero existen varios componentes y librerías de terceros que nos permiten usar GDI+, por ejemplo http://www.bilsen.com/gdiplus/, o http://www.mitov.com/html/igdi_.html.

A partir de Windows 7, Microsoft ha introducido una API aún más avanzada llamada Direct2D, aquí si Delphi incluye soporte para esta API directamente en Delphi 2010.

Aparte de las APIs propias de Windows existen muchas otras librerias, algunas de mejor calidad, otras orientadas a la velocidad, otras para 3D.

Por ejemplo tenemos SDL, OpenGL, DirectX.

Una librería muy interesante es AggPas que es un port de AGG (Anti Grain Geometry), muy fácil de usar.

En el siguiente post veremos algunos ejemplos de algunas de éstas librerías.