Macros en Basic para Calc - Apache OpenOffice Basic

27/12/23, 8:49 Macros en Basic para Calc - Apache OpenOffice Basic
wiki.open-office.es
Basic
Ver.4.1.x
Macros para Apache OpenOffice Calc

Trabajando con libros y hojas
Acceder al documento (libro) actual
Abrir un libro existente
Abrir un libro con macros existente
Verifica si el documento es un libro de Calc
Hoja de cálculo activa
Contar número de hojas
Hoja por índice
Hoja por nombre
Recorrer (iterar,enumerar) todas las hojas
Nueva hoja
Copiar / Mover hoja a otro libro
Trabajando con Filas

Fila
Índice de la fila
Establecer u obtener el alto de fila; ocultar o mostrar filas
Establecer u obtener el alto de fila en cm; ocultar o mostrar filas
Establecer u obtener si la fila es visible
Establece u obtiene si la fila es salto de página
Insertar una o más filas
Eliminar una o más filas
Trabajando con Columnas

Columna
Índice de la columna
Establecer u obtener el ancho de columna; mostrar u ocultar columnas
Establecer u obtener el ancho de columna en cm; mostrar u ocultar columnas
Establecer u obtener si la columna es visible
Establece u obtiene si la columna es salto de página
Insertar una o más columnas
Eliminar una o más columnas
Trabajando con celdas y rangos de celdas

Celda por referencia
Rango por referencia
Celda por posición
Celda o rango por nombre
Celda activa
Texto de la celda
Valor de la celda
Fórmula de la celda
Fórmula local de la celda
Tipo de contenido de la celda
https://wiki.open-office.es/Macros_en_Basic_para_OpenOffice_Calc#Posici.C3.B3n_de_la_celda 1/21
Posición de la celda
Posición de un rango
Insertar celdas
Eliminar celdas
Copiar celdas
Copiar celdas entre libros
Mover celdas
Mover celdas entre libros
Borrar contenido de celdas
Dando formato a celdas y a rangos de celdas

Color de fondo de celda o rango
Función auxiliar ColorRGB
Función auxiliar Extraer componentes R, G, B
Fondo transparente en celda o rango
Sombra en celda o rango
Justificación horizontal en celda o rango
Justificación vertical en celda o rango
Orientación del texto en celda o rango
Referencia de rotación en celda o rango
Ángulo del texto en celda o rango
Ajustar texto en celda
Rellenar una celda, rango o grupo de rangos
Recorrer los rangos de un grupo de rangos
Recorrer las celdas de un rango
Cambiar valor y aplicar formato numérico a una celda
Id de formato numérico
Barras de estado, fórmulas, progreso

