Creando informes con Rave Reports (y V)

Hasta ahora hemos visto como crear informes utilizando una conexión ADO, pero surgen los siguientes inconvenientes:

- Hay que instalar un driver ODBC en el cliente.

- Hay que configurar la conexión ODBC para que apunte a nuestra base de datos.

- Cada vez que el programa va a imprimir se abre una nueva conexión a la base de datos (imaginaos 20 usuarios trabajando a la vez).

- Puede faltar alguna DLL a la hora de instalar el programa en el cliente relacionada con conexiones ODBC.

Para solucionar esto vamos a ver como utilizar los objetos Direct Data View en el diseñador Rave Reports que nos van a evitar todos estos problemas.

PASANDO DE ADO, BDE y DBX

Los componentes Direct Data View que se encuentran en el editor Rave Designer permiten vincular los informes directamente con los componentes TRvDataSetConnection que se encuentren en nuestro programa Delphi, sin tener que establecer ninguna conexión de base de datos ni preocuparnos por drivers externos.

Funciona exactamente igual que los informes generados por QuickReport, donde el origen de datos es nuestro mismo programa, ahorrándonos conexiones extras. Vamos a ver un ejemplo de cómo generar un listado de clientes realizando una conexión directa entre Delphi y Rave Reports.

Los siguientes pasos serían para crear una conexión a Firebird desde Delphi:

1. Abrimos Delphi y creamos un formulario de prueba.

2. Insertamos un componente de la clase TIBDatabase en el formulario con el nombre BaseDatos.

3. Hacemos doble clic en el componente TIBDatabase y rellenamos los siguientes datos:

Connection: Remote
Server: 127.0.0.1
Database: D:\Desarrollo\DelphiAlLimite\Rave\BaseDatos.fdb
UserName: SYSDBA
Password: masterkey
Login Prompt: Desactivado

4. Añadimos un componente TIBTransaction y lo llamamos Transaccion.

5. Asociamos el componente Transaccion al componente BaseDatos a través de su propiedad DefaultTransaction.

6. En la propiedad DefaultDatabase del objeto TIBTransaction seleccionamos BaseDatos.

7. Insertamos en el formulario un componente TIBQuery con el nombre TClientes. En su propiedad Database seleccionamos BaseDatos. Y en su propiedad SQL ponemos:

SELECT * FROM CLIENTES

8. Hacemos doble clic sobre el componente TIBQuery y pulsamos la combinación de teclas CTRL + A para traernos los campos. Al hacer esto habrá dejado la base de datos abierta (BaseDatos). La dejamos así por ahora.

9. Insertamos en el formulario un componente TRvProject y lo llamamos Proyecto.

10. Insertamos otro componente de TRvSystem y lo llamamos Sistema. Asociamos este componente con TRvProject con su propiedad Engine.

11. Añadimos al formulario un componente TRvDataSetConnection que llamaremos DSClientes. En su propiedad DataSet elegimos TClientes.

Con toda esta movida ya tenemos una conexión a una base de datos Firebird y un DataSet especial para que Rave pueda recoger los datos.

CREANDO EL INFORME EN RAVE REPORTS

Dejando Delphi abierto con nuestra base de datos conectada (BaseDatos) ejecutamos el programa Rave Designer. Una vez estamos en el diseñador vamos a efectuar los siguiente pasos:

1. Pulsamos el botón New Data Object.

2. Seleccionamos Direct Data View y pulsamos Next.

3. Nos aparecerá una lista de conexiones abiertas en Delphi donde se estén utilizando componente TRvDataSetConnection. En nuestro caso aparecera DSClientes (DT). Lo seleccionamos y pulsamos Finish.

4. Renombramos el objeto DataView1 creado y lo llamamos Clientes.

5. Seleccionamos en el menú de arriba Tools -> Report Wizards -> Simple Table.

6. Seleccionamos Clientes y pulsamos Next.

7. Seleccionamos los campos ID, NOMBRE, DIRECCION, NIF, PROVINCIA y pulsamos Next.

8. Dejamos la ordenación como está y pulsamos Next.

9. En Report Title ponemos Listado de Clientes y pulsamos Next.

10. Seleccionamos la fuente a nuestro gusto y pulsamos Generate.

11. Guardamos el informe en el mismo directorio que nuestro proyecto de Delphi con el nombre Clientes.rav.

Si pulsamos el botón de la impresora y mostramos una vista previa veremos como se trae directamente de Delphi los datos y los imprime.

La potencia que nos da esta forma de trabajar es enorme, ya que es nuestro proyecto Delphi el que suministra los datos, siendo posible filtrar y ordenar tablas de bases de datos a nuestro antojo sin que Rave Reports no tenga que enterarse de donde proceden los datos.

Ya podemos cerrar el programa Rave Designer. Ahora vamos a ver como lanzar el informe desde Delphi.

LANZANDO EL INFORME RAVE DESDE DELPHI

En Delphi ya podemos desconectar la base de datos en tiempo de diseño. Para lanzar el listado hacemos lo siguiente:

begin
  BaseDatos.DatabaseName := '127.0.0.1:' + ExtractFilePath( Application.ExeName ) + 'BaseDatos.fdb';

  try
    BaseDatos.Open;
  except
    raise;
  end;

  TClientes.Open;
  Proyecto.ProjectFile := ExtractFilePath( Application.ExeName ) + 'clientes.rav';
  Proyecto.Execute;
end;

Esto abrirá la base de datos Firebird, también la tabla clientes y ejecutará el informe.

A partir de aquí podemos hacer lo que nos venga en gana para modificar el listado de clientes: modificar la SQL para cambiar la ordenación, filtrar por ID, NIF, etc.

FILTRANDO TABLAS MAESTRO/DETALLE EN RAVE REPORTS

Utilizando las tablas FACTURAS y DETALLEFAC que vimos anteriormente podemos filtrar el detalle de la factura a partir de la cabecera. Resumiendo un poco, los pasos serían los siguientes:

1. Vinculamos las tablas FACTURAS y DETALLEFAC en el informe utilizando componentes Direct Data View.

2. Volvemos a vincular los campos con estos dos componentes.

3. Seleccionamos la banda Detalle y configuramos las siguientes propiedades:

MasterDataView: Facturas
MasterKey: ID
DetailKey: IDFACTURA

Con estos simples pasos imprimiremos las facturas desde Delphi sin tener que preocuparnos de filtrar la tabla detalle. También habría que crear otro objeto Direct Data View para enlazar a la tabla CLIENTES y poder traernos los datos. Para imprimir la factura desde Delphi filtrando al cliente:

begin
  BaseDatos.DatabaseName := '127.0.0.1:' + ExtractFilePath( Application.ExeName ) + 'BaseDatos.fdb';

  try
    BaseDatos.Open;
  except
    raise;
  end;

  // Filtramos la factura
  TFacturas.SQL.Clear;
  TFacturas.SQL.Add( 'SELECT * FROM FACTURAS WHERE ID=2' );
  TFacturas.Open;

  // Filtramos el cliente según la factura
  TClientes.SQL.Clear;
  TClientes.SQL.Add( 'SELECT * FROM CLIENTES WHERE ID=' + TFacturas.FieldByName( 'IDCLIENTE' ).AsString );
  TClientes.Open;

  // Abrimos el detalle (ya se encarga Rave de filtrarlo respecto a la cabecera)
  TDetalleFac.Open;

  // Lanzamos el informe
  Proyecto.ProjectFile := ExtractFilePath( Application.ExeName ) + 'factura.rav';
  Proyecto.Execute;
end;

Se supone que hemos creado en el formulario de Delphi dos componentes TIBQuery llamados TFactura y TDetalleFac para la cabecera y detalle de la factura.

Con esto finalizamos la introducción al editor de informes Rave Reports.

Pruebas realizadas en Delphi 7, Rave Reports 5.0 y Firebird 2.0.

Creando informes con Rave Reports (IV)

