Uso de cookies

Utilizamos cookies propias y de terceros para mejorar nuestros servicios y mostrarle publicidad relacionada con sus preferencias mediante el análisis de sus hábitos de navegación. Si continúa navegando, consideramos que acepta su uso. Para obtener más información o bien conocer cómo cambiar la configuración lea nuestra Política de cookies

Revisión a fecha de 14:19 22 jun 2016; Salva (Discusión | contribuciones)

(dif) ← Revisión anterior | Revisión actual (dif) | Revisión siguiente → (dif)

Macros para Apache OpenOffice Calc

Trabajando con libros y hojas

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

Exportar

Eventos

Otras


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.

Para conocer más opciones de filtro, ver Propiedad FilterOptions.

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
   oRango = Rango( oHoja, cRango )
   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
	oRangoOrg = Rango( oHojaOrg, cRangoOrg )
	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
 
   oRangoOrg = Rango( oHojaOrg, cRangoOrg )
   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
   oRango = Rango( oHoja, cRango )
   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()
   oHoja = HojaActiva( oLibro )
   ' 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()
   oHoja = HojaActiva( oLibro )
   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)
      Case "0", "", "e", "estándar", "s", "standard"
         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)
      Case "0", "", "e", "estándar", "s", "standard"
         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
      Case "2", "", "e", "estándar", "s", "standard"
         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)
  • 18000: se corresponde con un ángulo de 1800 (la posición a las 9:00 horas)
  • 27000: se corresponde con un ángulo de 2700 (la posición a las 6: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:

enerofebreromarzo
Tienda 1100101102
Tienda 2120121122
Tienda 3140141142
Tienda 4160161162

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
 
  oFrame = ThisComponent.CurrentController.Frame
  oDispatch = createUnoService("com.sun.star.frame.DispatchHelper")
 
  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
 
  oFrame = ThisComponent.CurrentController.Frame
  oDispatch = createUnoService("com.sun.star.frame.DispatchHelper")
 
  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.


Obtenido de «https://wiki.open-office.es/index.php?title=Macros_en_Basic_para_OpenOffice_Calc&oldid=14403»
Modificada el 22 jun 2016 14:19.   Visitas: 88 103