Ocultar / Mostrar barra de Estado o Fórmulas
Barra de Estado y Barra de progreso
Exportar
Exportar en formato Excel
Exportar en formato Excel con contraseña
Devolver las celdas seleccionadas como una tabla HTML
Eventos
Evento Al cambiar la selección en Calc (http://blog.open-office.es/basic/evento-al-cambiar-la-seleccion-en-openoffice-libreoffice-calc)
Cambiar el cursor o puntero del ratón en OpenOffice Basic (http://blog.open-office.es/basic/cambiar-el-cursor-o-puntero-del-raton-en-openoffice-basic)
Reproducir sonidos en una hoja de cálculo de OpenOffice Calc (http://blog.open-office.es/calc/reproducir-sonidos-en-una-hoja-de-calculo-de-openoffice-calc)
Insertar la hora actual en OpenOffice Calc (http://blog.open-office.es/basic/insertar-la-hora-actual-en-openoffice-calc)
Otras
Copiar una celda (con executeDispatch)
Pegar en una celda (con executeDispatch)
Extraer URL y Texto de un hiperenlace
+ Macros para Calc en nuestro blog (http://blog.open-office.es/basic/macros/macros_calc/)
Trabajando con libros y hojas

Acceder al documento (libro) actual
Devuelve un objeto con el libro actualmente abierto.
Function Libro() As Object

'--------------------------------------------------------------------------------------------
Libro = ThisComponent
End Function
Abrir un libro existente

Abre el documento indicado en cRuta; debe contener la ruta y el nombre del documento. Por ejemplo C:\User\Docs\Informe-mensual.ods
Opcionalmente se le puede pasar un array aOpciones() de tipo com.sun.star.bean.PropertyValue, con las opciones deseadas para abrir el documento.
Function LibroAbrir( cRuta As String, Optional aOpciones() ) As Object

'--------------------------------------------------------------------------------------------
cRuta = ConvertToURL( cRuta )
If IsMissing( aOpciones ) Then aOpciones = Array()
LibroAbrir = StarDesktop.LoadComponentFromURL( cRuta, "_blank", 0, aOpciones() )
End Function
Ejemplos:
Abrir un libro Calc existente
Dim miLibro As Object

miLibro = LibroAbrir "C:\miLibroDeCalc.ods"
Abrir un libro Calc pero que no sea visible (oculto):
Dim miLibro As Object, aOpc(1) As New com.sun.star.bean.PropertyValue

aOpc(0).Name = "Hidden"
aOpc(0).Value = TRUE
miLibro = LibroAbrir "C:\miLibroDeCalc.ods", aOpc()
Abrir un archivo CSV desde Calc, delimitado por puntos y comas, usando como delimitador de texto las comillas dobles, desde la fila 1:
Dim miCsv As Object, aOpc(1) As New com.sun.star.bean.PropertyValue

aOpc(0).Name = "FilterName"
aOpc(0).Value = "scalc: Text - txt - csv (StarCalc)"
aOpc(1).Name = "FilterOptions"
aOpc(1).Value = "59,34,ANSI,1,,0,false,false"
miCsv = LibroAbrir "C:\miArchivo.csv", aOpc()
Para conocer más propiedades al abrir un documento, ver Service MediaDescriptor

(http://www.openoffice.org/api/docs/common/ref/com/sun/star/document/MediaDescriptor.html).
Para conocer más opciones de filtro, ver Propiedad FilterOptions (https://wiki.openoffice.org/wiki/Documentation/DevGuide/Spreadsheets/Filter_Options).
Abrir un libro con macros existente

Abre el documento con macros activadas indicado en cRuta; debe contener la ruta y el nombre del documento. Por ejemplo C:\User\Docs\Informe-mensual.ods
Function LibroConMacrosAbrir( cRuta As String ) As Object

'--------------------------------------------------------------------------------------------
Dim mOpciones(0) As New "com.sun.star.beans.PropertyValue"
mOpciones(0).Name = "MacroExecutionMode"
mOpciones(0).Value = 4
cRuta = ConvertToURL( cRuta )
LibroAbrir = StarDesktop.LoadComponentFromURL( cRuta, "_blank", 0, mOpciones() )
End Function
Verifica si el documento es un libro de Calc

Devuelve Verdadero si el objeto pasado como argumento es un libro de Calc.
Function DocEsLibroCalc( oLibro As Object ) As Boolean

'--------------------------------------------------------------------------------------------
DocEsLibroCalc = oLibro.SupportsService( "com.sun.star.sheet.SpreadsheetDocument" )
End Function
Hoja de cálculo activa

Devuelve un objeto con la hoja de cálculo activa del libro que se pasa como argumento.
Function HojaActiva( oLibro As Object ) As Object

'--------------------------------------------------------------------------------------------
HojaActiva = oLibro.GetCurrentController.GetActiveSheet
End Function
Contar número de hojas

Devuelve el número de hojas que contiene el libro pasado como argumento.
Function NumeroHojas( oLibro As Object ) As Long

'--------------------------------------------------------------------------------------------
NumeroHojas = oLibro.getSheets.getCount()
End Function
Hoja por índice

Devuelve un objeto con la hoja solicitada por su índice del libro pasado como argumento. La primera hoja tiene como índice 0. Si se eliminan o agregan hojas, se
renumeran inmediatamente según su disposición en el selector de hojas.
Function HojaPorIndice( oLibro As Object, nHoja As Long ) As Object

'--------------------------------------------------------------------------------------------
HojaPorIndice = oLibro.Sheets( nHoja )
End Function
Hoja por nombre

Devuelve un objeto con la hoja solicitada por su nombre del libro pasado como argumento. Por ejemplo Hoja3.
Function HojaPorNombre( oLibro As Object, cHoja As String ) As Object

'--------------------------------------------------------------------------------------------
HojaPorNombre = oLibro.Sheets.GetByName( cHoja )
End Function
Recorrer (iterar,enumerar) todas las hojas

Mostramos dos métodos diferentes, pero igual de efectivos.
Mediante un bucle For Each x In z Next se recorren todas las hojas del libro pasado como argumento.
Sub LibroRecorrerHojas( oLibro As Object )

'--------------------------------------------------------------------------------------------
Dim oHoja As Object, oHojas As Object
oHojas = oLibro.getSheets
For Each oHoja In oHojas

' aquí tu código
MsgBox "Hoja actual es " & oHoja.getName
Next
End Sub
Mediante un objeto Enumeration se recorren todas las hojas del libro pasado como argumento.
Sub LibroRecorrerHojas2( oLibro As Object )

'--------------------------------------------------------------------------------------------
Dim oHoja As Object, eHojas As Object
eHojas = oLibro.getSheets.CreateEnumeration
While eHojas.HasMoreElements
oHoja = eHojas.NextElement()
' aquí tu código
MsgBox "Hoja actual es " & oHoja.getName
Wend
End Sub
Nueva hoja
Inserta una nueva hoja con nombre cNombre en el libro pasado como argumento. Devuelve un objeto con la nueva hoja insertada.
Function LibroNuevaHoja( oLibro As Object, cNombre As String ) As Object

'--------------------------------------------------------------------------------------------
Dim oHoja As Object
oHoja = oLibro.CreateInstance( "com.sun.star.sheet.Spreadsheet" )
oLibro.Sheets.InsertByName( cNombre, oHoja )
LibroNuevaHoja = oHoja
End Function
Copiar / Mover hoja a otro libro

Copia o mueve la hoja actual del libro oLibroOrg pasado como argumento al final del libro cLibroDst; ambos libros deben estar abiertos; el libro origen se pasa como
objeto, y el destino, como cadena. El argumento lCopiar es True si se quiere copiar la hoja, False si se quiere mover.
Sub LibroCopiarHoja( oLibroOrg As Object, cLibroDst As String, lCopiar As Boolean )

'--------------------------------------------------------------------------------------------
Dim dispatcher As Object
dispatcher = CreateUNOService("com.sun.star.frame.DispatchHelper")
Dim Args(2) As New com.sun.star.beans.PropertyValue
Args(0).Name = "DocName"
Args(0).Value = cLibroDst ' Sin ruta ni .ods
Args(1).Name = "Index"
Args(1).Value = 32767
Args(2).Name = "Copy"
Args(2).Value = lCopiar ' True copia, False mueve
dispatcher.ExecuteDispatch(oLibroOrg.CurrentController.Frame, ".uno:Move", "", 0, Args())
End Sub
Ejemplo de uso
Dim oLibroOrg As Object, oLibroDst As Object

oLibroOrg = LibroAbrir("C:\Documentos\Calc\Libro Origen.ods")
oLibroDst = LibroAbrir("C:\Documentos\Calc\Libro Destino.ods")
LibroCopiarHoja oLibroOrg, "Libro Destino", True
Trabajando con Filas

Fila
Devuelve un objeto fila que es la fila nFila de la hoja pasada como argumento. nFila es un número entre 1 y 1.048.576, y se corresponde con el número de encabezado
de la fila.
Function Fila( oHoja As Object, nFila As Long ) As Object

'--------------------------------------------------------------------------------------------
nFila = FilaIndex( nFila )
Fila = oHoja.getRows.GetByIndex( nFila )
End Function
Índice de la fila
Devuelve el índice de la fila nFila, que es un número entre 1 y 1.048.576, y se corresponde con el número de encabezado de la fila. El índice es un número menos (la
primera fila tiene como índice el valor 0).
Function FilaIndex( nFila As Long ) As Long

'--------------------------------------------------------------------------------------------
' podemos hacer referencia a la fila por su número ordinal( 1 - 1.048.576 )
' el índice es un número menos que el ordinal( la primera fila es la 1, y tiene indice 0 )
If nFila < 1 Then nFila = 1
If nFila > 1048576 Then nFila = 1048576
FilaIndex = nFila - 1
End Function
Establecer u obtener el alto de fila; ocultar o mostrar filas

Establece o devuelve1 el alto del objeto fila pasado como argumento. nAlto establece el alto de la fila en milésimas de centímetro. Un valor 1000 se corresponde con 1
cm.
Si el valor pasado es mayor que cero, la fila tomará ese nuevo alto. Si estaba oculta, se mostrará.
Si el valor pasado es un valor negativo (menor de 0), se aplicará el ajuste óptimo de alto de fila o autoajuste.
Si el valor pasado es 0 la fila no se mostrará (fila oculta).
Si no se le pasa ningún valor, actúa como función y devuelve el alto de la fila en milésimas de centímetro. Un valor 1000 se corresponde con 1 cm.
Function FilaAlto( oFila As Object, Optional nAlto As Long ) As Long

'--------------------------------------------------------------------------------------------
If Not IsMissing( nAlto ) Then
If nAlto < 0 Then ' si nAlto es negativo entonces aplico alto óptimo
oFila.setPropertyValue( "OptimalHeight", True )
Else
oFila.setPropertyValue( "Height", nAlto )
EndIf
EndIf
FilaAlto = oFila.getPropertyValue( "Height" )
End Function
Establecer u obtener el alto de fila en cm; ocultar o mostrar filas

Establece o devuelve1 el alto del objeto fila pasado como argumento. nAlto establece el alto de la fila en centímetros.
Si el valor pasado es mayor que cero, la fila tomará ese nuevo alto. Si estaba oculta, se mostrará.
Si el valor pasado es un valor negativo (menor de 0), se aplicará el ajuste óptimo de alto de fila o autoajuste.
Si el valor pasado es 0 la fila no se mostrará (fila oculta).
Si no se le pasa ningún valor, actúa como función y devuelve el alto de la fila en centímetros.
Function FilaAltoCm( oFila As Object, Optional nAlto As Single ) As Single

'--------------------------------------------------------------------------------------------
If Not IsMissing( nAlto ) Then
If nAlto < 0 Then ' si nAlto es negativo entonces aplico alto óptimo
oFila.setPropertyValue( "OptimalHeight", True )
Else
oFila.setPropertyValue( "Height", nAlto * 1000 )
EndIf
EndIf
FilaAltoCm = oFila.getPropertyValue( "Height" ) / 1000
End Function
Establecer u obtener si la fila es visible

Otra forma de ocultar y mostrar filas es mediante su propiedad "IsVisible". Esta función establece o indica1 la visibilidad del objeto fila pasado como argumento. El
argumento lVisible es un valor booleano (verdadero o falso).
Si se pasa el argumento lVisible, la fila se hará visible (True) o se ocultará (False)
Si no se pasa el argumento, la función devuelve el estado de visibilidad actual de la fila (True es visible, False en caso contrario)
Function FilaVisible( oFila As Object, Optional lVisible As Boolean ) As Boolean

'--------------------------------------------------------------------------------------------
If Not IsMissing( lVisible ) Then
oFila.setPropertyValue( "IsVisible", lVisible )
EndIf
FilaVisible = oFila.getPropertyValue( "IsVisible" )
End Function
Establece u obtiene si la fila es salto de página

Esta función establece o indica1 si el objeto fila pasado como argumento es una fila de salto de página. El argumento lSaltoPagina es un valor booleano (verdadero o
falso).
Si se pasa el argumento lSaltoPagina, la fila será salto de página (True) o no lo será (False)
Si no se pasa el argumento, la función devuelve el estado de salto de página actual de la fila (True es salto de página, False en caso contrario)
Function FilaEsSaltoPagina( oFila As Object, Optional lSaltoPagina As Boolean ) As Boolean

'--------------------------------------------------------------------------------------------
If Not IsMissing( lSaltoPagina ) Then
oFila.setPropertyValue( "IsStartOfNewPage", lSaltoPagina )
EndIf
FilaEsSaltoPagina = oFila.getPropertyValue( "IsStartOfNewPage" )
End Function
Insertar una o más filas

Inserta una o más filas indicadas por el argumento nFilasInserta en el objeto hoja pasado como argumento. La(s) nueva(s) fila(s) se insertan justo tras la fila nTrasFila,
que es un número entre 1 y 1.048.575 (entre la primera y la penúltima), y se corresponde con el número ordinal de encabezado de la fila.
Sub FilaInserta( oHoja As Object, nTrasFila As Long, nFilasInserta As Long )

'--------------------------------------------------------------------------------------------
oHoja.getRows.insertByIndex( FilaIndex( nTrasFila ), nFilasInserta )
End Sub
Eliminar una o más filas

Elimina una o más filas indicadas por el argumento nFilasElimina en el objeto hoja pasado como argumento. La(s) fila(s) será(n) eliminada(s) empezando a contar
desde la filanDesdeFila (ésta incluída), que es un número entre 1 y 1.048.576, y se corresponde con el número ordinal de encabezado de la fila.
Sub FilaElimina( oHoja As Object, nDesdeFila As Long, nFilasElimina As Long )

'--------------------------------------------------------------------------------------------
oHoja.getRows.removeByIndex( FilaIndex( nDesdeFila ), nFilasElimina )
End Sub
Trabajando con Columnas

Columna
Devuelve un objeto columna que es la columna xColumna de la hoja pasada como argumento. xColumna es un número entre 1 y 1.024, o una combinación de letras en
el rango A-AMJ y se corresponde con el número ordinal o la(s) letra(s) de encabezado de la columna.
Function Columna( oHoja As Object, xColumna ) As Object

'--------------------------------------------------------------------------------------------
xColumna = ColumnaIndex( oHoja, xColumna )
Columna = oHoja.getColumns.GetByIndex( xColumna )
End Function
Índice de la columna
Devuelve el índice de la columna xColumna, que es un número entre 1 y 1.024, o una combinación de letras en el rango A-AMJ y se corresponde con el número
ordinal o la(s) letra(s) de encabezado de la columna. El índice es un número menos (la primera columna (columna A) tiene como índice el valor 0).
Function ColumnaIndex( xColumna ) As Long

'--------------------------------------------------------------------------------------------
' podemos hacer referencia a la columna por su letra( A - AMJ ) o por su ordinal( 1 - 1024 )
' el índice es un número menos que el ordinal( la primera columna es la A o 1, y tiene indice 0 )
If Not IsNumeric( xColumna ) Then ' se ha especificado la columna por su( s ) letra( s )
xColumna = CeldaPosicion( ThisComponent.Sheets( 0 ).GetCellRangeByName( xColumna & "1" ) ).Column + 1
EndIf
If xColumna < 1 Then xColumna = 1
If xColumna > 1024 Then xColumna = 1024
ColumnaIndex = xColumna - 1
End Function
Establecer u obtener el ancho de columna; mostrar u ocultar columnas

Establece o devuelve1 el ancho del objeto columna pasado como argumento. nAncho establece el ancho de la columna en milésimas de centímetro. Un valor 1000 se
corresponde con 1 cm.
Si el valor pasado es mayor que cero, la columna tomará ese nuevo ancho. Si estaba oculta, se mostrará.
Si el valor pasado es un valor negativo (menor de 0), se aplicará el ajuste óptimo de ancho de columna o autoajuste.
Si el valor pasado es 0 la columna no se mostrará (columna oculta).
Si no se le pasa ningún valor, actúa como función y devuelve el ancho de la columna en milésimas de centímetro. Un valor 1000 se corresponde con 1 cm.
Function ColumnaAncho( oColumna As Object, Optional nAncho As Long ) As Long

'--------------------------------------------------------------------------------------------
If Not IsMissing( nAncho ) Then
If nAncho < 0 Then ' si nAncho es negativo entonces aplico ancho óptimo
oColumna.setPropertyValue( "OptimalWidth", True )
Else
oColumna.setPropertyValue( "Width", nAncho )
EndIf
EndIf
ColumnaAncho = oColumna.getPropertyValue( "Width" )
End Function
Establecer u obtener el ancho de columna en cm; mostrar u ocultar columnas

Establece o devuelve1 el ancho del objeto columna pasado como argumento. nAncho establece el ancho de la columna en centímetros.
Si el valor pasado es mayor que cero, la columna tomará ese nuevo ancho. Si estaba oculta, se mostrará.
Si el valor pasado es un valor negativo (menor de 0), se aplicará el ajuste óptimo de ancho de columna o autoajuste.
Si el valor pasado es 0 la columna no se mostrará (columna oculta).
Si no se le pasa ningún valor, actúa como función y devuelve el ancho de la columna en centímetros.
Function ColumnaAnchoCm( oColumna As Object, Optional nAncho As Single ) As Single

'--------------------------------------------------------------------------------------------
If Not IsMissing( nAncho ) Then
If nAncho < 0 Then ' si nAncho es negativo entonces aplico ancho óptimo
oColumna.setPropertyValue( "OptimalWidth", True )
Else
oColumna.setPropertyValue( "Width", nAncho * 1000 )
EndIf
EndIf
ColumnaAnchoCm = oColumna.getPropertyValue( "Width" ) / 1000
End Function
Establecer u obtener si la columna es visible

Otra forma de ocultar y mostrar columnas es mediante su propiedad "IsVisible". Esta función establece o indica1 la visibilidad del objeto columna pasado como
argumento. El argumento lVisible es un valor booleano (verdadero o falso).
Si se pasa el argumento lVisible, la columna se hará visible (True) o se ocultará (False)
Si no se pasa el argumento, la función devuelve el estado de visibilidad actual de la columna (True es visible, False en caso contrario)
Function ColumnaVisible( oColumna As Object, Optional lVisible As Boolean ) As Boolean

'--------------------------------------------------------------------------------------------
If Not IsMissing( lVisible ) Then oColumna.setPropertyValue( "IsVisible", lVisible )
ColumnaVisible = oColumna.getPropertyValue( "IsVisible" )
End Function
Establece u obtiene si la columna es salto de página

Esta función establece o indica1 si el objeto columna pasado como argumento es una columna de salto de página. El argumento lSaltoPagina es un valor booleano
(verdadero o falso).
Si se pasa el argumento lSaltoPagina, la columna será salto de página (True) o no lo será (False)
Si no se pasa el argumento, la función devuelve el estado de salto de página actual de la columna (True es salto de página, False en caso contrario)
Function ColumnaEsSaltoPagina( oColumna As Object, Optional lSaltoPagina As Boolean ) As Boolean

'--------------------------------------------------------------------------------------------
If Not IsMissing( lSaltoPagina ) Then oColumna.setPropertyValue( "IsStartOfNewPage", lSaltoPagina )
ColumnaEsSaltoPagina = oColumna.getPropertyValue( "IsStartOfNewPage" )
End Function
Insertar una o más columnas

Inserta una o más columnas indicadas por el argumento nColumnasInserta en el objeto hoja pasado como argumento. La(s) nueva(s) columna(s) se insertan justo tras
la columna xTrasColumna, que es un número entre 1 y 1.024, o una combinación de letras en el rango A-AMI (entre la primera y la penúltima) y se corresponde con el
número ordinal o la(s) letra(s) de encabezado de la columna.
Sub ColumnaInserta( oHoja As Object, xTrasColumna, nColumnasInserta As Long )

'--------------------------------------------------------------------------------------------
oHoja.getColumns.insertByIndex( ColumnaIndex( xTrasColumna ), nColumnasInserta )
End Sub
Eliminar una o más columnas

Elimina una o más columnas indicadas por el argumento nColumnasElimina en el objeto hoja pasado como argumento. La(s) columna(s) será(n) eliminada(s)
empezando a contar desde la columna xDesdeColumna (ésta incluída), que es un número entre 1 y 1.024, o una combinación de letras en el rango A-AMJ y se
corresponde con el número ordinal o la(s) letra(s) de encabezado de la columna.
Sub ColumnaElimina( oHoja As Object, xDesdeColumna, nColumnasElimina As Long )

'--------------------------------------------------------------------------------------------
oHoja.getColumns.removeByIndex( ColumnaIndex( xDesdeColumna ), nColumnasElimina )
End Sub
Trabajando con celdas y rangos de celdas

Celda por referencia
Devuelve un objeto celda de la hoja pasada como argumento indicando su referencia en formato A1.
Function Celda( oHoja As Object, cReferencia As String ) As Object

'--------------------------------------------------------------------------------------------
Celda = oHoja.GetCellRangeByName( cReferencia )
End Function
Rango por referencia

Devuelve un objeto rango de celdas de la hoja pasada como argumento indicando su referencia en formato A1:A1.
Function Rango( oHoja As Object, cRango As String ) As Object

'--------------------------------------------------------------------------------------------
Rango = oHoja.GetCellRangeByName( cRango )
End Function
Celda por posición

Devuelve un objeto celda de la hoja pasada como argumento indicando su posición por número o letra de columna y número de fila. xColumna es un número entre 1 y
1.024, o una combinación de letras en el rango A-AMJ y se corresponde con el número ordinal o la(s) letra(s) de encabezado de la columna. nFila es un número entre 1
y 1.048.576, y se corresponde con el número de encabezado de la fila.
Function CeldaPorPosicion( oHoja As Object, xColumna, nFila As Long ) As Object

'--------------------------------------------------------------------------------------------
CeldaPorPosicion = oHoja.GetCellByPosition( ColumnaIndex( xColumna ), FilaIndex( nFila ) )
End Function
Celda o rango por nombre

Devuelve un objeto celda o rango que se corresponde con la celda con nombre o con el rango con nombre indicado en cNombre. En Calc los nombres de celdas y de
rangos son visibles en todo el libro, a diferencia de Excel donde puede definirse su ámbito a nivel de hoja o a nivel de libro.
Function CeldaRangoPorNombre( oHoja As Object, cNombre As String ) As Object

'--------------------------------------------------------------------------------------------
' En Calc una celda o rango con nombre es visible en todo el libro( ámbito );
' En Excel puede ser visible sólo en una hoja o en todo el libro
' La función devuelve la celda o el rango de celdas asociadas al nombre
CeldaRangoPorNombre = ThisComponent.NamedRanges.GetByName( cNombre ).getReferredCells
End Function
Celda activa
Devuelve un objeto celda, rango de celdas o grupo de rangos de celdas de la hoja pasada como argumento que se corresponde con la celda activa (actualmente
seleccionada), rango de celdas seleccionadas o grupo de rangos de celdas seleccionadas.
Function CeldaActiva() As Object

'--------------------------------------------------------------------------------------------
On Local Error Resume Next ' si no hay una celda seleccionada daría error
CeldaActiva = ThisComponent.getCurrentSelection
End Function
Texto de la celda
Establece o devuelve1 el texto del objeto celda que se pasa como argumento.
Si se pasa una cadena vacía o una cadena con texto, se sustituirá el contenido de la celda por la cadena pasada.
Si no se le pasa ninguna cadena, actúa como función y devuelve el texto contenido en la celda.
Function CeldaTexto( oCelda As Object, Optional cTexto As String ) As String

'--------------------------------------------------------------------------------------------
If Not IsMissing( cTexto ) Then oCelda.String = cTexto
CeldaTexto = oCelda.String
End Function
Valor de la celda
Establece o devuelve1 el valor numérico del objeto celda que se pasa como argumento.
Si se pasa una valor, se sustituirá el valor de la celda por el valor pasado. El texto presentado por la celda depende del formato que tenga asignado la celda.
Si no se le pasa ningún valor, actúa como función y devuelve el valor numérico contenido en la celda.
Function CeldaValor( oCelda As Object, Optional nValor As Double ) As Double

'--------------------------------------------------------------------------------------------
' Válida para números enteros, con decimales, moneda, fechas, horas, fechas/horas
If Not IsMissing( nValor ) Then oCelda.Value = nValor
CeldaValor = oCelda.Value
End Function
Fórmula de la celda
Establece o devuelve1 la fórmula del objeto celda que se pasa como argumento.
Si se pasa una cadena vacía o con una fórmula, se sustituirá la fórmula de la celda por la cadena pasada.
La fórmula tiene que utilizar comas o puntos y comas para separar argumentos, acorde a la configuración local, pero los nombres de las funciones deben de
estar escritos en su equivalente en inglés.
Para escribir comillas dentro de la cadena en el editor de Basic, utilizaremos dobles comillas dos veces, como se muestra en el ejemplo a continuación.
Ejemplo:
Queremos establecer una celda con la fórmula =SI(A1>100;"MAYOR";"MENOR"). El argumento cFormula deberá ser:
=IF(A1>100;""MAYOR"";""MENOR"") si la configuración local establece separar con puntos y comas los argumentos, o...
=IF(A1>100,""MAYOR"",""MENOR"") si la configuración local establece separar con comas los argumentos.
Si no se le pasa ninguna cadena, actúa como función y devuelve una cadena con la fórmula contenida en la celda, en formato inglés, pero utilizará comas o
puntos y comas para separar argumentos, acorde a la configuración local.
Ejemplo:
Una celda contiene la fórmula =SI(A1>100;"MAYOR";"MENOR"), pues se utilizan puntos y comas para separar argumentos acorde
a la configuración local. La función CeldaFormula devolverá:
=IF(A1>100;"MAYOR";"MENOR") si la configuración local establece separar con puntos y comas los argumentos, o...
=IF(A1>100,"MAYOR","MENOR") si la configuración local establece separar con comas los argumentos.
Function CeldaFormula( oCelda As Object, Optional cFormula As String ) As String

'--------------------------------------------------------------------------------------------
' Válida para fórmulas en formato inglés
' Ojo con los separadores de argumentos( es la coma, no el punto y coma),
' el separador decimal( el . y no la, )
' y los nombres de las funciones( es IF en lugar de SI)
If Not IsMissing( cFormula ) Then oCelda.Formula = cFormula
CeldaFormula = oCelda.Formula
End Function
Fórmula local de la celda

Establece o devuelve1 la fórmula en formato local del objeto celda que se pasa como argumento.
Si se pasa una cadena vacía o con una fórmula, se sustituirá la fórmula de la celda por la cadena pasada.
La fórmula tiene que utilizar comas o puntos y comas para separar argumentos acorde a la configuración local.
Para escribir comillas dentro de la cadena en el editor de Basic, utilizaremos dobles comillas dos veces, como se muestra en el ejemplo a continuación.
Ejemplo:
Queremos establecer una celda con la fórmula =SI(A1>100;"MAYOR";"MENOR"). El argumento cFormula deberá ser:
=SI(A1>100;""MAYOR"";""MENOR"") si la configuración local establece separar con puntos y comas los argumentos, o...
=SI(A1>100,""MAYOR"",""MENOR"") si la configuración local establece separar con comas los argumentos.
Si no se le pasa ninguna cadena, actúa como función y devuelve una cadena con la fórmula contenida en la celda; utilizará comas o puntos y comas para
separar argumentos acorde a la configuración local.
Ejemplo:
Una celda contiene la fórmula =SI(A1>100;"MAYOR";"MENOR"), pues se utilizan puntos y comas para separar argumentos acorde
a la configuración local. La función CeldaFormulaLocal devolverá =IF(A1>100;"MAYOR";"MENOR").
Una celda contiene la fórmula =SI(A1>100,"MAYOR","MENOR"), pues se utilizan comas para separar argumentos acorde a la
configuración local. La función CeldaFormulaLocal devolverá =IF(A1>100,"MAYOR","MENOR").
Function CeldaFormulaLocal( oCelda As Object, Optional cFormula As String ) As String

'--------------------------------------------------------------------------------------------
' Válida para fórmulas en formato local
' En español de España el separador de argumentos es el punto y coma,
' el separador decimal es la,
' y los nombres de las funciones son en español( SI y no IF)
If Not IsMissing( cFormula ) Then oCelda.FormulaLocal = cFormula
CeldaFormulaLocal = oCelda.FormulaLocal
End Function
Tipo de contenido de la celda

Devuelve una cadena describiendo el tipo del contenido de la celda. La cadena devuelta puede ser:
Cadena vacía: La celda está vacía.

Valor: La celda contiene un valor numérico (número con o sin decimales, moneda, fecha u hora).
Texto: La celda contiene un texto.
Fórmula: La celda contiene una fórmula.
Function CeldaContiene( oCelda As Object ) As String

'--------------------------------------------------------------------------------------------
Select Case oCelda.Type
Case com.sun.star.table.CellContentType.EMPTY: CeldaContiene = ""
Case com.sun.star.table.CellContentType.VALUE: CeldaContiene = "Valor"
Case com.sun.star.table.CellContentType.TEXT: CeldaContiene = "Texto"
Case com.sun.star.table.CellContentType.FORMULA: CeldaContiene = "Fórmula"
End Select
End Function
Posición de la celda
Devuelve la posición que ocupa el objeto celda que se pasa como argumento.
La posición de la celda viene definida por una estructura CellAddress que contiene los siguientes datos:
Sheet: Índice de la hoja

Column: Índice de la columna
Row: Índice de la fila
Function CeldaPosicion( oCelda As Object ) As com.sun.star.table.CellAddress

'--------------------------------------------------------------------------------------------
' CellAddress es una estructura con los siguientes datos
' Sheet : Índice de la Hoja
' Column : Índice de la Columna de la celda
' Row : Índice de la Fila de la celda
CeldaPosicion = oCelda.CellAddress
End Function
Ejemplo de uso
Sub main
Dim miCelda As Object, xPosicion
miCelda = CeldaActiva()
xPosicion = CeldaPosicion( miCelda )
Print "La celda está en la hoja " & xPosicion.Sheet + 1
Print "La celda está en la columna " & xPosicion.Column + 1
Print "La celda está en la fila " & xPosicion.Row + 1
End Sub
Posición de un rango
Devuelve la posición que ocupa el objeto celda o rango de celdas que se pasa como argumento.
La posición de un rango de celdas viene definida por una estructura CellRangeAddress que contiene los siguientes datos:
Sheet: Índice de la hoja

StartColumn: Índice de la columna inicial del rango (celda más arriba a la izquierda)
StartRow: Índice de la fila inicial del rango (celda más arriba a la izquierda)
EndColumn: Índice de la columna final del rango (celda más abajo a la derecha)
EndRow: Índice de la fila final del rango (celda más abajo a la derecha)
El rango puede ser de una sola celda; en ese caso, los valores Start y End coinciden.
Function CeldaRangoPosicion( oCelda As Object ) As com.sun.star.table.CellRangeAddress

'--------------------------------------------------------------------------------------------
' CellRangeAddress es una estructura con los siguientes datos
' Sheet : Índice de la Hoja
' StartColumn : Índice de la Columna inicial del rango
' StartRow : Índice de la Fila inicial del rango
' EndColumn : Índice de la Columna final del rango
' EndRow : Índice de la Fila final del rango
CeldaRangoPosicion = oCelda.RangeAddress
End Function
Ejemplo de uso
Sub main
Dim miRango As Object, xPosicion
miRango = CeldaActiva()
xPosicion = CeldaRangoPosicion( miRango )
Print "El rango está en la hoja " & xPosicion.Sheet + 1
Print "El rango comienza en la columna " & xPosicion.StartColumn + 1 & ", fila " & xPosicion.StartRow + 1
Print "El rango termina en la columna " & xPosicion.EndColumn + 1 & ", fila " & xPosicion.EndRow + 1
End Sub
Insertar celdas
Esta subrutina permite insertar en la hoja pasada como argumento una celda o rango de celdas a partir de la posición definida por cRango con el formato A1 para una
celda, o A1:A1 para un rango de celdas.
Si cRango es una celda, se inserta una celda; si cRango es un rango de celdas, por ejemplo, de 5x4 celdas, se insertan 5x4 celdas.
Al insertar las nuevas celdas, las existentes en esa posición se desplazarán en la dirección indicada por cDireccion (es indiferente al uso de mayúsculas o minúsculas).
Cadena vacía, se omite, a, abajo o down: Las nuevas celdas insertadas desplazan a las celdas existentes hacia abajo.
d, derecha o right: Las nuevas celdas insertadas desplazan a las celdas existentes hacia la derecha.
f, filas o rows: Las nuevas celdas se insertan como filas completas, desplazando a las filas existentes hacia abajo.
c, columnas o columns: Las nuevas celdas se insertan como columnas completas, desplazando a las columnas existentes hacia la derecha.
Sub CeldaInserta( oHoja As Object, cRango As String, Optional cDireccion As String )

'--------------------------------------------------------------------------------------------
Dim oRango As Object, oAddress As New com.sun.star.table.CellRangeAddress
oRango = Rango( oHoja, cRango )
oAddress = oRango.RangeAddress
If IsMissing( cDireccion) Then cDireccion = ""
Select Case LCase( cDireccion)
Case "", "a", "abajo", "down"
oHoja.insertCells( oAddress, com.sun.star.sheet.CellInsertMode.DOWN )
Case "d", "derecha", "right"
oHoja.insertCells( oAddress, com.sun.star.sheet.CellInsertMode.RIGHT )
Case "f", "filas", "rows"
oHoja.insertCells( oAddress, com.sun.star.sheet.CellInsertMode.ROWS )
Case "c", "columnas", "columns"
oHoja.insertCells( oAddress, com.sun.star.sheet.CellInsertMode.COLUMNS )
End Select
End Sub
Ejemplo de uso
Sub main
Dim oLibro As Object, oHoja As Object
oLibro = Libro()
oHoja = HojaActiva( oLibro )
CeldaInserta oHoja, "F9:H12", "derecha"
End Sub
Eliminar celdas
Esta subrutina permite eliminar en la hoja pasada como argumento una celda o rango de celdas a partir de la posición definida por cRango con el formato A1 para una
celda, o A1:A1 para un rango de celdas.
Si cRango es una celda, se elimina esa celda; si cRango es un rango de celdas, por ejemplo, de 5x4 celdas, se eliminan las 5x4 celdas.
Al eliminar las celdas, el espacio vacío se ocupa por las celdas vecinas, que se desplazarán en la dirección indicada por cDireccion (es indiferente al uso de mayúsculas
o minúsculas).
Cadena vacía, se omite, a, arriba o up: Las celdas situadas justo debajo suben para ocupar el espacio vacío dejado por las eliminadas.
i, izquierda o left: Las celdas situadas justo a la derecha se desplazan a la izquierda para ocupar el espacio vacío dejado por las eliminadas.
f, filas o rows: Se eliminan filas completas; las filas situadas justo debajo suben para ocupar el espacio vacío dejado por las eliminadas.
c, columnas o columns: Se eliminan columnas completas; las columnas situadas justo a la derecha se desplazan a la izquierda para ocupar el espacio vacío
dejado por las eliminadas.
Sub CeldaElimina( oHoja As Object, cRango As String, Optional cDireccion As String )

'--------------------------------------------------------------------------------------------
' Se elimina la celda; otras celdas ocupan el lugar que queda vacío
Dim oRango As Object, oAddress As New com.sun.star.table.CellRangeAddress
oAddress = oRango.RangeAddress
If IsMissing( cDireccion) Then cDireccion = ""
Select Case LCase( cDireccion)
Case "", "a", "arriba", "up"
oHoja.removeRange( oAddress, com.sun.star.sheet.CellDeleteMode.UP )
Case "i", "izquierda", "left"
oHoja.removeRange( oAddress, com.sun.star.sheet.CellDeleteMode.LEFT )
Case "f", "filas", "rows"
oHoja.removeRange( oAddress, com.sun.star.sheet.CellDeleteMode.ROWS )
Case "c", "columnas", "columns"
oHoja.removeRange( oAddress, com.sun.star.sheet.CellDeleteMode.COLUMNS )
End Select
End Sub
Copiar celdas
Esta subrutina copia desde la hoja origen pasada como objeto en oHojaOrg, una celda o rango de celdas indicados por cRangoOrg, hasta una hoja destino (que puede
ser la misma hoja, una hoja distinta del mismo libro o una hoja de otro libro) pasada como objeto en oHojaDst, y lo pega en la posición definida por la celda cCeldaDst.
cCeldaDst se especifica con formato A1; cRangoOrg con formato A1 si es una celda, o A1:A1 si es un rango. Precisa de las funciones Celda y Rango.
Este procedimiento sólo es válido para cuando la hoja origen y la hoja destino están en el mismo libro. En caso contrario, no funciona, pero puedes aplicar el
procedimiento CeldaCopiaEntreLibros.
Sub CeldaCopia( oHojaOrg As Object, cRangoOrg As String, oHojaDst As Object, cCeldaDst As String )
'--------------------------------------------------------------------------------------------
Dim oRangoOrg As Object, oCeldaDst As Object, _
oAddressOrg As New com.sun.star.table.CellRangeAddress, _
oAddressDst As New com.sun.star.table.CellAddress
oRangoOrg = Rango( oHojaOrg, cRangoOrg )

oAddressOrg = oRangoOrg.RangeAddress
oCeldaDst = Celda( oHojaDst, cCeldaDst )

oAddressDst = oCeldaDst.CellAddress
oHojaOrg.CopyRange( oAddressDst, oAddressOrg )

End Sub
Copiar celdas entre libros

Esta subrutina copia desde la hoja origen pasada como objeto en oHojaOrg, una celda o rango de celdas indicados por cRangoOrg, hasta una hoja destino (que puede
ser la misma hoja, una hoja distinta del mismo libro o una hoja de otro libro) pasada como objeto en oHojaDst, y lo pega en la posición definida por el rango
cRangoDst. cRangoOrg y cRangoDst se especifican con formato A1 si se copia una celda, o A1:A1 si se copia un rango.
Los rangos origen y destino deben tener las mismas dimensiones.
Este procedimiento es válido para cuando la hoja origen y la hoja destino no están en el mismo libro.
Sub CeldaCopiaEntreLibros( oHojaOrg As Object, cRangoOrg As String, oHojaDst As Object, cRangoDst As String )
'--------------------------------------------------------------------------------------------
Dim oRangoOrg As Object, oRangoDst As Object, oDataArrayOrg As Object
oDataArrayOrg = oRangoOrg.getDataArray()
oRangoDst = Rango( oHojaDst, cRangoDst )
oRangoDst.setDataArray( oDataArrayOrg )
End Sub
Mover celdas
Esta subrutina corta desde la hoja origen pasada como objeto en oHojaOrg, una celda o rango de celdas indicados por cRangoOrg, hasta una hoja destino (que puede
ser la misma hoja, una hoja distinta del mismo libro o una hoja de otro libro) pasada como objeto en oHojaDst, y lo pega en la posición definida por la celda cCeldaDst.
cCeldaDst se especifica con formato A1; cRangoOrg con formato A1 si es una celda, o A1:A1 si es un rango. Precisa de las funciones Celda y Rango.
Este procedimiento sólo es válido para cuando la hoja origen y la hoja destino están en el mismo libro. En caso contrario, no funciona, pero puedes aplicar el
procedimiento MoverCeldasEntreLibros.
Sub CeldaMueve( oHojaOrg As Object, cRangoOrg As String, oHojaDst As Object, cCeldaDst As String )
'--------------------------------------------------------------------------------------------
Dim oRangoOrg As Object, oCeldaDst As Object, _
oAddressOrg As New com.sun.star.table.CellRangeAddress, _
oAddressDst As New com.sun.star.table.CellAddress

oAddressOrg = oRangoOrg.RangeAddress
oCeldaDst = Celda( oHojaDst, cCeldaDst )

oAddressDst = oCeldaDst.CellAddress
oHojaOrg.moveRange( oAddressDst, oAddressOrg )

End Sub
Mover celdas entre libros

Esta subrutina corta desde la hoja origen pasada como objeto en oHojaOrg, una celda o rango de celdas indicados por cRangoOrg, hasta una hoja destino (que puede
ser la misma hoja, una hoja distinta del mismo libro o una hoja de otro libro) pasada como objeto en oHojaDst, y lo pega en la posición definida por el rango
cRangoDst. cRangoOrg y cRangoDst se especifican con formato A1 si se mueve una celda, o A1:A1 si se mueve un rango.
Los rangos origen y destino deben tener las mismas dimensiones.
Precisa de los procedimientos CopiaCeldasEntreLibros y CeldaBorra
Este procedimiento es válido para cuando la hoja origen y la hoja destino no están en el mismo libro.
Sub CeldaMueveEntreLibros( oHojaOrg As Object, cRangoOrg As String, oHojaDst As Object, cRangoDst As String )
'--------------------------------------------------------------------------------------------
CeldaCopiaEntreLibros oHojaOrg, cRangoOrg, oHojaDst, cRangoDst
CeldaBorra oHojaOrg, cRangoOrg
End Sub
Borrar contenido de celdas

Esta subrutina vacía el contenido de una celda o rango de celdas indicados por cRango en la hoja pasada como objeto en oHoja, según las opciones indicadas en
cFlags. cRangoOrg con formato A1 si es una celda, o A1:A1 si es un rango.
cFlags es una cadena en la que separadas por comas se indican las opciones de borrado, que pueden ser cualquier combinación de las siguientes claves:
v, valor, value, n, número, numero: Si se incluye, se borra el valor numérico que contiene la celda o rango.
fh, fechahora, dt, datetime: Si se incluye, se borra el valor numérico en la celda o rango de celdas con formato de fecha/hora.
t, texto, s, string: Si se incluye, se borra el texto que contiene la celda o rango.
c, comentario, a, annotation: Si se incluye, se borra el comentario que contiene la celda o rango.
f, fórmula, formula: Si se incluye, se borra la fórmula que contiene la celda o rango.
fc, formato, formato celda, formateo, ce, cell formatting, hardattr: Si se incluye, se borra el formato aplicado a la celda o rango en modo selección, pero
no los atributos ni el estilo ni el formato en modo edición.
e, estilo, s, style: Si se incluye, se borra el estilo asignado a la celda o rango.
o, objeto, object: Si se incluye, se borran los objetos gráficos insertados en la celda o rango.
at, atributos, ea, 'edit attributes', 'editattr': Si se incluye, se borran los atributos de edición (alineado, sangría, etc) aplicados a la celda o rango.
fe, formato edición, formato edicion, ef, edition formatting, formatted: Si se incluye, se borra el formato aplicado a la celda o rango en modo edición.
No se especifica o cadena vacía: Se borra todo.
Sub CeldaBorra( oHoja As Object, cRango As String, Optional cFlags As String )

'--------------------------------------------------------------------------------------------
' Se vacía/borra el contenido de la celda; no se elimina la celda
Dim oRango As Object, aFlags() As String, nFlags As Long, n As Integer, f As String
If IsMissing( cFlags) Then cFlags = ""
if cFlags = "" Then cFlags = "v,fh,t,c,f,fc,e,o,at,fe" ' todo / all
aFlags() = Split( cFlags, "," )
For Each f In aFlags
Select Case LCase( f)
Case "v", "valor", "value", "n", "número", "numero"
nFlags = nFlags + com.sun.star.sheet.CellFlags.VALUE
Case "fh", "fechahora", "dt", "datetime"
nFlags = nFlags + com.sun.star.sheet.CellFlags.DATETIME
Case "t", "texto", "s", "string"
nFlags = nFlags + com.sun.star.sheet.CellFlags.STRING
Case "c", "comentario", "a", "annotation"
nFlags = nFlags + com.sun.star.sheet.CellFlags.ANNOTATION
Case "f", "fórmula", "formula"
nFlags = nFlags + com.sun.star.sheet.CellFlags.FORMULA
Case "fc", "formato", "formato celda", "formateo", "ce", "cell formatting", "hardattr"
nFlags = nFlags + com.sun.star.sheet.CellFlags.HARDATTR
Case "e", "estilo", "s", "style"
nFlags = nFlags + com.sun.star.sheet.CellFlags.STYLES
Case "o", "objeto", "object"
nFlags = nFlags + com.sun.star.sheet.CellFlags.OBJECTS
Case "at", "atributos", "ea", "edit attributes", "editattr"
nFlags = nFlags + com.sun.star.sheet.CellFlags.EDITATTR
Case "fe", "formato edición", "formato edicion", "ef", "edition formatting", "formatted"
nFlags = nFlags + com.sun.star.sheet.CellFlags.FORMATTED
End Select
Next
oRango.clearContents( nFlags )
End Sub
Ejemplo de uso:
Sub main
Dim oLibro As Object, oHoja As Object
oLibro = Libro()
' Borro SÓLO los comentarios, formato de celda y formato de atributos
' del rango de celdas F7:H10, manteniendo el resto de información
CeldaBorra( oHoja, "F7:H10", "c,fc,at" )
End Sub
Dando formato a celdas y a rangos de celdas

Color de fondo de celda o rango
Establece o devuelve1 el color de fondo del objeto celda o rango de celdas que se pasa como argumento.
cColor puede ser un nombre, clave, color RGB en hexadecimal o cadena con los tres componentes RGB separados por comas, aceptados por la función ColorRGB.
Si se pasa una cadena, se sustituirá el color de fondo de la celda o rango por el valor pasado.
Si se omite el argumento, actúa como función y devuelve el color de fondo de la celda o rango. Si la celda o rango carecen de color de fondo, o el rango de
celdas tienen asignados distintos colores de fondo, devuelve -1.
Function CeldaRangoColorFondo( oCeldaRango As Object, Optional cColor As String ) As Long

'--------------------------------------------------------------------------------------------
' Devuelve -1 si la celda o rango no tiene color, o el rango de celdas tiene distintos colores de fondo
If Not IsMissing( cColor) Then oCeldaRango.setPropertyValue( "CellBackColor", ColorRGB( cColor ) )
CeldaRangoColorFondo = oCeldaRango.getPropertyValue( "CellBackColor" )
End Function
Función auxiliar ColorRGB

Función auxiliar que devuelve un valor numérico de tipo Long correspondiente al valor RGB de un color. cColor es una cadena (es indiferente al uso de mayúsculas o
minúsculas) que admite los siguientes valores:
rojo, r, red, rojo oscuro, r-, black red, rojo claro, r+, white red, amarillo, y, yellow, amarillo oscuro, y-, black yellow, amarillo claro, y+, white yellow,
verde, g, green, verde oscuro, g-, black green, verde claro, g+, white green, azul, b, blue, azul oscuro, b-, black blue, azul claro, b+, white blue, gris, gr,
grey, gris oscuro, gr-, black grey, gris claro, gr+, white grey, blanco, w, white, cian, c, cyan, magenta, m, magenta. Si r es rojo, r- es una tonalidad de
rojo más oscuro y r- es una tonalidad de rojo más claro.
El código de color hexadecimal, precedido por "&H"; por ejemplo, "&HFFFFFF" es el código para el color blanco.
Los componentes RGB expresados como valores numéricos en una cadena separados por comas; por ejemplo "255,255,255" es el código RGB para el
color blanco.
Function ColorRGB( cColor As String ) As Long

'--------------------------------------------------------------------------------------------
' Devuelve el código RGB de un color por nombre, clave o componente RGB
cColor = LCase( cColor)
Select Case cColor
Case "rojo", "r", "red": ColorRGB = RGB( 255, 0, 0)
Case "rojo oscuro", "r-", "black red": ColorRGB = RGB( 139, 0, 0)
Case "rojo claro", "r+", "white red": ColorRGB = RGB( 230, 74, 71)
Case "amarillo", "y", "yellow": ColorRGB = RGB( 255, 255, 115)

Case "amarillo oscuro", "y-", "black yellow": ColorRGB = RGB( 255, 255, 0)
Case "amarillo claro", "y+", "white yellow": ColorRGB = RGB( 255, 255, 186)
Case "verde", "g", "green": ColorRGB = RGB( 0, 128, 0)

Case "verde oscuro", "g-", "black green": ColorRGB = RGB( 0, 100, 0)
Case "verde claro", "g+", "white green": ColorRGB = RGB( 0, 255, 0)
Case "azul", "b", "blue": ColorRGB = RGB( 0, 0, 255)

Case "azul oscuro", "b-", "black blue": ColorRGB = RGB( 0, 0, 139)
Case "azul claro", "b+", "white blue": ColorRGB = RGB( 173, 216, 230)
Case "gris", "gr", "grey": ColorRGB = RGB( 128, 128, 128)

Case "gris oscuro", "gr-", "black grey": ColorRGB = RGB( 95, 95, 95)
Case "gris claro", "gr+", "white grey": ColorRGB = RGB( 211, 211, 211)
Case "blanco", "w", "white": ColorRGB = RGB( 255, 255, 255)

Case "cian", "c", "cyan": ColorRGB = RGB( 0, 255, 255)
Case "magenta", "m", "magenta": ColorRGB = RGB( 255, 0, 255)
Case Else ' vacío = negro / Valor RGB hexadecimal / valores RGB separados por comas
Dim r, g, b, aColor() As String
If Left( cColor, 2) = "&h" Then

cColor = Replace( cColor, "&h", "")
cColor = cColor & "000000"
r = cLng( "&H" & Left( cColor, 2))
g = cLng( "&H" & Mid( cColor, 3, 2))
b = cLng( "&H" & Mid( cColor, 5, 2))
Else
cColor = cColor & ",,"
aColor = Split( cColor, ",")
r = Val( aColor( 0))
g = Val( aColor( 1))
b = Val( aColor( 2))
EndIf
ColorRGB = RGB( r, g, b)
End Select
End Function
Función auxiliar Extraer componentes R, G, B

Función auxiliar que devuelve una cadena con los componentes RGB expresados como valores numéricos separados por comas, correspondientes al valor numérico
nRGB de tipo Long pasado.
Function RGBExtrae( nRGB As Long ) As String

'--------------------------------------------------------------------------------------------
' Extrae los componentes RGB de un valor Long RGB
' Devuelve una cadena "r,g,b"; por ejemplo "255,255,255" es blanco
Dim r As Long, v As Long, a As Long
' Extraigo rojo
x = 256^2
r = Int( nRGB / x )
nRGB = nRGB - ( r * x )
' Extraigo verde y azul

x = 256
v = Int( nRGB / x )
a = nRGB - ( v * x )
RGBExtrae = r & "," & v & "," & a

End Function
Fondo transparente en celda o rango

Establece o devuelve1 el porcentaje de transparencia del fondo del objeto celda o rango de celdas que se pasa como argumento. lTransparente es un valor booleano
(verdadero o falso).
Si se pasa lTransparente, se establecerá (True) o eliminará (False) la transparencia del fondo.
Si se omite el argumento, actúa como función y devuelve el estado de transparencia de la celda o rango como un valor booleano.
Function CeldaRangoFondoTransparente( oCeldaRango As Object, Optional lTransparente As Boolean ) As Boolean

'--------------------------------------------------------------------------------------------
If Not IsMissing( lTransparente) Then oCeldaRango.setPropertyValue( "IsCellBackgroundTransparent", lTransparente )
CeldaRangoFondoTransparente = oCeldaRango.getPropertyValue( "IsCellBackgroundTransparent" )
End Function
Sombra en celda o rango

Establece o devuelve1 las propiedades de la sombra del fondo del objeto celda o rango de celdas que se pasa como argumento.
La sombra de una celda o rango de celdas viene definida por una estructura ShadowFormat que contiene los siguientes datos:
Color: Color RGB como valor numérico de tipo Long

Position: Posición de la sombra respecto de la celda: arriba-derecha, abajo-derecha, etc.
ShadowWidth: Tamaño de la sombra en milésimas de cm (1000 equivale a 1 cm)
IsTransparent: True si la sombra es transparente (no se visualiza), False en caso contrario (se visualiza)
El rango puede ser de una sola celda; si no lo es, la sombra se aplica a todas las celdas del rango como un bloque.
Los argumentos de la función son:
cColor puede ser un nombre, clave, color RGB en hexadecimal o cadena con los tres componentes RGB separados por comas, aceptados por la función
ColorRGB.
cPosicion es una cadena de texto con uno de los siguientes valores (es indiferente al uso de mayúsculas o minúsculas):
Cadena vacía, none: No cambia la posición de la sombra. Si no se ha especificado antes una de las siguientes opciones, la sombra no se muestra.
bd, bajo_derecha, br, bottom_right: La sombra se muestra abajo a la derecha de la celda o rango de celdas.
bi, bajo_izquierda, bl, bottom_left: La sombra se muestra abajo a la izquierda de la celda o rango de celdas.
ad, arriba_derecha, tr, top_right: La sombra se muestra arriba a la derecha de la celda o rango de celdas.
ai, arriba_izquierda, tl, top_left: La sombra se muestra arriba a la izquierda de la celda o rango de celdas.
nAncho es un valor numérico que establece las dimensiones de la sombra en milésimas de cm (1000 es 1cm, 150 es 0,15cm = 15mm). La sombra se creará
desplazada de la celda en esas dimensiones, en las direcciones establecidas por cPosicion.
lTransparente es un valor booleano que establece que la sombra sea transparente (True, no se muestra), o no (False, se muestra).
Si se pasa cColor, se aplican las propiedades de sombra indicadas.
Si no se pasan alguno de los otros argumentos, sus valores por defecto son: cPosicion="bg", nAncho=150, lTransparente=False (abajo a la derecha,
de 15 mm, no transparente).
Si se omite el argumento cColor, el resto de argumentos se ignoran y actúa como función, devolviendo una estructura ShadowFormat con las propiedades
de sombra del objeto celda o rango de celdas pasado.
Si la celda o rango no tiene sombra asignada, o el rango tiene distintas propiedades de sombra, los valores devueltos por la función son:
Color=8421504 (que se corresponde con RGB(128,128,128) o gris al 50%), ShadowLocation=0, ShadowWidth=176, IsTransparent=False.
Function CeldaRangoSombra( oCeldaRango As Object, Optional cColor As String, Optional cPosicion As String, _
Optional nAncho As Long, Optional lTransparente As Boolean ) As com.sun.star.table.ShadowFormat
'--------------------------------------------------------------------------------------------
Dim oSombra As New com.sun.star.table.ShadowFormat
If Not IsMissing( cColor) Then
If IsMissing( cPosicion) Then cPosicion = "bd"
If IsMissing( nAncho) Then nAncho = 150
If IsMissing( lTransparente) Then lTransparente = False
oSombra.Color = ColorRGB( cColor )

Select Case LCase( cPosicion)
Case "", "none"
oSombra.Location = com.sun.star.table.ShadowLocation.NONE
Case "bd", "bajo_derecha", "br", "bottom_right"
oSombra.Location = com.sun.star.table.ShadowLocation.BOTTOM_RIGHT
Case "bi", "bajo_izquierda", "bl", "bottom_left"
oSombra.Location = com.sun.star.table.ShadowLocation.BOTTOM_LEFT
Case "ad", "arriba_derecha", "tr", "top_right"
oSombra.Location = com.sun.star.table.ShadowLocation.TOP_RIGHT
Case "ai", "arriba_izquierda", "tl", "top_left"
oSombra.Location = com.sun.star.table.ShadowLocation.TOP_LEFT
End Select
oSombra.ShadowWidth = nAncho
oSombra.IsTransparent = lTransparente
oCeldaRango.setPropertyValue( "ShadowFormat", oSombra )

EndIf
CeldaRangoSombra = oCeldaRango.getPropertyValue( "ShadowFormat" )
End Function
Ejemplo de uso:
Sub main
Dim oLibro As Object, oHoja As Object, oRango As Object, s
oLibro = Libro()
oRango = CeldaActiva()
' Establecer la sombra
CeldaRangoSombra( oRango , "gr+", "bd", "160", False )
' Obtener los valores de la sombra

s = CeldaRangoSombra( oRango )
Print "Color de sombra: " & s.Color
Print "Posicion de sombra: " & s.Location
Print "Ancho de sombra: " & s.ShadowWidth
Print "Transparencia de sombra: " & s.IsTransparent
End Sub
Justificación horizontal en celda o rango

Establece o devuelve1 la propiedad justificación horizontal del objeto celda o rango de celdas que se pasa como argumento (ver Alineación del texto).
La justificación horizontal de una celda o rango de celdas viene definida por una enumeración CellHoriJustify que puede ser:
0: justificación horizontal Estándar: Los textos se alinean a la izquierda, y los valores numéricos (números, fechas, horas, monedas) a la derecha.
1: justificación horizontal Izquierda: El contenido de la celda se alinea pegado al borde izquierdo.
2: justificación horizontal Centro horizontal: El contenido de la celda se alinea centrado horizontalmente en la celda.
3: justificación horizontal Derecha: El contenido de la celda se alinea pegado al borde derecho.
4: justificación horizontal Justificado: Si la celda tiene activa la propiedad Ajustar texto automáticamente y se muestra como ocupando varias líneas, el
contenido de la celda se alinea justificado entre los bordes derecho e izquierdo (aumentando el tamaño de los espacios en blanco), a excepción de la
(supuesta) última línea que se alinea a la izquierda (y en la que los espacios en blanco no cambian de tamaño).
5: justificación horizontal Repetir: El contenido de la celda se repite (completo) tantas veces como sea necesario para rellenar toda la celda a lo ancho.
El argumento cJustificacionH de la función es una cadena que puede tomar uno de los siguientes valores (es indiferente al uso de mayúsculas o minúsculas):
0, cadena vacía, e, estándar, s, standard: Se aplica justificación horizontal Estándar.

1, i, izquierda, l, left: Se aplica justificación horizontal Izquierda.
2, c, centro, center: Se aplica justificación horizontal Centro horizontal.
3, d, derecha, r, right: Se aplica justificación horizontal Derecha.
4, j, justificado, b, block: Se aplica justificación horizontal Justificado.
5, rep, repetir, repeat: Se aplica justificación horizontal Repetir.
Si se omite el argumento cJustificacionH, actúa como función, devolviendo un valor entero correspondiente a la justificación horizontal del objeto celda o
rango de celdas pasado.
Si el objeto rango pasado tiene celdas con distintas propiedades de justificación horizontal, la función devuelve 0.
Function CeldaRangoJustificacionH( oCeldaRango As Object, _

Optional cJustificacionH As String ) As Integer
'--------------------------------------------------------------------------------------------
If Not IsMissing( cJustificacionH) Then
Select Case LCase( cJustificacionH)
Case "0", "", "e", "estándar", "s", "standard"
oCeldaRango.setPropertyValue( "HoriJustify", com.sun.star.table.CellHoriJustify.Standard )
Case "1", "i", "izquierda", "l", "left"
oCeldaRango.setPropertyValue( "HoriJustify", com.sun.star.table.CellHoriJustify.LEFT )
Case "2", "c", "centro", "center"
oCeldaRango.setPropertyValue( "HoriJustify", com.sun.star.table.CellHoriJustify.CENTER )
Case "3", "d", "derecha", "r", "right"
oCeldaRango.setPropertyValue( "HoriJustify", com.sun.star.table.CellHoriJustify.RIGHT )
Case "4", "j", "justificado", "b", "block"
oCeldaRango.setPropertyValue( "HoriJustify", com.sun.star.table.CellHoriJustify.BLOCK )
Case "5", "rep", "repetir", "repeat"
oCeldaRango.setPropertyValue( "HoriJustify", com.sun.star.table.CellHoriJustify.REPEAT )
End Select
EndIf
CeldaRangoJustificacionH = oCeldaRango.getPropertyValue( "HoriJustify" )
End Function
Justificación vertical en celda o rango

Establece o devuelve1 la propiedad justificación vertical del objeto celda o rango de celdas que se pasa como argumento (ver Alineación del texto).
La justificación vertical de una celda o rango de celdas viene definida por una enumeración CellVertJustify que puede ser:
0: justificación vertical Estándar: El contenido de la celda se alinea pegado al borde inferior.

1: justificación vertical Arriba: El contenido de la celda se alinea pegado al borde superior.
2: justificación vertical Centro vertical: El contenido de la celda se alinea centrado verticalmente en la celda.
3: justificación vertical Abajo: El contenido de la celda se alinea pegado al borde inferior.
El argumento cJustificacionV de la función es una cadena que puede tomar uno de los siguientes valores (es indiferente al uso de mayúsculas o minúsculas):
0, cadena vacía, e, estándar, s, standard: Se aplica justificación horizontal Estándar.

1, s, superior, u, up: Se aplica justificación horizontal Arriba.
2, m, medio, c, centro, center: Se aplica justificación horizontal Centro vertical.
3, i, inferior, d, down: Se aplica justificación horizontal Abajo.
Si se omite el argumento cJustificacionV, actúa como función, devolviendo un valor entero correspondiente a la justificación vertical del objeto celda o
rango de celdas pasado.
Si el objeto rango pasado tiene celdas con distintas propiedades de justificación vertical, la función devuelve 0.
Function CeldaRangoJustificacionV( oCeldaRango As Object, _

Optional cJustificacionV As String ) As Integer
'--------------------------------------------------------------------------------------------
If Not IsMissing( cJustificacionV) Then
Select Case LCase( cJustificacionV)
oCeldaRango.setPropertyValue( "VertJustify", com.sun.star.table.CellVertJustify.Standard )
Case "1", "s", "superior", "t", "top"
oCeldaRango.setPropertyValue( "VertJustify", com.sun.star.table.CellVertJustify.TOP )
Case "2", "m", "medio", "c", "centro", "center"
oCeldaRango.setPropertyValue( "VertJustify", com.sun.star.table.CellVertJustify.CENTER )
Case "3", "i", "inferior", "b", "bottom"
oCeldaRango.setPropertyValue( "VertJustify", com.sun.star.table.CellVertJustify.BOTTOM )
End Select
EndIf
CeldaRangoJustificacionV = oCeldaRango.getPropertyValue( "VertJustify" )
End Function
Orientación del texto en celda o rango

Establece o devuelve1 la propiedad orientación del texto mostrado dentro del objeto celda o rango de celdas que se pasa como argumento (ver Orientación del texto).
La orientación del texto de una celda o rango de celdas viene definida por una enumeración CellOrientation que puede ser:
0: orientación Estándar: El texto se muestra de izquierda a derecha.

1: orientación Superior Inferior: El texto se muestra de arriba a abajo.
2: orientación Inferior Superior: El texto se muestra de abajo a arriba.
3: orientación Vertical: El contenido de la celda se muestra en disposición vertical.
El argumento cOrientacion de la función es una cadena que puede tomar uno de los siguientes valores (es indiferente al uso de mayúsculas o minúsculas):
0, cadena vacía, e, estándar, s, standard: Se aplica orientación Estándar.

1, si, superiorinferior, tb, topbottom: Se aplica orientación Superior Inferior.
2, is, inferiorsuperior, tp, bottomtop: Se aplica orientación Inferior Superior.
3, v, vertical, s, stacked: Se aplica orientación Vertical.
Si se omite el argumento cOrientacion, actúa como función, devolviendo un valor entero correspondiente a la orientación del objeto celda o rango de
celdas pasado.
Si el objeto rango pasado tiene celdas con distintas propiedades de orientación, la función devuelve 0.
Function CeldaRangoOrientacion( oCeldaRango As Object, _

Optional cOrientacion As String ) As Integer
'--------------------------------------------------------------------------------------------
If Not IsMissing( cOrientacion) Then
Select Case LCase( cOrientacion)
oCeldaRango.Orientation = com.sun.star.table.CellOrientation.STANDARD
Case "1", "si", "superiorinferior", "tb", "topbottom"
oCeldaRango.Orientation = com.sun.star.table.CellOrientation.TOPBOTTOM
Case "2", "is", "inferiorsuperior", "tp", "bottomtop"
oCeldaRango.Orientation = com.sun.star.table.CellOrientation.BOTTOMTOP
Case "3", "v", "vertical", "s", "stacked"
oCeldaRango.Orientation = com.sun.star.table.CellOrientation.STACKED
End Select
EndIf
CeldaRangoOrientacion = oCeldaRango.getPropertyValue( "Orientation" )
End Function
Referencia de rotación en celda o rango

Establece o devuelve1 la propiedad orientación del texto mostrado dentro del objeto celda o rango de celdas que se pasa como argumento (ver Orientación del texto).
La orientación del texto de una celda o rango de celdas viene definida por una enumeración CellOrientation que puede ser:
0: orientación Estándar: No he encontrado documentación acerca de esta opción.

1: orientación Borde Inferior: El contenido de la celda se expande tomando como arista de referencia la esquina inferior.
2: orientación Borde Superior: El contenido de la celda se expande tomando como arista de referencia la esquina superior.
3: orientación Dentro: El contenido de la celda se expande sólo en el interior de la celda.
El argumento cReferencia de la función es una cadena que puede tomar uno de los siguientes valores (es indiferente al uso de mayúsculas o minúsculas):
0, d, dentro, c, center: Se aplica orientación Dentro (centro).

1, bs, bordesuperior, t, top: Se aplica orientación Borde Superior.
2, cadena vacía, e, estándar, s, standard: Se aplica orientación Estándar.
3, bi, bordeinferior, b, bottom: Se aplica orientación Borde Inferior.
Si se omite el argumento cReferencia, actúa como función, devolviendo un valor entero correspondiente a la orientación del objeto celda o rango de celdas
pasado.
Si el objeto rango pasado tiene celdas con distintas propiedades de orientación, la función devuelve 0.
NOTA: La referencia de rotación "Dentro" se obtiene aplicando el valor com.sun.star.table.CellVertJustify.STANDARD, mientras que la referencia de rotación
"Estándar" se obtiene aplicando el valor com.sun.star.table.CellVertJustify.CENTER. Esto parece ser una incongruencia, pero no es erróneo (por nuestra parte).
Function CeldaRangoReferenciaRotacion( oCeldaRango As Object, _

Optional cReferencia As String ) As Integer
'--------------------------------------------------------------------------------------------
If Not IsMissing( cReferencia) Then
' He detectado una posible incongruencia
' al asignar com.sun.star.table.CellVertJustify.STANDARD se obtiene una referencia rotación Dentro (CENTER)
' al asignar com.sun.star.table.CellVertJustify.CENTER se obtiene una referencia rotación no documentada, asumo que es estándar
' no es un error por nuestra parte
Select Case LCase( cReferencia)
Case "0", "d", "dentro", "c", "center"
oCeldaRango.RotateReference = com.sun.star.table.CellVertJustify.STANDARD
Case "1", "bs", "bordesuperior", "t", "top"
oCeldaRango.RotateReference = com.sun.star.table.CellVertJustify.TOP
oCeldaRango.RotateReference = com.sun.star.table.CellVertJustify.CENTER
Case "3", "bi", "bordeinferior", "b", "bottom"
oCeldaRango.RotateReference = com.sun.star.table.CellVertJustify.BOTTOM
End Select
EndIf
CeldaRangoReferenciaRotacion = oCeldaRango.RotateReference
End Function
Ángulo del texto en celda o rango

Establece o devuelve1 la propiedad ángulo del texto (ver Orientación del texto) mostrado dentro del objeto celda o rango de celdas que se pasa como argumento.
La ángulo del texto de una celda o rango de celdas viene definida por el argumento nAngulo de la función, que es un valor de tipo Long entre 0 y 35999 que indica el
ángulo en centésimas de grado que toma el texto, siendo:
0: se corresponde con un ángulo de 00 (la posición de la manecilla de las horas en un reloj a las 03:00 horas)
9000: se corresponde con un ángulo de 900 (la posición a las 0:00 horas)
Si se omite el argumento nAngulo, actúa como función, devolviendo un valor entero correspondiente al ángulo en grados que toma el texto del objeto celda
o rango de celdas pasado.
Si el objeto rango pasado tiene celdas con distintas propiedades de ángulo, la función devuelve 0.
Function CeldaRangoAngulo( oCeldaRango As Object, Optional nAngulo As Long ) As Long

'--------------------------------------------------------------------------------------------
If Not IsMissing( nAngulo) Then
If nAngulo<0 OR nAngulo>35999 Then nAngulo = 0
oCeldaRango.setPropertyValue( "RotateAngle", nAngulo )
EndIf
CeldaRangoAngulo = oCeldaRango.getPropertyValue( "RotateAngle" )
End Function
Ajustar texto en celda

Establece o devuelve1 la propiedad Ajustar texto en celda (ver Propiedades del texto) del texto contenido dentro del objeto celda o de las celdas del rango de celdas que
se pasa como argumento.
El ajusta del texto viene definido por el argumento lAjustarTexto de la función, que es un valor de tipo Booleano (verdadero o falso) que:
Si se pasa como True activa el ajuste del texto. Al activar el ajuste de texto, la fila tomará una nueva altura de forma automática suficiente para
mostrar todo el texto contenido dentro del ancho de la celda, salvo que la fila haya sido personalizada con una altura previamente, en cuyo caso,
prevalece la altura personalizada.
Si se pasa como False desactiva el ajuste del texto. Al desactivar el ajuste de texto, la fila recupera la altura que tenía previamente,, salvo que la fila
haya sido personalizada con una altura previamente a ser activado el ajuste de texto, en cuyo caso, prevalece la altura personalizada.
Si se omite el argumento lAjustarTexto, actúa como función, devolviendo un valor booleano correspondiente al estado de la propiedad Ajustar texto en
celda del objeto celda o rango de celdas pasado.
Si el objeto rango pasado tiene celdas con distintas propiedades de Ajustar texto en celda, la función devuelve False.
Function CeldaRangoAjustarTexto( oCeldaRango As Object, Optional lAjustarTexto As Boolean ) As Boolean

'--------------------------------------------------------------------------------------------
If Not IsMissing( lAjustarTexto) Then oCeldaRango.setPropertyValue( "IsTextWrapped", lAjustarTexto )
CeldaRangoAjustarTexto = oCeldaRango.getPropertyValue( "IsTextWrapped" )
End Function
Rellenar una celda, rango o grupo de rangos

Esta subrutina muestra los distintos modos de proceder según el objeto que se le pasa, que puede ser un objeto celda (ScCellObj), un objeto rango (ScCellRangeObj) o
un objeto de rangos múltiples (ScCellRangesObj).
Se pretende rellenar con un valor xValor, y opcionalmente aplicar un formato cFormato la celda, rango de celdas o rangos múltiples que se pasan a la subrutina.
En el caso de que el formato no exista previamente en el banco de formatos del libro, se agregará.
Sub CeldaRangoSRellenar( oCeldaRangoS As Object, xValor, Optional cFormato As String )

'--------------------------------------------------------------------------------------------
Dim nFormato As Long, oLibro As Object
oLibro = Libro()
nFormato = IdFormatoNumerico( oLibro, cFormato )
If HasUnoInterfaces( oCeldaRangoS, "com.sun.star.lang.XServiceInfo" ) Then
If oCeldaRangoS.SupportsService( "com.sun.star.sheet.SheetCellRanges" ) Then
'Se ha pasado un rango múltiple (varios rangos)
subSetRangos( oCeldaRangoS, xValor, nFormato )
ElseIf oCeldaRangoS.SupportsService( "com.sun.star.table.CellRange" ) Then
' Se ha pasado un rango
subSetRango( oCeldaRangoS, xValor, nFormato )
ElseIf oCeldaRangoS.SupportsService( "com.sun.star.sheet.SheetCell" ) Then
' Se ha pasado una celda
subSetCelda( oCeldaRangoS, xValor, nFormato )
End If
End If
End Sub
Recorrer los rangos de un grupo de rangos

Esta subrutina toma un grupo de rangos cuyas celdas queremos rellenar con un valor xValor y aplicarles un formato nFormato; para lograrlo, toma cada uno de los
rangos y los envía a la subrutina subSetRango.
Sub subSetRangos( oRangos As Object, xValor, nFormato As Long )

'--------------------------------------------------------------------------------------------
Dim i As Long
For i = 0 To oRangos.getCount - 1
subSetRango( oRangos.GetByIndex( i ), xValor, nFormato )
Next
End Sub
Recorrer las celdas de un rango

Esta subrutina toma un rango cuyas celdas queremos rellenar con un valor xValor y aplicarles un formato nFormato; para lograrlo, toma cada una de las celdas y las
envía a la subrutina subSetCelda.
Sub subSetRango( oRango As Object, xValor, nFormato As Long )

'--------------------------------------------------------------------------------------------
Dim i As Long, j As Long
For i = 0 To oRango.getColumns.getCount - 1
For j = 0 To oRango.getRows.getCount - 1
subSetCelda( oRango.GetCellByPosition( i, j ), xValor, nFormato )
Next
Next
End Sub
Cambiar valor y aplicar formato numérico a una celda

Esta subrutina rellenar una celda con un valor xValor y le aplica un formato nFormato.
Sub subSetCelda( oCelda As Object, xValor, nFormato As Long )

'--------------------------------------------------------------------------------------------
oCelda.Value = xValor
oCelda.setPropertyValue( "NumberFormat", nFormato )
End Sub
Id de formato numérico
Esta función recibe un formato numérico en cFormatoNumerico. Busca el formato en el banco de formatos del objeto libro oLibro pasado como argumento, y si no
existe, lo agrega; devuelve el Id o identificador único del formato numérico para ese libro.
Function IdFormatoNumerico( oLibro As Object, cFormatoNumerico As String ) As Long

'--------------------------------------------------------------------------------------------
Dim cCodigoLocal As String, nIdFormato As Long
cCodigoLocal = oLibro.getPropertyValue( "CharLocale" )
nIdFormato = oLibro.getNumberFormats.queryKey( cFormatoNumerico, cCodigoLocal, False )
If nIdFormato = -1 Then ' formato no definido, se agrega
nIdFormato = oLibro.getNumberFormats.AddNew( cFormatoNumerico, cCodigoLocal )
End If
IdFormatoNumerico = nIdFormato
End Function
Barras de estado, fórmulas, progreso

Ocultar / Mostrar barra de Estado o Fórmulas
Sub Barra_Visible(cBarra As String, Optional lVisible As Boolean)
' Muestra u oculta la barra de estado o la barra de fórmulas
' Nombres de las barras en Calc:
' Fórmulas: InputLineVisible
' Estado: StatusBarVisible
Dim oFrame As Object

Dim oDispatch As Object
Dim args(0) As new com.sun.star.beans.PropertyValue
oFrame = ThisComponent.CurrentController.Frame
If IsMissing(lVisible) Then lVisible = true
args(0).Name = cBarra
args(0).Value = lVisible
oDispatch = createUnoService("com.sun.star.frame.DispatchHelper")
oDispatch.executeDispatch(oFrame, ".uno:" & cBarra , "", 0, args())
End Sub
Barra de Estado y Barra de progreso

Esta subrutina utiliza la función PadR
Sub BarraEstado( cTexto as string, optional nLongitud as integer, _

optional nMax as long, optional nValor as long )
' Establece el texto de la barra de estado y los valores de la barra de progreso
' cTexto: Texto a mostrar. Si es una cadena vacía, reinicia la barra de estado
' nLongitud: Longitud del texto; conviene fijar un valor mayor
' al de todos los textos a mostrar
' nMax: Valor máximo de la barra de progreso
' nValor: Valor actual de la barra de progreso
Dim x as object
Set x = ThisComponent.CurrentController.StatusIndicator
If cTexto = "" Then ' Cerrar Barra de estado y restaurar estado
x.Reset ' elimina los valores actuales de texto y de la barra de progreso
x.End ' reestablece el funcionamiento por defecto de la barra de estado
Else
x.Start( PadR(cTexto,nLongitud),nMax )
x.SetValue(nValor) ' también es válido x.Value = nActual
Endif
End Sub
Ejemplo de uso
Sub Ejemplo()
Dim nAct as long, nTot as long
nTot = 100
nAct = 0
BarraEstado "Iniciando proceso", 60, nTot, nAct
Wait 1000
For nAct=0 To nTot
BarraEstado "Procesando " & nAct & " de " & nTot, 60, nTot, nAct
Wait 100
Next
BarraEstado "Proceso terminado", 60, nTot, nTot
Wait 1000
BarraEstado ""
End Sub
Exportar
Exportar en formato Excel
Sub Documento_ExportarAExcel( ByVal cNombreyRuta as String )
' Exporta el documento activo en formato Excel 97
' Hay que tener en cuenta los problemas con la exportación a Excel
Dim aArg(1) As New com.sun.star.beans.PropertyValue
aArg(0).Name = "InteractionHandler"
aArg(0).Value = ""
aArg(1).Name = "FilterName"
aArg(1).Value = "MS Excel 97"
cNombreyRuta = ConvertToURL( cNombreyRuta )
ThisComponent.StoreToURL( cNombreyRuta , aArg() )
End Sub
Exportar en formato Excel con contraseña

Sub Documento_ExportarAExcel_Password( ByVal cNombreyRuta as String )
' Exporta el documento activo en formato Excel 97 con contraseña
' Hay que tener en cuenta los problemas con la exportación a Excel
Dim aArg(1) As New com.sun.star.beans.PropertyValue
aArg(0).Name = "InteractionHandler"
aArg(0).Value = ""
aArg(1).Name = "FilterName"
aArg(1).Value = "MS Excel 97"
aArg(2).Name = "ModifyPasswordInfo"
aArg(2).Value = 56789 ' inserta aquí una contraseña numérica
cNombreyRuta = ConvertToURL( cNombreyRuta )
ThisComponent.StoreToURL( cNombreyRuta , aArg() )
End Sub
Devolver las celdas seleccionadas como una tabla HTML

Function Seleccion2TablaHTML() As String
Dim oSel As Object
Dim lSeguir As Boolean
Dim col As Long, fila As Long
Dim cFin As Long, fFin As Long
Dim c As String
oSel = ThisComponent.getCurrentSelection()
lSeguir=False
Select Case oSel.getImplementationName()

Case "ScCellObj"
MsgBox "Sólo has seleccionado una celda. Son necesarias más"
Case "ScCellRangeObj"
lSeguir = True
Case "ScCellRangesObj"
MsgBox "No se permite seleccionar varios rangos"
Case Else
MsgBox "Seleccione un rango de celdas, por favor"
End Select
' Si es un rango de celdas, leemos sus límites

If lSeguir Then
cFin = oSel.getColumns().getCount() - 1
fFin = oSel.getRows().getCount() - 1
' Recorremos las celdas y creamos la tabla

c = "<table style='background-color:#eaeaea;border:2px solid #555;'><tbody>"
For fila = 0 To fFin
c = c & "<tr>"
For col = 0 To cFin
c = c & "<td style='border:1px solid #666;'>" & oSel.getCellByPosition(col,fila).getString & "</td>"
Next ' col
c = c & "</tr>"
Next ' fila
c = c & "</tbody></table>"
EndIf
Seleccion2TablaHTML = c
End Function
Ejemplo de tabla obtenida:
enero febrero marzo

Tienda 1 100 101 102
Tienda 2 120 121 122
Tienda 3 140 141 142
Tienda 4 160 161 162
Otras
Copiar una celda (con executeDispatch)
Sub Celda_Copiar( cCelda as string )
Dim a(1) As New com.sun.star.beans.PropertyValue
Dim oDispatch as Object, oFrame as Object
a(0).Name = "ToPoint"
a(0).Value = cCelda ' por ejemplo, "$B$3" o "B3"
oDispatch.executeDispatch(oFrame, ".uno:GoToCell", "", 0, a())

oDispatch.executeDispatch(oFrame, ".uno:Copy", "", 0, Array())
End Sub
Pegar en una celda (con executeDispatch)

Sub Celda_Pegar( cCelda as string )
Dim a(1) As New com.sun.star.beans.PropertyValue
Dim oDispatch as Object, oFrame as Object
a(0).Name = "ToPoint"
a(0).Value = cCelda ' por ejemplo, "$B$3" o "B3"
oDispatch.executeDispatch(oFrame, ".uno:GoToCell", "", 0, a())

oDispatch.executeDispatch(oFrame, ".uno:Paste", "", 0, Array())
End Sub
Extraer URL y Texto de un hiperenlace

Sub Main()
Dim cUrl As String, cTexto As String
Dim oCelda As Object
oCelda = ThisComponent.getCurrentSelection()
Extrae_URL_Texto ( oCelda, cUrl, cTexto )
MsgBox "El texto es " & cTexto
MsgBox "La URL es " & cUrl
End Sub
Sub Extrae_URL_Texto(oCelda As Object, ByRef cUrl As String, ByRef cTexto As String)

' Extrae la url y el texto de una celda que contiene un hiperenlace
Dim oCampos As Object
oCampos = oCelda.TextFields
If oCampos.Count > 0 Then
oCampo = oCampos(0)
If oCampo.URL > "" Then
cUrl = oCampo.URL
cTexto = oCampo.Representation
EndIf
EndIf
End Sub
Notas
1 ↑ Función que actúa como Set/Get según se pase o no el argumento opcional; si se pasa el argumento es una función Set que establece el valor; si no se pasa, es una
función Get que devuelve el valor actual.
Enlaces
Generar PDF gratis
Listas de enlaces con WordPress
Sumas y restas para niños
Clases particulares
Cual es mi IP
Gestión de reservas para pequeños y

medianos hostales, hoteles, pensiones y
albergues
Inicio
Atrás
Arriba
Macros para OpenOffice Impress

Obtenido de «https://wiki.open-office.es/index.php?title=Macros_en_Basic_para_OpenOffice_Calc&oldid=14403»
Categorías: Basic Ver.4.1.x Ver.3.4.x Ver.3.3.x Ver.3.2.x Ver.3.1.x
Modificada el 22 jun 2016 14:19. Visitas: 85 566

Macros en Basic para Calc - Apache OpenOffice Basic

Cargado por

Información del documento

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

Macros en Basic para Calc - Apache OpenOffice Basic

Cargado por

Copyright:

Formatos disponibles

27/12/23, 8:49 Macros en Basic para Calc - Apache OpenOffice Basic

Macros para Apache OpenOffice Calc

Trabajando con Filas

Trabajando con Columnas

Trabajando con celdas y rangos de celdas

Dando formato a celdas y a rangos de celdas

Barras de estado, fórmulas, progreso

+ Macros para Calc en nuestro blog (http://blog.open-office.es/basic/macros/macros_calc/)

Trabajando con libros y hojas

Function Libro() As Object

Abrir un libro existente

Function LibroAbrir( cRuta As String, Optional aOpciones() ) As Object

Dim miLibro As Object

Abrir un libro Calc pero que no sea visible (oculto):

Dim miLibro As Object, aOpc(1) As New com.sun.star.bean.PropertyValue

Dim miCsv As Object, aOpc(1) As New com.sun.star.bean.PropertyValue

Para conocer más propiedades al abrir un documento, ver Service MediaDescriptor

Para conocer más opciones de filtro, ver Propiedad FilterOptions (https://wiki.openoffice.org/wiki/Documentation/DevGuide/Spreadsheets/Filter_Options).

Abrir un libro con macros existente

Function LibroConMacrosAbrir( cRuta As String ) As Object

Verifica si el documento es un libro de Calc

Function DocEsLibroCalc( oLibro As Object ) As Boolean

Hoja de cálculo activa

Function HojaActiva( oLibro As Object ) As Object

Contar número de hojas

Function NumeroHojas( oLibro As Object ) As Long

Hoja por índice

Function HojaPorIndice( oLibro As Object, nHoja As Long ) As Object

Hoja por nombre

Function HojaPorNombre( oLibro As Object, cHoja As String ) As Object

Recorrer (iterar,enumerar) todas las hojas

Sub LibroRecorrerHojas( oLibro As Object )

For Each oHoja In oHojas

Sub LibroRecorrerHojas2( oLibro As Object )

Function LibroNuevaHoja( oLibro As Object, cNombre As String ) As Object

Copiar / Mover hoja a otro libro

Sub LibroCopiarHoja( oLibroOrg As Object, cLibroDst As String, lCopiar As Boolean )

Dim oLibroOrg As Object, oLibroDst As Object

Trabajando con Filas

Function Fila( oHoja As Object, nFila As Long ) As Object

Function FilaIndex( nFila As Long ) As Long

Establecer u obtener el alto de fila; ocultar o mostrar filas

Function FilaAlto( oFila As Object, Optional nAlto As Long ) As Long

Establecer u obtener el alto de fila en cm; ocultar o mostrar filas

Function FilaAltoCm( oFila As Object, Optional nAlto As Single ) As Single

Establecer u obtener si la fila es visible

Si se pasa el argumento lVisible, la fila se hará visible (True) o se ocultará (False)

Function FilaVisible( oFila As Object, Optional lVisible As Boolean ) As Boolean

Establece u obtiene si la fila es salto de página

Function FilaEsSaltoPagina( oFila As Object, Optional lSaltoPagina As Boolean ) As Boolean

Insertar una o más filas

Sub FilaInserta( oHoja As Object, nTrasFila As Long, nFilasInserta As Long )

Eliminar una o más filas

Sub FilaElimina( oHoja As Object, nDesdeFila As Long, nFilasElimina As Long )

Trabajando con Columnas

Function Columna( oHoja As Object, xColumna ) As Object

Function ColumnaIndex( xColumna ) As Long

Establecer u obtener el ancho de columna; mostrar u ocultar columnas

Function ColumnaAncho( oColumna As Object, Optional nAncho As Long ) As Long

Establecer u obtener el ancho de columna en cm; mostrar u ocultar columnas

Function ColumnaAnchoCm( oColumna As Object, Optional nAncho As Single ) As Single

Establecer u obtener si la columna es visible

Si se pasa el argumento lVisible, la columna se hará visible (True) o se ocultará (False)

Function ColumnaVisible( oColumna As Object, Optional lVisible As Boolean ) As Boolean