Después de crear los informes utilizando el programa Rave Designer ahora vamos a ver como abrir esos informes con extensión RAV dentro de nuestro proyecto de Delphi.

ABRIENDO INFORMES RAVE DESDE DELPHI

Para llamar a los informes creados desde Delphi vamos a insertar en nuestro formulario los componentes de la clase TRvProject y TRvSystem situados en la pestaña Rave. Al objeto RvProject lo vamos a llamar Proyecto y al componente RvSystem lo llamaremos Sistema.


También vamos a vincular el componente Sistema al componente Proyecto a través de su propiedad Engine. Como estamos utilizando una conexión ADO tenemos que añadir en la sección uses de nuestro formulario la unidad RvDLADO, porque en caso contrario nos mostraría el error:

No DATA Link drivers have been loaded.

El objeto RvSystem realmente no es obligatorio utilizarlo, pero es recomendable porque con el mismo podemos personalizar todo lo relacionado con la impresión de documentos, desde el título, hasta los mensajes, la forma de como mostrar la vista previa, etc.

Pues con esto ya podemos lanzar la vista previa del informe:

begin
  Proyecto.ProjectFile := ExtractFilePath( Application.ExeName ) + 'factura.rav';
  Proyecto.Execute;
end;

Primero se nos abre una ventana para seleccionar el tipo de impresión y la impresora por donde va a salir:


Si queremos quitar esta ventana y que lance directamente la vista previa del informe tenemos que desactivar la propiedad ssAllowSetup que se encuentra dentro de la propiedad SystemSetups del componente RvSystem (que hemos llamado Sistema).

Para lanzar directamente el informe a la impresora sin vista previa hay que configurar la propiedad DefaultDest del componente RvSystem con el valor rdPrinter.

INSTALANDO NUESTRA APLICACION EN OTRO PC

Uno de los problemas que suelen ocurrir al llevarnos la aplicación a otro ordenador es que siempre falta que configurar algo para que pueda imprimirse el informe.

En mi caso he probado a ejecutar la aplicación en una máquina virtual limpia (VMWare con Windows XP) y sólo he tenido que hacer lo siguiente para que imprima el informe:

- Hay que instalar el driver ODBC de Firebird 2.0 como mencioné en otro artículo anterior.

- Hay que ir a herramientas administrativas dentro del panel de control de Windows y configurar nuestra conexión hacia el archivo BaseDatos.fdb. El alias de la conexión tiene que llamarse igual como lo hicimos anteriormente: BaseDatos_Rave.

- Me ha ocurrido que al hacer un test de conexión me faltaba la siguiente librería:

MSVCR71.DLL

Para solucionarlo lo copiamos de otro Windows XP que lo tenga y lo metemos en la carpeta C:\Windows\System32\ y listo. O bien lo bajamos de Internet.

Y con esto ya tenemos nuestros informes funcionando en otra máquina. Naturalmente damos por hecho de que tiene instalado el motor de bases de datos Firebird 2.0.

En el próximo artículo seguiremos viendo más cosas interesantes relacionadas con Rave Reports.

Pruebas realizadas en Delphi 7 y Firebird 2.0.

Creando informes con Rave Reports (III)

Una vez que sabemos crear listados a partir de una tabla vamos a ver como se haría para tablas maestro/detalle, como puede ser una factura.

Nuestra factura consta de dos tablas. La cabecera de la factura está implementada en esta tabla:

CREATE TABLE FACTURAS (
ID          INTEGER NOT NULL,
IDCLIENTE   INTEGER,
BASEIMP     DOUBLE PRECISION,
IVA         DOUBLE PRECISION,
IMPORTEIVA  DOUBLE PRECISION,
TOTAL       DOUBLE PRECISION,
PRIMARY KEY (ID)
);

Y el detalle de la misma en esta otra:

CREATE TABLE DETALLEFAC (
ID          INTEGER NOT NULL,
IDFACTURA   INTEGER,
UNIDADES    DOUBLE PRECISION,
ARTICULO    VARCHAR(100),
PRECIO      DOUBLE PRECISION,
TOTALLINEA  DOUBLE PRECISION,
PRIMARY KEY (ID)
);

Cada línea de detalle está vinculada a la cabecera mediante el campo IDFACTURA.

VINCULANDO LAS TABLAS MAESTRO/DETALLE AL INFORME

Primero tenemos que incluir dos objetos DriverDataView para las tablas de cabecera y detalle. Hacemos lo siguiente:

1. Pulsamos el botón New Data Object.

2. Seleccionamos Driver Data View y pulsamos el botón Next.

3. Seleccionamos BaseDatos y pulsamos el botón Finish.

4. En la ventana que aparece pulsamos el botón Editor.

5. Escribimos una SQL que nos permita traernos los datos del cliente:

SELECT * FROM FACTURAS
LEFT JOIN CLIENTES ON FACTURAS.IDCLIENTE=CLIENTES.ID

6. Pulsamos el botón Ok.

7. Estando en el editor seleccionamos a la derecha el nuevo DriverDataView1 creado y a la izquierda ponemos su propiedad Name a Facturas.

Siguiendo los mismos pasos tenemos que vincular la tabla DETALLEFAC con la SQL:

SELECT * FROM DETALLEFAC

CREANDO INFORMES PARA TABLAS MAESTRO/DETALLE

En esta ocasión vamos a ver como crear una factura utilizando directamente el editor sin asistentes. El resultado sería el siguiente:


Los pasos para crear esta factura serían los siguientes:

1. Insertamos un componente Region que esta situado en la pestaña Report.

2. Dentro de la región creada insertamos tres componentes de tipo DataBand (pestaña Report).

3. A las tres bandas creadas las vamos a llamar Cabecera, Detalle y Pie.

4. A la propiedad DataView de la bandas Cabecera y Pie le asignamos la tabla Facturas.

5. A la propiedad DataView de la banda Detalle le asignamos la tabla DetalleFac.

6. La cabecera se compone de:


- 6 etiquetas en negrita de tipo Text situadas en la pestaña Standard.

- 8 campos de tipo DataText situados en la pestaña Report para los campos: ID, NOMBRE, DIRECCION, POBLACION, CP, PROVINCIA y NIF.

- 4 líneas utilizando el componente Line situado en la pestaña Drawing.

7. El detalle se compone de:


- 4 componetes de tipo DataText para los campos UNIDADES, ARTICULO, PRECIO y TOTALLINEA. Para que los campos UNIDADES, PRECIO y TOTALLINEA salgan con formato a dos decimales tenemos que seleccionar en el árbol del proyecto a la derecha (debajo de DetalleFac) los campos DetalleFacUNIDADES, DetalleFacPRECIO y DetalleFacTOTALLINEA y establecer su propiedad DisplayFormat con el valor ###,###,#0.00. A dichos campos también hay que ponerle su propiedad FontJustify con el valor pjRight (eso se hace en el folio) para que aparezcan alineados a la derecha.

8. El pie tiene el siguiente diseño:


- 3 etiquetas de tipo Text.

- 3 campos de tipo DataText para los campos BASEIMP, IMPORTEIVA y TOTAL, dando el formato de número real como hemos hecho con los campos moneda del detalle.

- 1 rectángulo de tipo Rectangle situado en la pestaña Drawing.

Y por último fuera de la región en la parte superor del folio he añadido una etiqueta con la palabra FACTURA.

Al ejecutar el informe este sería el resultado:


Como puede verse es muy fácil crear informes utilizando Rave Reports siempre que tengamos claro de que tabla extraer la información.

En el próximo artículo veremos como ejecutar estos informes desde Delphi.

Pruebas realizadas con Firebird 2.0 y Rave Reports 5.0.

Creando informes con Rave Reports (II)

Una vez establecida la conexión con la base de datos vamos a crear un objeto DriverDataView para vincularlo a nuestro informe.

CREANDO UN VINCULO PARA LA TABLA CLIENTES

Para enlazar la tabla de clientes hay que hacer lo siguiente:

