Como utilizar TExcelApplication

[Jose Roman]

Hola a todos.

Mi pregunta es la siguiente, tengo delphi 7 y me gustaria saber como utilizar el componente TExcelApplication de la paleta Servers, mas exactamente deseo trabajar con excel a traves de un programa realizado en Delphi:
- Crear un archivo de excel
- Insertar datos en celdas
- Borrar Hojas o celdas
- Editar celdas

Clara que si hay alguna manera mas facil de trabajar por favor expliquenme, he tratado con ADO pero no deja borrar celdas

[Neftali [Germán.Estévez]]

Busca información sobre Automatización en Excel; Hay mucha información; Aquí en los foros y fuera de ellos.
Empieza por este y este.

[Jose Roman]

Gracias, ensayare a ver como me va...

[Flecha]

Hola.

Por si acaso no encontraras lo que buscas, aquí te dejo el código fuente de una clase que me curré en su día para implementarla en Delphi 3 (aún no existía la paleta Servers ni nada de su contenido).

Básicamente consiste en crearte un objeto OLE por medio de esta línea de código:

Código Delphi [-]
Obj_Excel := CreateOleObject('Excel.Application');

o intentar capturar alguna ejecución de Excel que ya esté activa en el PC con esto otro:

Código Delphi [-]
 

Obj_Excel := GetActiveOleObject('Excel.Application');

Después, todo el trabajo es idéntico a crearte macros en Visual Basic de Excel.

Resulta luego curioso ver dentro del código Delphi líneas de código que son en realidad macros de VB.



A continuación el código. Lo preparé para mi apaño personal, y con las cositas justas que fui necesitando. Así que tiene muchas carencias, pero espero que te valga.

Código Delphi [-]
 

unit uExportExcel;

interface

const

  //============================================================
  //              Constantes creadas por mí
  //============================================================

  //--------- Colores en Fondo de Celdas -------------------------------------
  xl_CL_AmarLight = $00000024; // (36) Amarillo Claro
  xl_CL_AzulCielo = $00000021; // (33) Azul Cielo
  xl_CL_Turq      = $00000008; // ( 8) Truquesa
  xl_CL_TurqLight = $00000022; // (34) Turquesa Claro
  xl_CL_Rojo      = $00000003; // ( 3) Rojo
  //--------- Formatos de Impresión para Cabecera y Pie de página ------------
