Interfaz. OOo Basic.

Diálogo (e) Casilla de verificación y botón de opción (1).

Ambos controles presentan una apariencia similar, pero se diferencian en su forma de funcionamiento y también en el modo en que podemos acceder al resultado de su manipulación por el usuario. Veámoslo con más detalle sobre un ejemplo de uso de Diálogo sobre Writer, aunque ya sabes que sería igual si trabajáramos con un documento Calc, por lo que esta explicación sirve para trabajar sobre ambos servicios.

Por lo que conocemos de los controles de un Formulario, ya sabemos que la diferencia entre una casilla de verificación (CheckBox) y un botón de opción (OptionButton) es que en la primera podemos seleccionar todas las casillas presentes en el Dialogo, pero sólo uno de los n botones de que esté compuesto el conjunto de opciones. De ahí que su funcionalidad dentro de la interfaz sea diferente, tal y como expresan los términos que les acompaña.

Voy a ejemplificar el uso y acceso a Casilla y botones. sobre un docap-simple basado en Writer que, como en el [caso anterior] permite crear un listado simple, al que ahora añadiremos...

• Mediante una casilla la especificación de si se trata de un alumno con PTI-ACS
• Y mediante botones si se trata de un alumno con apoyos de AL, PT o ambos.

Las diferencias entre Casilla y Botón se observan más en la construcción de ambas y en las peculiaridades de cada una de ellas como control que en el modo de trabajar con ambas. El primer aspecto no se trata en esta entrada, aunque algo se ha dicho antes sobre el funcionamiento diferenciado de estos dos controles, pero sí expongo a continuación el modo de acceder al contenido seleccionado por el usuario. Dado que es igual para cada Botón o Casilla, lo que explico para uno de estos elementos se debe entender aplicable al resto.

Iniciamos con la declaración de tres variables, por ejemplo, 

• Dim obtnPT As Object, para la asignación o referenciar el objeto Botón 
• Dim bPT As Boolean, para contener el valor del objeto (2)
• Dim sApoyo As String, para contener la implicación o resultado que deriva de dicho valor.

La declaración de las variables antecede a la apertura del diálogo, que en el ejemplo que desarrollo se concreta como llamada a la función  Abrir() que cuenta con un parámetro (nDlg), variable String en la que referenciar el nombre del Dialogo, tal y como se establece en la construcción de éste (Dialog1).

El segundo paso consiste en acceder al objeto Botón (o Casilla), lo que implica conocer el nombre del control, como sucede en el resto de los elementos del Diálogo. La función o método requerido para ello es getControl() y el parámetro requerido es el nombre del control ("btnPT")

• obtnPT = oDialogo.getControl("btnPT")

Esta segunda fase se desarrolla tras la apertura algorítmica del Diálogo y antes de visibilizarlo (ejecutarlo), por lo que anteceden a la instrucción oDialogo.execute().

A continuación, tras ejecutar el Diálogo, asigno a la variable Boolean  bPT el valor (True/False) resultante de la acción del usuario sobre el control, y que está contenido en el atributo State propio de los objetos Botón y Casilla.

• bPT = obtnPT.State

Este paso no es estrictamente necesario, ya que podemos utilizar directamente la expresión referenciada (obtnPT.State) en el proceso posterior, pero resulta de utilidad didáctica para entender mejor cómo se desarrolla el proceso. 

Finalmente hacemos uso de una estructura condicional (If) para explicitar lo que la elección del usuario implica cuando selecciona o no el control Botón. Aquí se impone la lógica del algoritmo, que es la que da sentido a la acción del usuario. Por ejemplo, en nuestro caso, si el usuario hace clic (selecciona) la opción que representa nuestro botón btnPT, lo que se expresa es que el alumno cuenta con apoyo de PT, luego, si hace esta elección, el State del control será True. En caso contrario será False. En función de esto, la variable que expresa en forma de texto esa implicación tendrá un valor u otro. Todo ello se expresa como sigue (3):

If bPT= True Then

sApoyo = "Apoyo especializado de PT"

ElseIf bAL = True Then

sApoyo = "Apoyo especializado de AL"

ElseIf bAmbos = True Then

sApoyo = "Apoyos especializados de PT y de AL"