1. Pulsamos el botón NewDataObject y pulsamos el botón Next.

2. Seleccionamos Driver Data View y pulsamos el botón Next.

3. Seleccionamos BaseDatos y pulsamos el botón Finish. Se abrirá la siguiente ventana:


4. Pulsamos el botón Editor y se mostrará de esta forma:


5. Escribimos la siguiente SQL:

SELECT * FROM CLIENTES

6. Pulsamos el botón Ok.

7. Si nos fijamos a la derecha del editor a aparecido el objeto DriverDataView1. Lo seleccionamos y en la parte izquierda del editor cambiamos su propiedad Name a Clientes.

Con esto ya tenemos vinculada la tabla CLIENTES a nuestro informe.

UTILIZANDO EL ASISTENTE PARA GENERAR INFORMES

Vamos a ver los pasos para generar el listado de clientes utilizando el Wizard:

1. Seleccionamos Tools -> Report Wizards -> Simple Table. Aparecera esta ventana:


2. Seleccionamos Clientes y pulsamos Next:


3. Vamos a seleccionar los campos ID, NOMBRE, CP, PROVINCIA y NIF. Pulsamos Ok.

4. En la siguiente ventana se nos da la opción de ordenar los campos a nuestro gusto. En este caso he puesto el NIF después del NOMBRE. Al pulsar Next nos aparecera esta ventana:


5. En el campo Report Title ponemos Listado de Clientes. También podemos configurar los márgenes a nuestro gusto, aunque en este caso lo dejamos como está y pulsamos el botón Next. La siguiente ventana es esta:


6. Aquí podemos cambiar la fuente para el título, la cabecera de los campos y la fuente de los campos. En la cabecera de los campos le he configurado una fuente a Tahoma tamaño 10 y negrita. Para los campos lo he dejado en Tahoma 10. Al pulsar el botón Generate y aparecerá lo siguiente:


Con esto ya tenemos hecho el listado. Si pulsamos el botón Execute Report (la impresora) y seleccionamos Preview podemos ver como queda la vista previa del listado.

Como puede verse a primera vista los campos nos aparecen demasiado pegados los unos de los otros. Lo que hay que hacer es ajustar a mano en el editor las columnas para que queden a nuestro gusto.

Una de las cosas que mas me gustan de este editor es que se pueden seleccionar a la vez componentes de distintas bandas para moverlos o redimensionarlos. Con la tecla Mayúsculas pulsada y con los cursores del teclado podemos ampliar o reducir el tamaño de los campos. Y con la tecla Control pulsada se pueden mover varios campos a la vez. El comportamiento es muy similar al editor de formularios de Delphi.

ANALIZANDO EL INFORME CREADO

Si nos fijamos bien en el informe creado aparecen los siguientes objetos:

1. Primero crea un objeto Region (pestaña Report) para colocar todo el diseño encima.

2. Dentro de la región creada introduce tres bandas mediante el componente Band que se encuentra en la pestaña Report:

- ClientesTitleBand: La primera banda para el título Listado de Clientes.

- ClientesBand: La segunda banda contiene los títulos de los campos.

- ClientesDataBand: La tercera banda incluye los campos que se van a imprimir. Esta última banda es de tipo DataBand (también en la pestaña Report).

Lo bueno de tenerlo todo dentro de un componente Region es que si tenemos problemas con los márgenes de impresión, ajustando la región a nuestro gusto no aperecán los típicos problemas de folios duplicados en impresoras laser o multifunción que hace que salgan dos copias.

En el siguiente artículo vamos a crear un listado para tablas maestro/detalle.

Pruebas realizadas con Firebird 2.0 y Rave Reports 5.0.

Creando informes con Rave Reports (I)

Rave Reports es una herramienta externa asociada a Delphi que permite la creación de informes a partir de una base de datos. Se pueden crear toda variedad de informes, desde un simple folio con una banda hasta otros más complejos con múltiples bandas. Incluye las siguientes características:

- Integración de gráficos.
- Párrafos justificados.
- Modificación de opciones de impresora.
- Control de las fuentes.
- Vista previa antes de imprimir.
- Exportación a PDF, HTML, RTF y archivos de texto.

CREANDO UN INFORME PARA NUESTRA APLICACION

Vamos a suponer que tengo una base de datos creada en Firebird 2.0 cuyo nombre es BaseDatos.fdb. Esta base de datos tiene la siguiente tabla:

CREATE TABLE CLIENTES (
ID INTEGER NOT NULL,
NOMBRE VARCHAR(100),
DIRECCION VARCHAR(100),
POBLACION VARCHAR(50),
CP VARCHAR(5),
PROVINCIA VARCHAR(50),
IMPORTEPTE DOUBLE PRECISION,
NIF VARCHAR(15),
ALTA TIMESTAMP,
HORALLAMAR TIME,
ULTIMOPAGO DATE,
NUMPAGOS INTEGER,
OBSERVACIONES BLOB
);

Entonces vamos a crear un informe para sacar un listado de clientes. Para ello abrimos el diseñador de informes Rave desde Delphi a través de la opción Tools -> Rave Designer. Nos aparecera el siguiente entorno:


Los informes que genera este diseñador de informes tienen extensión RAV. Por defecto, el nombre del informe que vamos a crear se llama Project1.rav. Le vamos a cambiar el nombre seleccionando File -> Save As... con el nombre listado_clientes.rav.

Antes de comenzar a diseñar el listado tenemos que establecer una conexión con nuestra base de datos Firebird llamada BaseDatos.fdb para poder extraer la información.

CONFIGURANDO LA CONEXION ODBC

Como vamos a utilizar una conexión ADO para vincularlo a este informe, primero tenemos que establecer el orígen de datos ODBC. Al ser mi base de datos es Firebird me he instalado el driver ODBC que se encuentra en la página:

http://www.firebirdsql.org/

El driver se encuentra en el apartado Development -> Firebird ODBC Driver.

Aparte de utilizar este driver para conexiones ADO nos puede ser muy útil para vincular nuestras bases de datos a prográmas ofimáticos tales como Word, Excel y Access.

Una vez descargado e instalado el driver ODBC vamos a realizar los siguientes pasos:

1. Abrimos el panel de control de Windows.

2. Hacemos doble clic en el icono Herramientas Administrativas.

3. Hacemos doble clic en el icono Orígenes de datos (ODBC).

4. Teniendo seleccionada la pestaña DSN de usuario pulsamos el botón Agregar.

5. Seleccionamos Firebird/Interbase(r) Driver y pulsamos el botón Finalizar.

6. Se abrirá la siguiente ventana:


7. Vamos a rellenar los siguientes parámetros:

Nombre de Origen de Datos (DSN): BaseDatos_Rave
Description: BaseDatos_Rave
Base de Datos: D:\Desarrollo\DelphiAlLimite\Rave\BASEDATOS.FDB (donde esté el archivo FDB)
Cliente: C:\Firebird2\bin\fbclient.dll (donde esté instalado Firebird 2.0)
Cuenta de Base de Datos: SYSDBA
Contraseña: masterkey

8. Pulsamos el botón Comprobar conexión y debe mostrar ¡La conexión fue exitosa!

9. Pulsamos el botón Aceptar y veremos en la ventana anterior nuestra nueva conexión: BaseDatos_Rave.

10. Pulsamos el botón Aceptar y cerramos el panel de control de Windows.

Una vez configurada la conexión ODBC en Windows vamos a vincularla a nuestro informe.

CONECTANDO CON LA BASE DE DATOS DESDE RAVE REPORTS

Para establecer una conexión con nuestra base de datos Firebird nos tenemos que ir a la barra de botones que se encuentra en la esquina superior izquierda del diseñador de informes Rave y pulsar el botón New Data Object:
Al pulsarlo nos aparecen las siguientes opciones:


Seleccionamos Database Connection y pulsamos Next. La conexión sólo se puede realizar a través de ADO, BDE o DBExpress, aunque pueden añadirse otros drivers de conexión dentro del directorio:

C:\Archivos de programa\Borland\Delphi7\Rave5\DataLinks\

Seleccionamos ADO y pulsamos el botón Finish. Nos aparecerá la siguiente ventana:


Seleccionamos la opción Use Connection String y pulsamos el botón [...] que aparece a la derecha. Aparecerá la ventana de las propiedades de vínculo de datos:


Seleccionamos la pestaña Conexión y en la opción Usar el nombre de origen de datos seleccionamos BaseDatos_Rave. Pulsamos el botón Probar Conexión y nos saldrá el mensaje: La prueba de conexión fue satisfactoria. Pulsamos el botón Aceptar y en la ventana anterior pulsamos Ok.

Después de mucho sacrificio (es más fácil recompilar el núcleo de Linux) ya tenemos en el diseñador Rave la conexión directa con nuestra base de datos:


Si seleccionamos Database1 a la izquierda veremos sus propiedades:


Vamos a renombar las propiedades FullName y Name a BaseDatos.

En el próximo artículo vamos a vincular la tabla clientes y vamos a realizar el informe.

Pruebas realizadas con Firebird 2.0 y Rave Reports 5.0.

Como manejar excepciones en Delphi (y II)

Una vez que hemos visto lo que es una excepción y cómo proteger nuestro código usando bloques protegidos vamos a pasar a ver como pueden meterse unas excepciones dentro de otras para dar más seguridad a nuestro código. Es lo que se llaman excepciones anidadas.

EXCEPCIONES ANIDADAS

Vamos a ver un ejemplo de como anidar una excepción dentro de otra:

var
  F: TextFile;
begin
  AssignFile( F, 'C:\noexiste.txt' );

  try
    Reset( F );

    try
      CloseFile( F );
    except
      on E: Exception do
        ShowMessage( 'Excepción 2: ' + E.Message );
    end;

  except
    on E: Exception do
      ShowMessage( 'Excepción 1: ' + E.Message );
  end;
end;

En este ejemplo hemos metido un bloque protegido dentro de otro, donde cada uno controla su propia excepción. En este caso provocaría la excepción 1 ya que el archivo no existe.

DETENIENDO LA EXCEPCION

Cuando se provoca una excepción, una vez la hemos procesado con la sentencia on E: Exception, la ejecución continua hacia el siguiente bloque de código. Si queremos detener la ejecución del programa debemos utilizar el comando raise:

var
  F: TextFile;
begin
  AssignFile( F, 'C:\noexiste.txt' );
  ShowMessage( '1' );

  try
    Reset( F );

  except
    on E: Exception do
      raise;
  end;

  ShowMessage( '2' );
end;

En este ejemplo nunca llegaría a ejecutarse el segundo ShowMessage ya que raise detiene la ejecución del procedimiento.

FORZANDO A QUE FINALICE LA EJECUCION

Hay bloques de código en los cuales cuando se provoca una excepción ni podemos continuar con la ejecución ni podemos cortar la ejecución. Por ejemplo, supongamos que abro un archivo en módo sólo lectura e intento escribir en el mismo. Esto provocaría una excepción, pero lo que no puedo hacer es detener en seco la ejecución del programa ya que hay que cerrar el archivo que hemos abierto.

Para solucionar esto, los bloques protegidos permiten finalizar la ejecución en el caso de que se produzca una excepción mediante la claúsula finally. En nuestro ejemplo nos interesa que se cierre el archivo abierto:

var
  F: TextFile;
begin
  AssignFile( F, 'C:\prueba.txt' );

  try
    Reset( F );

    try
      WriteLn( F, 'intentando escribir' );
    finally
      ShowMessage( 'Finalizando...' );
      CloseFile( F );
    end;

  except
    on E: Exception do
      raise;
  end;
end;

Tenemos dos excepciones anidadas: una para abrir el archivo con una sentencia except que detiene la ejecución y otra dentro que utiliza la sentencia finally para cerrar el archivo en el caso de que se produzca un error.

TRATANDO EXCEPCIONES EN COMPONENTES VCL

Los componentes VCL también pueden provocar muchas excepciones si no sabemos utilizarlos correctamente. Un error típico es el intentar acceder a un elemento que no existe dentro de un componente ListBox llamado Lista:

begin
  Lista.Items.Add( 'PABLO' );
  Lista.Items.Add( 'MARIA' );
  Lista.Items.Add( 'CARLOS' );

  try
    ShowMessage( Lista.Items[4] );
  except
    on E: EStringListError do
      ShowMessage( 'La lista sólo tiene tres elementos.' );
  end;
end;

En este caso se ha provocado una excepción de la clase EStringListError, aunque bien se podría haber controlado de este modo:

  try
    ShowMessage( Lista.Items[4] );
  except
    on E: Exception do
      ShowMessage( 'La lista sólo tiene tres elementos.' );
  end;

Los componentes VCL disponen principalmente de estas clases de excepciones:

EAbort: Finaliza la secuencia de eventos sin mostrar el mensaje de error.

EAccessViolation: Comprueba errores de acceso a memoria inválidos.

EBitsError: Previene intentos para acceder a arrays de elementos booleanos.

EComponentError: Nos informa de un intento inválido de registar o renombar un componente.

EConvertError: Muestra un error al convertir objetos o cadenas de texto string.

EDatabaseError: Especifica un error de acceso a bases de datos.

EDBEditError: Error al introducir datos incompatibles con una máscara de texto.

EDivByZero: Errores de división por cero.

EExternalException: Significa que no reconoce el tipo de excepción (viene de fuera).

EIntOutError: Representa un error de entrada/salida a archivos.

EIntOverflow: Especifica que se ha provocado un desbordamiento de un tipo de dato.

EInvalidCast: Comprueba un error de conversión de tipos.

EInvalidGraphic: Indica un intento de trabajar con gráficos que tienen un formato desconocido.

EInvalidOperation: Ocurre cuando se ha intentado realizar una operación inválida sobre un componente.

EInvalidPointer: Se produce en operaciones con punteros inválidos.

EMenuError: Controla todos los errores relacionados con componentes de menú.

EOleCtrlError: Detecta problemas con controles ActiveX.

EOleError: Especifica errores de automatización de objetos OLE.

EPrinterError: Errores al imprimir.

EPropertyError: Ocurre cuando se intenta asignar un valor erroneo a una propiedad del componente.

ERangeError: Indica si se intenta asignar un número entero demasiado grande a una propiedad.

ERegistryExcepcion: Controla los errores en el resigtro.

EZeroDivide: Controla los errores de división para valores reales.

EXCEPCIONES SILENCIOSAS

Para dar un toque profesional a un programa hay ocasiones en que nos interesa controlar la excepción pero que no se entere el usuario del programa. Lo que no se puede hacer es abandonar la excepción con los comandos Break o con Exit ya que puede ser peor el remedio que la enfermedad.

Para salir elegantemente de una excepción hay que utilizar el comando Abort:

try
  { sentencias }
except
  Abort;
end;

De este modo se controla la excepción y el usuario no ve nada en pantalla.

Con esto finalizamos el tratamiento de excepciones en Delphi.

Pruebas realizadas en Delphi 7.

Como manejar excepciones en Delphi (I)

Las excepciones son condiciones excepcionales que se producen en nuestra aplicación en tiempo de ejecución y que requieren un tratamiento especial. Un ejemplo de excepciones podría ser las divisiones por cero o los desbordamientos de memoria. El tratamiento de excepciones proporciona una forma estándar de controlar los errores, descubriendo anticipadamente los problemas y posibilitando al programador anticiparse a los fallos que puedan ocurrir.

Cuando ocurre un error en un programa, se produce una excepción, lo que significa que crea un objeto excepción y situa el puntero de la pila en el primer punto donde se ha provocado la excepción. El objeto excepción contiene información sobre todo lo que ha ocurrido.

Esto nos permite crear aplicaciones más robustas ya que se puede llegar a averiguar el lugar en concreto donde se ha producido el error, particularmente en áreas donde los errores puedan causar la perdida de datos y recursos del sistema.