//  xl_FI_Fich = '&F'; // Nombre del Archivo Excel
  xl_FI_Fich = '&N'; // Nombre del Archivo Excel
  xl_FI_Hoja = '&A'; // Nombre de la Hoja Excel
  xl_FI_Pag  = '&P'; // Nº de la Hoja impresa
  xl_FI_TPag = ''; // Nº Total de Hojas impresas
  xl_FI_RC   = #10 ; // Salto de línea

  //============================================================
  //              Constantes de Excel
  //============================================================

  //--------- Constantes reutiliables en varios conceptos --------------------
  //--------- (ver su uso dentro de cada sección) ----------------------------
  xlAutomatic     = $FFFFEFF7; // (-4105)
  //--------- Para crear "objetos" nuevos dentro de una aplicación Excel -----
  xlWBATWorksheet = $FFFFEFB9; // (-4167) Documento Excel
  //--------- Para el cálculo de fórmulas ------------------------------------
  (* xlAutomatic -> Cálculo Automático *)
  xlManual        = $FFFFEFD9; // (-4135) Cálculo Manual
  //--------- Bordes de las Celdas -------------------------------------------
  xlEdgeLeft         = $00000007; // ( 7) Izquierdo
  xlEdgeTop          = $00000008; // ( 8) Superior
  xlEdgeBottom       = $00000009; // ( 9) Inferior
  xlEdgeRight        = $0000000A; // (10) Derecho
  xlInsideVertical   = $0000000B; // (11) Vertical Interior
  xlInsideHorizontal = $0000000C; // (12) Horizontal Interior
  //--------- Tipo de línea en bordes de Celdas ------------------------------
  xlContinuous = $00000001; // ( 1) Continua
  xlNone       = $FFFFEFD2; // (-4142) Ningúna línea
  //--------- Grosores en bordes de Celdas -----------------------------------
  xlThin   = $00000002; // ( 2) Fino
  xlMedium = $00000003; // ( 3) Medio
  //--------- Colores en bordes de Celdas ------------------------------------
  (* xlAutomatic -> Color por Defecto (negro) *)
  //--------- Selección de Celdas --------------------------------------------
  xlLastCell = $0000000B; // (11) Como si en Excel se pulsa [Ctrl]+[Shift] y [Cursor]
  //--------- Alineación de texto en las celdas ------------------------------
  xlCenter = $FFFFEFF4; // (-4108) Centrado
  //--------- Tipos de Condiciones para Formato Condicional
  xlCellValue  = $00000001; // ( 1) Basado en el valor de la celda
  xlExpression = $00000002; // ( 2) Basado en el resultado de una fórmula
  //--------- Operadores para Condiciones de Formato Condicional
  xlBetween      = $00000001; // ( 1)    Entre dos valores
  xlNotBetween   = $00000002; // ( 2) No Entre dos valores
  xlEqual        = $00000003; // ( 3)    Igual a...
  xlNotEqual     = $00000004; // ( 4) No Igual a...
  xlGreater      = $00000005; // ( 5) Mayor que...
  xlLess         = $00000006; // ( 6) Menor que...
  xlGreaterEqual = $00000007; // ( 7) Mayor o igual a...
  xlLessEqual    = $00000008; // ( 8) Menor o igual a...
  //--------- Para el tamaño de la pantalla de Excel -------------------------
  xlNormal    = $FFFFEFD1; // (-4143) Pantalla Tamaño Normal
  xlMaximized = $FFFFEFD7; // (-4137) Maximizar Pantalla
  xlMinimized = $FFFFEFD4; // (-4140) Minimizar Pantalla
  //--------- Para seleccionar celdas ----------------------------------------
  xlToLeft  = $FFFFEFC1; // (-4159) [Ctrl]+[Shift] + [flecha izquierda]
  xlToRight = $FFFFEFBF; // (-4161) [Ctrl]+[Shift] + [flecha derecha]
  xlUp      = $FFFFEFBE; // (-4162) [Ctrl]+[Shift] + [flecha arriba]
  xlDown    = $FFFFEFE7; // (-4121) [Ctrl]+[Shift] + [flecha abajo]


type
  TAplExcel = class
  private
  protected
    Obj_Excel : Variant;
    Obj_WBook : Variant;
    Reutilizado : boolean;
    Back_Calculation : integer;

    function Get_Obj_Excel : variant;
    function Get_Obj_WBook : variant;
    procedure Set_Obj_WBook (objeto : variant);

    procedure CrearAplicacionExcel (Reutilizar:boolean);
    procedure DocumentoTerminado(WorkBook:variant);
    procedure InitVarExcel;
    procedure LiberarMemoria (QuitarTodos:boolean);
  public
    constructor Create; virtual;    // Crea una Aplicación Excel
    procedure Destroy; virtual;     // Borro el objeto

    property Excel:Variant read Get_Obj_Excel;
    property WBook:Variant read Get_Obj_WBook;

    function CrearNuevoWBook : variant;
    procedure QuitarWBook(WorkBook:variant);
    procedure QuitarWSheet (WorkSheet:variant);
    procedure GuardarDocumento(WorkBook:variant; PathAndName:string; MostrarAlertas:boolean);
    procedure CargarDocumento(PathAndName:string);
    procedure NoGuardarDocumento(WorkBook:variant);
    procedure MostrarAplExcel;
    procedure OcultarAplExcel;

    procedure ControlErrorExcel;

    procedure ColorFondo (Selection:Variant; Color:integer);
    procedure PonerGrid  (Selection:Variant; GrosorMarco, GrosorVerti, GrosorHoriz:integer);
    procedure PonerMarco (Selection:Variant; Grosor:integer);

    function LetraColumna (x:integer):string;
    procedure SetPrintArea (Hoja : variant; x1,y1, x2,y2 : integer);
    procedure SetSaltoPagVert (Hoja : variant; NumSalto, Columna : integer);
  end;

implementation

uses ComObj, SysUtils;

