Difference between revisions of "Office Automation"

From Lazarus wiki
(Using COM Automation to interact with OpenOffice and Microsoft Office)
m (Text replace - "delphi>" to "syntaxhighlight>")
Line 17: Line 17:
 
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.
 
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.
  
<delphi>program TestOO;
+
<syntaxhighlight>program TestOO;
  
 
{$IFDEF FPC}
 
{$IFDEF FPC}
Line 60: Line 60:
 
   TextCursor.InsertDocumentFromURL('file:///C|/my/path/mydoc.doc',   
 
   TextCursor.InsertDocumentFromURL('file:///C|/my/path/mydoc.doc',   
 
                                   LoadParams);
 
                                   LoadParams);
end.</delphi>
+
end.</syntaxhighlight>
  
 
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. This will work with both delphi and fpc.
 
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. This will work with both delphi and fpc.
  
<delphi>program TestMsOffice;
+
<syntaxhighlight>program TestMsOffice;
  
 
{$IFDEF FPC}
 
{$IFDEF FPC}
Line 95: Line 95:
 
   Server.Visible := True;  {Make Word visible}
 
   Server.Visible := True;  {Make Word visible}
  
end.</delphi>
+
end.</syntaxhighlight>
  
 
== Attempting to use Python to manipulate OpenOffice ==
 
== Attempting to use Python to manipulate OpenOffice ==
Line 226: Line 226:
 
'''Inits first.'''
 
'''Inits first.'''
  
<delphi>  IMPLEMENTATION
+
<syntaxhighlight>  IMPLEMENTATION
 
   USES
 
   USES
 
     ExcelUtilities,
 
     ExcelUtilities,
Line 239: Line 239:
 
   ExcelBook  : IWorkBook ;
 
   ExcelBook  : IWorkBook ;
 
   ExcelSheet  : ISheet ;
 
   ExcelSheet  : ISheet ;
   ExcelSheets : ISheets ;</delphi>
+
   ExcelSheets : ISheets ;</syntaxhighlight>
  
 
Getting a sheet is simple:
 
Getting a sheet is simple:
<delphi>  // Initializing the common excel workbook:
+
<syntaxhighlight>  // Initializing the common excel workbook:
 
   ExcelApp        := TExcelApplication.Create(nil) ;
 
   ExcelApp        := TExcelApplication.Create(nil) ;
 
   ExcelApp.Active  := True ;
 
   ExcelApp.Active  := True ;
Line 250: Line 250:
 
   ExcelBook  := ExcelWbs.Add ;
 
   ExcelBook  := ExcelWbs.Add ;
 
   ExcelSheets := ExcelBook.Sheets ;
 
   ExcelSheets := ExcelBook.Sheets ;
   ExcelSheet  := ExcelSheets.Sheet(1) ;</delphi>
+
   ExcelSheet  := ExcelSheets.Sheet(1) ;</syntaxhighlight>
  
 
Playing around with cells is simple too:
 
Playing around with cells is simple too:
<delphi>  // adding a value
+
<syntaxhighlight>  // adding a value
 
   aCell := ExcelSheet.Cells(1, 1) ;
 
   aCell := ExcelSheet.Cells(1, 1) ;
 
   aCell.Value := 10;
 
   aCell.Value := 10;
Line 262: Line 262:
  
 
   // getting the value computed in Excel
 
   // getting the value computed in Excel
   aValue := aCell.Value ;</delphi>
+
   aValue := aCell.Value ;</syntaxhighlight>
  
  
Line 271: Line 271:
 
You can copy HTML to the clipboard which is understood by many applications. This way you can copy formatted text. For those applications that only understand text put plain text too.
 
You can copy HTML to the clipboard which is understood by many applications. This way you can copy formatted text. For those applications that only understand text put plain text too.
  
<delphi>uses
+
<syntaxhighlight>uses
 
   ClipBrd;
 
   ClipBrd;
 
...
 
...
Line 281: Line 281:
 
   Clipboard.AsText:=ThePlainUTF8Text;  
 
   Clipboard.AsText:=ThePlainUTF8Text;  
 
   AsHTML:='<b>Formatted</b> text'; // text with formattings
 
   AsHTML:='<b>Formatted</b> text'; // text with formattings
   Clipboard.AddFormat(ClipbrdFmtHTML,AsHTML[1],length(AsHTML));</delphi>
+
   Clipboard.AddFormat(ClipbrdFmtHTML,AsHTML[1],length(AsHTML));</syntaxhighlight>
  
 
==See also==
 
==See also==

Revision as of 15:48, 24 March 2012

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

The ability to interact with office software and generate spreadsheets, text documents and presentations from code can be invaluable in the office, and win a lot of time for those that can do it. One example of this is the creation of applications that can read files in an arbitrary format and output an Excel file, a task much more efficient to be done with code then manually.

Using the OpenOffice UNO Bridge

OpenOffice has language bindings for C++, Java, JavaScript and Python. On Windows, OpenOffice can also be manipulated in Pascal via COM Automation (see below), but there is currently no easy way of using OpenOffice's UNO (Universal Network Objects) from Pascal on OS X and Linux. If you're interested in developing an OO "bridge" for Pascal, please refer to these links for more information (caution: these links are quite techie in true Sun fashion):

api.openoffice.org

About Bridges

See also the topic below about Python.

Using COM Automation to interact with OpenOffice and 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 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 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.

program TestOO;

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

uses
  SysUtils, Variants, ComObj;

const
  ServerName = 'com.sun.star.ServiceManager';