Cuando creamos una respuesta a la excepción tenemos que hacerlo en dentro de bloques de código, los cuales se llaman bloques de código protegidos.

DEFINIENDO BLOQUES DE CODIGO PROTEGIDOS

Los bloques de código protegidos comienzan con la palabra reservada try. Si ocurre algún error dentro del bloque de código protegido, el tratamiento del error se introduce en un bloque de código que comienza con except.

Vamos a ver un ejemplo que provoca una excepción al abrir un archivo que no existe:

var
  F: TextFile;
begin
  AssignFile( F, 'c:\nosexiste.txt' );

  try
    Reset( F );
  except
    on E: Exception do
      Application.MessageBox( PChar( E.Message ), 'Error', MB_ICONSTOP );
  end;
end;

La primera parte de un bloque protegido comienza con la palabra try. El bloque try contiene el código que potencialmente puede provocar la excepción. Al provocar la excepción saltará directamente al comienzo del bloque de código que comienza con la palabra reservada except.

Como puede apreciarse en el código anterior hemos creado un objeto E que representa la excepción creada. El objeto E pertenece a la clase Exception que a su vez hereda directamente de la clase TObject. Este objeto contiene propiedades y métodos para manejar la excepción provocada.

PROVOCANCO NUESTRA PROPIA EXCEPCION

Nosotros también podemos crear nuestras propias excepciones que hereden de la clase Exception. Por ejemplo, voy a crear una excepción si una variable de tipo string está vacía. Primero defino el tipo especial de excepción:

type
  ECadenaVacia = class( Exception );

Y ahora la provoco en el programa:

var
  sCadena: String;
begin
  if sCadena = '' then
    raise ECadenaVacia.Create( 'Cadena vacia.' );
end;

El comando raise provoca a propósito la excepción para detener la ejecución del programa. No es necesario que creemos nuestros tipos de excepción. También podía haber sido así:

  if sCadena = '' then
    raise Exception.Create( 'cadena vacia' );

Cuando se provoca una excepción la variable global ErrorAddr declarada dentro de la unidad System contiene un puntero a la dirección de memoria donde se ha provocado el error. Esta variable es de sólo lectura a título informativo.

CONTROLANDO UNA EXCEPCION SEGUN SU TIPO

Dentro de un mismo bloque de código podemos controlar que tipo de excepción queremos controlar. Por ejemplo, si ejecutamos el código:

var
  s: string;
  i: Integer;
begin
  s := 'prueba';
  i := StrToInt( s );
end;

Mostrará el error:

'prueba' not is a valid integer value

Si queremos saber el tipo de excepción podemos sacarla por pantalla:

var
  s: string;
  i: Integer;
begin
  s := 'prueba';

  try
    i := StrToInt( s );
  except
    on E: Exception  do
      Application.MessageBox( PChar( E.ClassName + ': ' + E.Message ), 'Error', MB_ICONSTOP );
  end;
end;

Hemos incluido en el mensaje de la excepción la clase y el mensaje de error. Este sería el resultado:

EConvertError: 'prueba' not is a valid integer value

Así, mediante la propiedad ClassName de la clase Exception podemos averiguar la clase a la que pertenece la excepción. Ahora mediante la sentencia on podemos aislar la excepción de la forma:

on tipo do sentencia

En nuestro caso sería así:

  try
    i := StrToInt( s );
  except
    on E: EConvertError  do
      Application.MessageBox( 'Error de conversión', 'Error', MB_ICONSTOP )
    else
      Application.MessageBox( 'Error desconocido', 'Error', MB_ICONSTOP );
  end;

Si se produjera una excepción que no fuese de la clase EConvertError mostraría el mensaje Error desconocido.

De este modo podemos aislar dentro de un mismo bloque de código los distintos tipos de excepción que se puedan producir.

Otro ejemplo podría ser la división de dos números enteros:

try
  Resultado = b div c;
except
  on EZeroDivide do Resultado := MAXINT;
  on EIntOverflow do Resultado := 0;
  on EIntUnderflow do Resultado := 0;
end;

Aquí hemos aislado cada uno de los casos que se puedan producir al dividir dos números enteros, alterando el resultado a nuestro antojo.

En el próximo artículo seguiremos viendo más características de las excepciones.

Pruebas realizadas en Delphi 7.

Moviendo sprites con el teclado y el ratón

Basándome en el ejemplo del artículo anterior que mostraba como realizar el movimiento de sprites con fondo vamos a ver como el usuario puede mover los sprites usando el teclado y el ratón.

CAPTURANDO LOS EVENTOS DEL TECLADO

La clase TForm dispone de dos eventos para controlar las pulsaciones de teclado: OnKeyDown y OnKeyUp. Necesitamos ambos eventos porque no sólo me interesa saber cuando un usuario ha pulsado una tecla sino también cuando la ha soltado (para controlar las diagonales).

Para hacer esto voy a crear cuatro variables booleanas en la sección private el formulario que me van a informar de cuando están pulsadas las teclas del cursor:

type
  private
    { Private declarations }
    Sprite: TSprite;
    Buffer, Fondo: TImage;
    bDerecha, bIzquierda, bArriba, bAbajo: Boolean;

Estas variables las voy a actualizar en el evento OnKeyDown:

procedure TFormulario.FormKeyDown( Sender: TObject; var Key: Word; Shift: TShiftState );
begin
  case key of
    VK_LEFT: bIzquierda := True;
    VK_DOWN: bAbajo := True;
    VK_UP: bArriba := True;
    VK_RIGHT: bDerecha := True;
  end;
end;

y en el evento OnKeyUp:

procedure TFormulario.FormKeyUp( Sender: TObject; var Key: Word; Shift: TShiftState );
begin
  case key of
    VK_LEFT: bIzquierda := False;
    VK_DOWN: bAbajo := False;
    VK_UP: bArriba := False;
    VK_RIGHT: bDerecha := False;
  end;
end;

Al igual que hice con el ejemplo anterior voy a utilizar un temporizador (TTimer) llamado TmpTeclado con un intervalo que va a ser también de 10 milisegundos y cuyo evento OnTimer va a encargarse de dibujar el sprite en pantalla:

procedure TFormulario.TmpTecladoTimer( Sender: TObject );
begin
  // ¿Ha pulsado la tecla izquierda?
  if bIzquierda then
    if Sprite.x > 0 then
      Dec( Sprite.x );

  // ¿Ha pulsado la tecla arriba?
  if bArriba then
    if Sprite.y > 0 then
      Dec( Sprite.y );

  // ¿Ha pulsado la tecla derecha?
  if bDerecha then
    if Sprite.x + Sprite.Imagen.Width < ClientWidth then
      Inc( Sprite.x );

  // ¿Ha pulsado la tecla abajo?
  if bAbajo then
    if Sprite.y + Sprite.Imagen.Height < ClientHeight then
      Inc( Sprite.y );

  DibujarSprite;
end;

Este evento comprueba la pulsación de todas las teclas controlando que el sprite no se salga del formulario. El procedimiento de DibujarSprite sería el siguiente:

procedure TFormulario.DibujarSprite;
var
  Origen, Destino: TRect;
begin
  // Copiamos el fondo de pantalla al buffer
  Origen.Left := Sprite.x;
  Origen.Top := Sprite.y;
  Origen.Right := Sprite.x + Sprite.Imagen.Width;
  Origen.Bottom := Sprite.y + Sprite.Imagen.Height;
  Destino.Left := 0;
  Destino.Top := 0;
  Destino.Right := Sprite.Imagen.Width;
  Destino.Bottom := Sprite.Imagen.Height;
  Buffer.Canvas.CopyMode := cmSrcCopy;
  Buffer.Canvas.CopyRect( Destino, Fondo.Canvas, Origen );

  // Dibujamos el sprite en el buffer encima del fondo copiado
  Sprite.Dibujar( 0, 0, Buffer.Canvas );

  // Dibujamos el contenido del buffer a la pantalla
  Canvas.Draw( Sprite.x, Sprite.y, Buffer.Picture.Graphic );