procedure TAplExcel.LiberarMemoria (QuitarTodos:boolean);
var x:integer;
begin
  if VarIsNull(Obj_Excel) Then Exit;
  try
    for x:=Obj_Excel.Workbooks.Count downto 1 do Begin
      if QuitarTodos or Obj_Excel.Workbooks[x].Saved
      Then Begin
        QuitarWBook(Obj_Excel.Workbooks[x]);
      End;
    End;
  Except
  End;
end;

function TAplExcel.CrearNuevoWBook : variant;
begin
  //--------------------------------------------------
  // Me creo el documento Excel de la siguiente manera
  // para que sólo contenga una única hoja.
  //--------------------------------------------------
  try
    Result := Obj_Excel.Workbooks.Add(xlWBATWorksheet);
  except
    Result := null;
    raise;
  end;

  //--------------------------------------------------------
  // Pongo cálculo manual para agilizar el proceso
  // IMPORTANTE: siempre después de crear el documento Excel
  //--------------------------------------------------------
  if Obj_Excel.Workbooks.Count = 1
  Then Back_Calculation  := Obj_Excel.Calculation;
  If Obj_Excel.Calculation <> xlManual
  Then Obj_Excel.Calculation := xlManual;
end;

procedure TAplExcel.QuitarWBook(WorkBook:variant);
begin
  {$B-}
  if  (not VarIsNull(Obj_WBook))
  and (Obj_WBook.FullName = WorkBook.FullName)
  Then Obj_WBook := Null;
  NoGuardarDocumento(WorkBook);
  WorkBook.Close;
end;

procedure TAplExcel.QuitarWSheet (WorkSheet:variant);
var Alertas:boolean;
begin
  alertas := WorkSheet.Application.DisplayAlerts;
  WorkSheet.Application.DisplayAlerts := False;
  WorkSheet.Delete;
  WorkSheet.Application.DisplayAlerts := Alertas;
end;

procedure TAplExcel.DocumentoTerminado(WorkBook:variant);
begin
  WorkBook.Worksheets[1].Select;
  WorkBook.Worksheets[1].Activate;
  WorkBook.Worksheets[1].Cells[1,1].Select;
end;

procedure TAplExcel.GuardarDocumento(WorkBook:variant; PathAndName:string; MostrarAlertas:boolean);
var Alertas:boolean;
begin
  DocumentoTerminado(WorkBook);
  WorkBook.Application.Calculation  := Back_Calculation;
  alertas := WorkBook.Application.DisplayAlerts;
  WorkBook.Application.DisplayAlerts := MostrarAlertas;
  WorkBook.SaveAs ( PathAndName );
  WorkBook.Application.DisplayAlerts := alertas;
//  WorkBook.Application.Calculation := xlManual;
end;

procedure TAplExcel.CargarDocumento(PathAndName:string);
begin
  Obj_Excel.Workbooks.Open(PathAndName);
  if VarIsNull(Obj_WBook) Then Obj_WBook := Obj_Excel.Workbooks[Obj_Excel.Workbooks.Count];
end;

procedure TAplExcel.NoGuardarDocumento(WorkBook:variant);
begin
  WorkBook.Saved := True;
end;

procedure TAplExcel.MostrarAplExcel;
var x:integer;
Begin
  for x:=1 to Obj_Excel.Workbooks.Count do DocumentoTerminado(Obj_Excel.Workbooks[x]);
  Obj_Excel.Calculation  := Back_Calculation;
  Obj_Excel.WindowState :=  xlMaximized;
  Obj_Excel.Visible := True;
End;

procedure TAplExcel.OcultarAplExcel;
begin
  Obj_Excel.Visible := False;
end;