var          
  Server     : Variant;
  Desktop    : Variant;
  LoadParams : Variant;
  Document   : Variant;
  TextCursor : Variant;
begin
  if Assigned(InitProc) then
    TProcedure(InitProc);

  try
    Server := CreateOleObject(ServerName);
  except
    WriteLn('Unable to start OO.');
    Exit;
  end;

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

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

   {Create new document}
  Document := Desktop.LoadComponentFromURL('private:factory/swriter',
                                           '_blank', 0, LoadParams);

  TextCursor := Document.Text.CreateTextCursor;

   {Insert existing document}  //Substitute your path and doc
  TextCursor.InsertDocumentFromURL('file:///C|/my/path/mydoc.doc',  
                                   LoadParams);
end.

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. This will work with both delphi and fpc.

program TestMsOffice;

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

uses
  SysUtils, Variants, ComObj;

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

  try
    Server := CreateOleObject(ServerName);
  except
    WriteLn('Unable to start Word.');
    Exit;
  end;

   {Open existing document}  //Substitute your path and doc
  Server.Documents.Open('c:\my\path\mydoc.doc'); 

  Server.Visible := True;  {Make Word visible}

end.

Attempting to use Python to manipulate OpenOffice

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:


  1. Test UNO via Python macro run within OO
  2. Test UNO via Python standalone script
  3. Support for running Python scripts in Pascal
  4. Test UNO via Python script run in Pascal
  5. Pascal class that wraps Python UNO


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

Step 1. Test UNO via Python macro run within 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:

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

On Mac OS X, this folder is:

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

On both platforms, you'll need to create the python/Library1 folder.

Here is the code for test_macro.py, adapted from the OO Pascal example above:

<python># Python macro that tests UNO by creating new document and inserting some text.

import uno

def TestNewDoc():

 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)

</python>

In OO, choose Tools | Macros | Organize Macros | Python and run the macro to make sure it works.

Step 2. Test UNO via Python standalone script

Here is the same code as a standalone script:

<python># 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')

import officehelper

ctx = officehelper.bootstrap() 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) </python>

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.

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

On Mac OS X, run the script like this from a Terminal window:

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

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.

UNO Python To-Do

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:

  • Test on Linux
  • Test on more recent versions of OpenOffice
  • Jan. 5, 2009: Results of testing OpenOffice 3 on Windows:
    • OO 3.0.0 support for user Python macros is broken (Step 1); fixed with 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.
    • Note that paths to various parts of OO and to user macros have changed with OO 3.



Using the fpXMLXSDExport unit

Recent (August 2011) FPC trunk contains the fpXMLXSDExport unit, part of the FCL-DB export components. With that, you can export to various XML formats, including a Microsoft Access-compatible format and a Microsoft Excel-compatible format.

The Access format can output XML with or without an embedded XSD data/table definition. Note that exporting binary/BLOB type data needs additional action at the Access import end, as Access does not support proper binary fields, only OLE fields.

In the Excel format, multiline text fields are not supported at the moment: the line ends are removed during the export.

See fpXMLXSDExport for details.

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 SpreadSheet Interface Component

The component provides a library interface, abstracting the Excel COM and the Calc Open Office UNO interfaces. The component is available here: http://www.tcoq.org/composants

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. Be careful, this is a work-in-progress. Use it at your own risk.

Functionality:

  • creating and loading excel workbooks,
  • saving workbooks,
  • creating and accessing sheets,
  • getting values and setting values (and formulas) in cells,
  • getting and changing color of cells,
  • getting and changing column height and row width,
  • creating comments,
  • creating shapes,
  • creating charts.

Inits first.

  IMPLEMENTATION
  USES
    ExcelUtilities,
    SpreadSheetInterfaces ;

  VAR
   aCell    : IRange ;
   aValue   : OleVariant ; // Not sure about this, but it works. ie( Edit.Text := STRING(aValue); )
   ExcelApp : TExcelApplication ;
   ExcelWbs : IWorkBooks ;

  ExcelBook   : IWorkBook ;
  ExcelSheet  : ISheet ;
  ExcelSheets : ISheets ;

Getting a sheet is simple:

  // Initializing the common excel workbook:
  ExcelApp         := TExcelApplication.Create(nil) ;
  ExcelApp.Active  := True ;
  ExcelApp.Visible := True ;

  ExcelWbs    := ExcelApp.WorkBooks ;
  ExcelBook   := ExcelWbs.Add ;
  ExcelSheets := ExcelBook.Sheets ;
  ExcelSheet  := ExcelSheets.Sheet(1) ;

Playing around with cells is simple too:

  // adding a value
  aCell := ExcelSheet.Cells(1, 1) ;
  aCell.Value := 10;

  // adding a formula
  aCell := ExcelSheet.Cells(2,1) ;
  aCell.Formula := '=A1+10' ;

  // getting the value computed in Excel
  aValue := aCell.Value ;


The test case provided has many more examples.

Copy HTML to the clipboard

You can copy HTML to the clipboard which is understood by many applications. This way you can copy formatted text. For those applications that only understand text put plain text too.

uses
  ClipBrd;
...
  // register the mime type for text/html. You can do this once at program start:
  ClipbrdFmtHTML:=RegisterClipboardFormat('text/html');
...
  // put text and html on the clipboard. Other applications will choose the best format automatically.
  ThePlainUTF8Text:='Simple text';
  Clipboard.AsText:=ThePlainUTF8Text; 
  AsHTML:='<b>Formatted</b> text'; // text with formattings
  Clipboard.AddFormat(ClipbrdFmtHTML,AsHTML[1],length(AsHTML));

See also

External links