Else

sApoyo = ""

End If

La pulsación de cada uno de los tres botones (activando a True su State) (4) se traduce en un valor (que se expresa como String) que se asigna a la variable de respuesta (sApoyo). En caso de no activarse ningún botón, sApoyo recibe como valor una cadena vacía.

Documento. [Lista simple]

En el IDE de este documento puedes encontrar el código que incluye el acceso a los controles Botón y Casilla implementados en el diálogo que se activa mediante el comando Dialogo Lista.

NOTAS

(1) Esta entrada resulta de la la actualización y modificación de una anterior publicada el 4/07/2023, a la que sustituye.

(2) Como veremos a continuación, el valor, que depende de que el usuario seleccione (True) o no (False) el botón (o la casilla) es, en consecuencia un valor booleano. Como se explica en nota 4, estas variables no son imprescindibles, pero permiten explicar mejor el procedimiento, de ahí que haga uso de ellas.

(3) Utilizo la formulación completa del condicional, tal y como se emplea para dar cuenta del conjunto de botones, no sólo del control que centra la explicación. De este modo se comprende mejor el procedimiento. En esto hay diferencia respecto al control Casilla, ya que al ser cada una independiente del resto, es necesario utilizar una estructura condicional independiente para cada una de ellas. No obstante, esta diferencia, aunque coherente con la lógica del funcionamiento diferencial de ambos controles, es más formal que real, puesto que también es posible (aunque no conveniente) utilizar una estructura condicional para cada botón.

(4) En el condicional If bPT= True Then se puede sustituir la variable bPT por la expresión que ésta referencia (obtnPT.State), con la que la expresión quedaría como sigue:  If obtnPT.State= True Then. De este modo se simplifica el algoritmo y se ahorra memoria RAM al eliminar la duplicidad espacio de memoria reservado para el mismo dato. No obstante prefiero (en este ejemplo y en función del carácter didáctico de esta la entrada) ser menos eficiente el el uso de RAM y más claro en la explicación del proceso. 

Intefaz. OOo Basic.

Diálogo (c) Cuadro de texto.

El Cuadro de texto (TxtField) es el control más usado en Formulario y en Diálogo para la entrada de datos por parte del usuario; cumple en esto la misma función que InputBox() pero con mayores opciones de formato y de funcionalidad. Además también es interesante acceder al modelo de objeto para introducir contenido mediante un script.

Con Cuadro de texto (Texto en adelante, para simplificar) iniciamos el mismo recorrido por controles de Diálogo que realizamos en otro momento por los controles de Formulario. Lo hacemos también ahora por el control de uso más frecuente en la fase input. Además, aunque hay dos formas de uso, la más frecuente es la de permitir entrada de información por parte del usuario. Sobre ella y la posterior captura del texto introducido trataremos a continuación.

La implementación del control Texto se realiza manualmente desde el IDE, al igual que sucede con su contenedor Diálogo, por lo que remito a [esta entrada] para recordar cómo proceder. Además al contrario que en Formulario, ahora sí es necesario añadir una [Etiqueta] como elemento informativo que facilita al usuario la comprensión del contenido que se espera en Texto (1) 

Lo que sigue es válido para cualquier documento que incluya un Diálogo, con independencia del servicio desde el que trabajemos. Yo lo haré sobre un documento Writer, reproduciendo (con alguna modificación) lo que muestra la imagen que sigue.

