OOo Basic. Servicios

Calc. Mostrar hojas mediante macros

Además de [ocultar las hojas], también podemos mostrarlas cuando resulte conveniente. Para ello disponemos de la opción del menú Hoja | Mostar hoja y de una alternativa basada en el código macro. Se trata esta vez de un código algo más complejo que el que genera Grabar macro cuando capturamos la secuencia de ocultar hoja, pero precisamente por eso es también más maleable para ser aprovechado desde OOo Basic.

La macro que genera la funcionalidad Grabar macro presenta esta sintaxis:

Sub MstH1Macro

dim document   as object

dim dispatcher as object

document   = ThisComponent.CurrentController.Frame

dispatcher = createUnoService("com.sun.star.frame.DispatchHelper")

dim args1(0) as new com.sun.star.beans.PropertyValue

args1(0).Name = "aTableName"

args1(0).Value = "Hoja2"

dispatcher.executeDispatch(document, ".uno:Show", "", 0, args1())

End Sub

Además  de lo que tú ya conoces por ser parte invariable del código macro, el que resulta determinante de esta funcionalidad está comprendido entre las líneas 5 a 8. 

Fíjate que args1(0).Name trabaja con el nombre de la tabla ("aTableName"), por lo que args1(0).Value requiere un dato alfanumérico que se ajuste al nombre de una hoja realmente existente en estado "Oculto" (en este caso "Hoja2") (1). 

La instrucción concreta que muestra la hoja es ".uno:Show" y es el segundo parámetro de la función o método  dispatcher.executeDispatch().

Conocido esto resulta muy sencillo transformar la macro en una subrutina: es suficiente con dotarla de un parámetro string que permita recibir el nombre de la hoja desde el script desde el cual es llamada la subrutina. Vemos un ejemplo:

Sub MstH1 ' Script

MostarHoja("Hoja2")

End Sub

Sub MostarHoja(nH As String) ' Subrutina

dim document   as object

dim dispatcher as object

document   = ThisComponent.CurrentController.Frame

dispatcher = createUnoService("com.sun.star.frame.DispatchHelper")

dim args1(0) as new com.sun.star.beans.PropertyValue

args1(0).Name = "aTableName"

args1(0).Value = nH

dispatcher.executeDispatch(document, ".uno:Show", "", 0, args1())

End Sub

El script es muy simple y económico en términos de líneas de código, lo que nos permite multiplicarlo las veces que resulte necesario en nuestro algoritmo.

Y la subrutina sólo varía respecto a la macro en que hemos sustituido el string que concreta la hoja a mostrar por la variable-parámetro que definimos en su declaración (MostarHoja(nH As String))

La única condición que debemos respetar para que este conjunto script-subrutina funciones correctamente es que desde el script entreguemos un string y no un valor numérico cuando llamemos a la subrutina.

Documento. Este [libro Calc] contiene el código explicado en la entrada. Te sugiero que crees nuevos script que hagan uso de la subrutina para mostrar las hojas ocultas (hay nueve)

NOTAS

(1) Si la hoja no existe o ya está visible la macro no genera error.

Textos. OOo Basic.

Writer. Uso de macros para automatizar textos (1)

La forma básica de automatizar la escritura de un texto es haciendo uso de la funcionalidad LO-Writer Grabar macro (Herramientas/Macros/Grabar macro). Word posee una funcionalidad similar, aunque es necesario habilitar el modo Programador. Como sabes, mediante Grabar macro es posible generar un código que recoge cada una de las pulsaciones del teclado (y algunas acciones con el ratón) y convertirlas en código (OOo Basic en Writer). Posteriormente podrás modificar ese código para darle las funcionalidades de las que carece, como la inclusión de variables propias y el uso de estructuras de iteración o bifurcación.

Efectivamente, Grabar macro se limita a crear un código estrictamente imperativo-lineal, carente de esos componentes tan importantes en cualquier lenguaje de programación. Es por ello que una macro (entendida como código resultante del uso de Grabar macro) es una solución muy limitada para basar en ella el proceso de automatización de la escritura de un texto, aunque puede ser la base del mismo, según vimos en otro momento.

Precisamente por ello, y también por ser el primer recurso de utilidad en ese proceso de automatización, es conveniente entender el código-macro de escritura, así como saber crear una macro simple de escritura como la que tienes a continuación (puedes acceder a este código de esta macro simple desde aquí)

dim args1(0) as new com.sun.star.beans.PropertyValue

args1(0).Name = "Text"

args1(0).Value = "Texto"

dispatcher.executeDispatch(document, ".uno:InsertText", "", 0, args1())

Sin entrar en detalles que ahora importa poco, tal y como vimos en otro momento también, lo fundamental de esta macro simple es su estructura, compuesta por una matriz de dos atributos y una instrucción de ejecución, por ese orden. Respecto a la primera nos interesa el segundo argumento (args1(0).Value = "Texto"), ya que podemos utilizarla para...

