Generando un informe de Microsoft Word

Aunque hay muchos generadores de informes para Delphi como pueden ser QuickReport, Rave Reports, Report Manager, etc., no hay procesador de textos más completo que Microsoft Word.

Es este artículo vamos a ver como generar un nuevo documento de Word y poder introducir textos, tablas, figuras, notas al pie, etc. Esto lo vamos a conseguir utilizando el componente TWordApplication que encuentra en el apartado Servers dentro de la paleta de componentes.

Aunque no he conseguido averiguar la inmensidad de funciones que incorpora este objeto sí que podemos generar un informe más o menos decente.

EL COMPONENTE TWORDAPPLICATION

Insertamos el componente en nuestro formulario y lo llamamos Word para abreviar:


Este es el documento que vamos a generar:


Creamos un par de variables del tipo OleVariant para poder enviar parámetros a funciones:

var
  Documento, Texto: OleVariant;

Conectamos con Microsoft Word y le decimos que cree un nuevo documento que va a llamarse Informe.doc y que va a guardarse en el mismo directorio donde nos encontramos:

// Conectamos con Word y creamos un nuevo documento
Documento := ExtractFilePath( Application.ExeName ) + 'Informe.doc';
Word.Connect;
Word.Documents.Add(EmptyParam,EmptyParam,EmptyParam,EmptyParam);

Entramos al encabezado del documento y escribimos el título centrado:

with Word do
begin
  with Selection do
  begin
    // Insertamos un título en el encabezado del documento
    with Sections.Item(1).Headers.Item(1).Range do
    begin
      Font.Name := 'Courier New';
      Font.Bold := 1;
      Text := 'TITULO DEL DOCUMENTO';
      Paragraphs.Item(1).Alignment := 1; // centramos párrafo
    end;

La propiedad Selection contempla el punto donde se encuentra el cursor al principio de la página.