procedure TAplExcel.CrearAplicacionExcel (Reutilizar:boolean);
var v_Excel : variant;
begin
  //---------------------------------------------
  // Inicializo variables con valores por defecto
  //---------------------------------------------
  InitVarExcel;

  try
    //-------------------------------------
    // Creo o Recupero una Aplicación Excel
    //-------------------------------------
    try
      if Reutilizar Then try
        Obj_Excel := GetActiveOleObject('Excel.Application'); // La intento recuperar
        Reutilizado := True;
      except
        Obj_Excel := null;
      End;
      if VarIsNull(Obj_Excel) Then Begin
        Obj_Excel := CreateOleObject('Excel.Application'); // La creo
        Reutilizado := False;
      End;
    except
      Obj_Excel := null;
      raise;
    end;

    //---------------------------------------------------------------
    //  La hago invisible al usuario para que:
    //      - al evitar refrescos de pantalla, la velocidad sea mayor
    //      - el usuario no podrá "hurgar" y estorbar en el proceso
    //---------------------------------------------------------------
    OcultarAplExcel;
//Obj_Excel.Visible := True;

    //---------------------------
    // Creo nuevo documento Excel
    //---------------------------
    Obj_WBook := CrearNuevoWBook;

  except
    //------------------------------
    // Algo ha fallado en el proceso
    //------------------------------
    ControlErrorExcel;
  end;
end;

constructor TAplExcel.Create;
begin
  //-------------------------------------------------------
  // Me creo primero la Aplicación Excel para asegurarme de
  // que se crea junto al objeto
  //-------------------------------------------------------
  CrearAplicacionExcel (False);

  //-----------------------------
  // Por último me creo el objeto
  //-----------------------------
  inherited Create;
end;

//constructor TAplExcel.CreateOrRetrieve;
//begin
//  //-------------------------------------------------------
//  // Me creo primero la Aplicación Excel para asegurarme de
//  // que se crea junto al objeto
//  //-------------------------------------------------------
//  CrearAplicacionExcel (True);
//
//  //-----------------------------
//  // Por último me creo el objeto
//  //-----------------------------
//  inherited Create;
//end;

procedure TAplExcel.Destroy;
begin
  if not Obj_Excel.Visible Then Begin
    if not Reutilizado          Then LiberarMemoria(False);
    if not VarIsNull(Obj_Excel) Then Begin
      if Obj_Excel.Workbooks.Count > 0 Then Begin
        MostrarAplExcel;
      End
      Else Begin
        Obj_Excel.Quit;
        Obj_Excel := null;
      End;
    End;
  End;

  InitVarExcel;
  inherited Free;
end;

//procedure TAplExcel.DestroyToRetrieve;
//begin
//  Reutilizado := True;
//  Self.Destroy;
//end;

procedure TAplExcel.InitVarExcel;
begin
  //---------------------------------------------------------
  // Las inicializo en orden de menor a mayor entorno por si
  // acaso se produjera error inicializando de mayor a menor.
  //---------------------------------------------------------
  Back_Calculation := xlAutomatic;
  Reutilizado      := False;
  Obj_WBook := Null;
  Obj_Excel := Null;
end;

function TAplExcel.Get_Obj_Excel : variant;
begin
  Result := Obj_Excel;
end;

function TAplExcel.Get_Obj_WBook : variant;
begin
  Result := Obj_WBook;
end;

procedure TAplExcel.Set_Obj_WBook (objeto : variant);
begin
  Obj_WBook := objeto;
end;

procedure TAplExcel.ControlErrorExcel;
begin
  LiberarMemoria(True);
//  if Borrar And VarIsNull(Obj_Excel) and (Not Reutilizado)
//  then Self.Destroy;
  raise Exception.Create('No ha podido generarse el documento Excel.'#13#13+
                         'Cierre la aplicación, e inténtelo de nuevo.'#13+
                         'Si el problema persiste, reinicie el equipo.');
end;

procedure TAplExcel.ColorFondo (Selection:Variant; Color:integer);
begin
  Selection.Interior.ColorIndex := Color;
end;

procedure TAplExcel.PonerGrid  (Selection:Variant;
                                GrosorMarco, GrosorVerti, GrosorHoriz:integer);
begin
  PonerMarco (Selection, GrosorMarco);
  if Selection.Columns.Count > 1 Then Begin
    if GrosorVerti = xlNone Then
      Selection.Borders[xlInsideVertical  ].LineStyle := xlNone
    Else Begin
      Selection.Borders[xlInsideVertical  ].LineStyle := xlContinuous;
      Selection.Borders[xlInsideVertical  ].Weight    := GrosorVerti;
    End;
  End;
  if Selection.Rows.Count > 1 Then Begin
    if GrosorHoriz = xlNone Then
      Selection.Borders[xlInsideHorizontal].LineStyle := xlNone
    Else Begin
      Selection.Borders[xlInsideHorizontal].LineStyle := xlContinuous;
      Selection.Borders[xlInsideHorizontal].Weight    := GrosorHoriz;
    End;
  End;