Aunque los pasos previos (crear script de acceso y cierre del Diálogo) los doy por sabidos, ya que han sido trabajados con detalle [(en una entrada anterior]. Así que pasaré directamente al trabajo con los controles de Texto.

El acceso al contenido de los controles de texto se puede plantear de diferentes formas. Aquí mostraré dos de ellas (en Documentos podrás ver ambas versiones). En la primera el acceso se realiza desde el script asociado al cierre del formulario y en la segunda desde el script de manejo del contenido que, a su vez, se asocia con el de acceso al diálogo. La diferencia fundamental entre ambos es que en la primera necesitamos que las variables Object de acceso a los controles Texto se declaren como públicas (al inicio del módulo), mientras que en segundo son variables privadas del script de acceso al contenido de los controles. 

Veamos en detalle la primera formulación, que consta de cuatro script:

• Uno para acceder al Diálogo (AbrirDialogo), que lleva el peso de acceder a los controles Texto
• Dos para cerrarlo (CerrarDiálogo y Cerrar). El primero lleva la carga de generar el sistema de acceso  al contenidos de los controles y su paso a variables de tipo String. El segundo es una subrutina llamada desde el primero.
• Y uno de escritura en el documento (Agenda), en realidad una subrutina de escritura llamada desde CerrarDialogo.

En esta formulación, aunque el peso del acceso a los controles se reparte entre AbrirDialogo y CerrarDialogo, es este último el que cumple la función principal, ya que contiene las variables String, captura en ellas el contenido de las variables Object y llama a las dos subrutinas auxiliares (Cerrar y Agenda)

La segunda formulación consta también de cuatro script, dos principales...

• AbrirDiálogo, que nos permite acceder al diálogo y a sus controles, pero que a diferencia de la formulación anterior, gestiona también el acceso a los dos script auxiliares, así como el acceso al contenido de los controles de texto.
• CerrarDialogo, que en esta versión tiene como única función lo que indica su nombre, perdiendo el protagonismo que tenía en la primera formulación.

... y dos secundarios, asociados, como dije antes, al script principal AbrirDialogo.

• La subrutina Abrir(nDialog As Stirng), cuya función es facilitar el acceso al diálogo que se le pase como parámetro desde el script principal.
• Y la subrutina Agenda(sTexto As String), cuya función es completar el proceso escribiendo en el documento el contenido textual creado en el script principal y pasado como parámetro.

Vistas ambas formas de acceso al texto contenido en los controles Texto, queda a tu decisión cual emplear. Personalmente prefiero la segunda por no hacer demasiado extensa la lista de variables públicas, por diferenciar el acceso al contenido del acceso al Diálogo y por diferenciar estos procesos anteriores  del de cierre del Diálogo. En mi opinión es un procedimiento más claro en cuanto a la lógica del algoritmo.

En cualquier caso, lo que queda claramente establecido es la secuencia de pasos a dar para acceder al contenido del control Texto:

• Primero: Accedemos a la librería que contiene el objeto Diálogo: DialogLibraries.LoadLibrary( "Standard")
• Segundo: Accedemos al objeto Diálogo propiamente dicho: oDialogo = CreateUnoDialog(DialogLibraries.Standard.getByName(nDialog))

Estos dos pasos son previos al acceso al control y son comunes al acceso a cualquier control. En la primera versión estos dos pasos son asumidos por el script AbrirDialogo y en la segunda corre a cargo de la subrutina  Abrir(nDialog As Stirng) que es llamada desde el script AbrirDiálogo, una vez establecido el nombre del Diálogo al que queremos acceder.

• Tercero: Accedemos a cada uno de los objetos control Texto que contiene el objeto contenedor Dialogo: oTxtNombre = oDialogo.getControl("txtNombre")

En ambas formulaciones, este proceso se desarrolla sobre el script AbrirDialogo una vez se ha accedido a éste y no antes, ya que de invertir el orden no podríamos acceder a los controles en tanto que son objetos que pertenecen al objeto que los contiene (el Dialogo). Sin embargo este acceso a los objetos control Texto precede a la propia visualización del Diálogo.

• Cuarto: Accedemos al contenidos de los controles Texto, lo que se concreta como acceso a su atributo .Text: sNombre = oTxtNombre.Text. La asignación de este contenido a una variable de tipo String es optativo, aunque facilita el posterior y diferenciado trabajo con ese contenido.

Aquí es donde más difieren ambas formulaciones: mientras que en la primera es un proceso que se desarrolla en CerrarDialogo, en la segunda es asumido por AbrirDialogo. No difieren en el tratamiento posterior que se hace de ese contenido, ya que ambas formulaciones generan un contenido textual resultante de la concatenación de las variables String que pasan como parámetro a la subrutina de escritura Agenda(). 

Es interesante observar la posición que ocupa este proceso en el desarrollo del script AbrirDialogo en la segunda formulación (en la primera no se aprecia este detalle al activarse previamente el script de apertura: El acceso al contenido del atributo .Text del control Texto se realiza una ver que se visualiza el objeto contenedor Dialogo (oDialogo.execute())y no antes.

Hemos visto hasta este punto cómo acceder al contenido textual introducido por el usuario en el control Texto, con lo que estamos en disposición de afrontar los procedimientos de trabajo que son más frecuentes en la práctica; pero también es conveniente aprender a introducir contenido en estos controles mediante código. No es ésta una forma de trabajo especialmente frecuente, pero sí resulta de interés en determinadas aplicaciones. Además es sencillo de hacer: es suficiente con invertir la dirección de la asignación en el momento en que accedemos al atributo .Text desde una variable String:

• Para asignar el contenido de Texto a una variable: sNombre = oTxtNombre.Text
• Para asignar a un control Texto el contenido textual de una variable: oTxtNombre.Text = sNombre

No obstante sí hay una diferencia importante entre ambos procesos: cuando aplicamos el primero (sNombre = oTxtNombre.Text) lo hacemos después de visualizar el Diálogo (después de oDialogo.execute()); pero cuando aplicamos el segundo (oTxtNombre.Text = sNombre), dar contenido a la variable String y asignarla al objeto control Texto (a su atributo Text) debe hacerse antes de visualizar el objeto Diálogo.

Documentos:

•  Agenda Tlf. simple. [Primera formulación]
• Agenda Tlf. simple. [Segunda formulación]

NOTAS

(1) Se puede decir que ambos controles (Etiqueta y en este caso Texto) forman una unidad. Lo mismo podremos decir del resto de los controles que se explicarán en entradas sucesivas.

Interfaz. OOo Basic.

 Diálogo (b). Etiqueta

Aunque un Formulario también puede contener etiquetas, al estar creado sobre el documento, es fácil suplir su función por la mera escritura de su contenido sobre el propio documento. En el caso del Diálogo esto no es posible, así que no queda otro remedio que utilizarlas.

En el Diálogo una etiqueta puede cumplir varias funciones, según cómo se configure: puede servir como información sobre el control que sigue, pero también puede considerarse un elemento informativo sobre qué se solicita con el diálogo, sobre el proceso a seguir o sobre los resultados obtenidos. En todos estos (segundos) casos, la etiqueta es mucho más que un mero auxiliar de otro control, asemejándose a las funciones de información que son propias de MsgBox (1)

Generalmente la etiqueta es un control estático, lo que significa que el contenido que le demos en la fase de construcción del diálogo es que que va a mantener en todo momento. En este supuesto el uso de Etiqueta se limita a su implementación en la fase de creación del Diálogo, con lo que casi no deberíamos decir aquí nada más (2). Y de hecho podríamos funcionar con este planteamiento incluso aunque necesitemos aportar información diferente (3) a lo largo del script (4); en este caso, aunque no es precisamente ejemplo de ahorro de recursos y de simplicidad, es posible crear varios diálogos cada uno con su(s) etiquetas, y en cada una con su propio texto. Pero también podemos modificar el contenido o texto que mostrar; en este caso ya no podemos hablar de la etiqueta como elemento estático. Veremos ahora cómo.

Para que una etiqueta presente un contenido textual diferente necesitamos acceder a su modelo de objeto, lo cual nos permite modificar algunas de sus características, incluyendo (para lo que nos interesa ahora) el contenido textual de la propia etiqueta.

Dim oEtq As Object

Dim sEtqConten As String 

sEtqConten = "Este es el texto que mostrará la etiqueta" 

oEtq = oDlg.detControl()"etqInicio")

With oEtq.getModel

.Label = sEtqConten

 End With

Este segmento de código ilustra el modo en que podemos modificar dinámicamente el contenido textual de Etiqueta y constituye la base para que este control deje de ser necesariamente estático. Mediante la manipulación del contenido de una variable (sEtqConten) y el acceso al modelo de objeto (y su atributo Label) podemos implementar el texto que deseemos sin necesitar crear tantos diálogos y etiquetas como información queramos dar. Esto es válido para personalizar dicho contenido, para modificarlo en función de determinadas condiciones o para mostrar sobre el mismo diálogo una sucesión de contenido informativo diferente.

En el último documento que te proporciono ejemplifico una secuencia de mensajes simples sobre un único diálogo que se presentan de forma sucesiva mediante un bucle (5).

Documentos:

• Diálogo con etiqueta estática
• Diálogos múltiples con etiquetas estáticas
• Diálogo con etiquetas dinámicas

NOTAS

(1) Cuando no se usa como función (MsgBox()), capacidad que no tiene la etiqueta.

(2) De hecho difícilmente estaría justificado dedicarle una entrada en este blog.

(3) Segundo(s) supuesto(s) del párrafo anterior: notas informativas sobre el proceso a seguir e información sobre resultados del procesamiento de datos. Esta segunda función no es muy frecuente, ya que lo normal es trasladar los resultados el propio documento sobre el que trabaja el script.

(4) Los dos primeros documentos son ejemplos de etiquetas estáticas, única (el primero) y múltiple (el segundo). Perfectamente podríamos hacer uso de MsgBox. Aunque usar etiquetas tiene ventajas de formato sobre MsgBox, en lo fundamental no nos aportan mucho más. Aunque esas ventajas pueden ser suficientes para preferirlas.

(5) Para que se produzca el cambio de saludo es necesario cerrar el Diálogo tantas veces como ciclos tiene el bucle (3)

Interfaz. OOo Basic.

Diálogo (d) Listbox.

Un cuadro de lista (listbox) (en adelante Lista) es un control de apariencia similar al cuadro de texto, pero cuyas entradas están establecidas mediante una lista de opciones entre las cuales debe escoger el usuario la que considere adecuada. Esta lista, a la vez que facilita la entrada de información, limita también las opciones de respuesta, por lo que resulta adecuado como control cuando se conocen de antemano las posibles respuestas.

Sobre la base del docap-agenda que creamos [anteriormente], vamos a crear en ésta un docap-Listado simple, con tres campos, dos mediante control cuadro de texto (1) y un tercero utilizando un control Lista. El documento-soporte será, con en los anteriores, un documento del servicio Writer y la utilidad supuesta del docap será la creación de un listado simple de alumnos con los datos nombre, apellidos y curso o nivel escolar. Los dos primeros se ajustan al control Cuadro de texto, pero para el segundo caben varias opciones, siendo una de ellas el control Lista, dado que son conocidos los valores de respuesta: los cursos escolares comprendidos entre 1º de EI2 y 6º de EP (2).

Considerado resuelto la implementación del control en el Diálogo, paso directamente a explicar el acceso a su contenido, procedimiento también válido para el trabajo con este control en un documento Calc.

Dim olstCurso As Object

Dim sCurso As String

olstCurso = oDialogo.getControl("lstCurso")

sCurso = olstCurso.SelectedItem

En relación con el control Lista...

• Declaramos dos variables, una de tipo Object (olstCurso As Object), para referenciar el objeto Lista (olstCurso = oDialogo.getControl("lstCurso"))
• y otra de tipo String (sCurso As String) para referenciar el elemento seleccionado dentro de los disponibles en el listado de opciones de Lista. (sCurso = olstCurso.SelectedItem)

Como puedes observar, la única diferencia entre trabajar con un Cuadro de texto y una Lista en cuanto al acceso al dato del control es que para ésta empleamos el atributo .SelectedItem. Además esa instrucción debe ubicarse después de haber accedido al dialogo, haber asociado los objetos-controles a sus respectivas variables-objeto y haber ejecutado la visualización del dialogo (oDialogo.execute()).

Documento. [Lista simple]

En el IDE de este documento puedes encontrar el código que incluye el acceso al control Lista implementado sobre el diálogo que se activa con el comando Dialogo Lista.

NOTAS

(1) No comentaré nada sobre ellos, ya que fueron explicados [en su momento].

(2) Empleo la abreviatura EI2 para referirme al segundo ciclo de la etapa de Educación Infantil, esto es: los curso EI 3 años (EI21), 4 años (EI22) y 5 años (EI23). Para los curso de Educación Primaria utilizaré las iniciales EP1 a EP6.

Interfaz. OOo Basic.

Diálogo (a)

Un Cuadro de diálogo (Diálogo en adelante) es un formulario emergente que, a diferencia del Formulario que vimos en las [entradas anteriores], no se construye sobre el documento sino desde el IDE, aunque también de forma manual. Un Diálogo es un contendor de controles, los mismos que podemos utilizar en el Formulario.

Sus funciones son tres: facilitar la visualización de mensajes, facilitar el input y, en algunos casos, generar información output, aunque la principal es facilitar el input (1)

En esta entrada vamos a crear un Diálogo, a visualizarlo en pantalla y a aprender a acceder a él mediante código OOo Baisc.

Después de crear el Diálogo desde el IDE, y tomando como referencia el tratamiento que del tema hace Mauricio Baeza (parte de una hoja Calc), explicaré el código OOo Basic necesario para visualizar/activar un diálogo mediante código:

• Acceso al cuadro de diálogo llamado Dialogo1 según Mauricio Baeza

Declaramos la variable oDialMau como pública (2) e iniciamos el script

Dim oDialMau As Object

Sub AccesoCuadroDialogo

 Cargamos la librería Standard en memoria

DialogLibraries.LoadLibrary( "Standard" )

Cargamos el Diálogo en memoria utilizando la función CreateUNODialog() y llamando al atributo DialogLibraries que a su vez llama al objeto biblioteca Standard y al dialogo Dialogo1 por el método getByName()

oDialMau = CreateUnoDialog( DialogLibraries.Standard.getByName("Dialogo1") )

 Mostramos el Diálogo

oDialMau.execute()

End sub

• El segundo método (3) es muy similar, aunque presenta alguna pequeña diferencia, como se puede ver:

Creamos la variable oDialMod como pública (2) e iniciamos el script

Dim oDialMod As Object

 

Sub Mostrar_Dialogo

Accedemos a la librería Standard, que es en la que se encuentra el objeto Cuadro de diálogo

   

DialogLibraries.LoadLibrary("Standard")

Cargamos en memoria (variable oDialMod) el objeto Dialogo1 mediante la función o procedimiento CreateUNODialog() y mediante DialogLibraries aplicada a la librería Standard, que es donde se ubica nuestro diálogo

oDialMod=CreateUNODialog(DialogLibraries.Standard.Dialogo1)

Ejecutamos (la visualización de) el diálogo

oDialMod.Execute()

End Sub

 Aunque lo interesante de un cuadro de diálogo es utilizarlo como medio input, no es hasta que lo cerramos que podemos acceder a su contenido, así que, para finalizar esta entrada, conviene aprender a cerrarlo.

Para cerrar un Diálogo nada más fácil que lo que sigue, que con los cambios debidos, esto es, la sustitución de la variable objeto oDialMau por la correspondiente en la formulación alternativa (oDialMod, o la que corresponda), sirve para cerrar cualquier diálogo (4):

Sub Cerrar_DialMau

   oDialMau.EndExecute()

   MsgBox "Has cerrado el diálogo según Mau", 64, "Diálogo en Calc"

End Sub

Ahora te dejo enlace al documento en cuyo IDE puedes encontrar el código que hemos estado trabajando: [EjemploDialogo](5). Descárgala para trabajar con ella. contiene más script que los expuestos, pero por el momento vale con que estudies los que trabajamos en esta entrada; del resto ya hablaremos en otras entradas.

NOTAS

(1) Las formas de trabajo en que se basan los lenguajes de script hace que el output sea fundamentalmente desarrollado sobre los propios documentos, por lo que la función output del Diálogo es de uso muy limitado.

(2) Las variables oDialMod  y DialMau las podemos declarar como públicas o como privada (entonces dentro del script), pero es preferible crearlas como públicas para poder desarrollar otros script que trabajen con el diálogo.

(3) La diferencia entre ambos script radica en cómo se formula la llamada al diálogo en concreto:

• Bien mediante el método getByName() con el que culmina la ejecución del método CreateUNODialog()
• Bien como parte del procedimiento CreateUNODialog(), que se concreta como DialogLibraries.Standard.Dialogo1

(4) Recuerda que para que funcione este script de cierre, la variable clave (oDialogo) debe haber sido declarada como pública, lo que implica que al inicio del módulo y fuera de un script.

(5) Recuerda que este código se crea sobre Calc, pero sirve también para Writer, Impress y Draw.