Dentro del documento escribimos tres frases de un color distinto:

    // Establecemos la fuente Tahoma, negrita, azul y tamaño 10
    Font.Name := 'Tahoma';
    Font.Size := 10;
    Font.Color := clNavy;
    Font.Bold := 1;
    TypeText( 'Frase 1' + #13 );
    Font.Color := clRed;
    TypeText( 'Frase 2' + #13 );
    Font.Color := clGreen;
    TypeText( 'Frase 3' + #13 + #13 + #13 );

También vamos a insertar una nota al pie de página y otra al final del documento:

    // Insertamos una nota al pie y una nota al final
    Texto := 'Nota al pie de página';
    FootNotes.Add( Range, EmptyParam, Texto );
    Texto := 'Nota al final';
    EndNotes.Add( Range, EmptyParam, Texto );

Además insertamos una tabla configurando todas las celdas:

    // Insertamos una tabla con fuente de color negro
    Font.Color := clBlack;
    with Tables.Add( Range, 3, 4, EmptyParam, EmptyParam ) do
    begin
      // Títulos de la tabla
      Cell(1,1).Range.Text := 'Unidades';
      Cell(1,2).Range.Text := 'Artículo';
      Cell(1,3).Range.Text := 'Precio';
      Cell(1,4).Range.Text := 'Total';
      Rows.Item(1).Shading.BackgroundPatternColor := clGreen; // fonfo verde
      Rows.Item(1).Range.Font.Color := clYellow; // fuente amarilla

      // Contenido
      Cell(2,1).Range.Text := '1';
      Cell(2,2).Range.Text := 'PORTATIL ACER';
      Cell(2,3).Range.Text := '540';
      Cell(2,4).Range.Text := '540';
      Cell(3,1).Range.Text := '2';
      Cell(3,2).Range.Text := 'RATON OPTICO';
      Cell(3,3).Range.Text := '2,50';
      Cell(3,4).Range.Text := '5';
      Columns.Item(4).Shading.BackgroundPatternColor := clBlue; // fondo azul
    end;
  end;
end;

Para crear una nueva tabla hemos llamado a:

Tables.Add( Range, 3, 4, EmptyParam, EmptyParam )

El segundo parámetro determina el número de filas y el tercero el número de columnas.

Aparte de añadir el contenido a cada celda hemos establecido para toda la primera fila el fondo de color verde y la fuente de color amarillo:

      Rows.Item(1).Shading.BackgroundPatternColor := clGreen; // fonfo verde
      Rows.Item(1).Range.Font.Color := clYellow; // fuente amarilla

Igualmente le hemos dicho a la cuarta columna que el color de fondo es azul:

Columns.Item(4).Shading.BackgroundPatternColor := clBlue; // fondo azul

Aun así, si queremos ser más específicos podemos hacerlo para cada celda (Cells).

Por último he añadido una línea recta cuyas coordenadas van por pixels:

Word.ActiveDocument.Shapes.AddLine( 200, 200, 250, 250, EmptyParam );

Una vez hemos finalizado el documento lo guardamos y desconectamos de Word:

Word.ActiveDocument.SaveAs( Documento,
  EmptyParam, EmptyParam, EmptyParam, EmptyParam, EmptyParam, EmptyParam,
  EmptyParam, EmptyParam, EmptyParam, EmptyParam, EmptyParam, EmptyParam,
  EmptyParam, EmptyParam, EmptyParam );
Word.Quit;
Word.Disconnect;

Aunque me hubiera gustado poder añadir muchos más elementos a este informe, debido a la pésima documentación de Delphi 2007 y que en la web tampoco abundan muchos ejemplos (lo único decente que he visto es de unas páginas rusas y japonesas). Si averiguo más cosas lo ampliaré en un futuro.

Pruebas realizadas en RAD Studio 2007.

Creando una hoja de cálculo desde Delphi

Al igual que en el artículo anterior vimos como leer datos de una hoja de cálculo de Microsoft Excel hoy vamos a ver como crearla, rellenarla con datos y fórmulas para luego guardarla en disco.

Para ello utilizaremos el mismo componente: TExcelApplication. Le pondremos igualmente en su propiedad Name el nombre Excel. Mi objetivo es crear esta hoja de cálculo:


Esta hoja contiene 4 columnas con las unidades, el nombre del artículo, el precio y total línea. La columna del total debe contener una fórmula que multiplique las unidades por el precio.

Vamos a ver paso a paso como crear esta hoja de cálculo:

1º Declaramos la variable Hoja de tipo _WorkSheet para que apunte a la hoja de cálculo con la que estamos trabajando:

var
  Hoja: _WorkSheet;

2º Ejecutamos una instancia de Excel y creamos un nuevo libro (Workbook):

// Abrimos excel
Excel.Connect;

// Creamos un nuevo libro con tres hojas (predeterminado)
Excel.Workbooks.Add( NULL, 0 );

3º A la primera hoja del libro la llamamos Presupuesto:

// Apuntamos a la primera hoja y le cambiamos el nombre
Hoja := Excel.Worksheets.Item[1] as _WorkSheet;
Hoja.Name := 'Presupuesto';

4º Creamos los títulos de las columnas:

// Títulos de los datos
Hoja.Range['A1','A1'].Value2 := 'UNIDADES';
Hoja.Range['B1','B1'].Value2 := 'ARTICULO';
Hoja.Range['B1','B1'].ColumnWidth := 30;
Hoja.Range['C1','C1'].Value2 := 'PRECIO';
Hoja.Range['D1','D1'].Value2 := 'TOTAL';
Hoja.Range['A1','D1'].Font.Bold := True;

Aparte de introducir los títulos he utilizado las propiedades ColumnWidth y Font.Bold para ensanchar la columna del artículo y para poner todos los títulos en negrita.

5º Introducimos los datos dentro de las columnas:

// Datos
Hoja.Range['A2','A2'].Value2 := 3;
Hoja.Range['B2','B2'].Value2 := 'BOLIGRAFOS';
Hoja.Range['C2','C2'].Value2 := 1.25;
Hoja.Range['A3','A3'].Value2 := 2;
Hoja.Range['B3','B3'].Value2 := 'LIBRETAS';
Hoja.Range['C3','C3'].Value2 := 2.4;
Hoja.Range['A4','A4'].Value2 := 5;
Hoja.Range['B4','B4'].Value2 := 'LAPICES';
Hoja.Range['C4','C4'].Value2 := 0.45;

Al ser la propiedad Value2 de tipo Variant podemos introducir datos de todo tipo sin necesidad de realizar conversiones.

6º En la última columna vamos a introducir una fórmula para multiplicar unidades por precio:

// Fórmulas
Hoja.Range['D2','D2'].Formula := '=A2*C2';
Hoja.Range['D3','D3'].Formula := '=A3*C3';
Hoja.Range['D4','D4'].Formula := '=A4*C4';

7º Damos formato decimal a las columnas del precio y los totales y para ésta última columna le cambiamos los colores:

 // Formato decimal
 Hoja.Range['C2','D4'].NumberFormat := '0,00';

 // Damos formato a los totales
 Hoja.Range['D2','D4'].Font.Bold := True;          // fuente negrita
 Hoja.Range['D2','D4'].Font.Color := clBlue;       // fuente azul
 Hoja.Range['D2','D4'].Borders.Color := clRed;     // borde rojo
 Hoja.Range['D2','D4'].Interior.Color := clYellow; // fondo amarrillo

8º Por último guardamos la hoja de cálculo y desconectamos de Excel:

 // Lo primero que hacemos es guardarlo
 Excel.ActiveWorkbook.SaveAs( ExtractFilePath( Application.ExeName ) + 'Nueva.xls',
   EmptyParam, EmptyParam, EmptyParam,
   EmptyParam, EmptyParam, xlNoChange,
   EmptyParam, EmptyParam, EmptyParam,
   EmptyParam, EmptyParam, 0);

 Excel.Quit;
 Excel.Disconnect;

La hoja de cálculo la hemos guardado con el nombre Nueva.xls dentro de mismo directorio donde se ejecuta nuestra aplicación.

Y es que no hay nada mejor que sacarle partido a Microsoft Office para que nos haga el trabajo sucio.

Pruebas realizadas en RAD Studio 2007.

Leyendo datos de hojas de cálculo de Microsoft Excel

Si hay algo que nos piden frecuentemente a los programadores de gestión es poder recoger o enviar datos a los programas ofimáticos más populares: Microsoft Word, Microsoft Excel y Microsoft Access.

Lo más común suele ser leer datos de una hoja de cálculo y guardarlos en nuestra base de datos, aunque también tenemos la posibilidad de enviarle la información para que Excel nos haga una gráfica espectacular.

Una hoja de cálculo es realmente un libro que puede contener una o más hojas de cálculo:


A su vez, Microsoft Excel puede abrir varios libros a la vez.

EL COMPONENTE TEXCELAPPLICATION

En la paleta de componentes tenemos el componente de la clase TExcelApplication que se encuentra en la sección Servers:


Lo insertamos en el formulario donde vamos a hacer la importación y lo llamamos Excel para simplificar:


Supongamos que queremos leer esta hoja de cálculo:


Primero abrimos la hora de cálculo:

Excel.Workbooks.Open( ExtractFilePath( Application.ExeName ) + 'Hoja.xls',
  EmptyParam, EmptyParam, EmptyParam, EmptyParam, EmptyParam,
  EmptyParam, EmptyParam, EmptyParam, EmptyParam, EmptyParam,
  EmptyParam, EmptyParam, EmptyParam, EmptyParam, 0 );

Hay que reconocer que la cantidad de parámetros que tiene el método Open es impresionante:


Aunque no hay que asustarse porque lo que necesitamos realmente es el primer parámetro (el nombre del archivo excel a abrir). Los demás son para elegir si queremos abrirlo en modo sólo lectura, introducir una contraseña, etc.

Una vez que hemos abierto la hora de cálculo tenemos que situarnos en la Hoja1. Para ello creamos las siguientes variables:

var
  i: Integer;
  si: String;
  Hoja: _WorkSheet;

Las variables i y si son para recorrer las celdas de la hoja de cálculo y la variable Hoja va a apuntar a una hoja en concreto. En nuestro caso la primera:

Hoja := Excel.Worksheets.Item[1] as _WorkSheet;

Para leer información de las celdas de la hoja de cálculo tenemos que conocer las coordenadas horizontales (A,B,C,…) y las verticales (1,2,3,…). Cuando lea la información la voy a volcar a un componente ListView configurado con estas columnas:


Ahora sólo queda ir recorriendo cada fila hasta que encontremos una fila vacía:

i := 2;
si := IntToStr( i );
repeat
  with ListView.Items.Add do
  begin
    SubItems.Add( Hoja.Range['A'+si,'A'+si].Value2 ); // Código
    SubItems.Add( Hoja.Range['B'+si,'B'+si].Value2 ); // Nombre
    SubItems.Add( Hoja.Range['C'+si,'C'+si].Value2 ); // CIF
    SubItems.Add( Hoja.Range['D'+si,'D'+si].Value2 ); // Saldo
  end;

  Inc( i );
  si := IntToStr( i );
until ( VarType( Excel.Range['A'+si,'A'+si].Value2 ) = VarEmpty );

La propiedad Value2 de cada celda devuelve un tipo Variant, por ello utilizo la función VarType para comprobar si lo que hay en la celda esta vacío (VarEmpty). De ese modo sabemos cuando hemos terminado de leer datos.

Por último cerramos la hoja de cálculo con:

Excel.Workbooks.Close( 0 );

Con esto ya hemos conseguido traernos la información de la hoja de cálculo:


Igualmente podemos escribir datos en cualquier celda de la hoja de cálculo con total naturalidad:

Hoja.Range['B2','B2'].Value2 := ‘TRANSPORTES GARCIA, S.L.’;

De esta manera podemos crear nuestras plantillas de hojas de cálculo con gráficas incluidas y desde Delphi le enviamos la información.

Pruebas realizadas en RAD Studio 2007.