end;

procedure TAplExcel.PonerMarco (Selection:Variant; Grosor:integer);
begin
  Selection.Borders[xlEdgeLeft  ].LineStyle := xlContinuous;
  Selection.Borders[xlEdgeLeft  ].Weight    := Grosor;
  Selection.Borders[xlEdgeTop   ].LineStyle := xlContinuous;
  Selection.Borders[xlEdgeTop   ].Weight    := Grosor;
  Selection.Borders[xlEdgeBottom].LineStyle := xlContinuous;
  Selection.Borders[xlEdgeBottom].Weight    := Grosor;
  Selection.Borders[xlEdgeRight ].LineStyle := xlContinuous;
  Selection.Borders[xlEdgeRight ].Weight    := Grosor;
end;

function TAplExcel.LetraColumna (x:integer):string;
const letras = 'ABCDEFGHIJKLMNOPKRSTUVWXYZ';
begin
  Result := '';
  While x > 0 do begin
    Result := letras[1 + ((x - 1) Mod length(letras))] + Result;
    x := (x - 1) div length(letras);
  End;
end;

procedure TAplExcel.SetPrintArea (Hoja : variant; x1,y1, x2,y2 : integer);
begin
  if (x1 <= 0) or (x2 <= 0)
  Then raise Exception.Create('');
  Hoja.PageSetup.PrintArea := '$' + LetraColumna(x1) + '$' + inttostr(y1) + ':' +
                              '$' + LetraColumna(x2) + '$' + inttostr(y2);
end;

procedure TAplExcel.SetSaltoPagVert (Hoja : variant; NumSalto, Columna : integer);
var range : variant;
begin
  range := Hoja.Cells[1,Columna];
  Hoja.VPageBreaks[NumSalto].Location := Range;
end;

end.

[Flecha]

Se me olvidaba un consejo.

Para mayor agilidad a la hora de rellenar el contenido de las celdas del documento Excel te aconsejo que utilices un TMemo (aunque sea de forma temporal (en ejecución te lo creas y luego lo destruyes) y no sea visible en pantalla).
En el TMemo vas metiendo el contenido de todas las celdas (o de una buena cantidad de ellas, si lo vas haciendo por bloques). Luego ejecutas el procedimiento CopyToClipboard del TMemo. Por último sólo te queda ejecutar el procedimiento Paste que pertenece al WorkSheet del documento Excel.
Por ejemplo así:

Código Delphi [-]
 
procedure TMiForm.PegarDatos;
var x:integer;
begin
      Memo.SelectAll;
      Memo.CopyToClipboard;
      x:=0;
      repeat
        try
          MiExcel.ActiveSheet.Paste( MiExcel.ActiveSheet.Cells[ FilasFijas+Cont-(NumGrColum*FilasTope)-FilasDatos+1,
                                                              NumGrColum*AnchoGrColumnas+1 ],
                                   False);
          break;
        except
          inc(x);
          if x=20 Then raise;
        end;
      until false;
      Memo.Lines.Clear;
end;

En ese ejemplo el objeto MiExcel es del tipo TAplExcel que me creé.
Sólo hay una pequeña pega. Y es que en ocasiones este truco es tan rápido que intenta hacer el Paste casi antes de haber terminado de ponerse en orden el Clipboard y entonces salta un mensaje de error. Por eso lo tengo encerrado en un bucle. Si no consigue hacer el Paste a la primera, lo normal es que siempre lo consiga a la segunda, pues ya ha pasado algo más de tiempo.

Dentro del TMemo, lo que le vayas metiendo ahí, para separarlo por filas te valen los saltos de página, y para separarlo por columnas insertale caracteres de tabulación (#9).

Un saludo.

[Jose Roman]

Muchas gracias FLECHA, esta ayuda me responde las dudas que me surgieron.