end;

Prácticamente es el mismo visto en el artículo anterior. Ya sólo hace falta poner el marcha el mecanismo que bien podría ser en el evento OnCreate del formulario:

begin
  TmpTeclado.Enabled := True;
  Sprite.x := 250;
  Sprite.y := 150;
end;

CAPTURANDO LOS EVENTOS DEL RATON

Para capturar las coordenadas del ratón vamos a utilizar el evento OnMouseMove del formulario:

procedure TFormulario.FormMouseMove( Sender: TObject; Shift: TShiftState; X, Y: Integer );
begin
  Sprite.x := X;
  Sprite.y := Y;
end;

Para controlar los eventos del ratón voy a utilizar un temporizador distinto al del teclado llamado TmpRaton con un intervalo de 10 milisegundos. Su evento OnTimer sería sencillo:

procedure TFormulario.TmpRatonTimer( Sender: TObject );
begin
  DibujarSprite;
end;

Aquí nos surge un problema importante: como los movimientos del ratón son más bruscos que los del teclado volvemos a tener el problema de que el sprite nos va dejando manchas en pantalla. Para solucionar el problema tenemos que restaurar el fondo de la posición anterior del sprite antes de dibujarlo en la nueva posición..

Para ello voy a guardar en la clase TSprite las coordenadas anteriores:

type
  TSprite = class
  public
    x, y, xAnterior, yAnterior: Integer;
    ColorTransparente: TColor;
    Imagen, Mascara: TImage;
    constructor Create;
    destructor Destroy; override;
    procedure Cargar( sImagen: string );
    procedure Dibujar( x, y: Integer; Canvas: TCanvas );
  end;

Al procedimiento DibujarSprite le vamos a añadir que restaure el fondo del sprite de la posición anterior:

procedure TFormulario.DibujarSprite;
var
  Origen, Destino: TRect;
begin
  // Restauramos el fondo de la posición anterior del sprite
  if ( Sprite.xAnterior <> Sprite.x ) or ( Sprite.yAnterior <> Sprite.y ) then
  begin
    Origen.Left := Sprite.xAnterior;
    Origen.Top := Sprite.yAnterior;
    Origen.Right := Sprite.xAnterior + Sprite.Imagen.Width;
    Origen.Bottom := Sprite.yAnterior + Sprite.Imagen.Height;
    Destino := Origen;
    Canvas.CopyMode := cmSrcCopy;
    Canvas.CopyRect( Destino, Fondo.Canvas, Origen );
  end;

  // Copiamos el fondo de pantalla al buffer
  Origen.Left := Sprite.x;
  Origen.Top := Sprite.y;
  Origen.Right := Sprite.x + Sprite.Imagen.Width;
  Origen.Bottom := Sprite.y + Sprite.Imagen.Height;
  Destino.Left := 0;
  Destino.Top := 0;
  Destino.Right := Sprite.Imagen.Width;
  Destino.Bottom := Sprite.Imagen.Height;
  Buffer.Canvas.CopyMode := cmSrcCopy;
  Buffer.Canvas.CopyRect( Destino, Fondo.Canvas, Origen );

  // Dibujamos el sprite en el buffer encima del fondo copiado
  Sprite.Dibujar( 0, 0, Buffer.Canvas );

  // Dibujamos el contenido del buffer a la pantalla
  Canvas.Draw( Sprite.x, Sprite.y, Buffer.Picture.Graphic );

  Sprite.xAnterior := Sprite.x;
  Sprite.yAnterior := Sprite.y;
end;

Y finalmente activamos el temporizador que controla el ratón y ocultamos el cursor del ratón para que no se superponga encima de nuestro sprite:

begin
  TmpRaton.Enabled := True;
  Sprite.x := 250;
  Sprite.y := 150;
  ShowCursor( False );
end;

Al ejecutar el programa podeis ver como se mueve el sprite como si fuera el cursor del ratón.

Aunque se pueden hacer cosas bonitas utilizando el Canvas no os hagais muchas ilusiones ya que si por algo destaca la librería GDI de Windows (el Canvas) es por su lentitud y por la diferencia de velocidad entre ordenadores.

Para hacer cosas serías habría que irse a la librerías SDL (mi favorita), OpenGL o DirectX ( aunque hay decenas de motores gráficos 2D y 3D para Delphi en Internet que simplifican el trabajo).

Pruebas realizadas en Delphi 7.

Mover sprites con doble buffer

En el artículo anterior creamos la clase TSprite encargada de dibujar figuras en pantalla. Hoy vamos a reutilizarla para mover sprites, pero antes vamos a hacer una pequeña modificación:

type
  TSprite = class
  public
    x, y: Integer;
    ColorTransparente: TColor;
    Imagen, Mascara: TImage;
    constructor Create;
    destructor Destroy; override;
    procedure Cargar( sImagen: string );
    procedure Dibujar( x, y: Integer; Canvas: TCanvas );
  end;

Sólo hemos modificado el evento Dibujar añadiendo las coordenadas de donde se va a dibujar (independientemente de las que tenga el sprite). La implementación de toda la clase TSprite quedaría de esta manera:

{ TSprite }

constructor TSprite.Create;
begin
  inherited;
  Imagen := TImage.Create( nil );
  Imagen.AutoSize := True;
  Mascara := TImage.Create( nil );
  ColorTransparente := RGB( 255, 0, 255 );
end;

destructor TSprite.Destroy;
begin
  Mascara.Free;
  Imagen.Free;
  inherited;
end;

procedure TSprite.Cargar( sImagen: string );
var
  i, j: Integer;
begin
  Imagen.Picture.LoadFromFile( sImagen );
  Mascara.Width := Imagen.Width;
  Mascara.Height := Imagen.Height;

  for j := 0 to Imagen.Height - 1 do
    for i := 0 to Imagen.Width - 1 do
      if Imagen.Canvas.Pixels[i, j] = ColorTransparente then
      begin
        Imagen.Canvas.Pixels[i, j] := 0;
        Mascara.Canvas.Pixels[i, j] := RGB( 255, 255, 255 );
      end
      else
        Mascara.Canvas.Pixels[i, j] := RGB( 0, 0, 0 );
end;

procedure TSprite.Dibujar( x, y: Integer; Canvas: TCanvas );
begin
  Canvas.CopyMode := cmSrcAnd;
  Canvas.Draw( x, y, Mascara.Picture.Graphic );
  Canvas.CopyMode := cmSrcPaint;
  Canvas.Draw( x, y, Imagen.Picture.Graphic );
end;

CREANDO EL DOBLE BUFFER

Cuando se mueven figuras gráficas en un formulario aparte de producirse parpadeos en el sprite se van dejando rastros de las posiciones anteriores. Sucede algo como esto:


Para evitarlo hay muchísimas técnicas tales como el doble o triple buffer. Aquí vamos a ver como realizar un doble buffer para mover sprites. El formulario va a tener el siguiente fondo:


El fondo tiene unas dimensiones de 500x300 pixels. Para ajustar el fondo al formulario configuramos las siguientes propiedades en el inspector de objetos:

Formulario.ClientWidth = 500
Formulario.ClientHeight = 300

Se llama doble buffer porque vamos a crear dos imágenes:

Fondo, Buffer: TImage;

El Fondo guarda la imagen de fondo mostrada anteriormente y el Buffer va a encargarse de mezclar el sprite con el fondo antes de llevarlo a la pantalla.

Los pasos para dibujar el sprite serían los siguientes:


1º Se copia un trozo del fondo al buffer.

2º Se copia el sprite sin fondo encima del buffer.

3º Se lleva el contenido del buffer a pantalla.

Lo primero que vamos a hacer es declarar en la sección private del formulario los objetos:

  private
    { Private declarations }
    Sprite: TSprite;
    Buffer, Fondo: TImage;