• A partir de una macro simple que usamos a modo de plantilla, sustituir esa palabra por otra, por una frase o por un texto de la longitud que deseemos, simplemente con pegar ese contenido en sustitución del que originalmente tiene la macro-base.
• Sustituir el texto por una variable, siempre de tipo string, que previamente declaramos dentro de la macro (2) y a la que asignamos un determinado contenido (una cadena de texto o una concatenación de cadenas de texto o la combinación de cadenas de texto y variables).
• Podemos generar algún tipo de procedimiento de personalización del contenido sin necesidad de acceder al IDE, asignando, a su vez, esa variable a un objeto InputBox() o a recursos más complejos de interface, como un cuadro de diálogo. De este modo no será necesario "programar" el script cada vez que deseemos usarlo.
• Y, como ya vimos, podemos utilizar la macro, reconvertida en subrutina, accediendo a ella desde un script que contendrá la variable de asignación de contenido antes indicada, la cual se utilizará como argumento en la llamada a la macro-subrutina. También es ese caso podemos emplear recursos de interface.

En resumen, que las posibilidades son variadas, debiendo optar por aquella que mejor se ajuste a nuestras necesidades.

Otras macros que nos serán de utilidad en el manejo del contenido de un texto, aunque no tanto en su automatización son las siguientes:

• Seleccionar texto del documento (desde inicio del documento) (macro simple)

dispatcher.executeDispatch(document,".uno:EndOfDocumentSel", "", 0, Array())

El cursor se encuentra situado al inicio del documento y se desplaza hasta el final seleccionado todo el texto.

• Seleccionar texto del documento (desde final del documento) (macro simple)

dispatcher.executeDispatch(document, ".uno:StartOfDocumentSel", "", 0, Array())

El cursor se encuentra situado al final del documento y se desplaza hasta el inicio seleccionado todo el texto. 

• Seleccionar párrafo (desde el inicio del párrafo) (macro simple)

dispatcher.executeDispatch(document, ".uno:EndOfParaSel", "", 0, Array())

Posicionamos el cursor al inicio del párrafo.

• Seleccionar párrafo (desde el fin del párrafo) (macro simple)

dispatcher.executeDispatch(document, ".uno:EndOfParaSel", "", 0, Array())

Posicionamos el cursor al final del párrafo

• Seleccionar línea

dim args1(1) as new com.sun.star.beans.PropertyValue

args1(0).Name = "Count"

args1(0).Value = 1

args1(1).Name = "Select"

args1(1).Value = true

Desde el inicio (posición del cursor: inicio de la línea a seleccionar) (macro simple) 

dispatcher.executeDispatch(document, ".uno:GoDown", "", 0, args1())

Desde el final (posición del curso: línea inferior) (macro simple)

 dispatcher.executeDispatch(document, ".uno:GoUp", "", 0, args1())

También podemos crear macros de formato, con lo que automatizamos el formateo del texto según nos interese, y sin tener que hacerlo "manualmente". Estas son algunas de la macros de este tipo:

• Fuente (en el ejemplo: Verdana) (Macro simple)

dim args1(4) as new com.sun.star.beans.PropertyValue

args1(0).Name = "CharFontName.StyleName"

args1(0).Value = ""

args1(1).Name = "CharFontName.Pitch"

args1(1).Value = 2

args1(2).Name = "CharFontName.CharSet"

args1(2).Value = -1

args1(3).Name = "CharFontName.Family"

args1(3).Value = 5

args1(4).Name = "CharFontName.FamilyName"

args1(4).Value = "Verdana"

dispatcher.executeDispatch(document, ".uno:CharFontName", "", 0, args1())

• Tamaño (en el ejemplo: 12) (Macro simple)

dim args1(2) as new com.sun.star.beans.PropertyValue
args1(0).Name = "FontHeight.Height"
args1(0).Value = 12
args1(1).Name = "FontHeight.Prop"
args1(1).Value = 100
args1(2).Name = "FontHeight.Diff"
args1(2).Value = 0
dispatcher.executeDispatch(document, ".uno:FontHeight", "", 0, args1())

• Texto justificado (Macro simple)

dim args1(0) as new com.sun.star.beans.PropertyValue
args1(0).Name = "JustifyPara"
args1(0).Value = true
dispatcher.executeDispatch(document, ".uno:JustifyPara", "", 0, args1())

Con este conjunto de macros simples, y otros que vayamos creando, dispondremos de un conjunto de herramientas que, transformadas en su caso, y/o empleadas desde script, nos permitirán realizar composiciones de texto de cierta complejidad y con el mínimo conocimiento del lenguaje OOo Basic. Grabar macro trabaja por nosotros.

NOTAS

(1) Esta entrada se basa y sustituye a dos entradas publicadas originalmente el día 16/10/2023, tituladas respectivamente Writer. Trabajo con textos y Writer. Formateo de texto.
(2) En sentido estricto, si incluimos nuestra variable en el cuerpo de la macro, realmente la estamos convirtiendo en un script, ya que las macros generadas desde Grabar macro, no contienen variables de esa naturaleza, aunque admiten ser modificadas. En ese caso, personalmente prefiero considerarlas script, para no generar confusión entre unas y otros. De todas formas esto es mi opción, mientras que lo común es extender la denominación macro a todo segmento de código creado, de una u otra forma, sobre un documento (en este momento, un documento de texto, pero también sobre hojas de cálculo, presentaciones...