OOo Basic

Variables

Una orientadora, Mercedes, está colaborando con la Jefa de estudios del colegio elaborando informes escolares de una lista de alumnos y alumnas (el motivo ahora no es relevante). Mercedes piensa usar lo que estamos aprendiendo sobre LibreOffice y piensa crear un documento-base en Writer para elaborar los informes que recojan los datos de ese análisis. Veamos cómo lo podemos enfocar.

Después de investigar unos cuantos expedientes y una vez que se hace idea de cómo abordar el tema, Mercedes se plantea crear un documento-modelo para recoger toda la información. Hace un informe a modo de "ejemplo" y, después de revisarlo y reajustarlo, se plantea utilizarlo como base para construir los restantes. 

Aunque una Mercedes real posiblemente actuara de otro modo (1), nosotros vamos a suponer que quiere poner en práctica lo aprendido hasta ahora: crear macros y script.

Puesta a la tarea, Mercedes crea una primera macro a la vez que va escribiendo su documento. Supongamos que este texto es parte del inicio del documento:

Juan es actualmente alumno de 4º de E. Primaria en el C.P. Aurelia Sánchez (Santullano)

Activa Grabar macro, escribe el texto, finaliza la grabación, prueba su macro y observa que funciona según lo previsto. Pero ahora se le presenta un dilema: si quiere hacer ahora el informe de Luis se encuentra conque o utiliza su documento como documento-base y sustituye Juan por Luis o tiene que crear una macro para cada alumno. Evidentemente esta segunda opción no es razonable, ya que no le quita trabajo (2).

Supongamos que, a pesar de ello, crea una segunda macro, ahora con este otro texto:

Luis es actualmente alumno de 2º de E. Primaria en el C.P. Aurelia Sánchez (Santullano)

Comparemos ambos textos:

• Observamos que varían dos datos: el nombre del alumno y el curso.
• El resto permanece igual

Esos datos que varían (Juan - Luis y 4º - 2º) son las variables. Ambos pertenecen a dos conjuntos, el conjunto nombre y el conjunto curso, por lo que podemos entender que una variable, además de lo obvio (un dato que varía) también se puede entender como la denominación genérica de un conjunto de datos.

Pero desde la perspectiva de la programación, una variable es, en realidad, un identificador de un espacio de memoria RAM a cuyo contenido se accede utilizando ese identificador.

En todo caso, y con independencia de con qué conceptualización nos quedemos, usar variables nos va a permitir resolver de forma sencilla el problema de Mercedes: es suficiente con que sustituya el nombre concreto por un identificador como sNombre y el curso por sCurso para que no necesite cambiar en el texto ni el nombre ni el curso. Pero aun no sabemos cómo se hace eso.

Vamos a ver qué dice las macros que ha creado Mercedes. Para ello accedemos al IDE como sigue: 

• Herramientas | Macros  | Editar macros.
• Si no estamos ya en nuestro documento, Biblioteca Standard, Módule1 (por ejemplo), repetimos la selección que implica llegar hasta aquí...
• Y nos encontramos con el código siguiente:

sub InfoEscolar1

rem ----------------------------------------------------------------------

rem define variables

dim document   as object

dim dispatcher as object

rem ----------------------------------------------------------------------

rem get access to the document

document   = ThisComponent.CurrentController.Frame

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

rem ----------------------------------------------------------------------

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

args1(0).Name = "Text"

args1(0).Value = "Juan es actualmente alumno de 4º de E. Primaria del C.P. Aurelia Sánchez (Santullano)"

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

end sub

sub InfoEscolar2

rem ----------------------------------------------------------------------

rem define variables

dim document   as object

dim dispatcher as object

rem ----------------------------------------------------------------------

rem get access to the document

document   = ThisComponent.CurrentController.Frame

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

rem ----------------------------------------------------------------------

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

args1(0).Name = "Text"

args1(0).Value = "Luis es actualmente alumno de 2º de E. Primaria del C.P. Aurelia Sánchez (Santullano)"

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

end sub

Tenemos dos macros (Sub InfoEscolar1 y Sub InfoEscolar2) que son exactamente iguales, a excepción de la diferencia de nombre y curso que ya identificamos antes. Poca opción nos da esto para ahorrar tiempo. ¿Cómo podemos usar variables en este caso?.