Después los creamos en el evento OnCreate del formulario:

procedure TFormulario.FormCreate( Sender: TObject );
begin
  Sprite := TSprite.Create;
  Sprite.Cargar( ExtractFilePath( Application.ExeName ) + 'sprite.bmp' );
  Buffer := TImage.Create( nil );
  Buffer.Width := Sprite.Imagen.Width;
  Buffer.Height := Sprite.Imagen.Height;
  Fondo := TImage.Create( nil );
  Fondo.Picture.LoadFromFile( ExtractFilePath( Application.ExeName ) + 'fondo.bmp' );
end;

El fondo también lo he creado como imagen BMP en vez de JPG para poder utilizar la función CopyRect del Canvas. Nos aseguramos de que en el evento OnDestroy del formulario se liberen de memoria:

procedure TFormulario.FormDestroy( Sender: TObject );
begin
  Sprite.Free;
  Buffer.Free;
  Fondo.Free;
end;

Aunque podemos mover el sprite utilizando un bucle for esto podría dejar nuestro programa algo pillado. Lo mejor es moverlo utilizando un objeto de la clase TTimer. Lo introducimos en nuestro formulario con el nombre Temporizador. Por defecto hay que dejarlo desactivado (Enabled = False) y vamos a hacer que se mueva el sprite cada 10 milisegundos (Invertal = 10).

En el evento OnTimer hacemos que se mueva el sprite utilizando los pasos mencionados:

procedure TFSprites.TemporizadorTimer( Sender: TObject );
var
  Origen, Destino: TRect;
begin
  if Sprite.x < 400 then
  begin
    Inc( Sprite.x );

    // Copiamos el fondo de pantalla al buffer
    Origen.Left := Sprite.x;
    Origen.Top := Sprite.y;
    Origen.Right := Sprite.x + Sprite.Imagen.Width;
    Origen.Bottom := Sprite.y + Sprite.Imagen.Height;
    Destino.Left := 0;
    Destino.Top := 0;
    Destino.Right := Sprite.Imagen.Width;
    Destino.Bottom := Sprite.Imagen.Height;
    Buffer.Canvas.CopyMode := cmSrcCopy;
    Buffer.Canvas.CopyRect( Destino, Fondo.Canvas, Origen );

    // Dibujamos el sprite en el buffer encima del fondo copiado
    Sprite.Dibujar( 0, 0, Buffer.Canvas );

    // Dibujamos el contenido del buffer a la pantalla
    Canvas.Draw( Sprite.x, Sprite.y, Buffer.Picture.Graphic );
  end
  else
    Temporizador.Enabled := False;
end;

En el evento OnPaint del formulario tenemos que hacer que se dibuje el fondo:

procedure TFormulario.FormPaint( Sender: TObject );
begin
  Canvas.Draw( 0, 0, Fondo.Picture.Graphic );
end;

Esto es necesario por si el usuario minimiza y vuelve a mostrar la aplicación, ya que sólo se refresca la zona por donde está moviéndose el sprite.

Por fin hemos conseguido el efecto deseado:

Pruebas realizadas en Delphi 7.

Como dibujar sprites transparentes

Un Sprite es una figura gráfica móvil utilizada en los videojuegos de dos dimensiones. Por ejemplo, un videojuego de naves espaciales consta de los sprites de la nave, los meteoritos, los enemigos, etc., es decir, todo lo que sea móvil en pantalla y que no tenga que ver con los paisajes de fondo.

Anteriormente vimos como copiar imágenes de una superficie a otra utilizando los métodos Draw o CopyRect que se encuentran en la clase TCanvas. También se vió como modificar el modo de copiar mediante la propiedad CopyMode la cual permitia los valores cmSrcCopy, smMergePaint, etc.

El problema radica en que por mucho que nos empeñemos en dibujar una imagen transparente ningún tipo de copia funciona: o la hace muy transparente o se estropea el fondo.

DIBUJAR SPRITES MEDIANTE MASCARAS

Para dibujar sprites transparentes hay que tener dos imágenes: la original cuyo color de fondo le debemos dar alguno como común (como el negro) y la imagen de la máscara que es igual que la original pero como si fuera un negativo.

Supongamos que quiero dibujar este sprite (archivo BMP):


Es conveniente utilizar de color transparente un color de uso como común. En este caso he elegido el color rosa cuyos componentes RGB son (255,0,255). La máscara de esta imagen sería la siguiente:


Esta máscara no es necesario crearla en ningún programa de dibujo ya que la vamos a crear nosotros internamente. Vamos a encapsular la creación del sprite en la siguiente clase:

type
  TSprite = class
  public
    x, y: Integer;
    ColorTransparente: TColor;
    Imagen, Mascara: TImage;
    constructor Create;
    destructor Destroy; override;
    procedure Cargar( sImagen: string );
    procedure Dibujar( Canvas: TCanvas );
  end;

Esta clase consta de las coordenadas del sprite, el color que definimos como transparente y las imágenes a dibujar incluyendo su máscara. En el constructor de la clase creo dos objetos de la clase TImage en memoria:

constructor TSprite.Create;
begin
  inherited;
  Imagen := TImage.Create( nil );
  Imagen.AutoSize := True;
  Mascara := TImage.Create( nil );
  ColorTransparente := RGB( 255, 0, 255 );
end;

También he definido el color rosa como color transparente. Como puede apreciarse he utilizado el procedimiento RGB que convierte los tres componentes del color al formato de TColor que los guarda al revés BGR. Así podemos darle a Delphi cualquier color utilizando estos tres componentes copiados de cualquier programa de dibujo.

En el destructor de la clase nos aseguramos de que se liberen de memoria ambos objetos:

destructor TSprite.Destroy;
begin
  Mascara.Free;
  Imagen.Free;
  inherited;
end;

Ahora implementamos la función que carga de un archivo la imagen BMP y a continuación crea su máscara:

procedure TSprite.Cargar( sImagen: string );
var
  i, j: Integer;
begin
  Imagen.Picture.LoadFromFile( sImagen );
  Mascara.Width := Imagen.Width;
  Mascara.Height := Imagen.Height;

  for j := 0 to Imagen.Height - 1 do
    for i := 0 to Imagen.Width - 1 do
      if Imagen.Canvas.Pixels[i,j] = ColorTransparente then
      begin
        Imagen.Canvas.Pixels[i,j] := 0;
        Mascara.Canvas.Pixels[i,j] := RGB( 255, 255, 255 );
      end
      else
        Mascara.Canvas.Pixels[i,j] := RGB( 0, 0, 0 );
end;

Aquí nos encargamos de dejar la máscara en negativo a partir de la imagen original.

Para dibujar sprites recomiendo utilizar archivos BMP en lugar de JPG debido a que este último tipo de imágenes pierden calidad y podrían afectar al resultado de la máscara, dando la sensación de que el sprite tiene manchas. Hay otras librerías para Delphi que permiten cargar imágenes PNG que son ideales para la creación de videojuegos, pero esto lo veremos en otra ocasión.

Una vez que ya tenemos nuestro sprite y nuestra máscara asociada al mismo podemos crear el procedimiento encargado de dibujarlo:

procedure TSprite.Dibujar( Canvas: TCanvas );
begin
  Canvas.CopyMode := cmSrcAnd;
  Canvas.Draw( x, y, Mascara.Picture.Graphic )
  Canvas.CopyMode := cmSrcPaint;
  Canvas.Draw( x, y, Imagen.Picture.Graphic );}
end;

El único parámetro que tiene es el Canvas sobre el que se va a dibujar el sprite. Primero utilizamos la máscara para limpiar el terreno y después dibujamos el sprite sin el fondo. Vamos a ver como utilizar nuestra clase para dibujar un sprite en el formulario:

procedure TFormulario.DibujarCoche;
var
  Sprite: TSprite;
