Llamar a macros en Basic dende Python

Puen llamase a macros en Basic de LibreOffice dende scripts en Python y puen llograse asina carauterístiques notables, como:

La infraestructura de scripts de la Interfaz de Programación d'Aplicaciones (API) de LibreOffice tien encontu pa la execución inter-llinguax de scripts ente Python y Basic o, pal casu, otros llinguaxes de programación con sofitu. Los argumentos puen pasase atrás y alantre ente llamaes, siempre que representen primitives de tipos de datos que dambos llinguaxes reconozan, y asumiendo que la infraestructura de scripts los convierte de mou apropiáu.


Ye recomendable tener conocimientu de los módulos estándar de Python y de les carauterístiques de la API de LibreOffice antes facer llamaes inter-llinguaxe dende Python a Basic, JavaScript o cualquier otru motor de scripts.


When running Python scripts from an Integrated Development Environment (IDE), the LibreOffice nested Basic engine may be absent. Avoid Python to LibreOffice Basic calls in such context. However Python environment and Universal Networks Objects (UNO) are fully available. Refer to Setting Up an Integrated IDE for Python for more information.

Retrieving LibreOffice Basic Scripts

LibreOffice Basic macros can be personal, shared, or embedded in documents. In order to execute them, Python run time needs to be provided with Basic macro locations. Implementing the com.sun.star.script.provider.XScriptProvider interface allows the retrieval of executable scripts:

		 import uno
		 from com.sun.star.script.provider import Xscript
		 def getBasicScript(macro='Main', module='Module1', library='Standard',
		         isEmbedded=False) -> XScript:
		     '''Grab Basic script object before invocation.'''
		     ctx = uno.getComponentContext()
		     smgr = ctx.ServiceManager
		     if isEmbedded:
		         desktop = smgr.createInstanceWithContext('com.sun.star.frame.Desktop', ctx)
		         scriptPro = desktop.CurrentComponent.getScriptProvider()
		         location = "document"
		         mspf = smgr.createInstanceWithContext(
		             "com.sun.star.script.provider.MasterScriptProviderFactory", ctx)
		         scriptPro = mspf.createScriptProvider("")
		         location = "application"
		     scriptName = "vnd.sun.star.script:"+library+"."+module+"."+macro+ \
		     xScript = scriptPro.getScript(scriptName)
		     return xScript

Executing LibreOffice Basic Scripts

The LibreOffice Software Development Kit (SDK) documentation for com.sun.star.script.provider.XScript interface details the calling convention for inter-language calls. Invocation of functions requires three arrays:

Python Syntax

results = script.invoke((prompt,buttons,title), (), ())

script.invoke((message,), tuple, ())

script.invoke((args), (), results)

Examples of Personal or Shared Scripts

Examples in Input/Output to Screen detail Python to Basic invocation calls. Monitoring Document Events illustrates the usage of *args Python idiom to print a variable number of parameters to Access2Base logging console dialog.


At time of development you can interrupt Python script execution using Xray extension in order to inspect properties and methods of UNO objects. The APSO extension debugger allows object introspection using either Xray either MRI extensions.

	  def xray(myObject):
	  	  script = getBasicScript(library="XrayTool", module="_Main", macro="Xray")
	  	  script.invoke((myObject,), (), ())

Examples of Embedded Scripts in Documents

*argsPython simplified syntax can be used in conjunction with LibreOffice Basic routines that accept a variable number of arguments. Below Print and SUM Python functions call their Basic Print and SUM counterparts, using aforementioned getBasicScript function. Exception handling is not detailed.

	  # -*- coding: utf-8 -*-
	  from __future__ import unicode_literals
	  def Print(*args):
	      """Outputs the specified strings or numeric expressions in a dialog box."""
	      xScript = getBasicScript("Print", "Scripting", embedded=True)
	      xScript.invoke((args), (), ())
	  def SUM(*args):
	      """SUM the specified number expression."""
	      xScript = getBasicScript("SUM", "Scripting", embedded=True)
	      res = xScript.invoke((args), (), ())
	      return res[0]
	  # def getBasicScript()  # see above
	  def playWithArgs():
	      Print("Fun with *args ", -9.81, 297864.681974, 8762E-137)
	      Print(SUM(45, -9.81, 297864.681974))
	      Print(SUM(45, -9.81, 297864.681974, 8762E+137))
	  g_exportedScripts = (playWithArgs,)

The LibreOffice Basic Print and SUM document-based routines accept a variable number of arguments. The Private or Public attributes have no effect. The arguments type checking is skipped for clarity.

	  Option Compatible ' "Standard.Scripting" module
	  Option Explicit
	  Private Sub Print(ParamArray args() As Variant, Optional sep As String = " ")
	      ''' Print item list of variable number '''
	      ' acéutense tolos argumentos convertibles de CStr()
	      Dim str As String, i As Integer
	      If UBound(args) >= 0 Then
	          For i = 0 To UBound(args)
	              str = str + Cstr(args(i))+ sep 
	          Next i
	      End If
	      Print str
	  End Sub ' Standard.Scripting.Print()
	  Public Function SUM(ParamArray args() As Variant) As Variant
	      ''' SUM a variable list of numbers '''
	      Dim ndx As Integer
	      If UBound(args) >= 0 Then
	          For ndx = 0 To UBound(args)
	              SUM = SUM + args(ndx)
	          Next ndx
	      End If
	  End Function ' Standard.Scripting.SUM()

Please support us!