[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.