Chamar macros Basic pelo Python

É possível chamar as macros Basic do LibreOffice a partir de scripts Python, e recursos notáveis podem ser obtidos tais como:

A Interface de Programação de Aplicações (API) Scripting Framework do LibreOffice suporta a execução de scripts inter-linguagem entre Python e o Basic, ou demais linguagens suportadas. Os argumentos podem ser passados para frente ou de volta entre chamadas, desde que representem tipo de dados primitivos que ambas linguagens reconheçam, e assumindo que o Scripting Framework faça a conversão adequadamente.

tip

Recomenda-se conhecer os módulos padrões do Python e dos recursos da API do LibreOffice antes de começar a executar chamadas inter-linguagens do Python ao Basic, Javascript ou qualquer outro motor de scripts.


warning

Ao executar scripts Python dentro de um ambiente integrado de desenvolvimento (IDE), o motor embutido Basic do LibreOffice pode estar ausente. evite chamadas ao LibreOffice Basic neste contexto. Entretanto o ambiente Python e os Universal Networks Objects (UNO) estão plenamente disponíveis. Consulte Configurar um Ambiente de Desenvolvimento Integrado (IDE) para Python para mais informações.


Resgatar scripts Basic do LibreOffice

As macros Basic do LibreOffice Basic podem ser pessoais, compartilhadas ou embutidas em documentos. Para executá-las, o ambiente de execução do Python precisa ser fornecido nos locais em conjunto com as macros Basic. Implementar a interface com.sun.star.script.provider.XScriptProvider permite resgatar os scripts executáveis:


		 import uno
		 from com.sun.star.script.provider import Xscript
		     
		 def getBasicScript(macro='Main', module='Module1', library='Standard',
		         isEmbedded=False) -> XScript:
		     '''Agarre os objetos do script Basic antes de invocá-los.'''
		     ctx = uno.getComponentContext()
		     smgr = ctx.ServiceManager
		     if isEmbedded:
		         desktop = smgr.createInstanceWithContext('com.sun.star.frame.Desktop', ctx)
		         scriptPro = desktop.CurrentComponent.getScriptProvider()
		         location = "document"
		     else:
		         mspf = smgr.createInstanceWithContext(
		             "com.sun.star.script.provider.MasterScriptProviderFactory", ctx)
		         scriptPro = mspf.createScriptProvider("")
		         location = "application"
		     scriptName = "vnd.sun.star.script:"+library+"."+module+"."+macro+ \
		                  "?language=Basic&location="+location
		     xScript = scriptPro.getScript(scriptName)
		     return xScript
		 

Executar scripts Basic do LibreOffice

A documentação do kit de desenvolvimento de software (SDK) do LibreOffice para a interface com.sun.star.script.provider.XScript detalha a convenção de chamadas para chamadas inter-linguagem. A invocação de funções requer três vetores:

Sintaxe Python

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

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

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

Exemplos de scripts pessoais ou compartilhados

Os exemplos em Entrada e saída na tela detalham as chamadas ao Basic desde o Python. Em Monitorar eventos de documento ilustra-se o emprego do idioma Python *args para imprimir um número variável de parâmetros para a caixa de diálogo de logging do Access2Base.

tip

Enquanto estiver desenvolvendo, você pode interromper a execução de um script Python utilizando a extensão Xray para inspecionar propriedades e métodos de objetos UNO. O depurador da extensão APSO permite instrospecção de objetos utilizando tanto a extensão Xray quanto a extensão MRI.



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

Exemplo de scripts embutidos em documentos

A sintaxe simplificada do Python *args pode ser usada em conjunto com as rotinas do LibreOffice Basic que aceitam um número variável de argumentos. Abaixo tem-se as funções Python Print e SUM chamando suas contrapartidas Basic Print e SUM, usando a função getBasicScript. O tratamento das exceções não é detalhado aqui.


	  # -*- coding: utf-8 -*-
	  from __future__ import unicode_literals
	      
	  def Print(*args):
	      """Saída de texto ou expressão numérica numa caixa de diálogo."""
	      xScript = getBasicScript("Print", "Scripting", embedded=True)
	      xScript.invoke((args), (), ())
	      
	  def SUM(*args):
	      """Soma da expressão numérica especificada."""
	      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,)
	  

As rotinas do LibreOffice Basic Print e SUM em documentos aceitam um número variável de argumentos. Os atributos Private ou Public não tem efeito. A verificação dos tipo de dados foi omitida para melhor clareza.


	  Option Compatible ' "Standard.Scripting" module
	  Option Explicit
	      
	  Private Sub Print(ParamArray args() As Variant, Optional sep As String = " ")
	      ''' Imprime a lista de itens de tamanho variável'''
	      ' Todos os argumentos de  CStr() são aceitos
	      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 de uma lista variável de argumentos '''
	      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()
	  

♥ Doe para nosso projeto! ♥