Con el tiempo aprenderemos que una macro en realidad sí hace uso de variables, pero por ahora las que emplea no nos resuelven el problema. Y esta es la principal limitación de las macros, motivo por el que necesitamos aprender a trabajar con OOo Basic, incluso para mejorar (y simplificar) el uso de macros.

Como ya sabemos crear un script en OOo Basic, en esta entrada vamos a avanzar lo suficiente para resolver el problema a Mercedes:

• A continuación de la expresión dim dispatcher as object vamos a crear una línea en blanco (Intro) (en realidad dos líneas).
• Y escribimos Dim sNombre As String en la primera y Dim sCurso As String en la segunda (3). Ya tenemos creadas nuestras variables.
• A continuación buscamos línea...

args1(0).Value = "Juan es actualmente alumno de 4º de E. Primaria del C.P. Aurelia Sánchez (Santullano)"

• Y sustituimos  "Juan es actualmente alumno de 4º de E. Primaria del C.P. Aurelia Sánchez (Santullano)" por sNombre & " es actualmente alumno de " & sCurso & " de E. Primaria del C.P. Aurelia Sánchez (Santullano)" (es importante respetar el uso de las comillas y los espacios iniciales)

Con esto la segunda macro ya no es necesaria, así que la podemos borrar.

Mercedes dispone ya de variables en sustitución de los datos (nombre y curso), pero aun no puede sacar todo el partido posible de su descubrimiento: necesita un medio para introducir los datos concretos (Juan y Luis, por ejemplo). Para ello tiene que aprender a dar valor (asignar contenido o datos) a las variables, para ello...

 usar una función OOo Basic llamada InputBox(), asociándola a cada una de sus variables. Vemos cómo.

• A continuación de Dim sCurso As String generamos un salto de línea (mejor dos para que el código sea más visible) y escribimos estas dos líneas:

sNombre = "Juan"
sCurso = "4º" 

Con ellas estamos diciendo a OOo Basic que almacene en el espacio de memoria RAM identificado como sNombre el dato "Juan", de modo que cuando aparezca la expresión sNombre acceda a ese espacio de memoria, recupere su contenido (el dato "Juan" en este caso) y haga con él lo que corresponda (en nuestra "macro" escribir Juan antes de la cadena " es actualmente..."). Y lo mismo con sCurso.

Usar este procedimiento no es la mejor opción posible, ya que obliga a Mercedes a acceder al IDE y realizar las asignaciones pertinentes para cada informe, así que mejor buscamos otra solución más funcional: usaremos la función OOo Basic llamada InputBox(), asociándola a cada una de las variables. Vemos cómo:

• Sustituimos  sNombre = "Juan" por sNombre = InputBox("Nombre del alumno"
• Y hacemos lo mismo con sCurso

Ahora Mercedes ya no tiene que acceder al IDE, es suficiente escribir el nombre (y el curso) del alumno en espacio disponible en la ventanita emergente que genera la función InputBox() y que tendrá a su disposición de forma automática una vez que llame a la macro (Herramientas | Macros | Ejecutar macro)

Aunque parezca poco, en esta entrada hemos avanzado mucho:

• Hemos accedido a una macro e identificado en ella la información que nos interesa.
• Hemos aprendido a crear (declarar) y usar (asignar valor y sustituir el dato concreto por la variable) variables.
• Y hemos automatizado y generalizado la creación de un documento combinando una macro con unas variables, lo que equivale a decir que hemos aprendido (de momento empezado a aprender) cómo superar las limitaciones de las macros mediante su tratamiento con OOo Basic.
• Además hemos utilizado una función que facilita la fase Input del proceso básico de un script (Input - Procesamiento - Output) (4)

Evidentemente lo aprendido hasta ahora sobre las variables no es más que el principio, pero en las entradas que siguen seguiremos aprendiendo mucho más sobre ella. Por el momento te dejo para que descargues el documento [loPrimero.ods] con la macro modificada (InfoEscolar) según los pasos seguidos en esta entrada para que puedas estudiarla y crear tú las réplicas que te parezca (5).

NOTAS

(1) Una Mercedes real posiblemente se quedara aquí y se limitara a marcar los espacios de los datos que varían, manteniendo el resto del contenido, a modo de texto mutilado. No es mala opción y a la altura del proceso de aprendizaje en que nos movemos es posible que incluso sea la mejor opción. Excepción hecha del uso de la funcionalidad Combinar correspondencia, siempre que el documento no sea muy complejo. De todos modos (posiblemente sin saberlo) Mercedes está trabajando "manualmente" con variables (y constantes). No obstante nosotros vamos a darle más recorrido el tema y hacerlo un poco más complejo. Complicar lo sencillo es, a veces, una buena forma de aprender. 

(2) En realidad, aun en esta caricaturización de la situación crear una macro sí supone un ahorro de tiempo. Si el documento tiene cierta extensión, se aprecia la ventaja (relativa, pero real) que tiene Grabar macro: crear una macro que le dé forma y contenido evita tener que escribirlo todo desde cero. También es más estable, seguro y manejable que trabajar con un documento-modelo. Es necesario, eso sí, utilizar (por ejemplo) Editar | Buscar y reemplazar para ir modificando los datos que varíen (quedémonos con esto: datos que varían)

(3) También podemos escribir Dim sNombre As String, sCurso As String, pero por ahora nos interesa diferenciar ambas expresiones. Además seguramente habrás pensado que "alumno" no es un término correcto cuando tengamos que hacer el informe de Rosa, con lo que también podría ser considerada una variable. Pero, por didáctica nos limitaremos a las dos variables dichas.

(4) Como sin duda Mercedes es inteligente, se habrá dado cuenta además que, limpia de texto irrelevante, la sintaxis de la macro le permite crear todos los textos que se imagine, siendo suficiente con sustituir el párrafo de nuestra macro por cualquier otro texto, el cual puede haber creado previamente (copiar y pegar) o crearlo directamente sobre en el IDE. Esto incluye el uso de todas las variables que le interese. Sólo necesita copiar la macro, cambiar su nombre (Sub NuevoNombre) para no perder la macro original y realizar en args1(0).Value = a sustitución que propuse antes. Y todo ello sin necesidad de usar de nuevo Grabar macro. Eso sí que es un ahorro de tiempo.

(5) Para mayor claridad del ejemplo he borrado de la macro original todos los comentarios, que ahora son innecesarios, aunque es buena praxis comentar el código. Ya aprenderemos cómo. Originalmente esta macro se llamaba InfoEscolar1, pero como ahora no necesitamos crear una macro por cada informe que queramos crear, pasa a llamarse InfoEscolar.

OOo Basic

Primero, las macros.

El lenguaje OOo Basic se anuncia como lenguaje de macros, pero aunque esta consideración sea correcta en el sentido amplio que se da al término "macro", en sentido estricto y también práctico, puede dar lugar a confusión y conlleva un reduccionismo que afecta negativamente a la valoración de la potencialidad que tiene el conocimiento del lenguaje.

Por eso prefiero considerarlo simplemente como un lenguaje de programación orientado y delimitado a la creación de script dentro de la suite ofimática LibreOffice (1). De hecho uno puede trabajar con macros desde la funcionalidad Grabar macros y desconocer absolutamente OOo Basic, aunque lo que genera esa funcionalidad es precisamente una forma particular de código de este lenguaje.

El término "macro" es una simplificación de "macroinstrucción", que se puede entender como la ejecución unitaria y sucesiva de un conjunto de órdenes o instrucciones. Aunque también podemos entenderla instrumentalmente como lo que resulta de hacer uso de la funcionalidad Grabar macro. 

Es por eso considero que decir que OOo Basic es un  lenguaje de macros resulta insuficiente cuanto menos. 

Cierto es que el resultado de grabar una macro no deja de ser automatizar la ejecución de una serie de instrucciones que se presentan individualizadas e independientes cuando trabajamos directamente con el servicio (Writer, por ejemplo); pero OOo Basic es mucho más: permite hacer mucho más y resulta mucho más complejo, también útil y eficiente.

De hecho, mientras que para crear una macro no hace falta más que tener clara la secuencia de acciones que deseamos automatizar y activar la funcionalidad Grabar macro (2), crear un script, una subrutina o una función ni es posible desde Grabar macro ni se puede prescindir de conocer el lenguaje con el que se va a trabajar (en nuestro caso y como primera opción, OOo Basic).

Así que pasar de  crear una macro a crear código (script) es pasar de utilizar una funcionalidad avanzada incorporada al servicio (3) a adentrarse en el mundo de la programación. Para ello, como sabemos, hace falta lógica de programación y conocimiento del lenguaje. A facilitar lo primero dedicamos la sección [Programación] de este blog (también ésta en la que estamos) y la actual a iniciarnos en el conocimiento del lenguaje OOo Basic. En realidad ambas son complementarias.

Pero volvamos a las macros, porque a pesar de sus limitaciones (4) generan un abanico de posibilidades que posiblemente pasen desapercibidas al principio, cuando sólo somos usuarios de Grabar macro. Estas posibilidades se esconden en el IDE, espacio de trabajo que queda oculto a primera vista, especialmente si la propia funcionalidad Grabar macro permanece también oculta.

Esa posibilidad no es de descartar, ya que no tiene por qué estar activada en la configuración inicial de LibreOffice, así que será mejor que empecemos rasgando estos velos.

Sabemos que para acceder a Grabar macro debemos activar el menú Herramientas | Macros. La primera de sus opciones es precisamente Grabar macro, pero cabe la posibilidad de que no aparezca (5). En ese caso, lo primero que tenemos que hacer es hacerla visible. Para ello:

• Activamos la opción Herramientas | Opciones.
• Dentro de las que se nos ofrecen activamos LibreOffice | Avanzado
• Y en Opciones Java (a la derecha del menú anterior) encontramos Funcionalidades opcionales.
• La funcionalidad Activar grabación de macros (limitada) se encontrará no seleccionada. 
• La seleccionaremos (clic en el check list correspondiente) y haremos clic en Aplicar y en Aceptar para cerrar la ventana del menú.

Ahora Grabar macro estará disponible y se visualizará como primera opción de Macros, lo que nos permite activar la llamada grabadora de macros, que consiste en una pequeña ventanita emergente...

... en cuyo botón Finalizar grabación deberemos hacer clic cuando hayamos finalizado la secuencia de acciones que queremos automatizar. Lo que obtenemos como resultado es algo que resulta ciertamente confuso al no iniciado: visualizamos sin saberlo un acceso temporal al IDE, pero si no sabemos nada de su existencia es fácil que nuestra macro termine perdida sin que sepamos cómo acceder a ella cuando la necesitamos. Es necesario, por tanto, comprender el proceso a seguir.

Para ello vamos a simular que creamos una macro desde un nuevo documento. Por defecto, este documento no dispone aun de espacio propio para archivar la macro que creemos, algo que resulta imprescindible si deseamos que las macros queden vinculadas al propio documento (6).

Si creamos una macro activando Grabar macro y finalizamos el proceso tal y como expliqué antes, emerge automáticamente una ventana (una de las visualización del IDE, en realidad) que, por defecto, posicionará nuestra macro no en el documento desde el que la estamos creando, sino en Mis macros. Podemos guardarla ahí, pero es posible que después no sepamos cómo recuperarla, así que, al menos para empezar, es preferible guardarla en el propio documento.

Para ello, antes de finalizar el proceso, nos posicionaremos en el icono que representa nuestro documento (se sitúa al final del listado de componentes) y hacemos clic en Módulo Nuevo, aunque es suficiente con hacer clic en Guardar, ya que al no existir ningún módulo (ni carpeta o directorio), LibreOffice lo crea por defecto (Module1), después de crear el directorio Standard.

Ahora nuestro archivo consta (en el IDE) de una carpeta Standard y un módulo Module1 donde está guardada nuestra primera macro. Las siguientes que grabemos lo será en esta ubicación, pero deberemos tener cuidado de darles un nombre propio, ya que de no hacerlo asume Main (principal) como nombre por defecto para esta nuestra segunda macro (7)

Hasta aquí ya sabemos crear macros, pero hace falta usarlas, cosa que requiere un nuevo ajuste en el funcionamiento que por defecto tiene LibreOffice. Me refiero al nivel de seguridad con el que está inicialmente configurado, que impide la activación de macros (8). Como seguramente este será nuestro caso (en estos momentos), deberemos modificar esa configuración inicial. Para ello:

• Volvemos al menú Herramientas | Opciones
• Seleccionamos ahora Seguridad y (a la derecha) hacemos clic en Seguridad de macros.
• Se activa una ventana emergente que nos da cuatro opciones.
• Personalmente opto por Medio, por el control que me da sobre la activación o no de las macros. No recomiendo la opción Bajo por los riesgos que comporta ni Alto por lo que complica el uso de macros personales, que es nuestro objetivo.
• Sólo nos resta hacer clic en Aceptar para finalizar este proceso.

A partir de este momento, cuando carguemos en memoria un documento que contenga macros, antes de darnos acceso a él, LibreOffice nos informará que el documento contiene macros y nos dará la doble opción de activarlas no inhibirlas. Dado que pretendemos trabajar con nuestro código o con código de confianza (y sólo en esos dos casos) lo lógico es que permitamos la activación de macros, pero siempre será nuestra decisión y responsabilidad.

Toca ahora acceder a las macros que acabamos de crear para probar su funcionamiento. Para ello seguimos trabajando meramente con las funcionalidades de LibreOffice, ajenos aun a la creación de código y al código que, sin saberlo, hemos creado. Para ello:

• Seleccionamos la opción Herramientas | Macros | Ejecutar macro
• En la ventana emergente Selector de macros nos posicionamos en el icono que representa nuestro documento y hacemos clic en la crucecita que precede al icono.
• Se despliega su estructura de carpetas (biblioteca o librería Standard, es como se denomina a lo que aparece a continuación) y hacemos de nuevo clic en la crucecita que precede a Standard (9).
• Se muestra el contenido de Standard, en estos momentos únicamente Module1.
• Haciendo clic en Module1 se muestra en Nombre de macro (ventana a la derecha de Biblioteca) el listado de las macros que hayamos creado.
• Haciendo clic en una de las macros esta se activará y ejecutará en el documento la secuencia de acciones que hayamos grabado.

Estaremos un rato entretenidos grabando y activando macros; es necesario para familiarizarse con esta funcionalidad y con las posibilidades que tiene generar nuestras propias macros, pero aunque resulte entretenido y útil para determinadas necesidades, no tardaremos en descubrir también sus limitaciones (10). Por suerte OOo Basic no sólo nos permite superar esas limitaciones; también nos va a permitir integrar las macros como parte de nuestro propio código, con lo que lo hecho hasta ahora no es sólo un inocente divertimento (los hay mucho mejores, claro está) ni tiempo perdido.

Hasta aquí hemos aprendido a crear macros mediante la funcionalidad Grabar macro de LibreOffice, demostrando saber usar funcionalidades complejas de la suite; hemos activado esa opción (si no se encuentra disponible); sabemos guardar nuestras macros en el documento desde el que las creamos; sabemos también regular el nivel de seguridad con el que queremos trabajar en LibreOffice y, finalmente, somos capaces de activar nuestras macros para que trabajen por nosotros. 

No son pocas las habilidades que hemos desarrollado en tan poco tiempo, pero lo verdaderamente interesante y útil está aun por llegar. De momento, podemos dar un formato complejo a un texto, crear tablas, listados y contenido, pero también hemos podido comprobar que si queremos dirigir un documento a una persona concreta, citar por su nombre a un niño o a un profesor, informar de una hora y un lugar concretos o comentar los resultados del alumno en un área del currículo nos vemos obligados bien a crear una macro específica para cada caso, situación o contenido concreto... o a modificar el texto que crea la macro sustituyendo unos datos por otros. En estas circunstancias, Grabar macro es de relativa ayuda... o de ninguna. 

Como ya dije, OOo Basic nos permite superar esas limitaciones. Por eso es importante que aprendamos ahora los elementos básicos de este lenguaje. Una vez que los hayamos aprendido, podremos volver sobre nuestras macros (11) para aprovechar mucho y bien lo que nos aportan. Pero, de momento, deberemos hacer un alto en este camino y recorrer otro más largo, pero necesario y sumamente interesante. No se trata precisamente de la travesía de ningún desierto, aunque se requiere paciencia, estudio, práctica y esfuerzo. Merece la pena.

NOTAS

(1) También, y primeramente, OpenOffice. 

(2) Para los amigos: secuencia Herramientas | Macros | Grabar macro.

(3) Crear macro no es la única ni quizá la más útil de esa categoría de funcionalidades. Desde la perspectiva del usuario, particularmente interesante me parece Combinar correspondencia o el uso de formularios, ya que permiten dotar a los documentos de recursos muy interesantes de cara al trabajo de los profesionales de los SEO. No obstante, Grabar macro es la puerta lógica de acceso a la programación mediante OOo Basic, y eso nos permite ir mucho más allá en la creación de recursos ajustados a nuestras necesidades de lo que podemos avanzar con aquellas.

(4) De por sí, una macro no aporta gran cosa de utilidad, salvo quizá en procesos complejos de formato y la automatización de la escritura de contenido invariable. Es necesario recurrir al uso de variables para personalizar el contenido textual, algo que requiere conocimiento del lenguaje de programación. 

(5) En ese caso, la primera opción visible será Ejecutar macro, pero el usuario no iniciado en el uso de macros no obtendrá ninguna utilidad de ella, ya que no se pueden ejecutar macros que no se han creado. 

(6) Tendremos ocasión de comprobar que ésta no es la única opción, pero por el momento eso no nos interesa ni nos resuelve nuestro problema actual; al contrario, puede resultar engañoso.

(7) La primera es posible que haya sido guardada por defecto como Macro1. Si no queremos sustituirla por la segunda macro no la seleccionaremos. Hay que observar que en Nombre de macro consta aquella en que se ubica la funcionalidad Grabar macro, pero podemos cambiar ese nombre por cualquier otro (sin espacios en blanco), de modo que no sustituyamos una macro ya creada por la nueva.

(8) Esto es debido al riesgo que comporta el uso de código no seguro, categoría en la que se considera están las macros, dado que potencialmente pueden haber sido pensadas como software malicioso. Dado que somos nosotros quienes creamos macros en nuestro beneficio, este no es el caso, pero LibreOffice no lo sabe y cautelosamente no lo presupone.

(9) Como dije antes (7), y ahora concreto más, al crear nuestro Module1 se crea automáticamente este directorio que, por su naturaleza de contender de código, se denomina Biblioteca en español, pero que se conoce más como Librería por esa fea costumbre que tenemos los hispanos de traducir literalmente los términos ingleses (Library).

(10) En cuanto a utilidad estoy pensando en el formateo de documentos o en su estructuración, por ejemplo. Las limitaciones son evidentes, pero Grabar macro no deja de ser una buena solución definitiva en ciertos casos, provisional en otros y complementaria en tercer lugar.

(11) En ese momento, no muy lejano, sobre su código, que por ahora nos es completamente desconocido.

OOo Basic

Características del lenguaje OOo Basic

Aunque todos los lenguajes de programación tienen, en lo básico, mucho en común (y oportunidades tendremos de comprobarlo en las entradas de esta sección), OOo Basic (y también VBA) tiene características específicas que interesa conocer desde el inicio de su aprendizaje.

Este lenguaje procede del desarrollado para OpenOffice y se define como lenguaje de macros. Es fundamental entender lo que implica esta categorización, ya que, aunque la considero poco precisa y hasta cierto punto confusa, resumen lo que OOo Basic tiene de específico (insisto: también VBA): es un lenguaje para trabajar desde dentro de las suites OpenOffice y LibreOffice, desde cada uno de sus servicios (Writer, Calc...), como recurso para automatizar procedimientos.

Dentro de eso que se ha venido en llamar competencia digital docente, más específicamente en lo que se refiere a la lógica de programación competencia (un tanto olvidado, como ya tuve ocasión de [comentar]) y más en concreto aun en lo referido a la competencia ofimática ([ver al respecto]), el conocimiento orientado a la práctica de un lenguaje como OOo Basic nos permite hacer un uso mucho más potente y eficiente de unos recursos que (para los SEO) son fundamentales.

Fundamentales por la propia naturaleza de nuestras funciones y del trabajo cotidiano. Y fundamentales también por el ahorro de tiempo que supone lo que deriva de ese conocimiento: la posibilidad de automatizar los procedimientos de trabajo y la creación documental que conllevan. Esto viene a ser equivalente a decir incremento de la competencia ofimática.

El lenguaje OOo Basic aporta, por tanto, ciertas ventajas, aunque también presenta limitaciones que no tienen otros lenguajes de propósito general, no "encerrados" en la suite ofimática (1). Pero ahora me interesa destacar algunas de las innegables ventajas que, en mi opinión, hacen que merezca la pena trabajar con él:

• Usar OOo Basic (2) implica incrementar exponencialmente el aprovechamiento del conocimiento de los servicios de las suites ofimáticas. Dicho de otra forma, no partimos de cero, y estos conocimientos previos suponen tener andado un buen trecho del camino.
• En relación con lo anterior, los resultados que podemos obtener con OOo Basic son directamente aprovechables desde los propios servicios, con independencia de cuáles sean éstos y de la frecuencia y familiaridad de uso que tengamos de ellos (3)
• Las habilidades que se adquieren en el uso de funcionalidades de cierta complejidad se ven potenciadas con el conocimiento y uso de OOo Basic. La relación entre ambos (funcionalidades avanzadas y creación de script) es bidireccional: ambas se potencian, aunque puedan considerarse alternativas.

Podemos resumir todo lo anterior diciendo que OOo Basic como parte que es de la suite LibreOffice complementa y potencia sus funcionalidades, transformando lo que son simples documentos en una especie de aplicación o programa que, además de automatizar la generación de contenidos, incorpora procesos de análisis de datos de cierto nivel de complejidad, tanto como necesitemos o seamos capaces de desarrollar.

La ventaja para el profesional son evidentes: es él mismo el que, desde su conocimiento profesional y de sus específicas necesidades, desarrolla un recurso orientado a proporcionarle ayuda. Es por eso que, aunque podemos enmarcar el uso de OOo Basic dentro del desarrollo de la competencia ofimática, en realidad se supera ampliamente esta delimitación, ya que se adentra en el conocimiento y uso funcional de las habilidades de programación.

Cierto es que nada es gratis, y en este caso se requiere conocimiento del lenguaje. A ello está dedicado este apartado.

NOTAS

(1) Me refiero, por ejemplo, a Python. No es éste un tema que me interesa desarrollar ahora, ya que tiempo y espacio habrá para navegar por esos mares.

(2) O VBA para los que opten por MSO, que en esto del lenguaje no hay mucha diferencia de funcionalidad, aunque si de código, como también de servicios. La apuesta de la Administración educativa asturiana por los servicios de Microsoft no es un secreto. Sus razones tendrá, pero ni el precio ni la utilidad, ni siquiera la versatilidad pueden ser argumentos a favor de esta opción.

(3) Constato reiteradamente que la frecuencia de uso, por si misma, no permite incrementar el nivel de conocimiento que se tiene de ellos. Y lo que es igualmente limitante: los servicios realmente utilizados se limitan al procesador de texto y, muy en segundo lugar, de los servicios de creación de presentaciones. Las hojas de cálculo y no digamos las bases de datos son, en la práctica, auténticos desconocidos. Considero que esto evidencia la insuficiencia de considerar que el uso genera por si mismo un incremento conocimiento de las funcionalidades de las herramientas y consecuentemente un mayor aprovechamiento. Siendo esto así (y lo es), se hace aun más necesaria una formación específica sobre duchas funcionalidades, incluyendo la propia y específica sobre los mal llamados "lenguajes de macros". 

Procedimientos. Docap.

Docap basado en macros. (1)

La primera y más básica forma de crear un docap es utilizando el código resultante del uso de la funcionalidad Grabar macro (2). No obstante existen diferencias importantes entre el uso de la funcionalidad Grabar macro y la creación de un docap. De ello ya hemos hablado en la sección [Usos], y más concretamente en esta [entrada] y en las dos que la siguen, pero insistiremos en ello también aquí.

Empezando por esa insistencia, una diferencia no menor entre el uso de Grabar macro y la creación de un docap es que la primera no exige adentrarse en el IDE del servicio (Writer, por ejemplo) (3), pero crear un docap sí lo hace imprescindible. Las implicaciones de esto son muchas y muy importantes.

Por concretar y no repetir aquí lo ya explicado en otras entradas, me limitaré a exponer de forma resumida la creación de un docap partiendo del uso de macros simples, considerando ya conocido el procedimiento para crear un docap a partir de una única macro, así como el método de trabajo modular.

1. Una vez analizada la secuencia de acciones que necesitamos para el docap y creadas las macros individuales necesarias, creo el script gestor desde el que se llama (Call) a cada una de las macros en el orden y momento en que las necesitamos para completar el proceso.
2. Bien en cada una de las macros individuales, bien desde un script específico, se declaran las variables de datos y se utilizan los procedimientos para la interacción con el usuario (interface), a fin de posibilitar la entrada de datos.
3. La forma más simple de hacerlo es que el usuario acceda al IDE y realice directamente la asignación, sin emplear ningún recurso interface específico. Esta forma tiene la ventaja de hacer innecesaria cualquier sistema de interface, pero también exige un mayor grado de conocimiento del lenguaje de programación por su parte y como procedimiento puede resultar un tanto engorroso.
4. Una alternativa relativamente simple a lo anterior es proporcionar al usuario acceso a las variables mediante InputBox(). [Este docap] es ejemplo de esta segunda opción.
5. Al inicio del script gestor debemos llamar necesariamente al script en el que se asignan los objetos necesarios para el funcionamiento de las macro: las variables de tipo objeto deben haber sido declaras al inicio del código, fuera de cualquier macro y la asignación se realiza en un script específico:

dim document   as object

dim dispatcher as object

 Sub VarSis

    document   = ThisComponent.CurrentController.Frame

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

 End Sub

 El proceso que sigo para crear un docap basado en el uso modular de macros simples está descrito con detalle [en esta lista de You Tube]

NOTAS

(1) Entrada basada en otra previa, con el mismo título, publicada originalmente con fecha 30/09/2023.

(2) Utilizo el término "macro" en sentido restringido, esto es, como código resultante del uso de la funcionalidad Grabar macro a la que accede desde el menú [Herramientas|Macros|Grabar macro]. Si por algún motivo esta funcionalidad no estuviera activada, para tenerla disponible (se aconseja) se procederá como sigue: Herramientas|Opciones|LibreOffice|Avanzado y en el menú emergente activar la casilla Activar grabación de macros (limitada)

(3) En realidad, esta afirmación no es del todo exacta, aunque sí pertinente por las diferencias que se explican también en esta entrada. En todo caso, si no hemos creado previamente un módulo dentro del documento (que es lo que cabe esperar), al intentar grabar la macro nos exigirá realizar este proceso. Para ello se accede automáticamente al IDE y nos obliga a crear un Módulo nuevo. Para hacerlo correctamente deberemos tener decidido en qué directorio lo vamos a crear, siendo recomendable (en este momento) hacerlo sobre la "carpeta" Standard del documento con el que estamos trabajando. Por defecto, el sistema crea un módulo llamado Module1. Podemos cambiar el nombre por el que deseemos, pero para lo que estamos tratando aquí ese nombre es satisfactorio.

Usos. Textos.

Uso de macros para automatizar la escritura (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 en 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...

Usos. Textos

Automatizar la escritura de textos mediante OOo Basic.

Parece lógico empezar por explicar estos procedimientos con las herramientas disponibles desde el propio procesador de textos (en nuestro caso Writer), ya que es la herramienta a la que estamos acostumbrados y porque el paso de Grabar macro a la escritura de script desde el IDE del propio servicio nos permite avanzar mucho en este aprendizaje sin necesidad de hacer uso de otros lenguajes. De hecho podríamos limitarnos a usar OOo Basic como única herramienta para automatizar la composición de texto, sin más complicación, pero hacerlo nos limita para el desarrollo de otros aspectos de la competencia digital, así que no es nuestra opción. 

Así que, como hay que ir por partes y, a ser posible, que el avance tenga su lógica, inicio esta sección exponiendo diferentes formas de "trabajar" con textos y en la automatización de su composición con las herramientas más básicas y accesibles: macros y script OOo Basic.

Veremos en primer lugar y como prolongación de lo visto en la sección anterior y primera del capítulo Usos, cómo combinar el uso de macros y OOo Basic para desarrollar este proceso de automatización. Hay más que escritura en este proceso, así que también trataremos sobre el establecimiento de formatos y el desplazamiento por el documento. Precisamente en ambos, la combinación de macros y script resulta muy beneficiosa en términos de facilidad de creación de código y  simplicidad de uso.

Pasaremos después a trabajar exclusivamente con OOo Basic en cuanto cuenta con alternativas diferenciadas en la funcionalidad Grabar macro para el manejo y la escritura de textos.

Finalmente nos enfrentaremos a tareas específicas, que derivan de las "imposiciones" formales y de formato de algunos textos con los que tenemos que trabajar como documento-base (un ejemplo de ello, los modelos de informe o de dictamen, pero hay más) y abordaremos el modo de cumplimentar "campos" de contenido en ellos.

Además de escribir textos, es frecuente que los documentos contengan también tablas, por lo que resulta de interés saber cómo crearlas y cumplimentarlas, así cómo realizar desplazamientos por ellas de forma automatizada.