begin
  Sprite := TSprite.Create;
  Sprite.x := 100;
  Sprite.y := 100;
  Sprite.Cargar( ExtractFilePath( Application.ExeName ) + 'sprite.bmp' );
  Sprite.Dibujar( Canvas );
  Sprite.Free;
end;

Este sería el resultado en el formulario:


Si el sprite lo vamos a dibujar muchas veces no es necesario crearlo y destruirlo cada vez. Deberíamos crearlo en el evento OnCreate del formulario y en su evento OnDestroy liberarlo (Sprite.Free).

En el próximo artículo veremos como mover el sprite en pantalla utilizando una técnica de doble buffer para evitar parpadeos en el movimiento.

Pruebas realizadas en Delphi 7.

Dibujando con la clase TCanvas (y III)

Vamos a terminar de ver lo más importante de las operaciones que se pueden realizar con el objeto Canvas.

DIBUJAR UN RECTANGULO SIN FONDO

El procedimiento FrameRect permite crear rectángulos sin fondo teniendo en cuenta el valor de la propiedad Brush:

procedure FrameRect( const Rect: TRect );

Veamos un ejemplo:

with Canvas do
begin
  R.Left := 300;
  R.Top := 250;
  R.Right := 350;
  R.Bottom := 300;
  Brush.Color := clGreen;
  FrameRect( R );
end;

Este sería el dibujo resultante:


COMO COPIAR IMAGENES DE UN BITMAP A OTRO

La manera más utilizada de copiar imágenes es mediante el método Draw:

procedure Draw( X, Y: Integer; Graphic: TGraphic );

Vamos a ver un ejemplo de como copiar la imagen de un objeto de la clase TImage a nuestro formulario utilizando el procedimiento Draw:

var
R: TRect;
begin
  with Canvas do
  begin
    R.Left := 300;
    R.Top := 250;
    R.Right := 350;
    R.Bottom := 300;
    Brush.Color := clGreen;
    FrameRect( R );
    Draw( 100, 100, Imagen.Picture.Graphic );
  end;
end;

Hemos supuesto que el objeto de la clase TImage se llama Imagen. Este sería el resultado:


La imagen copiada consta de cuatro iconos y un fondo de color blanco. Otra cosa que podemos hacer es modificar el tamaño de la imagen a copiar utilizando el procedimiento:

procedure StretchDraw( const Rect: TRect; Graphic: TGraphic );

El parámetro Rect determina las nuevas coordenadas así como en ancho y alto de la imagen a copiar. En el siguiente ejemplo voy a copiar la misma imagen pero voy a reducirla un tamaño de 100x100:

var
  R: TRect;
begin
  with Canvas do
  begin
    R.Left := 100;
    R.Top := 100;
    R.Right := 200;
    R.Bottom := 200;
    StretchDraw( R, Imagen.Picture.Graphic );
  end;
end;

Quedaría de la siguiente manera:


También se pueden copiar imágenes utilizando el procedimiento:

procedure CopyRect( const Dest: TRect; Canvas: TCanvas; const Source: TRect );

cuyos parámetros son:

Dest: Coordenadas del rectángulo destino.
Canvas: Referencia al Canvas del origen a copiar.
Source: Coordenadas del rectángulo origen.

Para el ejemplo anterior voy a copiar la imagen en su tamaño original al formulario:

var
  Origen, Destino: TRect;
begin
  with Canvas do
  begin
    Origen.Left := 0;
    Origen.Top := 0;
    Origen.Right := Imagen.Picture.Width;
    Origen.Bottom := Imagen.Picture.Height;
    Destino.Left := 100;
    Destino.Top := 100;
    Destino.Right := 100 + Imagen.Width;
    Destino.Bottom := 100 + Imagen.Height;
    CopyRect( Destino, Imagen.Canvas, Origen );
  end;
end;

Entonces, ¿que diferencia hay entre Draw o StretchDraw y CopyRect? La diferencia es que CopyRect sólo puede utilizarse cuando el objeto TImage ha cargado un bitmap (*.BMP) porque si es un JPG provoca una excepción. En cambio las funciones Draw o StretchDraw siempre funcionan independientemente del tipo de imagen que sea.

LOS MODOS DE COPIA DE UNA IMAGEN

En principio cuando se realiza la copia de una imagen a otra, la copia de los pixels es exacta. Pero si queremos modificar el modo de copiar entonces la clase TCanvas tiene de la propiedad CopyMode que establece que tipo de operación que se va a realizar. Estos son sus posibles valores:

cmBlackness: pinta la imagen destino de color negro, independientemente del origen.

cmDstInvert: Invierte los colores de la imagen según la imagen destino.

cmMergeCopy: mezcla la imagen origen y destino utilizando el operador binario AND.

cmMergePaint: mezcla la imagen origen y destino utilizando el operador binario OR.

cmNotSrcCopy: copia la imagen origen invertida a la imagen destino.

cmNotSrcErase: mezcla las imagenes origen y destino y después las invierte con el operador binario OR.

cmPatCopy: copia la imagen según el valor de la propiedad Brush.Style del Canvas.

cmPatInvert: copia la imagen invertida según el valor de la propiedad Brush.Style del Canvas.

cmPatPaint: combina las imágenes origen y destino utilizando la operación binaria OR para luego invertirlas.

cmSrcAnd: combina la imagen origen con la imagen destino utilizando el operador binario AND.

cmSrcCopy: realiza una copia exacta de la imagen origen a la imagen destino (por defecto).

cmSrcErase: invierte la imagen destino y copia el origen utilizando el operador binario AND.

cmSrcInvert: invierte las imágenes origen y destino utilizando el operador binario XOR.

cmSrcPaint: combina las imágenes destino y origen utilizando el operador binario AND.

cmWhiteness: pinta toda la imagen destino de color blanco ignorando la imagen origen.

Por ejemplo voy a crear un efecto fantasma con la imagen origen:

with Canvas do
begin
  CopyMode := cmMergePaint;
  Draw( 100, 100, Imagen.Picture.Graphic );
end;

El efecto sería el siguiente:


COMO ACCEDER A LOS PIXELS DE LA IMAGEN

Si no son suficientes las operaciones que podemos realizar en una imagen también podemos acceder directamente a los pixels de una imagen a traves de su propiedad Pixels:

property Pixels[ X, Y: Integer ]: TColor;

Esta propiedad nos sirve igualmente para leer y para escribir pixels en la imagen. El componente TColor es un tipo entero de 32 bits definido en la unidad Graphics del siguiente modo:

type
 TColor = -$7FFFFFFF-1..$7FFFFFFF;

Dentro del mismo número entero están definidos los colores básicos RGB los
cuales son:

R = Red (Rojo)
G = Green (Verde)
B = Blue (Azul)

Combinando estos tres colores se puede crear cualquier otro color. Estos colores estan dentro del valor TColor del siguiento modo:

$00GGBBRR

Donde GG es el byte en hexadecimal que representa el color verde, BB es el color azul y RR es el color rojo. Aquí tenemos unos ejemplos de los números en hexadecimal:

Rojo   := $000000FF;
Azul   := $0000FF00;
Verde  := $00FF0000;
Blanco := $00FFFFFF;
Negro  := $00000000;

Para no complicarnos mucho la vida Delphi ya dispone de colores predeterminados tales como clRed (Rojo), clBlue (Azul), etc. Sabiendo esto imaginaos que deseo hacer un programa que convierta todos los colores blancos de la imagen en amarillo:

var
  i, j: Integer;
begin
  with Canvas do
  for j := 0 to ClientHeight - 1 do
    for i := 0 to ClientWidth - 1 do
      if Pixels[i,j] = clWhite then
        Pixels[i,j] := clYellow;
end;

Mediante un doble bucle recorro toda la imagen y compruebo si el pixel donde estoy es blanco para sustituirlo por el amarillo. Este sería el resultado:


Con este método se podemos realizar nuestros propios filtros o crear cualquier tipo de efecto.

Con esto finalizamos el apartado dedicado al objeto Canvas.

Pruebas realizadas en Delphi 7.