Lenguajes. R.

Conceptos básicos

Voy a tratar en esta entrada algunas cuestiones que se pueden considerar básicas para el trabajo con R. Me refiero concretamente al modo en que este lenguaje trabaja con la documentación que genera, esto es: al directorio de trabajo y a la creación y acceso a los script (1).

El directorio o carpeta de trabajo es el espacio de memoria de nuestro ordenador en el que se encuentran los archivos con los que estamos trabajando y donde R los buscará para cargarlos y grabarlos.

Para acceder a este directorio emplearemos la función getwd(), que se pasa sin especificar atributos y devuelve una cadena de texto con la ruta de acceso. Si se desea, se puede cambiar de directorio con la función setwd(), especificando el parámetro dentro del paréntesis; dicho parámetro consiste en una cadena de texto con la ruta deseada (vg. "setwd("C:\mi_directorio").

También podemos conocer el contenido del directorio de trabajo mediante la función list.files() (sin argumento), que muestra todos los archivos que contiene y mediante list.dirs() (sin argumentos), que muestra todos los subdirectorios.

Cada vez que ejecutamos R estamos creando una sesión de trabajo, que no es otra cosa que una instancia de su entorno. Todo lo que creemos en esa sesión se almacena en la memoria RAM del ordenador. Este modo de funcionamiento nos permite tener activa más de una sesión. 

Cuando cerramos R, también cerramos la sesión de trabajo correspondiente, pero podemos acceder a una sesión anterior accediendo al archivo .Rdata que genera, con lo que podremos continuar trabajando en su desarrollo.

Para conocer los objetos y funciones que contiene una sesión de trabajo emplearemos la función ls() (sin argumentos), que nos devuelve una lista con los identificadores de los objetos guardados (no los archivos). Dichos objetos configuran el entorno de trabajo de la sesión.

Estos conceptos son un tanto extraños para el profano y simplemente se pretende aquí que sea conocedor de su existencia y formas básicas de manejo; pero lo que no debe resultarnos extraño es el concepto de script, término al que ya estamos acostumbrados. Un script es un documento de texto con extensión .R (mi_script.R) que este lenguaje interpreta como propio. Como ya dije [en esta entrada], es aconsejable generar script como modo de guardar el trabajo desarrollado.

Para acceder desde la consola a un script creado usaremos la función source(), pasando como parámetro la ruta del mismo (vg source("C:/Mis_ScriptR/mi_script.R"), aunque RStudio proporciona formas más directas y conocidas de acceso (2).

Tanto por la simplicidad de su conformación básica como por el estilo de trabajo del lenguaje, R cuenta con múltiples paquetes o conjuntos de script con los que es posible realizar múltiples tareas. 

No obstante, la mayoría de estos paquetes no están cargados a priori en R, por lo que es necesario importarlos o instalarlos empleando la función install.packages() que recibe como argumento el nombre del paquete (vg install.packages("readr")). 

Una vez instalado, podrás hacer uso del paquete mediante la función library() (en el caso anterior library(readr)) (4); esto nos permite acceder y usar las funciones de dicho paquete.

NOTAS

(1) Sigo en estos temas a [Mendoza Vega, JB. R para principiantes]

(2) Que serán las que empleemos con más frecuencia: File | Open File, o File | Recent Files si se trata de script con los que hemos trabajado recientemente.

(3) Los paquetes oficiales de R se encuentran alojados en CRAN, lo cual nos garantiza que han pasado rigurosos controles antes de ser puestos a disposición de la comunidad de usuarios. Puedes acceder a CRAN desde [este enlace]. Desde [este otro] tienes acceso a un amplio listado de los paquetes disponible

(4) Observa que en la instalación el nombre del paquete es tratado como cadena de texto, por lo que va entrecomillado, pero no así al cargarlo mediante la función library(), por lo que ahora el argumento no se entrecomilla. Por claridad y estilo de trabajo, en R se debe usar la función library() cada vez que se desee trabajar con las funciones de un paquete; no basta con haberlo instalado para acceder a ellas.

Procedimientos. Macros.

Vincular macros o script a un objeto (2)

Además de un comando o a una hoja, también podemos asignar una macro/script a un objeto figura o imagen. Aunque aquí nos basemos en Calc, esa posibilidad activar un script no se limita a este servicio, ya que es posible insertar una forma o una imagen en cualquiera de los servicios LibreOffice.

Después de implementar una forma (Insertar | Forma) y/o una imagen (Insertar | Imagen) en la hoja, hacemos clic derecho sobre ella para seleccionara. Automáticamente se despliega un menú de opciones, dentro de las cuales tenemos la opción Asignar macro.

Haciendo en ella accedemos a un submenú donde se diferencia una ventana superior donde se identifica la única opción de evento disponible (Botón del ratón presionado). En la ventana inferior se encuentran los subdirectorios que contienen las distintas ubicaciones de macros posibles (Macro de). Deberemos hacer clic en aquella que contenga la macro que deseamos asociar a la forma/imagen y seleccionarla en Macros existentes.

Una vez seleccionada la macro/script deberemos hacer clic en el comando Asignar (lateral derecho de la ventana) y después en Aceptar (marco inferior). Estas dos acciones son necesarias para que se realice correctamente la asignación de la macro/script al objeto forma/imagen.

El documento Calc que ejemplifica este proceso consta de dos hojas: en la primera he implementado una figura y en la segunda una imagen. Los script (podemos decir, de ida y vuelta) permiten acceder uno a Hoja2 y otro a Hoja1. De este modo, al hacer clic en el cuadrado azul (Hoja1) nos desplazamos a Hoja2 (previamente se muestra esta hoja y después se oculta Hoja1). El proceso que desarrolla el script asociado a la imagen situada en Hoja2 realiza el proceso contrario.

Documento. En [este libro Calc] puedes encontrar ejemplificado el proceso descrito en la entrada, incluyendo los dos script que se activan desde los objetos gráficos insertados en sus dos hojas.

Procedimientos. Macros.

Vincular macros o script a un objeto (1)

Una vez que hemos creado una macro o un script, necesitamos hacer que funciones. La primera alternativa consiste en utilizar las opciones de la interface del servicio (Herramientas | Macros | Ejecutar macro), solución simple y funcional pero poco atractiva a día de hoy. La segunda consiste en asignar la macro/script a un comando de formulario (botón), que es la forma que más se asemeja al modo standard de trabajar con las interfaces visuales. Pero aun hay otras opciones.

Una forma un tanto especial y específico de las hojas de cálculo, consiste en asociar el script a la propia hoja. Para ello nos posicionamos en el navegador inferior de Calc y hacemos clic derecho sobre el nombre de una de las pestañas, la que representa la hoja a la que queremos asignar el script. 

Se visualiza la ventana emergente con el menú que vemos en la imagen superior y seleccionamos la opción Eventos de hoja. Haciendo clic en ella, accedemos a una ventana de selección de opciones de vinculación (eventos) (1)

Seleccionamos uno de estos eventos y  hacemos clic en Macros. A continuación podremos seleccionar la macro/script que nos interesa vincular a la página, seleccionarla y hacemos clic en Aceptar.

 

Nos devuelve a la ventana anterior (ahora con la macro seleccionada identificada en la columna Acción asignada) y volvemos a hacer clic en Aceptar.

De este modo la macro/script queda vinculada a la página en función del evento que hayamos escogido.

En el ejemplo que desarrollo como concreción del proceso anterior, he elegido el evento Activar documento y la macro Main. Esto implica que cuando Hoja1 sea la hoja activa se pondrán en marcha las instrucciones que contiene este script.

Sub Main

Dim oHoja As Object

oHoja = ThisComponent.getSheets.getByIndex(1)

oHoja.isVisible = True

Wait 500

oHoja = ThisComponent.getSheets.getByIndex(0)

oHoja.isVisible = False

Wait 500

oHoja = ThisComponent.getSheets.getByIndex(2)

oHoja.isVisible = True

Wait 500

oHoja = ThisComponent.getSheets.getByIndex(1)

oHoja.isVisible = False

Wait 500

oHoja = ThisComponent.getSheets.getByIndex(3)

oHoja.isVisible = True

Wait 500

oHoja = ThisComponent.getSheets.getByIndex(2)

oHoja.isVisible = False

End Sub

En resumen, se visibiliza (mostrar) una hoja, se espera 500 msg y se oculta la hoja precedente (2), con lo que la hoja visible pasa a ser también la hoja activa (3).

Documento. Este [libro Calc] contiene el código anterior asociado a Hoja1. Al abrir este documento, nos encontramos posicionados en Hoja4. Si nos desplazamos "manualmente" a Hoja1 se desarrollará el proceso esperado (4). 

NOTAS

(1) Si comparas los eventos posibles con los que se despliegan cuando trabajamos con el control de formulario Botón (Comando), verás que los eventos de hoja son mucho más limitados.

(2) Esto es así por trabajar con el índice de las hojas, lo que facilita la secuencia Mostrar-Ocultar.

(3) Este script contiene la instrucción Wait cuyo uso merece más atención de la que se le presta aquí. Será necesario analizarla específicamente en una entrada específica.

(4) Dado que se ocultan todas las hojas (menos Hoja4), para volver al estado inicial deberemos mostrar todas las hojas (Hoja | Mostar la hoja, seleccionamos todas las que se nos muestran y clic en Aceptar), pero mantendremos Hoja4 como hoja activa. Si guardamos el documento posicionándonos en Hoja1, de modo que al volver a activarlo estemos posicionados en ella, no se activará el script.

Procedimientos. datos.

Posicionarse en una hoja mediante OOo Basic

Con OOo Basic podemos trabajar sobre cualquier hoja del libro Calc con independencia de que sea sobre la hoja activa o sobre cualquiera de las demás. Eso supone una importante ventaja a la hora de crear un docap; pero muchas veces necesitamos posicionarnos visualmente sobre una hoja determinada. Mediante macros ya sabemos resolver este problema, pero también es conveniente hacerlo desde un script. En esta entrada vamos a aprender cómo.

Ya hemos visto [cómo trabajar con las hojas] de un libro Calc, pero esta opción no nos facilita visualizar la hoja (convertirla en la hoja activa), salvo que estemos trabajando sobre ésta. Para resolver esta dificultad hemos recurridos hasta ahora a una subrutina basada en macro, pero necesitamos hacerlo directamente desde un script OOo Basic. Veamos cómo esto es posible.

En principio podemos hacerlo identificando la hoja que deseamos visualizar (convertir en hoja activa) bien por su nombre, bien por su índice. El procedimiento es muy similar, en lo fundamental, así que explicaré una de las dos formas (por el nombre) y, sobre ese mismo script, indicaré las modificaciones que hay que realizar para acceder por el índice de la hoja.

Sub Ir_Hoja2Nombre ' Por el nombre

Dim DocCalc As Object

Dim Hoja As Object

DocCalc = ThisComponent

Hoja = DocCalc.getSheets().getByName("Hoja2")

DocCalc.CurrentController().SetActiveSheet(Hoja)

End Sub

Declaramos dos variables (DocCalc y Hoja), ambas de tipo Object, para asignar respectivamente el objeto documento Calc a la primera (DocCalc = ThisComponent) y el objeto Hoja a la segunda (Hoja = DocCalc.getSheets().getByName("Hoja2")); además identificamos es ésta a la hoja por su nombre mediante el método getByName() (.getByName("Hoja2")) (1)

Ya sólo nos falta convertir esa hoja seleccionada del libro en HojaActiva; para ello está la instrucción DocCalc.CurrentController().SetActiveSheet(Hoja). Con ella...

• mediante el método CurrentController() del objeto DocumentoActual (ThisComponent) que hemos asignado a la variable DocCalc (DocCalc.CurrentController())...
• implementamos a su vez el método SetActiveSheet(), que permite asignar la condición de HojaActiva al valor del parámetro asignado, que no es otro que el contenido en la variable objeto Hoja (SetActiveSheet(Hoja))

Si queremos realizar esta misma operación a partir del valor índice de la hoja, modificaremos la asignación de objeto a la variables Hoja, sustituyendo el método getByName() por el método .getByIndex() (2)

Documento. En [este libro Calc] encontrarás el código explicado en la entrada. En realidad contiene dos script: uno basado en el nombre de la hoja y otro en su valor índice.

NOTAS

(1) En nuestro caso, la hoja llamada Hoja2. Sin duda te habrás percatado de la posibilidad de convertir este script en una subrutina, transformado el nombre de la hoja en su parámetro. 

(2) Al que pasamos un valor numérico como parámetro, en nuestro caso, por mantener la similitud con el script anterior, ese valor es 1.

Procedimientos. Datos.

Calc. Uso de funciones dentro de los script.

Sabemos que Calc cuenta con un número elevado de funciones que podemos utilizar en este servicio para trabajar con datos, numéricos o alfanuméricos. Podemos reemplazar estas funciones mediante código OOo Basic, pero también tenemos la posibilidad de incluirlas en nuestros script, aprovechando así toda su potencia y ahorrándonos trabajo (1). 

Encontré el código que explicaré en esta entrada buscando precisamente cómo aprovechar las funciones Calc  en el código OOo Basic y, por lo que parece, no fui el único que se planteó una pregunta parecida (2). Cierto que no me ayudó a resolver el problema que tenía planteado, pero me ha parecido una solución muy interesante y de mucha utilidad, así que la comparto (3).

La base fundamental de este procedimiento consiste en hacer referencia en los script a las funciones Calc, pero no es la denominación con que se nos presentan en el servicio en su Asistente de funciones, sino en inglés; detalle éste importante para que funciones el código (4).

Se plantean dos opciones básicas: la que incorpora la función Calc en el script y la que lo hace mediante una función OOo Basic. Esta diferencia conlleva mucho más, como podremos ver más adelante, pero como primer criterio de diferenciación es relevante para que nos vayamos poniendo en situación.

Estas dos formas de trabajo se ejemplifican en los siguientes script. En el primero llamamos a una función para que "escriba" su resultado en una celda y después accedemos al contenido de esa celda para aprovechar el resultado de la función.

Sub PruebaFuncionCalc1a

Dim oHoja As Object

Dim dResulta As Double

oHoja = ThisComponent.CurrentController.ActiveSheet

oHoja.getCellRangeByName("B12").Formula = "=SUM(A1:A12)"

dResulta = oHoja.getCellRangeByName("B12").Value

MsgBox dResulta

End Sub

Tras declarar dos variables (oHoja y dResulta) y acceder al objeto Hoja (oHoja = ThisComponent.CurrentController.ActiveSheet), implementamos la fórmula (=SUM(A1:A12)) en la celda B12. Para ello añadimos al identificador de la celda el identificador Formula (oHoja.getCellRangeByName("B12").Formula = "=SUM(A1:A12)")

Una vez que la fórmula actúa y entrega su resultado en la celda establecida, accedemos a dicho resultado asignándolo a la variable dResulta (dResulta = oHoja.getCellRangeByName("B12").Value) (5). En este caso, lo que hacemos con el valor obtenido es mostrarlo mediante MsgBox (MsgBox dResulta), pero podríamos utilizarlo de cualquier otra forma, dependiendo del algoritmo de nuestro script.

El segundo modo de trabajo implica el uso de una función (FuncionCalc()) que es llamada desde un script (PruebaFuncionCalc2). Empecemos explicando el script:

Sub PruebaFuncionCalc2

Dim oHoja As Object

Dim dSuma As Double

oHoja = ThisComponent.getSheets().getByName("Hoja1")

dSuma = FuncionCalc( "SUM", Array(oHoja.getCellRangeByName("A1:A12")) )

MsgBox dSuma

 

End Sub

Tras declarar las dos variables necesarias (oHoja y dSuma) y acceder al objeto Hoja (oHoja = ThisComponent.getSheets().getByName("Hoja1")) recurrimos a la función (FuncionCalc()), asignando el dato que devuelve ésta a la variable dSuma. Dado que se trata de una función, cuenta (en este caso) con dos parámetros, que son los que pasamos por valor en la formulación de la llamada a la función (FuncionCalc( "SUM", Array(oHoja.getCellRangeByName("A1:A12")) )):

• El primero es el nombre de la función Calc (en inglés) ("SUM")
• Y el segundo, mucho más complejo, es la matriz de datos formada por el contenido del conjunto de celdas A1:A12, esto es: los datos que requiere la función Calc (Array(oHoja.getCellRangeByName("A1:A12"))) (6)

Después utilizamos el resultado devuelto por la función para mostrarlo en pantalla mediante MsgBox (MsgBox dSuma) (7)

 Veamos a continuación el código de la función FuncionCalc():

Function FuncionCalc( Nombre As String, Datos() )

Dim oSFA As Object

oSFA = createUnoService( "com.sun.star.sheet.FunctionAccess" )

FuncionCalc = oSFA.callFunction( Nombre, Datos() )

End Function

Observa que la función tiene dos parámetros, uno de tipo texto y otro una matriz (Nombre As String, Datos()): son los mismos a los que damos valor desde el script (( "SUM", Array(oHoja.getCellRangeByName("A1:A12")))).

Además, la función cuenta con una variable de tipo objeto (oSFA) a la que se asigna el objeto UnoService de acceso a las funciones de Calc FunctionAccess. (createUnoService( "com.sun.star.sheet.FunctionAccess")) Esta asignación se basa en la estructura típica de acceso a las funciones nucleares de la suite LibreOffice, que, como sabes, está escrita en parte en Java, esto es: en un lenguaje orientado a objetos (POO)

Siguiendo la sintaxis de las funciones, asignamos al identificador de la actual el resultado de aplicar la función nombrada a la matriz de datos; como recordarás, ambos han sido pasados por valor desde el scriot (FuncionCalc = oSFA.callFunction(Nombre, Datos())). De este modo la función devuelve al script, el resultado de dicha función. (8)

Dado que sólo he sabido manejar adecuadamente el primer modo de trabajo (ver nota 8), me limitaré a exponer cómo transformarlo para trabajar con otras funciones. Llamo a estos script PruebaFuncionCalc1b y PruebaFuncionCalc1c respectivamente. En el primero empleo una función Calc que actúa sobre un dato unitario (la función RAIZ()) y en el segundo trabajo con una función que trabaja con datos alfanuméricos, posicionados en una colección del celdas (no una matriz) (la función CONCATENAR()) (9).

Empecemos por el primer script y la función RAIZ()

Sub PruebaFuncionCalc1b

Dim oHoja As Object

Dim sResulta As Double

oHoja = ThisComponent.CurrentController.ActiveSheet

oHoja.getCellRangeByName("B15").Formula = "=SQRT(A15)"

dResulta = oHoja.getCellRangeByName("B15").Value

MsgBox dResulta

End Sub

 Como ves hay poco que añadir a lo visto en la explicación del script de base (PruebaFuncionCalc1a): únicamente sustituimos la expresión de la función anterior (SUM()) por la actual (SQRT()) (en inglés), con lo que no tienes mayor dificultad que recurrir al Asistente para funciones de Calc y traducir el nombre de la función al inglés. Los cambios de parámetros van incluidos en el procedimiento: para SUM() era necesaria una matriz de datos ("=SUM(A1:A12)") y para SQRT() únicamente una referencia a celda ("=SQRT(A15)")

El script PruebaFuncionCalc1c muestra la validez universal del procedimiento de sustitución que te acabo de explicar:

Sub PruebaFuncionCalc1c

Dim oHoja As Object

Dim sResulta As String

oHoja = ThisComponent.CurrentController.ActiveSheet

oHoja.getCellRangeByName("B20").Formula = "=CONCATENATE(A20;A21;A22)"

dResulta = oHoja.getCellRangeByName("B20").String

MsgBox dResulta

End Sub

De nuevo, es suficiente con escribir la sintaxis de la función Calc en la posición adecuada dentro del script para obtener el resultado deseado. 

Pero aun hay más: podemos combinar varias funciones dentro de la misma expresión, del mismo modo que es posible construir una combinación de funciones Calc. El script PruebaFuncionCalc1d es una prueba de ello.

Sub PruebaFuncionCalc1d

Dim oHoja As Object

Dim dResulta As Double

oHoja = ThisComponent.CurrentController.ActiveSheet

oHoja.getCellRangeByName("B13").Formula = "=SQRT(SUM(A1:A12))"

dResulta = oHoja.getCellRangeByName("B13").Value

MsgBox dResulta

End Sub

Aquí combinamos las funciones SQRT() y SUM() para obtener una función combinada en la que sobre la suma resultante de la matriz de datos A1:A12 solicitamos el cálculo de su raíz cuadrada ("=SQRT(SUM(A1:A12))"). El resultado se escribe en la celda B13. Como puedes comprobar, la sintaxis de la instrucción únicamente varía en la forma en que se llaman a ambas funciones, que es la misma que escribimos sobre la Línea de entrada de fórmulas de Calc.

Por tanto resulta evidente la ventaja de este modo de implementar funciones Calc en los script OOo Basic: es suficiente con escribir la fórmula según su sintaxis Calc, sustituyendo el nombre de la función por su equivalente en inglés. Es además importante establecer correctamente la referencia a los datos con los que trabajarán dichas funciones.

Documentos.

Pongo a tu disposición dos documento. El primero [FormulCalc.ods] es el documento Calc en el que puedes encontrar los ejemplos explicados en la entrada. El segundo [WIKI de OpenOffice] el enlace a la web donde encontrarás el listado de funciones Calc en inglés y en español.

NOTAS

(1) En algunas ocasiones esto puede ser así, pero en otras es preferible generar procedimiento propios, basados en OOo Basic, ya que son mucho más potentes y flexibles. No obstante, no es de despreciar lo que el uso de las funciones Calc nos puede ayudar a resolver problemas (especialmente de cálculos complejos) para los que no dispongamos de solución en un momento concreto. Toda ayuda es bienvenida.

(2) El material procede en primera instancia de la Web OpenOffice (en español), aunque los autores reconocen el mérito a Mauricio Baeza, del que son deudores. Y yo de ambos.

(3) A lo que aportan los autores anteriores añado de mi parte mi explicación del funcionamiento del código. Esta explicación no está disponible al menos en la primera de las referencias.

(4) Una contribución que añado para facilitarte el trabajo: el listado de funciones Calc en inglés y en español, cortesía de la WIKI de OpenOffice.

(5) Utilizamos .Value por tratarse de un resultado numérico. En caso de emplear una fórmula que devuelva un contenido alfanumérico emplearíamos .String. 

(6) Si tienes curiosidad, puedes comprobarlo escribiendo esa misma función en la Línea de entrada (de fórmulas) de Calc.

(7) Observa que, a diferencia del modo anterior, ahora no escribimos el resultado de la función en ninguna celda; no como paso previo para acceder a su resultado. Podríamos hacerlo, pero sería ya una decisión a posteriori, equivalente a mostrarlo por pantalla, que es la solución por la que optamos en este caso. 

(8) En principio podríamos sustituir la función SUM() por cualquiera otra que utilice como datos una matriz similar a la que emplea ésta, pero no resulta tan sencillo trabajar con funciones que actúan sobre otro tipo de estructuras. Al menos yo no he sabido hacerlo. Supongo que habrá forma de hacerlo y cuando lo averigüe lo expondré. 

(9) Te sugiero que, antes de seguir, refresques tu memoria haciendo uso de ambas funciones desde Calc. Así te resultarán familiares y comprenderás mejor los script en los que se incluyen.

OOo Basic

Primer script

En esta entrada vamos crear nuestro primer script con OOo Basic, el típico script con el que comienza toda andadura por el aprendizaje de los lenguajes de programación. Pero para ello deberemos saber dónde.

Al crear una macro nos hemos acercado al IDE, pero no terminamos de entrar en él porque no era necesario. Ahora sí.

El IDE (Entorno de Desarrollo Integrado) es la utilidad que nos permite trabajar con un lenguaje de programación. El ser OOo Basic un lenguaje de script interno y delimitado por la suite LibreOffice, su IDE se ubica y es accesible desde el propio entorno LibreOffice; desde la interface general y/o desde las interfaces de cada uno de sus servicios.

Nosotros vamos a trabajar (de momento) desde Writer, así que empezaremos creando un nuevo documento. Le daremos nombre (loDocumento1) y lo guardaremos en una carpeta que previamente habremos creado en nuestro Escritorio (1). De este modo empezaremos desde cero, que es la mejor forma de empezar.

Y lo haremos accediendo a Herramientas | Macros | Organizar macros | BASIC (2). Este es nuestro primer paso porque, al partir de un nuevo documento, como ya sabes, aun no se definido en él un espacio específico para nuestras macros y script.

En la ventana emergente hacemos clic (de nuevo) en Organizador y en la nueva ventanita seleccionamos el icono de nuestro documento (loPrimero.odt), en la crucecita que precede al nombre, y después en a que precede a la carpeta (Biblioteca) Standard  y hacemos clic en Nuevo (3). Surge una nueva ventanita que contiene un campo de texto con la palabra Module1 y tres botones: hacemos clic en Aceptar y automáticamente se crea Module1 dentro de Standard. Clic en Cerrar.

Si hacemos clic en Nuevo (ahora referido a macro/script, accederemos al contenido de las tres carpetas disponibles en el IDE: Mis macros y diálogos, Macros y diálogos de la aplicación y loPrimero.odt: ésta es la que nos interesa ahora. Seguimos el proceso ya conocido de selección y despliegue de componentes y terminamos accediendo a una pantalla  casi vacía: 

REM  *****  BASIC  *****

Sub Main

End Sub

Este será el "espacio" (documento) en el que crearemos nuestros script. Por el momento nuestro primer script, justo entre las instrucciones Sub Main y End Sub. Cuando finalicemos esto será lo que veamos:

Sub Main

    print "OOo Basic para orientadores"

End Sub

No es el típico saludo "Hola Mundo" pero cumple su misma función: anunciar(nos) que estamos empezando a aprender OOo Basic.

Ahora sitúa el cursos dentro del Sub y haz clic en la flechita verde situada encima de la palabra REM, o en Ejecutar | Ejecutar: obtendrás una ventana emergente que contiene la frase que hemos escrito. Este es nuestro primer script. Por ahora suficiente (4)

NOTA

(1) Es una sugerencia; tú puedes crearlo con el nombre que te parezca y guardarlo en donde creas oportuno. A tu cargo también la organización interna de esta carpeta y recordar dónde guardas tus archivos.

(2) Verás otras opciones de lenguajes, pero ahora no nos interesan, así que nos centramos en BASIC, que no es otra cosa que OOo Basic. Podemos nombrar nuestro módulo como deseemos, pero por ahora no nos vamos a detener en estos detalle, así que aceptaremos el nombre que se nos propone (Module1)

(3) Como vamos a crear un módulo, y es la opción por defecto, no me voy a referir ahora a las otras opciones (Diálogos y Bibliotecas)

(4) Cuando queras finalizar y acceder de nuevo al documento, sigue esta secuencia: Archivo | Guardar o Archivo | Cerrar. La segunda cierra el IDE sin guardar lo que hemos creado, así que te recomiendo que utilices la primera opción para no perder el trabajo realizado. Para finalizar del todo cerraremos nuestro documento loPrimero.odt de igual modo que cerramos cualquier otro documento Writer, guardando los cambios.

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