Guía básica OpenOffice programación

8/8/2020 Guía BÁSICA de OpenOffice.
org
Página 1
OpenOffice.org 3.2 Guía BÁSICA
https://translate.googleusercontent.com/translate_f 1/161
8/8/2020 Guía BÁSICA de OpenOffice.org
Página 2
Derechos de autor
El contenido de este documento está sujeto a la Licencia de documentación pública. Solo puedes usar esto
documento si cumple con los términos de la licencia. Ver:http://www.openoffice.org/licenses/PDL.html
Página 3
Contenido
Derechos de autor.................................................. .................................................. .................................................. .............................. 2
Prefacio................................................. .................................................. ... 5
1 Guía de programación BÁSICA de OpenOffice.org.................................................. .7

Acerca de OpenOffice.org Basic.................................................. .................................................. ............................................... 7
Usuarios previstos de OpenOffice.org Basic.................................................. .................................................. ........................... 8
Uso de OpenOffice.org Basic.................................................. .................................................. ............................................... 8
Más información.................................................. .................................................. .................................................. ................ 8
2 El lenguaje de OpenOffice.org BÁSICO.................................................. ...... 9

Descripción general de un programa básico.................................................. .................................................. .............................................. 9
Trabajar con variables.................................................. .................................................. .................................................. ... 11
Instrumentos de cuerda.................................................. .................................................. .................................................. ................................. 12
Números.................................................. .................................................. .................................................. ............................. 13
Valores booleanos.................................................. .................................................. .................................................. ..................dieciséis
Fecha y hora.................................................. .................................................. .................................................. ...................dieciséis
Matrices.................................................. .................................................. .................................................. .................................. 17
Alcance y vida útil de las variables.................................................. .................................................. ...................................... 20
Constantes.................................................. .................................................. .................................................. ............................ 21
Operadores.................................................. .................................................. .................................................. ............................ 22
Derivación.................................................. .................................................. .................................................. ........................... 23
Bucles.................................................. .................................................. .................................................. .................................. 25
Procedimientos y funciones.................................................. .................................................. .................................................. 27
Manejo de errores.................................................. .................................................. .................................................. .................. 30
Otras instrucciones.................................................. .................................................. .................................................. ............. 32
3 Biblioteca en tiempo de ejecución.................................................. ...................................... 35

Funciones de conversión.................................................. .................................................. .................................................. ....... 35
Instrumentos de cuerda.................................................. .................................................. .................................................. ................................. 38
Fecha y hora.................................................. .................................................. .................................................. ................... 40
Archivos y directorios.................................................. .................................................. .................................................. ......... 42
Cuadros de mensajes y entradas.................................................. .................................................. .................................................. .47
Otras funciones.................................................. .................................................. .................................................. ................ 49
4 Introducción a la API.................................................. ............................ 51

Objetos de red universal (UNO).................................................. .................................................. .................................. 51
Propiedades y métodos.................................................. .................................................. .................................................. .... 52
Página 4
Módulos, servicios e interfaces.................................................. .................................................. ....................................... 53
Herramientas para trabajar con UNO.................................................. .................................................. ........................................... 53
Descripción general de las interfaces centrales.................................................. .................................................. .......................................... 54
5 Trabajar con documentos.................................................. ......................... 59

El StarDesktop.................................................. .................................................. .................................................. ................ 59
Estilos y plantillas.................................................. .................................................. .................................................. ......... 66
6 documentos de texto.................................................. ...................................... 69

La estructura de los documentos de texto.................................................. .................................................. .................................... 69
Editar documentos de texto.................................................. .................................................. .................................................. ..75
Más que solo texto.................................................. .................................................. .................................................. ......... 81
7 documentos de hoja de cálculo.................................................. .......................... 91

La estructura de las hojas de cálculo . .................................................. .................................................. .......................................... 91
Editar documentos de hoja de cálculo.................................................. .................................................. ..................................... 107
8 Dibujos y presentaciones.................................................. .................. 111

La estructura de los dibujos.................................................. .................................................. ............................................... 111
Editar objetos de dibujo.................................................. .................................................. .................................................. 125
Presentaciones.................................................. .................................................. .................................................. .................... 128
9 gráficos (diagramas).................................................. ................................. 131

Usar gráficos en hojas de cálculo.................................................. .................................................. ........................................... 131
La estructura de los gráficos.................................................. .................................................. .................................................. ..132
Tipos de gráficos.................................................. .................................................. .................................................. ...................... 140
10 bases de datos.................................................. ............................................ 143

SQL: un lenguaje de consulta.................................................. .................................................. .................................................. ..143
Tipos de acceso a la base de datos.................................................. .................................................. ................................................ 143
Fuentes de datos.................................................. .................................................. .................................................. .................... 144
Acceso a la base de datos.................................................. .................................................. .................................................. .............. 146
11 diálogos.................................................. ................................................. 151

Trabajar con cuadros de diálogo.................................................. .................................................. .................................................. .... 151
Propiedades.................................................. .................................................. .................................................. ......................... 153
Eventos.................................................. .................................................. .................................................. ............................... 156
Elementos de control de diálogo.................................................. .................................................. .................................................. 161
12 formularios.................................................. .................................................. 167

Trabajando con formularios.................................................. .................................................. .................................................. ...... 167
Formularios de elementos de control.................................................. .................................................. .................................................. .170
Formularios de base de datos . .................................................. .................................................. .................................................. .............. 176
Página 5
Prefacio
Esta guía proporciona una introducción a la programación con OpenOffice.org Basic. Para sacarle el máximo partido a esto
libro, debe estar familiarizado con otros lenguajes de programación. Se proporcionan ejemplos extensos para ayudarlo
desarrolle rápidamente sus propios programas básicos de OpenOffice.org.
Nota: a lo largo de este documento, el directorio de instalación de OpenOffice.org se representa en sintaxis como
install-dir .
Página 6
1
CAPÍTULO 1
1 Guía de programación BÁSICA de OpenOffice.org
Esta guía proporciona una introducción a la programación con OpenOffice.org Basic. Para sacarle el máximo partido a esto
libro, debe estar familiarizado con otros lenguajes de programación. Se proporcionan ejemplos extensos para ayudarlo
desarrolle rápidamente sus propios programas básicos de OpenOffice.org.
Esta guía divide la información sobre la administración de OpenOffice.org en varios capítulos. Los primeros tres
Los capítulos le presentan OpenOffice.org Basic:
El lenguaje de OpenOffice.org Basic
Biblioteca en tiempo de ejecución
Introducción a la API
Estos capítulos proporcionan una descripción general de OpenOffice.org Basic y deben ser leídos por cualquier persona que desee escribir
Programas básicos de OpenOffice.org. Los capítulos restantes describen los componentes individuales del
API de OpenOffice.org con más detalle y se puede leer de forma selectiva según sea necesario:
Trabajar con documentos
Documentos de texto
Documentos de hoja de cálculo
Dibujos y presentaciones
Gráficos (diagramas)
Bases de datos
Diálogos
Formularios
Acerca de OpenOffice.org Basic

El lenguaje de programación OpenOffice.org Basic se ha desarrollado especialmente para OpenOffice.org y está firmemente
integrado en el paquete Office.
Como sugiere su nombre, OpenOffice.org Basic es un lenguaje de programación de la familia Basic. Cualquiera que tenga
anteriormente trabajó con otros lenguajes básicos, en particular con Visual Basic o Visual Basic para aplicaciones
(VBA) de Microsoft: se acostumbrará rápidamente a OpenOffice.org Basic. Grandes secciones de lo básico
Las construcciones de OpenOffice.org Basic son compatibles con Visual Basic.
El lenguaje de programación OpenOffice.org Basic se puede dividir en cuatro componentes:
El lenguaje de OpenOffice.org Basic: define las construcciones lingüísticas elementales, por ejemplo, para variables
declaraciones, bucles y funciones.
La biblioteca en tiempo de ejecución: proporciona funciones estándar que no tienen referencia directa a OpenOffice.org,
por ejemplo, funciones para editar números, cadenas, valores de fecha y archivos.
La API de OpenOffice.org (interfaz de programación de aplicaciones): permite el acceso a los documentos de OpenOffice.org
Página 7
Acerca de OpenOffice.org Basic
y permite que se creen, guarden, modifiquen e impriman.

El editor de cuadros de diálogo: crea ventanas de diálogo personales y ofrece la posibilidad de agregar elementos de control
y controladores de eventos.
Nota - VBA: la compatibilidad entre OpenOffice.org Basic y VBA se relaciona con OpenOffice.org Basic
idioma, así como la biblioteca en tiempo de ejecución. La API de OpenOffice.org y el Editor de diálogo no son compatibles con
VBA (la estandarización de estas interfaces habría hecho que muchos de los conceptos proporcionados en OpenOffice.org
imposible).
Usuarios previstos de OpenOffice.org Basic

El ámbito de aplicación de OpenOffice.org Basic comienza donde terminan las funciones estándar de OpenOffice.org.
Por lo tanto, las tareas rutinarias se pueden automatizar en OpenOffice.org Basic, se pueden hacer enlaces a otros programas, para
ejemplo a un servidor de base de datos, y las actividades complejas se pueden realizar con solo presionar un botón usando
guiones predefinidos.
OpenOffice.org Basic ofrece acceso completo a todas las funciones de OpenOffice.org, admite todas las funciones, modifica
tipos de documentos y ofrece opciones para crear ventanas de diálogo personales.
Uso de OpenOffice.org Basic

OpenOffice.org Basic puede ser utilizado por cualquier usuario de OpenOffice.org sin ningún programa o ayuda adicional. Incluso en
la instalación estándar, OpenOffice.org Basic tiene todos los componentes necesarios para crear sus propias macros básicas,
incluso:
El entorno de desarrollo integrado (IDE) que proporciona un editor para crear y probar macros.
El intérprete, que es necesario para ejecutar macros de OpenOffice.org Basic.
Las interfaces para varias aplicaciones de OpenOffice.org, que permiten el acceso directo a los documentos de Office.
Más información
Los componentes de la API de OpenOffice.org que se analizan en esta guía se seleccionaron en función de sus prácticas
beneficios para el programador de OpenOffice.org Basic. En general, solo se analizan partes de las interfaces. Para
imagen más detallada, ver la referencia de la API.
los La Guía del desarrollador describe la API de OpenOffice.org con más detalle que esta guía, pero está destinada principalmente
para programadores de Java y C ++. Cualquiera que ya esté familiarizado con la programación básica de OpenOffice.org puede
encuentre información adicional en la Guía del desarrollador sobre OpenOffice.org Basic y OpenOffice.org
programación.
Los programadores que deseen trabajar directamente con Java o C ++ en lugar de OpenOffice.org Basic deben consultar el
OpenOffice.org Developer's Guide en lugar de esta guía. La programación de OpenOffice.org con Java o C ++ es una
proceso considerablemente más complejo que programar con OpenOffice.org Basic.
8 OpenOffice.org 3.2 Guía BÁSICA · Marzo de 2010
Página 8
2
CAPITULO 2
2 El lenguaje de OpenOffice.org BASIC
OpenOffice.org Basic pertenece a la familia de lenguajes básicos. Muchas partes de OpenOffice.org Basic son idénticas
a Microsoft Visual Basic para Aplicaciones y Microsoft Visual Basic. Cualquiera que ya haya trabajado con
Estos lenguajes pueden acostumbrarse rápidamente a OpenOffice.org Basic.
A los programadores de otros lenguajes, como Java, C ++ o Delphi, también les resultará fácil familiarizarse
ellos mismos con OpenOffice.org Basic. OpenOffice.org Basic es una programación procedimental completamente desarrollada
lenguaje y ya no requiere estructuras de control rudimentarias, como GoTo y GoSub .
También puede beneficiarse de las ventajas de la programación orientada a objetos desde una interfaz en OpenOffice.org
Basic le permite utilizar bibliotecas de objetos externas. Toda la API de OpenOffice.org se basa en estas interfaces,
que se describen con más detalle en los siguientes capítulos de este documento.
Este capítulo proporciona una descripción general de los elementos y construcciones clave del lenguaje básico de OpenOffice.org, como
así como el framework en el que las aplicaciones y bibliotecas están orientadas a OpenOffice.org Basic.
Descripción general de un programa básico

OpenOffice.org Basic es un lenguaje de interpretación. A diferencia de C ++ o Delphi, el compilador básico de OpenOffice.org
No cree archivos ejecutables o autoextraíbles que sean capaces de ejecutarse automáticamente. En su lugar, ejecuta un
Programa básico de OpenOffice.org dentro de OpenOffice.org. Primero se comprueba el código para detectar errores obvios y luego
ejecutado línea por línea.
Líneas de programa
La ejecución orientada a líneas del intérprete básico produce una de las diferencias clave entre Basic y otras
lenguajes de programación. Considerando que la posición de los saltos de línea en el código fuente de Java, C ++ o Delphi
programas es irrelevante, cada línea en un programa básico forma una unidad autónoma. Llamadas a funciones, matemáticas
Las expresiones y otros elementos lingüísticos, como los encabezados de funciones y bucles, deben completarse en la misma línea.
que comienzan.
Si no hay suficiente espacio, o si esto da como resultado líneas largas, entonces varias líneas se pueden unir agregando
subraya _. El siguiente ejemplo muestra cómo se pueden vincular cuatro líneas de una expresión matemática:
LongExpression = (Expression1 * Expression2) + _ (Expression3 * Expression4) + _
(Expresión5 * Expresión6) + _ (Expresión7 * Expresión8)
Nota: El guión bajo debe ser siempre el último carácter de una línea vinculada y no puede ir seguido de un espacio o un
pestaña o un comentario, de lo contrario el código genera un error.
Página 9
Además de vincular líneas individuales, en OpenOffice.org Basic puede usar dos puntos para dividir una línea en varias
secciones, de modo que haya suficiente espacio para varias expresiones. Las asignaciones
a=1a=a+1a=a+1
se puede escribir de la siguiente manera:

a = 1: a = a + 1: a = a + 1
Comentarios
Además del código del programa a ejecutar, un programa básico de OpenOffice.org también puede contener comentarios
que explican las partes individuales del programa y brindan información importante que puede ser útil en un futuro
punto.
OpenOffice.org Basic proporciona dos métodos para insertar comentarios en el código del programa:
Todos los caracteres que siguen a un apóstrofe se tratan como comentarios:

Dim A 'Este es un comentario para la variable A
La palabra clave Rem , seguida del comentario:
Rem Este comentario es introducido por la palabra clave Rem.
Un comentario generalmente incluye todos los caracteres hasta el final de la línea. OpenOffice.org Basic luego interpreta el
la siguiente línea como una instrucción regular nuevamente. Si los comentarios cubren varias líneas, cada línea debe identificarse como un
comentario:
Dim B 'Este comentario para la variable B es relativamente largo
'y se extiende sobre varias líneas. los
Por tanto, el carácter de comentario debe repetirse
'en cada línea.
Marcadores
Un programa de OpenOffice.org Basic puede contener docenas, cientos o incluso miles de marcadores , que son nombres
para variables, constantes, funciones, etc. Cuando selecciona un nombre para un marcador, se aplican las siguientes reglas:
Los marcadores solo pueden contener letras latinas, números y guiones bajos (_).
El primer carácter de un marcador debe ser una letra o un guión bajo.
Los marcadores no pueden contener caracteres especiales, como ä â î ß.
La longitud máxima de un marcador es de 255 caracteres.
No se hace distinción entre caracteres en mayúscula y minúscula. El marcador OneTestVariable , para
ejemplo, define la misma variable como onetestVariable y ONETESTVARIABLE .
Sin embargo, hay una excepción a esta regla: se hace una distinción entre mayúsculas y minúsculas
caracteres para las constantes UNO-API. Se presenta más información sobre UNO enIntroducción al
API de OpenOffice.org.
Nota - VBA: Las reglas para construir marcadores son diferentes en OpenOffice.org Basic que en VBA. por
ejemplo, OpenOffice.org Basic solo permite caracteres especiales en los marcadores cuando se usa Option Compatible , ya que
pueden causar problemas en proyectos internacionales.
A continuación, se muestran algunos ejemplos de marcadores correctos e incorrectos:

Apellido 'Correcto
Apellido5 'Correcto (el número 5 no es el primer dígito)
Nombre 'incorrecto (no se permiten espacios)
DéjàVu 'Incorrecto (no se permiten letras como é, à)
5 Apellidos 'incorrectos (el primer carácter no debe ser un número)
Primero, nombre 'incorrecto (no se permiten comas ni puntos)
Incluir un nombre de variable entre corchetes permite nombres que de otro modo no se permitirían; por ejemplo,
espacios.
Dim [First Name] As String 'Espacio aceptado entre corchetes
Dim [DéjàVu] As Integer 'Caracteres especiales entre corchetes
Página 10
[Nombre] = "Andrew"
[DéjàVu] = 2
Trabajar con variables
Declaración de variable implícita
Los lenguajes básicos están diseñados para ser fáciles de usar. Como resultado, OpenOffice.org Basic permite la creación de una variable
mediante un uso simple y sin una declaración explícita. En otras palabras, existe una variable desde el momento en que
lo incluye en su código. Dependiendo de las variables que ya están presentes, el siguiente ejemplo declara
hasta tres nuevas variables:
a=b+c
Declarar variables implícitamente no es una buena práctica de programación porque puede resultar en un error
introducción de una nueva variable mediante, por ejemplo, un error de escritura. En lugar de producir un mensaje de error,
El intérprete inicializa el error de escritura como una nueva variable con un valor de 0. Puede ser muy difícil localizar errores de
este tipo en su código.
Declaración de variable explícita
Para evitar errores causados por una declaración implícita de variables, OpenOffice.org Basic proporciona un modificador llamado:
Opción explícita
Esto debe aparecer en la primera línea de programa de cada módulo y garantiza que se emita un mensaje de error si uno de
las variables utilizadas no se declaran. El modificador Option Explicit debe incluirse en todos los módulos básicos.
En su forma más simple, el comando para una declaración explícita de una variable es el siguiente:
Dim MyVar
Este ejemplo declara una variable con el nombre MyVar y la variante de tipo . Una variante es una variable universal que
puede registrar todos los valores imaginables, incluidas cadenas, números enteros, cifras de punto flotante y valores booleanos.
A continuación, se muestran algunos ejemplos de variables variantes:
MyVar = "Hello World" 'Asignación de una cadena
MyVar = 1 'Asignación de un número entero
MyVar = 1.0 'Asignación de un número de coma flotante
MyVar = Verdadero 'Asignación de un valor booleano
Las variables declaradas en el ejemplo anterior incluso se pueden usar para diferentes tipos de variables en el mismo programa.
Aunque esto proporciona una flexibilidad considerable, es mejor restringir una variable a un tipo de variable. Cuando
OpenOffice.org Basic encuentra un tipo de variable definido incorrectamente en un contexto particular, aparece un mensaje de error
generado.
Utilice el siguiente estilo cuando haga una declaración de variable vinculada a tipo:
Dim MyVar As Integer 'Declaración de una variable de tipo entero
La variable se declara como un tipo entero y puede registrar valores de números enteros. También puede utilizar lo siguiente
estilo para declarar una variable de tipo entero:
Atenuar MyVar% 'Declaración de una variable de tipo entero
La instrucción Dim puede registrar varias declaraciones de variables:

Atenuar MyVar1, MyVar2
Si desea asignar las variables a un tipo permanente, debe realizar asignaciones separadas para cada variable:
Atenuar MyVar1 como entero, MyVar2 como entero
Si no declara el tipo de una variable, OpenOffice.org Basic asigna a la variable un tipo de variante. por
Capítulo 2 · El lenguaje de OpenOffice.org BÁSICO 11
Página 11
Trabajar con variables
Por ejemplo, en la siguiente declaración de variable, MyVar1 se convierte en una variante y MyVar2 se convierte en un número entero:
Atenuar MyVar1, MyVar2 como entero
Las siguientes secciones enumeran los tipos de variables que están disponibles en OpenOffice.org Basic y describen cómo pueden
ser utilizado y declarado.
Instrumentos de cuerda
Las cadenas, junto con los números, forman los tipos básicos más importantes de OpenOffice.org Basic. Una cadena consiste
de una secuencia de caracteres individuales consecutivos. La computadora guarda las cadenas internamente como una secuencia de
números donde cada número representa un carácter específico.
De un conjunto de caracteres ASCII a Unicode
Los juegos de caracteres hacen coincidir los caracteres de una cadena con un código correspondiente (números y caracteres) en una tabla que
describe cómo la computadora debe mostrar la cadena.
El conjunto de caracteres ASCII
El conjunto de caracteres ASCII es un conjunto de códigos que representan números, caracteres y símbolos especiales por un byte.
Los códigos ASCII de 0 a 127 corresponden al alfabeto y a símbolos comunes (como puntos, paréntesis y
comas), así como algunos códigos especiales de control de la pantalla y la impresora. El juego de caracteres ASCII se usa comúnmente como
un formato estándar para transferir datos de texto entre computadoras.
Sin embargo, este conjunto de caracteres no incluye una gama de caracteres especiales utilizados en Europa, como â, ä e î, como
así como otros formatos de caracteres, como el alfabeto cirílico.
El conjunto de caracteres ANSI
Microsoft basó su producto Windows en el conjunto de caracteres del Instituto Nacional Estadounidense de Estándares (ANSI), que
se amplió gradualmente para incluir caracteres que faltan en el conjunto de caracteres ASCII.
Páginas de códigos
Los juegos de caracteres ISO 8859 proporcionan un estándar internacional. Los primeros 128 caracteres del conjunto de caracteres ISO
corresponden al juego de caracteres ASCII. La norma ISO introduce nuevos conjuntos de caracteres ( páginas de códigos ) para que
se pueden mostrar correctamente más idiomas. Sin embargo, como resultado, el mismo valor de carácter puede representar diferentes
personajes en diferentes idiomas.
Unicode
Unicode aumenta la longitud de un carácter a cuatro bytes y combina diferentes conjuntos de caracteres para crear un
estándar para representar tantos idiomas del mundo como sea posible. La versión 2.0 de Unicode ahora es compatible con
muchos programas, incluidos OpenOffice.org y OpenOffice.org Basic.
Variables de cadena
OpenOffice.org Basic guarda cadenas como variables de cadena en Unicode. Una variable de cadena puede almacenar hasta 65535
Pagina 12
caracteres. Internamente, OpenOffice.org Basic guarda el valor Unicode asociado para cada carácter. El trabajo
la memoria necesaria para una variable de cadena depende de la longitud de la cadena.
Declaración de ejemplo de una variable de cadena:

Dim Variable como cadena
También puede escribir esta declaración como:

Dim Variable $
Nota - VBA: al migrar aplicaciones VBA, asegúrese de que la longitud de cadena máxima permitida en
Se observa OpenOffice.org Basic (65535 caracteres).
Especificación de cadenas explícitas
Para asignar una cadena explícita a una variable de cadena, encierre la cadena entre comillas (").
Dim MyString como cadena
MyString = "Esto es una prueba"
Para dividir una cadena en dos líneas de código, agregue un signo comercial (el operador de concatenación) y el guión bajo
carácter de continuación al final de la primera línea:
MyString = "Esta cadena es tan larga que" & _
"se ha dividido en dos líneas".
Para incluir una comilla (") en una cadena, introdúzcala dos veces en el punto correspondiente:
MyString = "a" "-comilla". 'produce una "-comilla
Números
OpenOffice.org Basic admite cinco tipos básicos para procesar números:
Entero
Entero largo
Soltero
Doble
Moneda
Variables enteras
Las variables enteras pueden almacenar cualquier número entero entre -32768 y 32767 . Una variable entera puede tomar hasta dos
bytes de memoria. El símbolo de declaración de tipo para una variable entera es % . Cálculos que utilizan variables enteras
son muy rápidos y particularmente útiles para contadores de bucles. Si asigna un número de punto flotante a un entero
variable, el número se redondea hacia arriba o hacia abajo al siguiente número entero.
Declaraciones de ejemplo para variables enteras:

Atenuar variable como entero
Atenuar Variable%
Variables enteras largas
Las variables de entero largo pueden almacenar cualquier número entero entre –2147483648 y 2147483647 . Un entero largo
La variable puede ocupar hasta cuatro bytes de memoria. El símbolo de declaración de tipo para un entero largo es & . Cálculos
Página 13
Números
con variables enteras largas son muy rápidas y particularmente útiles para contadores de bucle. Si asigna un punto flotante
número a una variable de entero largo, el número se redondea hacia arriba o hacia abajo al siguiente número entero.
Declaraciones de ejemplo para variables enteras largas:

Dim Variable tan largo
Dim Variable y
Variables simples
Las variables individuales pueden almacenar cualquier número de punto flotante positivo o negativo entre 3,402823 x 10 38 y 1,401298 x
10 -45 . Una sola variable puede ocupar hasta cuatro bytes de memoria. El símbolo de declaración de tipo para una sola variable es ! .
Originalmente, las variables simples se usaban para reducir el tiempo de cálculo requerido para las variables dobles más precisas.
Sin embargo, estas consideraciones de velocidad ya no se aplican, lo que reduce la necesidad de variables únicas.
Declaraciones de ejemplo para variables individuales:

Variable de atenuación como única
¡Variable tenue!
Variables dobles
Las variables dobles pueden almacenar cualquier número de punto flotante positivo o negativo entre 1.79769313486232 x 10 308
y 4.94065645841247 x 10 -324 . Una variable doble puede ocupar hasta ocho bytes de memoria. Las variables dobles son
Adecuado para cálculos precisos. El símbolo de declaración de tipo es # .
Declaraciones de ejemplo de variables dobles:

Dim Variable como doble
Dim Variable #
Variables de moneda
Las variables de moneda difieren de los otros tipos de variables por la forma en que manejan los valores. El punto decimal es fijo
y va seguido de cuatro lugares decimales. La variable puede contener hasta 15 números antes del punto decimal. UNA
La variable de moneda puede almacenar cualquier valor entre -922337203685477.5808 y +922337203685477.5807 y toma
hasta ocho bytes de memoria. El símbolo de declaración de tipo para una variable de moneda es @ .
Las variables de moneda están destinadas principalmente a cálculos comerciales que producen errores de redondeo imprevisibles debido a
el uso de números de coma flotante.
Declaraciones de ejemplo de variables monetarias:

Dim Variable como moneda
Dim Variable @
Advertencia: el manejo del tipo de moneda básica no es confiable.Edición 31001 Edición 54049 Edición 91121 Edición
107277 aún no se han corregido en OpenOffice.org versión 3.1.1.
Carrozas
Los tipos simple, doble y moneda a menudo se conocen colectivamente como flotantes o tipos de números de punto flotante.
Pueden contener valores numéricos con fracciones decimales de diversa longitud, de ahí el nombre: El punto decimal
parece poder "flotar" a través del número.
Puede declarar variables del tipo float. El tipo de variable real (simple, largo, moneda) se determina el
momento en que se asigna un valor a la variable:
Página 14
Números
Dim A como flotador

A = 1210,126
Especificación de números explícitos
Los números se pueden presentar de varias formas, por ejemplo, en formato decimal o en notación científica, o incluso con un
base diferente al sistema decimal. Las siguientes reglas se aplican a los caracteres numéricos en OpenOffice.org
Básico:
Números enteros
El método más simple es trabajar con números enteros. Se enumeran en el texto fuente sin una coma
separando la cifra de mil:
Dim A como entero
Dim B como flotador
A = 1210
B = 2438
Los números pueden ir precedidos por un signo más (+) o menos (-) (con o sin un espacio entre ellos):
Dim A como entero
Dim B como flotador
A = + 121
B = - 243
Numeros decimales
Cuando escriba un número decimal, utilice un punto (.) Como punto decimal. Esta regla asegura que los textos fuente puedan ser
transferidos de un país a otro sin conversión.
Dim A como entero
Dim B como entero
Dim C como flotador
A = 1223,53 'se redondea

B = - 23446.46 'se redondea
C = + 3532,76323
También puede usar signos más (+) o menos (-) como prefijos para números decimales (nuevamente con o sin espacios).
Si se asigna un número decimal a una variable entera, OpenOffice.org Basic redondea la cifra hacia arriba o hacia abajo.
Estilo de escritura exponencial
OpenOffice.org Basic permite que los números se especifiquen en el estilo de escritura exponencial, por ejemplo, puede escribir
1.5e-10 para
el número 1.5 x 10 -10 (0.00000000015). La letra "e" puede ser minúscula o mayúscula con o
sin un signo más (+) como prefijo.
Aquí hay algunos ejemplos correctos e incorrectos de números en formato exponencial:

Dim A como doble
A = 1,43E2 'Correcto
A = + 1.43E2 'Correcto (espacio entre el signo más y el número básico)
A = - 1.43E2 'Correcto (espacio entre menos y número básico)
A = 1,43E-2 'Correcto (exponente negativo)
A = 1,43E -2 'Incorrecto (no se permiten espacios dentro del número)
A = 1,43E-2 'Incorrecto (no se permiten comas como puntos decimales)
A = 1.43E2.2 'Incorrecto (el exponente debe ser un número entero)
Tenga en cuenta que en el primer y tercer ejemplo incorrecto, no se genera ningún mensaje de error aunque las variables
Página 15
Números
devuelve valores incorrectos. La expresion

A = 1,43E -2
se interpreta como 1,43 menos 2, que corresponde al valor -0,57. Sin embargo, el valor 1,43 x 10 -2
(correspondiente a 0,0143) era el valor previsto. Con el valor
A = 1,43E2,2
OpenOffice.org Basic ignora la parte del exponente después del punto decimal e interpreta la expresión como
A = 1,43E2
Valores hexadecimales
En el sistema hexadecimal (sistema de base 16), un número de 2 dígitos corresponde exactamente a un byte. Esto permite
los números deben manejarse de una manera que refleje más de cerca la arquitectura de la máquina. En el sistema hexadecimal,
los números del 0 al 9 y las letras de la A a la F se utilizan como números. Una A representa el número decimal 10, mientras que el
la letra F representa el número decimal 15. OpenOffice.org Basic le permite usar números hexadecimales enteros
valores, con tal de que son precedidos por & H .
Dim A tan largo
A = & HFF 'Valor hexadecimal FF, corresponde al valor decimal 255
A = & H10 'Valor hexadecimal 10, corresponde al valor decimal 16
Valores octales
OpenOffice.org Basic también comprende el sistema octal (sistema de base 8), que utiliza los números del 0 al 7. Usted
debe utilizar números enteros que van precedidos de & O .
Dim A tan largo
A = & O77 'Valor octal 77, corresponde al valor decimal 63
A = & O10 'Valor octal 10, corresponde al valor decimal 8
Valores booleanos
Las variables booleanas solo pueden contener uno de dos valores: Verdadero o Falso . Son adecuados para especificaciones binarias.
que solo puede adoptar uno de dos estados. Un valor booleano se guarda internamente como un valor entero de dos bytes, donde 0
corresponde a False y cualquier otro valor a True. No existe un símbolo de declaración de tipo para las variables booleanas.
La declaración solo se puede realizar utilizando el suplemento As Boolean .
Declaración de ejemplo de una variable booleana:

Atenuar variable como booleana
Fecha y hora
Las variables de fecha pueden contener valores de fecha y hora. Al guardar los valores de fecha, OpenOffice.org Basic utiliza un
formato que permite comparaciones y operaciones matemáticas sobre valores de fecha y hora. No hay tipo
símbolo de declaración para variables de fecha. La declaración solo se puede realizar utilizando el suplemento As Date .
Declaración de ejemplo de una variable de fecha:

Dim Variable como fecha
dieciséis OpenOffice.org 3.2 Guía BÁSICA · Marzo de 2010
Página 16
Matrices
Matrices
Además de las variables simples (escalares), OpenOffice.org Basic también admite matrices (campos de datos). Un campo de datos
contiene varias variables, que se abordan mediante un índice.
Definición de matrices
Las matrices se pueden definir de la siguiente manera:
Matrices simples
Una declaración de matriz es similar a la de una declaración de variable simple. Sin embargo, a diferencia de la declaración de variable,
el nombre de la matriz va seguido de paréntesis que contienen las especificaciones para el número de elementos. los
expresión Dim MyArray (3) declara una matriz que tiene cuatro variables del tipo de datos variante, a saber
MyArray (0) , MyArray (1) , MyArray (2) y MyArray (3) .
También puede declarar variables específicas de tipo en una matriz. Por ejemplo, la siguiente línea declara una matriz con cuatro
variables enteras:
Dim MyInteger (3) como entero
En los ejemplos anteriores, el índice de la matriz siempre comienza con el valor inicial estándar de cero. Como un
Como alternativa, se puede especificar un rango de validez con valores iniciales y finales para la declaración del campo de datos. El seguimiento
ejemplo declara un campo de datos que tiene seis valores enteros y que se puede direccionar usando los índices 5 a 10:
Atenuar MyInteger (5 a 10) como entero
No es necesario que los índices sean valores positivos. El siguiente ejemplo también muestra una declaración correcta, pero con
límites de campo de datos negativos:
Atenuar MyInteger (-10 a -5) como entero
Declara un campo de datos enteros con 6 valores que se pueden direccionar utilizando los índices -10 a -5.
No hay límites prácticos en los índices o en el número de elementos en una matriz, siempre que haya suficientes
memoria:
Dim s (-53000 a 89000) como cadena
s (-52000) = "aa"
s (79999) = "bb"
imprimir s (-52000), s (79999)
Nota - VBA: a veces se aplican otros valores límite para índices de campos de datos en VBA. Lo mismo se aplica también a la
número máximo de elementos posibles por dimensión. Los valores válidos allí se pueden encontrar en el VBA correspondiente.
documentación.
Valor especificado para el índice de inicio
El índice de inicio de un campo de datos generalmente comienza con el valor 0. Alternativamente, puede cambiar el índice de inicio para todos
declaraciones de campo de datos al valor 1 mediante la llamada:
Opción Base 1
La llamada debe incluirse en el encabezado de un módulo si desea que se aplique a todas las declaraciones de matriz en el módulo.
Sin embargo, esta llamada no afecta a las secuencias UNO que se definen a través de la API de OpenOffice.org cuya
El índice siempre comienza con 0. Para mejorar la claridad, debe evitar el uso de Option Base 1.
El número de elementos en una matriz no se ve afectado si usa Option Base 1 , solo cambia el índice de inicio. los
declaración
Opción Base 1
'...
Página 17
Matrices
Dim MyInteger (3)
crea 4 variables enteras que se pueden describir con las expresiones MyInteger (1) , MyInteger (2) ,
MyInteger (3) y MyInteger (4) .
Nota - VBA: en OpenOffice.org Basic, la expresión Option Base 1 no afecta el número de

elementos en una matriz como lo hace en VBA. Es, más bien, el índice de inicio que se mueve en OpenOffice.org Basic. Mientras
la declaración MyInteger (3) crea tres valores enteros en VBA con los índices 1 a 3, la misma declaración
en OpenOffice.org Basic crea cuatro valores enteros con los índices 1 a 4. Al usar Option Compatible ,
OpenOffice.org Basic se comporta como VBA.
Campos de datos multidimensionales
Además de los campos de datos unidimensionales, OpenOffice.org Basic también admite el trabajo con
Campos de información. Las dimensiones correspondientes están separadas entre sí por comas. El ejemplo Dim
MyIntArray (5, 5) Como Integer define una matriz de enteros con dos dimensiones, cada una con 6 índices (se puede direccionar
a través de los índices 0 a 5). Toda la matriz puede registrar un total de 6 x 6 = 36 valores enteros.
Puede definir cientos de dimensiones en OpenOffice.org Basic Arrays; sin embargo, la cantidad de
la memoria limita el número de dimensiones que puede tener.
Cambios dinámicos en las dimensiones de los campos de datos
Los ejemplos anteriores se basan en campos de datos de una dimensión específica. También puede definir matrices en las que
La dimensión de los campos de datos cambia dinámicamente. Por ejemplo, puede definir una matriz para contener todas las palabras
en un texto que comienza con la letra A. Dado que inicialmente se desconoce el número de estas palabras, debe poder
posteriormente cambie los límites del campo. Para hacer esto en OpenOffice.org Basic, use la siguiente llamada:
ReDim MyArray (10)
Nota - VBA: a diferencia de VBA, donde solo puede dimensionar matrices dinámicas utilizando Dim MyArray () ,
OpenOffice.org Basic le permite cambiar matrices estáticas y dinámicas usando ReDim .
El siguiente ejemplo cambia la dimensión de la matriz inicial para que pueda registrar 11 o 21 valores:
Dim MyArray (4) As Integer 'Declaración con cinco elementos
'...
ReDim MyArray (10) As Integer 'Incrementar a 11 elementos
'...
ReDim MyArray (20) As Integer 'Incremento a 21 elementos
Cuando restablece las dimensiones de una matriz, puede utilizar cualquiera de las opciones descritas en las secciones anteriores. Esta
incluye declarar campos de datos multidimensionales y especificar valores iniciales y finales explícitos. Cuando las dimensiones
del campo de datos se modifican, todos los contenidos se pierden. Si desea conservar los valores originales, utilice la función Conservar
mando:
Dim MyArray (10) As Integer 'Definiendo la inicial
'dimensiones
'...
ReDim Preserve MyArray (20) As Integer 'Increase in
'campo de datos, mientras
'reteniendo contenido
Cuando utilice Conservar , asegúrese de que el número de dimensiones y el tipo de variables sigan siendo los mismos.
Nota - VBA: a diferencia de VBA, donde solo se puede cambiar el límite superior de la última dimensión de un campo de datos
a través de Preserve , OpenOffice.org Basic también le permite cambiar otras dimensiones.
Si usa ReDim con Preserve , debe usar el mismo tipo de datos que se especifica en el campo de datos original
declaración.
Página 18
Matrices
Determinación de las dimensiones de los campos de datos
Las funciones LBound () y UBound () devuelven respectivamente el valor de índice más bajo permitido y el más alto permitido
valor de índice de una matriz. Esto es útil cuando una matriz ha cambiado sus dimensiones.
Dim MyArray (10) como entero
'... algunas instrucciones
Dim n como entero
n = 47 'podría ser el resultado de un cálculo
Redim MyArray (n) como entero
MsgBox (LBound (MyArray)) 'muestra: 0
MsgBox (UBound (MyArray)) 'muestra: 47
Para una matriz multidimensional, debe especificar la posición (1 an) del índice que desea conocer el
valores superiores e inferiores permitidos:
Atenuar MyArray (10, 13 a 28) como entero
MsgBox (LBound (MyArray, 2)) 'muestra: 13
MsgBox (UBound (MyArray, 2)) 'muestra: 28
Matrices vacías
En algunos casos, especialmente cuando se trata de la API, es necesario declarar una matriz vacía. Tal matriz se declara
sin dimensión, pero luego puede ser llenado por una función de API o con una declaración de Redim:
Dim s () As String 'declara una matriz vacía
'--- más adelante en el programa ...
Redim s (13) como cadena
No puede asignar un valor a una matriz vacía, ya que no contiene ningún elemento.
La "firma" de una matriz vacía es que UBound () devuelve -1 y LBound () devuelve 0:

Atenuar MyArray () como entero
MsgBox (LBound (MyArray)) 'muestra: 0
MsgBox (UBound (MyArray)) 'muestra: -1
Algunas funciones de la API devuelven una matriz que contiene elementos (indexados desde cero) o devuelven una matriz vacía. Utilizar
UBound () para comprobar si la matriz devuelta está vacía.
Definición de valores para matrices
Los valores de los campos de matriz se pueden almacenar así:

MyArray (0) = "algún valor"
Acceso a matrices
El acceso a los valores en una matriz funciona así:

MsgBox ("Valor:" & MyArray (0))
Ejemplo de creación de matrices, asignación de valor y acceso
Y un ejemplo que contiene todos los pasos que muestran el uso real de la matriz:
Sub TestArrayAxess Atenuar MyArray (3) MyArray (0) = "lala" MsgBox ("Valor:"
& MyArray (0)) End Sub
Página 19
Alcance y vida útil de las variables
Una variable en OpenOffice.org Basic tiene una vida útil limitada y un alcance limitado desde el cual se puede leer y usar
en otros fragmentos del programa. La cantidad de tiempo que se retiene una variable, así como dónde se puede acceder a ella
de, depende de su ubicación y tipo especificados.
Variables Locales
Las variables que se declaran en una función o un procedimiento se denominan variables locales:
Subprueba
Atenuar MyInteger como entero
'...
End Sub
Las variables locales solo permanecen válidas mientras la función o el procedimiento se esté ejecutando, y luego se restablecen a cero.
Cada vez que se llama a la función, los valores generados anteriormente no están disponibles.
Para mantener los valores anteriores, debe definir la variable como estática :
Subprueba
MyInteger estático como entero
'...
End Sub
Nota - VBA: a diferencia de VBA, OpenOffice.org Basic garantiza que no se utilice el nombre de una variable local
simultáneamente como una variable global y privada en el encabezado del módulo. Cuando transfiere una aplicación VBA a
OpenOffice.org Basic, debe cambiar cualquier nombre de variable duplicado.
Variables de dominio público
Las variables de dominio público se definen en la sección de encabezado de un módulo mediante la palabra clave Dim . Estas variables son
disponible para todos los módulos en su biblioteca:
Módulo A:
Dim A como entero
Subprueba
Dar la vuelta
Fracaso
End Sub
Sub Flip
A=A+1
End Sub
Módulo B:
Sub flop
A=A-1
End Sub
El valor de la variable A no cambia con la función de prueba , pero se incrementa en uno en la función de inversión y
disminuido en uno en la función Flop . Ambos cambios en la variable son globales.
También puede usar la palabra clave Public en lugar de Dim para declarar una variable de dominio público:
Público A como entero
Una variable de dominio público solo está disponible mientras la macro asociada se esté ejecutando y luego la variable sea
Reiniciar.
Página 20
Variables globales
En términos de su función, las variables globales son similares a las variables de dominio público, excepto que sus valores son
retenido incluso después de que se haya ejecutado la macro asociada. Las variables globales se declaran en la sección de encabezado de un
módulo usando la palabra clave Global :
Global A como entero
Variables privadas
Las variables privadas solo están disponibles en el módulo en el que están definidas. Utilice la palabra clave Privado para
definir la variable:
Privado MyInteger como entero
Si varios módulos contienen una variable privada con el mismo nombre, OpenOffice.org Basic crea una
variable para cada aparición del nombre. En el siguiente ejemplo, tanto el módulo A como el B tienen un Private
variable llamada C . La función de prueba primero establece la variable privada en el módulo A y luego la variable privada en
Módulo B .
Módulo A:
Privado C como entero
Subprueba
SetModuleA 'Establece la variable C del módulo A
SetModuleB 'Establece la variable C del módulo B
ShowVarA 'Muestra la variable C del módulo A (= 10)
ShowVarB 'Muestra la variable C del módulo B (= 20)
End Sub
Sub SetModuleA
C = 10
End Sub
Sub ShowVarA
MsgBox C 'Muestra la variable C del módulo A.
End Sub
Módulo B:
Privado C como entero
Sub SetModuleB
C = 20
End Sub
Sub ShowVarB
MsgBox C 'Muestra la variable C del módulo B.
End Sub
Tenga en cuenta que ShowVarB solo muestra el valor esperado de C (20) porque Sub Test lo mantiene dentro del alcance. Si
las llamadas a SetModuleB y ShowVarB son independientes, por ejemplo, SetModuleB se activa desde un botón de la barra de herramientas
y ShowVarB se activa desde otro botón de la barra de herramientas, luego ShowVarB mostrará un valor C de 0 desde el módulo
las variables se restablecen después de completar cada macro.
Constantes
Las constantes son valores que el programa puede usar pero no cambiar.
Definiendo constantes
En OpenOffice.org Basic, use la palabra clave Const para declarar una constante.
Página 21
Constantes
Const A = 10
También puede especificar el tipo de constante en la declaración:

Const B como doble = 10
Alcance de las constantes
Las constantes tienen el mismo alcance que las variables (consulte Alcance y vida útil de las variables), pero la sintaxis es ligeramente
diferente. Una definición de Const en el encabezado del módulo está disponible para el código en ese módulo. Para hacer la definición
disponible para otros módulos, agregue la palabra clave Public .
Const pública uno como entero = 1
Constantes predefinidas
OpenOffice.org Basic predefine varias constantes. Entre los más útiles están:
Verdadero y falso , para declaraciones de asignación booleanas
PI como tipo Valor numérico doble
Dim bHit como booleano

bHit = Verdadero
Dim dArea como Double, dRadius como Double

'... (asignar un valor a dRadius)
dArea = PI * dRadius * dRadius
Operadores
OpenOffice.org Basic comprende operadores matemáticos, lógicos y de comparación comunes.
Operadores matemáticos
Los operadores matemáticos se pueden aplicar a todos los tipos de números, mientras que el operador + también se puede utilizar para
concatenar cadenas.
+ Suma de números y valores de fecha, concatenación de cadenas
Y Concatenación de cadenas
- Resta de números y valores de fecha
* Multiplicacion de numeros
/ División de números
\ División de números con un resultado de número entero (redondeado)
^ Elevando el poder de los números
MODIFICACIÓN
operación de módulo (cálculo del resto de una división)
Nota: aunque puede usar el operador + para concatenar cadenas, el intérprete básico puede confundirse
al concatenar un número a una cadena. El operador & es más seguro cuando se trata de cadenas porque asume
que todos los argumentos deben ser cadenas y convierte los argumentos en cadenas si no son cadenas.
Página 22
Operadores
Operadores logicos
Los operadores lógicos le permiten realizar operaciones sobre elementos de acuerdo con las reglas del álgebra de Boole. Si el
Los operadores se aplican a valores booleanos, la operación proporciona el resultado requerido directamente. Si se usa en conjunto
con valores enteros y enteros largos, la operación se realiza a nivel de bits.
Y Y operador
O U operador
XOR Operador O exclusivo
NO Negación
EQV Prueba equivalente (ambas partes verdadero o falso )
DIABLILLO Implicación (si la primera expresión es verdadera, la segunda también debe ser verdadera)
Operadores de comparación
Los operadores de comparación se pueden aplicar a todos los tipos de variables elementales (números, detalles de fecha, cadenas y valores booleanos
valores).
= Igualdad de números, valores de fecha y cadenas
<> Desigualdad de números, valores de fecha y cadenas
> Mayor que comprobar números, valores de fecha y cadenas
>= Mayor o igual para verificar números, valores de fecha y cadenas
< Menos que comprobar números, valores de fecha y cadenas
<= Menor o igual para verificar números, valores de fecha y cadenas
Nota: VBA: OpenOffice.org Basic no admite el operador de comparación VBA Like .
Derivación
Utilice sentencias de ramificación para restringir la ejecución de un bloque de código hasta que se cumpla una condición particular.
Si ... Entonces ... Else
La instrucción de ramificación más común es la instrucción If , como se muestra en el siguiente ejemplo:

Si A> 3 entonces
B=2
Terminara si
La asignación B = 2 solo ocurre cuando el valor de la variable A es mayor que tres. Una variación de la declaración If
es la cláusula If / Else :
Si A> 3 entonces
B=2
Más
Página 23
Derivación
B=0
Terminara si
En este ejemplo, a la variable B se le asigna el valor de 2 cuando A es mayor que 3, de lo contrario a B se le asigna el valor
de 0.
Para declaraciones más complejas, puede conectar en cascada la instrucción If , por ejemplo:
Si A = 0 entonces
B=0
Si A <3 Entonces
B=1
Más
B=2
Terminara si
Si el valor de la variable A es igual a cero, a B se le asigna el valor 0. Si A es menor que 3 (pero no igual a cero), entonces B es
se le asigna el valor 1. En todos los demás casos (es decir, si A es mayor o igual que 3), a B se le asigna el valor 2.
Una instrucción If completa se puede escribir en una sola línea, con una sintaxis más simple. El primer ejemplo de esta página puede
estar escrito como:
Si A> 3 entonces B = 2
El segundo ejemplo de esta página se puede escribir como:

Si A> 3 Entonces B = 2 De lo contrario B = 0
Seleccione el caso
La instrucción Select ... Case es una alternativa a la instrucción If en cascada y se utiliza cuando es necesario
comprobar un valor en función de varias condiciones:
Seleccione Caso DayOfWeek
Caso 1:
NameOfWeekday = "Domingo"
Caso 2:
NameOfWeekday = "Lunes"
Caso 3:
NameOfWeekday = "Martes"
Caso 4:
NameOfWeekday = "Miércoles"
Caso 5:
NameOfWeekday = "Jueves"
Caso 6:
NameOfWeekday = "Viernes"
Caso 7:
NameOfWeekday = "Sábado"
Finalizar Seleccionar
En este ejemplo, el nombre de un día de la semana corresponde a un número, de modo que a la variable DayOfWeek se le asigna el
valor de 1 para el domingo , 2 para el valor del lunes y así sucesivamente.
El comando Seleccionar no se limita a asignaciones simples 1: 1; también puede especificar operadores de comparación
o listas de expresiones en una rama Case . El siguiente ejemplo enumera las variantes de sintaxis más importantes:
Seleccionar caso var
Caso 1 a 5
'... Var está entre los números 1 y 5 (incluidos los valores 1 y 5).
Caja> 100
'... Var es mayor que 100
Caso 6, 7, 8
'... Var es 6, 7 u 8
Caso 6, 7, 8,> 15, <0
'... Var es 6, 7, 8, mayor que 15 o menor que 0
Caso diferente
'... todos los demás casos
Ahora considere un ejemplo engañoso (avanzado) y un error común:

Caso Var = 8
'... Var es 0
Página 24
Derivación
Caso diferente
La declaración (Var = 8) se evalúa como VERDADERO si Var es 8 y FALSO en caso contrario. VERDADERO es -1 y FALSO es 0. El
La instrucción Select Case evalúa la expresión, que es VERDADERA o FALSA, y luego compara ese valor con Var.
Cuando Var es 0, hay una coincidencia. Si comprende el último ejemplo, también sabrá por qué este ejemplo
no hagas lo que parece
Caso Var> 8 y Var <11
'... Var es 0
Caso diferente
Bucles
Un bucle ejecuta un bloque de código para el número de pasadas que se especifican. También puede tener bucles con un
número indefinido de pasadas.
Para ... Siguiente
El bucle For ... Next tiene un número fijo de pasadas. El contador de bucle define el número de veces que el bucle
se va a ejecutar. En el siguiente ejemplo, la variable I es el contador de bucle, con un valor inicial de 1. El contador
se incrementa en 1 al final de cada pasada. Cuando la variable I es igual a 10, el ciclo se detiene.
Dim I
Para I = 1 a 10
'... Parte interior del bucle
Siguiente yo
Si desea incrementar el contador de bucle en un valor distinto de 1 al final de cada pasada, use la función Paso :
Dim I
Para I = 1 a 10 Paso 0.5
Siguiente yo
En el ejemplo anterior, el contador se incrementa en 0,5 al final de cada pasada y el bucle se ejecuta 19
veces.
También puede utilizar valores de paso negativos:

Dim I
Para I = 10 a 1 paso -1
Siguiente yo
En este ejemplo, el contador comienza en 10 y se reduce en 1 al final de cada pasada hasta que el contador es 1.
La instrucción Exit For le permite salir de un bucle For prematuramente. En el siguiente ejemplo, el bucle es
terminado durante el quinto pase:
Dim I
Para I = 1 a 10
Si I = 5 Entonces
Salir por
Terminara si
Siguiente yo
Para cada
La variación del bucle For Each ... Next en VBA es compatible con OpenOffice.org Basic. Para cada bucle no
Página 25
Bucles
use un contador explícito como lo hace un bucle For ... Next . Un bucle For Each dice "haz esto con todo en este conjunto",
en lugar de "hacer esto n veces". Por ejemplo:
Constante d1 = 2
Constante d2 = 3
Const d3 = 2
Dim i
Atenuar a (d1, d2, d3)
Para cada i en un ()
Siguiente yo
El bucle se ejecutará 36 veces.
Do ... Loop
El Do ... Loop no está vinculado a un número fijo de pases. En cambio, el bucle Do ... se ejecuta hasta que se
se cumple la condición. Hay cuatro versiones del Do ... Loop . En los dos primeros ejemplos, el código dentro del bucle
puede que no se ejecute en absoluto (lógica "hacer 0 veces"). En los últimos ejemplos, el código se ejecutará al menos una vez. (En
los siguientes ejemplos, A> 10 representa cualquier condición):
1 La versión Do While ... Loop

Hacer mientras A> 10
'... cuerpo de bucle
Lazo
comprueba si la condición después de While es verdadera antes de cada pasada y solo entonces ejecuta el ciclo.
2 La versión Do until ... Loop

Hacer hasta A> 10
Lazo
ejecuta el bucle siempre que la condición posterior a Hasta se evalúe como falsa .
3 La versión Do ... Loop While

Hacer
Bucle mientras A> 10
solo comprueba la condición después del primer paso del bucle y finaliza si la condición después de While se evalúa como
falso .
4 La versión Do ... Loop Until

Hacer
Bucle hasta A> 10
también comprueba su condición después de la primera pasada, pero termina si la condición después de Hasta se evalúa como verdadera .
Como en el bucle For ... Next , el bucle Do ... también proporciona un comando de terminación. El comando Exit Do puede
salir en el bucle en cualquier punto dentro del bucle.
Hacer
Si A = 4 Entonces
Salir Hacer
Terminara si
Bucle mientras A> 10
En algunos casos, el ciclo solo puede terminar cuando se cumple una condición dentro del ciclo. Entonces puedes usar el
Do Loop "perpetuo":
Hacer
'... algunos cálculos internos
Si A = 4 Entonces Salga Hacer
'... otras instrucciones
Lazo
Page 26
Bucles
Mientras ... Wend
La construcción del bucle While ... Wend funciona exactamente igual que el bucle Do While ... , pero con la desventaja
que no hay ningún comando de salida disponible. Los siguientes dos bucles producen resultados idénticos:
Hacer mientras A> 10
Lazo
Mientras que A> 10

Encaminarse a
Ejemplo de programación: clasificación con bucles incrustados
Hay muchas formas de utilizar bucles, por ejemplo, para buscar listas, devolver valores o ejecutar operaciones matemáticas complejas.
Tareas. El siguiente ejemplo es un algoritmo que usa dos bucles para ordenar una lista por nombres.
Suborden
Dim Entry (1 a 10) como cadena
Dim Count como entero
Dim Count2 como entero
Dim Temp como cadena
Entry (1) = "Patty"

Entry (2) = "Kurt"
Entry (3) = "Thomas"
Entry (4) = "Michael"
Entry (5) = "David"
Entry (6) = "Cathy"
Entry (7) = "Susie"
Entry (8) = "Edward"
Entry (9) = "Christine"
Entry (10) = "Jerry"
Para conteo = 1 a 9
Para Count2 = Count + 1 a 10
Si Entrada (Cuenta)> Entrada (Cuenta2) Entonces
Temp = Entrada (recuento)
Entrada (recuento) = Entrada (recuento2)
Entrada (Count2) = Temp
Terminara si
Siguiente recuento2
Siguiente conteo
Para cuenta = 1 a 10
Entrada de impresión (recuento)
Siguiente conteo
End Sub
Los valores se intercambian por pares varias veces hasta que finalmente se clasifican en orden ascendente. Como burbujas, el
las variables migran gradualmente a la posición correcta. Por esta razón, este algoritmo también se conoce comoOrdenamiento de burbuja.
Procedimientos y funciones
Los procedimientos y funciones forman puntos fundamentales en la estructura de un programa. Proporcionan el marco para
dividir un problema complejo en varias subtareas.
Procedimientos
Un procedimiento ejecuta una acción sin proporcionar un valor explícito. Su sintaxis es

Subprueba
Página 27
'... aquí está el código real del procedimiento

End Sub
El ejemplo define un procedimiento llamado Prueba que contiene código al que se puede acceder desde cualquier punto de la
programa. La llamada se realiza ingresando el nombre del procedimiento en el punto relevante del programa.
Funciones
Una función , al igual que un procedimiento, combina un bloque de programas a ejecutar en una unidad lógica. Sin embargo,
a diferencia de un procedimiento, una función proporciona un valor de retorno.
Prueba de funcionamiento
'... aquí está el código real de la función
Prueba = 123
Función final
El valor de retorno se asigna mediante una asignación simple. No es necesario colocar la tarea al final de
la función, pero se puede hacer en cualquier lugar de la función.
La función anterior se puede llamar dentro de un programa de la siguiente manera:

Dim A
A = Prueba
El código define una variable A y le asigna el resultado de la función Test .
El valor de retorno se puede sobrescribir varias veces dentro de la función. Al igual que con la asignación de variables clásica, la
La función en este ejemplo devuelve el valor que se le asignó por última vez.
Prueba de funcionamiento
Prueba = 12
'...
Prueba = 123
Función final
En este ejemplo, el valor de retorno de la función es 123.
Si no se asigna nada, la función devuelve un valor cero (número 0 para valores numéricos y un espacio en blanco para cadenas).
El valor de retorno de una función puede ser de cualquier tipo. El tipo se declara de la misma forma que una declaración de variable:
Prueba de función como entero
'... aquí está el código real de la función
Función final
Si no se especifica el tipo de retorno (ver el primer ejemplo de esta página), la función devuelve una variante.
Terminación prematura de procedimientos y funciones
En OpenOffice.org Basic, puede utilizar los comandos Exit Sub y Exit Function para finalizar un procedimiento
o funcionar prematuramente, por ejemplo, para el manejo de errores. Estos comandos detienen el procedimiento o la función y
devolver el programa al punto en el que se llamó el procedimiento o la función.
El siguiente ejemplo muestra un procedimiento que termina la implementación cuando la variable ErrorOccured
tiene el valor Verdadero .
Subprueba
Dim ErrorOccured como booleano
'...
Si se solucionó el error, entonces
Salir Sub
Terminara si
'...
End Sub
Página 28
Parámetros de paso
Las funciones y los procedimientos pueden recibir uno o más parámetros. Los parámetros esenciales deben incluirse en
paréntesis después de los nombres de funciones o procedimientos. El siguiente ejemplo define un procedimiento que espera una
valor entero A y una cadena B como parámetros.
Subprueba (A como entero, B como cadena)
'...
End Sub
Los parámetros son normalmente Pasado por Referencia en OpenOffice.org Basic. Los cambios realizados en las variables son
retenido cuando se sale del procedimiento o función:
Subprueba
Dim A como entero
A = 10
ChangeValue (A)
'El parámetro A ahora tiene el valor 20
End Sub
Sub ChangeValue (TheValue como entero)

TheValue = 20
End Sub
En este ejemplo, el valor A que se define en la función Prueba se pasa como parámetro al ChangeValue
función. Luego, el valor se cambia a 20 y se pasa a TheValue , que se conserva cuando se sale de la función.
También puede pasar un parámetro como valor si no desea que los cambios posteriores al parámetro afecten a la
valor que se pasa originalmente. Para especificar que un parámetro se debe pasar como valor, asegúrese de que ByVal
La palabra clave precede a la declaración de la variable en el encabezado de la función.
En el ejemplo anterior, si reemplazamos la función ChangeValue , la variable superior A permanece

no se ve afectado por este cambio. Después de la llamada a la función ChangeValue , la variable A retiene el valor 10.
Sub ChangeValue (ByVal TheValue como entero)
TheValue = 20
End Sub
Nota - VBA: el método para pasar parámetros a procedimientos y funciones en OpenOffice.org Basic es
prácticamente idéntico al de VBA. De forma predeterminada, los parámetros se pasan por referencia. Para pasar parámetros como
valores, utilice la palabra clave ByVal . En VBA, también puede usar la palabra clave ByRef para forzar que se pase un parámetro
por referencia. OpenOffice.org Basic reconoce pero ignora esta palabra clave, porque ya es la predeterminada
procedimiento en OpenOffice.org Basic.
Parámetros opcionales
Las funciones y los procedimientos solo se pueden llamar si se pasan todos los parámetros necesarios durante la llamada.
OpenOffice.org Basic te permite definir parámetros como opcionales , es decir, si los valores correspondientes no están incluidos
en una llamada, OpenOffice.org Basic pasa un parámetro vacío. En el siguiente ejemplo, el parámetro A es
obligatorio, mientras que el parámetro B es opcional.
Subprueba (A como entero, B opcional como entero)
'...
End Sub
La función IsMissing comprueba si un parámetro se ha pasado o se ha dejado fuera.

Subprueba (A como entero, B opcional como entero)
Dim B_Local como entero
'Compruebe si el parámetro B está realmente presente
Si no falta (B), entonces
B_Local = Parámetro B 'B presente
Más
B_Local = 0 'Falta el parámetro B -> valor predeterminado 0
Terminara si
'... Iniciar la función actual
End Sub
Página 29
El ejemplo primero prueba si se ha pasado el parámetro B y, si es necesario, pasa el mismo parámetro a

la variable interna B_Local . Si el parámetro correspondiente no está presente, entonces un valor predeterminado (en este caso,
el valor 0) se pasa a B_Local en lugar del parámetro pasado.
Nota - VBA: la palabra clave ParamArray presente en VBA no es compatible con OpenOffice.org Basic.
Recursividad
Un procedimiento o función recursiva es aquel que tiene la capacidad de llamarse a sí mismo hasta que detecta que alguna condición base
ha quedado satisfecho. Cuando se llama a la función con la condición base, se devuelve un resultado.
El siguiente ejemplo usa una función recursiva para calcular el factorial de los números 42 , -42 y 3.14 :
Sub principal
Msgbox CalculateFactorial (42) 'Muestra 1,40500611775288E + 51
Msgbox CalculateFactorial (-42) 'Muestra "¡Número no válido para factorial!"
Msgbox CalculateFactorial (3.14) 'Muestra "¡Número no válido para factorial!"
End Sub
Función CalculateFactorial (Number)

Si Número <0 O Número <> Int (Número) Entonces
CalculateFactorial = "¡Número no válido para factorial!"
ElseIf Number = 0 Entonces
CalculateFactorial = 1
Más
'Esta es la llamada recursiva:
CalculateFactorial = Number * CalculateFactorial (Número - 1)
Terminara si
Función final
El ejemplo devuelve el factorial del número 42 llamando de forma recursiva a la función CalculateFactorial
hasta que alcance la condición base de 0! = 1 .
Nota: los niveles de recursividad se establecen en diferentes niveles según la plataforma de software. Para Windows el
el nivel de recursividad es 5800. Para Solaris y Linux, se realiza una evaluación del tamaño de la pila y el nivel de recursividad
es calculado.
Manejo de errores
El manejo correcto de situaciones de error es una de las tareas de programación que más tiempo requieren. OpenOffice.org
Basic proporciona una gama de herramientas para simplificar el manejo de errores.
La instrucción en caso de error
La instrucción On Error es la clave para cualquier manejo de errores:

Subprueba
On Error Goto ErrorHandler
'... realizar una tarea durante la cual puede ocurrir un error
Salir Sub
ErrorHandler:
'... código individual para el manejo de errores
End Sub
La línea On Error Goto ErrorHandler define cómo procede OpenOffice.org Basic en caso de error.
El Goto ManejadorError asegura que OpenOffice.org Basic salga de la línea de programa actual y luego se ejecuta
el ErrorHandler: código.
Página 30
Manejo de errores
El comando de reanudar
El comando Resume Next continúa el programa desde la línea que sigue a donde ocurrió el error en el
programa después de que se haya ejecutado el código en el controlador de errores:
ErrorHandler:
Reanudar a continuación
Utilice el comando Resume Proceed para especificar un punto de salto para continuar con el programa después del manejo de errores:
ErrorHandler:
Reanudar Continuar
Continuar:
'... el programa continúa aquí después del error
El término Proceed es una etiqueta. Podría ser, por ejemplo, A247. La sintaxis de los nombres de las etiquetas es la misma que la de las variables.
nombres
Para continuar un programa sin un mensaje de error cuando ocurre un error, use el siguiente formato:
Subprueba
En Error Reanudar Siguiente
'... realizar una tarea durante la cual puede ocurrir un error
End Sub
Utilice el comando En caso de error, reanudar siguiente con precaución, ya que su efecto es global.
Consultas sobre información de error
En el manejo de errores, es útil tener una descripción del error y saber dónde y por qué ocurrió el error:
La variable Err contiene el número de errores que se han producido.

La variable Error $ contiene una descripción del error.
La variable Erl contiene el número de línea donde ocurrió el error.
La llamada MsgBox "Error" & Err & ":" & Error $ & "(línea:" & Erl & ")" muestra cómo la información de error puede
se mostrará en una ventana de mensaje.
Nota - VBA: mientras que VBA resume los mensajes de error en un objeto estadístico llamado Err , OpenOffice.org
Basic proporciona las variables Err, Error $ y Erl .
La información de estado permanece válida hasta que el programa encuentra un comando Reanudar o En caso de error , con lo cual
la información se restablece.
Nota - VBA: en VBA, el método Err.Clear del objeto Err restablece el estado de error después de que ocurre un error.
En OpenOffice.org Basic, esto se logra con los comandos On Error o Resume .
Consejos para el manejo estructurado de errores
Tanto el comando de definición, en caso de error , como el comando de retorno, Reanudar , son variantes de la construcción Goto .
Si desea estructurar limpiamente su código para evitar generar errores cuando use esta construcción, debe
No use comandos de salto sin monitorearlos.
Se debe tener cuidado al usar el comando On Error Resume Next ya que esto descarta todos los errores abiertos
mensajes
La mejor solución es utilizar solo un enfoque para el manejo de errores dentro de un programa: mantenga el manejo de errores separado
del código del programa real y no vuelva al código original después de que ocurra el error.
Page 31
Manejo de errores
El siguiente código es un ejemplo de un procedimiento de manejo de errores:

Ejemplo secundario
'Definir el controlador de errores al inicio de la función
On Error Goto ErrorHandler
'... Aquí está el código del programa real
En error Goto 0 'Desactivar manejo de errores
'Fin de la implementación del programa regular
Salir Sub
'Punto de inicio del manejo de errores

ErrorHandler:
'Verifique si se esperaba un error
Si Err = ExpectedErrorNo entonces
'... Error de proceso
Más
'... Advertencia de error inesperado
Terminara si
En error Goto 0 'Desactivar manejo de errores
End Sub
Este procedimiento comienza con la definición de un controlador de errores, seguido del código del programa real. Al final de
el código del programa, la gestión de errores se desactiva mediante la llamada On Error Goto 0 y el procedimiento
la implementación finaliza con el comando Exit Sub (que no debe confundirse con End Sub ).
El ejemplo primero verifica si el número de error corresponde al número esperado (como se almacena en el imaginario
ExpectedErrorNo constante) y luego maneja el error en consecuencia. Si ocurre otro error, el sistema genera
una advertencia. Es importante comprobar el número de error para poder detectar errores imprevistos.
La llamada On Error Goto 0 al final del código restablece la información de estado del error (el código de error en el
Err variables del sistema) para que se pueda reconocer claramente un error que se produzca en una fecha posterior.
Otras instrucciones
Tipo ... Tipo final
Una estructura es una colección de campos de datos que se pueden manipular como un solo elemento. En términos más antiguos, puede pensar en un
estructura como un registro o parte de un registro.
los La API a menudo usa estructuras predefinidas, pero estas son estructuras UNO , un tipo de estructura altamente especializado.
Definición
Con las sentencias Type ... End Type , puede definir sus propias estructuras (no UNO):
Escriba unMenuItem 'asignar el nombre del tipo
'Defina los campos de datos dentro de la estructura. Cada
La definición de 'parece una declaración Dim, sin el "Dim".
aCommand como cadena
aTexto como cadena
Tipo final 'cerrar la definición
Ejemplo
La definición de Tipo es solo un patrón o plantilla, no un conjunto de variables reales. Para hacer una instancia del tipo,
variables reales que se pueden leer y almacenar, use la instrucción Dim as New :
Atenuar maItem como nuevo aMenuItem
Página 32
Otras instrucciones
Alcance
Como se muestra en el ejemplo a continuación, la definición de tipo se puede escribir al comienzo de un módulo (antes del primer Sub
o Función ). La definición estará disponible para todas las rutinas del módulo.
A partir de la versión 3.0 de OpenOffice.org, a diferencia de las variables, no hay forma de hacer que la definición sea accesible fuera de
el módulo.
Una instancia del nuevo tipo es una variable y sigue las reglas habituales para el alcance de la variable (consulteAlcance y vida útil
de variables)
Un ejemplo de cómo usar la definición, y cómo hacer referencia a los campos dentro de una instancia, aparece en el
sección sobre Con ... Terminar con .
Con ... terminar con
Calificadores
En general, Basic no mira dentro de un contenedor, como un Objeto , para ver qué nombres podrían definirse allí.
Si desea utilizar ese nombre, debe indicarle a Basic dónde buscar. Lo haces usando el nombre del objeto como
un calificador . Escríbalo antes del nombre interior y sepárelo con un punto:
MyObject.SomeName
Dado que los contenedores pueden contener otros contenedores, es posible que necesite más de un calificador. Escribe los calificadores en orden,
de exterior a interior:
OuterObject.InnerObject.FarInsideObject.SomeName
Estos nombres también pueden describirse como "concatenados con el operador punto ('.')".
La alternativa con
Las declaraciones With ... End With entre corchetes brindan una alternativa a escribir todos los calificadores, siempre:
y algunos de los calificadores de la API pueden ser bastante largos. Usted especifica los calificadores en la instrucción With . Hasta
Basic encuentra la instrucción End With , busca nombres parcialmente calificados : nombres que comienzan con un punto
(operador de punto unario). El compilador usa los calificadores de With como si estuvieran escritos delante del
nombre parcialmente calificado.
Ejemplo 1: una estructura definida por el usuario
Este ejemplo muestra cómo puede definir y usar una estructura, y cómo hacer referencia a los elementos dentro de ella, tanto con como
sin Con . De cualquier manera, los nombres de los campos de datos (de la definición de Tipo ) deben estar calificados por el nombre
de la instancia (de la instrucción Dim ).
Escriba unMenuItem
aCommand como cadena
aTexto como cadena
Tipo final
Sub principal
'Cree una instancia de la estructura definida por el usuario.
'Tenga en cuenta la palabra clave, "Nuevo".
Atenuar maItem como nuevo aMenuItem
Con maItem
.aCommand = ".uno: Copiar"
.aText = "~ Copiar"
Terminar con
MsgBox "Comando:" & maItem.aCommand & Chr (13) _
Page 33
Otras instrucciones
& "Texto:" & maItem.aText
End Sub
Ejemplo 2: declaración de caso
En Celdas y rangos, el siguiente ejemplo tiene los calificadores en las declaraciones de caso escritos completamente, para
claridad. Puede escribirlo más fácilmente, de esta manera:
Dim Doc como objeto
Dim hoja como objeto
Atenuar celda como objeto
Doc = ThisComponent
Hoja = Hojas Doc. (0)
Celda = Sheet.getCellByPosition (1,1) 'Celda "B2" (basada en 0)
Cell.Value = 1000
Con com.sun.star.table.CellContentType
Seleccione Case Cell.Type
Caso .VACÍO
MsgBox "Contenido: vacío"
Caso .VALUE
MsgBox "Contenido: Valor"
Caso .TEXT
MsgBox "Contenido: Texto"
Estuche .FORMULA
MsgBox "Contenido: fórmula"
Terminar con
Observe que la construcción With debe estar completamente fuera de la construcción Select .
34
3
CAPÍTULO 3
3 Biblioteca de ejecución
Las siguientes secciones presentan las funciones centrales de la biblioteca en tiempo de ejecución:
Funciones de conversión
Cuerdas
Fecha y hora
Archivos y directorios
Cuadros de entrada y mensajes
Otras funciones
En muchas situaciones, surgen circunstancias en las que una variable de un tipo debe cambiarse a una variable de
otro tipo.
Conversiones de tipo implícitas y explícitas
La forma más sencilla de cambiar una variable de un tipo a otro es utilizar una asignación.
Dim A como cadena
Dim B como entero
B = 101
A=B
En este ejemplo, la variable A es una cadena y la variable B es un número entero. OpenOffice.org Basic asegura que la variable B sea
convertido a una cadena durante la asignación a la variable A . Esta conversión es mucho más elaborada de lo que parece: la
el entero B permanece en la memoria de trabajo en forma de un número de dos bytes. A , por otro lado, es una cuerda,
y la computadora guarda un valor largo de uno o dos bytes para cada carácter (cada número). Por lo tanto, antes
Al copiar el contenido de B a A , B debe convertirse al formato interno de A.
A diferencia de la mayoría de los otros lenguajes de programación, Basic realiza la conversión de tipos automáticamente. Sin embargo, esto puede
tener consecuencias fatales. Tras una inspección más cercana, la siguiente secuencia de código
Dim A como cadena
Dim B como entero
Dim C como entero
B=1
C=1
A=B+C
que a primera vista parece sencillo, finalmente resulta ser una especie de trampa. El intérprete básico primero
35
Página 35
calcula el resultado del proceso de adición y luego lo convierte en una cadena, que, como resultado, produce el
cuerda 2.
Si, por otro lado, el intérprete básico primero convierte los valores iniciales B y C en una cadena y aplica el signo más
operador al resultado, produce la cadena 11 .
Lo mismo se aplica cuando se utilizan variables variantes:

Dim A
Dim B
Dim C
B=1
C = "1"
A=B+C
Dado que las variables variantes pueden contener tanto números como cadenas, no está claro si a la variable A se le asigna el
número 2 o la cuerda 11.
Las fuentes de error señaladas para las conversiones de tipos implícitas solo pueden evitarse mediante una programación cuidadosa; por ejemplo,
al no utilizar el tipo de datos de variante.
Para evitar otros errores resultantes de conversiones de tipo implícitas, OpenOffice.org Basic ofrece una variedad de conversiones
funciones, que puede utilizar para definir cuándo se debe convertir el tipo de datos de una operación:
CStr (Var)
convierte cualquier tipo de datos en una cadena.

CInt (Var)
convierte cualquier tipo de datos en un valor entero.

CLng (Var)
convierte cualquier tipo de datos en un valor largo.

CSng (Var)
convierte cualquier tipo de datos en un solo valor.

CDbl (Var)
convierte cualquier tipo de datos en un valor doble.

CBool (Var)
convierte cualquier tipo de datos en un valor booleano.

CDate (Var)
convierte cualquier tipo de datos en un valor de fecha.
Puede utilizar estas funciones de conversión para definir cómo OpenOffice.org Basic debe realizar este tipo
operaciones de conversión:
Dim A como cadena
Dim B como entero
Dim C como entero
B=1
C=1
A = CStr (B + C) 'B y C se suman primero, luego
'convertido a la cadena "2"
A = CStr (B) + CStr (C) 'B y C se convierten en una cadena, luego
'combinado para producir la cadena "11"
Durante la primera adición en el ejemplo, OpenOffice.org Basic primero agrega las variables enteras y luego convierte
el resultado en una cadena de personajes. A se le asigna la cadena 2 . En la segunda instancia, las variables enteras son primero
convertidos en dos cadenas y luego vinculados entre sí mediante la asignación. A lo tanto se le asigna
la cuerda 11 .
Las funciones de conversión numéricas CSng y CDbl también aceptan números decimales. El símbolo definido en el
Los ajustes específicos del país correspondientes deben utilizarse como símbolo de coma decimal. Por el contrario, los métodos CStr
utilice la configuración específica del país actualmente seleccionada al formatear números, fechas y detalles de hora.
Page 36
La función Val es diferente de los métodos Csng, Cdbl y Cstr . Convierte una cadena en un número;
sin embargo, siempre espera que se utilice un punto como símbolo del punto decimal.
Dim A como cadena
Dim B como doble
A = "2,22"
B = Val (A) 'Se convierte correctamente independientemente de la
'configuración específica del país
Comprobación del contenido de variables
En algunos casos, la fecha no se puede convertir:

Dim A como cadena
Dim B como fecha
A
B==A
"prueba" 'Crea mensaje de error
En el ejemplo que se muestra, la asignación de la cadena de prueba a una variable de fecha no tiene sentido, por lo que Basic
el intérprete informa de un error. Lo mismo se aplica al intentar asignar una cadena a una variable booleana:
Dim A como cadena
Dim B como booleano
A = "prueba"
B=A 'Crea mensaje de error
Nuevamente, el intérprete básico informa de un error.
Estos mensajes de error pueden evitarse comprobando el programa antes de una asignación, para establecer
si el contenido de la variable que se asignará coincide con el tipo de la variable de destino. OpenOffice.org Basic
proporciona las siguientes funciones de prueba para este propósito:
IsNumeric (valor)
comprueba si un valor es un número.

IsDate (valor)
comprueba si un valor es una fecha.

IsArray (valor)
comprueba si un valor es una matriz.
Estas funciones son especialmente útiles cuando se consulta la entrada del usuario. Por ejemplo, puede comprobar si un usuario tiene
escribió un número o fecha válidos.
Si IsNumeric (UserInput) entonces
ValidInput = UserInput
Más
ValidInput = 0
MsgBox "Mensaje de error".
Terminara si
En el ejemplo anterior, si la variable UserInput contiene un valor numérico válido, este se asigna al
Variable ValidInput . Si UserInput no contiene un número válido, a ValidInput se le asigna el valor 0 y
se devuelve un mensaje de error.
Si bien existen funciones de prueba para verificar números, detalles de fecha y matrices en OpenOffice.org Basic, una
la función para comprobar los valores booleanos no existe. Sin embargo, la funcionalidad se puede imitar utilizando el
Función IsBoolean :
Función IsBoolean (valor como variante) como booleano
En caso de error, vaya a ErrorIsBoolean:
Dim Dummy como booleano
Dummy = Valor
IsBoolean = Verdadero
En error Goto 0
Salir Sub
ErrorIsBoolean:
Capítulo 3 · Biblioteca en tiempo de ejecución 37
Page 37
IsBoolean = Falso
En error Goto 0
Función final
El IsBoolean función define un interior simulada ayuda variable del tipo booleano y trata de asignar a este
el valor transferido. Si la asignación se realiza correctamente, la función devuelve True . Si falla, se produce un error en tiempo de ejecución,
el controlador de errores intercepta el error y la función devuelve False .
Nota - VBA: si una cadena en OpenOffice.org Basic contiene un valor no numérico y si se asigna a un
número, OpenOffice.org Basic no produce un mensaje de error, pero deja de convertir la cadena en la primera
carácter invalido. Este procedimiento difiere de VBA. Allí, se desencadena un error y la implementación del programa
termina si se ejecuta una asignación correspondiente.
Trabajar con conjuntos de caracteres

Al administrar cadenas, OpenOffice.org Basic usa el conjunto de caracteres Unicode. Las funciones Asc y Chr
Permitir que se establezca el valor Unicode perteneciente a un carácter y / o el carácter correspondiente
encontrado para un valor Unicode. Las siguientes expresiones asignan los distintos valores Unicode a la variable de código:
Código = Asc ("A") 'Letra latina A (valor Unicode 65)
Código = Asc ("€") 'Carácter de euro (valor Unicode 8364)
Código = Asc ("Л") 'Letra cirílica Л (valor Unicode 1083)
Por el contrario, la expresión MyString = Chr (13) asegura que la cadena MyString se inicializa con el valor de
el número 13 , que representa un salto de línea duro.
El comando Chr se usa a menudo en lenguajes básicos para insertar caracteres de control en una cadena. La asignación
MyString = Chr (9) + "Esto es una prueba" + Chr (13), por lo tanto, asegura que el texto esté precedido por un carácter de tabulación.
(Valor Unicode 9) y que se agrega un salto de línea fijo (valor Unicode 13) después del texto.
Acceder a partes de una cuerda
OpenOffice.org Basic proporciona tres funciones que devuelven cadenas parciales, más una función de longitud:
Izquierda (MyString, Longitud)
devuelve los primeros caracteres de longitud de MyString .

Derecha (MyString, Longitud)
devuelve los últimos caracteres de longitud de MyString .

Medio (MyString, Inicio, Longitud)
devuelve los primeros caracteres de longitud de MyString a partir de la posición de inicio .

Len (MyString)
devuelve el número de caracteres en MyString .
Aquí hay algunos ejemplos de llamadas para las funciones nombradas:

Dim MyResult como cadena
Atenuar MyLen como entero
MyString = "Esta es una pequeña prueba"

MyResult = Left (MyString, 5) 'Proporciona la cadena "This"
MyResult = Right (MyString, 5) 'Proporciona la cadena "prueba"
MyResult = Mid (MyString, 8, 5) 'Proporciona la cadena "a sm"
MyLen = Len (MyString) 'Proporciona el valor 20
Página 38
Buscar y reemplazar
OpenOffice.org Basic proporciona la función InStr para buscar una cadena parcial dentro de otra cadena:
ResultString = InStr (MyString, SearchString)
El parámetro SearchString especifica la cadena que se buscará dentro de MyString . La función devuelve un
número que contiene la posición en la que SearchString aparece por primera vez dentro de MyString ; un valor de retorno de
cero indica que no hay coincidencia. Si desea encontrar otras coincidencias para la cadena, la función también proporciona la
oportunidad de especificar una posición de inicio opcional desde la cual OpenOffice.org Basic comienza la búsqueda. En este caso,
la sintaxis de la función es:
ResultString = InStr (StartPosition, MyString, SearchString)
En los ejemplos anteriores, InStr ignora los caracteres en mayúsculas y minúsculas. Para cambiar la búsqueda de modo que InStr
distingue entre mayúsculas y minúsculas, agregue el parámetro 0 , como se muestra en el siguiente ejemplo:
ResultString = InStr (MyString, SearchString, 0)
Usando las funciones anteriores para editar cadenas, los programadores pueden buscar y reemplazar una cadena en otra
cuerda:
Función Reemplazar (Fuente como cadena, Buscar como cadena, NewPart como cadena)
Atenuar resultado como cadena
Atenuar StartPos tan largo
Atenuar CurrentPos tan largo
Resultado = ""
StartPos = 1
CurrentPos = 1
Si Buscar = "" Entonces
Resultado = Fuente
Más
Hacer mientras CurrentPos <> 0
CurrentPos = InStr (StartPos, Fuente, Búsqueda)
Si CurrentPos <> 0 entonces
Resultado = Resultado + Medio (Fuente, StartPos, _
CurrentPos - StartPos)
Resultado = Resultado + NewPart
StartPos = CurrentPos + Len (Buscar)
Más
Resultado = Resultado + Medio (Fuente, StartPos, Len (Fuente))
Terminara si 'Posición <> 0
Lazo
Terminara si
Reemplazar = Resultado
Función final
La función busca a través de la cadena de búsqueda transferida en un bucle mediante InStr en el término original
Fuente .Si encuentra el término de búsqueda, toma la parte anterior a la expresión y la escribe en el retorno de resultado.
buffer. Agrega la sección NewPart en el punto del término de búsqueda Buscar . Si no se encuentran más coincidencias para el
término de búsqueda, la función establece la parte de la cadena que aún queda y la agrega al búfer de retorno. Eso
devuelve la cadena producida de esta manera como resultado del proceso de reemplazo.
Dado que reemplazar partes de secuencias de caracteres es una de las funciones más utilizadas, la función Mid en
OpenOffice.org Basic se ha ampliado para que esta tarea se realice automáticamente. El siguiente ejemplo
reemplaza tres caracteres con la cadena es de la sexta posición de la cadena MyString .
MyString = "Este era mi texto"

Mid (MyString, 6, 3, "es")
Advertencia: cuando se usa con 4 argumentos, para reemplazar una subcadena en una cadena, Mid es una instrucción , no una
función: ¡no devuelve ningún valor!
Página 39
Cadenas de formato
La función de formato da formato a los números como una cadena. Para hacer esto, la función espera que una expresión de formato sea
especificado, que luego se utiliza como plantilla para formatear los números. Cada marcador de posición dentro de la plantilla
asegura que este elemento tenga el formato correspondiente en el valor de salida. Los cinco marcadores de posición más importantes
dentro de una plantilla están los caracteres cero ( 0 ), signo de libra ( # ), punto ( . ), coma ( , ) y signo de dólar ( $ ).
El carácter 0 dentro de la plantilla asegura que siempre se coloque un número en el punto correspondiente. Si un
no se proporciona el número, se muestra 0 en su lugar.
Una . representa el símbolo de coma decimal definido por el sistema operativo en la configuración específica del país.
El siguiente ejemplo muestra cómo el 0 y . Los caracteres pueden definir los dígitos después del punto decimal en un
expresión:
MyFormat = "0.00"
MyString = Format (-1579.8, MyFormat) 'Proporciona "-1579,80"
MyString = Format (1579.8, MyFormat) 'Proporciona "1579,80"
MyString = Formato (0.4, MyFormat) 'Proporciona "0,40"
De la misma manera, se pueden agregar ceros delante de un número para lograr la longitud deseada:
MyFormat = "0000.00"
MyString = Format (-1579.8, MyFormat) 'Proporciona "-1579,80"
A , representa el carácter que utiliza el sistema operativo para un separador de miles, y el # representa un dígito
o lugar que solo se muestra si lo requiere la cadena de entrada.
MyFormat = "#, ## 0.00"
MyString = Format (-1579.8, MyFormat) 'Proporciona "-1.579,80"
MyString = Format (1579.8, MyFormat) 'Proporciona "1.579,80"
En lugar del marcador de posición $ , la función Formato muestra el símbolo de moneda relevante definido por el sistema
(este ejemplo asume que se ha definido una configuración regional europea):
MyFormat = "#, ## 0.00 $"
MyString = Format (-1579.8, MyFormat) 'Proporciona "-1.579,80 €"
MyString = Format (1579.8, MyFormat) 'Proporciona "1.579,80 €"
MyString = Formato (0.4, MyFormat) 'Proporciona "0,40 €"
MyString = Format (0.434, MyFormat) 'Proporciona "0,43 €"
Las instrucciones de formato que se utilizan en VBA para formatear los detalles de fecha y hora también se pueden utilizar:
sub principal
atenuar myDate como fecha
myDate = "06/01/98"
TestStr = Formato (myDate, "mm-dd-aaaa") '01-06-1998
MsgBox TestStr
final sub
Fecha y hora
OpenOffice.org Basic proporciona el tipo de datos Fecha , que guarda los detalles de fecha y hora en formato binario.
Especificación de detalles de fecha y hora dentro del

Código de programa
Puede asignar una fecha a una variable de fecha mediante la asignación de una cadena simple:
Atenuar MyDate como fecha
Page 40
Fecha y hora
MyDate = "24.1.2002"
Esta asignación puede funcionar correctamente porque OpenOffice.org Basic convierte automáticamente el valor de la fecha
definido como una cadena en una variable de fecha. Sin embargo, este tipo de asignación puede causar errores, valores de fecha y hora.
se definen y muestran de manera diferente en diferentes países.
Dado que OpenOffice.org Basic utiliza la configuración específica del país del sistema operativo al convertir una cadena
en un valor de fecha, la expresión mostrada anteriormente solo funciona correctamente si la configuración específica del país coincide
la expresión de cadena.
Para evitar este problema, la función DateSerial debe usarse para asignar un valor fijo a una variable de fecha:
Dim MyVar como fecha
MyDate = DateSerial (2001, 1, 24)
El parámetro de la función debe estar en la secuencia: año, mes, día. La función asegura que la variable sea
realmente asignó el valor correcto independientemente de la configuración específica del país
La función TimeSerial formatea los detalles de la hora de la misma manera que la función DateSerial formatea las fechas:
Dim MyVar como fecha
MyDate = TimeSerial (11, 23, 45)
Sus parámetros deben especificarse en la secuencia: horas, minutos, segundos.
Extracción de detalles de fecha y hora
Las siguientes funciones forman la contraparte de las funciones DateSerial y TimeSerial :

Día (MyDate)
devuelve el día del mes de MyDate .

Mes (MyDate)
devuelve el mes de MyDate .

Año (MyDate)
devuelve el año de MyDate .

Día de la semana (MyDate)
devuelve el número del día de la semana de MyDate .
Hora (MyTime)
devuelve las horas de MyTime .

Minuto (MyTime)
devuelve los minutos de MyTime .

Segundo (MyTime)
devuelve los segundos de MyTime .
Estas funciones extraen las secciones de fecha u hora de una variable de fecha especificada . El siguiente ejemplo comprueba
si la fecha guardada en MyDate es del año 2003.
'... Inicialización de MyDate
Si Year (MyDate) = 2003, entonces

'... La fecha especificada es en el año 2003
Terminara si
De la misma forma, el siguiente ejemplo comprueba si MyTime está entre 12 y 14 horas.

Atenuar MyTime como fecha
'... Inicialización de MyTime
Si Hora (Mi Hora)> = 12 Y Hora (Mi Hora) <14 Entonces

'... El tiempo especificado es entre 12 y 14 horas
Terminara si
Página 41
Fecha y hora
La función Día de la semana devuelve el número del día de la semana para la fecha transferida:
Dim MyWeekday como cadena
'... inicializar MyDate
Seleccionar caso WeekDay (MyDate)

caso 1
MyWeekday = "Domingo"
caso 2
MyWeekday = "Lunes"
caso 3
MyWeekday = "Martes"
caso 4
MyWeekday = "Miércoles"
caso 5
MyWeekday = "Jueves"
caso 6
MyWeekday = "Viernes"
caso 7
MyWeekday = "Sábado"
Nota: el domingo se considera el primer día de la semana.
Recuperando la fecha y hora del sistema
Las siguientes funciones están disponibles en OpenOffice.org Basic para recuperar la hora y la fecha del sistema:
Fecha
devuelve la fecha actual como una cadena. El formato depende de la configuración de localización.
Hora
devuelve la hora actual como una cadena.

Ahora
devuelve el momento actual (fecha y hora) como un valor combinado de tipo Fecha .
Trabajar con archivos es una de las tareas básicas de una aplicación. La API de OpenOffice.org le proporciona una
gama de objetosacon
el Introducción los de
la API queOpenOffice.org.
puede crear, abrir y modificar documentos
Independientemente de esto,deenOffice.
algunosEstos se tendrá
casos presentan
queen detalledirectamente
acceder en
el sistema de archivos, busque en directorios o edite archivos de texto. La biblioteca en tiempo de ejecución de OpenOffice.org Basic
proporciona varias funciones fundamentales para estas tareas.
Nota: Algunas funciones de directorio y archivo específicas de DOS ya no se proporcionan en OpenOffice.org, o sus
la función es solo limitada. Por ejemplo, no se proporciona soporte para las funciones ChDir , ChDrive y CurDir .
Algunas propiedades específicas de DOS ya no se utilizan en funciones que esperan propiedades de archivo como parámetros (para
ejemplo, para diferenciar de archivos ocultos y archivos de sistema). Este cambio se hizo necesario para garantizar la
mayor nivel posible de independencia de plataforma para OpenOffice.org.
Administrar archivos
Modo de compatibilidad
La declaración y función CompatibilityMode proporcionan una mayor compatibilidad con VBA, al cambiar el
Página 42
funcionamiento de determinadas funciones. El efecto sobre cualquier función en particular se describe con esa función, a continuación.
Como declaración, CompatibilityMode (valor) toma un valor booleano para establecer o borrar el modo. Como una función,
CompatibilityMode () devuelve el valor booleano del modo.
Modo de ajuste de CompatibilityMode (True)

CompatibilityMode (False) 'modo claro
Dim bMode como booleano

bMode = CompatibilityMode ()
Búsqueda en directorios
La función Dir en OpenOffice.org Basic es responsable de buscar en directorios archivos y sub-

directorios. Cuando se solicita por primera vez, se debe asignar una cadena que contenga la ruta de los directorios que se buscarán.
Dir como primer parámetro. El segundo parámetro de Dir especifica el archivo o directorio que se buscará.
OpenOffice.org Basic devuelve el nombre de la primera entrada de directorio encontrada. Para recuperar la siguiente entrada, el Dir
La función debe solicitarse sin parámetros. Si la función Dir no encuentra más entradas, devuelve un vacío
cuerda.
El siguiente ejemplo muestra cómo se puede utilizar la función Dir para solicitar todos los archivos ubicados en un directorio. los
El procedimiento guarda los nombres de los archivos individuales en la variable AllFiles y luego los muestra en un cuadro de mensaje.
Sub ShowFiles
Atenuar NextFile como cadena
Atenuar todos los archivos como cadena
AllFiles = ""
NextFile = Dir ("C: \", 0)
Mientras que NextFile <> ""

AllFiles = AllFiles & Chr (13) & NextFile
NextFile = Dir
Encaminarse a
MsgBox AllFiles
End Sub
El 0 (cero) utilizado como segundo parámetro en la función Dir asegura que Dir solo devuelva los nombres de los archivos
y los directorios se ignoran. Aquí se pueden especificar los siguientes parámetros:
0: devuelve archivos normales

16 : subdirectorios
El siguiente ejemplo es prácticamente el mismo que el anterior, pero la función Dir transfiere el valor 16
como parámetro, que devuelve los subdirectorios de una carpeta en lugar de los nombres de los archivos.
Sub ShowDirs
Dim NextDir como cadena
Atenuar AllDirs como cadena
AllDirs = ""
NextDir = Dir ("C: \", 16)
Mientras NextDir <> ""
AllDirs = AllDirs y Chr (13) y NextDir
NextDir = Dir
Encaminarse a
MsgBox AllDirs
End Sub
Nota - VBA: cuando se solicita en OpenOffice.org Basic, la función Dir , usando el parámetro 16, solo devuelve
los subdirectorios de una carpeta. En VBA, la función también devuelve los nombres de los archivos estándar para que más
La comprobación es necesaria para recuperar los directorios únicamente. Al utilizar la función CompatibilityMode (true) ,
OpenOffice.org Basic se comporta como VBA y la función Dir, usando el parámetro 16, devuelve subdirectorios y
archivos estándar.
Página 43
Nota - VBA: las opciones proporcionadas en VBA para buscar a través de directorios específicamente para archivos con el
Las propiedades ocultas , de archivo de sistema , archivadas y de nombre de volumen no existen en OpenOffice.org Basic
porque las funciones correspondientes del sistema de archivos no están disponibles en todos los sistemas operativos.
Nota - VBA: Las especificaciones de ruta enumeradas en Dir pueden usar * y? marcadores de posición en VBA y
OpenOffice.org Basic. Sin embargo, en OpenOffice.org Basic, el marcador de posición * puede ser solo el último carácter de un
nombre de archivo y / o extensión de archivo, que no es el caso en VBA.
Crear y eliminar directorios
OpenOffice.org Basic proporciona la función MkDir para crear directorios.

MkDir ("C: \ SubDir1")
Esta función crea directorios y subdirectorios. También se crean todos los directorios necesarios dentro de una jerarquía, si
necesario. Por ejemplo, si solo existe el directorio C: \ SubDir1 , entonces una llamada
MkDir ("C: \ SubDir1 \ SubDir2 \ SubDir3 \")
crea el directorio C: \ SubDir1 \ SubDir2 y el directorio C: \ SubDir1 \ SubDir2 \ SubDir3 .
La función RmDir elimina directorios.

RmDir ("C: \ SubDir1 \ SubDir2 \ SubDir3 \")
Si el directorio contiene subdirectorios o archivos, estos también se eliminan. Por lo tanto, debe tener cuidado cuando
utilizando RmDir .
Nota - VBA: en VBA, las funciones MkDir y RmDir solo se relacionan con el directorio actual. En OpenOffice.org
Básico, por otro lado, MkDir y RmDir se pueden usar para crear o eliminar niveles de directorios.
Nota - VBA: en VBA, RmDir produce un mensaje de error si un directorio contiene un archivo. En OpenOffice.org
Básico, se borran el directorio y todos sus archivos . Si usa la función CompatibilityMode (true) ,
OpenOffice.org Basic se comportará como VBA.
Copiar, renombrar, eliminar y comprobar el

Existencia de archivos
La siguiente llamada crea una copia del archivo de origen con el nombre de Destino :
FileCopy (origen, destino)
Con la ayuda de la siguiente función se puede cambiar el nombre del OldName archivo con NuevoNombre . La sintaxis de la palabra clave As ,
y el hecho de que no se use una coma, se remonta a las raíces del lenguaje básico.
Nombre OldName como NewName
La siguiente llamada elimina el archivo de nombre de archivo. Si desea eliminar el directorio (incluidos sus archivos), use RmDir
función.
Matar (nombre de archivo)
La función FileExists se puede utilizar para comprobar si existe un archivo:
Si FileExists (nombre de archivo) entonces
MsgBox "archivo existe".
Terminara si
Page 44
Leer y cambiar las propiedades del archivo
Al trabajar con archivos, a veces es importante poder establecer las propiedades del archivo, la hora a la que se
última modificación y la longitud del archivo.
La siguiente llamada devuelve algunas propiedades sobre un archivo.

Atenuar Attr como entero
Attr = GetAttr (nombre de archivo)
El valor de retorno se proporciona como una máscara de bits en la que son posibles los siguientes valores:
1: archivo de solo lectura
16: nombre de un directorio
El siguiente ejemplo determina la máscara de bits del archivo test.txt y comprueba si es de solo lectura
si es un directorio. Si ninguno de estos aplica, FileDescription se asigna la cadena "normal".
Atenuar FileMask como entero
Dim FileDescription como cadena
FileMask = GetAttr ("prueba.txt")
Si (FileMask Y 1)> 0 Entonces

FileDescription = FileDescription y "solo lectura"
Terminara si
Si (FileMask Y 16)> 0 Entonces

FileDescription = FileDescription & "directorio"
Terminara si
Si FileDescription = "" Entonces

FileDescription = "normal"
Terminara si
Descripción del archivo MsgBox
Nota - VBA: los indicadores utilizados en VBA para consultar el nombre oculto , el archivo del sistema, el archivado y el volumen
Las propiedades de archivo no son compatibles con OpenOffice.org Basic porque son específicas de Windows y no son o son
solo parcialmente disponible en otros sistemas operativos.
La función SetAttr permite cambiar las propiedades de un archivo. Por tanto, la siguiente llamada se puede utilizar para
proporcionar un archivo con estado de solo lectura:
SetAttr ("prueba.txt", 1)
Un estado de solo lectura existente se puede eliminar con la siguiente llamada:

SetAttr ("prueba.txt", 0)
La función FileDateTime proporciona la fecha y la hora de la última modificación de un archivo . La fecha es

formateado aquí de acuerdo con la configuración específica del país utilizada en el sistema.
FileDateTime ("test.txt") 'Proporciona la fecha y hora de la última modificación del archivo.
La función FileLen determina la longitud de un archivo en bytes (como valor entero largo).
FileLen ("test.txt") 'Proporciona la longitud del archivo en bytes
Escribir y leer archivos de texto
OpenOffice.org Basic proporciona una amplia gama de métodos para leer y escribir archivos. El seguimiento
las explicaciones se relacionan con el trabajo con archivos de texto ( no con documentos de texto).
Escribir archivos de texto
Antes de acceder a un archivo de texto, primero debe abrirse. Para hacer esto, se necesita un identificador de archivo gratuito , que claramente
identifica el archivo para el acceso posterior al archivo.
Página 45
La función FreeFile se utiliza para crear un identificador de archivo gratuito:

FileNo = FreeFile
FileNo esuna variable entera que recibe el identificador de archivo. A continuación, el mango se utiliza como parámetro para el Open
instrucción, que abre el archivo.
Para abrir un archivo para que se pueda escribir como un archivo de texto, la llamada a Abrir es:
Abrir nombre de archivo para salida como #FileNo
El nombre de archivo es una cadena que contiene el nombre del archivo. FileNo es el identificador creado por la función FreeFile .
Una vez que se abre el archivo, la instrucción Print puede crear el contenido del archivo, línea por línea:
Imprima #FileNo, "Esta es una línea de prueba".
FileNo también significa el identificador de archivo aquí. El segundo parámetro especifica el texto que se guardará como una línea de
el archivo de texto.
Una vez que se ha completado el proceso de escritura, el archivo debe cerrarse mediante una llamada de cierre :
Cerrar #FileNo
Nuevamente aquí, se debe especificar el identificador del archivo.
El siguiente ejemplo muestra cómo se abre, escribe y cierra un archivo de texto:

Dim FileNo como entero
Atenuar CurrentLine como cadena
Atenuar nombre de archivo como cadena
Nombre de archivo = "c: \ data.txt" 'Definir nombre de archivo

FileNo = FreeFile 'Establecer un identificador de archivo libre
Abrir nombre de archivo para salida como #FileNo 'Abrir archivo (modo de escritura)
Imprimir #FileNo, "Esta es una línea de texto" 'Guardar línea
Imprimir #FileNo, "Esta es otra línea de texto" 'Guardar línea
Cerrar #FileNo ' Cerrar el archivo
Leer archivos de texto
Los archivos de texto se leen de la misma forma que se escriben. La instrucción Open utilizada para abrir el archivo contiene la
Para la expresión de entrada en lugar de la expresión para la salida y, en lugar del comando Imprimir para escribir
datos, la instrucción de entrada de línea debe usarse para leer los datos.
Finalmente, al llamar un archivo de texto, la instrucción eof se usa para verificar si el final del archivo ha sido
alcanzado:
eof (FileNo)
El siguiente ejemplo muestra cómo se puede leer un archivo de texto:

Dim FileNo como entero
Atenuar CurrentLine como cadena
Dim Archivo como cadena
Dim Msg como cadena
'Definir nombre de archivo

Nombre de archivo = "c: \ data.txt"
'Establecer un identificador de archivo libre

FileNo = Freefile
'Abrir archivo (modo lectura)

Abrir nombre de archivo para entrada como FileNo
'Compruebe si se ha alcanzado el final del archivo

Hacer mientras no eof (FileNo)
'Leer línea
Entrada de línea #FileNo, CurrentLine
Si CurrentLine <> "" entonces
Msg = Msg & CurrentLine & Chr (13)
terminara si
Página 46
Lazo
' Cerrar el archivo
Cerrar #FileNo
Msgbox Msg
Las líneas individuales se recuperan en un bucle Do While , se guardan en la variable Msg y se muestran al final en un
caja de mensaje.
Cuadros de mensajes y entradas

OpenOffice.org Basic proporciona las funciones MsgBox y InputBox para la comunicación básica del usuario.
Visualización de mensajes
MsgBox muestra un cuadro de información básica, que puede tener uno o más botones. En su variante más simple el MsgBox
solo contiene texto y un botón Aceptar:
MsgBox "¡Esto es un dato!"
La apariencia del cuadro de información se puede cambiar mediante un parámetro. El parámetro ofrece la opción de
agregar botones adicionales, definir el botón preasignado y agregar un símbolo de información.
Nota - Por convención, los nombres simbólicos que se dan a continuación están escritos en MAYÚSCULAS, para marcarlos como
predefinido, en lugar de definido por el usuario. Sin embargo, los nombres no distinguen entre mayúsculas y minúsculas.
Los valores para seleccionar los botones son:

0, MB_OK - Botón OK
1, MB_OKCANCEL - Botón Aceptar y Cancelar
2, MB_ABORTRETRYIGNORE : botones Cancelar, Reintentar e Ignorar
3, MB_YESNOCANCEL : botones Sí, No y Cancelar
4, MB_YESNO - Botones Sí y No
5, MB_RETRYCANCEL - Botones Reintentar y Cancelar
Para establecer un botón como botón predeterminado, agregue uno de los siguientes valores al valor del parámetro de la lista de
selecciones de botones. Por ejemplo, para crear botones Sí, No y Cancelar (valor 3) donde Cancelar es el predeterminado (valor
512), el valor del parámetro es 3 + 512 = 515. La expresión MB_YESNOCANCEL + MB_DEFBUTTON3 es más difícil de
escribir, pero más fácil de entender.
0, MB_DEFBUTTON1 - El primer botón es el valor predeterminado
256, MB_DEFBUTTON2 - El segundo botón es el valor predeterminado
512, MB_DEFBUTTON3 - El tercer botón es el valor predeterminado
Finalmente, los siguientes símbolos de información están disponibles y también se pueden mostrar agregando el correspondiente
valores paramétricos:
16, MB_ICONSTOP - Señal de pare
32, MB_ICONQUESTION - Signo de interrogación
48, MB_ICONEXCLAMATION - Signo de exclamación
64, MB_ICONINFORMATION - Icono de sugerencia
La siguiente llamada muestra un cuadro de información con los botones Sí y No (valor 4), de los cuales el segundo
El botón (No) se establece como valor predeterminado (valor 256) y que también recibe un signo de interrogación (valor 32),
4 + 256 + 32 = 292.
MsgBox "¿Desea continuar?", 292
'o,
MsgBox "¿Quiere continuar?", MB_YESNO + MB_DEFBUTTON2 + MB_ICONQUESTION
Página 47de mensajes y entradas
Cuadros
Visualización del cuadro de mensaje
Si un cuadro de información contiene varios botones, se debe consultar un valor de retorno para determinar qué botón
ha sido presionado. Los siguientes valores de retorno están disponibles en esta instancia:
1, IDOK - Ok
2, IDCANCEL - Cancelar
3, IDABORT - Abortar
4, IDRETRY - Reintentar
5- Ignorar
6, IDYES - Sí
7, IDNO - No
En el ejemplo anterior, la verificación de los valores devueltos podría ser la siguiente:

Dim iBox como entero
iBox = MB_YESNO + MB_DEFBUTTON2 + MB_ICONQUESTION
Si MsgBox ("¿Desea continuar?", IBox) = IDYES Entonces
'o,
Si MsgBox ("¿Desea continuar?", 292) = 6 Entonces
'Sí botón presionado
Más
'Ningún botón presionado
Terminara si
Además del texto de información y el parámetro para organizar el cuadro de información, MsgBox también permite un
tercer parámetro, que define el texto del título del cuadro:
MsgBox "¿Desea continuar?", 292, "Título del cuadro"
Si no se especifica un título de cuadro, el valor predeterminado es "soffice".
Cuadro de entrada para consultar cadenas simples
La función InputBox consulta cadenas simples del usuario. Por tanto, es una alternativa sencilla a la configuración
diálogos. InputBox recibe tres parámetros estándar:
Un texto informativo.
Un título de cuadro.
Un valor predeterminado que se puede agregar dentro del área de entrada.
InputVal = InputBox ("Introduzca el valor:", "Prueba", "valor predeterminado")
Visualización del cuadro de entrada

Las dimensiones de la ventana InputBox no se pueden cambiar.
Si el usuario hace clic en el botón Aceptar, InputBox devuelve la cadena escrita por el usuario (o la cadena predeterminada si
no fue cambiado).
Si el usuario hace clic en el botón Cancelar o cierra la ventana, InputBox devuelve una cadena vacía.
48
Otras funciones
Otras funciones
Bip
La función Beep hace que el sistema reproduzca un sonido que puede usarse para advertir al usuario de una acción incorrecta.
Beep no tiene ningún parámetro:
Beep 'crea un tono informativo
Cáscara
Los programas externos se pueden iniciar utilizando la función Shell.

Shell (nombre de ruta, estilo de ventana, Param, bSync)
Nombre de ruta
la ruta del programa a ejecutar.
En MS-Windows, use ConvertToURL (Pathname); de lo contrario, el comando no funcionará si Pathname

contiene espacios o caracteres nacionales.
Windowstyle
la ventana en la que se inicia el programa.
Son posibles los siguientes valores:
0: el programa recibe el foco y se inicia en una ventana oculta.
1 - El programa recibe el foco y se inicia en una ventana de tamaño normal.
2 - El programa recibe el foco y se inicia en una ventana minimizada.
3 - El programa recibe el foco y se inicia en una ventana maximizada.

4 - El programa se inicia en una ventana de tamaño normal, sin recibir el foco.
6 - El programa se inicia en una ventana minimizada, el foco permanece en la ventana actual.
10 - El programa se inicia en modo de pantalla completa.
Param
parámetros de la línea de comandos que se transferirán al programa que se iniciará.

bSync
esperar a que el comando de shell termine la bandera
verdadero : espere a que termine el comando de shell

falso : no espere a que termine el comando de shell
Espera y espera hasta
La instrucción Wait suspende la ejecución del programa durante un tiempo especificado. El período de espera se especifica en
milisegundos El comando:
Espera 2000
especifica un retraso de 2 segundos (2000 milisegundos).
La declaración WaitUntil proporciona un mayor grado de compatibilidad con el uso de parámetros de VBA. Esperar hasta
toma un parámetro de tipo Fecha , con un valor combinado de fecha y hora. El comando:
WaitHasta ahora + TimeValue ("00:00:02")
Página 49
Otras funciones
especifica el mismo retraso, 2 segundos, que en el ejemplo anterior.
Reinar
La función Environ devuelve las variables ambientales del sistema operativo. Dependiendo del sistema
ydeconfiguración, aquí sedelguardan
directorio temporal sistemavarios tipos de datos. La siguiente llamada determina las variables de entorno
operativo:
Dim TempDir
TempDir = Environ ("TEMP")
Página 50
4
CAPÍTULO 4
4 Introducción a la API
Los objetos y métodos de OpenOffice.org, como párrafos, hojas de cálculo y fuentes, son accesibles para
OpenOffice.org Basic a través de la interfaz de programación de aplicaciones de OpenOffice.org o API. A través de la API,
por ejemplo, se pueden crear, abrir, modificar e imprimir documentos. La API puede ser utilizada no solo por
OpenOffice.org Basic, pero también por otros lenguajes de programación, como Java y C ++. La interfaz entre
la API y varios lenguajes de programación son proporcionados por algo llamado Universal Network Objects
(UNO).
Este capítulo proporciona información sobre la API. Sobre la base de estos antecedentes, los siguientes capítulos mostrarán
cómo se puede utilizar la API para hacer que OpenOffice.org haga lo que usted quiere que haga.
Objetos de red universal (UNO)

OpenOffice.org proporciona una interfaz de programación en forma de Universal Network Objects (UNO). Esto es
una interfaz de programación orientada a objetos que OpenOffice.org subdivide en varios objetos que por su
parte asegura el acceso controlado por programa al paquete de Office.
Dado que OpenOffice.org Basic es un lenguaje de programación procedimental, varias construcciones lingüísticas han tenido que ser
añadido que permiten el uso de UNO.
Para utilizar un objeto de red universal en OpenOffice.org Basic, necesitará una declaración de variable para el
objeto asociado. La declaración se realiza mediante la instrucción Dim (verEl lenguaje de OpenOffice.org Basic)
La designación del tipo de objeto debe usarse para declarar una variable de objeto:
Dim obj como objeto
La llamada declara una variable de objeto llamada Obj .
La variable de objeto creada debe inicializarse para que pueda utilizarse. Esto se puede hacer usando el
función createUnoService :
Obj = createUnoService ("com.sun.star.frame.Desktop")
Esta llamada asigna a la variable Obj una referencia al objeto recién creado. com.sun.star.frame.Desktop
se parece a un tipo de objeto; sin embargo, en la terminología de UNO se le llama servicio en lugar de tipo. De acuerdo con
Filosofía UNO, un Obj se describe como una referencia a un objeto que apoya la
com.sun.star.frame.Desktop
Servicio. El término de servicio utilizado en OpenOffice.org Basic corresponde, por tanto, al tipo y los términos de clase utilizados en
otros lenguajes de programación.
Sin embargo, existe una diferencia principal: un objeto de red universal puede admitir varios servicios al mismo tiempo.
hora. Algunos servicios de UNO, a su vez, admiten otros servicios para que, a través de un objeto, se le proporcione un
Toda la gama de servicios. Por ejemplo, que el objeto antes mencionado, que se basa en el
51
51
Objetos de red universal (UNO)
servicio, también puede incluir otros servicios para cargar documentos y para finalizar el programa.
Nota - VBA: mientras que la estructura de un objeto en VBA está definida por la clase a la que pertenece, en
OpenOffice.org Basic la estructura se define a través de los servicios que soporta. Un objeto de VBA es siempre
asignado precisamente a una sola clase. Sin embargo, un objeto de OpenOffice.org Basic puede admitir varios servicios.
Propiedades y métodos
Un objeto en OpenOffice.org Basic proporciona una gama de propiedades y métodos que se pueden llamar mediante
el objeto.
Propiedades
Las propiedades son como las propiedades de un objeto; por ejemplo, Nombre de archivo y Título de un objeto Documento .
Las propiedades se establecen mediante una simple asignación:

Document.Title = "Guía básica del programador de OpenOffice.org"
Document.Filename = "basguide.odt"
Una propiedad, al igual que una variable normal, tiene un tipo que define qué valores puede registrar. El precedente
Las propiedades de nombre de archivo y título son del tipo cadena.
Propiedades reales y propiedades imitadas
La mayoría de las propiedades de un objeto en OpenOffice.org Basic se definen como tales en la descripción UNO del
Servicio. Además de estas propiedades "reales", también hay propiedades en OpenOffice.org Basic que consisten en
dos métodos a nivel UNO. Uno de estos se utiliza para consultar el valor de la propiedad y el otro se emite para
establecerlo ( obtener y establecer métodos). La propiedad ha sido virtualmente imitada por dos métodos. Objetos de personaje en
UNO, por ejemplo, proporciona los métodos getPosition y setPosition a través de los cuales la clave asociada
el punto se puede llamar y cambiar. El programador de OpenOffice.org Basic puede acceder a los valores a través del
Propiedad de posición . Independientemente de esto, los métodos originales también están disponibles (en nuestro ejemplo, getPosition
y setPosition ).
Métodos
Los métodos pueden entenderse como funciones que se relacionan directamente con un objeto y a través de las cuales se llama a este objeto.
El objeto Document anterior podría, por ejemplo, proporcionar un método Save , que se puede llamar de la siguiente manera:
Document.Save ()
Los métodos, al igual que las funciones, pueden contener parámetros y valores de retorno. La sintaxis de tales llamadas a métodos es
orientado a funciones clásicas. La siguiente llamada también especifica el parámetro True para el objeto de documento
al solicitar el método Guardar.
Ok = Documento.Guardar (Verdadero)
Una vez que se ha completado el método, Guardar guarda un valor de retorno en la variable Ok .
Página 52
Módulos, servicios e interfaces
Módulos, servicios e interfaces

OpenOffice.org ofrece cientos de servicios. Para proporcionar una descripción general de estos servicios, se han
combinados en módulos. Los módulos no tienen otra importancia funcional para OpenOffice.org Basic
programadores. Al especificar un nombre de servicio, solo el nombre del módulo es de importancia porque
esto también debe aparecer en el nombre. El nombre completo de un servicio consta de la expresión com.sun.star ,
que especifica que es un servicio de OpenOffice.org, seguido del nombre del módulo, como frame , y finalmente el
nombre del servicio real, como Escritorio . El nombre completo en el ejemplo mencionado sería:
Además de los términos del módulo y del servicio, UNO introduce el término "interfaz ". Si bien este término puede ser
familiar para los programadores de Java, no se utiliza en Basic.
Una interfaz combina varios métodos. En el sentido más estricto de la palabra, un servicio en UNO no admite
métodos, sino interfaces, que a su vez proporcionan diferentes métodos. En otras palabras, los métodos se asignan
(como combinaciones) al servicio en interfaces. Este detalle puede ser de interés en particular para Java o C ++
programadores, ya que en estos lenguajes se necesita la interfaz para solicitar un método. En OpenOffice.org Basic, este
es irrelevante. Aquí, los métodos se llaman directamente por medio del objeto relevante.
Sin embargo, para comprender la API, es útil tener la asignación de métodos a varias interfaces
útil, ya que se utilizan muchas interfaces en los diferentes servicios. Si está familiarizado con una interfaz, puede
Transfiera sus conocimientos de un servicio a otro.
Algunas interfaces centrales se utilizan con tanta frecuencia, activadas por diferentes servicios, que se vuelven a mostrar al final
de este capítulo.
Herramientas para trabajar con UNO

La pregunta sigue siendo qué objetos - o servicios si vamos a permanecer con la terminología de la ONU -
Apoyar qué propiedades, métodos e interfaces y cómo se pueden determinar. Además de esta guía,
puede obtener más información sobre los objetos de las siguientes fuentes: el método supportsService , el método de depuración
métodos, así como la Guía del desarrollador y la referencia de API.
El método supportsService
Varios objetos UNO admiten el método supportsService , con el que puede establecer si un
El objeto admite un servicio particular. La siguiente llamada, por ejemplo, determina si el objeto TextElement
admite el servicio com.sun.star.text.Paragraph.
Ok = TextElement.supportsService ("com.sun.star.text.Paragraph")
Propiedades de depuración
Cada objeto UNO sabe qué propiedades, métodos e interfaces ya contiene. OpenOffice.org Basic
proporciona propiedades que las devuelven en forma de una cadena que contiene una lista. Las propiedades correspondientes son:
DBG_properties
devuelve una cadena que contiene todas las propiedades de un objeto

DBG_methods
devuelve una cadena que contiene todos los métodos de un objeto

DBG_supportedInterfaces
devuelve una cadena que contiene todas las interfaces que admiten un objeto.
Capítulo 4 · Introducción a la API 53
Page 53
Herramientas para trabajar con UNO
El siguiente código de programa muestra cómo DBG_properties y DBG_methods se pueden utilizar en la vida real.
aplicaciones. Primero crea el servicio com.sun.star.frame.Desktop y luego muestra las propiedades admitidas
y métodos en los cuadros de mensajes.
Dim obj como objeto
Obj = createUnoService ("com.sun.star.frame.Desktop")
MsgBox Obj.DBG_Properties
MsgBox Obj.DBG_methods
Al usar DBG_properties , tenga en cuenta que la función devuelve todas las propiedades que los servicios ofrecidos por el objeto
teóricamente puede apoyar. Sin embargo, no se ofrece ninguna garantía de que el objeto también pueda utilizarlos.
en cuestión. En casos muy raros, antes de llamar a alguna propiedad, use la función IsEmpty para verificar si es
realmente disponible.
Herramientas de depuración
El uso de las propiedades DBG_ es un método muy burdo para descubrir el contenido de los objetos de una API.
La ventana de observación del IDE básico puede mostrar las propiedades de un objeto Uno (pero no los métodos, no los
interfaces).
Para mostrar toda la información disponible de un objeto y vincular a la documentación API correspondiente, utilice en su lugar
Herramienta de rayos X oHerramienta de resonancia magnética.
Nota - VBA: OpenOffice.org Basic no proporciona finalización de código. Solo en tiempo de ejecución puedes averiguarlo
qué propiedades o métodos están disponibles para un objeto. Todas las herramientas de depuración anteriores funcionan en un programa en ejecución.
Referencia de API
Puede encontrar más información sobre los servicios disponibles, sus interfaces, métodos y propiedades en el
referencia para la API de OpenOffice.org.
Descripción general de las interfaces centrales

Algunas interfaces de OpenOffice.org se pueden encontrar en muchas partes de la API de OpenOffice.org. Definen conjuntos de
métodos para tareas abstractas que se pueden aplicar a varios problemas. Aquí encontrará una descripción general de la mayoría
común de estas interfaces.
El origen de los objetos se explica más adelante en esta guía. En este punto, solo algunos de los aspectos abstractos
de objetos, para los cuales la API de OpenOffice.org proporciona algunas interfaces centrales, se discuten.
Creación de objetos dependientes del contexto
La API de OpenOffice.org ofrece dos opciones para crear objetos. Uno se puede encontrar en el
La función createUnoService mencionada al comienzo de este capítulo. createUnoService crea un objeto
que se puede utilizar universalmente. Estos objetos y servicios también se conocen como servicios independientes del contexto.
Además de los servicios independientes del contexto, también hay servicios dependientes del contexto cuyos objetos son solo
útil cuando se usa junto con otro objeto. Un objeto de dibujo para un documento de hoja de cálculo, por ejemplo,
por lo tanto, solo puede existir junto con este documento.
Página 54
Interfaz com.sun.star.lang.XMultiServiceFactory
Los objetos dependientes del contexto se crean normalmente mediante un método de objeto, del que depende el objeto. los
El método createInstance , que se define en la interfaz XMultiServiceFactory , se utiliza en particular en
los objetos del documento.
El objeto de dibujo se puede crear, por ejemplo, de la siguiente manera utilizando un objeto de hoja de cálculo:
Dim RectangleShape como objeto
RectangleShape = _
Spreadsheet.createInstance ("com.sun.star.drawing.RectangleShape")
Una plantilla de párrafo en un documento de texto se crea de la misma manera:

Estilo de atenuación como objeto
Style = Textdocument.createInstance ("com.sun.star.style.ParagraphStyle")
Acceso con nombre a objetos subordinados
Las interfaces XNameAccess y XNameContainer se utilizan en objetos que contienen objetos subordinados, que
se puede abordar utilizando un nombre en lenguaje natural.
Mientras que XNamedAccess permite el acceso a los objetos individuales, XNameContainer asume la inserción,
modificación y eliminación de elementos.
com.sun.star.container.XName Interfaz de acceso
Un ejemplo de la utilización de XNameAccess es proporcionada por el hojas objeto de una hoja de cálculo. Combina todas las
páginas dentro de la hoja de cálculo. Se accede a las páginas individuales desde el objeto hojas , utilizando getByName
método de XNameAccess :
Atenuar hojas como objeto
Sheets = Hoja de cálculo.
Hoja = Sheets.getByName ("Hoja1")
El método getElementNames proporciona una descripción general de los nombres de todos los elementos. Como resultado, devuelve un dato
campo que contiene los nombres. El siguiente ejemplo muestra cómo todos los nombres de elementos de una hoja de cálculo pueden
determinado y mostrado en un bucle:
Dim SheetNames
Dim I como entero

SheetNames = Sheets.getElementNames
Para I = LBound (SheetNames) a UBound (SheetNames)

MsgBox SheetNames (I)
Siguiente yo
El método hasByName de la interfaz XNameAccess revela si un objeto subordinado con una

El nombre existe dentro del objeto básico. Por tanto, el siguiente ejemplo muestra un mensaje que informa al usuario
si el objeto Hoja de cálculo contiene una página con el nombre Hoja1 .

Si Sheets.HasByName ("Sheet1"), entonces
MsgBox "Hoja1 disponible"
Más
MsgBox "Hoja1 no disponible"
Terminara si
Interfaz com.sun.star.container.XNameContainer
La interfaz XNameContainer asume la inserción, eliminación y modificación de elementos subordinados en un
Página 55
objeto básico. Las funciones responsables son insertByName , removeByName y replaceByName .
El siguiente es un ejemplo práctico de esto. Llama a un documento de texto, que contiene un objeto StyleFamilies
y lo utiliza para, a su vez, hacer que las plantillas de párrafo (ParagraphStyles) del documento estén disponibles.
Dim StyleFamilies como objeto
Dim ParagraphStyles como objeto
Atenuar NewStyle como objeto
StyleFamilies = Textdoc.StyleFamilies
ParagraphStyles = StyleFamilies.getByName ("ParagraphStyles")
ParagraphStyles.insertByName ("NewStyle", NewStyle)
ParagraphStyles.replaceByName ("ChangingStyle", NewStyle)
ParagraphStyles.removeByName ("OldStyle")
La línea insertByName inserta el estilo NewStyle bajo el nombre del mismo nombre en ParagraphStyles
objeto. La línea replaceByName cambia el objeto detrás de ChangingStyle a NewStyle . Finalmente, el
La llamada removeByName elimina el objeto detrás de OldStyle de ParagraphStyles .
Acceso basado en índices a objetos subordinados
Las interfaces XIndexAccess y XIndexContainer se utilizan en objetos que contienen objetos subordinados y
que se puede abordar mediante un índice.
XIndexAccess proporciona los métodos para acceder a objetos individuales. XIndexContainer proporciona métodos para
insertar y quitar elementos.
Interfaz com.sun.star.container.XIndexAccess
XIndexAccess proporciona los métodos getByIndex y getCount para llamar a los objetos subordinados.
getByIndex proporciona un objeto con un índice particular. getCount devuelve cuántos objetos están disponibles.
Dim I como entero
Para I = 0 a Sheets.getCount () - 1
Hoja = Sheets.getByIndex (I)
'Hoja de edición
Siguiente yo
El ejemplo muestra un bucle que recorre todos los elementos de la hoja uno tras otro y guarda una referencia a cada uno en
la variable de objeto Hoja . Cuando trabaje con índices, tenga en cuenta que getCount devuelve el número de elementos.
Sin embargo, los elementos de getByIndex se numeran comenzando con 0. La variable de conteo del ciclo
por lo tanto, va de 0 a getCount () - 1 .
Interfaz com.sun.star.container.XIndexContainer
La interfaz XIndexContainer proporciona las funciones insertByIndex y removeByIndex . Los parametros

están estructurados de la misma manera que las funciones correspondientes en XNameContainer .
Acceso iterativo a objetos subordinados
En algunos casos, un objeto puede contener una lista de objetos subordinados que no pueden ser identificados por un nombre
o un índice. En estas situaciones, las interfaces XEnumeration y XenumerationAccess son adecuadas. Ellos
Proporcionar un mecanismo a través del cual todos los elementos subordinados de un objeto puedan pasar, paso a paso, sin
tener que utilizar direccionamiento directo.
Page 56
com.sun.star.container.XEnumeration y XenumerationAccess
Interfaces
El objeto básico debe proporcionar la interfaz XEnumerationAccess , que contiene solo un createEnumeration
método. Esto devuelve un objeto auxiliar, que a su vez proporciona a la interfaz XEnumeration la
métodos hasMoreElements y nextElement . A través de ellos, tendrá acceso a los objetos subordinados.
El siguiente ejemplo recorre todos los párrafos de un texto:

Dim ParagraphEnumeration como objeto
Dim párrafo como objeto
ParagraphEnumeration = Textdoc.Text.createEnumeration
Mientras que ParagraphEnumeration.hasMoreElements ()

Párrafo = ParagraphEnumeration.nextElement ()
Encaminarse a
El ejemplo primero crea un objeto auxiliar ParagraphEnumeration . Esto devuelve gradualmente al individuo
párrafos del texto en un bucle. El bucle finaliza tan pronto como el método hasMoreElements devuelve el
Valor falso , que indica que se ha llegado al final del texto.
Página 57
5
CAPÍTULO 5
5 Trabajar con documentos
La API de OpenOffice.org se ha estructurado para que la mayor cantidad posible de sus partes se puedan utilizar universalmente para
diferentes tareas. Esto incluye las interfaces y los servicios para crear, abrir, guardar, convertir e imprimir.
documentos y para la administración de plantillas. Dado que estas áreas de función están disponibles en todo tipo de documentos,
se explican primero en este capítulo.
El StarDesktop
Estilos y plantillas
El documento actual
En versiones anteriores de la Guía básica de programación, estas instrucciones se usaban para obtener la
documento:
Dim Doc como objeto
Doc = StarDesktop.CurrentComponent
Este código correcto tiene un inconveniente: no funciona si la macro se inicia desde el IDE porque luego hace referencia a
el IDE, no el documento. ¡Este código solo funciona si la macro se inicia desde el propio documento!
En su lugar, debería utilizar el objeto básico ThisComponent . Devuelve el objeto de documento en el que se ejecuta la macro.
Si inicia la macro desde el IDE, ThisComponent todavía encontrará y devolverá su documento.
Dim Doc como objeto
Doc = ThisComponent 'codificación recomendada para Basic
El StarDesktop
Cuando se trabaja con documentos, se utilizan dos servicios con mayor frecuencia:
El servicio com.sun.star.frame.Desktop, que es similar al servicio principal de OpenOffice.org. Proporciona
las funciones para el objeto marco de OpenOffice.org, bajo las cuales se clasifican todas las ventanas de documentos.
Los documentos también se pueden crear, abrir e importar utilizando este servicio.
La funcionalidad básica para los objetos de documento individuales la proporciona el
servicio com.sun.star.document.OfficeDocument. Esto proporciona los métodos para guardar, exportar y
impresión de documentos.
El servicio com.sun.star.frame.Desktop se crea automáticamente cuando se inicia OpenOffice.org. Este servicio puede
ser direccionado en OpenOffice.org Basic usando el nombre global StarDesktop .
La interfaz más importante de StarDesktop es com.sun.star.frame.XComponentLoader. Esto básicamente
59
58
El StarDesktop
cubre el método loadComponentFromURL , que es responsable de crear, importar y abrir

documentos.
Nota - StarOffice 5: el nombre del objeto StarDesktop se remonta a StarOffice 5, en el que todos los documentos
Las ventanas estaban integradas en una aplicación común llamada StarDesktop . En la versión actual de
OpenOffice.org, ya no se usa un StarDesktop visible . Sin embargo, el nombre StarDesktop se mantuvo para
el objeto frame de OpenOffice.org porque indica claramente que se trata de un objeto básico para toda la aplicación.
El objeto StarDesktop reemplaza al objeto Aplicación de StarOffice 5 que anteriormente se aplicaba como raíz
objeto. Sin embargo, a diferencia del antiguo objeto Aplicación , StarDesktop es el principal responsable de abrir nuevos
documentos. Las funciones residentes en el antiguo objeto Aplicación para controlar la representación en pantalla de
OpenOffice.org (por ejemplo, FullScreen , FunctionBarVisible , Height , Width , Top , Visible ) no son
más usado.
Nota - VBA: mientras que el documento activo en Word se accede a través de Application.ActiveDocument
y en Excel a través de Application.ActiveWorkbook, en OpenOffice.org, StarDesktop es responsable
para esta tarea. Se accede al objeto de documento activo en OpenOffice.org a través del
StarDesktop.CurrentComponent , oa través de ThisComponent .
ThisComponent
El nombre global ThisComponent generalmente devuelve el mismo objeto que StarDesktop.CurrentComponent , con
una ventaja significativa. Si está ejecutando desde el IDE básico, depurando o explorando, entonces
StarDesktop devuelve el IDE básico en sí. Probablemente esto no sea lo que quieres. ThisComponent devuelve el último
documento previamente activo.
Información básica sobre documentos en OpenOffice.org
Cuando se trabaja con documentos de OpenOffice.org, resulta útil abordar algunos de los problemas básicos de
administración en OpenOffice.org. Esto incluye la forma en que se estructuran los nombres de archivo para OpenOffice.org
documentos, así como el formato en el que se guardan los archivos.
Nombres de archivo en notación URL
Dado que OpenOffice.org es una aplicación independiente de la plataforma, utiliza la notación URL (que es independiente de cualquier
sistema operativo), como se define en el estándar de Internet RFC 1738 para los nombres de archivo. Nombres de archivo estándar que usan este
el sistema comienza con el prefijo file: /// seguido de la ruta local. Si el nombre del archivo contiene subdirectorios, entonces
estos están separados por una sola barra diagonal, no con una barra invertida que se usa normalmente en Windows. El seguimiento
ruta hace referencia al archivo test.odt en el directorio doc de la unidad C :.
archivo: /// C: /doc/test.odt
Para convertir nombres de archivos locales en una URL, OpenOffice.org proporciona la función ConvertToUrl . Para convertir un
URL en un nombre de archivo local, OpenOffice.org proporciona la función ConvertFromUrl :
MsgBox ConvertToUrl ("C: \ doc \ test.odt")
'archivo de suministros: /// C: /doc/test.odt
MsgBox ConvertFromUrl ("archivo: /// C: /doc/test.odt")
'suministros (en Windows) c: \ doc \ test.odt
El ejemplo convierte un nombre de archivo local en una URL y lo muestra en un cuadro de mensaje. Luego convierte una URL en un
nombre del archivo local y también muestra este.
El estándar de Internet RFC 1738, en el que se basa, permite el uso de los caracteres 0-9 , az y AZ . Todas
otros caracteres se insertan como codificación de escape en las URL. Para hacer esto, se convierten en su hexadecimal
valor en el conjunto de caracteres UTF-8 y están precedidos por un signo de porcentaje. Un espacio en un nombre de archivo local, por lo tanto, para
ejemplo, se convierte en % 20 en la URL.
Página 59
El StarDesktop
Formato de archivo XML
Los documentos de OpenOffice.org se basan en el formato de archivo XML. Los archivos basados en XML se pueden abrir y editar con
otros programas.
Compresión de archivos
Dado que XML se basa en archivos de texto estándar, los archivos resultantes suelen ser muy grandes. OpenOffice.org por lo tanto
comprime los archivos y los guarda como un archivo ZIP. Mediante una opción del método storeAsURL , el usuario puede guardar
los archivos XML originales directamente. VerOpciones del método storeAsURL, a continuación.
Crear, abrir e importar documentos
Los documentos se abren, importan y crean utilizando el método StarDesktop.loadComponentFromURL (URL,

Frame, SearchFlags, FileProperties) El primer parámetro de loadComponentFromURL especifica la URL del
archivo asociado.
Como segundo parámetro, loadComponentFromURL espera un nombre para el objeto de marco de la ventana que
OpenOffice.org crea internamente para su administración. El nombre en blanco predefinido generalmente se especifica aquí,
y esto asegura que OpenOffice.org crea una nueva ventana.
Con estos parámetros, el usuario puede abrir un documento de OpenOffice.org, ya que los marcadores de posición (valores ficticios) pueden
ser asignado a los dos últimos parámetros:
Dim Doc como objeto
Atenuar URL como cadena
Dim Dummy () 'Una matriz (vacía) de PropertyValues
Url = "archivo: /// C: /test.odt"
Doc = StarDesktop.loadComponentFromURL (Url, "_blank", 0, ficticio)
La llamada anterior abre el archivo test.odt y lo muestra en una nueva ventana.
Se puede abrir cualquier número de documentos de esta manera en OpenOffice.org Basic y luego editar utilizando el
objetos de documento.
Nota: StarOffice 5: StarDesktop.loadComponentFromURL reemplaza a Documents.Add y

Documentos: métodos abiertos de la antigua API de OpenOffice.org.
Reemplazo del contenido de la ventana del documento
El valor _blank nombrado para el parámetro Frame asegura que OpenOffice.org crea una nueva ventana para cada
llamar desde loadComponentFromURL . En algunas situaciones, es útil reemplazar el contenido de una ventana existente.
En este caso, el objeto marco de la ventana debe contener un nombre explícito. Tenga en cuenta que este nombre no debe comenzar
con un guión bajo. Además, el parámetro SearchFlags debe configurarse para que el marco correspondiente
se crea, si aún no existe. La constante correspondiente para SearchFlags es:
SearchFlags = com.sun.star.frame.FrameSearchFlag.CREATE + _
com.sun.star.frame.FrameSearchFlag.ALL
El siguiente ejemplo muestra cómo el contenido de una ventana abierta se puede reemplazar con la ayuda del marco.
parámetro y SearchFlags :
Dim Doc como objeto
Dim Dummy ()
Atenuar las banderas de búsqueda tan largas
SearchFlags = com.sun.star.frame.FrameSearchFlag.CREATE + _
com.sun.star.frame.FrameSearchFlag.ALL
Url = "archivo: /// C: /test.odt"
Doc = StarDesktop.loadComponentFromURL (Url, "MyFrame", SearchFlags, Dummy)
Capítulo 5 · Trabajar con documentos 61
60
El StarDesktop
MsgBox "Presione Aceptar para mostrar el segundo documento".
Url = "archivo: /// C: /test2.odt"

Doc = StarDesktop.loadComponentFromURL (Url, "MyFrame", _
SearchFlags, ficticio)
El ejemplo abre primero el archivo test.odt en una nueva ventana con el nombre del marco de MyFrame . Una vez que el mensaje
se ha confirmado el cuadro, reemplaza el contenido de la ventana con el archivo test2.odt .
Opciones del método loadComponentFromURL
El cuarto parámetro de la función loadComponentFromURL es un campo de datos PropertyValue . que proporciona

OpenOffice.org con varias opciones para abrir y crear documentos. El campo de datos debe proporcionar un
PropertyValue estructura para cada opción en la que el nombre de la opción se guarda como una cadena, así como el
valor asociado.
loadComponentFromURL admite las siguientes opciones:

AsTemplate (booleano)
si es verdadero, carga un documento nuevo sin título desde la URL dada. Si es falso, los archivos de plantilla se cargan para su edición.
CharacterSet (cadena)
define en qué conjunto de caracteres se basa un documento.

FilterName (cadena)
especifica un filtro especial para la función loadComponentFromURL . Los nombres de filtro disponibles están definidos
en el archivo \ share \ config \ registry \ instance \ org \ openoffice \ office \ TypeDetection.xml .
FilterData (cadena)
define opciones adicionales para filtros.

FilterOptions (cadena)
define opciones adicionales (utilizadas por filtros antiguos).

Oculto (booleano)
value true carga el documento en modo invisible.

JumpMark (cadena)
una vez que se ha abierto un documento, salta a la posición definida en JumpMark.

MacroExecutionMode (entero)
indica si se pueden ejecutar macros de documentos. Valores: consulte com.sun.star.document.MacroExecMode

Contraseña (cadena)
transfiere una contraseña para un archivo protegido.

ReadOnly (booleano)
value true carga un documento en modo de solo lectura.

UpdateDocMode (entero)
indica cómo / si se actualizarán los enlaces. Valores: consulte com.sun.star.document.UpdateDocMode
El siguiente ejemplo muestra cómo un archivo de texto separado por una coma en OpenOffice.org Calc se puede abrir usando
la opción FilterName .
Dim Doc como objeto
Dim FileProperties (1) Como nuevo com.sun.star.beans.PropertyValue
Url = "archivo: /// C: /doc.csv"

FileProperties (0) .Name = "FilterName"
FileProperties (0) .Value = "Texto - txt - csv (StarCalc)"
FileProperties (1) .Name = "FilterOptions"
FileProperties (1) .value = "44,34,0,1"
Doc = StarDesktop.loadComponentFromURL (Url, "_blank", 0, FileProperties ())
Página 61
El StarDesktop
La matriz FileProperties tiene dos elementos, uno para cada opción utilizada. La propiedad Filtername define
si OpenOffice.org utiliza un filtro de texto Calc de OpenOffice.org para abrir archivos. La propiedad FilterOptions
contiene la descripción de la sintaxis del archivo csv.
Crear nuevos documentos
OpenOffice.org crea automáticamente un nuevo documento si el documento especificado en la URL es una plantilla.
Alternativamente, si solo se necesita un documento vacío sin ninguna adaptación, una URL privada: de fábrica puede ser
especificado:
Dim Dummy ()
Dim Doc como objeto
Url = "privado: fábrica / swriter"

Doc = StarDesktop.loadComponentFromURL (Url, "_blank", 0, Dummy ())
La llamada crea un documento de escritura de OpenOffice.org vacío.
Documentar objetos
La función loadComponentFromURL presentada en la sección anterior devuelve un objeto de documento. Esta

admite el servicio com.sun.star.document.OfficeDocument, que a su vez proporciona dos interfaces centrales:
La interfaz com.sun.star.frame.XStorable, que se encarga de guardar los documentos.
La interfaz com.sun.star.view.XPrintable, que contiene los métodos para imprimir documentos.
Guardar y exportar documentos
Los documentos de OpenOffice.org se guardan directamente a través del objeto de documento. El método de almacenamiento del
La interfaz com.sun.star.frame.XStorable está disponible para este propósito:
Doc.store ()
Esta llamada funciona siempre que al documento ya se le haya asignado un espacio de memoria. Este no es el caso para
nuevos documentos. En este caso, se utiliza el método storeAsURL . Este método también se define en
com.sun.star.frame.XStorable y se puede utilizar para definir la ubicación del documento:
Dim Dummy ()
Url = "archivo: /// C: /test3.odt"

Doc.storeAsURL (URL, Dummy ())
Además de los métodos anteriores, com.sun.star.frame.XStorable también proporciona algunos métodos de ayuda que son
útil al guardar documentos. Estos son:
hasLocation ()
especifica si al documento ya se le ha asignado una URL.

isReadonly ()
especifica si un documento tiene protección de solo lectura.

es modificado()
especifica si un documento se ha modificado desde la última vez que se guardó.
El código para guardar un documento se puede ampliar con estas opciones de modo que el documento solo se guarde si el objeto
realmente se ha modificado y el nombre del archivo solo se consulta si es realmente necesario:
Si (Doc. Está modificado) Entonces
Si (Doc.hasLocation And (Not Doc.isReadOnly)) Entonces
Doc.store ()
Más
Doc.storeAsURL (URL, Dummy ())
Página 62
El StarDesktop
Terminara si
Terminara si
El ejemplo primero verifica si el documento relevante se ha modificado desde la última vez que se guardó. Sólo
continúa con el proceso de guardado si este es el caso. Si el documento ya tiene asignada una URL y no es una
documento de solo lectura, se guarda en la URL existente. Si no tiene una URL o se abrió en su versión de solo lectura
estado, se guarda en una nueva URL.
Opciones del método storeAsURL
Al igual que con el método loadComponentFromURL , algunas opciones también se pueden especificar en forma de
Campo de datos PropertyValue utilizando el método storeAsURL . Estos determinan el procedimiento que utiliza OpenOffice.org
al guardar un documento. storeAsURL proporciona las siguientes opciones:
CharacterSet (cadena)
define en qué conjunto de caracteres se basa un documento.

FilterName (cadena)
especifica un filtro especial para la función loadComponentFromURL . Los nombres de filtro disponibles están definidos
en el archivo \ share \ config \ registry \ instance \ org \ openoffice \ office \ TypeDetection.xml .
FilterData (cadena)
define opciones adicionales para filtros.

FilterOptions (cadena)
define opciones adicionales (utilizadas por filtros antiguos).

Sobrescribir (booleano)
permite sobrescribir un archivo que ya existe sin una consulta.

transfiere la contraseña de un archivo protegido.

Desembalado (booleano)
guarda el documento (no comprimido) en subdirectorios.
Actualmente no se admite la posibilidad de almacenar documentos desempaquetados, la propiedad "Desempaquetado" es

simplemente ignorado, mira Edición 64364 .
El siguiente ejemplo muestra cómo se puede utilizar la opción Sobrescribir junto con storeAsURL :
Dim Doc como objeto
Dim FileProperties (0) Como nuevo com.sun.star.beans.PropertyValue
'... Inicializar Doc
Url = "archivo: /// c: /test3.odt"

FileProperties (0) .Name = "Sobrescribir"
FileProperties (0) .Value = True
Doc.storeAsURL (Url, FileProperties ())
A continuación, el ejemplo guarda Doc con el nombre de archivo especificado si ya existe un archivo con el nombre.
Imprimir documentos
Al igual que para guardar, los documentos se imprimen directamente mediante el objeto de documento. El método de impresión del
La interfaz com.sun.star.view.Xprintable se proporciona para este propósito. En su forma más simple, la llamada de impresión es:
Dim Dummy ()
Doc.print (Dummy ())
Como en el caso del método loadComponentFromURL , el parámetro Dummy es un campo de datos PropertyValue
a través del cual OpenOffice.org puede especificar varias opciones de impresión.
Page 63
El StarDesktop
Las opciones del método de impresión.
El método de impresión espera un campo de datos PropertyValue como parámetro, que refleja la configuración de la impresión.
diálogo de OpenOffice.org:
CopyCount (entero)
especifica el número de copias que se imprimirán.

Nombre de archivo (cadena)
imprime el documento en el archivo especificado.

Intercalar (booleano)
aconseja a la impresora que clasifique las páginas de las copias.

Ordenar (booleano)
ordena las páginas al imprimir varias copias ( CopyCount > 1).

Páginas (cadena)
contiene la lista de las páginas que se imprimirán (sintaxis como se especifica en el cuadro de diálogo de impresión).
Espera (booleano)
si se establece en Verdadero, el método de impresión volverá después de que el trabajo se almacene en la lista de espera de la impresora. Utilizar este
opción si desea cerrar el documento después de la impresión.
El siguiente ejemplo muestra cómo se pueden imprimir varias páginas de un documento utilizando la opción Páginas :
Dim Doc como objeto
Dim PrintProperties (1) Como nuevo com.sun.star.beans.PropertyValue
PrintProperties (0) .Name = "Páginas"

PrintProperties (0) .Value = "1-3; 7; 9"
PrintProperties (1) .Name = "Esperar"
PrintProperties (1) .Value = True
Doc.print (PrintProperties ())
Selección y configuración de la impresora
La interfaz com.sun.star.view.XPrintable proporciona la propiedad Printer , que selecciona la impresora. Esta

La propiedad recibe un campo de datos PropertyValue con la siguiente configuración:
Nombre (cadena)
especifica el nombre de la impresora.

PaperOrientation (Enum)
especifica la orientación del papel (valor com.sun.star.view.PaperOrientation.PORTRAIT para formato vertical,

com.sun.star.view.PaperOrientation.LANDSCAPE para formato apaisado).
PaperFormat (enumeración)
especifica el formato del papel (por ejemplo, com.sun.star.view.PaperFormat.A4 para DIN A4 o

com.sun.star.view.PaperFormat.Letter para letras estadounidenses).
PaperSize (tamaño)
especifica el tamaño del papel en centésimas de milímetro.
El siguiente ejemplo muestra cómo se puede cambiar una impresora y establecer el tamaño del papel con la ayuda de Printer
propiedad.
Dim Doc como objeto
Dim PrinterProperties (1) Como nuevo com.sun.star.beans.PropertyValue
Dim PaperSize As New com.sun.star.awt.Size
PaperSize.Width = 20000 'corresponde a 20 cm

PaperSize.Height = 20000 'corresponde a 20 cm
PrinterProperties (0) .Name = "Nombre"
PrinterProperties (0) .Value = "Mi HP Laserjet"
PrinterProperties (1) .Name = "PaperSize"
PrinterProperties (1) .Value = PaperSize
Capítulo 5 · Trabajar con documentos sesenta y cinco
Página 64
El StarDesktop
Doc.Printer = PrinterProperties ()
El ejemplo define un objeto llamado PaperSize con el tipo com.sun.star.awt.Size. Esto es necesario para especificar
el tamaño del papel. Además, crea un campo de datos para dos entradas PropertyValue llamadas PrinterProperties .
A continuación, este campo de datos se inicializa con los valores que se establecerán y se le asignará la propiedad Impresora . Desde el
Desde el punto de vista de la ONU, la impresora no es un inmueble sino una imitación.
Estilos
Los estilos son listas con nombre que contienen atributos de formato. Funcionan en todas las aplicaciones de OpenOffice.org y ayudan
para simplificar significativamente el formato. Si el usuario cambia uno de los atributos de un estilo, OpenOffice.org
ajusta automáticamente todas las secciones del documento según el atributo. Por tanto, el usuario puede, por ejemplo,
cambiar el tipo de fuente de todos los encabezados de nivel uno mediante una modificación central en el documento.
Tipos de estilo
Dependiendo de los tipos de documentos relevantes, OpenOffice.org reconoce una amplia gama de diferentes tipos de estilos.
OpenOffice.org Writer admite los siguientes tipos de estilos:

Estilos de personajes
Estilos de párrafo
Estilos de marco
Estilos de página
Estilos de numeración
OpenOffice.org Calc admite los siguientes tipos de estilos:

Estilos de celda
Estilos de página
OpenOffice.org Impress admite los siguientes tipos de estilos:

Estilos de elementos de carácter
Estilos de presentación
En la terminología de OpenOffice.org, los diferentes tipos de estilos se denominan StyleFamilies de acuerdo con la
com.sun.star.style.StyleFamily servicio en el que se basan. Se accede a las StyleFamilies mediante
el objeto del documento:
Dim Doc como objeto
Atenuar CellStyles como objeto
Doc = ThisComponent
StyleFamilies = Doc.StyleFamilies
CellStyles = StyleFamilies.getByName ("CellStyles")
El ejemplo usa la propiedad StyleFamilies de un documento de hoja de cálculo para establecer una lista que contenga todos
estilos de celda disponibles.
Se puede acceder a los estilos individuales directamente mediante un índice:

Dim Doc como objeto
Atenuar CellStyles como objeto
Atenuar CellStyle como objeto
Dim I como entero
Página 65
Doc = ThisComponent
CellStyles = StyleFamilies.getByName ("CellStyles")
Para I = 0 a CellStyles.Count - 1
CellStyle = CellStyles (I)
MsgBox CellStyle.Name
Siguiente yo
El bucle agregado desde el ejemplo anterior muestra los nombres de todos los estilos de celda uno tras otro en un mensaje
caja.
Nota - La referencia CellStyles (I) corresponde al método getByIndex () , que es opcional para estos
objetos de contenedor de estilo. Puede que no esté disponible en todos los tipos de documentos. El método getByName () es
obligatorio y siempre debe estar disponible.
Detalles sobre varias opciones de formato
Cada tipo de estilo proporciona una amplia gama de propiedades de formato individuales. Aquí hay una descripción general de la mayoría
propiedades de formato importantes y los puntos en los que se explican:
Propiedades de los personajes, servicio com.sun.star.style.CharacterProperties
Propiedades de párrafo, servicio com.sun.star.text.Paragraph
Propiedades de la celda, servicio com.sun.star.table.CellProperties
Propiedades de la página, servicio com.sun.star.style.PageProperties
Propiedades del elemento de carácter, Varios servicios
Las propiedades del formato no están restringidas de ninguna manera a las aplicaciones en las que se explican, sino que pueden
ser utilizado universalmente. Por ejemplo, la mayoría de las propiedades de la página descritas enPor tanto, las hojas de cálculo no se pueden utilizar
sólo en OpenOffice.org Calc, pero también en OpenOffice.org Writer.
Puede encontrar más información sobre cómo trabajar con estilos en la Valores predeterminados para carácter y párrafo
sección de propiedades enDocumentos de texto.
Plantillas
Las plantillas son documentos auxiliares. Proporcionan una forma muy conveniente de almacenar, mantener y distribuir estilos,
macros, texto de caldera y otras cosas útiles.
Tipos de documentos y plantillas
Cada tipo principal de documento de OpenOffice.org tiene su propio tipo de plantilla asociado. En general, y para estilos en
en particular, puede acceder a la información dentro de una plantilla de la misma manera que accedería a la misma información
en el tipo de documento asociado. En otras palabras, el código (como los ejemplos anteriores) que funciona en un
El tipo de documento también debería funcionar para el tipo de plantilla asociado.
Actualización automática
La mayoría de los tipos de plantillas (las plantillas de dibujo son la excepción) tienen una función de actualización automática. Si un estilo en el
se ha cambiado la plantilla, y abre un documento creado con esa plantilla, verá un mensaje preguntando
si actualizar los estilos en el documento. Si hace clic en Sí , los estilos nuevos o modificados se copiarán en
el documento. Los estilos eliminados de la plantilla no se eliminan de los documentos.
Puede surgir un problema si hace clic en No : los estilos no se actualizarán y la función de actualización automática se
apagado. A partir de la versión 3.1 de OpenOffice.org, este estado no se muestra en la GUI, ni hay ninguna forma de GUI para
vuelva a habilitar la función. (Solo para documentos de Writer, puede utilizar elExtensión Template Changer para configurar esta función
de nuevo.)
Página 66
La siguiente subrutina, adaptada de la extensión Template Changer, volverá a habilitar la función de actualización para todos
tipos de documentos.
Sub FixUpdate
Dim oDocSettings como objeto
oDocSettings = ThisComponent.createInstance ("com.sun.star.document.Settings")
oDocSettings.UpdateFromTemplate = True
End Sub 'FixUpdate
Página 67
6
CAPÍTULO 6
6 Documentos de texto
Además de las cadenas puras, los documentos de texto también contienen información de formato. Estos pueden aparecer en cualquier momento
el texto. La estructura se complica aún más con las tablas. Estos incluyen no solo cadenas unidimensionales, sino también
campos bidimensionales. La mayoría de los programas de procesamiento de texto ahora finalmente ofrecen la opción de colocar dibujos
objetos, marcos de texto y otros objetos dentro de un texto. Estos pueden estar fuera del flujo de texto y se pueden colocar
en cualquier lugar de la página.
Este capítulo presenta las interfaces y servicios centrales de los documentos de texto.
La estructura de los documentos de texto
Editar documentos de texto
Más que solo texto
La primera sección trata sobre la anatomía de los documentos de texto y se concentra en cómo un OpenOffice.org Basic
El programa se puede utilizar para realizar pasos iterativos a través de un documento de OpenOffice.org. Se centra en párrafos,
porciones de párrafo y su formato.
La segunda sección se enfoca en trabajar de manera eficiente con documentos de texto. Para ello, OpenOffice.org
proporciona varios objetos de ayuda, como el objeto TextCursor , que se extienden más allá de los especificados en el primer
sección.
La tercera sección va más allá del trabajo con textos. Se concentra en tablas, marcos de texto, campos de texto, marcadores,
directorios de contenido y más.
La información sobre cómo crear, abrir, guardar e imprimir documentos se describe en Trabajar con documentos,
porque se puede utilizar no solo para documentos de texto, sino también para otros tipos de documentos.

Un documento de texto puede contener básicamente cuatro tipos de información:
El texto real
Plantillas para formatear caracteres, párrafos y páginas
Elementos que no son de texto, como tablas, gráficos y objetos de dibujo
Configuración global para el documento de texto
Esta sección se concentra en el texto y las opciones de formato asociadas.
69
Página 68
Párrafos y partes de párrafos
El núcleo de un documento de texto consta de una secuencia de párrafos. Estos no están ni nombrados ni indexados y no
por lo tanto, no es posible acceder directamente a párrafos individuales. Sin embargo, los párrafos pueden ser
atravesado secuencialmente con la ayuda del objeto Enumeration descrito enIntroducción a la API. Esto permite
los párrafos que se van a editar.
Sin embargo, cuando se trabaja con el objeto Enumeration , se debe tener en cuenta un escenario especial: no solo devuelve
párrafos, pero también tablas (estrictamente hablando, en OpenOffice.org Writer, una tabla es un tipo especial de párrafo).
Antes de acceder a un objeto devuelto, debe comprobar si el objeto devuelto admite la
Servicio com.sun.star.text.Paragraph para párrafos o servicio com.sun.star.text.TextTable para tablas.
El siguiente ejemplo recorre el contenido de un documento de texto en un bucle y utiliza un mensaje en cada instancia para
informar al usuario si el objeto en cuestión es un párrafo o una tabla.
Dim Doc como objeto
Dim Enum como objeto
Atenuar TextElement como objeto
'Crear objeto de documento

Doc = ThisComponent
'Crear objeto de enumeración
Enum = Doc.Text.createEnumeration
'recorrer todos los elementos de texto
Mientras Enum.hasMoreElements
TextElement = Enum.nextElement
Si TextElement.supportsService ("com.sun.star.text.TextTable") Entonces

MsgBox "El bloque actual contiene una tabla".
Terminara si
Si TextElement.supportsService ("com.sun.star.text.Paragraph") Entonces

MsgBox "El bloque actual contiene un párrafo".
Terminara si
Encaminarse a
El ejemplo crea un objeto de documento Doc que hace referencia al documento actual de OpenOffice.org. Con el
Con la ayuda de Doc , el ejemplo crea un objeto de enumeración que atraviesa las partes individuales del
text (párrafos y tablas) y asigna el elemento actual al objeto TextElement . El ejemplo usa el
supportsService para comprobar si TextElement es un párrafo o una tabla.
Los párrafos
El servicio com.sun.star.text.Paragraph otorga acceso al contenido de un párrafo. El texto del párrafo puede
ser recuperado y modificado usando la propiedad String:
Dim Doc como objeto
Dim Enum como objeto
Doc = ThisComponent
Enum = Doc.Text.createEnumeration
Mientras Enum.hasMoreElements
TextElement = Enum.nextElement

TextElement.String = Reemplazar (TextElement.String, "usted", "U")
TextElement.String = Reemplazar (TextElement.String, "también", "2")
TextElement.String = Reemplazar (TextElement.String, "para", "4")
Terminara si
Encaminarse a
El ejemplo abre el documento de texto actual y lo recorre con la ayuda del objeto Enumeration. Eso
usa la propiedad TextElement.String en todos los párrafos para acceder a los párrafos relevantes y reemplaza el
usted también y para cadenas con U, 2 y 4 caracteres. La función Reemplazar utilizada para reemplazar no
caen dentro del ámbito lingüístico estándar de OpenOffice.org Basic. Esta es una instancia de la función de ejemplo
Página 69
descrito en Buscar y reemplazar.
Nota - VBA: El contenido del procedimiento descrito aquí para acceder a los párrafos de un texto es
comparable con la lista de párrafos utilizada en VBA, que se proporciona en los objetos Rango y Documento
disponible allí. Mientras que en VBA se accede a los párrafos por su número (por ejemplo, por el
Llamada al párrafo (1) ), en OpenOffice.org Basic, se debe utilizar el objeto Enumeration descrito anteriormente.
No hay una contraparte directa en OpenOffice.org Basic para las listas de caracteres, oraciones y palabras
proporcionado en VBA. Sin embargo, tiene la opción de cambiar a un TextCursor que permite la navegación
a nivel de personajes, oraciones y palabras.
Porciones de párrafo
El ejemplo anterior puede cambiar el texto según lo solicitado, pero a veces también puede destruir el formato.
Esto se debe a que un párrafo a su vez consta de subobjetos individuales. Cada uno de estos subobjetos contiene su propio
información de formato. Si el centro de un párrafo, por ejemplo, contiene una palabra impresa en negrita, entonces será
representado en OpenOffice.org por tres porciones de párrafo: la porción antes del tipo de negrita, luego la palabra en
negrita y, finalmente, la parte que sigue a la negrita, que de nuevo se muestra como normal.
Si el texto del párrafo ahora se cambia usando la propiedad String del párrafo , entonces OpenOffice.org primero
elimina las partes de párrafo antiguas e inserta una nueva parte de párrafo. El formato de las secciones anteriores es
luego perdido.
Para evitar este efecto, el usuario puede acceder a las partes del párrafo asociadas en lugar de a todo el párrafo.
Los párrafos proporcionan su propio objeto de enumeración para este propósito. El siguiente ejemplo muestra un bucle doble
que pasa por todos los párrafos de un documento de texto y las partes de párrafo que contienen y aplica la
procesos de sustitución del ejemplo anterior:
Dim Doc como objeto
Dim Enum1 como objeto
Atenuar TextPortion como objeto
Doc = ThisComponent
Enum1 = Doc.Text.createEnumeration
'recorrer todos los párrafos
Mientras Enum1.hasMoreElements
TextElement = Enum1.nextElement

Enum2 = TextElement.createEnumeration
'recorrer todos los subpárrafos
TextPortion = Enum2.nextElement
MsgBox "'" & TextPortion.String & "'"
TextPortion.String = Reemplazar (TextPortion.String, "usted", "U")
TextPortion.String = Reemplazar (TextPortion.String, "también", "2")
TextPortion.String = Reemplazar (TextPortion.String, "para", "4")
Encaminarse a
Terminara si
Encaminarse a
El ejemplo se ejecuta en un documento de texto en un ciclo doble. El bucle exterior se refiere a los párrafos del texto.
El ciclo interno procesa las partes de párrafo en estos párrafos. El código de ejemplo modifica el contenido en
cada una de estas porciones de párrafo utilizando la propiedad String de la cadena. como es el caso en el ejemplo anterior
para los párrafos. Sin embargo, dado que las partes de los párrafos se editan directamente, su información de formato se conserva
al reemplazar la cuerda.
Capítulo 6 · Documentos de texto 71
Página 70
Formateo
Hay varias formas de formatear el texto. La forma más sencilla es asignar las propiedades del formato directamente al texto.
secuencia. A esto se le llama formato directo. El formateo directo se utiliza en particular con documentos cortos porque
los formatos pueden ser asignados por el usuario con el mouse. Puede, por ejemplo, resaltar una determinada palabra dentro de un
texto en negrita o en el centro de una línea.
Además del formato directo, también puede formatear el texto utilizando plantillas. A esto se le llama formato indirecto. Con
formato indirecto, el usuario asigna una plantilla predefinida a la parte de texto relevante. Si el diseño del texto es
cambiado en una fecha posterior, el usuario solo necesita cambiar la plantilla. OpenOffice.org luego cambia la forma en
en el que se representan todas las porciones de texto que utilizan esta plantilla.
Nota - VBA: en VBA, las propiedades de formato de un objeto generalmente se distribuyen en un rango de subobjetos
(por ejemplo, Range.Font , Range.Borders , Range.Shading , Range.ParagraphFormat ). Las propiedades son
se accede mediante expresiones en cascada (por ejemplo, Range.Font.AllCaps ). En OpenOffice.org Basic, el
las propiedades de formato por otro lado están disponibles directamente, utilizando los objetos relevantes ( TextCursor,
Párrafo , etc.). Encontrará una descripción general de las propiedades de caracteres y párrafos disponibles en
OpenOffice.org en las dos secciones siguientes.
Nota: las propiedades de formato se pueden encontrar en cada objeto ( párrafo, TextCursor , etc.) y
ser aplicado directamente.
Propiedades del personaje
Las propiedades de formato que hacen referencia a caracteres individuales se describen como propiedades de carácter. Éstos incluyen
negrita y el tipo de fuente. Los objetos que permiten establecer las propiedades de los personajes deben
Servicio com.sun.star.style.CharacterProperties. OpenOffice.org reconoce una amplia gama de servicios que admiten
este servicio. Estos incluyen los servicios com.sun.star.text.Paragraph descritos anteriormente para párrafos y
los servicios com.sun.star.text.TextPortion para partes de párrafos.
El servicio com.sun.star.style.CharacterProperties no proporciona ninguna interfaz, sino que ofrece una gama de
propiedades a través de las cuales se pueden definir y llamar propiedades de carácter. Una lista completa de todos los personajes
Las propiedades se pueden encontrar en la referencia API de OpenOffice.org. La siguiente lista describe los más importantes
propiedades:
CharFontName (cadena)
nombre del tipo de fuente seleccionado.

CharColor (largo)
color de texto.
CharHeight (flotar)
altura del carácter en puntos (pt).

CharUnderline (grupo constante)
tipo de subrayado (constantes de acuerdo con com.sun.star.awt.FontUnderline).

CharWeight (grupo constante)
peso de la fuente (constantes de acuerdo con com.sun.star.awt.FontWeight).

CharBackColor (largo)
color de fondo.
CharKeepTogether (booleano)
supresión de salto de línea automático.

CharStyleName (cadena)
nombre de la plantilla de personaje.
Page 71
Propiedades de párrafo
Se considera que la información de formato que no se refiere a caracteres individuales, sino a todo el párrafo
ser una propiedad de párrafo. Esto incluye la distancia del párrafo desde el borde de la página, así como la línea.
espaciado. Las propiedades del párrafo están disponibles a través del servicio com.sun.star.style.ParagraphProperties.
Incluso las propiedades de párrafo están disponibles en varios objetos. Todos los objetos que soportan el
El servicio com.sun.star.text.Paragraph también proporciona soporte para las propiedades de párrafo en
com.sun.star.style.ParagraphProperties.
Puede encontrar una lista completa de las propiedades de los párrafos en la referencia API de OpenOffice.org. Lo mas
Las propiedades comunes de los párrafos son:
ParaAdjust (enumeración)
orientación vertical del texto (constantes de acuerdo con com.sun.star.style.ParagraphAdjust).

ParaLineSpacing (estructura)
interlineado (estructura de acuerdo con com.sun.star.style.LineSpacing).

ParaBackColor (largo)
color de fondo.
ParaLeftMargin (largo)
margen izquierdo en centésimas de milímetro.

ParaRightMargin (largo)
margen derecho en centésimas de milímetro.

ParaTopMargin (largo)
margen superior en centésimas de milímetro.

ParaBottomMargin (largo)
margen inferior en centésimas de milímetro.

ParaTabStops (matriz de estructura)
tipo y posición de las pestañas (matriz con estructuras del tipo com.sun.star.style.TabStop).
ParaStyleName (cadena)
nombre de la plantilla de párrafo.
Ejemplo: exportación HTML simple
El siguiente ejemplo demuestra cómo trabajar con información de formato. Se itera a través de un texto.
documento y crea un archivo HTML simple. Cada párrafo se registra en su propio elemento HTML para este
propósito. Las partes de los párrafos que se muestran en negrita se marcan con un elemento HTML al exportar.
Dim FileNo como entero, nombre de archivo como cadena, CurLine como cadena
Dim Doc como objeto
Dim Enum1 como objeto, Enum2 como objeto
Atenuar TextElement como objeto, TextPortion como objeto
Nombre de archivo = "c: \ text.html"

FileNo = Freefile
Abrir nombre de archivo para salida como #FileNo
Imprimir #FileNo, "<HTML> <BODY>"
Doc = ThisComponent


CurLine = ""
Página 72
'recorrer todas las partes del párrafo

Si TextPortion.CharWeight = com.sun.star.awt.FontWeight.BOLD THEN

CurLine = CurLine & "" & TextPortion.String & ""
Más
CurLine = CurLine y TextPortion.String
Terminara si
Encaminarse a
'salida de la línea
CurLine = CurLine & ""
Imprimir #FileNo, CurLine
Terminara si
Encaminarse a
'escribir pie de página HTML

Imprimir #FileNo, "</BODY> </HTML>"
Cerrar #FileNo
La estructura básica del ejemplo está orientada hacia los ejemplos para ejecutar a través de las porciones de párrafo de
un texto ya comentado anteriormente. Las funciones para escribir el archivo HTML, así como un código de prueba que verifica
el peso de la fuente de las porciones de texto correspondientes y proporciona porciones de párrafo en
etiqueta HTML correspondiente.
Valores predeterminados para propiedades de carácter y párrafo
El formato directo siempre tiene prioridad sobre el formato indirecto . En otras palabras, formatear usando plantillas es
asignó una prioridad más baja que el formato directo en un texto.
No es fácil establecer si una sección de un documento se ha formateado directa o indirectamente. El símbolo

las barras proporcionadas por OpenOffice.org muestran las propiedades comunes del texto, como el tipo de fuente, el peso y el tamaño. Sin embargo,
Aún no está claro si la configuración correspondiente se basa en una plantilla o en el formato directo del texto.
OpenOffice.org Basic proporciona el método getPropertyState , con el que los programadores pueden comprobar cómo
cierta propiedad fue formateada. Como parámetro, toma el nombre de la propiedad y devuelve una constante que
proporciona información sobre el origen del formato. Las siguientes respuestas, que se definen en el
com.sun.star.beans.PropertyState, son posibles:
com.sun.star.beans.PropertyState.DIRECT_VALUE
la propiedad se define directamente en el texto (formato directo)

com.sun.star.beans.PropertyState.DEFAULT_VALUE
la propiedad está definida por una plantilla (formato indirecto)

com.sun.star.beans.PropertyState.AMBIGUOUS_VALUE
la propiedad no está clara. Este estado surge, por ejemplo, al consultar la propiedad de tipo negrita de un
párrafo, que incluye tanto las palabras en negrita como las palabras en letra normal.
El siguiente ejemplo muestra cómo se pueden editar las propiedades de formato en OpenOffice.org. Busca a través de un texto
para las porciones de párrafos que se han representado en negrita utilizando formato directo. Si encuentra un
parte del párrafo correspondiente, elimina el formato directo utilizando el método setPropertyToDefault y
asigna una plantilla de caracteres MyBold a la parte del párrafo correspondiente.
Dim Doc como objeto
Atenuar TextPortion como objeto
Doc = ThisComponent

Page 73

'recorrer todas las partes del párrafo
Si TextPortion.CharWeight = _
com.sun.star.awt.FontWeight.BOLD AND _
TextPortion.getPropertyState ("CharWeight") = _
com.sun.star.beans.PropertyState.DIRECT_VALUE Entonces
TextPortion.setPropertyToDefault ("CharWeight")
TextPortion.CharStyleName = "MyBold"
Terminara si
Encaminarse a
Terminara si
Encaminarse a

La sección anterior ya ha discutido una amplia gama de opciones para editar documentos de texto, centrándose en la
servicios com.sun.star.text.TextPortion y com.sun.star.text.Paragraph, que otorgan acceso a partes de párrafos
así como párrafos. Estos servicios son apropiados para aplicaciones en las que se va a editar el contenido de un texto.
en una pasada a través de un bucle. Sin embargo, esto no es suficiente para muchos problemas. OpenOffice.org proporciona la
servicio com.sun.star.text.TextCursor para tareas más complicadas, incluida la navegación hacia atrás dentro de un
documento o navegación basada en oraciones y palabras en lugar de TextPortions .
El TextCursor
Un TextCursor en la API de OpenOffice.org es comparable con el cursor visible utilizado en OpenOffice.org

documento. Marca un cierto punto dentro de un documento de texto y se puede navegar en varias direcciones a través del
uso de comandos. Sin embargo, los objetos TextCursor disponibles en OpenOffice.org Basic no deben confundirse
con el cursor visible. Estas son dos cosas muy diferentes.
Nota - VBA: la terminología difiere de la utilizada en VBA: en términos del alcance de la función, el objeto Range
de VBA se puede comparar con el objeto TextCursor en OpenOffice.org y no, ya que el nombre posiblemente
sugiere - con el objeto Range en OpenOffice.org.
El objeto TextCursor en OpenOffice.org, por ejemplo, proporciona métodos para navegar y cambiar el texto que
se incluyen en el objeto Range en VBA (por ejemplo, MoveStart, MoveEnd, InsertBefore, InsertAfter). los
las contrapartes correspondientes del objeto TextCursor en OpenOffice.org se describen en las siguientes secciones.
Navegar dentro de un texto
El objeto TextCursor en OpenOffice.org Basic actúa independientemente del cursor visible en un documento de texto.
Un cambio de posición controlado por programa de un objeto TextCursor no tiene ningún impacto en el cursor visible.
Incluso se pueden abrir varios objetos TextCursor para el mismo documento y utilizarlos en varias posiciones, que son
independientes unos de otros.
Un objeto TextCursor se crea usando la llamada createTextCursor :

Dim Doc como objeto
Atenuar el cursor como objeto
Doc = ThisComponent
Cursor = Doc.Text.createTextCursor ()
El objeto Cursor creado de esta manera admite el servicio com.sun.star.text.TextCursor , que a su vez
proporciona una amplia gama de métodos para navegar dentro de documentos de texto. El siguiente ejemplo mueve primero el
TextCursor diez caracteres a la izquierda y luego tres caracteres a la derecha:
Page 74
Cursor.goLeft (10, falso)

Cursor.goRight (3, falso)
Un TextCursor puede resaltar un área completa. Esto se puede comparar con resaltar un punto en el texto usando
el ratón. El parámetro False en la llamada de función anterior especifica si el área pasó con el
se resalta el movimiento del cursor. Por ejemplo, TextCursor en el siguiente ejemplo
Cursor.goLeft (3, verdadero)
primero mueve diez caracteres hacia la derecha sin resaltar, y luego retrocede tres caracteres y resalta
esta. Por lo tanto, el área resaltada por TextCursor comienza después del séptimo carácter en el texto y termina
después del décimo carácter.
Estos son los métodos centrales que el servicio com.sun.star.text.TextCursor proporciona para la navegación:
goLeft (contar, expandir)
salta Contar caracteres a la izquierda.

goRight (contar, expandir)
salta Contar caracteres a la derecha.

gotoStart (expandir)
salta al inicio del documento de texto.

gotoEnd (expandir)
salta al final del documento de texto.

gotoRange (TextRange, Expandir)
salta al TextRange -Object especificado .

gotoStartOfWord (expandir)
salta al comienzo de la palabra actual.

gotoEndOfWord (expandir)
salta al final de la palabra actual.

gotoNextWord (expandir)
salta al comienzo de la siguiente palabra.

gotoPreviousWord (Expandir)
salta al comienzo de la palabra anterior.

isStartOfWord ()
devuelve True si TextCursor está al comienzo de una palabra.

isEndOfWord ()
devuelve True si TextCursor está al final de una palabra.

gotoStartOfSentence (expandir)
salta al comienzo de la oración actual.

gotoEndOfSentence (expandir)
salta al final de la oración actual.

gotoNextSentence (expandir)
salta al comienzo de la siguiente oración.

gotoPreviousSentence (expandir)
salta al comienzo de la oración anterior.

isStartOfSentence ()
devuelve True si TextCursor está al comienzo de una oración.
Página 75
isEndOfSentence ()
devuelve True si TextCursor está al final de una oración.

gotoStartOfParagraph (expandir)
salta al inicio del párrafo actual.

gotoEndOfParagraph (expandir)
salta al final del párrafo actual.

gotoNextParagraph (expandir)
salta al comienzo del siguiente párrafo.

gotoPreviousParagraph (Expandir)
salta al inicio del párrafo anterior.

isStartOfParagraph ()
devuelve True si TextCursor está al comienzo de un párrafo.

isEndOfParagraph ()
devuelve True si TextCursor está al final de un párrafo.
El texto se divide en oraciones sobre la base de símbolos de oración. Los períodos se interpretan, por ejemplo, como
símbolos que indican el final de las oraciones. (En inglés, al menos, deben ir seguidos de un espacio, tabulación o retorno para
esto funciona.)
El parámetro Expandir es un valor booleano que especifica si el área pasada durante la navegación debe ser
resaltado. Además, todos los métodos de navegación devuelven un parámetro booleano que especifica si el
la navegación fue exitosa o si la acción se terminó por falta de texto.
La siguiente es una lista de varios métodos para editar áreas resaltadas usando un TextCursor y que también
admite el servicio com.sun.star.text.TextCursor:
collapseToStart ()
restablece el resaltado y coloca el TextCursor al comienzo del área resaltada anteriormente.

collapseToEnd ()
restablece el resaltado y coloca el TextCursor al final del área resaltada anteriormente.

isCollapsed ()
devuelve True si TextCursor no cubre ningún resaltado en este momento.
Dar formato al texto con TextCursor
El servicio com.sun.star.text.TextCursor admite todas las propiedades de caracteres y párrafos que se presentaron
al comienzo de este capítulo.
El siguiente ejemplo muestra cómo se pueden utilizar junto con un TextCursor . Pasa por un
complete el documento y formatee la primera palabra de cada oración en negrita.
Dim Doc como objeto
Dim Proceder como booleano
Doc = ThisComponent
Cursor = Doc.Text.createTextCursor
Hacer
Cursor.gotoEndOfWord (verdadero)
Cursor.CharWeight = com.sun.star.awt.FontWeight.BOLD
Proceed = Cursor.gotoNextSentence (Falso)
Cursor.gotoNextWord (Falso)
Bucle mientras se avanza
El ejemplo primero crea un objeto de documento para el texto que se acaba de abrir. Luego recorre el
texto completo, frase por frase, y resalta cada una de las primeras palabras y le da formato en negrita.
Page 76
Recuperar y modificar contenido de texto
Si un TextCursor contiene un área resaltada, entonces este texto está disponible por medio de la propiedad String del
Objeto TextCursor . El siguiente ejemplo usa la propiedad String para mostrar las primeras palabras de una oración en un
caja de mensaje:
Dim Doc como objeto
Doc = ThisComponent
Hacer
MsgBox Cursor.String
La primera palabra de cada oración se puede modificar de la misma manera usando la propiedad String :
Dim Doc como objeto
Doc = ThisComponent
Hacer
Cursor.String = "Ups"
Si el TextCursor contiene un área resaltada, una asignación a la propiedad String la reemplaza con la nueva
texto. Si no hay un área resaltada, el texto se inserta en la posición actual del TextCursor .
Insertar códigos de control
En algunas situaciones, no es el texto real de un documento, sino su estructura lo que debe modificarse.
OpenOffice.org proporciona códigos de control para este propósito. Estos se insertan en el texto e influyen en su estructura.
Los códigos de control se definen en el grupo de constantes com.sun.star.text.ControlCharacter. El seguimiento
Los códigos de control están disponibles en OpenOffice.org:
PARAGRAPH_BREAK
salto de párrafo.
LINE_BREAK
salto de línea dentro de un párrafo.

SOFT_HYPHEN
posible punto de silabeo.

HARD_HYPHEN
punto obligatorio para la silabificación.

HARD_SPACE
espacio protegido que no se extiende ni se comprime en texto justificado.
Para insertar los códigos de control, no solo necesita el cursor, sino también los objetos de documento de texto asociados. los
El siguiente ejemplo inserta un párrafo después del vigésimo carácter de un texto:
Dim Doc como objeto
Doc = ThisComponent
Page 77
Doc.Text.insertControlCharacter (Cursor, _
com.sun.star.text.ControlCharacter.PARAGRAPH_BREAK, Falso)
El parámetro False en la llamada del método insertControlCharacter asegura que el área actualmente
resaltado por TextCursor permanece después de la operación de inserción. Si el parámetro True se pasa aquí, entonces
insertControlCharacter reemplaza el texto actual.
Búsqueda de porciones de texto
En muchos casos, se da el caso de que en un texto se busque un término en particular y el punto correspondiente
necesita ser editado. Todos los documentos de OpenOffice.org proporcionan una interfaz especial para este propósito, y esta interfaz
siempre funciona de acuerdo con el mismo principio: antes de un proceso de búsqueda, lo que comúnmente se denomina
Primero se debe crear un SearchDescriptor . Esto define lo que busca OpenOffice.org en un documento. UNA
SearchDescriptor es un objeto que admite com.sun.star.util. Servicio SearchDescriptor y
se puede crear mediante el método createSearchDescriptor de un documento:
Dim SearchDesc como objeto
SearchDesc = Doc.createSearchDescriptor
Una vez que se ha creado el SearchDescriptor , recibe el texto a buscar:

SearchDesc.searchString = "cualquier texto"
En términos de su función, SearchDescriptor se compara mejor con el diálogo de búsqueda de OpenOffice.org.

De manera similar a la ventana de búsqueda, la configuración necesaria para una búsqueda se puede establecer en SearchDescriptor
objeto.
Las propiedades las proporciona el servicio com.sun.star.util.SearchDescriptor:

SearchBackwards (booleano)
busca en el texto hacia atrás en lugar de hacia adelante.

SearchCaseSensitive (booleano)
toma en consideración los caracteres en mayúsculas y minúsculas durante la búsqueda.

SearchRegularExpression (booleano)
trata la expresión de búsqueda como una expresión regular.

SearchStyles (booleano)
busca en el texto la plantilla de párrafo especificada.

Palabras de búsqueda (booleano)
solo busca palabras completas.
La función SearchSimilarity (o “coincidencia aproximada ”) de OpenOffice.org también está disponible en OpenOffice.org Basic.
Con esta función, OpenOffice.org busca una expresión que puede ser similar pero no exactamente igual a
la expresión de búsqueda. El número de caracteres adicionales, eliminados y modificados para estas expresiones se puede
definido individualmente. Estas son las propiedades asociadas de com.sun.star.util.SearchDescriptor
Servicio:
SearchSimilarity (booleano)
realiza una búsqueda de similitudes.

SearchSimilarityAdd (breve)
número de caracteres que se pueden agregar para una búsqueda de similitud.

SearchSimilarityExchange (breve)
número de caracteres que se pueden reemplazar como parte de una búsqueda de similitud.
SearchSimilarityRemove (breve)
número de caracteres que pueden eliminarse como parte de una búsqueda de similitud.
SearchSimilarityRelax (booleano)
tiene en cuenta todas las reglas de desviación al mismo tiempo para la expresión de búsqueda.
Página 78
Una vez que se ha preparado SearchDescriptor según lo solicitado, se puede aplicar al documento de texto. los
Los documentos de OpenOffice.org proporcionan los métodos findFirst y findNext para este propósito:
Encontrado = Doc.findFirst (SearchDesc)
Hacer hasta que sea nulo (encontrado)

'Editar resultados de búsqueda ...
Encontrado = Doc.findNext (Found.End, SearchDesc)
Lazo
El ejemplo busca todas las coincidencias en un bucle y devuelve un objeto TextRange , que se refiere al pasaje de texto encontrado.
Ejemplo: búsqueda por similitud
Este ejemplo muestra cómo se puede buscar en un texto la palabra "facturación" y los resultados formateados en negrita. UNA
La búsqueda de similitudes se utiliza para que no sólo la palabra "rotación", sino también la forma plural "pérdidas de balón" y
Se encuentran declinaciones como "volumen de negocios". Las expresiones encontradas difieren hasta en dos letras de la búsqueda.
expresión:
Dim SearchDesc como objeto
Dim Doc como objeto
Doc = ThisComponent
SearchDesc = Doc.createSearchDescriptor
SearchDesc.SearchString = "facturación"
SearchDesc.SearchSimilarity = True
SearchDesc.SearchSimilarityAdd = 2
SearchDesc.SearchSimilarityExchange = 2
SearchDesc.SearchSimilarityRemove = 2
SearchDesc.SearchSimilarityRelax = Falso
Encontrado = Doc.findFirst (SearchDesc)
Hacer hasta que sea nulo (encontrado)

Found.CharWeight = com.sun.star.awt.FontWeight.BOLD
Encontrado = Doc.findNext (Found.End, SearchDesc)
Lazo
Nota - VBA: la idea básica de buscar y reemplazar en OpenOffice.org es comparable a la que se usa en VBA. Ambos
Las interfaces le proporcionan un objeto, a través del cual se pueden definir las propiedades para buscar y reemplazar.
Este objeto se aplica luego al área de texto requerida para realizar la acción. Considerando que el responsable
Se puede acceder al objeto auxiliar en VBA a través de la propiedad Find del objeto Range, en OpenOffice.org Basic
es creado por la llamada createSearchDescriptor o createReplaceDescriptor del objeto de documento.
Incluso las propiedades de búsqueda y los métodos disponibles difieren.
Como en la antigua API de OpenOffice.org, la búsqueda y reemplazo de texto en la nueva API también se realiza utilizando el
objeto de documento. Mientras que anteriormente había un objeto llamado SearchSettings especialmente para definir el
opciones de búsqueda, en el nuevo objeto, las búsquedas ahora se realizan utilizando un SearchDescriptor o
Reemplazar objeto Descriptor para reemplazar texto automáticamente. Estos objetos cubren no solo las opciones, sino también
el texto de búsqueda actual y, si es necesario, el reemplazo de texto asociado. Los objetos descriptores se crean utilizando
el objeto del documento, completado de acuerdo con las solicitudes relevantes, y luego transferido de nuevo al
objeto de documento como parámetros para los métodos de búsqueda.
Reemplazo de partes de texto
Al igual que con la función de búsqueda, la función de sustitución de OpenOffice.org también está disponible en
OpenOffice.org Basic. Las dos funciones se manejan de manera idéntica. Un objeto especial que registra los parámetros.
para el proceso también se necesita primero para un proceso de reemplazo. Se llama ReplaceDescriptor y admite la
servicio com.sun.star.util.ReplaceDescriptor. Todas las propiedades del SearchDescriptor descritas en el
El párrafo anterior también es compatible con ReplaceDescriptor. Por ejemplo, durante un proceso de reemplazo,
la distinción entre mayúsculas y minúsculas también se puede activar y desactivar, y se pueden realizar búsquedas de similitudes.
El siguiente ejemplo demuestra el uso de ReplaceDescriptors para una búsqueda dentro de OpenOffice.org
documento.
Dim I As Long
Dim Doc como objeto
Página 79
Dim Reemplazar como objeto

Dim BritishWords (5) como cadena
Atenuar USWords (5) como cadena
BritishWords () = Array ("color", "vecino", "centro", "comportamiento", _

"metro", "hasta")
USWords () = Array ("color", "vecino", "centro", "comportamiento", _
"metro", "hasta")
Doc = ThisComponent
Reemplazar = Doc.createReplaceDescriptor
Para I = 0 a 5
Replace.SearchString = Palabras británicas (I)
Reemplazar.ReplaceString = USWords (I)
Doc.replaceAll
Siguiente yo (Reemplazar)
Las expresiones para buscar y reemplazar se establecen utilizando las propiedades SearchString y ReplaceString de
los ReplaceDescriptors . El proceso de reemplazo real finalmente se implementa utilizando el método replaceAll
método del objeto de documento, que reemplaza todas las apariciones de la expresión de búsqueda.
Ejemplo: buscar y reemplazar texto con expresiones regulares
La función de reemplazo de OpenOffice.org es particularmente efectiva cuando se usa junto con

expresiones Estos brindan la opción de definir una expresión de búsqueda de variable con marcadores de posición y
caracteres en lugar de un valor fijo.
Las expresiones regulares compatibles con OpenOffice.org se describen en detalle en la sección de ayuda en línea para
OpenOffice.org. Aquí están algunos ejemplos:
Un punto dentro de una expresión de búsqueda representa cualquier carácter. Por tanto, la expresión de búsqueda sh.rt puede estar
tanto para camiseta como para short .
El carácter ^ marca el comienzo de un párrafo. Todas las apariciones del nombre Peter que están al comienzo de un
por lo tanto, el párrafo se puede encontrar usando la expresión de búsqueda ^ Peter .
El carácter $ marca el final de un párrafo. Todas las apariciones del nombre Peter que están al final de un párrafo
por lo tanto, se puede encontrar usando la expresión de búsqueda Peter $ .
Un * indica que el carácter anterior se puede repetir cualquier número de veces. Se puede combinar con el
período como marcador de posición para cualquier personaje. La expresión temperamento. * E , por ejemplo, puede representar la
Expresiones templanza y temperatura .
El siguiente ejemplo muestra cómo se pueden eliminar todas las líneas vacías de un documento de texto con la ayuda del
expresión ^ $:
Dim Doc como objeto
Dim Reemplazar como objeto
Dim I As Long
Doc = ThisComponent
Reemplazar = Doc.createReplaceDescriptor
Reemplazar.SearchRegularExpression = True
Reemplazar.SearchString = "^ $"
Replace.ReplaceString = ""
Doc.replaceAll (Reemplazar)
Más que solo texto

Hasta ahora, este capítulo solo se ha ocupado de los párrafos de texto y sus partes. Pero los documentos de texto también pueden contener
otros objetos Estos incluyen tablas, dibujos, campos de texto y directorios. Todos estos objetos se pueden anclar a
cualquier punto dentro de un texto.
Gracias a estas características comunes, todos estos objetos en OpenOffice.org admiten un servicio básico común llamado
com.sun.star.text.TextContent. Esto proporciona las siguientes propiedades:
80
Más que solo texto
AnchorType (enumeración)
determina el tipo de anclaje de un objeto TextContent (valores predeterminados de acuerdo con

com.sun.star.text.TextContentAnchorType enumeración).
AnchorTypes (secuencia de Enum)
enumeración de todos los AnchorTypes que admiten un objeto TextContent especial .

TextWrap (enumeración)
determina el tipo de ajuste de texto alrededor de un objeto TextContent (valores predeterminados de acuerdo con
com.sun.star.text.WrapTextMode enumeración).
Los objetos TextContent también comparten algunos métodos, en particular, aquellos para crear, insertar y eliminar
objetos.
Un nuevo TextContent objeto se creó usando el createInstance método del objeto documento.
Un objeto se inserta usando el método insertTextContent del objeto de texto.
Los objetos TextContent se eliminan mediante el método removeTextContent .
Encontrará una variedad de ejemplos que utilizan estos métodos en las siguientes secciones.
Mesas
El siguiente ejemplo crea una tabla con la ayuda del método createInstance descrito anteriormente.
Dim Doc como objeto
Atenuar tabla como objeto
Doc = ThisComponent
Tabla = Doc.createInstance ("com.sun.star.text.TextTable")

Table.initialize (5, 4)
Doc.Text.insertTextContent (Cursor, Tabla, Falso)
Una vez creada, la tabla se establece en el número de filas y columnas solicitadas mediante una llamada de inicialización y luego
insertado en el documento de texto mediante insertTextContent.
Como se puede ver en el ejemplo, el método insertTextContent espera que no solo el objeto Content sea
insertado, pero otros dos parámetros:
un objeto Cursor que determina la posición de inserción

una variable booleana que especifica si el objeto de contenido debe reemplazar la selección actual del
cursor ( valor verdadero ) o se debe insertar antes de la selección actual en el texto ( falso )
Nota - VBA: al crear e insertar tablas en un documento de texto, objetos similares a los disponibles en VBA
se utilizan en OpenOffice.org Basic: el objeto de documento y un objeto TextCursor en OpenOffice.org Basic, o
el objeto Range como contraparte de VBA. Mientras que el método Document.Tables.Add asume la tarea de
creando y configurando la mesa en VBA, esta se crea en OpenOffice.org Basic de acuerdo con el anterior
ejemplo usando createInstance , inicializado e insertado en el documento a través de insertTextContent .
Las tablas insertadas en un documento de texto se pueden determinar mediante un bucle simple. El método getTextTables ()
del objeto de documento de texto se utiliza para este propósito:
Dim Doc como objeto
Dim TextTables como objeto
Dim I como entero
Doc = ThisComponent
TextTables = Doc.getTextTables ()
Para I = 0 a TextTables.count - 1
Tabla = TextTables (I)

'Tabla de edición
Siguiente yo
Página 81
Más que solo texto
Nota: las tablas de texto están disponibles en OpenOffice.org a través de la lista TextTables del objeto de documento. los
El ejemplo anterior muestra cómo se puede crear una tabla de texto. Las opciones para acceder a las tablas de texto se describen en la
sección siguiente.
Editar tablas
Una tabla consta de filas individuales. Estos, a su vez, contienen las distintas células. Estrictamente hablando, no hay mesa.
columnas en OpenOffice.org. Estos se producen implícitamente ordenando las filas (una debajo de la otra) junto a una
otro. Para simplificar el acceso a las tablas, OpenOffice.org, sin embargo, proporciona algunos métodos que operan usando
columnas. Son útiles si no se han combinado celdas en la tabla.
Tomemos primero las propiedades de la tabla en sí. Estos se definen en el servicio com.sun.star.text.TextTable.
Aquí hay una lista de las propiedades más importantes del objeto de tabla:
BackColor (largo)
color de fondo de la mesa.

BottomMargin (largo)

LeftMargin (largo)
RightMargin (largo)

TopMargin (largo)

RepeatHeadline (booleano)
El encabezado de la tabla se repite en cada página.

Ancho (largo)
ancho absoluto de la mesa en centésimas de milímetro.
Filas
Una tabla consta de una lista que contiene filas. El siguiente ejemplo muestra cómo se pueden recuperar las filas de una tabla
y formateado.
Dim Doc como objeto
Atenuar filas como objeto
Atenuar fila como objeto
Dim I como entero
Doc = ThisComponent


Filas = Table.getRows
Para I = 0 a Rows.getCount () - 1
Fila = Rows.getByIndex (I)
Row.BackColor = & HFF00FF
próximo
El ejemplo primero crea una lista que contiene todas las filas usando una llamada Table.getRows . El getCount y getByIndex
Los métodos permiten que la lista se procese más y pertenece a la interfaz com.sun.star.table.XtableRows .
El método getByIndex devuelve un objeto de fila, que admite el servicio com.sun.star.text.TextTableRow.
Page 82
Más que solo texto
Estos son los métodos centrales de la interfaz com.sun.star.table.XtableRows:

getByIndex (entero)
devuelve un objeto de fila para el índice especificado.

getCount ()
devuelve el número de objetos de fila.

insertByIndex (índice, recuento)
inserta Contar filas en la tabla a partir de la posición de índice .

removeByIndex (índice, recuento)
elimina Contar filas de la tabla a partir de la posición de Índice .
Mientras que los métodos getByIndex y getCount están disponibles en todas las tablas, insertByIndex y
Los métodos removeByIndex solo se pueden usar en tablas que no contienen celdas combinadas.
El servicio com.sun.star.text.TextTableRow proporciona las siguientes propiedades:

BackColor (largo)
color de fondo de la fila.

Altura (largo)
altura de la línea en centésimas de milímetro.

IsAutoHeight (booleano)
la altura de la mesa se adapta dinámicamente al contenido.

VertOrient (const)
Orientación vertical del marco de texto: detalles sobre la orientación vertical del texto dentro de la tabla (valores en
de acuerdo con com.sun.star.text.VertOrientation)
Columnas
Se accede a las columnas de la misma forma que a las filas, utilizando getByIndex , getCount , insertByIndex y
removeByIndex en el objeto Column , al que se llega a través de getColumns . Sin embargo, pueden
solo se utilizará en tablas que no contengan celdas de tabla fusionadas. Las celdas no se pueden formatear por columna en
OpenOffice.org Basic. Para hacerlo, se debe utilizar el método de formatear celdas de tabla individuales.
Células
Cada celda de un documento de OpenOffice.org tiene un nombre único. Si el cursor de OpenOffice.org está en una celda, entonces el
El nombre de esa celda se puede ver en la barra de estado. La celda superior izquierda generalmente se llama A1 y la fila inferior derecha es
generalmente se llama Xn , donde X representa las letras de la columna superior yn los números de la última fila. La célula
los objetos están disponibles a través del método getCellByName () del objeto de tabla. El siguiente ejemplo muestra un
bucle que pasa por todas las celdas de una tabla e ingresa los números de fila y columna correspondientes en el
células.
Dim Doc como objeto
Atenuar filas como objeto
Dim RowIndex como entero
Atenuar columnas como objeto
Dim ColIndex como entero
Atenuar CellName como cadena
Doc = ThisComponent

Página 83
Más que solo texto
Filas = Table.getRows
Cols = Table.getColumns
Para RowIndex = 1 a Rows.getCount ()

Para ColIndex = 1 a Cols.getCount ()
CellName = Chr (Asc ("A") - 1 + ColIndex) & RowIndex
Celda = Table.getCellByName (CellName)
Cell.String = "fila:" & CStr (RowIndex) + ", columna:" & CStr (ColIndex)
próximo
próximo
Una celda de tabla es comparable con un texto estándar. Es compatible con la interfaz createTextCursor para crear un
objeto TextCursor asociado .
CellCursor = Cell.createTextCursor ()
Por lo tanto, todas las opciones de formato para caracteres individuales y párrafos están disponibles automáticamente.
El siguiente ejemplo busca en todas las tablas de un documento de texto y aplica el formato de alineación a la derecha a todas las celdas
con valores numéricos mediante la propiedad de párrafo correspondiente.
Dim Doc como objeto
Dim CellNames
Atenuar CellCursor como objeto
Dim I como entero
Dim J como entero
Doc = ThisComponent
TextTables = Doc.getTextTables ()
Para I = 0 a TextTables.count - 1
Tabla = TextTables (I)
CellNames = Table.getCellNames ()
Para J = 0 a UBound (CellNames)

Celda = Table.getCellByName (CellNames (J))
Si IsNumeric (Cell.String) Entonces
CellCursor = Cell.createTextCursor ()
CellCursor.paraAdjust = com.sun.star.style.ParagraphAdjust.RIGHT
Terminara si
próximo
próximo
El ejemplo crea una lista TextTables que contiene todas las tablas de un texto que se atraviesan en un bucle. OpenOffice.org
luego crea una lista de los nombres de celda asociados para cada una de estas tablas. Se pasan a su vez en un bucle.
Si una celda contiene un valor numérico, el ejemplo cambia el formato correspondiente. Para hacer esto, primero
crea un objeto TextCursor que hace referencia al contenido de la celda de la tabla y luego adapta el
propiedades de párrafo de la celda de la tabla.
Marcos de texto
Los marcos de texto se consideran objetos TextContent , al igual que las tablas y los gráficos. Pueden consistir esencialmente
de texto estándar, pero se pueden colocar en cualquier posición de una página y no se incluyen en el flujo de texto.
Como con todos los objetos TextContent , también se hace una distinción con los marcos de texto entre la creación real y
inserción en el documento.
Dim Doc como objeto
Atenuar marco como objeto
Doc = ThisComponent
Frame = Doc.createInstance ("com.sun.star.text.TextFrame")
Doc.Text.insertTextContent (cursor, marco, falso)
El marco de texto se crea utilizando el método createInstance del objeto de documento. El marco de texto creado en
Página 84
Más que solo texto
de esta manera se puede insertar en el documento utilizando el método insertTextContent del objeto Text . En lo
haciendo, se debe especificar el nombre del servicio com.sun.star.text.TextFrame adecuado.
La posición de inserción del marco de texto está determinada por un objeto Cursor , que también se ejecuta cuando se inserta.
Nota - VBA: los marcos de texto son la contraparte de OpenOffice.org al marco de posición utilizado en Word. Mientras
VBA utiliza el método Document.Frames.Add para este propósito, se realiza la creación en OpenOffice.org Basic
utilizando el procedimiento anterior con la ayuda de un TextCursor , así como el método createInstance del
objeto de documento.
Los objetos de marco de texto proporcionan una gama de propiedades con las que se puede ajustar la posición y el comportamiento del marco.
influenciado. La mayoría de estas propiedades se definen en el servicio com.sun.star.text.BaseFrameProperties,
que también es compatible con cada servicio TextFrame . Las propiedades centrales son:
BackColor (largo)
color de fondo del marco de texto.


LeftMargin (largo)

RightMargin (largo)

TopMargin (largo)

Altura (largo)
altura del marco de texto en centésimas de milímetro.

Ancho (largo)
ancho del marco de texto en centésimas de milímetro.

HoriOrient (constante)
orientación horizontal del marco de texto (de acuerdo con com.sun.star.text.HoriOrientation).

VertOrient (const)
orientación vertical del marco de texto (de acuerdo con com.sun.star.text.VertOrientation).
El siguiente ejemplo crea un marco de texto utilizando las propiedades descritas anteriormente:
Dim Doc como objeto
Doc = ThisComponent
Frame.Width = 3000
Frame.Height = 1000
Frame.AnchorType = com.sun.star.text.TextContentAnchorType.AS_CHARACTER
Frame.TopMargin = 0
Frame.BottomMargin = 0
Frame.LeftMargin = 0
Frame.RightMargin = 0
Frame.BorderDistance = 0
Frame.HoriOrient = com.sun.star.text.HoriOrientation.NONE
Frame.VertOrient = com.sun.star.text.VertOrientation.LINE_TOP
El ejemplo crea un TextCursor como marca de inserción para el marco de texto. Esto se coloca entre el primer
y segunda palabra del texto. El marco de texto se crea utilizando Doc.createInstance . Las propiedades del texto
Página 85
Más que solo texto
Los objetos de marco se establecen en los valores iniciales requeridos.
La interacción entre AnchorType (del TextContent Service) y VertOrient (del

BaseFrameProperties Service) se deben anotar aquí. AnchorType recibe AS_CHARACTER
valor. Por tanto, el marco de texto se inserta directamente en el flujo de texto y se comporta como un carácter. Puede, por
Por ejemplo, pasar a la siguiente línea si se produce un salto de línea. El valor LINE_TOP de la propiedad VertOrient
asegura que el borde superior del marco de texto esté a la misma altura que el borde superior del carácter.
Una vez que se completa la inicialización, el marco de texto finalmente se inserta en el documento de texto mediante una llamada de
insertTextContent .
Para editar el contenido de un marco de texto, el usuario utiliza el TextCursor , que ya se ha mencionado en numerosas
veces y también está disponible para marcos de texto.
Dim Doc como objeto
Dim FrameCursor como objeto
Doc = ThisComponent
Frame.Width = 3000
Frame.Height = 1000
FrameCursor = Frame.createTextCursor ()
FrameCursor.charWeight = com.sun.star.awt.FontWeight.BOLD
FrameCursor.paraAdjust = com.sun.star.style.ParagraphAdjust.CENTER
FrameCursor.String = "¡Esta es una pequeña prueba!"
El ejemplo crea un marco de texto, lo inserta en el documento actual y abre un TextCursor para el texto
cuadro. Este cursor se utiliza para establecer la fuente del marco en negrita y para establecer la orientación del párrafo en centrado. los
Al marco de texto finalmente se le asigna el mensaje "¡Esta es una pequeña prueba!" cuerda.
Campos de texto
Los campos de texto son objetos TextContent porque proporcionan una lógica adicional que se extiende más allá del texto puro. Texto
Los campos se pueden insertar en un documento de texto utilizando los mismos métodos que se utilizan para otros objetos TextContent :
Dim Doc como objeto
Dim DateTimeField como objeto
Doc = ThisComponent
DateTimeField = Doc.createInstance ("com.sun.star.text.textfield.DateTime")
DateTimeField.IsFixed = Falso
DateTimeField.IsDate = True
Doc.Text.insertTextContent (Cursor, DateTimeField, False)
El ejemplo inserta un campo de texto con la fecha actual al comienzo del documento de texto actual. El verdadero valor de
la propiedad IsDate da como resultado que solo se muestre la fecha y no la hora. El valor False para IsFixed asegura
que la fecha se actualiza automáticamente cuando se abre el documento.
Nota - VBA: mientras que el tipo de un campo en VBA se especifica mediante un parámetro de Document.Fields.Add
método, el nombre del servicio responsable del tipo de campo en cuestión lo define en OpenOffice.org
Básico.
Nota: StarOffice 5: en el pasado, se accedía a los campos de texto mediante una amplia gama de métodos que
OpenOffice.org disponible en el antiguo Selección objeto (por ejemplo InsertField , DeleteUserField ,
SetCurField) .
En OpenOffice.org, los campos se administran utilizando un concepto orientado a objetos. Para crear un campo de texto, un campo de texto
86
Más que solo texto
del tipo requerido primero debe crearse e inicializarse utilizando las propiedades requeridas. El campo de texto es entonces
insertado en el documento utilizando el método insertTextContent . El texto fuente correspondiente se puede ver en
El ejemplo anterior. Los tipos de campo más importantes y sus propiedades se describen en las siguientes secciones.
Además de insertar campos de texto, buscar los campos en un documento también puede ser una tarea importante. los
El siguiente ejemplo muestra cómo todos los campos de texto de un documento de texto se pueden atravesar en un bucle y verificar su
tipo relevante.
Dim Doc como objeto
Dim TextFieldEnum como objeto
Atenuar TextField como objeto
Dim I como entero
Doc = ThisComponent
TextFieldEnum = Doc.getTextFields.createEnumeration
Mientras TextFieldEnum.hasMoreElements ()
TextField = TextFieldEnum.nextElement ()
Si TextField.supportsService ("com.sun.star.text.textfield.DateTime") Entonces

MsgBox "Fecha / hora"
ElseIf TextField.supportsService ("com.sun.star.text.textfield.Annotation") Entonces
MsgBox "Anotación"
Más
MsgBox "desconocido"
Terminara si
Encaminarse a
El punto de partida para establecer los campos de texto presentes es la lista TextFields del objeto de documento. los
ejemplo crea un objeto de enumeración sobre la base de esta lista, con el que todos los campos de texto se pueden consultar a su vez
en un bucle. Los campos de texto encontrados se verifican para el servicio admitido mediante el método supportsService . Si
el campo resulta ser un campo de fecha / hora o una anotación, luego el tipo de campo correspondiente se muestra en un
cuadro de información. Si, por el contrario, el ejemplo encuentra otro campo, muestra la información
"desconocido".
A continuación, encontrará una lista de los campos de texto más importantes y sus propiedades asociadas. Una lista completa de todos
Los campos de texto se proporcionan en la referencia de API en el módulo com.sun.star.text.textfield . (Al enumerar el
nombre de servicio de un campo de texto, los caracteres en mayúsculas y minúsculas deben usarse en OpenOffice.org Basic, como en el
ejemplo anterior.)
Número de páginas, palabras y caracteres
Los campos de texto

com.sun.star.text.textfield.PageCount
com.sun.star.text.textfield.WordCount
com.sun.star.text.textfield.CharacterCount
devuelve el número de páginas, palabras o caracteres de un texto. Admiten la siguiente propiedad:

NumberingType (const)
formato de numeración (directrices de acuerdo con las constantes de com.sun.star.style.NumberingType).
Página actual
El número de la página actual se puede insertar en un documento utilizando com.sun.star.text.textfield.PageNumber

campo de texto. Se pueden especificar las siguientes propiedades:
NumberingType (const)
formato de número (directrices de acuerdo con las constantes de com.sun.star.style.NumberingType).

Desplazamiento (corto)
desplazamiento añadido al número de páginas (también es posible una especificación negativa).
Page 87
Más que solo texto
El siguiente ejemplo muestra cómo se puede insertar el número de páginas en el pie de página de un documento.
Dim Doc como objeto
Dim DateTimeField como objeto
Atenuar PageStyles como objeto
Dim StdPage como objeto
Dim FooterCursor como objeto
Atenuar PageNumber como objeto
Doc = ThisComponent
PageNumber = Doc.createInstance ("com.sun.star.text.textfield.PageNumber")

PageNumber.NumberingType = com.sun.star.style.NumberingType.ARABIC
PageStyles = Doc.StyleFamilies.getByName ("PageStyles")
StdPage = PageStyles ("Predeterminado")

StdPage.FooterIsOn = True
FooterCursor = StdPage.FooterTextLeft.Text.createTextCursor ()
StdPage.FooterTextLeft.Text.insertTextContent (FooterCursor, PageNumber, False)
El ejemplo primero crea un campo de texto que admite el servicio com.sun.star.text.textfield.PageNumber. Desde el
Las líneas de encabezado y pie de página se definen como parte de las plantillas de página de OpenOffice.org, esto se establece inicialmente
usando la lista de todos los PageStyles .
Para asegurarse de que la línea del pie de página sea visible, la propiedad FooterIsOn se establece en True . A continuación, el campo de texto se inserta en
el documento utilizando el objeto de texto asociado de la línea del pie de página de la izquierda.
Anotaciones
Los campos de anotación (com.sun.star.text.textfield.Annotation) se pueden ver por medio de un pequeño símbolo amarillo en el
texto. Al hacer clic en este símbolo se abre un campo de texto, en el que se puede escribir un comentario sobre el punto actual del texto.
grabado. Un campo de anotación tiene las siguientes propiedades.
Autor (cadena)
nombre del autor.

Contenido (cadena)
comentario de texto.
Fecha (fecha)
fecha en la que se escribe la anotación.
Fecha y hora
Un campo de fecha / hora (com.sun.star.text.textfield.DateTime) representa la fecha actual o la hora actual. Eso
admite las siguientes propiedades:
IsFixed (booleano)
si es Verdadero , los detalles de tiempo de la inserción permanecen sin cambios; si es Falso , estos se actualizan cada vez que
se abre el documento.
IsDate (booleano)
si es Verdadero , el campo muestra la fecha actual; de lo contrario, la hora actual.

DateTimeValue (estructura)
contenido actual del campo (estructura com.sun.star.util.DateTime)

NumberFormat (const)
formato en el que se representa la hora o la fecha.
Page 88
Más que solo texto
Nombre / número de capítulo
El nombre del capítulo actual está disponible a través de un campo de texto del tipo com.sun.star.text.textfield.Chapter.
El formulario se puede definir mediante dos propiedades.
ChapterFormat (const)
determina si se representa el nombre del capítulo o el número de capítulo (de acuerdo con
com.sun.star.text.ChapterFormat)
Nivel (entero)
determina el nivel de capítulo cuyo nombre y / o número de capítulo se mostrará. El valor 0 representa
nivel más alto disponible.
Marcadores
Los marcadores (Service com.sun.star.text.Bookmark) son objetos TextContent . Los marcadores se crean e insertan
utilizando el concepto ya descrito anteriormente:
Dim Doc como objeto
Atenuar marcador como objeto
Doc = ThisComponent
Bookmark = Doc.createInstance ("com.sun.star.text.Bookmark")

Bookmark.Name = "Mis marcadores"
Doc.Text.insertTextContent (cursor, marcador, verdadero)
El ejemplo crea un Cursor , que marca la posición de inserción del marcador y luego el marcador real
objeto ( marcador ). A continuación, se asigna un nombre al marcador y se inserta en el documento a través de
insertTextContent en la posición del cursor.
Se accede a los marcadores de un texto a través de una lista denominada Marcadores . Se puede acceder a los marcadores mediante
su número o su nombre.
El siguiente ejemplo muestra cómo se puede encontrar un marcador dentro de un texto y cómo se puede insertar un texto en su posición.
Dim Doc como objeto
Atenuar marcador como objeto
Doc = ThisComponent
Bookmark = Doc.Bookmarks.getByName ("Mis marcadores")
Cursor = Doc.Text.createTextCursorByRange (Bookmark.Anchor)

Cursor.String = "Aquí está el marcador"
En este ejemplo, el método getByName se usa para encontrar el marcador requerido por medio de su nombre. los
La llamada createTextCursorByRange luego crea un Cursor , que se coloca en la posición de ancla del
marcador. Luego, el cursor inserta el texto requerido en este punto.
Page 89
7
CAPÍTULO 7
7 Documentos de hoja de cálculo
OpenOffice.org Basic proporciona una amplia interfaz para la creación y edición controladas por programas de
hojas de cálculo. Este capítulo describe cómo controlar los servicios, métodos y propiedades relevantes de la hoja de cálculo.
documentos:
La estructura de las hojas de cálculo
Editar documentos de hoja de cálculo
La primera sección aborda la estructura básica de los documentos de hoja de cálculo y le muestra cómo acceder y editar
el contenido de las celdas individuales.
La segunda sección se concentra en cómo editar hojas de cálculo de manera eficiente enfocándose en áreas de celda y las opciones
para buscar y reemplazar el contenido de la celda.
Nota - StarOffice 5: el objeto Rango le permite abordar cualquier área de la mesa y se ha ampliado en el nuevo
API.

El objeto de documento de una hoja de cálculo se basa en el servicio com.sun.star.sheet.SpreadsheetDocument. Cada uno de
estos documentos pueden contener varias hojas de cálculo. En esta guía, un documento o una hoja de cálculo basados en tablas
documento es el documento completo, mientras que una hoja de cálculo (u hoja para abreviar) es una hoja (tabla) en el documento.
Nota - VBA: se utiliza una terminología diferente para las hojas de cálculo y su contenido en VBA y OpenOffice.org
Básico. Mientras que el objeto de documento en VBA se llama Libro de trabajo y sus páginas individuales Hojas de trabajo, son
llamado SpreadsheetDocument y Sheet en OpenOffice.org Basic.
Hojas de cálculo
Puede acceder a las hojas individuales de un documento de hoja de cálculo a través de la lista Hojas .
Los siguientes ejemplos le muestran cómo acceder a una hoja a través de su número o su nombre.
Ejemplo 1: acceso mediante el número (la numeración comienza con 0)

Dim Doc como objeto
Doc = ThisComponent
91
Page 90
Nota: ThisComponent devuelve el documento activo actualmente.

La expresión Doc.Sheets (0) es una simplificación básica de la llamada API: Doc.getSheets.getByIndex (0)
Ejemplo 2: acceso mediante el nombre

Dim Doc como objeto
Doc = ThisComponent
Hoja = Doc.Sheets.getByName ("Hoja 1")
En el primer ejemplo, se accede a la hoja por su número (el recuento comienza en 0). En el segundo ejemplo, la hoja es
accede por su nombre y el método getByName .
El objeto Sheet que se obtiene mediante el método getByName admite com.sun.star.sheet.Spreadsheet

Servicio. Además de proporcionar varias interfaces para editar el contenido, este servicio proporciona lo siguiente
propiedades:
IsVisible (booleano)
valor Verdadero si la hoja de cálculo está visible.

PageStyle (cadena)
nombre de la plantilla de página para la hoja de cálculo.
Cambio de nombre de hojas
Una hoja proporciona los métodos getName y setName para leer y modificar su nombre. Basic puede manejar ambos métodos
como un nombre de propiedad . Aquí cambiamos el nombre de la primera hoja del documento de hoja de cálculo.
Dim Doc como objeto
Doc = ThisComponent
Sheet.Name = "Primero"
Crear y eliminar hojas
El contenedor Hojas de un documento de hoja de cálculo también se usa para crear y eliminar hojas individuales. los
El siguiente ejemplo usa el método hasByName para verificar si existe una hoja llamada MySheet . Si es así, el método
determina una referencia de objeto correspondiente mediante el método getByName y luego guarda la referencia en un
variable en Hoja . Si la hoja correspondiente no existe, se crea mediante la llamada createInstance y
insertado en el documento de hoja de cálculo mediante el método insertByName .
Dim Doc como objeto
Doc = ThisComponent
Si Doc.Sheets.hasByName ("MySheet"), entonces

Hoja = Doc.Sheets.getByName ("Mi hoja")
Más
Hoja = Doc.createInstance ("com.sun.star.sheet.Spreadsheet")
Doc.Sheets.insertByName ("Mi hoja", Hoja)
Terminara si
Los métodos hasByName , getByName e insertByName se obtienen del

interfaz com.sun.star.container.XNameContainer como se describe en Introducción a la API.
La interfaz com.sun.star.sheet.Spreadsheets proporciona un método mejor para crear una nueva hoja:
insertNewByName .
Inserta una nueva hoja con el nombre especificado por el primer argumento, en la posición especificada
por el segundo argumento.
Dim Doc como objeto
Doc = ThisComponent
Doc.Sheets.insertNewByName ("Otra hoja", 2)
Page 91
La misma interfaz proporciona los métodos moveByName y copyByName .
La interfaz com.sun.star.container.XNameContainer proporciona un método para eliminar una hoja de un nombre dado:
Dim Doc como objeto
Doc = ThisComponent
Doc.Sheets.removeByName ("Otra hoja")
Filas y columnas
Cada hoja contiene una lista de sus filas y columnas. Están disponibles a través de las propiedades de Filas y Columnas .
del objeto de hoja de cálculo y admiten com.sun.star.table.TableColumns y / o com.sun.star.table.TableRows
servicios.
El siguiente ejemplo crea dos objetos que hacen referencia a la primera fila y la primera columna de una hoja y almacena
las referencias en las variables de objeto FirstCol y FirstRow .
Dim Doc como objeto
Atenuar FirstRow como objeto
Atenuar FirstCol como objeto
Doc = ThisComponent
FirstCol = Hoja.Columnas (0)

FirstRow = Sheet.Rows (0)
Los objetos de columna admiten el servicio com.sun.star.table.TableColumn que tiene las siguientes propiedades:
Ancho (largo)
ancho de una columna en centésimas de milímetro.

OptimalWidth (booleano)
establece una columna en su ancho óptimo.

muestra una columna.

IsStartOfNewPage (booleano)
al imprimir, crea un salto de página antes de una columna.
El ancho de una columna solo se optimiza cuando la propiedad OptimalWidth se establece en True . Si el ancho de un
se cambia una celda individual, no se cambia el ancho de la columna que contiene la celda. En términos de funcionalidad,
OptimalWidth es más un método que una propiedad.
Los objetos de fila se basan en el servicio com.sun.star.table.TableRow que tiene las siguientes propiedades:
Altura (largo)
altura de la fila en centésimas de milímetro.

OptimalHeight (booleano)
establece la fila a su altura óptima.

muestra la fila.
IsStartOfNewPage (booleano)
al imprimir, crea un salto de página antes de la fila.
Si la propiedad OptimalHeight de una fila se establece en True , la altura de la fila cambia automáticamente cuando
se cambia la altura de una celda en la fila. La optimización automática continúa hasta que a la fila se le asigna un valor absoluto.
height a través de la propiedad Height .
Capítulo 7 · Documentos de hoja de cálculo 93
Página 92
El siguiente ejemplo activa la optimización automática de altura para las primeras cinco filas de la hoja y hace
la segunda columna invisible.
Dim Doc como objeto
Atenuar fila como objeto
Dim Col como objeto
Dim I como entero
Doc = ThisComponent
Para I = 0 a 4
Fila = Hoja.Rutas (I)
Row.OptimalHeight = Verdadero
Siguiente yo
Col = Hoja.Columnas (1)

Col.IsVisible = Falso
Nota: Se puede acceder a las listas de Filas y Columnas a través de un índice en OpenOffice.org Basic. La API real
la llamada es: Sheet.getColumns.getByIndex (1)
Nota - VBA: a diferencia de VBA, la primera columna tiene el índice 0 y no el índice 1.
Insertar y eliminar filas y columnas
Los objetos Filas y Columnas de una hoja pueden acceder a las filas y columnas existentes, así como insertarlas y eliminarlas.
Dim Doc como objeto
Dim NewColumn como objeto
Doc = ThisComponent
Sheet.Columns.insertByIndex (3, 1)
Sheet.Columns.removeByIndex (5, 1)
Este ejemplo usa el método insertByIndex para insertar una nueva columna en la cuarta posición de la columna en el
hoja (índice 3 - la numeración comienza en 0). El segundo parámetro especifica el número de columnas que se insertarán (en
este ejemplo: uno).
El método removeByIndex elimina la sexta columna (índice 5). Nuevamente, el segundo parámetro especifica el
número de columnas que desea eliminar.
Los métodos para insertar y eliminar filas usan la función del objeto Rows de la misma manera que los métodos mostrados
para editar columnas usando el objeto Columns .
Celdas y rangos
Una hoja de cálculo consta de una lista bidimensional que contiene celdas. Cada celda está definida por su posición X e Y con
con respecto a la celda superior izquierda que tiene la posición (0,0).
Direccionamiento y edición de celdas individuales
El siguiente ejemplo crea un objeto que hace referencia a la celda superior izquierda e inserta un texto en la celda:
Dim Doc como objeto
Doc = ThisComponent
Page 93
Celda = Sheet.getCellByPosition (0, 0)

Cell.String = "Prueba"
Además de las coordenadas numéricas, cada celda de una hoja tiene un nombre, por ejemplo, la celda superior izquierda (0,0) de un
La hoja de cálculo se llama A1 . La letra A representa la columna y el número 1 representa la fila. Es importante que el
El nombre y la posición de una celda no se confunden porque el recuento de filas para los nombres comienza con 1 pero el recuento de
la posición comienza con 0.
Si la posición de la celda es fija, es más claro usar el siguiente código:
Dim
Dim Doc
hoja como
como objeto
objeto
Doc = ThisComponent
Celda = Sheet.getCellRangeByName ("A1")

El código anterior también funciona con una celda con nombre.
En OpenOffice.org, la celda de una tabla puede estar vacía o contener texto, números o fórmulas. El tipo de celda no es
determinado por el contenido que se guarda en la celda, sino más bien por la propiedad del objeto que se utilizó para su entrada.
Los números se pueden insertar y recuperar con la propiedad Value , texto con la propiedad String y fórmulas
con la propiedad Formula .
Dim Doc como objeto
Doc = ThisComponent

Cell.Value = 100


Cell.Formula = "= A1"
El ejemplo inserta un número, un texto y una fórmula en los campos A1 a A3.
Nota - StarOffice 5: El Valor , cuerdas , y Fórmula propiedades sustituyen a la antigua PutCell método de
StarOffice 5 para establecer los valores de una celda de tabla.
OpenOffice.org trata el contenido de la celda que se ingresa usando la propiedad String como texto, incluso si el contenido es un
número. Los números están alineados a la izquierda en la celda en lugar de alineados a la derecha. También debe notar la diferencia entre
texto y números cuando usa fórmulas:
Dim Doc como objeto
Doc = ThisComponent

Cell.Value = 100

Cell.String = 1000

Cell.Formula = "= A1 + A2"
MsgBox Cell.Value
Aunque la celda A1 contiene el valor 100 y la celda A2 contiene el valor 1000, la fórmula A1 + A2 devuelve el
valor 100. Esto se debe a que el contenido de la celda A2 se ingresó como una cadena y no como un número.
Para verificar si el contenido de una celda contiene un número o una cadena, use la propiedad Tipo :
Página 94
Dim Doc como objeto

Doc = ThisComponent
Celda = Sheet.getCellByPosition (1,1)
Cell.Value = 1000
Seleccione Case Cell.Type

Caso com.sun.star.table.CellContentType.EMPTY
MsgBox "Contenido: vacío"
Caso com.sun.star.table.CellContentType.VALUE
MsgBox "Contenido: Valor"
Caso com.sun.star.table.CellContentType.TEXT
MsgBox "Contenido: Texto"
Caso com.sun.star.table.CellContentType.FORMULA
MsgBox
Finalizar "Contenido: fórmula"
Seleccionar
La propiedad Cell.Type devuelve un valor para la enumeración com.sun.star.table.CellContentType que

identifica el tipo de contenido de una celda. Los posibles valores son:
VACÍO
sin valor
VALOR
número
TEXTO
instrumentos de cuerda
FÓRMULA
fórmula
Insertar, eliminar, copiar y mover celdas
Además de modificar directamente el contenido de la celda, OpenOffice.org Calc también proporciona una interfaz que le permite
insertar, eliminar, copiar o combinar celdas. La interfaz (com.sun.star.sheet.XRangeMovement) está disponible a través del
objeto de hoja de cálculo y proporciona cuatro métodos para modificar el contenido de la celda.
El método insertCell se utiliza para insertar celdas en una hoja.

Dim Doc como objeto
Atenuar CellRangeAddress como nuevo com.sun.star.table.CellRangeAddress
Doc = ThisComponent
CellRangeAddress.Sheet = 0
CellRangeAddress.StartColumn = 1
CellRangeAddress.StartRow = 1
CellRangeAddress.EndColumn = 2
CellRangeAddress.EndRow = 2
Sheet.insertCells (CellRangeAddress, com.sun.star.sheet.CellInsertMode.DOWN)
Este ejemplo inserta un rango de celdas de dos filas por dos columnas de tamaño en la segunda columna y fila (cada una
llevar el número 1) de la primera hoja (número 0) en la hoja de cálculo. Cualquier valor existente en el rango de celdas especificado
se mueven por debajo del rango.
Para definir el rango de celdas que desea insertar, use la estructura com.sun.star.table.CellRangeAddress. los
Los siguientes valores están incluidos en esta estructura:
Hoja (corta)
número de la hoja (la numeración comienza con 0).
Page 95
StartColumn (largo)
primera columna del rango de celdas (la numeración comienza con 0).
StartRow (larga)
primera fila del rango de celdas (la numeración comienza con 0).
EndColumn (largo)
columna final en el rango de celdas (la numeración comienza con 0).

EndRow (largo)
última fila en el rango de celdas (la numeración comienza con 0).
La estructura CellRangeAddress completa se debe pasar como primer parámetro a insertCells

método. El segundo parámetro de insertCells contiene un valor de com.sun.star.sheet.CellInsertMode
enumeración y define qué se debe hacer con los valores que se encuentran delante de la posición de inserción. los
La enumeración CellInsertMode reconoce los siguientes valores:
NINGUNA
los valores actuales permanecen en su posición actual.
ABAJO
las celdas en y debajo de la posición de inserción se mueven hacia abajo.

DERECHA
las celdas a la derecha de la posición de inserción se mueven a la derecha.

FILAS
las filas después de la posición de inserción se mueven hacia abajo.

Columnas
las columnas después de la posición de inserción se mueven a la derecha.
El método removeRange es la contraparte del método insertCells . Este método elimina el rango que es
definido en la estructura CellRangeAddress de la hoja.
Dim Doc como objeto
Doc = ThisComponent
Sheet.removeRange (CellRangeAddress, com.sun.star.sheet.CellDeleteMode.UP)
Este ejemplo elimina el rango de celdas B2: C3 de la hoja y luego desplaza las celdas subyacentes dos filas hacia arriba.
El tipo de eliminación se define mediante uno de los siguientes valores de com.sun.star.sheet.CellDeleteMode
enumeración:
NINGUNA
los valores actuales permanecen en su posición actual.

ARRIBA
las celdas en y debajo de la posición de inserción se mueven hacia arriba.

IZQUIERDA
las celdas a la derecha de la posición de inserción se mueven a la izquierda.

FILAS
las filas después de la posición de inserción se mueven hacia arriba.
Page 96
Columnas
las columnas después de la posición de inserción se mueven a la izquierda.
La interfaz XRangeMovement proporciona dos métodos adicionales para mover ( moveRange ) o copiar
( copyRange ) rangos de celdas. El siguiente ejemplo mueve el rango B2: C3 para que el rango comience en la posición A6 :
Dim Doc como objeto
Atenuar CellAddress como nuevo com.sun.star.table.CellAddress
Doc = ThisComponent
CellAddress.Sheet = 0
CellAddress.Column = 0
CellAddress.Row = 5
Sheet.moveRange (CellAddress, CellRangeAddress)
Además de la estructura CellRangeAdress , el método moveRange espera una com.sun.star.table.CellAddress

estructura para definir el origen de la región objetivo del movimiento. El método CellAddress proporciona lo siguiente
valores:
Hoja (corta)
número de la hoja de cálculo (la numeración comienza con 0).

Columna (larga)
número de la columna dirigida (la numeración comienza con 0).

Fila (larga)
número de la fila dirigida (la numeración comienza con 0).
El método moveRange siempre sobrescribe el contenido de la celda en el rango de destino . A diferencia del
InsertCells método, un parámetro para realizar movimientos automáticos no se proporciona en el removeRange
método.
El método copyRange funciona de la misma manera que el método moveRange , excepto que copyRange inserta un
copia del rango de celdas en lugar de moverlo.
Nota - VBA: en términos de su función, OpenOffice.org Basic insertCell , removeRange y

Los métodos copyRange son comparables con los métodos Range.Insert , Range.Delete y Range.Copy de VBA .
Mientras que en VBA, los métodos se aplican al objeto Range correspondiente , en OpenOffice.org Basic son
aplicado al objeto de hoja asociado .
Dar formato a documentos de hoja de cálculo
Un documento de hoja de cálculo proporciona propiedades y métodos para formatear celdas y páginas.
Propiedades de celda
Existen numerosas opciones para dar formato a las celdas, como especificar el tipo de fuente y el tamaño del texto. Cada celda
admite los servicios com.sun.star.style.CharacterProperties y com.sun.star.style.ParagraphProperties, los principales
propiedades de las cuales se describen en Documentos de texto. El formato de celda especial es manejado por el
Servicio com.sun.star.table.CellProperties. Las principales propiedades de este servicio se describen a continuación
secciones.
Página 97
Puede aplicar todas las propiedades nombradas a celdas individuales y rangos de celdas.
Nota - VBA: el objeto CellProperties en la API de OpenOffice.org es comparable con Interior

objeto de VBA que también define propiedades específicas de la celda.
Color de fondo y sombras
El servicio com.sun.star.table.CellProperties proporciona las siguientes propiedades para definir colores de fondo
y sombras:
CellBackColor (largo)
color de fondo de la celda de la tabla

IsCellBackgroundTransparent (booleano)
establece el color de fondo en transparente

ShadowFormat (estructura)
especifica la sombra de las celdas (estructura de acuerdo con com.sun.star.table.ShadowFormat)
La estructura com.sun.star.table.ShadowFormat y las especificaciones detalladas para las sombras de celda tienen la
siguiente estructura:
Ubicación (enumeración)
posición de la sombra (valor de la estructura com.sun.star.table.ShadowLocation).

ShadowWidth (corto)
tamaño de la sombra en centésimas de milímetro

IsTransparent (booleano)
establece la sombra en transparente
Color (largo)
color de la sombra
El siguiente ejemplo escribe el número 1000 en la celda B2, cambia el color de fondo a rojo usando el
CellBackColor , y luego crea una sombra gris claro para la celda que se mueve 1 mm hacia la izquierda y
abajo.
Dim Doc como objeto
Atenuar ShadowFormat como nuevo com.sun.star.table.ShadowFormat
Doc = ThisComponent
Cell.Value = 1000
Cell.CellBackColor = RGB (255, 0, 0)
ShadowFormat.Location = com.sun.star.table.ShadowLocation.BOTTOM_RIGHT
ShadowFormat.ShadowWidth = 100
ShadowFormat.Color = RGB (160, 160, 160)
Cell.ShadowFormat = ShadowFormat
Justificación
OpenOffice.org proporciona varias funciones que le permiten cambiar la justificación de un texto en una celda de tabla.
Las siguientes propiedades definen la justificación horizontal y vertical de un texto:
Página 98
HoriJustify (enumeración)
justificación horizontal del texto (valor de com.sun.star.table.CellHoriJustify)

VertJustify (enumeración)
justificación vertical del texto (valor de com.sun.star.table.CellVertJustify)

Orientación (enumeración)
orientación del texto (valor de acuerdo con com.sun.star.table.CellOrientation)

IsTextWrapped (booleano)
permite saltos de línea automáticos dentro de la celda

RotateAngle (largo)
ángulo de rotación del texto en centésimas de grado
El siguiente ejemplo muestra cómo se puede "apilar" el contenido de una celda para que los caracteres individuales sean
impreso uno debajo de otro en la esquina superior izquierda de la celda. Los personajes no se rotan.
Dim Doc como objeto
Doc = ThisComponent
Cell.Value = 1000
Cell.HoriJustify = com.sun.star.table.CellHoriJustify.LEFT
Cell.VertJustify = com.sun.star.table.CellVertJustify.TOP
Cell.Orientation = com.sun.star.table.CellOrientation.STACKED
Formato de número, fecha y texto
OpenOffice.org proporciona una amplia gama de formatos de fecha y hora predefinidos. Cada uno de estos formatos tiene un
número interno que se usa para asignar el formato a las celdas usando la propiedad NumberFormat . OpenOffice.org
proporciona los métodos queryKey y addNew para que pueda acceder a los formatos numéricos existentes y crear
sus propios formatos numéricos. Se accede a los métodos a través de la siguiente llamada de objeto:
NumberFormats = Doc.NumberFormats
Un formato se especifica utilizando una cadena de formato que está estructurada de manera similar a la función de formato de
OpenOffice.org Basic. Sin embargo, hay una diferencia importante: mientras que el formato de comando espera inglés
abreviaturas y puntos decimales o caracteres como separadores de miles, las abreviaturas especificadas por el país deben
ser utilizado para la estructura de un formato de comando para el objeto NumberFormats .
El siguiente ejemplo formatea la celda B2 para que los números se muestren con tres lugares decimales y
comas como separador de miles.
Dim Doc como objeto
Dim NumberFormats como objeto
Dim NumberFormatString como cadena
Dim NumberFormatId tan largo
Atenuar LocalSettings como nuevo com.sun.star.lang.Locale
Doc = ThisComponent
Cell.Value = 23400.3523565
LocalSettings.Language = "en"
LocalSettings.Country = "nosotros"
NumberFormats = Doc.NumberFormats
NumberFormatString = "#, ## 0.000"
NumberFormatId = NumberFormats.queryKey (NumberFormatString, LocalSettings, True)

Si NumberFormatId = -1 entonces
Page 99
NumberFormatId = NumberFormats.addNew (NumberFormatString, LocalSettings)

Terminara si
MsgBox NumberFormatId
Cell.NumberFormat = NumberFormatId
El cuadro de diálogo Formato de celdas en OpenOffice.org Calc proporciona una descripción general de las diferentes opciones de formato para
células.
Propiedades de la página
Las propiedades de la página son las opciones de formato que colocan el contenido del documento en una página, así como los elementos visuales.
que se repiten página tras página. Éstos incluyen
Formatos de papel
Márgenes de página
Encabezados y pies de página.
El procedimiento para definir formatos de página difiere de otras formas de formateo. Considerando que celda, párrafo y
los elementos de carácter se pueden formatear directamente, los formatos de página también se pueden definir y aplicar indirectamente usando la página
estilos Por ejemplo, los encabezados o pies de página se agregan al estilo de página.
Las siguientes secciones describen las principales opciones de formato para las páginas de la hoja de cálculo. Muchos de los estilos que son
descritos también están disponibles para documentos de texto. Las propiedades de la página que son válidas para ambos tipos de documentos
se definen en el servicio com.sun.star.style.PageProperties. Las propiedades de la página que solo se aplican a la hoja de cálculo
Los documentos se definen en el servicio com.sun.star.sheet.TablePageStyle.
Nota - VBA: las propiedades de la página (márgenes de página, bordes, etc.) para un documento de Microsoft Office son
definido por medio de un objeto PageSetup en el nivel del objeto Hoja de trabajo (Excel) o del objeto Documento (Word). En
OpenOffice.org, estas propiedades se definen utilizando un estilo de página que a su vez está vinculado al asociado
documento.
Fondo de la página
El servicio com.sun.star.style.PageProperties define las siguientes propiedades del fondo de una página:
BackColor (largo)
color de fondo
BackGraphicURL (cadena)
URL de los gráficos de fondo que desea utilizar
BackGraphicFilter (Cadena)
nombre del filtro para interpretar los gráficos de fondo

BackGraphicLocation (Enum)
posición de los gráficos de fondo (valor según enumeración)

BackTransparent (booleano)
hace que el fondo sea transparente
Formato de página
El formato de la página se define mediante las siguientes propiedades del servicio com.sun.star.style.PageProperties:
IsLandscape (booleano)
formato de paisaje
Ancho (largo)
ancho de página en centésimas de milímetro
Página 100
Altura (largo)
altura de la página en centésimas de milímetro

PrinterPaperTray (cadena)
nombre de la bandeja de papel de la impresora que desea utilizar
El siguiente ejemplo establece el tamaño de página del estilo de página "Predeterminado" en formato apaisado DIN A5 (altura 14,8
cm, ancho 21 cm):
Dim Doc como objeto
Atenuar DefPage como objeto
Doc = ThisComponent
PageStyles = StyleFamilies.getByName ("PageStyles")
DefPage = PageStyles.getByName ("Predeterminado")
DefPage.IsLandscape = Verdadero
DefPage.Width = 21000
DefPage.Height = 14800
Margen, borde y sombra de página
El servicio com.sun.star.style.PageProperties proporciona las siguientes propiedades para ajustar los márgenes de la página también
como fronteras y sombras:
LeftMargin (largo)
ancho del margen izquierdo de la página en centésimas de milímetro

RightMargin (largo)
ancho del margen derecho de la página en centésimas de milímetro

TopMargin (largo)
ancho del margen de la página superior en centésimas de milímetro

ancho del margen de la página inferior en centésimas de milímetro

LeftBorder (estructura)
especificaciones para la línea izquierda del borde de la página (estructura com.sun.star.table.BorderLine)

RightBorder (estructura)
especificaciones para la línea derecha del borde de la página (estructura com.sun.star.table.BorderLine)

TopBorder (estructura)
especificaciones para la línea superior del borde de la página (estructura com.sun.star.table.BorderLine)
BottomBorder (estructura)
especificaciones para la línea inferior del borde de la página (estructura com.sun.star.table.BorderLine)

LeftBorderDistance (largo)
distancia entre el borde izquierdo de la página y el contenido de la página en centésimas de milímetro

RightBorderDistance (largo)
distancia entre el borde de la página derecho y el contenido de la página en centésimas de milímetro

TopBorderDistance (largo)
distancia entre el borde de la página superior y el contenido de la página en centésimas de milímetro

BottomBorderDistance (largo)
distancia entre el borde inferior de la página y el contenido de la página en centésimas de milímetro
Page 101
ShadowFormat (estructura)
especificaciones para la sombra del área de contenido de la página (estructura com.sun.star.table.ShadowFormat)
El siguiente ejemplo establece los bordes izquierdo y derecho del estilo de página "Predeterminado" en 1 centímetro.
Dim Doc como objeto
Doc = ThisComponent
DefPage.LeftMargin = 1000
DefPage.RightMargin = 1000
Encabezados y pies de pagina
Los encabezados y pies de página de un documento forman parte de las propiedades de la página y se definen mediante el
Servicio com.sun.star.style.PageProperties. Las propiedades para formatear encabezados son:
HeaderIsOn (booleano)
el encabezado está activado

HeaderLeftMargin (largo)
distancia entre el encabezado y el margen izquierdo de la página en centésimas de milímetro

HeaderRightMargin (largo)
distancia entre el encabezado y el margen derecho de la página en centésimas de milímetro

HeaderBodyDistance (largo)
distancia entre el encabezado y el cuerpo principal del documento en centésimas de milímetro

HeaderHeight (largo)
altura del cabezal en centésimas de milímetro

HeaderIsDynamicHeight (booleano)
la altura del encabezado se adapta automáticamente al contenido

HeaderLeftBorder (estructura)
detalles del borde izquierdo del marco alrededor del encabezado (estructura com.sun.star.table.BorderLine)
HeaderRightBorder (estructura)
detalles del borde derecho del marco alrededor del encabezado (estructura com.sun.star.table.BorderLine)
HeaderTopBorder (estructura)
detalles de la línea superior del borde alrededor del encabezado (estructura com.sun.star.table.BorderLine)
HeaderBottomBorder (estructura)
detalles de la línea inferior del borde alrededor del encabezado (estructura com.sun.star.table.BorderLine)
HeaderLeftBorderDistance (largo)
distancia entre el borde izquierdo y el contenido del encabezado en centésimas de milímetro

HeaderRightBorderDistance (largo)
distancia entre el borde derecho y el contenido del encabezado en centésimas de milímetro

HeaderTopBorderDistance (largo)
distancia entre el borde superior y el contenido del encabezado en centésimas de milímetro

HeaderBottomBorderDistance (largo)
distancia entre el borde inferior y el contenido del encabezado en centésimas de milímetro
Page 102
HeaderIsShared (booleano)
los encabezados de las páginas pares e impares tienen el mismo contenido (consulte HeaderText , HeaderTextLeft y
HeaderTextRight )
HeaderBackColor (largo)
color de fondo del encabezado

HeaderBackGraphicURL (Cadena)

HeaderBackGraphicFilter (Cadena)
nombre del filtro para interpretar los gráficos de fondo del encabezado
HeaderBackGraphicLocation (Enum)
posición de los gráficos de fondo para el encabezado (valor según com.sun.star.style.GraphicLocation

enumeración)
HeaderBackTransparent (booleano)
muestra el fondo del encabezado como transparente

HeaderShadowFormat (estructura)
detalles de la sombra del encabezado (estructura com.sun.star.table.ShadowFormat)
Las propiedades para dar formato a los pies de página son:

FooterIsOn (booleano)
pie de página está activado

FooterLeftMargin (largo)
distancia entre el pie de página y el margen izquierdo de la página en centésimas de milímetro

FooterRightMargin (largo)
distancia entre el pie de página y el margen derecho de la página en centésimas de milímetro

FooterBodyDistance (largo)
distancia entre el pie de página y el cuerpo principal del documento en centésimas de milímetro
FooterHeight (largo)
altura del pie de página en centésimas de milímetro

FooterIsDynamicHeight (booleano)
la altura del pie de página se adapta automáticamente al contenido

FooterLeftBorder (estructura)
detalles de la línea izquierda del borde alrededor del pie de página (estructura com.sun.star.table.BorderLine)
FooterRightBorder (estructura)
detalles de la línea derecha del borde alrededor del pie de página (estructura com.sun.star.table.BorderLine)
FooterTopBorder (estructura)
detalles de la línea superior del borde alrededor del pie de página (estructura com.sun.star.table.BorderLine)
FooterBottomBorder (estructura)
detalles de la línea inferior del borde alrededor del pie de página (estructura com.sun.star.table.BorderLine)
FooterLeftBorderDistance (largo)
distancia entre el borde izquierdo y el contenido del pie de página en centésimas de milímetro
FooterRightBorderDistance (largo)
distancia entre el borde derecho y el contenido del pie de página en centésimas de milímetro
FooterTopBorderDistance (largo)
distancia entre el borde superior y el contenido del pie de página en centésimas de milímetro
Page 103
FooterBottomBorderDistance (largo)
distancia entre el borde inferior y el contenido del pie de página en centésimas de milímetro
FooterIsShared (booleano)
los pies de página de las páginas pares e impares tienen el mismo contenido (consulte FooterText , FooterTextLeft ,
y FooterTextRight )
FooterBackColor (largo)
color de fondo del pie de página

FooterBackGraphicURL (String)

FooterBackGraphicFilter (String)
nombre del filtro para interpretar los gráficos de fondo del pie de página
FooterBackGraphicLocation (Enum)
posición de los gráficos de fondo para el pie de página (valor según com.sun.star.style.GraphicLocation
enumeración)
FooterBackTransparent (booleano)
muestra el fondo del pie de página como transparente

FooterShadowFormat (estructura)
detalles de la sombra del pie de página (estructura com.sun.star.table.ShadowFormat)
Cambiar el texto de encabezados y pies de página
Se accede al contenido de los encabezados y pies de página en una hoja de cálculo a través de las siguientes propiedades:
LeftPageHeaderContent (Objeto)
contenido de encabezados para páginas pares (servicio com.sun.star.sheet.HeaderFooterContent)

RightPageHeaderContent (objeto)
contenido de encabezados para páginas impares (servicio com.sun.star.sheet.HeaderFooterContent)

LeftPageFooterContent (Objeto)
contenido de pies de página para páginas pares (servicio com.sun.star.sheet.HeaderFooterContent)

RightPageFooterContent (objeto)
contenido de pies de página para páginas impares (servicio com.sun.star.sheet.HeaderFooterContent)
Si no necesita distinguir entre encabezados o pies de página para páginas pares e impares (el FooterIsShared
propiedad es False ), luego establezca las propiedades para encabezados y pies de página en páginas impares.
Todos los objetos nombrados devuelven un objeto que admite el servicio com.sun.star.sheet.HeaderFooterContent. Por
medio de los (no originales) propiedades LeftText , CenterText , y RightText , este servicio proporciona tres texto
elementos para los encabezados y pies de página de OpenOffice.org Calc.
El siguiente ejemplo escribe "Sólo una prueba". valor en el campo de texto de la izquierda del encabezado del "Predeterminado"
modelo.
Dim Doc como objeto
Atenuar HText como objeto
Dim HContent como objeto
Doc = ThisComponent
DefPage.HeaderIsOn = Verdadero
Página 104
HContent = DefPage.RightPageHeaderContent
HText = HContent.LeftText
HText.String = "Solo una prueba".
DefPage.RightPageHeaderContent = HContent
Tenga en cuenta la última línea del ejemplo: una vez que se cambia el texto, el objeto TextContent debe asignarse al
encabezado nuevamente para que el cambio sea efectivo.
Otro mecanismo para cambiar el texto de los encabezados y pies de página está disponible para documentos de texto (OpenOffice.org
Writer) porque constan de un solo bloque de texto. Las siguientes propiedades se definen en el
Servicio com.sun.star.style.PageProperties:
HeaderText (Objeto)
objeto de texto con contenido del encabezado (servicio com.sun.star.text.XText)

HeaderTextLeft (Objeto)
objeto de texto con contenido de encabezados en las páginas de la izquierda (servicio com.sun.star.text.XText)
HeaderTextRight (Objeto)
objeto de texto con contenido de encabezados en las páginas de la derecha (servicio com.sun.star.text.XText)
FooterText (Objeto)
objeto de texto con contenido del pie de página (servicio com.sun.star.text.XText)

FooterTextLeft (Objeto)
objeto de texto con contenido de pies de página en las páginas de la izquierda (servicio com.sun.star.text.XText)
FooterTextRight (Objeto)
objeto de texto con contenido de pies de página en las páginas de la derecha (servicio com.sun.star.text.XText)
El siguiente ejemplo crea un encabezado en el estilo de página "Predeterminado" para documentos de texto y agrega el texto "Solo un
Prueba "en el encabezado.
Dim Doc como objeto
Atenuar HText como objeto
Doc = ThisComponent
DefPage.HeaderIsOn = Verdadero
HText = DefPage.HeaderText
HText.String = "Solo una prueba".
En este caso, el acceso se proporciona directamente a través de la propiedad HeaderText del estilo de página en lugar de la
Objeto HeaderFooterContent .
Centrado (solo hojas de cálculo)
El servicio com.sun.star.sheet.TablePageStyle solo se utiliza en los estilos de página de OpenOffice.org Calc y permite
los rangos que desea imprimir estén centrados en la página. Este servicio proporciona las siguientes propiedades:
CentroHorizontalmente (booleano)
el contenido de la tabla está centrado horizontalmente

CenterVertically (booleano)
el contenido de la tabla está centrado verticalmente
Página 105
Definición de elementos a imprimir (solo hojas de cálculo)
Cuando formatea hojas, puede definir si los elementos de la página son visibles. Para este propósito, el
El servicio com.sun.star.sheet.TablePageStyle proporciona las siguientes propiedades:
PrintAnnotations (booleano)
imprime comentarios de celda

PrintGrid (booleano)
imprime las líneas de cuadrícula de la celda

PrintHeaders (booleano)
imprime los encabezados de fila y columna

PrintCharts (booleano)
imprime gráficos contenidos en una hoja

PrintObjects (booleano)
imprime objetos incrustados

PrintDrawing (booleano)
impresiones dibujar objetos

PrintDownFirst (booleano)
si el contenido de una hoja se extiende a lo largo de varias páginas, primero se imprimen en orden vertical descendente,
y luego por el lado derecho.
PrintFormulas (booleano)
imprime las fórmulas en lugar de los valores calculados

PrintZeroValues (booleano)
imprime los valores cero

Mientras que la sección anterior describía la estructura principal de los documentos de hoja de cálculo, esta sección describe la
servicios que le permiten acceder fácilmente a celdas individuales o rangos de celdas.
Rangos de celda
Además de un objeto para celdas individuales (servicio com.sun.star.table.Cell), OpenOffice.org también proporciona objetos
que representan rangos de celdas. Estos objetos CellRange se crean mediante la llamada getCellRangeByName del
objeto de hoja de cálculo:
Dim Doc como objeto
Atenuar CellRange como objeto
Doc = ThisComponent
CellRange = Sheet.getCellRangeByName ("A1: C15")
Se utilizan dos puntos (:) para especificar un rango de celdas en un documento de hoja de cálculo. Por ejemplo, A1: C15 representa todas las celdas
en las filas 1 a 15 en las columnas A, B y C.
Si la posición del rango de celdas solo se conoce en tiempo de ejecución, use el siguiente código:
Dim Doc como objeto
Page 106
Doc = ThisComponent
CellRange = Sheet.getCellRangeByPosition (0, 0, 2, 14)
Los argumentos de getCellRangeByPosition son la posición de la celda superior izquierda del rango, seguida de
la posición de la celda inferior derecha del mismo rango.
La ubicación de celdas individuales en un rango de celdas se puede determinar usando el método getCellByPosition , donde
las coordenadas de la celda superior izquierda en el rango de celdas son (0, 0). El siguiente ejemplo utiliza este método para crear un
objeto de la celda C3.
Dim Doc como objeto
Doc = ThisComponent
CellRange = Sheet.getCellRangeByName ("B2: D4")
Celda = CellRange.GetCellByPosition (1, 1)
Formateo de rangos de celdas
Al igual que las celdas individuales, puede aplicar formato a los rangos de celdas utilizando com.sun.star.table.CellProperties
Servicio. Para obtener más información y ejemplos de este servicio, consulteDar formato a documentos de hoja de cálculo.
Computación con rangos de celda
Puede utilizar el método computeFunction para realizar operaciones matemáticas en rangos de celdas. los
computeFunction espera una constante como parámetro que describe la función matemática que desea
utilizar. Las constantes asociadas se definen en la enumeración com.sun.star.sheet.GeneralFunction. El seguimiento
los valores están disponibles:
SUMA
suma de todos los valores numéricos

CONTAR
número total de todos los valores (incluidos los valores no numéricos)

COUNTNUMS
número total de todos los valores numéricos

PROMEDIO
promedio de todos los valores numéricos

MAX
mayor valor numérico

MIN
valor numérico más pequeño

PRODUCTO
producto de todos los valores numéricos

STDEV
Desviación Estándar
VAR
diferencia
STDEVP
desviación estándar basada en la población total
Page 107
VARP
varianza basada en la población total
El siguiente ejemplo calcula el valor promedio del rango A1: C3 e imprime el resultado en un cuadro de mensaje:
Dim Doc como objeto
Doc = ThisComponent
CellRange = Sheet.getCellRangeByName ("A1: C3")
MsgBox CellRange.computeFunction (com.sun.star.sheet.GeneralFunction.AVERAGE)
Advertencia: las funciones VAR, VARP, STDVERP devuelven un valor incorrecto cuando se aplican a una
rango. VerEdición 22625 .
Eliminar el contenido de la celda
El método clearContents simplifica el proceso de eliminar el contenido de la celda y los rangos de celda en el sentido de que elimina una
tipo específico de contenido de un rango de celdas.
El siguiente ejemplo elimina todas las cadenas y la información de formato directo del rango B2: C3 .
Dim Doc como objeto
Atenuar las banderas tan largas
Doc = ThisComponent
CellRange = Sheet.getCellRangeByName ("B2: C3")
Banderas = com.sun.star.sheet.CellFlags.STRING + _
com.sun.star.sheet.CellFlags.HARDATTR
CellRange.clearContents (banderas)
Los indicadores especificados en clearContents provienen de la lista de constantes com.sun.star.sheet.CellFlags. Esta lista
proporciona los siguientes elementos:
VALOR
valores numéricos que no están formateados como fecha u hora

FECHA Y HORA
valores numéricos formateados como fecha u hora

CUERDA
instrumentos de cuerda
ANOTACIÓN
comentarios que están vinculados a celdas

FÓRMULA
fórmulas
HARDATTR
formateo directo de celdas

ESTILOS
formato indirecto
OBJETOS
dibujar objetos que están conectados a celdas
Página 108
EDITATTR
formato de caracteres que solo se aplica a partes de las celdas
También puede agregar las constantes para eliminar información diferente mediante una llamada desde clearContents .
Buscar y reemplazar el contenido de la celda
Los documentos de hoja de cálculo, como los documentos de texto, proporcionan una función para buscar y reemplazar.
Los objetos descriptores para buscar y reemplazar en documentos de hoja de cálculo no se crean directamente a través del
objeto de documento, sino a través de la lista Hojas . El siguiente es un ejemplo de un proceso de búsqueda y reemplazo:
Dim Doc como objeto
Dim ReplaceDescriptor como objeto
Dim I como entero
Doc = ThisComponent
ReplaceDescriptor = Hoja.createReplaceDescriptor ()
ReplaceDescriptor.SearchString = "es"
ReplaceDescriptor.ReplaceString = "era"
Para I = 0 a Doc.Sheets.Count - 1
Hoja = Hojas Doc. (I)
Sheet.ReplaceAll (ReplaceDescriptor)
Siguiente yo
Este ejemplo utiliza la primera página del documento para crear un ReplaceDescriptor y luego lo aplica a todos
páginas en un bucle.
Page 109
8
CAPÍTULO 8
8 Dibujos y presentaciones
Este capítulo proporciona una introducción a la creación y edición de dibujos y presentaciones controladas por macros.
La primera sección describe la estructura de los dibujos, incluidos los elementos básicos que contienen los dibujos. los
La segunda sección aborda funciones de edición más complejas, como agrupar, rotar y escalar objetos. los
la tercera sección trata de las presentaciones.
Puede encontrar información sobre cómo crear, abrir y guardar dibujos en Trabajando con documentos.
La estructura de los dibujos
Páginas
Sugerencia: un documento de Draw (o Impress) se compone de páginas, también llamadas diapositivas. Lo que está escrito aquí también
se aplica a los documentos de Impress.
OpenOffice.org no limita el número de páginas de un documento de dibujo. Puede diseñar cada página por separado.
Tampoco hay límite para la cantidad de elementos de dibujo que puede agregar a una página.
Las páginas de un documento de dibujo están disponibles a través del contenedor DrawPages . Puede acceder individual
páginas a través de su número o su nombre. Si un documento tiene una página y esta se llama Diapositiva 1 , entonces la
Los siguientes ejemplos son idénticos.
Ejemplo 1: acceso mediante el número (la numeración comienza con 0)

Dim Doc como objeto
Atenuar página como objeto
Doc = ThisComponent
Página = Doc.DrawPages (0)
Nota: la expresión Doc.DrawPages (0) es una simplificación básica de la llamada a la API:

Doc.getDrawPages.getByIndex (0)
Ejemplo 2: acceso mediante el nombre

Dim Doc como objeto
Doc = ThisComponent
Page = Doc.DrawPages.getByName ("Diapositiva 1")
111
Página 110
En el Ejemplo 1, se accede a la página por su número (el conteo comienza en 0). En el segundo ejemplo, la página es
accede por su nombre y el método getByName .
Propiedades de una página
La llamada anterior devuelve un objeto de página que admite el servicio com.sun.star.drawing.DrawPage . los
El servicio reconoce las siguientes propiedades:
BorderLeft (largo)
borde izquierdo en centésimas de milímetro

BorderRight (largo)
borde derecho en centésimas de milímetro

BorderTop (largo)
borde superior en centésimas de milímetro

BorderBottom (largo)
borde inferior en centésimas de milímetro

Ancho (largo)
ancho de página en centésimas de milímetro
Altura (largo)
altura de página en centésimas de milímetro

Número (corto)
número de páginas (la numeración comienza en 1), solo lectura

Orientación (enumeración)
orientación de la página (de acuerdo con la enumeración com.sun.star.view.PaperOrientation )
Si se cambian estos ajustes, todas las páginas del documento se verán afectadas.
El siguiente ejemplo establece el tamaño de página de un documento de dibujo que se acaba de abrir en 20 x 20
centímetros con un margen de página de 0,5 centímetros:
Dim Doc como objeto
Doc = ThisComponent
Page.BorderLeft = 500
Page.BorderRight = 500
Page.BorderTop = 500
Page.BorderBottom = 500
Page.Width = 20000
Page.Height = 20000
Cambio de nombre de páginas
Advertencia: si se inserta una nueva página en un documento de dibujo de varias páginas, todas las páginas siguientes
no han cambiado de nombre verán automáticamente su cambio de nombre predeterminado, por ejemplo, la diapositiva 3 se cambiará a la diapositiva 4 , etc.
Este cambio de nombre automático también funciona a la inversa cuando se elimina una página.
La única forma de tener un nombre de página fijo es cambiar el nombre de la página, mediante la interfaz de usuario o mediante programación.
Una página proporciona los métodos getName y setName para leer y modificar su nombre. Basic puede manejar ambos métodos
como un nombre de propiedad . Aquí cambiamos el nombre de la primera página del documento de dibujo.
Dim Doc como objeto
Página 111
Doc = ThisComponent
Page.Name = "Primero"
Crear y eliminar páginas
El contenedor DrawPages de un documento de dibujo también se utiliza para crear y eliminar páginas individuales. los
El siguiente ejemplo usa el método hasByName para verificar si existe una página llamada MyPage . Si es así, el método
determina una referencia de objeto correspondiente mediante el método getByName y luego guarda la referencia en un
variable en la página . Si la página correspondiente no existe, se crea e inserta en el documento de dibujo por
el método insertNewByIndex . El argumento del método es la posición, contada desde 0, de la existente
página después de la cual se insertará la nueva página. Luego, se cambia el nombre de la nueva página.
Dim Doc como objeto
Doc = ThisComponent
Si Doc.Drawpages.hasByName ("MyPage"), entonces

Page = Doc.Drawpages.getByName ("Mi página")
Más
Página = Doc.Drawpages.insertNewByIndex (2)
Page.Name = "MyPage" 'siempre debe cambiar el nombre de una nueva página
'Mi página es la cuarta página del documento, es decir, la posición 3
Terminara si
Los métodos hasByName y getByName se obtienen de la interfaz com.sun.star.container.XNameAccess.
El método insertNewByIndex se obtiene de la interfaz com.sun.star.drawing.XDrawPages. Lo mismo

La interfaz proporciona el método remove para eliminar (eliminar) una página:
Dim Doc como objeto
Doc = ThisComponent
Si Doc.Drawpages.hasByName ("MyPage"), entonces

Doc.Drawpages.remove (página)
Terminara si
Duplicar una página
Se crea una copia de una página determinada, no desde el contenedor DrawPages, sino desde el propio documento de dibujo con
el método duplicado . La copia se crea en la siguiente posición después de la página original, con un nombre predeterminado.
Dim Doc como objeto
Atenuar página como objeto, ClonedPage como objeto
Doc = ThisComponent
ClonedPage = Doc.duplicate (página)
ClonedPage.Name = "MyCopy" 'siempre debe cambiar el nombre de una nueva página
Mover una página
La API no proporciona un método para cambiar la posición de una página dentro de un documento de dibujo.
Propiedades elementales de los objetos de dibujo
Los objetos de dibujo incluyen formas (rectángulos, círculos, etc.), líneas y objetos de texto. Todos estos comparten un número
de funciones comunes y admite el servicio com.sun.star.drawing.Shape . Este servicio define el tamaño
y Propiedades de posición de un objeto de dibujo.
OpenOffice.org Basic también ofrece varios otros servicios a través de los cuales puede modificar dichas propiedades, como
formatear o aplicar rellenos. Las opciones de formato que están disponibles dependen del tipo de objeto de dibujo.
Capítulo 8 · Dibujos y presentaciones 113
112
El siguiente ejemplo crea e inserta un rectángulo en un documento de dibujo:

Dim Doc como objeto
Dim Point como nuevo com.sun.star.awt.Point
Dim Size As New com.sun.star.awt.Size
Doc = ThisComponent
Punto.x = 1000
Punto.y = 1000
Tamaño.Ancho = 10000
Tamaño.Altura = 10000
RectangleShape = Doc.createInstance ("com.sun.star.drawing.RectangleShape")

RectangleShape.Size = Tamaño
RectangleShape.Position = Punto
Page.add (RectangleShape)
Las estructuras de Punto y Tamaño con el punto de origen (esquina izquierda) y el tamaño del objeto de dibujo son
luego inicializado. Las longitudes se especifican en centésimas de milímetro.
A continuación, el código del programa utiliza la llamada Doc.createInstance para crear el objeto de dibujo rectangular según lo especificado por
el servicio com.sun.star.drawing.RectangleShape. Al final, el objeto de dibujo se asigna a una página mediante un
Page.add llamar.
Propiedades de relleno
Esta sección describe cuatro servicios y en cada caso el código del programa de muestra utiliza un elemento de forma rectangular
que combina varios tipos de formato. Las propiedades de relleno se combinan en com.sun.star.drawing.FillProperties
Servicio.
OpenOffice.org reconoce cuatro tipos principales de formato para un área de relleno. La variante más simple es un relleno de un solo color.
Las opciones
opción para definir
de proyectar degradados
gráficos existentesdeencolor y tramas
el área le permiten crear otros colores en juego. La cuarta variante es la
de relleno.
El modo de relleno de un objeto de dibujo se define mediante la propiedad FillStyle . Los valores permitidos se definen en
com.sun.star.drawing.FillStyle.
Rellenos de un solo color
La propiedad principal de los rellenos de un solo color es:

FillColor (largo)
llenar el color del área
Para usar el modo de relleno, debe la propiedad FillStyle al modo de relleno SOLID .
El siguiente ejemplo crea una forma de rectángulo y la llena de rojo (valor RGB 255, 0, 0):
Dim Doc como objeto
Punto.x = 1000
Punto.y = 1000
Doc = ThisComponent

113
RectangleShape.FillStyle = com.sun.star.drawing.FillStyle.SOLID
RectangleShape.FillColor = RGB (255,0,0)
Gradiente de color
Si establece la propiedad FillStyle en GRADIENT , puede aplicar un degradado de color a cualquier área de relleno de un
Documento de OpenOffice.org.
Si desea aplicar un degradado de color predefinido, puede asignar el nombre asociado del
Propiedad FillTransparenceGradientName . Para definir su propio degradado de color, debe completar un
com.sun.star.awt.Gradient estructura para asignar la propiedad FillGradient . Esta propiedad proporciona lo siguiente
opciones:
Estilo (enumeración)
tipo de gradiente, por ejemplo, lineal o radial (valores predeterminados de acuerdo con
com.sun.star.awt.GradientStyle)
StartColor (largo)
color de inicio del degradado de color

EndColor (largo)
color final del degradado de color

Ángulo (corto)
ángulo del degradado de color en décimas de grado

XOffset (corto)
Coordenada X en la que comienza el degradado de color, especificada en centésimas de milímetro

YOffset (corto)
Coordenada Y en la que comienza el degradado de color, especificada en centésimas de milímetro

StartIntensity (corto)
intensidad de StartColor como porcentaje (en OpenOffice.org Basic, también puede especificar valores superiores a
100 por ciento)
EndIntensity (corto)
intensidad de EndColor como porcentaje (en OpenOffice.org Basic, también puede especificar valores superiores a
100 por ciento)
StepCount (corto)
número de graduaciones de color que OpenOffice.org debe calcular para los gradientes
El siguiente ejemplo demuestra el uso de degradados de color con la ayuda de com.sun.star.awt.Gradient

estructura:
Dim Doc como objeto
Atenuar degradado como nuevo com.sun.star.awt.Gradient
Punto.x = 1000
Punto.y = 1000
Doc = ThisComponent

114
Gradient.Style = com.sun.star.awt.GradientStyle.LINEAR
Gradient.StartColor = RGB (255,0,0)
Gradient.EndColor = RGB (0,255,0)
Gradient.StartIntensity = 150
Gradient.EndIntensity = 150
Gradient.Angle = 450
Gradient.StepCount = 100
RectangleShape.FillStyle = com.sun.star.drawing.FillStyle.GRADIENT
RectangleShape.FillGradient = Gradient
Este ejemplo crea un degradado de color lineal ( Estilo = LINEAL ). El degradado comienza con rojo ( StartColor ) en
la esquina superior izquierda, y se extiende en un ángulo de 45 grados ( ángulo ) al verde ( EndColor ) en la esquina inferior derecha. los
La intensidad del color de los colores inicial y final es del 150 por ciento ( StartIntensity y EndIntensity ), lo que da como resultado
los colores parecen más brillantes que los valores especificados en las propiedades StartColor y EndColor . El color
el degradado se representa con cien colores individuales graduados ( StepCount ).
Escotillas
Para crear un relleno de sombreado, la propiedad FillStyle debe establecerse en HATCH . El código del programa para definir la trampilla es
muy similar al código para degradados de color. Nuevamente una estructura auxiliar, en este caso com.sun.star.drawing.Hatch,
se utiliza para definir la apariencia de las tramas. La estructura de las trampillas tiene las siguientes propiedades:
Estilo (enumeración)
tipo de trama: simple, cuadrado o cuadrado con diagonales (valores predeterminados de acuerdo con
com.sun.star.awt.HatchStyle )
Color (largo)
color de las lineas

Distancia (larga)
distancia entre líneas en centésimas de milímetro

Ángulo (corto)
ángulo de eclosión en décimas de grado
El siguiente ejemplo demuestra el uso de una estructura de sombreado:

Dim Doc como objeto
Dim Hatch como nuevo com.sun.star.drawing.Hatch
Punto.x = 1000
Punto.y = 1000
Doc = ThisComponent

RectangleShape.FillStyle = com.sun.star.drawing.FillStyle.HATCH
Hatch.Style = com.sun.star.drawing.HatchStyle.SINGLE
Sombreado.Color = RGB (64,64,64)
Distancia de sombreado = 20
Hatch.Angle = 450
RectangleShape.FillHatch = Sombreado
Este código crea una estructura de sombreado simple ( HatchStyle = SINGLE ) cuyas líneas se giran 45 grados ( ángulo ).
115 de 1189.
Las líneas son de color gris oscuro ( color ) y están espaciadas 0,2 milímetros ( distancia ).
Mapas de bits
Para utilizar la proyección de mapa de bits como relleno, debe establecer la propiedad FillStyle en BITMAP . Si el mapa de bits ya está
disponible en OpenOffice.org, solo necesita especificar su nombre en la propiedad FillBitMapName y su visualización
estilo (simple, en mosaico o alargado) en la propiedad FillBitmapMode (valores predeterminados de acuerdo con
com.sun.star.drawing.BitmapMode).
Si desea utilizar un archivo de mapa de bits externo, puede especificar su URL en la propiedad FillBitmapURL .
El siguiente ejemplo crea un rectángulo y pone en mosaico el mapa de bits Sky que está disponible en OpenOffice.org para llenar el
área del rectángulo:
Dim Doc como objeto
Punto.x = 1000
Punto.y = 1000
Doc = ThisComponent

RectangleShape.FillStyle = com.sun.star.drawing.FillStyle.BITMAP
RectangleShape.FillBitmapName = "Cielo"
RectangleShape.FillBitmapMode = com.sun.star.drawing.BitmapMode.REPEAT
Transparencia
Puede ajustar la transparencia de cualquier relleno que aplique. La forma más sencilla de cambiar la transparencia de un
elemento de dibujo es utilizar la propiedad FillTransparence .
El siguiente ejemplo crea un rectángulo rojo con una transparencia del 50 por ciento.
Dim Doc como objeto
Punto.x = 1000
Punto.y = 1000
Doc = ThisComponent

RectangleShape.FillStyle = com.sun.star.drawing.FillStyle.SOLID
RectangleShape.FillTransparence = 50
RectangleShape.FillColor = RGB (255,0,0)
Para que el relleno sea transparente, establezca la propiedad FillTransparence en 100.
116
Además de la propiedad FillTransparence , el servicio com.sun.star.drawing.FillProperties también proporciona

FillTransparenceGradient propiedad. Se utiliza para definir un degradado que especifica la transparencia de un relleno.
zona.
Propiedades de linea
Todos los objetos de dibujo que pueden tener una línea de borde admiten el servicio com.sun.star.drawing.LineStyle. Algunos de los
Las propiedades que brinda este servicio son:
LineStyle (enumeración)
tipo de línea (valores predeterminados de acuerdo con com.sun.star.drawing.LineStyle)

LineColor (largo)
color de linea
LineTransparence (corto)
transparencia de línea
Ancho de línea (largo)
espesor de línea en centésimas de milímetro

LineJoint (enumeración)
transiciones a puntos de conexión (valores predeterminados de acuerdo con com.sun.star.drawing.LineJoint)
El siguiente ejemplo crea un rectángulo con un borde sólido ( LineStyle = SOLID ) de 5 milímetros de grosor
( LineWidth ) y 50 por ciento transparente. Los bordes derecho e izquierdo de la línea se extienden hasta sus puntos de
se cruzan entre sí ( LineJoint = MITRE ) para formar un ángulo recto.
Dim Doc como objeto
Punto.x = 1000
Punto.y = 1000
Doc = ThisComponent

RectangleShape.LineColor = RGB (128,128,128)

RectangleShape.LineTransparence = 50
RectangleShape.LineWidth = 500
RectangleShape.LineJoint = com.sun.star.drawing.LineJoint.MITER
RectangleShape.LineStyle = com.sun.star.drawing.LineStyle.SOLID
Además de las propiedades enumeradas, el servicio com.sun.star.drawing.LineStyle ofrece opciones para dibujar
líneas punteadas y discontinuas. Para obtener más información, consulte la referencia de la API de OpenOffice.org.
Propiedades del texto (objetos de dibujo)
Los com.sun.star.style.CharacterProperties y com.sun.star.style.ParagraphProperties
Los servicios pueden formatear texto en objetos de dibujo. Estos servicios se relacionan con caracteres y párrafos individuales y son
descrito en detalle en Documentos de texto.
El siguiente ejemplo inserta texto en un rectángulo y formatea la fuente com.sun.star.style.CharacterProperties
Página 117
Servicio.
Dim Doc como objeto
Punto.x = 1000
Punto.y = 1000
Doc = ThisComponent

RectangleShape.String = "Esto es una prueba"

RectangleShape.CharWeight = com.sun.star.awt.FontWeight.BOLD
RectangleShape.CharFontName = "Arial"
Este código usa la propiedad String del rectángulo para insertar el texto y CharWeight y CharFontName
properties del servicio com.sun.star.style.CharacterProperties para formatear la fuente del texto.
El texto solo se puede insertar después de que el objeto de dibujo se haya agregado a la página de dibujo. También puedes usar el
com.sun.star.drawing.Text servicio para colocar y formatear texto en el objeto de dibujo. Los siguientes son algunos de los
propiedades importantes de este servicio:
TextAutoGrowHeight (booleano)
adapta la altura del elemento de dibujo al texto que contiene

TextAutoGrowWidth (booleano)
adapta el ancho del elemento de dibujo al texto que contiene

TextHorizontalAdjust (Enum)
posición horizontal del texto dentro del elemento de dibujo (valores predeterminados de acuerdo con
com.sun.star.drawing.TextHorizontalAdjust)
TextVerticalAdjust (Enum)
posición vertical del texto dentro del elemento de dibujo (valores predeterminados de acuerdo con
com.sun.star.drawing.TextVerticalAdjust)
TextLeftDistance (largo)
distancia a la izquierda entre el elemento de dibujo y el texto en centésimas de milímetro

TextRightDistance (largo)
distancia a la derecha entre el elemento de dibujo y el texto en centésimas de milímetro

TextUpperDistance (largo)
distancia superior entre el elemento de dibujo y el texto en centésimas de milímetro

TextLowerDistance (largo)
menor distancia entre el elemento de dibujo y el texto en centésimas de milímetro
El siguiente ejemplo demuestra el uso de las propiedades nombradas.

Dim Doc como objeto
Punto.x = 1000
Punto.y = 1000
Doc = ThisComponent
118

RectangleShape.String = "Esta es una prueba" '¡Solo puede tener lugar después de Page.add!
RectangleShape.TextVerticalAdjust = com.sun.star.drawing.TextVerticalAdjust.TOP
RectangleShape.TextHorizontalAdjust = com.sun.star.drawing.TextHorizontalAdjust.LEFT
RectangleShape.TextLeftDistance = 300
RectangleShape.TextRightDistance = 300
RectangleShape.TextUpperDistance = 300
RectangleShape.TextLowerDistance = 300
Este código inserta un elemento de dibujo en una página y luego agrega texto en la esquina superior izquierda del objeto de dibujo usando
las propiedades TextVerticalAdjust y TextHorizontalAdjust . La distancia mínima entre el texto
el borde del objeto de dibujo se establece en tres milímetros.
Propiedades de la sombra
Puede agregar una sombra a la mayoría de los objetos de dibujo con el servicio com.sun.star.drawing.ShadowProperties. los
Las propiedades de este servicio son:
Sombra (booleana)
activa la sombra
ShadowColor (largo)
color de sombra
ShadowTransparence (corto)
transparencia de la sombra
ShadowXDistance (largo)
distancia vertical de la sombra desde el objeto de dibujo en centésimas de milímetro

ShadowYDistance (largo)
distancia horizontal de la sombra desde el objeto de dibujo en centésimas de milímetro
El siguiente ejemplo crea un rectángulo con una sombra que está desplazada vertical y horizontalmente de la
rectángulo por 2 milímetros. La sombra se representa en gris oscuro con un 50 por ciento de transparencia.
Dim Doc como objeto
Punto.x = 1000
Punto.y = 1000
Doc = ThisComponent

RectangleShape.Shadow = True
RectangleShape.ShadowColor = RGB (192,192,192)
RectangleShape.ShadowTransparence = 50
RectangleShape.ShadowXDistance = 200
RectangleShape.ShadowYDistance = 200
Page 119
Una descripción general de varios objetos de dibujo
Formas de rectángulo
Los objetos de forma rectangular (com.sun.star.drawing.RectangleShape) admiten los siguientes servicios para formatear
objetos:
com.sun.star.drawing.FillProperties
Propiedades de línea
com.sun.star.drawing.LineProperties
Propiedades del texto
com.sun.star.drawing.Text (con com.sun.star.style.CharacterProperties y

com.sun.star.style.ParagraphProperties)
Propiedades de sombra
com.sun.star.drawing.ShadowProperties
CornerRadius (largo)
radio para redondear esquinas en centésimas de milímetro
Círculos y elipses
El servicio com.sun.star.drawing.EllipseShape es responsable de los círculos y elipses y apoya la

siguientes servicios:

Además de estos servicios, los círculos y elipses también proporcionan estas propiedades:
CircleKind (enumeración)
tipo de círculo o elipse (valores predeterminados de acuerdo con com.sun.star.drawing.CircleKind)

CircleStartAngle (largo)
ángulo de inicio en décimas de grado (solo para segmentos de círculo o elipse)

CircleEndAngle (largo)
ángulo final en décimas de grado (solo para segmentos de círculo o elipse)
La propiedad CircleKind determina si un objeto es un círculo completo, un corte circular o una sección de un círculo. los
los siguientes valores están disponibles:
com.sun.star.drawing.CircleKind.FULL
círculo completo o elipse completo

com.sun.star.drawing.CircleKind.CUT
sección de círculo (círculo parcial cuyas interfaces están vinculadas directamente entre sí)
Página 120
com.sun.star.drawing.CircleKind.SECTION
rebanada circular
com.sun.star.drawing.CircleKind.ARC
ángulo (sin incluir la línea del círculo)
El siguiente ejemplo crea un corte circular con un ángulo de 70 grados (producido a partir de la diferencia entre el inicio
ángulo de 20 grados y ángulo final de 90 grados)
Dim Doc como objeto
Dim ElipseForma como objeto
Punto.x = 1000
Punto.y = 1000
Doc = ThisComponent
EllipseShape = Doc.createInstance ("com.sun.star.drawing.EllipseShape")

EllipseShape.Size = Tamaño
EllipseShape.Position = Punto
EllipseShape.CircleStartAngle = 2000
EllipseShape.CircleEndAngle = 9000
EllipseShape.CircleKind = com.sun.star.drawing.CircleKind.SECTION
Page.add (EllipseShape)
Líneas
OpenOffice.org proporciona el servicio com.sun.star.drawing.LineShape para objetos de línea. Los objetos de línea admiten todos los
los servicios generales de formato con la excepción de áreas. Las siguientes son todas las propiedades que son
asociado con el servicio LineShape :

El siguiente ejemplo crea y formatea una línea con la ayuda de las propiedades nombradas. El origen de la línea es
especificado en la propiedad Ubicación , mientras que las coordenadas enumeradas en la propiedad Tamaño especifican el punto final de
la línea.
Dim Doc como objeto
Dim LineShape como objeto
Punto.x = 1000
Punto.y = 1000
Doc = ThisComponent
LineShape = Doc.createInstance ("com.sun.star.drawing.LineShape")

LineShape.Size = Tamaño
LineShape.Position = Punto
Page 121
Page.add (LineShape)
Formas de polipolígono
OpenOffice.org también admite formas poligonales complejas a través de com.sun.star.drawing.PolyPolygonShape
Servicio. Estrictamente hablando, un PolyPolygon no es un polígono simple sino un polígono múltiple. Varias listas independientes
que contienen puntos de esquina, por lo tanto, se pueden especificar y combinar para formar un objeto completo.
Al igual que con las formas rectangulares, todas las propiedades de formato de los objetos de dibujo también se proporcionan para los polígonos:

El servicio PolyPolygonShape también tiene una propiedad que le permite definir las coordenadas de un polígono:
PolyPolygon (Matriz) :
campo que contiene las coordenadas del polígono (matriz doble con puntos del
com.sun.star.awt.Point tipo)
El siguiente ejemplo muestra cómo puede definir un triángulo con el servicio PolyPolygonShape .
Dim Doc como objeto
Dim PolyPolygonShape como objeto
Dim PolyPolygon como variante
Atenuar coordenadas (2) Como nuevo com.sun.star.awt.Point
Doc = ThisComponent
PolyPolygonShape = Doc.createInstance ("com.sun.star.drawing.PolyPolygonShape")

Page.add (PolyPolygonShape) 'Page.add debe tener lugar antes de que se establezcan las coordenadas
Coordenadas (0) .x = 1000

Coordenadas (0) .y = 1000
PolyPolygonShape.PolyPolygon = Array (Coordenadas ())
Dado que los puntos de un polígono se definen como valores absolutos, no es necesario especificar el tamaño o el inicio
posición de un polígono. En su lugar, necesita crear una matriz de puntos, empaquetar esta matriz en una segunda matriz
(usando la llamada Array (Coordinates ()) ), y luego asigne esta matriz al polígono. Antes de la convocatoria correspondiente
se puede hacer, el polígono debe insertarse en el documento.
La matriz doble en la definición le permite crear formas complejas fusionando varios polígonos. Por ejemplo,
puede crear un rectángulo y luego insertar otro rectángulo dentro de él para crear un agujero en el rectángulo original:
Dim Doc como objeto
Dim PolyPolygonShape como objeto
Dim PolyPolygon como variante
Dim Square1 (3) Como nuevo com.sun.star.awt.Point
Doc = ThisComponent
PolyPolygonShape = Doc.createInstance ("com.sun.star.drawing.PolyPolygonShape")
Page 122
Page.add (PolyPolygonShape) 'Page.add debe tener lugar antes de que se establezcan las coordenadas
Cuadrado1 (0) .x = 5000

Cuadrado1 (1) .x = 10000
Cuadrado1 (2) .x = 10000
Cuadrado1 (3) .x = 5000
Cuadrado1 (0) .y = 5000
Cuadrado1 (1) .y = 5000
Cuadrado1 (2) .y = 10000
Cuadrado1 (3) .y = 10000
Cuadrado2 (0) .x = 6500
Cuadrado2 (1) .x = 8500
Cuadrado2 (2) .x = 8500
Cuadrado2 (3) .x = 6500
Cuadrado2 (0) .y = 6500
Cuadrado2 (1) .y = 6500
Cuadrado2 (2) .y = 8500
Cuadrado2 (3) .y = 8500
Cuadrado3 (0) .x = 6500

Cuadrado3 (1) .x = 8500
Cuadrado3 (2) .x = 8500
Cuadrado3 (3) .x = 6500
Cuadrado3 (0) .y = 9000
Cuadrado3 (1) .y = 9000
Cuadrado3 (2) .y = 9500
Cuadrado3 (3) .y = 9500
PolyPolygonShape.PolyPolygon = Array (Cuadrado1 (), Cuadrado2 (), Cuadrado3 ())
Con respecto a qué áreas se rellenan y qué áreas son agujeros, OpenOffice.org aplica una regla simple: el borde
de la forma exterior es siempre el borde exterior del polipolígono. La siguiente línea hacia adentro es el borde interno del
forma y marca la transición al primer agujero. Si hay otra línea hacia adentro, marca la transición a un relleno
zona.
Gráficos
El último de los elementos de dibujo presentados aquí son objetos gráficos que se basan en
servicio com.sun.star.drawing.GraphicObjectShape. Estos se pueden usar con cualquier gráfico dentro de OpenOffice.org
cuyo aspecto se puede adaptar mediante toda una gama de propiedades.
Los objetos gráficos admiten dos de las propiedades generales de formato:


Las propiedades adicionales que son compatibles con los objetos gráficos son:
GraphicURL (cadena)
URL del gráfico

Ajustar luminancia (corto)
luminancia de los colores, como porcentaje (también se permiten valores negativos)

AdjustContrast (corto)
contraste como porcentaje (también se permiten valores negativos)

AdjustRed (corto)
valor rojo como porcentaje (también se permiten valores negativos)

AdjustGreen (corto)
valor verde como porcentaje (también se permiten valores negativos)
Página 123
AdjustBlue (corto)
valor azul como porcentaje (también se permiten valores negativos)

Gamma (corto)
valor gamma de un gráfico

Transparencia (corta)
transparencia de un gráfico como porcentaje

GraphicColorMode (enumeración)
modo de color, por ejemplo, estándar, etapas grises, blanco y negro (valor predeterminado de acuerdo con
com.sun.star.drawing.ColorMode)
El siguiente ejemplo muestra cómo insertar una página en un objeto gráfico.
Dim Doc como objeto
Dim GraphicObjectShape como objeto
Punto.x = 1000 'especificaciones, insignificantes porque las últimas

las coordenadas son vinculantes
Punto.y = 1000
Doc = ThisComponent
GraphicObjectShape = Doc.createInstance ("com.sun.star.drawing.GraphicObjectShape")
GraphicObjectShape.Size = Tamaño
GraphicObjectShape.Position = Punto
GraphicObjectShape.GraphicURL = "archivo: /// c: /test.jpg"

GraphicObjectShape.AdjustBlue = -50
GraphicObjectShape.AdjustGreen = 5
GraphicObjectShape.AdjustBlue = 10
GraphicObjectShape.AdjustContrast = 20
GraphicObjectShape.AdjustLuminance = 50
GraphicObjectShape.Transparency = 40
GraphicObjectShape.GraphicColorMode = com.sun.star.drawing.ColorMode.STANDARD
Page.add (GraphicObjectShape)
Este código inserta el gráfico test.jpg y adapta su apariencia usando las propiedades de Ajustar . En este ejemplo,
los gráficos se representan como 40 por ciento transparentes sin que se produzcan otras conversiones de color
( GraphicColorMode = ESTÁNDAR ).
Editar objetos de dibujo
Agrupar objetos
En muchas situaciones, es útil agrupar varios objetos de dibujo individuales para que se comporten como un solo
objeto grande.
El siguiente ejemplo combina dos objetos de dibujo:

Dim Doc como objeto
Dim Square como objeto
Círculo tenue como objeto
Atenuar formas como objeto
Dim Group As Object
Page 124

Atenuar NewPos como nuevo com.sun.star.awt.Point
Dim altura tan larga
Dim Width As Long
Doc = ThisComponent
Punto.x = 3000
Punto.y = 3000
'crear elemento de dibujo cuadrado
Cuadrado = Doc.createInstance ("com.sun.star.drawing.RectangleShape")
Square.Size = Tamaño
Square.Position = Punto
Square.FillColor = RGB (255,128,128)
Page.add (cuadrado)
'crear elemento de dibujo circular

Círculo = Doc.createInstance ("com.sun.star.drawing.EllipseShape")
Circle.Size = Tamaño
Circle.Position = Punto
Circle.FillColor = RGB (255,128,128)
Circle.FillColor = RGB (0,255,0)
Page.add (círculo)
'combinar elementos de dibujo cuadrados y circulares

Formas = createUnoService ("com.sun.star.drawing.ShapeCollection")
Shapes.add (cuadrado)
Shapes.add (círculo)
Grupo = Page.group (Formas)
'centrar elementos de dibujo combinados
Height = Page.Height
Width = Page.Width
NewPos.X = Ancho / 2
NewPos.Y = Altura / 2
Height = Group.Size.Height
Width = Group.Size.Width
NewPos.X = NewPos.X - Ancho / 2
NewPos.Y = NewPos.Y - Altura / 2
Group.Position = NewPos
Este código crea un rectángulo y un círculo y los inserta en una página. Luego crea un objeto que soporta la
com.sun.star.drawing.ShapeCollection y usa el método Add para agregar el rectángulo y el círculo a este
objeto. El ShapeCollection se añade a la página utilizando el Grupo método y devuelve el actual grupo de objetos
que se puede editar como una forma individual .
Si desea formatear los objetos individuales de un grupo, aplique el formato antes de agregarlos al grupo.
No puede modificar los objetos una vez que están en el grupo.
Rotar y cortar objetos de dibujo
Todos los objetos de dibujo que se describen en las secciones anteriores también se pueden rotar y cortar utilizando el
Servicio com.sun.star.drawing.RotationDescriptor.
El servicio proporciona las siguientes propiedades:

RotateAngle (largo)
ángulo de rotación en centésimas de grado

ShearAngle (largo)
ángulo de corte en centésimas de grado
El siguiente ejemplo crea un rectángulo y lo rota 30 grados usando la propiedad RotateAngle :

Dim Doc como objeto
125
Punto.x = 1000
Punto.y = 1000
Doc = ThisComponent

RectangleShape.RotateAngle = 3000
El siguiente ejemplo crea el mismo rectángulo que en el ejemplo anterior, pero en su lugar lo corta 30 grados
utilizando la propiedad ShearAngle .
Dim Doc como objeto
Punto.x = 1000
Punto.y = 1000
Doc = ThisComponent
RectangleShape.ShearAngle = 3000
Buscar y reemplazar
Al igual que en los documentos de texto, los documentos de dibujo proporcionan una función para buscar y reemplazar. Esta función es similar a
el que se usa en documentos de texto como se describe en Documentos de texto. Sin embargo, en los documentos de dibujo,
Los objetos descriptores para buscar y reemplazar no se crean directamente a través del objeto de documento, sino
a través del nivel de personaje asociado. El siguiente ejemplo describe el proceso de reemplazo dentro de un dibujo:
Dim Doc como objeto
Dim ReplaceDescriptor como objeto
Dim I como entero
Doc = ThisComponent
ReplaceDescriptor = Page.createReplaceDescriptor ()
ReplaceDescriptor.SearchString = "es"
ReplaceDescriptor.ReplaceString = "era"
Para I = 0 a Doc.DrawPages.Count - 1
Página = Doc.DrawPages (I)
Page.ReplaceAll (ReplaceDescriptor)
Siguiente yo
Este código usa la primera página del documento para crear un ReplaceDescriptor y luego aplica este descriptor
en un bucle a todas las páginas del documento de dibujo.
Página 126
Presentaciones
Presentaciones
Las presentaciones de OpenOffice.org se basan en documentos de dibujo. Cada página de la presentación es una diapositiva. Usted puede
acceder a las diapositivas de la misma manera que se accede a un dibujo estándar a través de la lista DrawPages del documento
objeto. El servicio com.sun.star.presentation.PresentationDocument, responsable de los documentos de presentación,
también proporciona el servicio completo com.sun.star.drawing.DrawingDocument.
Trabajar con presentaciones
Además de las funciones de dibujo que proporciona la propiedad Presentación , la presentación

El documento tiene un objeto de presentación que proporciona acceso a las principales propiedades y mecanismos de control para
presentaciones. Por ejemplo, este objeto proporciona un método de inicio que puede iniciar presentaciones.
Dim Doc como objeto
Presentación tenue como objeto
Doc = ThisComponent
Presentación = Presentación doc.
Presentation.start ()
El código utilizado en este ejemplo crea un objeto Doc que hace referencia al documento de presentación actual y
establece el objeto de presentación asociado. El método start () del objeto se utiliza para iniciar el ejemplo y
ejecutar la presentación en pantalla.
Los siguientes métodos se proporcionan como objetos de presentación:

comienzo
comienza la presentación
final
termina la presentación
ensayar tiempos
inicia la presentación desde el principio y establece su tiempo de ejecución
Las siguientes propiedades también están disponibles:

AllowAnimations (booleano)
ejecuta animaciones en la presentación

CustomShow (cadena)
le permite especificar el nombre de la presentación para que pueda hacer referencia al nombre en la presentación
FirstPage (cadena)
nombre de la diapositiva con la que desea iniciar la presentación

IsAlwaysOnTop (booleano)
siempre muestra la ventana de presentación como la primera ventana en la pantalla

IsAutomatic (booleano)
se ejecuta automáticamente a través de la presentación

IsEndless (booleano)
reinicia la presentación desde el principio una vez que termina

IsFullScreen (booleano)
inicia automáticamente la presentación en modo de pantalla completa

IsMouseVisible (booleano)
muestra el mouse durante la presentación
Página 127
Presentaciones
Pausa (larga)
la cantidad de tiempo que se muestra una pantalla en blanco al final de la presentación

StartWithNavigator (booleano)
muestra la ventana del navegador cuando comienza la presentación

UsePn (booleano)
muestra el puntero durante la presentación
Page 128
9
CAPÍTULO 9
9 Gráficos (diagramas)
OpenOffice.org puede mostrar datos como un gráfico, que crea representaciones gráficas de datos numéricos en el formulario
de barras, gráficos circulares, líneas u otros elementos. Los datos se pueden mostrar como gráficos 2D o 3D, y la apariencia
de los elementos del gráfico se pueden adaptar individualmente de forma similar al proceso utilizado para dibujar elementos.
Los gráficos no se tratan como documentos independientes en OpenOffice.org, sino como objetos que están incrustados en un
documento existente.
Un gráfico puede contener sus propios datos o puede mostrar datos del documento contenedor. Por ejemplo, gráficos en
las hojas de cálculo pueden mostrar datos obtenidos de los rangos de celdas y los gráficos en documentos de texto pueden mostrar datos obtenidos
de las tablas del escritor.
Usar gráficos en hojas de cálculo

Los gráficos dentro de las hojas de cálculo pueden mostrar los datos de un rango de celdas asignado dentro de la hoja de cálculo. Alguna
las modificaciones realizadas a los datos dentro de la hoja de cálculo también se reflejarán en el gráfico asignado. El seguimiento
El ejemplo muestra cómo crear un gráfico asignado a algunos rangos de celdas dentro de un documento de hoja de cálculo:
Dim Doc como objeto
Dim Charts como objeto
Dim Chart como objeto
Dim Rect como nuevo com.sun.star.awt.Rectangle
Dim RangeAddress (0) Como nuevo com.sun.star.table.CellRangeAddress
Doc = ThisComponent
Gráficos = Hojas de documento (0).
Rect.X = 8000
Rect.Y = 1000
Ancho rect. = 10000
Altura rect. = 7000
RangeAddress (0) .Sheet = 0
RangeAddress (0) .StartColumn = 0
RangeAddress (0) .StartRow = 0
RangeAddress (0) .EndColumn = 2
RangeAddress (0) .EndRow = 12
Charts.addNewByName ("MyChart", Rect, RangeAddress (), True, True)
Aunque el código utilizado en el ejemplo puede parecer complejo, los procesos centrales se limitan a tres líneas.
La primera línea central crea la variable de documento Doc , que hace referencia al documento de hoja de cálculo actual ( Doc
línea = StarDesktop.CurrentComponent ). El código utilizado en el ejemplo crea una lista que contiene todos los gráficos.
de la primera hoja de cálculo ( Línea de gráficos = Hojas de documento (0). Gráficos ). Finalmente, en la última línea, se agrega un nuevo gráfico a
esta lista usando el método addNewByName . Este nuevo gráfico es visible para el usuario. La variable RangeAddress
determina el rango de celdas asignado cuyos datos se mostrarán dentro del gráfico. La variable Rect determina el
posición y tamaño del gráfico dentro de la primera hoja del documento de hoja de cálculo.
131
Página 129
Usar gráficos en hojas de cálculo
El ejemplo anterior crea un gráfico de barras. Si se necesita un tipo de gráfico diferente, entonces el gráfico de barras debe estar explícitamente
sustituido:
Chart = Charts.getByName ("MyChart"). EmbeddedObject
Chart.Diagram = Chart.createInstance ("com.sun.star.chart.LineDiagram")
La primera línea define el objeto de gráfico correspondiente. La segunda línea reemplaza el gráfico actual por uno nuevo:
en este ejemplo, un gráfico de líneas.
Nota - VBA: en Microsoft Excel, se hace una distinción entre los gráficos que se han insertado como un
página en un documento de Microsoft Excel y gráficos que están incrustados en una página de tabla. En consecuencia, dos
Allí se definen diferentes métodos de acceso para los gráficos. Esta distinción no se hace en OpenOffice.org Basic,
porque los gráficos en OpenOffice.org Calc siempre se crean como objetos incrustados en una página de tabla. Los gráficos son
siempre se accede utilizando la lista Gráficos del objeto Hoja asociado .
La estructura de los gráficos

La estructura de un gráfico y, por lo tanto, la lista de servicios e interfaces que admite, depende del gráfico.
tipo. Por ejemplo, los métodos y propiedades del eje Z están disponibles en gráficos 3D, pero no en gráficos 2D, y
en los gráficos circulares, no hay interfaces para trabajar con ejes.
Título, subtítulo y leyenda
El título, subtítulo y leyenda son elementos básicos proporcionados para cada gráfico. El objeto Chart proporciona lo siguiente
propiedades para administrar estos elementos:
HasMainTitle (booleano)
activa el título
Título (objeto)
objeto con información detallada sobre el título del gráfico (admite el servicio com.sun.star.chart.ChartTitle)
HasSubTitle (booleano)
activa el subtítulo
Subtítulo (objeto)
objeto con información detallada sobre el subtítulo del gráfico (admite com.sun.star.chart.ChartTitle
Servicio)
HasLegend (booleano)
activa la leyenda
Leyenda (objeto)
objeto con información detallada sobre la leyenda (admite el servicio com.sun.star.chart.ChartLegend)
Ambos servicios com.sun.star.chart.ChartTitle y com.sun.star.chart.ChartLegend admiten la

service com.sun.star.drawing.Shape . Esto permite determinar la posición y tamaño de los elementos usando
las propiedades Posición y Tamaño . Como el tamaño de la leyenda y los títulos se calcula automáticamente en función de
el contenido actual y la altura del carácter, por ejemplo, la propiedad de tamaño proporciona acceso de solo lectura.
Rellenar y alinear propiedades (servicios com.sun.star.drawing.FillProperties y com.sun.star.drawing.LineProperties) como

así como las propiedades del personaje (servicio com.sun.star.style.CharacterProperties) se proporcionan para más
formato de los elementos.
com.sun.star.chart.ChartTitle contiene no solo las propiedades de formato enumeradas, sino también otras dos propiedades:
Cadena (cadena)
texto que se mostrará como título o subtítulo
130
TextRotation (largo)
ángulo de rotación del texto en centésimas de grado
La leyenda (com.sun.star.chart.ChartLegend) contiene la siguiente propiedad adicional:

Alineación (enumeración)
posición en la que aparece la leyenda (valor de tipo com.sun.star.chart.ChartLegendPosition)
El siguiente ejemplo crea un gráfico con un título "Cadena de título principal", un subtítulo "Cadena de subtítulos" y una leyenda. los
La leyenda tiene un color de fondo gris, se coloca en la parte inferior del gráfico y tiene un tamaño de carácter de 7 puntos.
Dim Doc como objeto
Rect.X = 8000
Rect.Y = 1000
Ancho rect. = 10000
Altura rect. = 7000
Doc = ThisComponent

Chart.HasMainTitle = True
Chart.Title.String = "Cadena de título principal"
Chart.HasSubTitle = True
Chart.Subtitle.String = "Cadena de subtítulos"
Chart.HasLegend = True
Chart.Legend.Alignment = com.sun.star.chart.ChartLegendPosition.BOTTOM
Chart.Legend.FillStyle = com.sun.star.drawing.FillStyle.SOLID
Chart.Legend.FillColor = RGB (210, 210, 210)
Chart.Legend.CharHeight = 7
Antecedentes
Cada gráfico tiene un área de fondo. El objeto Gráfico proporciona la propiedad Área para formatear el fondo:
Área (objeto)
área de fondo del gráfico (admite el servicio com.sun.star.chart.ChartArea)
El fondo de un gráfico cubre su área completa, incluida el área debajo del título, subtítulo y leyenda. los
El servicio com.sun.star.chart.ChartArea asociado admite propiedades de línea y relleno.
Diagrama
El objeto Gráfico proporciona la propiedad Diagrama que forma el sistema de coordenadas con ejes y cuadrículas, donde
finalmente se muestran los datos:
Diagrama (objeto)
objeto que forma el sistema de coordenadas donde se trazan los datos. Es compatible con com.sun.star.chart.Diagram
servicio y:
com.sun.star.chart.StackableDiagram
com.sun.star.chart.ChartAxisXSupplier
com.sun.star.chart.ChartAxisYSupplier
Capítulo 9 · Gráficos (diagramas) 133
Página 131
com.sun.star.chart.ChartAxisZSupplier
com.sun.star.chart.ChartTwoAxisXSupplier
com.sun.star.chart.ChartTwoAxisYSupplier
Se admiten diferentes servicios según el tipo de gráfico (consulte Tipos de gráficos)
Pared y piso
La pared del gráfico es el fondo del sistema de coordenadas donde se trazan los datos. Normalmente existen dos paredes de gráficos
para gráficos 3D: uno detrás de los datos trazados y otro como la demarcación de la izquierda o la derecha. Esto depende de
la rotación del gráfico. Los gráficos 3D también suelen tener un suelo.
El objeto Diagrama proporciona las propiedades Muro y Suelo:

Muro (objeto)
muro de fondo del sistema de coordenadas (admite el servicio com.sun.star.chart.ChartArea)

Piso (Objeto)
panel de suelo del sistema de coordenadas (solo para gráficos 3D, admite el servicio com.sun.star.chart.ChartArea)
Los objetos especificados admiten el servicio com.sun.star.chart.ChartArea , que proporciona el relleno y

propiedades de línea (servicios com.sun.star.drawing.FillProperties y com.sun.star.drawing.LineProperties, consulte
Dibujos y presentaciones)
El siguiente ejemplo muestra cómo los gráficos (llamados Sky) ya contenidos en OpenOffice.org se pueden utilizar como
fondo para un gráfico. La pared está configurada para ser azul.
Dim Doc como objeto
Rect.X = 8000
Rect.Y = 1000
Ancho rect. = 10000
Altura rect. = 7000
Doc = ThisComponent

Chart.Area.FillStyle = com.sun.star.drawing.FillStyle.BITMAP
Chart.Area.FillBitmapName = "Cielo"
Chart.Area.FillBitmapMode = com.sun.star.drawing.BitmapMode.REPEAT
Chart.Diagram.Wall.FillStyle = com.sun.star.drawing.FillStyle.SOLID
Chart.Diagram.Wall.FillColor = RGB (00,132,209)
Hachas
OpenOffice.org reconoce cinco ejes diferentes que se pueden utilizar en un gráfico. En el escenario más simple, estos son los X
y ejes Y. Cuando se trabaja con gráficos 3D, a veces también se proporciona un eje Z. Para gráficos en los que los valores de
las diversas filas de datos se desvían significativamente entre sí, OpenOffice.org proporciona un segundo eje X e Y
para operaciones de segunda escala.
El objeto Diagrama proporciona las siguientes propiedades para acceder a los ejes:
Page 132
HasXAxis (booleano)
activa el eje X
XAxis (objeto)
objeto con información detallada sobre el eje X (admite el servicio com.sun.star.chart.ChartAxis)

HasXAxisDescription (booleano)
activa las etiquetas para las marcas de intervalo para el eje X

HasYAxis (booleano)
activa el eje Y
YAxis (objeto)
objeto con información detallada sobre el eje Y (admite el servicio com.sun.star.chart.ChartAxis)

HasYAxisDescription (booleano)
activa las etiquetas para las marcas de intervalo para el eje Y

HasZAxis (booleano)
activa el eje Z
ZAxis (objeto)
objeto con información detallada sobre el eje Z (admite el servicio com.sun.star.chart.ChartAxis)

HasZAxisDescription (booleano)
activa las etiquetas para las marcas de intervalo para el eje Z

HasSecondaryXAxis (booleano)
activa el eje X secundario

SecondaryXAxis (objeto)
objeto con información detallada sobre el eje X secundario (admite com.sun.star.chart.ChartAxis

Servicio)
HasSecondaryXAxisDescription (booleano)
activa las etiquetas para las marcas de intervalo para el eje X secundario
HasSecondaryYAxis (booleano)
activa el eje Y secundario

SecondaryYAxis (objeto)
objeto con información detallada sobre el eje Y secundario (admite com.sun.star.chart.ChartAxis

Servicio)
HasSecondaryYAxisDescription (booleano)
activa las etiquetas para las marcas de intervalo para el eje Y secundario
Propiedades de los ejes
Los objetos de eje de un gráfico de OpenOffice.org admiten el servicio com.sun.star.chart.ChartAxis. Además de

propiedades de los personajes (servicio com.sun.star.style.CharacterProperties, consulte Documentos de texto) y líneas
(servicio com.sun.star.drawing.LineStyle, consulte Dibujos y presentaciones), proporciona lo siguiente
propiedades:
Propiedades de escala:
Max (doble)
valor máximo para el eje
Page 133
Min (doble)
valor mínimo para el eje

Origen (doble)
punto de intersección para ejes cruzados

StepMain (doble)
distancia entre las principales marcas de intervalo

StepHelp (doble)
distancia entre las marcas de intervalo menores (en desuso desde OpenOffice.org 3.0; Use la propiedad
StepHelpCount en su lugar)
StepHelpCount (largo)
Contiene el número de intervalos menores dentro de un intervalo mayor. Por ejemplo, un StepHelpCount de 5 divide el
intervalo mayor en 5 piezas y, por lo tanto, produce 4 marcas menores. (disponible desde OpenOffice.org 3.0)
AutoMax (booleano)
el valor máximo para el eje se calcula automáticamente cuando se establece en verdadero

AutoMin (booleano)
el valor mínimo para el eje se calcula automáticamente cuando se establece en verdadero

AutoOrigin (booleano)
el origen se determina automáticamente cuando se establece en verdadero

AutoStepMain (booleano)
StepMain se determina automáticamente cuando se establece en verdadero

AutoStepHelp (booleano)
StepHelpCount se determina automáticamente cuando se establece en verdadero

Logarítmico (booleano)
escala los ejes de forma logarítmica (en lugar de lineal)

ReverseDirection (booleano)
determina si la orientación del eje es matemática o inversa. (disponible desde OpenOffice.org 2.4)
Propiedades de la etiqueta:
DisplayLabels (booleano)
activa la etiqueta de texto en las marcas de intervalo

TextRotation (largo)
ángulo de rotación de la etiqueta de texto en centésimas de grado

ArrangeOrder (enumeración)
la etiqueta puede estar escalonada, por lo que se colocan alternativamente en dos líneas (valores según
com.sun.star.chart.ChartAxisArrangeOrderType)
TextBreak (booleano)
permite saltos de línea dentro de las etiquetas de los ejes

TextCanOverlap (booleano)
permite una superposición de las etiquetas de los ejes

NumberFormat (largo)
formato de número que se utilizará con las etiquetas de los ejes

LinkNumberFormatToSource (booleano)
determina si se debe utilizar el formato numérico proporcionado por el documento contenedor o de la propiedad
Page 134
NumberFormat . (desde OpenOffice.org 2.3)
Propiedades de la marca de intervalo:

Marcas (Const)
determina la posición de las principales marcas de intervalo (valores de acuerdo con

com.sun.star.chart.ChartAxisMarks)
HelpMarks (Const)
determina la posición de las marcas de intervalo menores (valores de acuerdo con

com.sun.star.chart.ChartAxisMarks)
Solo para gráficos de barras:

Superposición (larga)
porcentaje que especifica la medida en que las barras de diferentes conjuntos de datos pueden superponerse (al 100%, el
las barras se muestran como completamente superpuestas, al -100%, hay una distancia del ancho de una barra entre
ellos)
GapWidth (largo)
porcentaje que especifica la distancia que puede haber entre los diferentes grupos de barras de un gráfico (en
100%, hay una distancia correspondiente al ancho de una barra)
Rejillas
Para los ejes primarios, se pueden mostrar cuadrículas y subcuadrículas, haciendo coincidir los intervalos mayores y menores. los
El objeto de diagrama proporciona las siguientes propiedades para acceder a las cuadrículas:
HasXAxisGrid (booleano)
activa la cuadrícula principal para el eje X

XMainGrid (Objeto)
objeto con información detallada sobre la cuadrícula principal para el eje X (admite com.sun.star.chart.ChartGrid
Servicio)
HasXAxisHelpGrid (booleano)
activa la cuadrícula menor para el eje X

XHelpGrid (Objeto)
objeto con información detallada sobre la cuadrícula menor para el eje X (admite com.sun.star.chart.ChartGrid
Servicio)
lo mismo para y y z:
HasYAxisGrid (booleano)
activa la cuadrícula principal para el eje Y

YMainGrid (objeto)
objeto con información detallada sobre la cuadrícula principal para el eje Y (admite com.sun.star.chart.ChartGrid
Servicio)
HasYAxisHelpGrid (booleano)
activa la cuadrícula menor para el eje Y

YHelpGrid (objeto)
objeto con información detallada sobre la cuadrícula menor para el eje Y (admite com.sun.star.chart.ChartGrid
Servicio)
135
HasZAxisGrid (booleano)
activa la cuadrícula principal para el eje Z

ZMainGrid (Objeto)
objeto con información detallada sobre la cuadrícula principal para el eje Z (admite com.sun.star.chart.ChartGrid
Servicio)
HasZAxisHelpGrid (booleano)
activa la cuadrícula menor para el eje Z

ZHelpGrid (objeto)
objeto con información detallada sobre la cuadrícula menor para el eje Z (admite com.sun.star.chart.ChartGrid
Servicio)
El objeto de cuadrícula se basa en el servicio com.sun.star.chart.ChartGrid, que a su vez admite las propiedades de línea de
el servicio de asistencia com.sun.star.drawing.LineStyle (consulte Dibujos y presentaciones)
Título de los ejes
Para todos los ejes se puede mostrar un título adicional. El objeto Diagrama proporciona las siguientes propiedades para acceder
el título de los ejes:
HasXAxisTitle (booleano)
activa el título del eje X

XAxisTitle (Objeto)
objeto con información detallada sobre el título del eje X (admite el servicio com.sun.star.chart.ChartTitle)
misma y y z:
HasYAxisTitle (booleano)
activa el título del eje Y

YAxisTitle (Objeto)
objeto con información detallada sobre el título del eje Y (admite el servicio com.sun.star.chart.ChartTitle)
HasZAxisTitle (booleano)
activa el título del eje Z

ZAxisTitle (Objeto)
objeto con información detallada sobre el título del eje Z (admite el servicio com.sun.star.chart.ChartTitle)
y para los ejes secundarios (disponible desde OpenOffice.org 3.0):

HasSecondaryXAxisTitle (booleano)
activa el título del eje X secundario.

SecondXAxisTitle (Objeto)
objeto con información detallada sobre el título del eje X secundario (admite com.sun.star.chart.ChartTitle
Servicio)
HasSecondaryYAxisTitle (booleano)
activa el título del eje Y secundario.

SecondYAxisTitle (Objeto)
objeto con información detallada sobre el título del eje Y secundario (admite com.sun.star.chart.ChartTitle
Servicio)
Los objetos para formatear el título de los ejes se basan en el servicio com.sun.star.chart.ChartTitle, que también se utiliza
para títulos de gráficos.
Page 136
Ejemplo
El siguiente ejemplo crea un gráfico de líneas. El color de la pared posterior del gráfico se establece en blanco. Tanto la X como
Los ejes Y tienen una cuadrícula gris para orientación visual. El valor mínimo del eje Y se fija en 0 y el máximo
El valor se fija en 100 para que la resolución del gráfico se mantenga incluso si se cambian los valores. El eje X
apunta en sentido inverso de derecha a izquierda. Y se agregó un título para el eje X.
Dim Doc como objeto
Doc = ThisComponent
Rect.X = 8000
Rect.Y = 1000
Ancho rect. = 10000
Altura rect. = 7000

Chart.Diagram = Chart.createInstance ("com.sun.star.chart.LineDiagram")
Chart.Diagram.Wall.FillColor = RGB (255, 255, 255)
Chart.Diagram.HasXAxisGrid = True
Chart.Diagram.XMainGrid.LineColor = RGB (192, 192, 192)
Chart.Diagram.HasYAxisGrid = True
Chart.Diagram.YMainGrid.LineColor = RGB (192, 192, 192)
Chart.Diagram.YAxis.Min = 0
Chart.Diagram.YAxis.Max = 100
Chart.Diagram.XAxis.ReverseDirection = true 'necesita OpenOffice.org 2.4 o más reciente

Chart.Diagram.HasXAxisTitle = true
Chart.Diagram.XAxisTitle.String = "Ejemplo de eje X invertido"
Gráficos 3D
La mayoría de los gráficos de OpenOffice.org también se pueden mostrar con gráficos en 3D. Las siguientes propiedades se proporcionan para
Gráficos 3D en el objeto Diagram :
Dim3D (booleano)
activa la pantalla 3D
Profundo (booleano)
las series se organizarán una detrás de la otra en dirección z

RightAngledAxes (booleano)
activa un modo de visualización 3D donde los ejes X e Y forman un ángulo recto dentro de la proyección. (disponible desde
OpenOffice.org 2.3)
D3DScenePerspective (enumeración)
define si los objetos 3D se dibujarán en perspectiva o en proyección paralela (valores según

com.sun.star.drawing.ProjectionMode)
Perspectiva (larga)
Perspectiva de gráficos 3D ([0,100]) (disponible desde OpenOffice.org 2.4.1)

Rotación Horizontal (larga)
Rotación horizontal de gráficos 3D en grados ([-180,180]) (disponible desde OpenOffice.org 2.4.1)

Rotación Vertical (largo)
Rotación vertical de gráficos 3D en grados ([-180,180]) (disponible desde OpenOffice.org 2.4.1)
137
El siguiente ejemplo crea un gráfico de áreas 3D.

Dim Doc como objeto
Doc = ThisComponent
Rect.X = 8000
Rect.Y = 1000
Ancho rect. = 10000
Altura rect. = 7000

Chart.Diagram = Chart.createInstance ("com.sun.star.chart.AreaDiagram")
Chart.Diagram.Dim3D = verdadero
Chart.Diagram.Deep = verdadero
Chart.Diagram.RightAngledAxes = true 'necesita OpenOffice.org 2.3 o más reciente
Chart.Diagram.D3DScenePerspective = com.sun.star.drawing.ProjectionMode.PERSPECTIVE
Chart.Diagram.Perspective = 100 'necesita OpenOffice.org 2.4.1 o más reciente
Chart.Diagram.RotationHorizontal = 60 'necesita OpenOffice.org 2.4.1 o más reciente
Chart.Diagram.RotationVertical = 30 'necesita OpenOffice.org 2.4.1 o más reciente
Gráficos apilados
Los gráficos apilados son gráficos que se organizan con varios valores individuales uno encima del otro para producir un total
valor. Esta vista muestra no solo los valores individuales, sino también un resumen de todos los valores.
En OpenOffice.org, se pueden mostrar varios tipos de gráficos apilados. Todos estos gráficos apoyan la
com.sun.star.chart.StackableDiagram, que a su vez proporciona las siguientes propiedades:
Apilado (booleano)
activa el modo de visualización apilada

Porcentaje (booleano)
en lugar de valores absolutos, muestra su distribución porcentual
Tipos de gráficos
Gráficos lineales
Los gráficos de líneas (com.sun.star.chart.LineDiagram) admiten dos ejes X, dos ejes Y y un eje Z. Ellos pueden ser
se muestra como gráficos 2D o 3D (com.sun.star.chart.Dim3Ddiagramservice). Las líneas se pueden apilar
(com.sun.star.chart.StackableDiagram).
Los gráficos de líneas proporcionan las siguientes propiedades:

SymbolType (const)
símbolo para mostrar los puntos de datos (constante de acuerdo con com.sun.star.chart.ChartSymbolType)
SymbolSize (largo)
tamaño del símbolo para mostrar los puntos de datos en centésimas de milímetro
Página 138
Tipos de gráficos
SymbolBitmapURL (cadena)
nombre de archivo de gráficos para mostrar los puntos de datos

Líneas (booleanas)
vincula los puntos de datos por medio de líneas

SplineType (largo)
función spline para suavizar las líneas (0: sin función spline, 1: splines cúbicos, 2: splines B)
SplineOrder (largo)
peso polinomial para splines (solo para splines B)

SplineResolution (largo)
número de puntos de apoyo para el cálculo de splines
Gráficos de área
Los gráficos de área (servicio com.sun.star.chart.AreaDiagram) admiten dos ejes X, dos ejes Y y un eje Z. Ellos pueden
mostrarse como gráficos 2D o 3D (servicio com.sun.star.chart.Dim3Ddiagram). Las áreas se pueden apilar
Gráfica de barras
Los gráficos de barras (com.sun.star.chart.BarDiagram) admiten dos ejes X, dos ejes Y y un eje Z. Ellos pueden ser
mostrados como gráficos 2D o 3D (servicio com.sun.star.chart.Dim3Ddiagram). Las barras se pueden apilar
Proporcionan las siguientes propiedades:

Vertical (booleano)
muestra las barras verticalmente; de lo contrario, se representan horizontalmente

Profundo (booleano)
en el modo de visualización 3D, coloca las barras una detrás de la otra en lugar de una junto a la otra
StackedBarsConnected (booleano)
vincula las barras asociadas en un gráfico apilado por medio de líneas (solo disponible con gráficos horizontales)
NumberOfLines (largo)
número de líneas que se mostrarán en un gráfico apilado como líneas en lugar de barras
GroupBarsPerAxis (booleano)
muestra barras unidas a diferentes ejes detrás o al lado de la otra (disponible desde OpenOffice.org 2.4)
Gráficos circulares
Los gráficos circulares (com.sun.star.chart.PieDiagram) no contienen ningún eje y no se pueden apilar. Se pueden mostrar
como gráficos 2D o 3D (servicio com.sun.star.chart.Dim3DDiagram).
Las siguientes propiedades se proporcionan para gráficos circulares y de anillos con el objeto Diagrama :
Ángulo de inicio (largo)
ángulo de la primera pieza de un pastel en grados (disponible desde OpenOffice.org 3.0)
Página 139
10
CAPÍTULO 10
10 Bases de datos
OpenOffice.org tiene una interfaz de base de datos integrada (independiente de cualquier sistema) llamada Star Database
Conectividad (SDBC). El objetivo de desarrollar esta interfaz era proporcionar acceso a tantos datos diferentes
fuentes como sea posible.
Para que esto sea posible, los conductores acceden a las fuentes de datos. Las fuentes de las que los conductores obtienen sus datos son
irrelevante para un usuario de SDBC. Algunos controladores acceden a bases de datos basadas en archivos y toman los datos directamente de ellos. Otros
utilice interfaces estándar como JDBC u ODBC. Sin embargo, también hay controladores especiales que acceden a MAPI
libreta de direcciones, directorios LDAP u hojas de cálculo de OpenOffice.org como fuentes de datos.
Dado que los controladores se basan en componentes UNO, se pueden desarrollar otros controladores y, por lo tanto, abrir nuevos datos
fuentes. Encontrará detalles sobre esto en la Guía del desarrollador de OpenOffice.org.
Nota - VBA: en términos de su concepto, SDBC es comparable con las bibliotecas ADO y DAO disponibles en
VBA Permite un acceso de alto nivel a las bases de datos, independientemente de los backends de la base de datos subyacente.
SQL: un lenguaje de consulta

El lenguaje SQL se proporciona como lenguaje de consulta para los usuarios de SDBC. Para comparar las diferencias entre
diferentes dialectos SQL, los componentes SDBC de OpenOffice.org tienen su propio analizador SQL. Esto usa el
ventana de consulta para verificar los comandos SQL escritos y corrige errores de sintaxis simples, como los asociados con
Caracteres en mayúsculas y minúsculas.
Si un controlador permite el acceso a una fuente de datos que no es compatible con SQL, entonces debe convertir el
transfirió comandos SQL al acceso nativo necesario.
Tipos de acceso a la base de datos

La interfaz de la base de datos de OpenOffice.org está disponible en OpenOffice.org Writer y OpenOffice.org Calc
aplicaciones, así como en los formularios de bases de datos.
En OpenOffice.org Writer, se pueden crear letras estándar con la ayuda de fuentes de datos SDBC y estas pueden
luego se imprime. También puede mover datos desde la ventana de la base de datos a documentos de texto usando la función de arrastrar y
función de caída.
Si mueve una tabla de base de datos a una hoja de cálculo, OpenOffice.org crea un área de tabla que se puede actualizar en el
clic del ratón si los datos originales han sido modificados. Por el contrario, los datos de la hoja de cálculo se pueden mover a un
143
140
Tipos de acceso a la base de datos
tabla de base de datos y una importación de base de datos realizada
Finalmente, OpenOffice.org proporciona un mecanismo para formularios basados en bases de datos. Para hacer esto, primero crea un
Formulario estándar de OpenOffice.org Writer o OpenOffice.org Calc y luego vincular los campos a una base de datos.
Todas las opciones especificadas aquí se basan en la interfaz de usuario de OpenOffice.org. Sin conocimientos de programación
es necesario para utilizar las funciones correspondientes.
Esta sección, sin embargo, proporciona poca información sobre las funciones especificadas, pero en cambio se concentra en
interfaz de programación de SDBC, que permite la consulta automatizada de bases de datos y, por lo tanto, permite una gran
mayor variedad de aplicaciones a utilizar.
Sin embargo, se necesita un conocimiento básico de la forma en que funcionan las bases de datos y el lenguaje de consulta SQL para
comprender las siguientes secciones.
Fuentes de datos
Una base de datos se incorpora a OpenOffice.org creando lo que comúnmente se conoce como una fuente de datos. los
La interfaz de usuario proporciona una opción correspondiente para crear fuentes de datos en el menú Extras. También puedes crear
fuentes de datos y trabajar con ellas utilizando OpenOffice.org Basic.
Un objeto de contexto de base de datos que se crea utilizando la función createUnoService sirve como punto de partida para
acceder a una fuente de datos. Esto se basa en el servicio com.sun.star.sdb.DatabaseContext y es el objeto raíz para todos
operaciones de base de datos.
El siguiente ejemplo muestra cómo se puede crear un contexto de base de datos y luego usarlo para determinar los nombres de todos
fuentes de datos disponibles. Muestra los nombres en un cuadro de mensaje.
Atenuar DatabaseContext como objeto
Dim Nombres
Dim I como entero
DatabaseContext = createUnoService ("com.sun.star.sdb.DatabaseContext")
Nombres = DatabaseContext.getElementNames ()
Para I = 0 a UBound (Nombres ())

Nombres de MsgBox (I)
Siguiente yo
Las fuentes de datos individuales se basan en el servicio com.sun.star.sdb.DataSource y se pueden determinar a partir de
el contexto de la base de datos usando el método getByName :
Dim DataSource como objeto

DataSource = DatabaseContext.getByName ("Clientes")
El ejemplo crea un objeto DataSource para una fuente de datos denominada Clientes .
Las fuentes de datos proporcionan una variedad de propiedades, que a su vez brindan información general sobre el origen de los datos.
e información sobre métodos de acceso. Las propiedades son:
Nombre (cadena)
nombre de la fuente de datos

URL (cadena)
URL de la fuente de datos en forma de jdbc: subprotocol: subname o sdbc: subprotocol: subname
Configuración (matriz)
matriz que contiene PropertyValue -pairs con parámetros de conexión (normalmente al menos el nombre de usuario y
contraseña)
141
Fuentes de datos
Usuario (cadena)
nombre de usuario
contraseña de usuario (no se guarda)

IsPasswordRequired (booleano)
la contraseña es necesaria y se solicita de forma interactiva al usuario.

IsReadOnly (booleano)
permite el acceso de solo lectura a la base de datos

NumberFormatsSupplier (Objeto)
objeto que contiene los formatos numéricos disponibles para la base de datos (admite el
interfaz de com.sun.star.util.XNumberFormatsSupplier)
TableFilter (matriz)
lista de nombres de tablas que se mostrarán

TableTypeFilter (matriz)
lista de tipos de tablas que se mostrarán. Los valores disponibles son TABLE , VIEW y SYSTEM TABLE
SuppressVersionColumns (booleano)
suprime la visualización de columnas que se utilizan para la administración de versiones
Nota: las fuentes de datos de OpenOffice.org no son comparables 1: 1 con las fuentes de datos en ODBC.
Mientras que una fuente de datos ODBC solo cubre información sobre el origen de los datos, una fuente de datos en
OpenOffice.org también incluye una variedad de información sobre cómo se muestran los datos dentro de las ventanas de la base de datos.
de OpenOffice.org.
Consultas
Las consultas predefinidas se pueden asignar a una fuente de datos. OpenOffice.org toma nota de los comandos SQL de las consultas para que
están disponibles en todo momento. Las consultas se utilizan para simplificar el trabajo con bases de datos porque se pueden abrir
con un simple clic del mouse y también brinde a los usuarios sin ningún conocimiento de SQL la opción de emitir SQL
comandos.
Un objeto que admite el servicio com.sun.star.sdb.QueryDefinition se oculta detrás de una consulta. Las consultas
se accede mediante el método QueryDefinitions de la fuente de datos.
El siguiente ejemplo enumera los nombres de las consultas de fuentes de datos que se pueden establecer en un cuadro de mensaje.
Dim QueryDefinitions como objeto
Dim QueryDefinition como objeto
Dim I como entero

QueryDefinitions = DataSource.getQueryDefinitions ()
Para I = 0 Para QueryDefinitions.Count () - 1

QueryDefinition = QueryDefinitions (I)
MsgBox QueryDefinition.Name
Siguiente yo
Además de la propiedad Name utilizada en el ejemplo, com.sun.star.sdb.QueryDefinition proporciona un

gama de otras propiedades. Estos son:
Nombre (cadena)
nombre de consulta
Capítulo 10 · Bases de datos 145
Página 142
Fuentes de datos
Comando (cadena)
Comando SQL (normalmente un comando SELECT )
El siguiente ejemplo muestra cómo se puede crear un objeto de consulta de una manera controlada por programa y se puede
asignado a una fuente de datos.
Dim QueryDefinitions como objeto
Dim QueryDefinition como objeto
Dim I como entero

QueryDefinitions = DataSource.getQueryDefinitions ()
QueryDefinition = createUnoService ("com.sun.star.sdb.QueryDefinition")
QueryDefinition.Command = "SELECT * FROM Customer"
QueryDefinitions.insertByName ("NewQuery", QueryDefinition)
El objeto de consulta se crea primero usando la llamada createUnoService , luego se inicializa y luego se inserta en el
Objeto QueryDefinitions mediante insertByName .
Acceso a la base de datos

Se necesita una conexión a la base de datos para acceder a una base de datos. Este es un canal de transferencia que permite
comunicación con la base de datos. A diferencia de las fuentes de datos presentadas en la sección anterior, la base de datos
Por tanto, la conexión debe restablecerse cada vez que se reinicia el programa.
OpenOffice.org proporciona varias formas de establecer conexiones con bases de datos. Este ejemplo muestra cómo conectarse
a una fuente de datos existente.
Dim Connection como objeto
Atenuar InteractionHandler como objeto

Si no es DataSource.IsPasswordRequired, entonces
Conexión = DataSource.GetConnection ("", "")
Más
InteractionHandler = createUnoService ("com.sun.star.sdb.InteractionHandler")
Conexión = DataSource.ConnectWithCompletion (InteractionHandler)
Terminara si
El código utilizado en el ejemplo comprueba primero si la base de datos está protegida con contraseña. Si no, crea el
Se requiere conexión a la base de datos mediante la llamada GetConnection . Las dos cadenas vacías en la línea de comando están
para el nombre de usuario y la contraseña.
Si la base de datos está protegida con contraseña, el ejemplo crea un InteractionHandler y abre la base de datos
conexión mediante el método ConnectWithCompletion . InteractionHandler asegura que OpenOffice.org
solicita al usuario los datos de inicio de sesión necesarios.
Iteración de tablas
Por lo general, se accede a una tabla en OpenOffice.org a través del objeto ResultSet . Un ResultSet es un tipo de marcador
que indica un conjunto actual de datos dentro de un volumen de resultados obtenidos usando el comando SELECT .
Este ejemplo muestra cómo se puede utilizar un ResultSet para consultar valores de una tabla de base de datos.
Dim Connection como objeto
Atenuar InteractionHandler como objeto
Page 143
Declaración Dim como objeto

Dim ResultSet como objeto

Si no es DataSource.IsPasswordRequired, entonces
Conexión = DataSource.GetConnection ("", "")
Más
InteractionHandler = createUnoService ("com.sun.star.sdb.InteractionHandler")
Conexión = DataSource.ConnectWithCompletion (InteractionHandler)
Terminara si
Declaración = Connection.createStatement ()
ResultSet = Statement.executeQuery ("SELECT" "CustomerNumber" "FROM" "Cliente" "")
Si no es IsNull (ResultSet), entonces

Mientras ResultSet.next
MsgBox ResultSet.getString (1)
Encaminarse a
Terminara si
Una vez que se ha establecido la conexión a la base de datos, el código utilizado en el ejemplo utiliza primero el
Connection.createObject para crear un objeto Statement . Este objeto Statement luego usa el
executeQuery para devolver el ResultSet real . El programa ahora comprueba si el ResultSet realmente
existe y atraviesa los registros de datos mediante un bucle. Los valores requeridos (en el ejemplo, los del
CustomerNumber ) devuelve el ResultSet utilizando el método getString , por lo que el parámetro 1
determina que la llamada se relaciona con los valores de la primera columna.
Nota - VBA: el objeto ResultSet de SDBC es comparable con el objeto Recordset de DAO y
ADO, ya que también proporciona acceso iterativo a una base de datos.
Nota - StarOffice 5: Se accede a la base de datos en OpenOffice.org a través de un objeto ResultSet . Esta
refleja el contenido de una tabla o el resultado de un comando SQL-SELECT. En el pasado, el objeto ResultSet
proporcionó los métodos residentes en el objeto Aplicación para la navegación dentro de los datos, por ejemplo,
DataNextRecord ).
Métodos específicos de tipo para recuperar valores
Como puede verse en el ejemplo de la sección anterior, OpenOffice.org proporciona un método getString para
acceder al contenido de la tabla. El método proporciona el resultado en forma de cadena. Los siguientes métodos de obtención son
disponible:
getByte ()
admite los tipos de datos SQL para números, caracteres y cadenas
getShort ()

getInt ()

getLong ()

getFloat ()

getDouble ()

getBoolean ()
Page 144
getString ()
admite todos los tipos de datos SQL

getBytes ()
admite los tipos de datos SQL para valores binarios

obtener la fecha()
admite los tipos de datos SQL para números, cadenas, fecha y hora
consigue tiempo()
getTimestamp ()
getCharacterStream ()
admite los tipos de datos SQL para números, cadenas y valores binarios
getUnicodeStream ()
admite los tipos de datos SQL para números, cadenas y valores binarios
getBinaryStream ()
valores binarios
getObject ()
admite todos los tipos de datos SQL
En todos los casos, el número de columnas debe enumerarse como un parámetro cuyos valores deben consultarse.
Las variantes de ResultSet
El acceso a las bases de datos suele ser una cuestión de velocidad crítica. OpenOffice.org proporciona varias formas de optimizar
ResultSets y controlando así la velocidad de acceso. Cuantas más funciones proporcione un ResultSet , más
Su implementación suele ser compleja y, por tanto, cuanto más lentas son las funciones.
Un ResultSet simple proporciona el alcance mínimo de funciones disponibles. Solo permite aplicar iteración
hacia adelante y para que los valores sean interrogados. Opciones de navegación más amplias, como la posibilidad de modificar
los valores, por lo tanto, no están incluidos.
El objeto Statement utilizado para crear el ResultSet proporciona algunas propiedades que permiten las funciones del
ResultSet para ser influenciado:
ResultSetConcurrency (const)
especificaciones sobre si los datos se pueden modificar (especificaciones de acuerdo con

com.sun.star.sdbc.ResultSetConcurrency).
ResultSetType (const)
especificaciones relativas al tipo de ResultSets (especificaciones de acuerdo con

com.sun.star.sdbc.ResultSetType).
Los valores definidos en com.sun.star.sdbc.ResultSetConcurrency son:

ACTUALIZABLE
ResultSet permite modificar valores

SOLO LECTURA
ResultSet no permite modificaciones
El grupo de constantes com.sun.star.sdbc.ResultSetConcurrency proporciona las siguientes especificaciones:
Page 145
FORWARD_ONLY
ResultSet solo permite la navegación hacia adelante

SCROLL_INSENSITIVE
ResultSet permite cualquier tipo de navegación, los cambios en los datos originales, sin embargo, no se anotan
SCROLL_SENSITIVE
ResultSet permite cualquier tipo de navegación, cambios en los datos originales impactan en ResultSet
Nota - VBA: corresponde un ResultSet que contiene las propiedades READ_ONLY y SCROLL_INSENSITIVE
a un conjunto de registros del tipo Instantánea en ADO y DAO.
Cuando se utilizan las propiedades UPDATEABLE y SCROLL_SENSITIVE de ResultSet , el alcance de la función de un

ResultSet es comparable con un Recordset tipo Dynaset de ADO y DAO.
Métodos de navegación en ResultSets
Si un ResultSet es de tipo SCROLL_INSENSITIVE o SCROLL_SENSITIVE , admite una amplia gama de métodos

para la navegación en el stock de datos. Los métodos centrales son:
siguiente()
navegación al siguiente registro de datos

anterior()
navegación al registro de datos anterior

primero()
navegación al primer registro de datos

último()
navegación al último registro de datos

beforeFirst ()
navegación hasta antes del primer registro de datos

afterLast ()
navegación hasta después del último registro de datos
Todos los métodos devuelven un parámetro booleano que especifica si la navegación se realizó correctamente.
Para determinar la posición actual del cursor, se proporcionan los siguientes métodos de prueba y todos devuelven un valor booleano:
isBeforeFirst ()
ResultSet está antes del primer registro de datos

isAfterLast ()
ResultSet es posterior al último registro de datos

es primero()
ResultSet es el primer registro de datos
isLast ()
ResultSet es el último registro de datos
Modificar registros de datos
Si se ha creado un ResultSet con el valor ResultSetConcurrency = UPDATEABLE , entonces su contenido puede

ser editado. Esto solo se aplica mientras el comando SQL permita que los datos se reescriban en la base de datos
Page 146
(depende del principio). Esto no es posible, por ejemplo, con comandos SQL complejos con columnas enlazadas o
valores acumulados.
El objeto ResultSet proporciona métodos de actualización para modificar valores, que están estructurados de la misma manera que
los métodos de obtención para recuperar valores. El método updateString , por ejemplo, permite escribir una cadena.
Después de la modificación, los valores deben transferirse a la base de datos utilizando el método updateRow () . La llamada
debe tener lugar antes del siguiente comando de navegación, de lo contrario se perderán los valores.
Si se comete un error durante las modificaciones, esto se puede deshacer usando el método cancelRowUpdates () . Esta
La llamada solo está disponible siempre que los datos no se hayan reescrito en la base de datos usando updateRow () .
Page 147
11
CAPÍTULO 11
11 Diálogos
Puede agregar ventanas de diálogo y formularios personalizados a los documentos de OpenOffice.org. Estos a su vez se pueden vincular a
Macros de OpenOffice.org Basic para ampliar considerablemente el rango de uso de OpenOffice.org Basic. Los diálogos pueden, por
ejemplo, mostrar información de la base de datos o guiar a los usuarios a través de un proceso paso a paso para crear un nuevo documento
en forma de mago.
Sugerencia: encontrará otra descripción de los cuadros de diálogo en la Guía del desarrollador:
capítulo OpenOffice.org_Basic_IDE describe con más detalle el IDE
capítulo Los cuadros de diálogo de programación y los controles de cuadro de diálogo muestran más ejemplos en Basic.
Trabajar con cuadros de diálogo

Los cuadros de diálogo básicos de OpenOffice.org constan de una ventana de diálogo que puede contener campos de texto, cuadros de lista, botones de radio y
otros elementos de control.
Crear diálogos
Puede crear y estructurar cuadros de diálogo utilizando el editor de cuadros de diálogo de OpenOffice.org:
Crear y estructurar diálogos en el editor de diálogos
Puede arrastrar los elementos de control de la paleta de diseño (derecha) al área de diálogo y definir su posición y
151
148 de 1189.
Trabajar con cuadros de diálogo
Talla.
El ejemplo muestra un diálogo que contiene una etiqueta y un cuadro de lista.
Un diálogo que contiene una etiqueta y un cuadro de lista.

Puede abrir un cuadro de diálogo con el siguiente código:
Dim Dlg como objeto
DialogLibraries.LoadLibrary ("Estándar")
Dlg = CreateUnoDialog (DialogLibraries.Standard.DlgDef)
Dlg.Execute ()
Dlg.dispose ()
CreateUnoDialog creaun objeto llamado Dlg que hace referencia al diálogo asociado. Antes de poder crear el
cuadro de diálogo, debe asegurarse de que la biblioteca que utiliza (en este ejemplo, la biblioteca estándar ) esté cargada. los
El método LoadLibrary realiza esta tarea.
Una vez que se haya inicializado el objeto de diálogo Dlg , puede utilizar el método Execute para mostrar el diálogo. Cuadros de diálogo
como éste se describen como modales porque no permiten ninguna otra acción del programa hasta que se cierren.
Mientras este diálogo está abierto, el programa permanece en la llamada Ejecutar .
El método de eliminación al final del código libera los recursos utilizados por el diálogo una vez que finaliza el programa.
Diálogos de cierre
Cerrar con Aceptar o Cancelar
Si un cuadro de diálogo contiene un botón Aceptar o Cancelar , el cuadro de diálogo se cierra automáticamente cuando hace clic en uno de estos
botones. Se trata más información sobre cómo trabajar con estos botones enElementos de control de diálogo en detalle.
Si cierra un cuadro de diálogo haciendo clic en el botón Aceptar , el método Ejecutar devuelve un valor de retorno de 1; de lo contrario, un
se devuelve el valor 0.
Dim Dlg como objeto
DialogLibraries.LoadLibrary ("Estándar")
Dlg = CreateUnoDialog (DialogLibraries.Standard.MyDialog)
Seleccione Case Dlg.Execute ()
Caso 1
MsgBox "Aceptar presionado"
Caso 0
MsgBox "Cancelar presionado"
Page 149 Trabajar con cuadros de diálogo
Cerrar con el botón Cerrar en la barra de título
Puede cerrar un cuadro de diálogo haciendo clic en el botón cerrar en la barra de título de la ventana de diálogo. El método Execute de
el diálogo devuelve el valor 0, que es el mismo que cuando hace clic en Cancelar.
Cierre con una llamada de programa explícita
También puede cerrar una ventana de diálogo abierta con el método endExecute :
Dlg.endExecute ()
El método Ejecutar del cuadro de diálogo devuelve el valor 0, que es el mismo que cuando hace clic en Cancelar.
Acceso a elementos de control individuales
Un diálogo puede contener cualquier número de elementos de control. Puede acceder a estos elementos a través de getControl
método que devuelve el elemento de control por nombre.
Dim Ctl como objeto
Ctl = Dlg.getControl ("MyButton")

Ctl.Label = "Nueva etiqueta"
Este código determina el objeto para el elemento de control MyButton y luego inicializa la variable de objeto Ctl
con una referencia al elemento. Finalmente, el código establece la propiedad Label del elemento de control en New
Valor de etiqueta .
Nota: a diferencia de los identificadores básicos de OpenOffice.org, los nombres de los elementos de control distinguen entre mayúsculas y minúsculas.
Trabajar con el modelo de cuadros de diálogo y control

Elementos
Se produce la división entre los elementos visibles del programa ( Ver ) y los datos o documentos detrás de ellos ( Modelo )
en muchos lugares de la API de OpenOffice.org. Además de los métodos y propiedades de los elementos de control, tanto
Los objetos de elemento de diálogo y control tienen un objeto Modelo subordinado . Este objeto le permite acceder directamente al
contenido de un diálogo o elemento de control.
En los diálogos, la distinción entre datos y representación no siempre es tan clara como en otras áreas de API de
OpenOffice.org. Los elementos de la API están disponibles a través de la Vista y el Modelo.
La propiedad Model proporciona acceso controlado por programa al modelo de objetos de elementos de diálogo y control.
Dim cmdSiguiente como objeto
cmdNext = Dlg.getControl ("cmdNext")

cmdNext.Model.Enabled = Falso
Este ejemplo desactiva el botón cmdNext en el diálogo Dlg con la ayuda del objeto modelo de cmdNext .
Propiedades
Nombre y título
Cada elemento de control tiene su propio nombre que se puede consultar utilizando la siguiente propiedad del modelo:
Capítulo 11 · Diálogos 153
Page 150
Propiedades
Model.Name (cadena)
nombre del elemento de control
Puede especificar el título que aparece en la barra de título de un diálogo con la siguiente propiedad de modelo:
Model.Title (Cadena)
título del diálogo (solo se aplica a los diálogos)
Posición y tamaño
Puede consultar el tamaño y la posición de un elemento de control utilizando las siguientes propiedades del objeto de modelo:
Modelo Altura (largo)
altura del elemento de control (en unidades ma)

Modelo.Ancho (largo)
ancho del elemento de control (en unidades ma)

Model.PositionX (largo)
Posición X del elemento de control, medida desde el borde interior izquierdo del diálogo (en unidades ma)
Model.PositionY (largo)
Posición Y del elemento de control, medida desde el borde interior superior del cuadro de diálogo (en unidades ma)
Para garantizar la independencia de la plataforma para la aparición de cuadros de diálogo, OpenOffice.org utiliza Map AppFont (ma)
unidad interna para especificar la posición y el tamaño dentro de los diálogos. Una unidad ma se define como un octavo de la
altura promedio de un carácter de la fuente del sistema definida en el sistema operativo y un cuarto de su ancho.
Al usar unidades ma, OpenOffice.org asegura que un diálogo se vea igual en diferentes sistemas bajo diferentes
ajustes del sistema.
Si desea cambiar el tamaño o la posición de los elementos de control para el tiempo de ejecución, determine el tamaño total del cuadro de diálogo
y ajustar los valores de los elementos de control a las proporciones de las partes correspondientes.
Nota: Map AppFont (ma) reemplaza la unidad Twips para lograr una mejor independencia de la plataforma.
Secuencia de enfoque y tabulador
Puede navegar por los elementos de control en cualquier cuadro de diálogo presionando la tecla Tab. Las siguientes propiedades son
disponible en este contexto en el modelo de elementos de control:
Model.Enabled (booleano)
activa el elemento de control

Model.Tabstop (booleano)
permite acceder al elemento de control mediante la tecla Tab

Model.TabIndex (largo)
posición del elemento de control en el orden de activación
Finalmente, el elemento de control proporciona un método getFocus que asegura que el elemento de control subyacente
recibe el foco:
getFocus
el elemento de control recibe el foco (solo para diálogos)
Page 151
Propiedades
Diálogos de varias páginas
Un diálogo en OpenOffice.org puede tener más de una pestaña. La propiedad Step de un cuadro de diálogo define la
pestaña del cuadro de diálogo, mientras que la propiedad Step para un elemento de control especifica la página de pestaña donde el control
se mostrará el elemento.
El valor de paso de 0 es
independientemente de un
su caso
valorespecial. Si establece
de paso . Del este valor
mismo modo, en cero este
si establece en unvalor
diálogo, todos
en cero losunelementos
para elementode
decontrol
control,son visibles es
el elemento
se muestra en todas las páginas de pestañas en un cuadro de diálogo.
Diseño de la página 1 del diálogo
En el ejemplo anterior, también puede asignar el valor de Paso de 0 a la línea divisoria, así como Cancelar ,
Botones Anterior , Siguiente y Listo para mostrar estos elementos en todas las páginas. También puede asignar los elementos a un
página de pestaña individual (por ejemplo, página 1).
El siguiente código de programa muestra cómo se puede modificar el valor de Paso en los controladores de eventos de los botones Siguiente y Anterior.
aumentado o reducido y cambia el estado de los botones.
Sub cmdNext_Initiate

Dim cmdPrev como objeto
cmdPrev = Dlg.getControl ("cmdPrev")

cmdPrev.Model.Enabled = No cmdPrev.Model.Enabled
cmdNext.Model.Enabled = Falso
Dlg.Model.Step = Dlg.Model.Step + 1
End Sub
Sub cmdPrev_Initiate

Dim cmdPrev como objeto
cmdPrev = Dlg.getControl ("cmdPrev")

cmdPrev.Model.Enabled = Falso
cmdNext.Model.Enabled = True
Dlg.Model.Step = Dlg.Model.Step - 1
End Sub
Se debe incluir una variable Dlg global que haga referencia a un diálogo abierto para que este ejemplo sea posible. El dialogo
luego cambia su apariencia de la siguiente manera:
Página 152
Propiedades
Página 1
Página 2
Sugerencia: puede encontrar unotro ejemplo de OOoBasic aquí.
Diálogos que admiten varios idiomas
Las cadenas de un diálogo se pueden localizar, consulte el capítulo de la Guía del desarrollador Localización de diálogo.
Eventos
Los diálogos y formularios de OpenOffice.org se basan en un modelo de programación orientado a eventos en el que puede asignar
controladores de eventos a los elementos de control. Un controlador de eventos ejecuta un procedimiento predefinido cuando una acción particular
ocurre. También puede editar documentos o abrir bases de datos con manejo de eventos, así como acceder a otros controles
elementos.
Los elementos de control de OpenOffice.org reconocen diferentes tipos de eventos que pueden desencadenarse en diferentes situaciones.
Estos tipos de eventos se pueden dividir en cuatro grupos:
Control del mouse : eventos que corresponden a acciones del mouse (por ejemplo, movimientos simples del mouse o un clic
en una ubicación de pantalla en particular).
Control de teclado : eventos que se activan mediante golpes de teclado.
Modificación de foco : eventos que realiza OpenOffice.org cuando los elementos de control están activados o
desactivado
Página 153
Eventos
Eventos específicos de elementos de control : eventos que solo ocurren en relación con ciertos elementos de control.
Cuando trabaje con eventos, asegúrese de crear el cuadro de diálogo asociado en el desarrollo de OpenOffice.org
entorno y que contiene los elementos de control o documentos necesarios (si aplica los eventos a un formulario).
El entorno de desarrollo básico de OpenOffice.org
La figura anterior muestra el entorno de desarrollo básico de OpenOffice.org con una ventana de diálogo que contiene
dos cuadros de lista. Puede mover los datos de una lista a otra usando los botones entre los dos cuadros de lista.
Si desea mostrar el diseño en pantalla, debe crear el OpenOffice.org Basic asociado

procedimientos para que los controladores de eventos puedan llamarlos. Aunque puede utilizar estos procedimientos en cualquier
módulo, es mejor limitar su uso a dos módulos. Para que su código sea más fácil de leer, debe asignar
nombres significativos para estos procedimientos. Saltar directamente a un procedimiento de programa general desde una macro puede resultar
en código poco claro. En cambio, para simplificar el mantenimiento del código y la resolución de problemas, debe crear otro procedimiento
para servir como un punto de entrada para el manejo de eventos, incluso si solo ejecuta una única llamada al procedimiento de destino.
El código del siguiente ejemplo mueve una entrada del cuadro de lista de izquierda a derecha de un cuadro de diálogo.
Sub cmdSelect_Initiate
Dim lstEntries como objeto

Dim lstSelection como objeto
lstEntries = Dlg.getControl ("lstEntries")

lstSelection = Dlg.getControl ("lstSelection")
Si lstEntries.SelectedItem> 0 entonces
lstSelection.AddItem (lstEntries.SelectedItem, 0)
lstEntries.removeItems (lstEntries.SelectItemPos, 1)
Más
Bip
Terminara si
End Sub
Si este procedimiento fue creado en OpenOffice.org Basic, puede asignarlo a un evento requerido usando la propiedad
ventana del editor de diálogo.
El cuadro de diálogo Asignar acción
Page 154
Eventos
El cuadro de diálogo Asignar acción enumera todos los eventos disponibles. Para asignar una macro a un evento:
1. Seleccione el evento
2. Haga clic en Macro ...
3. Busque y seleccione la macro que desea asignar
4. Haga clic en Aceptar.
Parámetros
La ocurrencia de un evento en particular no siempre es suficiente para una respuesta adecuada. Información Adicional
puede ser requerido. Por ejemplo, para procesar un clic del mouse, es posible que necesite la posición de la pantalla donde el mouse
se presionó el botón.
En OpenOffice.org Basic, puede utilizar parámetros de objeto para proporcionar más información sobre un evento a un
procedimiento, por ejemplo:
Sub ProcessEvent (evento como objeto)
End Sub
La estructura y las propiedades del objeto Event dependen del tipo de evento que desencadena la llamada al procedimiento.
Independientemente del tipo de evento, todos los objetos proporcionan acceso al elemento de control relevante y su modelo. los
Se puede acceder al elemento de control usando Event.Source y su modelo usando Event.Source.Model .
Puede utilizar estas propiedades para desencadenar un evento dentro de un controlador de eventos.
Eventos de mouse
OpenOffice.org Basic reconoce los siguientes eventos del mouse:

Ratón movido
el usuario mueve el mouse

El mouse se movió mientras se presionaba la tecla
el usuario arrastra el mouse mientras mantiene presionada una tecla

Botón del mouse presionado
el usuario presiona un botón del mouse
Nota: este evento también se utiliza para notificar solicitudes de un menú contextual emergente en el control. En este caso, el
miembro PopupTrigger del evento pasado a su función macro será VERDADERO . En particular, si tal solicitud
se realiza presionando el botón derecho del mouse en el control, el evento se disparará dos veces: una vez para el menú emergente
request, y una vez para el evento real del mouse. Si solo le interesa el clic del mouse, su macro debe
ignore todas las llamadas donde PopupTrigger sea TRUE .
Botón del mouse liberado
el usuario suelta un botón del mouse

Ratón afuera
el usuario mueve el mouse fuera de la ventana actual
La estructura de los objetos de evento asociados se define en la estructura com.sun.star.awt.MouseEvent que

proporciona la siguiente información:
155 de 1189.
Eventos
Botones (cortos)
botón presionado (una o más constantes de acuerdo con com.sun.star.awt.MouseButton)

X (largo)
Coordenada X del mouse, medida en píxeles desde la esquina superior izquierda del elemento de control
Y (largo)
Coordenada Y del mouse, medida en píxeles desde la esquina superior izquierda del elemento de control
ClickCount (largo)
número de clics asociados con el evento del mouse (si OpenOffice.org puede responder lo suficientemente rápido,
ClickCount tambiénes 1 para un doble clic porque solo se inicia un evento individual)
Las constantes definidas en com.sun.star.awt.MouseButton para los botones del mouse son:
IZQUIERDA
boton izquierdo del raton

DERECHA
Botón derecho del mouse

MEDIO
botón central del ratón
El siguiente ejemplo muestra la posición del mouse y el botón del mouse que se presionó:
Sub MouseUp (evento como objeto)
Dim Msg como cadena
Msg = "Claves:"
Si Event.Buttons AND com.sun.star.awt.MouseButton.LEFT Entonces
Msg = Msg & "IZQUIERDA"
Terminara si
Si Event.Buttons AND com.sun.star.awt.MouseButton.RIGHT Entonces

Msg = Msg & "DERECHA"
Terminara si
Si Event.Buttons AND com.sun.star.awt.MouseButton.MIDDLE Entonces

Msg = Msj & "MIDDLE"
Terminara si
Msg = Msg & Chr (13) y "Posición:"

Msg = Msg & Event.X & "/" & Event.Y
MsgBox Msg
End Sub
Nota - VBA: los eventos VBA Click y Doubleclick no están disponibles en OpenOffice.org Basic. En lugar
use el evento OpenOffice.org Basic MouseUp para el evento click e imite el evento Doubleclick al
cambiar la lógica de la aplicación.
Eventos de teclado
Los siguientes eventos de teclado están disponibles en OpenOffice.org Basic:

Tecla presionada
el usuario presiona una tecla.

Clave liberada
el usuario suelta una tecla
Ambos eventos se relacionan con acciones lógicas clave y no con acciones físicas. Si el usuario presiona varias teclas para generar un
carácter único (por ejemplo, para añadir un acento a un carácter), OpenOffice.org Basic solo crea un evento.
Page 156
Eventos
Una sola acción de tecla en una tecla de modificación, como la tecla Mayús o la tecla Alt, no crea una
evento.
La información sobre una tecla presionada la proporciona el objeto de evento que OpenOffice.org Basic proporciona al
procedimiento para el manejo de eventos. Contiene las siguientes propiedades:
KeyCode (corto)
código de la tecla presionada (valores predeterminados de acuerdo con com.sun.star.awt.Key)

KeyChar (cadena)
carácter que se ingresa (teniendo en cuenta las claves de modificación)
El siguiente ejemplo usa la propiedad KeyCode para establecer si la tecla Enter, la tecla Tab o una de las otras
se ha pulsado las teclas de control. Si se ha pulsado una de estas teclas, se devuelve el nombre de la tecla; de lo contrario
se devuelve el carácter que se escribió:
Sub KeyPressed (evento como objeto)
Dim Msg como cadena
Seleccionar evento de caso.KeyCode

Caso com.sun.star.awt.Key.RETURN
Msg = "Retorno presionado"
Caso com.sun.star.awt.Key.TAB
Msg = "Tab presionado"
Caso com.sun.star.awt.Key.DELETE
Msg = "Eliminar presionado"
Caso com.sun.star.awt.Key.ESCAPE
Msg = "Escape presionado"
Caso com.sun.star.awt.Key.DOWN
Msg = "Presionado hacia abajo"
Caso com.sun.star.awt.Key.UP
Msg = "Arriba presionado"
Caso com.sun.star.awt.Key.LEFT
Msg = "Izquierda presionada"
Caso com.sun.star.awt.Key.RIGHT
Msg = "Presionado derecho"
Caso diferente
Msg = "Personaje" & Event.KeyChar & "ingresado"
MsgBox Msg
End Sub
Se puede encontrar información sobre otras constantes de teclado en la Referencia de API bajo com.sun.star.awt.Key
grupo de constantes.
Eventos de enfoque
Los eventos de enfoque indican si un elemento de control recibe o pierde el enfoque. Puede utilizar estos eventos para, por ejemplo,
determinar si un usuario ha terminado de procesar un elemento de control para que pueda actualizar otros elementos de un diálogo.
Los siguientes eventos de enfoque están disponibles:
Al recibir el enfoque
elemento recibe foco

Al perder el enfoque
el elemento pierde el foco
Los objetos de evento para los eventos de enfoque se estructuran de la siguiente manera:
FocusFlags (corto)
causa del cambio de enfoque (valor predeterminado de acuerdo con com.sun.star.awt.FocusChangeReason)

NextFocus (objeto)
objeto que recibe el enfoque (solo para el evento Al perder el enfoque )
Page 157
Eventos
Temporal (booleano)
el enfoque se pierde temporalmente
Eventos específicos de elementos de control
Además de los eventos anteriores, que son compatibles con todos los elementos de control, también hay algunos controles
Eventos específicos de elementos que solo se definen para ciertos elementos de control. Los más importantes de estos eventos son:
Cuando se cambió el artículo
el valor de un elemento de control cambia

Estado del artículo cambiado
el estado de un elemento de control cambia

Texto modificado
el texto de un elemento de control cambia

Al iniciar
una acción que se puede realizar cuando se activa el elemento de control (por ejemplo, se presiona un botón)
Cuando trabaje con eventos, tenga en cuenta que algunos eventos, como el evento Al iniciar , se pueden iniciar cada
vez que hace clic con el mouse en algunos elementos de control (por ejemplo, en botones de opción). No se realiza ninguna acción para
compruebe si el estado del elemento de control ha cambiado realmente. Para evitar estos "eventos ciegos", guarde el control anterior
valor del elemento en una variable global, y luego verifique si el valor ha cambiado cuando se está ejecutando un evento.
El evento Al iniciar también es digno de mención por las siguientes razones:

Este evento se inicia al presionar una tecla o un botón del mouse. Por lo tanto, proporciona una interfaz consistente para
usuarios que navegan con el mouse o con el teclado.
Cuando la propiedad Repetir de un botón de comando se establece en Verdadero , este evento es el que se repite repetidamente.
enviado, siempre que la acción de activación (tecla hacia abajo o botón del mouse hacia abajo) permanezca en efecto.
Las propiedades del evento Estado del artículo cambiado son:

Seleccionado (largo)
entrada seleccionada actualmente

Resaltado (largo)
entrada resaltada actualmente
ItemId (largo)
ID de entrada
Elementos de control de diálogo

OpenOffice.org Basic reconoce una gama de elementos de control que se pueden dividir en los siguientes grupos:
Campos de entrada Botones Selección Otro

liza
Campos de texto Botones estándar Cuadros de lista Barras de desplazamiento (horizontal y vertical)
Campos de fecha Casillas de verificación Cajas combinadas Campos de grupos
Campos de tiempo Botones de radio Control del árbol Barras de progreso
Campos numéricos Líneas divisorias (horizontal y vertical)
Campos de moneda Gráficos
Adopción de campos Campos de selección de archivos
cualquier formato
Page 158
Botones
Un botón realiza una acción cuando hace clic en él.
El escenario más simple es que el botón active un evento Al iniciar cuando un usuario hace clic en él. Usted puede
también vincule otra acción al botón para cerrar un diálogo usando la propiedad PushButtonType . Cuando haces clic en un
botón que tiene esta propiedad establecida en el valor de 0, el cuadro de diálogo no se ve afectado. Si hace clic en un botón que tiene este
propiedad establecida en el valor de 1, el diálogo se cierra y el método Execute del diálogo devuelve el valor 1
(la secuencia de diálogo ha finalizado correctamente). Si PushButtonType tiene el valor 2, el diálogo se cierra y
el método Ejecutar del diálogo devuelve el valor 0 (diálogo cerrado). En el Editor de diálogo, los valores de propiedad
se muestran simbólicamente, como Predeterminado (0), Correcto (1) y Cancelar (2).
Las siguientes son algunas de las propiedades que están disponibles a través del modelo de botón:
Model.BackgroundColor (largo)
color de fondo
Model.DefaultButton (booleano)
El botón se utiliza como valor predeterminado y responde a la tecla Enter si no tiene foco
Model.FontDescriptor (estructura)
estructura que especifica los detalles de la fuente que se utilizará (de acuerdo con
estructura com.sun.star.awt.FontDescriptor)
Model.Label (Cadena)
etiqueta que se muestra en el botón

Modelo imprimible (booleano)
el elemento de control se puede imprimir

Model.TextColor (largo)
color del texto del elemento de control

Model.HelpText (Cadena)
texto de ayuda que se muestra cuando mueve el cursor del mouse sobre el elemento de control
Model.HelpURL (cadena)
URL de la ayuda en línea para el elemento de control correspondiente

PushButtonType (corto)
acción vinculada al botón (0: sin acción, 1: Aceptar, 2: Cancelar)
Botones de opción
Estos botones se utilizan generalmente en grupos y le permiten seleccionar entre varias opciones. Cuando seleccionas
una opción, todas las demás opciones del grupo están desactivadas. Esto asegura que en cualquier momento, solo una opción
el botón está configurado.
Un elemento de control de botón de opción proporciona dos propiedades:

Estado (booleano)
activa el botón
Etiqueta (cadena)
etiqueta que se muestra en el botón
También puede utilizar las siguientes propiedades del modelo de los botones de opción:
estructura con detalles de la fuente que se utilizará (de acuerdo con com.sun.star.awt.FontDescriptor)
Page 159
etiqueta que se muestra en el elemento de control


Model.State (corto)
si esta propiedad es igual a 1 se activa la opción, en caso contrario se desactiva


texto de ayuda que se muestra cuando el cursor del mouse descansa sobre el elemento de control
URL de ayuda en línea para el elemento de control correspondiente
Para combinar varios botones de opción en un grupo, debe colocarlos uno tras otro en la activación
secuencia sin espacios ( propiedad Model.TabIndex , descrita como Orden en el editor de diálogo). Si la activación
la secuencia es interrumpida por otro elemento de control, entonces OpenOffice.org se inicia automáticamente con un nuevo control
grupo de elementos que se puede activar independientemente del primer grupo de elementos de control.
Nota - VBA: a diferencia de VBA, no puede insertar botones de opción en un grupo de elementos de control en OpenOffice.org
Básico. La agrupación de elementos de control en OpenOffice.org Basic solo se utiliza para asegurar una división visual por
dibujar un marco alrededor de los elementos de control.
Casillas de verificación
Las casillas de verificación se utilizan para registrar un valor Sí o No y, según el modo, pueden adoptar dos o tres estados.
Además de los estados Sí y No, una casilla de verificación puede tener un estado intermedio si el Sí o No correspondiente
estado tiene más de un significado o no está claro.
Las casillas de verificación proporcionan las siguientes propiedades:

Estado (corto)
estado de la casilla de verificación (0: no, 1: sí, 2: estado intermedio)

Etiqueta (cadena)
etiqueta para el elemento de control

enableTriState (booleano)
además de los estados activado y desactivado, también puede utilizar el estado intermedio
El objeto modelo de una casilla de verificación proporciona las siguientes propiedades:

estructura con detalles de la fuente utilizada (de acuerdo con la estructura com.sun.star.awt.FontDescriptor)
etiqueta para el elemento de control


Model.State (corto)
estado de la casilla de verificación (0: no, 1: sí, 2: estado intermedio)

el elemento de control se puede alcanzar con la tecla Tab
160 de 1189.

texto de ayuda que se muestra cuando coloca el cursor del mouse sobre el elemento de control
Campos de texto
Los campos de texto permiten a los usuarios escribir números y texto. El archivo com.sun.star.awt.UnoControlEdit. el servicio forma la base
para campos de texto.
Un campo de texto puede contener una o más líneas y se puede editar o bloquear para las entradas del usuario. Los campos de texto también pueden ser
utilizado como moneda especial y campos numéricos, así como campos de pantalla para tareas especiales. Como estos elementos de control
se basan en el servicio UnoControlEdit Uno, su manejo controlado por programa es similar.
Los campos de texto proporcionan las siguientes propiedades:

Texto (cadena)
texto actual
SelectedText (cadena)
texto resaltado actualmente

Selección (estructura)
Resaltado de detalles de solo lectura (estructura de acuerdo con com.sun.star.awt.Selection, con Min y
Número máximo de propiedades para especificar el inicio y el final del resaltado actual)
MaxTextLen (corto)
número máximo de caracteres que puede escribir en el campo

Editable (booleano)
Verdadero activa la opción para ingresar texto, Falso bloquea la opción de ingreso (la propiedad no se puede llamar
directamente pero solo a través de IsEditable )
IsEditable (booleano)
el contenido del elemento de control se puede cambiar, solo lectura
Las siguientes propiedades se proporcionan a través del objeto de modelo asociado:

Model.Align (corto)
orientación del texto (0: alineado a la izquierda, 1: centrado, 2: alineado a la derecha)

color del fondo del elemento de control

Modelo Borde (corto)
tipo de borde (0: sin borde, 1: borde 3D, 2: borde simple)

Model.EchoChar (Cadena)
carácter de eco para campos de contraseña
Model.HardLineBreaks (booleano)
los saltos de línea automáticos se insertan permanentemente en el texto del elemento de control
Página 161
Model.HScroll (booleano)
el texto tiene una barra de desplazamiento horizontal

Model.MaxTextLen (corto)
longitud máxima del texto, donde 0 corresponde a ningún límite de longitud

Model.MultiLine (booleano)
permite la entrada a varios tramos


Model.ReadOnly (booleano)
el contenido del elemento de control es de solo lectura


Model.Text (Cadena)
texto asociado con el elemento de control


Model.VScroll (booleano)
el texto tiene una barra de desplazamiento vertical

texto de ayuda que se muestra cuando el cursor del mouse descansa sobre el elemento de control
Cuadros de lista
Los cuadros de lista (servicio com.sun.star.awt.UnoControlListBox) admiten las siguientes propiedades:

ItemCount (corto)
número de elementos, solo lectura

SelectedItem (cadena)
texto de la entrada resaltada, solo lectura

SelectedItems (matriz de cadenas)
campo de datos con entradas resaltadas, solo lectura

SelectedItemPos (corto)
número de la entrada resaltada actualmente, solo lectura

SelectedItemsPos (matriz de corto)
campo de datos con el número de entradas resaltadas (para listas que admiten selección múltiple), solo lectura
MultipleMode (booleano)
Verdadero activa la opción de selección múltiple de entradas, Falso bloquea selecciones múltiples (la propiedad
no se puede llamar directamente sino solo a través de IsMultipleMode )
IsMultipleMode (booleano)
permite selección múltiple dentro de listas, solo lectura
Los cuadros de lista proporcionan los siguientes métodos:
Page 162
addItem (artículo, pos)
ingresa la cadena especificada en el artículo en la lista en la posición Pos

addItems (ItemArray, Pos)
ingresa las entradas enumeradas en el campo de datos ItemArray de la cadena en la lista en la posición Pos
removeItems (Pos, Count)
elimina las entradas de conteo a partir de la posición Pos

selectItem (Item, SelectMode)
activa o desactiva el resaltado para el elemento especificado en la cadena Item dependiendo de la

Variable booleana SelectMode
makeVisible (Pos)
se desplaza por el campo de la lista para que la entrada especificada con Pos sea visible
El objeto de modelo de los cuadros de lista proporciona las siguientes propiedades:

color de fondo del elemento de control

Modelo Borde (corto)

Model.LineCount (corto)
número de líneas en el elemento de control

Model.MultiSelection (booleano)
permite una selección múltiple de entradas

Model.SelectedItems (matriz de cadenas)
lista de entradas resaltadas

Model.StringItemList (matriz de cadenas)
lista de todas las entradas


Model.ReadOnly (booleano)



texto de ayuda mostrado automáticamente que se muestra si el cursor del mouse está sobre el elemento de control
Nota - VBA: La opción VBA para emitir entradas de lista con un valor numérico adicional ( ItemData ) no
existen en OpenOffice.org Basic. Si desea administrar un valor numérico (por ejemplo, un ID de base de datos) además
al texto en lenguaje natural, debe crear un campo de datos auxiliares que se administre en paralelo al cuadro de lista.
Page 163
12
CAPÍTULO 1 2
12 Formularios
En muchos aspectos, la estructura de los formularios de OpenOffice.org corresponde a los diálogos. Sin embargo, hay algunos
diferencias clave:
Los cuadros de diálogo aparecen en forma de una única ventana de diálogo, que se muestra sobre el documento y no
permitir cualquier acción que no sea el procesamiento del diálogo hasta que finalice el diálogo. Las formas, por otro lado, son
se muestra directamente en el documento, al igual que los elementos de dibujo.
Se proporciona un editor de cuadros de diálogo para crear cuadros de diálogo, que se puede encontrar en OpenOffice.org Basic.
entorno de desarrollo. Los formularios se crean usando los controles de formulario y la barra de herramientas de diseño de formulario directamente
dentro del documento.
Mientras que las funciones de diálogo están disponibles en todos los documentos de OpenOffice.org, el alcance completo del formulario
Las funciones solo están disponibles en texto y hojas de cálculo.
Los elementos de control de un formulario se pueden vincular con una tabla de base de datos externa. Esta función no está disponible en
diálogos
Los elementos de control de los diálogos y las formas se diferencian en varios aspectos.
Los usuarios que deseen proporcionar sus formularios con sus propios métodos para el manejo de eventos, deben consultar la Diálogos
capítulo. Los mecanismos allí explicados son idénticos a los de los formularios.
Trabajando con formularios

Los formularios de OpenOffice.org pueden contener campos de texto, cuadros de lista, botones de radio y una variedad de otros elementos de control,
que se insertan directamente en un texto o una hoja de cálculo. La barra de herramientas de funciones de formulario se utiliza para editar formularios.
Un formulario de OpenOffice.org puede adoptar uno de dos modos: el modo borrador y el modo de visualización. En modo borrador, el
La posición de los elementos de control se puede cambiar y sus propiedades se pueden editar usando una ventana de propiedades.
La barra de herramientas de funciones de formulario también se utiliza para cambiar entre modos.
Determinación de formas de objeto
OpenOffice.org coloca los elementos de control de un formulario a nivel de objeto de dibujo. La forma del objeto real puede ser
se accede a través de la lista de formularios en el nivel de dibujo. Se accede a los objetos de la siguiente manera en documentos de texto:
Dim Doc como objeto
Atenuar DrawPage como objeto
Atenuar forma como objeto
Doc = ThisComponent
DrawPage = Doc.DrawPage
Formulario = DrawPage.Forms.GetByIndex (0)
167
Page 164
El método GetByIndex devuelve el formulario con el número de índice 0.
Cuando se trabaja con hojas de cálculo, se necesita una etapa intermedia para la lista de Hojas porque los niveles de dibujo son
no ubicado directamente en el documento sino en las hojas individuales:
Dim Doc como objeto
Atenuar DrawPage como objeto
Doc = ThisComponent
Hoja = Doc.Sheets.GetByIndex (0)
DrawPage = Sheet.DrawPage
Formulario = DrawPage.Forms.GetByIndex (0)
Como ya sugiere el nombre del método GetByIndex , un documento puede contener varios formularios. Esto es útil,
por ejemplo, si el contenido de diferentes bases de datos se muestra dentro de un documento, o si una base de datos 1: n
La relación se muestra dentro de un formulario. También se proporciona la opción de crear subformularios para este propósito.
Los tres aspectos de la forma de un elemento de control
Un elemento de control de un formulario tiene tres aspectos:

El modelo del elemento de control es el objeto clave para el programador básico de OpenOffice.org cuando trabaja
con formas de elementos de control.
La contraparte de esto es la Vista del elemento de control, que administra la información de la pantalla.
Dado que los formularios de elementos de control dentro de los documentos se administran como un elemento de dibujo especial,
también un objeto Shape que refleja las propiedades específicas del elemento de dibujo del elemento de control (en
en particular su posición y tamaño).
Acceder al modelo de formularios de elementos de control
Los modelos de los elementos de control de un formulario están disponibles a través del método GetByName del formulario Object:
Dim Doc como objeto
Dim Ctl como objeto
Doc = ThisComponent
Form = Doc.DrawPage.Forms.GetByIndex (0)
Ctl = Form.getByName ("MyListBox")
El ejemplo determina el modelo del elemento de control MyListBox , que se encuentra en la primera forma del
documento de texto actualmente abierto.
Si no está seguro de la forma de un elemento de control, puede utilizar la opción para buscar en todos los formularios
el elemento de control requerido:
Dim Doc como objeto
Dim Ctl como objeto
Dim I como entero
Doc = ThisComponent
Forms = Doc.Drawpage.Forms
Para I = 0 a Forms.Count - 1
Formulario = Forms.GetbyIndex (I)
Si Form.HasByName ("MyListBox") Entonces
Ctl = Form.GetbyName ("MyListBox")
Función de salida
Terminara si
Siguiente yo
El ejemplo usa el método HasByName para verificar todas las formas de un documento de texto para determinar si
contienen un modelo de elemento de control llamado MyListBox . Si se encuentra un modelo correspondiente, entonces una referencia a esto es
guardado en la variable Ctl y la búsqueda finaliza.
Page 165
Acceso a la vista de formularios de elementos de control
Para acceder a la vista de un formulario de elemento de control, necesita el modelo asociado. La vista del elemento de control
luego se puede determinar con la ayuda del modelo y utilizando el controlador de documentos.
Dim Doc como objeto
Dim DocCrl como objeto
Dim Ctl como objeto
Dim CtlView como objeto
Dim I como entero
Doc = ThisComponent
DocCrl = Doc.getCurrentController ()
Si Form.HasByName ("MyListBox") Entonces
Ctl = Form.GetbyName ("MyListBox")
CtlView = DocCrl.GetControl (Ctl)
Función de salida
Terminara si
Siguiente yo
El código enumerado en el ejemplo es muy similar al código enumerado en el ejemplo anterior para determinar un control
modelo de elemento. Utiliza no solo el objeto de documento Doc sino también el objeto controlador de documento DocCrl que
hace referencia a la ventana del documento actual. Con la ayuda de este objeto controlador y el modelo del
elemento de control, luego usa el método GetControl para determinar la vista ( variable CtlView ) del control
forma del elemento.
Acceder al objeto Forma de las formas del elemento de control
El método para acceder a los objetos de forma de un elemento de control también utiliza el nivel de dibujo correspondiente del
documento. Para determinar un elemento de control especial, se deben buscar todos los elementos de dibujo del nivel de dibujo
mediante.
Dim Doc como objeto
Dim I como entero
Doc = ThisComponent
Para i = 0 a Doc.DrawPage.Count - 1
Forma = Doc.DrawPage (i)
Si HasUnoInterfaces (Shape, "com.sun.star.drawing.XControlShape") Entonces
Si Shape.Control.Name = "MyListBox", entonces
Función de salida
Terminara si
Terminara si
próximo
El ejemplo comprueba todos los elementos del dibujo para determinar si son compatibles con
La interfaz com.sun.star.drawing.XControlShape necesaria para las formas de los elementos de control. Si este es el caso, el
La propiedad Control.Name luego verifica si el nombre del elemento de control es MyListBox . Si esto es cierto, el
La función finaliza la búsqueda.
Determinación del tamaño y la posición de los elementos de control
Como ya se mencionó, el tamaño y la posición de los elementos de control se pueden determinar usando la forma asociada
objeto. La forma del elemento de control, como todos los demás objetos de forma , proporciona las propiedades Tamaño y Posición para
este propósito:
Tamaño (estructura)
tamaño del elemento de control (estructura de datos com.sun.star.awt.Size)
Capítulo 12 · Formularios 169
Page 166
Posición (estructura)
posición del elemento de control (estructura de datos com.sun.star.awt.Point)
El siguiente ejemplo muestra cómo se puede establecer la posición y el tamaño de un elemento de control utilizando el
objeto de forma:
'... Inicializar objeto Shape, como se mostró anteriormente ...
Punto.x = 1000
Punto.y = 1000
Shape.Size = Tamaño
Shape.Position = Punto
El objeto de forma del elemento de control ya debe conocerse para que el código funcione. Si este no es el caso,
debe determinarse utilizando el código anterior.
Formularios de elementos de control

Los elementos de control disponibles en formularios son similares a los de los diálogos. La selección va desde texto simple
campos a través de listas y cuadros combinados a varios botones.
A continuación, encontrará una lista de las propiedades más importantes para las formas de los elementos de control. Todas las propiedades forman parte de
los objetos de modelo asociados.
Además de los elementos de control estándar, también está disponible un elemento de control de mesa para formularios, que permite
incorporación completa de tablas de la base de datos. Esto se describe en elCapítulo de Formularios de base de datos .
Botones
El objeto de modelo de un botón de formulario proporciona las siguientes propiedades:

BackgroundColor (largo)
color de fondo
DefaultButton (booleano)
el botón sirve como valor predeterminado. En este caso, también responde al botón de entrada si no tiene foco
Habilitado (booleano)
el elemento de control se puede activar

Tabstop (booleano)
se puede acceder al elemento de control a través del botón tabulador

TabIndex (largo)
posición del elemento de control en secuencia de activación

FontName (cadena)
nombre del tipo de fuente

FontHeight (Single)
altura del carácter en puntos (pt)
Page 167
Etiqueta (cadena)
cadena que contiene información adicional, que se puede guardar en el botón para acceso controlado por programa
TargetURL (cadena)
URL de destino para botones del tipo de URL

TargetFrame (cadena)
nombre de la ventana (o marco) en la que TargetURL se abrirá al activar el botón (para botones
del tipo de URL )
Etiqueta (cadena)
etiqueta de botón
TextColor (largo)

HelpText (cadena)
texto de ayuda mostrado automáticamente que se muestra si el cursor del mouse está sobre el elemento de control
HelpURL (cadena)

ButtonType (enumeración)
acción que está vinculada con el botón (valor predeterminado de com.sun.star.form.FormButtonType)

Estado (corto)
en botón de alternancia, 1 = pulsado, 0 = normal
A través de la propiedad ButtonType , tiene la oportunidad de definir una acción que se realiza automáticamente
cuando se presiona el botón. El grupo de constantes com.sun.star.form.FormButtonType asociado proporciona el
siguientes valores:
EMPUJAR
botón estándar
ENVIAR
entrada de fin de formulario (particularmente relevante para formularios HTML)

REINICIAR
restablece todos los valores dentro del formulario a sus valores originales
URL
llamada de la URL definida en TargetURL (se abre dentro de la ventana que se especificó mediante
TargetFrame )
Los tipos de botón Aceptar y Cancelar proporcionados en los cuadros de diálogo no son compatibles con los formularios.
Botones de opción
Las siguientes propiedades de un botón de opción están disponibles a través de su objeto de modelo:

Tabstop (booleano)
se puede acceder al elemento de control mediante la tecla de tabulación

TabIndex (largo)
posición del elemento de control en la secuencia de activación
Page 168
FontName (cadena)

FontHeight (Single)

Etiqueta (cadena)
Etiqueta (cadena)
inscripción de botón
Imprimible (booleano)

Estado (corto)
si es 1, la opción está activada, de lo contrario está desactivada

RefValue (cadena)
cadena para guardar información adicional (por ejemplo, para administrar ID de registros de datos)
TextColor (largo)

HelpText (cadena)
texto de ayuda que se muestra automáticamente, que se muestra si el cursor del mouse está sobre el elemento de control
HelpURL (cadena)
El mecanismo para agrupar botones de opción distingue entre los elementos de control de los cuadros de diálogo y los formularios.
Mientras que los elementos de control que aparecen uno tras otro en los diálogos se combinan automáticamente para formar un grupo,
la agrupación en formas se realiza sobre la base de nombres. Para hacer esto, todos los botones de opción de un grupo deben contener el
mismo nombre. OpenOffice.org combina los elementos de control agrupados en una matriz de modo que los botones individuales
de un programa OpenOffice.org Basic se puede acceder de la misma manera.
El siguiente ejemplo muestra cómo se puede determinar el modelo de un grupo de elementos de control.
Dim Doc como objeto
Dim Ctl como objeto
Dim I como entero
Doc = ThisComponent
Si Form.HasByName ("MyOptions") Entonces
Ctl = Formulario. GetGroupbyName ("MisOpciones")
Función de salida
Terminara si
Siguiente yo
El código corresponde al ejemplo anterior para determinar un modelo de elemento de control simple. Busca
a través de todos los formularios en el documento de texto actual en un bucle y utiliza el método HasByName para comprobar si el
El formulario correspondiente contiene un elemento con el nombre MyOptions que está buscando. Si este es el caso, entonces el
Se accede a la matriz del modelo utilizando el método GetGroupByName (en lugar del método GetByName para determinar
modelos simples).
Casillas de verificación
El objeto modelo de un formulario de casilla de verificación proporciona las siguientes propiedades:
Page 169

Tabstop (booleano)

TabIndex (largo)

FontName (cadena)

FontHeight (Single)

Etiqueta (cadena)
Etiqueta (cadena)
etiqueta de botón

Estado (corto)
si es 1, la opción está activada, de lo contrario está desactivada
RefValue (cadena)
cadena para guardar información adicional (por ejemplo, para administrar ID de registros de datos)
TextColor (largo)

HelpText (cadena)
HelpURL (cadena)
Campos de texto
Los objetos de modelo de los formularios de campo de texto ofrecen las siguientes propiedades:
Alinear (corto)
orientación del texto (0: alineado a la izquierda, 1: centrado, 2: alineado a la derecha)


Borde (corto)

EchoChar (cadena)
carácter de eco para el campo de contraseña

FontName (cadena)

FontHeight (Single)
Página 170
HardLineBreaks (booleano)
los saltos de línea automáticos se insertan permanentemente en el texto del elemento de control
HScroll (booleano)
el texto tiene una barra de desplazamiento horizontal

MaxTextLen (corto)
longitud máxima del texto; si se especifica 0, no hay límites

MultiLine (booleano)
permite entradas de varias líneas


ReadOnly (booleano)


Tabstop (booleano)

TabIndex (largo)

FontName (cadena)

FontHeight (Single)
Texto (cadena)
texto del elemento de control

TextColor (largo)

VScroll (booleano)
el texto tiene una barra de desplazamiento vertical

HelpText (cadena)
HelpURL (cadena)
Cuadros de lista
El objeto de modelo de los formularios de cuadro de lista proporciona las siguientes propiedades:

Borde (corto)
tipo de borde (0: sin borde, 1: marco 3D, 2: marco simple)

FontDescriptor (estructura)
estructura con detalles de la fuente que se utilizará (de acuerdo con la estructura com.sun.star.awt.FontDescriptor)
Página 171
LineCount (corto)
número de líneas de elemento de control

MultiSelection (booleano)
permite una selección múltiple de entradas

SelectedItems (matriz de cadenas)
lista de entradas resaltadas

StringItemList (matriz de cadenas)
lista de todas las entradas

ValueItemList (matriz de variante)
lista que contiene información adicional para cada entrada (por ejemplo, para administrar ID de registros de datos)

ReadOnly (booleano)


Tabstop (booleano)

TabIndex (largo)

FontName (cadena)

FontHeight (Single)

Etiqueta (cadena)
cadena que contiene información adicional que se puede guardar en el botón para acceso controlado por programa
TextColor (largo)

HelpText (cadena)
HelpURL (cadena)
Nota - VBA: a través de su propiedad ValueItemList , los formularios de cuadro de lista proporcionan una contraparte del VBA
propiedad, ItemData , a través de la cual puede administrar información adicional para entradas de lista individuales.
Además, los siguientes métodos se proporcionan a través del objeto de vista del cuadro de lista:
addItem (artículo, pos)
inserta la cadena especificada en el artículo en la posición Pos en la lista

addItems (ItemArray, Pos)
inserta las entradas enumeradas en el campo de datos ItemArray de la cadena en la lista en la posición Pos
removeItems (Pos, Count)
elimina las entradas de conteo a partir de la posición Pos
Page 172
selectItem (Item, SelectMode)
activa o desactiva el resaltado para el elemento especificado en la cadena Item dependiendo de la

Variable SelectMode
makeVisible (Pos)
se desplaza por el campo de lista para que la entrada especificada por Pos sea visible
Formularios de base de datos

Los formularios de OpenOffice.org se pueden vincular directamente a una base de datos. Los formularios creados de esta manera proporcionan todas las funciones
de un front-end de base de datos completo sin requerir trabajo de programación independiente.
Puede desplazarse y buscar en las tablas y consultas seleccionadas, así como cambiar los registros de datos e insertar nuevos
registros de datos. OpenOffice.org garantiza automáticamente que los datos relevantes se recuperen de la base de datos y que
los cambios realizados se vuelven a escribir en la base de datos.
Un formulario de base de datos corresponde a un formulario estándar de OpenOffice.org. Además de las propiedades estándar, el
Las siguientes propiedades específicas de la base de datos también deben configurarse en el formulario:
Nombre de origen de datos (cadena)
nombre de la fuente de datos (consulte Acceso a la base de datos; la fuente de datos debe crearse globalmente en OpenOffice.org)
Comando (cadena)
nombre de la tabla, consulta o el comando de selección SQL al que se va a hacer un enlace

CommandType (Const)
especifica si el comando es una tabla, una consulta o un comando SQL (valor de

com.sun.star.sdb.CommandType enumeración)
La enumeración com.sun.star.sdb.CommandType cubre los siguientes valores:

MESA
Mesa
CONSULTA
Consulta
MANDO
Comando SQL
Los campos de la base de datos se asignan a los elementos de control individuales a través de esta propiedad:
DataField (cadena)
nombre del campo de la base de datos vinculada
Mesas
Se proporciona otro elemento de control para trabajar con bases de datos, el elemento de control de tabla. Esto representa el
contenido de una consulta o tabla de base de datos completa. En el escenario más simple, un elemento de control de tabla está vinculado a un
base de datos utilizando el formulario de piloto automático, que vincula todas las columnas con los campos de base de datos relevantes de acuerdo con el
especificaciones del usuario.

Guía básica OpenOffice programación

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Guía básica OpenOffice programación

Cargado por

Copyright:

Formatos disponibles

8/8/2020 Guía BÁSICA de OpenOffice.

OpenOffice.org 3.2 Guía BÁSICA

Derechos de autor.................................................. .................................................. .................................................. .............................. 2

Prefacio................................................. .................................................. ... 5

1 Guía de programación BÁSICA de OpenOffice.org.................................................. .7

2 El lenguaje de OpenOffice.org BÁSICO.................................................. ...... 9

3 Biblioteca en tiempo de ejecución.................................................. ...................................... 35

4 Introducción a la API.................................................. ............................ 51

Módulos, servicios e interfaces.................................................. .................................................. ....................................... 53

5 Trabajar con documentos.................................................. ......................... 59

6 documentos de texto.................................................. ...................................... 69

7 documentos de hoja de cálculo.................................................. .......................... 91

8 Dibujos y presentaciones.................................................. .................. 111

9 gráficos (diagramas).................................................. ................................. 131

10 bases de datos.................................................. ............................................ 143

11 diálogos.................................................. ................................................. 151

12 formularios.................................................. .................................................. 167

1 Guía de programación BÁSICA de OpenOffice.org

Acerca de OpenOffice.org Basic

El lenguaje de programación OpenOffice.org Basic se puede dividir en cuatro componentes:

y permite que se creen, guarden, modifiquen e impriman.

Usuarios previstos de OpenOffice.org Basic

Uso de OpenOffice.org Basic

8 OpenOffice.org 3.2 Guía BÁSICA · Marzo de 2010

2 El lenguaje de OpenOffice.org BASIC

Descripción general de un programa básico

se puede escribir de la siguiente manera:

Todos los caracteres que siguen a un apóstrofe se tratan como comentarios:

A continuación, se muestran algunos ejemplos de marcadores correctos e incorrectos:

10 OpenOffice.org 3.2 Guía BÁSICA · Marzo de 2010

Trabajar con variables

Declaración de variable implícita

Declaración de variable explícita

La instrucción Dim puede registrar varias declaraciones de variables:

Capítulo 2 · El lenguaje de OpenOffice.org BÁSICO 11

De un conjunto de caracteres ASCII a Unicode

El conjunto de caracteres ASCII

El conjunto de caracteres ANSI

12 OpenOffice.org 3.2 Guía BÁSICA · Marzo de 2010

Declaración de ejemplo de una variable de cadena:

También puede escribir esta declaración como:

Especificación de cadenas explícitas

Declaraciones de ejemplo para variables enteras:

Variables enteras largas

Capítulo 2 · El lenguaje de OpenOffice.org BÁSICO 13

Declaraciones de ejemplo para variables enteras largas:

Declaraciones de ejemplo para variables individuales:

Declaraciones de ejemplo de variables dobles:

Declaraciones de ejemplo de variables monetarias:

14 OpenOffice.org 3.2 Guía BÁSICA · Marzo de 2010

Dim A como flotador

Especificación de números explícitos

A = 1223,53 'se redondea

Estilo de escritura exponencial

Aquí hay algunos ejemplos correctos e incorrectos de números en formato exponencial:

Capítulo 2 · El lenguaje de OpenOffice.org BÁSICO 15

devuelve valores incorrectos. La expresion

Declaración de ejemplo de una variable booleana:

Declaración de ejemplo de una variable de fecha:

dieciséis OpenOffice.org 3.2 Guía BÁSICA · Marzo de 2010

Las matrices se pueden definir de la siguiente manera:

Valor especificado para el índice de inicio

Capítulo 2 · El lenguaje de OpenOffice.org BÁSICO 17