Difference between revisions of "Office Automation/es"

From Lazarus wiki
Jump to navigationJump to search
(New page: {{Office Automation}}    La capacidad de interactuar con los programas ofimáticos y así generar hojas de cálculo, documentos de texto y presentaciones desde nuestro cód...)
 
m (Fixed syntax highlighting; removed categories included in template)
 
(16 intermediate revisions by 3 users not shown)
Line 1: Line 1:
 
{{Office Automation}}
 
{{Office Automation}}
  
   La capacidad de interactuar con los programas ofimáticos y así generar hojas de cálculo, documentos de texto y presentaciones desde nuestro código puede ser muy valiosa en la oficina, y ahorrar mucho tiempo a aquellos que hagan. Un ejemplo es la creación de aplicaciones que pueden leer archivos en un formato arbitrario y guardar la salida en un archivo de Excel, una tarea mucho más eficiente de hacer con el código a continuación expuesto que de forma manual.
+
   La capacidad de interactuar con los programas ofimáticos y así generar hojas de cálculo, documentos de texto y presentaciones desde nuestro código puede ser muy valiosa en la oficina, y ahorrar mucho tiempo a aquellos que lo necesiten. Un ejemplo es la creación de aplicaciones que pueden leer archivos en un formato arbitrario y guardar la salida en un archivo de Excel, una tarea mucho más eficiente de hacer con el código a continuación expuesto que de forma manual.
  
 
== Utilizando ''UNO Bridge'' de OpenOffice ==
 
== Utilizando ''UNO Bridge'' de OpenOffice ==
   OpenOffice tiene enlaces para lenguaje como C, Java, JavaScript y Python. En Windows, OpenOffice también puede ser manipulado en Pascal a través de automatización COM (véase más adelante), pero actualmente no una forma sencilla de usar OpenOffice UNO (Universal Network Objects -Objetos Universales de Red-) desde Pascal en OS X y Linux. Si estás interesado en el desarrollo de un puente entre  OO y Pascal, por favor mira estos enlaces para más información (precaución: estos enlaces son muy ''técnicos'' al estilo SUN):
+
   OpenOffice tiene enlaces para lenguaje como C, Java, JavaScript y Python. En Windows, OpenOffice también puede ser manipulado en Pascal a través de automatización COM (véase más adelante), pero actualmente no existe una forma sencilla de usar OpenOffice UNO (Universal Network Objects -Objetos Universales de Red-) desde Pascal en OS X y Linux. Si estás interesado en el desarrollo de un puente entre  OO y Pascal, por favor mira estos enlaces para más información (precaución: estos enlaces son muy ''técnicos'' al estilo SUN):
  
 
[http://api.openoffice.org/ api.openoffice.org]
 
[http://api.openoffice.org/ api.openoffice.org]
Line 13: Line 13:
  
 
== Usar automatización COM para interactuar con OpenOffice y Microsoft Office==
 
== Usar automatización COM para interactuar con OpenOffice y Microsoft Office==
Automation is unique to Windows so the following two examples won't work on OS X or Linux. For those platforms, please refer to [http://wiki.lazarus.freepascal.org/Multiplatform_Programming_Guide#Making_do_without_Windows_COM_Automation Making do without Windows COM Automation]. If you only need to create and/or view a word processing document from your program, take a look at the [http://web.fastermac.net/~MacPgmr/XDev/XDevStatus.html#RTF XDev Toolkit].
+
   La automatización COM es exclusiva de Windows, así que los ejemplos que siguen no funcionan ni en OS X ni en Linux. Para estas plataformas ver [http://wiki.lazarus.freepascal.org/Multiplatform_Programming_Guide#Making_do_without_Windows_COM_Automation Prescindiendo de la automatización COM  de Windows]. Si sólo necesita crear y/o ver un documento de texto desde su programa, da un vistazo al [http://web.fastermac.net/~MacPgmr/XDev/XDevStatus.html#RTF XDev Toolkit].
  
Here's a simple example of how to open a document with your program using the OpenOffice Automation server. Note that this works only on Windows.
+
   Este es una ejemplo sencillo de cómo abrir un documento con tu programa utilizando el servidor de automatización de OpenOffice. Recuerda que esto sólo funciona en Windows.
<PRE>
 
program TestOO;
 
  
{$IFDEF FPC}
+
<syntaxhighlight lang=pascal> program PruebaOpenOffice;
{$MODE Delphi}
 
{$ELSE}
 
{$APPTYPE CONSOLE}
 
{$ENDIF}
 
  
uses
+
{$IFDEF FPC}
   SysUtils, Variants, ComObj;
+
   {$MODE Delphi}
 +
{$ELSE}
 +
  {$APPTYPE CONSOLE}
 +
{$ENDIF}
  
const
+
uses
  ServerName = 'com.sun.star.ServiceManager';
+
   SysUtils, Variants, ComObj;
var         
 
  Server    : Variant;
 
  Desktop   : Variant;
 
  LoadParams : Variant;
 
  Document  : Variant;
 
  TextCursor : Variant;
 
begin
 
  if Assigned(InitProc) then
 
    TProcedure(InitProc);
 
  
   try
+
const
    Server := CreateOleObject(ServerName);
+
  NombreServidor = 'com.sun.star.ServiceManager';
  except
+
var         
    WriteLn('Unable to start OO.');
+
  Servidor    : Variant;
    Exit;
+
  Escritorio    : Variant;
  end;
+
  ParametrosCarga : Variant;
 +
  Documento   : Variant;
 +
  CursorTexto : Variant;
 +
begin
 +
  if Assigned(InitProc) then
 +
    TProcedure(InitProc);
 +
 
 +
  try
 +
    Servidor := CreateOleObject(NombreServidor);
 +
  except
 +
    WriteLn('No puedo arrancar OpenOffice.');
 +
    Exit;
 +
  end;
 +
 
 +
  Escritorio := Servidor.CreateInstance('com.sun.star.frame.Desktop');
  
  Desktop := Server.CreateInstance('com.sun.star.frame.Desktop');
+
  ParametrosCarga := VarArrayCreate([0, -1], varVariant);
  
  LoadParams := VarArrayCreate([0, -1], varVariant);
+
    {Crear un documento nuevo}
 +
  Documento := Escritorio.LoadComponentFromURL('private:factory/swriter',
 +
                                          '_blank', 0, ParametrosCarga);
  
  {Create new document}
+
   CursorTexto := Documento.Text.CreateTextCursor;
   Document := Desktop.LoadComponentFromURL('private:factory/swriter',
 
                                          '_blank', 0, LoadParams);
 
  
   TextCursor := Document.Text.CreateTextCursor;
+
  {Insertarun documento existente}  //Substituye por tu ruta y documento
 +
   CursorTexto.InsertDocumentFromURL('file:///C|/mi/ruta/midocumento.doc', 
 +
                                  ParametrosCarga);
 +
end.</syntaxhighlight>
  
  {Insert existing document}  //Substitute your path and doc
+
&nbsp;&nbsp;&nbsp;Y aquí un ejemplo sencillo de cómo abrir un documento con tu programa usando el servidor de automatización de Word. Ten en cuenta que este ejemplo sólo funciona en Windows y sólo cuando se compila con Delphi; Free Pascal 2.2.2 compila el código, pero no funciona. Por favor. Comprueba más adelante o prueba con una versión más reciente de FPC.
  TextCursor.InsertDocumentFromURL('file:///C|/my/path/mydoc.doc',
 
                                  LoadParams);
 
end.
 
</PRE>
 
  
Here's a simple example of how to open a document with your program using the Word Automation server. Note that this example works only on Windows and only when compiled with Delphi; Free Pascal 2.2.2 can now compile the code but running it does not work. Please check back later or test with a future version of FPC.
+
<syntaxhighlight lang=pascal> program PruebaMsOffice;
<PRE>
 
program TestMsOffice;
 
  
{$IFDEF FPC}
+
{$IFDEF FPC}
{$MODE Delphi}
+
  {$MODE Delphi}
{$ELSE}
+
{$ELSE}
{$APPTYPE CONSOLE}
+
  {$APPTYPE CONSOLE}
{$ENDIF}  
+
{$ENDIF}  
  
uses
+
uses
  SysUtils, Variants, ComObj;
+
  SysUtils, Variants, ComObj;
  
const
+
const
  ServerName = 'Word.Application';
+
    NombreServidor = 'Word.Application';
var
+
var
  Server     : Variant;
+
     Servidor    : Variant;
begin
+
begin
  if Assigned(InitProc) then
+
  if Assigned(InitProc) then
    TProcedure(InitProc);
+
    TProcedure(InitProc);
  
  try
+
  try
    Server := CreateOleObject(ServerName);
+
    Servidor := CreateOleObject(NombreServidor);
  except
+
  except
    WriteLn('Unable to start Word.');
+
    WriteLn('No puedo arrancar M$Word.');
 
     Exit;
 
     Exit;
 
   end;
 
   end;
  
   {Open existing document}  //Substitute your path and doc
+
   {Abrir un documento existente}  //Substituye por tu ruta y documento
   Server.Documents.Open('c:\my\path\mydoc.doc');  
+
   Servidor.Documents.Open('c:\mi\ruta\midocumento.doc');  
  
   Server.Visible := True;  {Make Word visible}
+
   Servidor.Visible := True;  {Hacer Word visible}
  
end.
+
end.</syntaxhighlight>
</PRE>
 
  
 +
== Utilizar Python para manejar OpenOffice ==
  
== Attempting to use Python to manipulate OpenOffice ==
+
&nbsp;&nbsp;&nbsp;Dado que OpenOffice incluye soporte para Python, sería posible ejecutar secuencias de comandos de Python desde Pascal para manipular OO, en lugar de un enlace real para lenguaje Pascal. Éstos son los pasos para un posible enfoque para realizarlo:
 
 
Since OpenOffice includes support for Python, it would seem possible to run Python scripts from Pascal to manipulate OO, in lieu of actual Pascal language bindings. Here are the steps for one possible approach to doing this:
 
  
 
<OL>
 
<OL>
<LI>Test UNO via Python macro run within OO
+
<LI>Probar que UNO vía macro de Python funciona dentro de OO
<LI>Test UNO via Python standalone script
+
<LI>Probar que UNO vía macro de Python independiente
<LI>Support for running Python scripts in Pascal
+
<LI>Crear el soporte para  correr macros de Python en Pascal
<LI>Test UNO via Python script run in Pascal
+
<LI>Probar que UNO vía macro de Python funciona con Pascal
<LI>Pascal class that wraps Python UNO
+
<LI>Crear una clase Pascal para envolver Python UNO
 
</OL>
 
</OL>
  
Note: The following scripts were tested with OpenOffice 2.3.1 on Windows XP and NeoOffice 2.2.5 Patch 6 on Mac OS X 10.4.11 (PowerPC).
+
&nbsp;&nbsp;&nbsp;Nota: Las siguientes macros han sido probadas con OpenOffice 2.3.1 en Windows XP y NeoOffice 2.2.5 Patch 6 en Mac OS X 10.4.11 (PowerPC).
  
==== Step 1. Test UNO via Python macro run within OO ====
+
==== Paso 1. Probar que UNO vía macro de Python funciona dentro de OO ====
  
OO has tools for creating JavaScript macros, but not Python macros, so use a text editor to save the following script to file test_macro.py and place it in OO's user macro folder. On Windows, this folder is:
+
&nbsp;&nbsp;&nbsp;OpenOffice tiene herramientas para crear macros de JavaScript, pero no las macros Python, por lo que utilizaremos el editor de texto para guardar la secuencia de comandos siguiente para el archivo prueba_macro.py y colocarlo en la carpeta de macros OO del usuario. En Windows, esta carpeta es:
  
 
<pre>
 
<pre>
C:\Document and Setting\<username>\Application Data\OpenOffice.org2\user\Scripts\python\Library1
+
C:\Document and Setting\<NombreUsuario>\Application Data\OpenOffice.org2\user\Scripts\python\Library1</pre>
</pre>
 
  
On Mac OS X, this folder is:
+
&nbsp;&nbsp;&nbsp;En Mac OS X, la carpeta es:
  
<pre>
+
<pre> ~/Library/Preferences/NeoOffice-2.2/usuario/Scripts/python/Library1</pre>
~/Library/Preferences/NeoOffice-2.2/user/Scripts/python/Library1
+
&nbsp;&nbsp;&nbsp;En ambas plataformas es necesario crear la carpeta '''python/Library1'''.
</pre>
 
  
On both platforms, you'll need to create the python/Library1 folder.
+
&nbsp;&nbsp;&nbsp;Este es el código para prueba_macro.py, adaptado del ejemplo OO Pascal anterior:
  
Here is the code for test_macro.py, adapted from the OO Pascal example above:
+
<syntaxhighlight lang=pascal> # Macro Python que prueba UNO creando un nuevo documento e inserta en el algo de texto.
  
<pre>
+
import uno
# Python macro that tests UNO by creating new document and inserting some text.
 
  
import uno
+
def PruebaNuevoDoc():
 +
  ctx = uno.getComponentContext()
 +
  smgr = ctx.ServiceManager
 +
  escritorio = smgr.createInstance('com.sun.star.frame.Desktop')
 +
  doc = escritorio.loadComponentFromURL('private:factory/swriter', '_blank', 0, ())
 +
  textoCursor = doc.Text.createTextCursor()
 +
  doc.Text.insertString(textoCursor, 'Hola Mundo', 0)
 +
</syntaxhighlight>
  
def TestNewDoc():
+
&nbsp;&nbsp;&nbsp;En OO, seleccionar '''Herramientas | Macros | Organizar Macros | Python...''' y ejecuta la macro para comprobar que funciona.
  ctx = uno.getComponentContext()
 
  smgr = ctx.ServiceManager
 
  desktop = smgr.createInstance('com.sun.star.frame.Desktop')
 
  doc = desktop.loadComponentFromURL('private:factory/swriter', '_blank', 0, ())
 
  textCursor = doc.Text.createTextCursor()
 
  doc.Text.insertString(textCursor, 'Hello World', 0)
 
</pre>
 
  
In OO, choose Tools | Macros | Organize Macros | Python and run the macro to make sure it works.
+
==== Paso 2. Probar que UNO funciona con una macro de Python independiente ====
  
==== Step 2. Test UNO via Python standalone script ====
+
&nbsp;&nbsp;&nbsp;Aquí el código para una macro independiente:
  
Here is the same code as a standalone script:
+
<syntaxhighlight lang=pascal> # Macro Python que prueba UNO creando un nuevo documento e inserta en el algo de texto.
  
<pre>
+
import sys
# Python script that tests UNO by creating new document and inserting some text.
 
  
import sys
+
if sys.platform == 'darwin':
 +
  sys.path.append('/Applications/NeoOffice.app/Contents/MacOS')
  
if sys.platform == 'darwin':
+
import officehelper
  sys.path.append('/Applications/NeoOffice.app/Contents/MacOS')
 
  
import officehelper
+
ctx = officehelper.bootstrap()
 +
smgr = ctx.ServiceManager
 +
escritorio = smgr.createInstance('com.sun.star.frame.Desktop')
 +
doc = escritorio.loadComponentFromURL('private:factory/swriter', '_blank', 0, ())
 +
textoCursor = doc.Text.createTextCursor()
 +
doc.Text.insertString(textoCursor, 'Hola Mundo', 0)
 +
</syntaxhighlight>
  
ctx = officehelper.bootstrap()
+
&nbsp;&nbsp;&nbsp;Guarda el archivo prueba.py y ejecútalo desde la línea de órdenes de Windows. Nota: En Windows y Linux, usa la versión de Python incluida con OO; en Mac OS X, usa la versión Python 2.3. del sistema.  
smgr = ctx.ServiceManager
 
desktop = smgr.createInstance('com.sun.star.frame.Desktop')
 
doc = desktop.loadComponentFromURL('private:factory/swriter', '_blank', 0, ())
 
textCursor = doc.Text.createTextCursor()
 
doc.Text.insertString(textCursor, 'Hello World', 0)
 
</pre>
 
  
Save this to file test.py and run it like this on Windows from a command line. Note: On Windows and Linux, use the version of Python included with OO; on Mac OS X, use the system's Python 2.3.
+
<pre> "\program files\openoffice.org 2.3\program\python" test.py</pre>
  
<pre>
+
&nbsp;&nbsp;&nbsp;En Mac OS X, corre la macro en una ventana de Terminal así:
"\program files\openoffice.org 2.3\program\python" test.py
 
</pre>
 
  
On Mac OS X, run the script like this from a Terminal window:
+
<pre> #!/bin/sh
 
+
export DYLD_LIBRARY_PATH=$DYLD_LIBRARY_PATH":/Applications/NeoOffice.app/Contents/MacOS"
<pre>
+
python2.3 test.py</pre>
#!/bin/sh
 
export DYLD_LIBRARY_PATH=$DYLD_LIBRARY_PATH":/Applications/NeoOffice.app/Contents/MacOS"
 
python2.3 test.py
 
</pre>
 
  
Unfortunately, this script doesn't work either on Windows or Mac OS X. On Windows, it displays an error dialog with no text (!) and then outputs an error message to the console that says "Cannot connect to soffice server". On Mac OS X, it starts NeoOffice and creates the new document, then NeoOffice shuts down abruptly.
+
&nbsp;&nbsp;&nbsp;Desafortunadamente, esta macro no funciona bien en Windows o Mac OS X. En Windows, se muestra un diálogo de error sin texto (¡!) Y luego escribe un mensaje de error en la consola que dice "No se puede conectar a un servidor soffice". En Mac OS X, se inicia NeoOffice y crea el nuevo documento, a continuación, NeoOffice se cierra abruptamente.
  
==== UNO Python To-Do ====
+
==== UNO Python Cosas por Hacer (ToDo) ====
  
Obviously additional investigation is needed before we can proceed to step 3. You are welcome to work on this. Here are a couple things to try:
+
&nbsp;&nbsp;&nbsp;Obviamente se necesita investigación adicional antes de proceder al paso 3. Te invitamos a trabajar en ello. Éstas son un par de cosas para probar:
  
* Test on Linux
+
* Pruebas en Linux
* Test on more recent versions of OpenOffice
+
* Pruebas en versiones más recientes de OpenOffice
  
* Jan. 5, 2009: Results of testing OpenOffice 3 on Windows:
+
* Enero. 5, 2009: Resultados de probar OpenOffice 3 en Windows:
** OO 3.0.0 support for user Python macros is broken (Step 1); fixed with OO 3.0.1 RC1.
+
** OO 3.0.0 soporte para macros Python de usuario roto (paso 1); arreglado en OO 3.0.1 RC1.
** Step 2 no longer displays the empty error dialog and the console exception message is different, but still doesn't start OO.
+
** Paso 2 el diálogo vacío ya no se muestra y el el mensaje de error de la consola es diferente, pero OO sigue sin arrancar.
** Note that paths to various parts of OO and to user macros have changed with OO 3.
+
** Ten en cuenta que las rutas a diferentes partes de OO y de las macros de usuario han cambiado con OO 3.
  
  
 
----
 
----
== Using the Free Pascal Spreadsheet Library ==
 
 
Another way to automate repetitive work with spreadsheets is to use the [[FPSpreadsheet]] library. It can read and write spreadsheets in several formats and it doesn't require having any external application installed on the machine.
 
 
== Writing an Excel file using ADO ==
 
please write me.
 
 
== Read/Writing an Excel file using the Excel Interface Component ==
 
 
The component is available here:
 
http://tcoq.free.fr/composants.html
 
  
Since Automation is not yet available, but COM is available, the Excel interface component provides a set of Lazarus classes encapsulating calls to the Excel COM interface (the one below the Automation). It hides most of the drudgery of working with low-level code.
+
== Usar la librería Spreadsheet de Free Pascal ==
  
Functionality:
+
&nbsp;&nbsp;&nbsp;Otra manera de automatizar tareas repetitivas con hojas de cálculo es utilizar la librería [[FPSpreadsheet]]. Puede leer y escribir hojas de cálculo en varios formatos y no requiere tener ninguna aplicación externa instalada en la máquina.
  
- creating and loading excel workbooks,
+
== Escribir un archivo Excel usando ADO ==
  
- saving workbooks,
+
* Si alguien puede documentar este paso la información vendría muy bien.
  
- creating and accessing sheets,
+
== Leer y escribir archivos Excel utilizando el componente Excel Interface ==
  
- getting values and setting values (and formulas) in cells,
+
&nbsp;&nbsp;&nbsp;El componente está disponible aquí:
 +
:http://tcoq.free.fr/composants.html
  
- getting and changing color of cells,
+
&nbsp;&nbsp;&nbsp;Dado que la Automatización no está disponible, pero COM si lo está, el componente de interfaz de Excel proporciona un conjunto de clases que encapsula las llamadas a Lazarus a la interfaz COM de Excel (por debajo de la Automatización). Así se oculta la mayoría del aburrido código de trabajo a bajo nivel.
  
- getting and changing column height and row width,
+
&nbsp;&nbsp;&nbsp;Funcionalidad:
  
- creating comments,
+
*crear y cargar libros de trabajo de excel,
 +
*guardar libros de trabajo,
 +
*crear y acceder a hojas,
 +
*extraer y dar valores (y formulas) en las celdas,
 +
*recuperar y vambiar colores de las celdas,
 +
*recuperar y cambiar la anchura de las columnas y la altura de la filas,
 +
*crear comentarios,
 +
*crear formas,
 +
*crear gráficos.
  
- creating shapes,
+
&nbsp;&nbsp;&nbsp; Obtener una hoja es sencillo:
 +
<syntaxhighlight lang=pascal> // Iniciando un libro de trabajo excel corriente:
 +
  ExcelAplicacion := TExcelApplication.Create(nil);
 +
  ExcelAplicacion.Active := True;
 +
  ExcelAplicacion.Visible := True;
 +
  LibrosExcel := ExcelAplicacion.WorkBooks;
 +
  unLibroExcel := LibrosExcel.Open(NombreArchivodePrueba)
 +
  HojasExcel := unLibroExcel.Sheets;
 +
  unaHojaExcel := HojasExcel.Sheet('Hoja1');</syntaxhighlight>
  
- creating charts.
+
&nbsp;&nbsp;&nbsp;Trabajar con las celdas es muy fácil:
  
 +
<syntaxhighlight lang=pascal> // añadiendo un valor
 +
  unaCelda := unaHojaExcel.Cells(1, 1);
 +
  unaCelda.Value := 10;
 +
  // añadiendo una formula
 +
  unaCelda := unaHojaExcel.Cells(2,1);
 +
  unaCelda.Formula := '=A1+10';
 +
  // obteniendo el valor claculado por Excel
 +
  unValor := unaCelda.Value;</syntaxhighlight>
  
Getting a sheet is simple:
+
&nbsp;&nbsp;&nbsp;En el ejemplo facilitado hay muchos más ejemplos.
  // Initializing the common excel workbook:
 
  ExcelApp := TExcelApplication.Create(nil);
 
  ExcelApp.Active := True;
 
  ExcelApp.Visible := True;
 
  ExcelWbs := ExcelApp.WorkBooks;
 
  ExcelWb := ExcelWbs.Open( TestFileName)
 
  ExcelSheets := ExcelWb.Sheets;
 
  ExcelSheet1 := ExcelSheets.Sheet('Sheet1');
 
  
Playing around with cells is simple too:
+
== Enlaces externos ==
  // adding a value
+
* Descripción del formato de fichero Excel en el [http://sc.openoffice.org/excelfileformat.pdf sitio web de OpenOffice]
  aCell := aSheet.Cells(1, 1);
 
  aCell.Value := 10;
 
 
 
  // adding a formula
 
  aCell := aSheet.Cells(2,1);
 
  aCell.Formula := '=A1+10';
 
 
 
  // getting the value computed in Excel
 
  aValue := aCell.Value;
 
 
 
 
 
The test case provided has many more examples.
 
 
 
== External links ==
 
* Excel file format description on the [http://sc.openoffice.org/excelfileformat.pdf OpenOffice website]
 
 
 
----
 
:Traducido por [[User:Iskraelectrica|Iskraelectrica]]
 
[[category:Español]][[category:Castellano]]
 

Latest revision as of 12:43, 21 February 2020

Deutsch (de) English (en) español (es) français (fr) italiano (it) русский (ru) 中文(中国大陆)‎ (zh_CN)

   La capacidad de interactuar con los programas ofimáticos y así generar hojas de cálculo, documentos de texto y presentaciones desde nuestro código puede ser muy valiosa en la oficina, y ahorrar mucho tiempo a aquellos que lo necesiten. Un ejemplo es la creación de aplicaciones que pueden leer archivos en un formato arbitrario y guardar la salida en un archivo de Excel, una tarea mucho más eficiente de hacer con el código a continuación expuesto que de forma manual.

Utilizando UNO Bridge de OpenOffice

   OpenOffice tiene enlaces para lenguaje como C, Java, JavaScript y Python. En Windows, OpenOffice también puede ser manipulado en Pascal a través de automatización COM (véase más adelante), pero actualmente no existe una forma sencilla de usar OpenOffice UNO (Universal Network Objects -Objetos Universales de Red-) desde Pascal en OS X y Linux. Si estás interesado en el desarrollo de un puente entre OO y Pascal, por favor mira estos enlaces para más información (precaución: estos enlaces son muy técnicos al estilo SUN):

api.openoffice.org

About_Bridges

Ver también el tema más abajo sobre Python.

Usar automatización COM para interactuar con OpenOffice y Microsoft Office

   La automatización COM es exclusiva de Windows, así que los ejemplos que siguen no funcionan ni en OS X ni en Linux. Para estas plataformas ver Prescindiendo de la automatización COM de Windows. Si sólo necesita crear y/o ver un documento de texto desde su programa, da un vistazo al XDev Toolkit.

   Este es una ejemplo sencillo de cómo abrir un documento con tu programa utilizando el servidor de automatización de OpenOffice. Recuerda que esto sólo funciona en Windows.

 program PruebaOpenOffice;

 {$IFDEF FPC}
  {$MODE Delphi}
 {$ELSE}
  {$APPTYPE CONSOLE}
 {$ENDIF} 

 uses
   SysUtils, Variants, ComObj;

 const
   NombreServidor = 'com.sun.star.ServiceManager';
 var          
   Servidor     : Variant;
   Escritorio    : Variant;
   ParametrosCarga : Variant;
   Documento   : Variant;
   CursorTexto : Variant;
 begin
   if Assigned(InitProc) then
     TProcedure(InitProc);

   try
     Servidor := CreateOleObject(NombreServidor);
   except
     WriteLn('No puedo arrancar OpenOffice.');
     Exit;
   end;

   Escritorio := Servidor.CreateInstance('com.sun.star.frame.Desktop');

   ParametrosCarga := VarArrayCreate([0, -1], varVariant);

    {Crear un documento nuevo}
   Documento := Escritorio.LoadComponentFromURL('private:factory/swriter',
                                           '_blank', 0, ParametrosCarga);

  CursorTexto := Documento.Text.CreateTextCursor;

   {Insertarun documento existente}  //Substituye por tu ruta y documento
  CursorTexto.InsertDocumentFromURL('file:///C|/mi/ruta/midocumento.doc',  
                                   ParametrosCarga);
 end.

   Y aquí un ejemplo sencillo de cómo abrir un documento con tu programa usando el servidor de automatización de Word. Ten en cuenta que este ejemplo sólo funciona en Windows y sólo cuando se compila con Delphi; Free Pascal 2.2.2 compila el código, pero no funciona. Por favor. Comprueba más adelante o prueba con una versión más reciente de FPC.

 program PruebaMsOffice;

 {$IFDEF FPC}
  {$MODE Delphi}
 {$ELSE}
  {$APPTYPE CONSOLE}
 {$ENDIF} 

 uses
   SysUtils, Variants, ComObj;

 const
    NombreServidor = 'Word.Application';
 var
    Servidor    : Variant;
 begin
   if Assigned(InitProc) then
     TProcedure(InitProc);

   try
     Servidor := CreateOleObject(NombreServidor);
   except
     WriteLn('No puedo arrancar M$Word.');
    Exit;
  end;

   {Abrir un documento existente}  //Substituye por tu ruta y documento
  Servidor.Documents.Open('c:\mi\ruta\midocumento.doc'); 

  Servidor.Visible := True;  {Hacer Word visible}

 end.

Utilizar Python para manejar OpenOffice

   Dado que OpenOffice incluye soporte para Python, sería posible ejecutar secuencias de comandos de Python desde Pascal para manipular OO, en lugar de un enlace real para lenguaje Pascal. Éstos son los pasos para un posible enfoque para realizarlo:

  1. Probar que UNO vía macro de Python funciona dentro de OO
  2. Probar que UNO vía macro de Python independiente
  3. Crear el soporte para correr macros de Python en Pascal
  4. Probar que UNO vía macro de Python funciona con Pascal
  5. Crear una clase Pascal para envolver Python UNO

   Nota: Las siguientes macros han sido probadas con OpenOffice 2.3.1 en Windows XP y NeoOffice 2.2.5 Patch 6 en Mac OS X 10.4.11 (PowerPC).

Paso 1. Probar que UNO vía macro de Python funciona dentro de OO

   OpenOffice tiene herramientas para crear macros de JavaScript, pero no las macros Python, por lo que utilizaremos el editor de texto para guardar la secuencia de comandos siguiente para el archivo prueba_macro.py y colocarlo en la carpeta de macros OO del usuario. En Windows, esta carpeta es:

 C:\Document and Setting\<NombreUsuario>\Application Data\OpenOffice.org2\user\Scripts\python\Library1

   En Mac OS X, la carpeta es:

 ~/Library/Preferences/NeoOffice-2.2/usuario/Scripts/python/Library1

   En ambas plataformas es necesario crear la carpeta python/Library1.

   Este es el código para prueba_macro.py, adaptado del ejemplo OO Pascal anterior:

 # Macro Python que prueba UNO creando un nuevo documento e inserta en el algo de texto.

 import uno

 def PruebaNuevoDoc():
   ctx = uno.getComponentContext()
   smgr = ctx.ServiceManager
   escritorio = smgr.createInstance('com.sun.star.frame.Desktop')
   doc = escritorio.loadComponentFromURL('private:factory/swriter', '_blank', 0, ())
   textoCursor = doc.Text.createTextCursor()
   doc.Text.insertString(textoCursor, 'Hola Mundo', 0)

   En OO, seleccionar Herramientas | Macros | Organizar Macros | Python... y ejecuta la macro para comprobar que funciona.

Paso 2. Probar que UNO funciona con una macro de Python independiente

   Aquí el código para una macro independiente:

 # Macro Python que prueba UNO creando un nuevo documento e inserta en el algo de texto.

 import sys

 if sys.platform == 'darwin':
   sys.path.append('/Applications/NeoOffice.app/Contents/MacOS')

 import officehelper

 ctx = officehelper.bootstrap()
 smgr = ctx.ServiceManager
 escritorio = smgr.createInstance('com.sun.star.frame.Desktop')
 doc = escritorio.loadComponentFromURL('private:factory/swriter', '_blank', 0, ())
 textoCursor = doc.Text.createTextCursor()
 doc.Text.insertString(textoCursor, 'Hola Mundo', 0)

   Guarda el archivo prueba.py y ejecútalo desde la línea de órdenes de Windows. Nota: En Windows y Linux, usa la versión de Python incluida con OO; en Mac OS X, usa la versión Python 2.3. del sistema.

 "\program files\openoffice.org 2.3\program\python" test.py

   En Mac OS X, corre la macro en una ventana de Terminal así:

 #!/bin/sh
 export DYLD_LIBRARY_PATH=$DYLD_LIBRARY_PATH":/Applications/NeoOffice.app/Contents/MacOS"
 python2.3 test.py

   Desafortunadamente, esta macro no funciona bien en Windows o Mac OS X. En Windows, se muestra un diálogo de error sin texto (¡!) Y luego escribe un mensaje de error en la consola que dice "No se puede conectar a un servidor soffice". En Mac OS X, se inicia NeoOffice y crea el nuevo documento, a continuación, NeoOffice se cierra abruptamente.

UNO Python Cosas por Hacer (ToDo)

   Obviamente se necesita investigación adicional antes de proceder al paso 3. Te invitamos a trabajar en ello. Éstas son un par de cosas para probar:

  • Pruebas en Linux
  • Pruebas en versiones más recientes de OpenOffice
  • Enero. 5, 2009: Resultados de probar OpenOffice 3 en Windows:
    • OO 3.0.0 soporte para macros Python de usuario roto (paso 1); arreglado en OO 3.0.1 RC1.
    • Paso 2 el diálogo vacío ya no se muestra y el el mensaje de error de la consola es diferente, pero OO sigue sin arrancar.
    • Ten en cuenta que las rutas a diferentes partes de OO y de las macros de usuario han cambiado con OO 3.



Usar la librería Spreadsheet de Free Pascal

   Otra manera de automatizar tareas repetitivas con hojas de cálculo es utilizar la librería FPSpreadsheet. Puede leer y escribir hojas de cálculo en varios formatos y no requiere tener ninguna aplicación externa instalada en la máquina.

Escribir un archivo Excel usando ADO

  • Si alguien puede documentar este paso la información vendría muy bien.

Leer y escribir archivos Excel utilizando el componente Excel Interface

   El componente está disponible aquí:

http://tcoq.free.fr/composants.html

   Dado que la Automatización no está disponible, pero COM si lo está, el componente de interfaz de Excel proporciona un conjunto de clases que encapsula las llamadas a Lazarus a la interfaz COM de Excel (por debajo de la Automatización). Así se oculta la mayoría del aburrido código de trabajo a bajo nivel.

   Funcionalidad:

  • crear y cargar libros de trabajo de excel,
  • guardar libros de trabajo,
  • crear y acceder a hojas,
  • extraer y dar valores (y formulas) en las celdas,
  • recuperar y vambiar colores de las celdas,
  • recuperar y cambiar la anchura de las columnas y la altura de la filas,
  • crear comentarios,
  • crear formas,
  • crear gráficos.

    Obtener una hoja es sencillo:

 // Iniciando un libro de trabajo excel corriente:
  ExcelAplicacion := TExcelApplication.Create(nil);
  ExcelAplicacion.Active := True;
  ExcelAplicacion.Visible := True;
  LibrosExcel := ExcelAplicacion.WorkBooks;
  unLibroExcel := LibrosExcel.Open(NombreArchivodePrueba)
  HojasExcel := unLibroExcel.Sheets;
  unaHojaExcel := HojasExcel.Sheet('Hoja1');

   Trabajar con las celdas es muy fácil:

 // añadiendo un valor
  unaCelda := unaHojaExcel.Cells(1, 1);
  unaCelda.Value := 10;
  // añadiendo una formula
  unaCelda := unaHojaExcel.Cells(2,1);
  unaCelda.Formula := '=A1+10';
  // obteniendo el valor claculado por Excel
  unValor := unaCelda.Value;

   En el ejemplo facilitado hay muchos más ejemplos.

Enlaces externos