Apache OpenOffice Wiki - User contributions [en]

Talk:ES/Documentation

2013-06-11T16:10:29Z

Mauriciobaeza: /* Discusión o silencio */

== Información desactualizada y duplicidad de caminos ==
Esta página tiene enlaces a páginas en inglés que ya disponen de su equivalente en español.
Considero que debería existir una sóla página desde la cual surja toda la documentación de la wiki en español, y que esa página debería ser [[ES]]
Por ello sugiero:

* Agregar en la página [[ES]] aquellos enlaces que sí tiene esta página y que todavía no existe equivalente en español
* Sustituir su contenido por una redirección a [[ES]] con un comando
:: <nowiki>#REDIRECT [[ES]]</nowiki>

== Plantilla ==
Por otra parte opino que sería bueno crear una plantilla con este contenido...

<pre><nowiki>
<div style="border: 1px solid rgb(140, 45, 6); margin: 0px 5px 5px; padding: 1px; float: right; width: 300px;
background-color: rgb(255, 255, 255);" id="contrib"><div style="padding: 2px; background-color: rgb(140, 45, 6);
color: rgb(255, 255, 255); font-weight: bold; text-align: center;">Quieres ayudar?</div>

{|
|-
|
*[[ES/Participar|Cómo participar]]
*[[ES/AyudaWiki|Cómo contribuir]]
*[[ES/AyudaWiki|Politicas de edición]]
*[[ES/PanelDelProyecto|Panel del proyecto]]
|
*[[Documentation/Wishlist|Lista de Deso]] <--------------- No sé muy bien qué es esto
*[[:Category:ES/AyudaWiki/Ayuda|Página que necesitan ayuda!]]
*[[:Category:ES/AyudaWiki/Pendientes|Páginas pendientes]]
*[[:Category:ES/AyudaWiki/Candidatas|Páginas candidatas]]
|}

</div>
</nowiki></pre>

...con los enlaces correctos a las páginas actuales en español.
Esta plantilla:
* podría ser agregada a todas las páginas en español que incluirían en su encabezado una plantilla general en la que se podría enlazar fácilmente cualquier mensaje que se quiera transmitir sin realizar más que unos simples cambios, por ejemplo <nowiki>{{EncabezadoES}}</nowiki>
* se crearán las plantillas/categorías (si no existen ya) para enlazar a las páginas que necesitan ayuda, páginas pendientes, páginas candidatas.
* Veo acertado incluir también un panel del proyecto donde para cada apartado pueda indicarse quienes han sido los colaboradores que han ayudado a realizarlo, o a quienes se les ha asignado-encargado su realización o mantenimiento.

== Discusión o silencio ==
Entenderé que si tras <del>15 días</del> 72 horas a partir de la fecha de esta discusión nadie comenta nada, se sobreentiende que es aceptado el cambio por la comunidad.
Saludos

--[[User:Salva|Salva]] ([[User talk:Salva|talk]]) 10:56, 11 June 2013 (UTC)

Totalmente de acuerdo
--[[User:mauriciobaeza|mauriciobaeza]] ([[User talk:mauriciobaeza|talk]]) 11:08, 11 June 2013 (UTC)

Talk:ES/Documentation

2013-06-11T16:09:39Z

Mauriciobaeza: /* Discusión o silencio */

ES/Manuales/GuiaAOO/TemasAvanzados/Macros/Python/PythonCalc/ReferenciaARangos

2013-05-24T04:29:58Z

Mauriciobaeza: /* Referencia a varios rangos de celdas */

{{DISPLAYTITLE: Referencia a rangos}}

Seguro que sabes, si eres usuario habitual de una hoja de calculo, que el trabajo con rangos es esencial en estos documentos, por lo mismo, el trabajo con rangos desde código es igualmente importante, ya vimos como aseguramos que estamos trabajando en una hoja de calculo, así que dejo a tu criterio esta validación. En la siguientes secciones nos centraremos en aprender como hacer referencia a distintos tipos de rangos para después poder manipularlos, darles formato o hacer con ellos lo que queramos.

== Referencia a celdas individuales ==

Podemos acceder a las celdas de una hoja de calculo de varias maneras, principalmente por su nombre o por su posición, pero muy importante, primero tienes que acceder a la hoja donde están las celdas que te interesa manipular, como acceder a hojas es un tema que ya hemos tratado, pero en cada ejemplo podrás notar que repasamos estos conocimientos, la forma más simple de hacer referencia a una celda es por su nombre.
<source lang=python>
activa = doc.getCurrentController().getActiveSheet()
# Referencia a la celda E5
celda = activa.getCellRangeByName('E5')
# Mostramos el contenido de la celda
msgbox (celda.getString())
# Mostramos direccion de esta celda
ca = celda.getCellAddress()
message = u'Columna: %s\nFila: %s\nHoja: %s' % (ca.Column, ca.Row, ca.Sheet)
msgbox (message)
</source>

Observa como comprobamos en la ultima linea, que efectivamente hemos hecho referencia a la celda que nos interesa, es decir a la celda E5, que en columna y fila es la 4, por que recordamos que los números de columna y fila empiezan en 0, observa la estructura <idl>com.sun.star.table.CellAddress</idl>, esta, es muy importante pues a muchos métodos para manipular celdas, se les tienen que pasar estructuras como esta, solo tiene tres propiedades, la hoja (valor tipo '''integer''' que también empieza en 0) donde esta la celda referenciada, la columna ('''long''') y la fila ('''long''') de esta celda.

Ahora accedemos a una celda por su posición, recuerda que los índices de inicio desde código empiezan en 0, por lo que para hacer referencia a la celda E5, tenemos que poner la columna 4 y fila 4, el primer valor es para la columna y el segundo para la fila, no esta de más comentarte que tengas cuidado de no establecer una posición fuera de la hoja, pues te dará un error, si el valor de la fila y columna se la solicitas al usuario, “deberías” de validar que los valores proporcionados son correctos.
<source lang=python>
activa = doc.getCurrentController().getActiveSheet()

col = 9
fil = 14
if col < activa.getColumns().getCount() and fil < activa.getRows().getCount():
celda = activa.getCellByPosition(col, fil)
msgbox (celda.getString())
else:
msgbox('Valores incorrectos')
</source>

Es frecuente que el acceso por nombre a una celda se use para establecer valores preestablecidos, como títulos de campos por ejemplo, y el acceso por posición es muy útil para realizar ciclos, como el ejemplo siguiente que inserta el año como titulo en la celda A1 y los meses del año de la celda A2 a la A13.
<source lang=python>
import uno
import datetime

def pruebas():
ctx = uno.getComponentContext()
sm = ctx.getServiceManager()

desktop = sm.createInstanceWithContext('com.sun.star.frame.Desktop', ctx)
doc = desktop.getCurrentComponent()

activa = doc.getCurrentController().getActiveSheet()
activa.getCellRangeByName('A1').setString(datetime.date.today().year)
for i in range(1,13):
activa.getCellByPosition(0, i).setString(datetime.date(2013, i, 1).strftime('%B'))

return
</source>

Observa que hemos estado usando el método '''getString()''' para obtener el contenido de una celda y '''setString(cadena)''' para establecerlo, más adelante veremos todas las posibilidades que tenemos para introducir u obtener datos de las celdas de nuestra hoja de calculo, así como sus diferencias.

== Referencia a un rango de celdas ==

Podemos acceder a un rango de celdas por su nombre, usando el mismo método usado para acceder a una celda.
<source lang=python>
activa = doc.getCurrentController().getActiveSheet()
rango = activa.getCellRangeByName('A1:E5')
doc.getCurrentController().select(rango)
</source>

Para acceder a un rango de celdas por su posición, hay que usar un método diferente: '''getCellRangeByPosition''', que requiere de cuatro argumentos.
<source lang=python>
activa = doc.getCurrentController().getActiveSheet()
# Seleccionamos el rango B1:C10
rango = activa.getCellRangeByPosition(1, 0, 2, 9)
doc.getCurrentController().select(rango)
</source>

Observa que este nuevo método requiere cuatro argumentos: la columna y fila donde empieza nuestro rango y la columna y fila donde termina, recuerda que los números de fila y columna empiezan en 0, algunos piensan que los dos últimos argumentos son el ancho y alto del rango a usar, no es así, estos argumentos también son números de índices de columna y fila respectivamente y tienes que tener la precaución de establecer los segundos iguales o mas grandes que los primeros, sino, te dará un error en tiempo de ejecución y por supuesto sin sobrepasar el máximo de filas y columnas de la hoja de calculo. Observa también, como en la ultima línea seleccionamos el rango referenciado.

Otra posibilidad, es usar nombres definidos de rangos, es decir, aquellos que establecemos desde el '''Cuadro de nombre''' en la hoja de calculo, ya sabes, ese cuadro de lista desplegable (combobox) que esta al lado de la barra de formulas, que también puedes establecer desde el menú ''''Insertar | Nombres | Definir...'''' cuya teclas de acceso rápido son {{Key|Ctrl|F3}}. En el siguiente ejemplo, seleccionamos el rango de celdas llamado Datos. Toma nota de que si el rango no existe en la hoja desde donde se intenta referenciar, te dará un error.
<source lang=python>
activa = doc.getCurrentController().getActiveSheet()
rango = activa.getCellRangeByName('Datos')
doc.getCurrentController().select(rango)
</source>

Este método no es sensible a mayúsculas o minúsculas. Observa como primero obtenemos una referencia a la interfaz <idl>com.sun.star.sheet.XNamedRanges</idl> y dado que esta hereda la interfaz <idl>com.sun.star.container.XNameAccess</idl> podemos usar el método '''getElementNames''' para obtener todos los nombres con rango en el documento. Si el usuario es el que proporciona el nombre del rango, como siempre, es mejor validar que el rango exista.
<source lang=python>
nr = doc.NamedRanges
nombre = 'Datos'
nombres_rangos = nr.getElementNames()

if nombre in nombres_rangos:
rango = nr.getByName(nombre).getReferredCells()
doc.getCurrentController().select(rango)
else:
msgbox(u'No existe el rango: %S' % nombre)
</source>

No confundas estos nombres de rangos, con los que puedes establecer en el menú '''Datos | Definir rango...''', ya que estos últimos se refieren a rangos considerados como una tabla de datos, de hecho, puedes tener un mismo nombre para un rango de celdas y para un rango de datos, pero son dos cosas diferentes, los segundos, los veremos más adelante.

De los rangos de celdas, también es posible obtener información, para ello se hace uso de la estructura <idl>com.sun.star.table.CellRangeAddress</idl> a través del método '''getRangeAddress''' que te devuelve información de: la hoja donde esta el rango, la columna y fila donde comienza y la columna y fila donde acaba.
<source lang=python>
activa = doc.getCurrentController().getActiveSheet()
rango = activa.getCellRangeByName('Datos')
ra = rango.getRangeAddress()

message = """
El rango esta en la hoja: %s
Columna inicio: %s
Fila Inicio: %s
Columna final: %s
Fila final: %s
""" % (ra.Sheet, ra.StartColumn, ra.StartRow, ra.EndColumn, ra.EndRow)

msgbox(message)
</source>

Esta estructura ('''getRangeAddress''') también es usada por varios métodos para manipular rangos que veremos más adelante, por lo que es importante que la tengas presente.

== Referencia a varios rangos de celdas ==

Cuando en la interfaz del usuario, hacemos la selección de un rango y mantenemos presionada la tecla {{Key|Ctrl}} y hacemos un segunda selección de un rango y así sucesivamente, estamos hablando de un conjunto de rangos que tiene sus características particulares para su control y manejo. Para seleccionar varios rangos desde código, primero debemos crear el '''contenedor''' de estos rangos, veamos como.
<source lang=python>
desktop = sm.createInstanceWithContext('com.sun.star.frame.Desktop', ctx)
doc = desktop.getCurrentComponent()

activa = doc.getCurrentController().getActiveSheet()
#~ Creamos el contender para los rangos
rangos = doc.createInstance('com.sun.star.sheet.SheetCellRanges')
#~ Creamos la estructura CellRangeAddress necesaria
dir_rango = activa.getCellRangeByName('A1:B2').getRangeAddress()
#~ Y lo agregamos al contenedor de rangos
rangos.addRangeAddress(dir_rango, False)
#~ Aquí solo hacemos referencia al rango
rango = activa.getCellRangeByName('E1:G2')
#~ Y lo agregamos al contenedor de rangos, nota como tenemos que usar
#~ el método getRangeAddress para pasarle el argumento correcto
rangos.addRangeAddress(rango.getRangeAddress(), False)
#~ Aquí agregamos un rango directamente al contenedor
#~ toma en cuenta que se van acumulando
rangos.addRangeAddress(activa.getCellRangeByName('D4:E5').getRangeAddress() , False)

#~ Comprobamos que están correctos seleccionándolos
doc.getCurrentController().select(rangos)
</source>

No te confundas, las tres líneas donde se agrega el rango con el método '''addRangeAddress()''' son iguales, lo que cambia es la forma en que hacemos referencia a la dirección del rango, si vas empezando a programar, te recomiendo ir desglosando cada línea, con el tiempo y la experiencia, podrás concentrar código de forma más natural, por ahora, usa todas las líneas que consideres pertinentes para que tu código lo entiendas con solo verlo.

Por supuesto, también de estos rangos podemos obtener información, por ejemplo, los nombres de los rangos que contiene,
<source lang=python>
activa = doc.getCurrentController().getActiveSheet()
#~ Creamos el contender para los rangos
rangos = doc.createInstance('com.sun.star.sheet.SheetCellRanges')

#~ Agregamos los rangos que queramos
rangos.addRangeAddress(activa.getCellRangeByName('A1:A2').getRangeAddress(), False)
rangos.addRangeAddress(activa.getCellRangeByName('B4:B5').getRangeAddress(), False)
rangos.addRangeAddress(activa.getCellRangeByName('C7:C8').getRangeAddress(), False)
rangos.addRangeAddress(activa.getCellRangeByName('D10:D11').getRangeAddress(), False)
rangos.addRangeAddress(activa.getCellRangeByName('E13:E14').getRangeAddress(), False)

#~ Mostramos las direcciones de los rangos
msgbox(rangos.getRangeAddressesAsString())
</source>

Nota como los rangos es una cadena larga de las direcciones de los rangos separados por un ''';''', si lo quieres mejor presentable, reemplaza los puntos y comas por un salto de línea con el siguiente código.
<source lang=python>
#~ Mostramos las direcciones de los rangos
message = rangos.getRangeAddressesAsString().replace(';', '\n')
msgbox(message)
</source>

Los rangos también se pueden remover de la colección.
<source lang=python>
activa = doc.getCurrentController().getActiveSheet()
#~ Creamos el contender para los rangos
rangos = doc.createInstance('com.sun.star.sheet.SheetCellRanges')

#~ Agregamos los rangos que queramos
rangos.addRangeAddress(activa.getCellRangeByName('A1:A2').getRangeAddress(), False)
rangos.addRangeAddress(activa.getCellRangeByName('B4:B5').getRangeAddress(), False)
rangos.addRangeAddress(activa.getCellRangeByName('C7:C8').getRangeAddress(), False)
rangos.addRangeAddress(activa.getCellRangeByName('D10:D11').getRangeAddress(), False)
rangos.addRangeAddress(activa.getCellRangeByName('E13:E14').getRangeAddress(), False)

#~ Comprobamos que estén los rangos
msgbox(rangos.getRangeAddressesAsString().replace(';', '\n'))

#~ Removemos el rango deseado
rangos.removeRangeAddress(activa.getCellRangeByName('D10:D11').getRangeAddress())

#~ Volvemos a verificar que se haya removido
msgbox(rangos.getRangeAddressesAsString().replace(';', '\n'))
</source>

Cuidado, si el rango que quieres remover no existe en la colección, te dará un error en tiempo de ejecución, lo mejor es validar antes que existe...
<source lang=python>
# Validamos que el rango a remover exista en la colección
if rangos.hasByName('Hoja1.D10:D11'):
rangos.removeRangeAddress(activa.getCellRangeByName('D10:D11').getRangeAddress())
</source>

El código anterior tiene un problema que tal vez te pueda causar un pequeño inconveniente, cuando consultamos con '''hasByName''' si el rango existe, observa que le pasamos el nombre del rango como texto '''('Hoja1.D10:D11')''' y que incluye el nombre de la hoja donde esta el rango, pero observa como al método '''removeRangeAddress''', le pasamos un objeto ('''activa''') que no necesariamente tiene que corresponder con el nombre de hoja ('''Hoja1'''), siempre garantiza que se corresponde uno con el otro, es decir, que el objeto que apunta a la hoja, efectivamente corresponda en nombre con el rango pasado.

== Referencia a filas y columnas ==

Las filas y columnas de una hoja de calculo siguen siendo rangos de celdas, lo único que las caracteriza, en función de hacer referencia a ellas, es que abarcan la totalidad de celdas que contienen, como en.

[[Category:ES]]
[[Category:Manuales]]
[[Category:ES/Python]]

ES/Manuales/GuiaAOO/TemasAvanzados/Macros/Python/PythonCalc/ReferenciaARangos

2013-05-22T03:58:13Z

Mauriciobaeza: /* Referencia a varios rangos de celdas */

{{DISPLAYTITLE: Referencia a rangos}}

Seguro que sabes, si eres usuario habitual de una hoja de calculo, que el trabajo con rangos es esencial en estos documentos, por lo mismo, el trabajo con rangos desde código es igualmente importante, ya vimos como aseguramos que estamos trabajando en una hoja de calculo, así que dejo a tu criterio esta validación. En la siguientes secciones nos centraremos en aprender como hacer referencia a distintos tipos de rangos para después poder manipularlos, darles formato o hacer con ellos lo que queramos.

== Referencia a celdas individuales ==

Podemos acceder a las celdas de una hoja de calculo de varias maneras, principalmente por su nombre o por su posición, pero muy importante, primero tienes que acceder a la hoja donde están las celdas que te interesa manipular, como acceder a hojas es un tema que ya hemos tratado, pero en cada ejemplo podrás notar que repasamos estos conocimientos, la forma más simple de hacer referencia a una celda es por su nombre.
<source lang=python>
activa = doc.getCurrentController().getActiveSheet()
# Referencia a la celda E5
celda = activa.getCellRangeByName('E5')
# Mostramos el contenido de la celda
msgbox (celda.getString())
# Mostramos direccion de esta celda
ca = celda.getCellAddress()
message = u'Columna: %s\nFila: %s\nHoja: %s' % (ca.Column, ca.Row, ca.Sheet)
msgbox (message)
</source>

Observa como comprobamos en la ultima linea, que efectivamente hemos hecho referencia a la celda que nos interesa, es decir a la celda E5, que en columna y fila es la 4, por que recordamos que los números de columna y fila empiezan en 0, observa la estructura <idl>com.sun.star.table.CellAddress</idl>, esta, es muy importante pues a muchos métodos para manipular celdas, se les tienen que pasar estructuras como esta, solo tiene tres propiedades, la hoja (valor tipo '''integer''' que también empieza en 0) donde esta la celda referenciada, la columna ('''long''') y la fila ('''long''') de esta celda.

Ahora accedemos a una celda por su posición, recuerda que los índices de inicio desde código empiezan en 0, por lo que para hacer referencia a la celda E5, tenemos que poner la columna 4 y fila 4, el primer valor es para la columna y el segundo para la fila, no esta de más comentarte que tengas cuidado de no establecer una posición fuera de la hoja, pues te dará un error, si el valor de la fila y columna se la solicitas al usuario, “deberías” de validar que los valores proporcionados son correctos.
<source lang=python>
activa = doc.getCurrentController().getActiveSheet()

col = 9
fil = 14
if col < activa.getColumns().getCount() and fil < activa.getRows().getCount():
celda = activa.getCellByPosition(col, fil)
msgbox (celda.getString())
else:
msgbox('Valores incorrectos')
</source>

Es frecuente que el acceso por nombre a una celda se use para establecer valores preestablecidos, como títulos de campos por ejemplo, y el acceso por posición es muy útil para realizar ciclos, como el ejemplo siguiente que inserta el año como titulo en la celda A1 y los meses del año de la celda A2 a la A13.
<source lang=python>
import uno
import datetime

def pruebas():
ctx = uno.getComponentContext()
sm = ctx.getServiceManager()

desktop = sm.createInstanceWithContext('com.sun.star.frame.Desktop', ctx)
doc = desktop.getCurrentComponent()

activa = doc.getCurrentController().getActiveSheet()
activa.getCellRangeByName('A1').setString(datetime.date.today().year)
for i in range(1,13):
activa.getCellByPosition(0, i).setString(datetime.date(2013, i, 1).strftime('%B'))

return
</source>

Observa que hemos estado usando el método '''getString()''' para obtener el contenido de una celda y '''setString(cadena)''' para establecerlo, más adelante veremos todas las posibilidades que tenemos para introducir u obtener datos de las celdas de nuestra hoja de calculo, así como sus diferencias.

== Referencia a un rango de celdas ==

Podemos acceder a un rango de celdas por su nombre, usando el mismo método usado para acceder a una celda.
<source lang=python>
activa = doc.getCurrentController().getActiveSheet()
rango = activa.getCellRangeByName('A1:E5')
doc.getCurrentController().select(rango)
</source>

Para acceder a un rango de celdas por su posición, hay que usar un método diferente: '''getCellRangeByPosition''', que requiere de cuatro argumentos.
<source lang=python>
activa = doc.getCurrentController().getActiveSheet()
# Seleccionamos el rango B1:C10
rango = activa.getCellRangeByPosition(1, 0, 2, 9)
doc.getCurrentController().select(rango)
</source>

Observa que este nuevo método requiere cuatro argumentos: la columna y fila donde empieza nuestro rango y la columna y fila donde termina, recuerda que los números de fila y columna empiezan en 0, algunos piensan que los dos últimos argumentos son el ancho y alto del rango a usar, no es así, estos argumentos también son números de índices de columna y fila respectivamente y tienes que tener la precaución de establecer los segundos iguales o mas grandes que los primeros, sino, te dará un error en tiempo de ejecución y por supuesto sin sobrepasar el máximo de filas y columnas de la hoja de calculo. Observa también, como en la ultima línea seleccionamos el rango referenciado.

Otra posibilidad, es usar nombres definidos de rangos, es decir, aquellos que establecemos desde el '''Cuadro de nombre''' en la hoja de calculo, ya sabes, ese cuadro de lista desplegable (combobox) que esta al lado de la barra de formulas, que también puedes establecer desde el menú ''''Insertar | Nombres | Definir...'''' cuya teclas de acceso rápido son {{Key|Ctrl|F3}}. En el siguiente ejemplo, seleccionamos el rango de celdas llamado Datos. Toma nota de que si el rango no existe en la hoja desde donde se intenta referenciar, te dará un error.
<source lang=python>
activa = doc.getCurrentController().getActiveSheet()
rango = activa.getCellRangeByName('Datos')
doc.getCurrentController().select(rango)
</source>

Este método no es sensible a mayúsculas o minúsculas. Observa como primero obtenemos una referencia a la interfaz <idl>com.sun.star.sheet.XNamedRanges</idl> y dado que esta hereda la interfaz <idl>com.sun.star.container.XNameAccess</idl> podemos usar el método '''getElementNames''' para obtener todos los nombres con rango en el documento. Si el usuario es el que proporciona el nombre del rango, como siempre, es mejor validar que el rango exista.
<source lang=python>
nr = doc.NamedRanges
nombre = 'Datos'
nombres_rangos = nr.getElementNames()

if nombre in nombres_rangos:
rango = nr.getByName(nombre).getReferredCells()
doc.getCurrentController().select(rango)
else:
msgbox(u'No existe el rango: %S' % nombre)
</source>

No confundas estos nombres de rangos, con los que puedes establecer en el menú '''Datos | Definir rango...''', ya que estos últimos se refieren a rangos considerados como una tabla de datos, de hecho, puedes tener un mismo nombre para un rango de celdas y para un rango de datos, pero son dos cosas diferentes, los segundos, los veremos más adelante.

De los rangos de celdas, también es posible obtener información, para ello se hace uso de la estructura <idl>com.sun.star.table.CellRangeAddress</idl> a través del método '''getRangeAddress''' que te devuelve información de: la hoja donde esta el rango, la columna y fila donde comienza y la columna y fila donde acaba.
<source lang=python>
activa = doc.getCurrentController().getActiveSheet()
rango = activa.getCellRangeByName('Datos')
ra = rango.getRangeAddress()

message = """
El rango esta en la hoja: %s
Columna inicio: %s
Fila Inicio: %s
Columna final: %s
Fila final: %s
""" % (ra.Sheet, ra.StartColumn, ra.StartRow, ra.EndColumn, ra.EndRow)

msgbox(message)
</source>

Esta estructura ('''getRangeAddress''') también es usada por varios métodos para manipular rangos que veremos más adelante, por lo que es importante que la tengas presente.

== Referencia a varios rangos de celdas ==

Cuando en la interfaz del usuario, hacemos la selección de un rango y mantenemos presionada la tecla {{Key|Ctrl}} y hacemos un segunda selección de un rango y así sucesivamente, estamos hablando de un conjunto de rangos que tiene sus características particulares para su control y manejo. Para seleccionar varios rangos desde código, primero debemos crear el '''contenedor''' de estos rangos, veamos como.
<source lang=python>
desktop = sm.createInstanceWithContext('com.sun.star.frame.Desktop', ctx)
doc = desktop.getCurrentComponent()

activa = doc.getCurrentController().getActiveSheet()
#~ Creamos el contender para los rangos
rangos = doc.createInstance('com.sun.star.sheet.SheetCellRanges')
#~ Creamos la estructura CellRangeAddress necesaria
dir_rango = activa.getCellRangeByName('A1:B2').getRangeAddress()
#~ Y lo agregamos al contenedor de rangos
rangos.addRangeAddress(dir_rango, False)
#~ Aquí solo hacemos referencia al rango
rango = activa.getCellRangeByName('E1:G2')
#~ Y lo agregamos al contenedor de rangos, nota como tenemos que usar
#~ el método getRangeAddress para pasarle el argumento correcto
rangos.addRangeAddress(rango.getRangeAddress(), False)
#~ Aquí agregamos un rango directamente al contenedor
#~ toma en cuenta que se van acumulando
rangos.addRangeAddress(activa.getCellRangeByName('D4:E5').getRangeAddress() , False)

#~ Comprobamos que están correctos seleccionándolos
doc.getCurrentController().select(rangos)
</source>

No te confundas, las tres líneas donde se agrega el rango con el método '''addRangeAddress()''' son iguales, lo que cambia es la forma en que hacemos referencia a la dirección del rango, si vas empezando a programar, te recomiendo ir desglosando cada línea, con el tiempo y la experiencia, podrás concentrar código de forma más natural, por ahora, usa todas las líneas que consideres pertinentes para que tu código lo entiendas con solo verlo.

Por supuesto, también de estos rangos podemos obtener información, por ejemplo, los nombres de los rangos que contiene,
<source lang=python>
activa = doc.getCurrentController().getActiveSheet()
#~ Creamos el contender para los rangos
rangos = doc.createInstance('com.sun.star.sheet.SheetCellRanges')

#~ Agregamos los rangos que queramos
rangos.addRangeAddress(activa.getCellRangeByName('A1:A2').getRangeAddress(), False)
rangos.addRangeAddress(activa.getCellRangeByName('B4:B5').getRangeAddress(), False)
rangos.addRangeAddress(activa.getCellRangeByName('C7:C8').getRangeAddress(), False)
rangos.addRangeAddress(activa.getCellRangeByName('D10:D11').getRangeAddress(), False)
rangos.addRangeAddress(activa.getCellRangeByName('E13:E14').getRangeAddress(), False)

#~ Mostramos las direcciones de los rangos
msgbox(rangos.getRangeAddressesAsString())
</source>

Nota como los rangos es una cadena larga de las direcciones de los rangos separados por un ''';''', si lo quieres mejor presentable, reemplaza los puntos y comas por un salto de línea con el siguiente código.
<source lang=python>
#~ Mostramos las direcciones de los rangos
message = rangos.getRangeAddressesAsString().replace(';', '\n')
msgbox(message)
</source>

[[Category:ES]]
[[Category:Manuales]]
[[Category:ES/Python]]

ES/Manuales/GuiaAOO/TemasAvanzados/Macros/Python/PythonCalc/ReferenciaARangos

2013-05-22T03:56:16Z

Mauriciobaeza:

{{DISPLAYTITLE: Referencia a rangos}}

Seguro que sabes, si eres usuario habitual de una hoja de calculo, que el trabajo con rangos es esencial en estos documentos, por lo mismo, el trabajo con rangos desde código es igualmente importante, ya vimos como aseguramos que estamos trabajando en una hoja de calculo, así que dejo a tu criterio esta validación. En la siguientes secciones nos centraremos en aprender como hacer referencia a distintos tipos de rangos para después poder manipularlos, darles formato o hacer con ellos lo que queramos.

== Referencia a celdas individuales ==

Podemos acceder a las celdas de una hoja de calculo de varias maneras, principalmente por su nombre o por su posición, pero muy importante, primero tienes que acceder a la hoja donde están las celdas que te interesa manipular, como acceder a hojas es un tema que ya hemos tratado, pero en cada ejemplo podrás notar que repasamos estos conocimientos, la forma más simple de hacer referencia a una celda es por su nombre.
<source lang=python>
activa = doc.getCurrentController().getActiveSheet()
# Referencia a la celda E5
celda = activa.getCellRangeByName('E5')
# Mostramos el contenido de la celda
msgbox (celda.getString())
# Mostramos direccion de esta celda
ca = celda.getCellAddress()
message = u'Columna: %s\nFila: %s\nHoja: %s' % (ca.Column, ca.Row, ca.Sheet)
msgbox (message)
</source>

Observa como comprobamos en la ultima linea, que efectivamente hemos hecho referencia a la celda que nos interesa, es decir a la celda E5, que en columna y fila es la 4, por que recordamos que los números de columna y fila empiezan en 0, observa la estructura <idl>com.sun.star.table.CellAddress</idl>, esta, es muy importante pues a muchos métodos para manipular celdas, se les tienen que pasar estructuras como esta, solo tiene tres propiedades, la hoja (valor tipo '''integer''' que también empieza en 0) donde esta la celda referenciada, la columna ('''long''') y la fila ('''long''') de esta celda.

Ahora accedemos a una celda por su posición, recuerda que los índices de inicio desde código empiezan en 0, por lo que para hacer referencia a la celda E5, tenemos que poner la columna 4 y fila 4, el primer valor es para la columna y el segundo para la fila, no esta de más comentarte que tengas cuidado de no establecer una posición fuera de la hoja, pues te dará un error, si el valor de la fila y columna se la solicitas al usuario, “deberías” de validar que los valores proporcionados son correctos.
<source lang=python>
activa = doc.getCurrentController().getActiveSheet()

col = 9
fil = 14
if col < activa.getColumns().getCount() and fil < activa.getRows().getCount():
celda = activa.getCellByPosition(col, fil)
msgbox (celda.getString())
else:
msgbox('Valores incorrectos')
</source>

Es frecuente que el acceso por nombre a una celda se use para establecer valores preestablecidos, como títulos de campos por ejemplo, y el acceso por posición es muy útil para realizar ciclos, como el ejemplo siguiente que inserta el año como titulo en la celda A1 y los meses del año de la celda A2 a la A13.
<source lang=python>
import uno
import datetime

def pruebas():
ctx = uno.getComponentContext()
sm = ctx.getServiceManager()

desktop = sm.createInstanceWithContext('com.sun.star.frame.Desktop', ctx)
doc = desktop.getCurrentComponent()

activa = doc.getCurrentController().getActiveSheet()
activa.getCellRangeByName('A1').setString(datetime.date.today().year)
for i in range(1,13):
activa.getCellByPosition(0, i).setString(datetime.date(2013, i, 1).strftime('%B'))

return
</source>

Observa que hemos estado usando el método '''getString()''' para obtener el contenido de una celda y '''setString(cadena)''' para establecerlo, más adelante veremos todas las posibilidades que tenemos para introducir u obtener datos de las celdas de nuestra hoja de calculo, así como sus diferencias.

== Referencia a un rango de celdas ==

Podemos acceder a un rango de celdas por su nombre, usando el mismo método usado para acceder a una celda.
<source lang=python>
activa = doc.getCurrentController().getActiveSheet()
rango = activa.getCellRangeByName('A1:E5')
doc.getCurrentController().select(rango)
</source>

Para acceder a un rango de celdas por su posición, hay que usar un método diferente: '''getCellRangeByPosition''', que requiere de cuatro argumentos.
<source lang=python>
activa = doc.getCurrentController().getActiveSheet()
# Seleccionamos el rango B1:C10
rango = activa.getCellRangeByPosition(1, 0, 2, 9)
doc.getCurrentController().select(rango)
</source>

Observa que este nuevo método requiere cuatro argumentos: la columna y fila donde empieza nuestro rango y la columna y fila donde termina, recuerda que los números de fila y columna empiezan en 0, algunos piensan que los dos últimos argumentos son el ancho y alto del rango a usar, no es así, estos argumentos también son números de índices de columna y fila respectivamente y tienes que tener la precaución de establecer los segundos iguales o mas grandes que los primeros, sino, te dará un error en tiempo de ejecución y por supuesto sin sobrepasar el máximo de filas y columnas de la hoja de calculo. Observa también, como en la ultima línea seleccionamos el rango referenciado.

Otra posibilidad, es usar nombres definidos de rangos, es decir, aquellos que establecemos desde el '''Cuadro de nombre''' en la hoja de calculo, ya sabes, ese cuadro de lista desplegable (combobox) que esta al lado de la barra de formulas, que también puedes establecer desde el menú ''''Insertar | Nombres | Definir...'''' cuya teclas de acceso rápido son {{Key|Ctrl|F3}}. En el siguiente ejemplo, seleccionamos el rango de celdas llamado Datos. Toma nota de que si el rango no existe en la hoja desde donde se intenta referenciar, te dará un error.
<source lang=python>
activa = doc.getCurrentController().getActiveSheet()
rango = activa.getCellRangeByName('Datos')
doc.getCurrentController().select(rango)
</source>

Este método no es sensible a mayúsculas o minúsculas. Observa como primero obtenemos una referencia a la interfaz <idl>com.sun.star.sheet.XNamedRanges</idl> y dado que esta hereda la interfaz <idl>com.sun.star.container.XNameAccess</idl> podemos usar el método '''getElementNames''' para obtener todos los nombres con rango en el documento. Si el usuario es el que proporciona el nombre del rango, como siempre, es mejor validar que el rango exista.
<source lang=python>
nr = doc.NamedRanges
nombre = 'Datos'
nombres_rangos = nr.getElementNames()

if nombre in nombres_rangos:
rango = nr.getByName(nombre).getReferredCells()
doc.getCurrentController().select(rango)
else:
msgbox(u'No existe el rango: %S' % nombre)
</source>

No confundas estos nombres de rangos, con los que puedes establecer en el menú '''Datos | Definir rango...''', ya que estos últimos se refieren a rangos considerados como una tabla de datos, de hecho, puedes tener un mismo nombre para un rango de celdas y para un rango de datos, pero son dos cosas diferentes, los segundos, los veremos más adelante.

De los rangos de celdas, también es posible obtener información, para ello se hace uso de la estructura <idl>com.sun.star.table.CellRangeAddress</idl> a través del método '''getRangeAddress''' que te devuelve información de: la hoja donde esta el rango, la columna y fila donde comienza y la columna y fila donde acaba.
<source lang=python>
activa = doc.getCurrentController().getActiveSheet()
rango = activa.getCellRangeByName('Datos')
ra = rango.getRangeAddress()

message = """
El rango esta en la hoja: %s
Columna inicio: %s
Fila Inicio: %s
Columna final: %s
Fila final: %s
""" % (ra.Sheet, ra.StartColumn, ra.StartRow, ra.EndColumn, ra.EndRow)

msgbox(message)
</source>

Esta estructura ('''getRangeAddress''') también es usada por varios métodos para manipular rangos que veremos más adelante, por lo que es importante que la tengas presente.

== Referencia a varios rangos de celdas ==

Cuando en la interfaz del usuario, hacemos la selección de un rango y mantenemos presionada la tecla {{Key|Ctrl}} y hacemos un segunda selección de un rango y así sucesivamente, estamos hablando de un conjunto de rangos que tiene sus características particulares para su control y manejo. Para seleccionar varios rangos desde código, primero debemos crear el '''contenedor''' de estos rangos, veamos como.
<source lang=python>
desktop = sm.createInstanceWithContext('com.sun.star.frame.Desktop', ctx)
doc = desktop.getCurrentComponent()

activa = doc.getCurrentController().getActiveSheet()
#~ Creamos el contender para los rangos
rangos = doc.createInstance('com.sun.star.sheet.SheetCellRanges')
#~ Creamos la estructura CellRangeAddress necesaria
dir_rango = activa.getCellRangeByName('A1:B2').getRangeAddress()
#~ Y lo agregamos al contenedor de rangos
rangos.addRangeAddress(dir_rango, False)
#~ Aquí solo hacemos referencia al rango
rango = activa.getCellRangeByName('E1:G2')
#~ Y lo agregamos al contenedor de rangos, nota como tenemos que usar
#~ el método getRangeAddress para pasarle el argumento correcto
rangos.addRangeAddress(rango.getRangeAddress(), False)
#~ Aquí agregamos un rango directamente al contenedor
#~ toma en cuenta que se van acumulando
rangos.addRangeAddress(activa.getCellRangeByName('D4:E5').getRangeAddress() , False)

#~ Comprobamos que están correctos seleccionándolos
doc.getCurrentController().select(rangos)
</source>

No te confundas, las tres líneas donde se agrega el rango con el método '''addRangeAddress()''' son iguales, lo que cambia es la forma en que hacemos referencia a la dirección del rango, si vas empezando a programar, te recomiendo ir desglosando cada línea, con el tiempo y la experiencia, podrás concentrar código de forma más natural, por ahora, usa todas las líneas que consideres pertinentes para que tu código lo entiendas con solo verlo.

Por supuesto, también de estos rangos podemos obtener información, por ejemplo, los nombres de los rangos que contiene,
<source lang=python>
activa = doc.getCurrentController().getActiveSheet()
#~ Creamos el contender para los rangos
rangos = doc.createInstance('com.sun.star.sheet.SheetCellRanges')

#~ Agregamos los rangos que queramos
rangos.addRangeAddress(activa.getCellRangeByName('A1:A2').getRangeAddress(), False)
rangos.addRangeAddress(activa.getCellRangeByName('B4:B5').getRangeAddress(), False)
rangos.addRangeAddress(activa.getCellRangeByName('C7:C8').getRangeAddress(), False)
rangos.addRangeAddress(activa.getCellRangeByName('D10:D11').getRangeAddress(), False)
rangos.addRangeAddress(activa.getCellRangeByName('E13:E14').getRangeAddress(), False)

#~ Mostramos las direcciones de los rangos
msgbox(rangos.getRangeAddressesAsString())
</source>

Nota como los rangos es una cadena larga de las direcciones de los rangos separados por un ''';''', si lo quieres mejor presentable, reemplaza los puntos y comas por un salto de línea con el siguiente código.
<source lang=python>
#~ Mostramos las direcciones de los rangos
message = rangos.getRangeAddressesAsString().replace(';', '\n')
msgbox(message)
</source>

[[Category:ES]]
[[Category:Manuales]]
[[Category:ES/Python]]

ES/Manuales/GuiaAOO/TemasAvanzados/Macros/Python/PythonCalc/ReferenciaARangos

2013-05-15T04:23:18Z

Mauriciobaeza:

ES/Manuales/GuiaAOO/TemasAvanzados/Macros/Python/PythonCalc/ReferenciaARangos

2013-05-14T04:18:39Z

Mauriciobaeza: Created page with "{{DISPLAYTITLE: Referencia a rangos}} Seguro que sabes, si eres usuario habitual de una hoja de calculo, que el trabajo con rangos es esencial en estos documentos, por lo mis..."

ES/Manuales/GuiaAOO/TemasAvanzados/Macros/Python/PythonCalc/TrabajandoConHojas

2013-05-10T05:03:36Z

Mauriciobaeza: /* Protección y desprotección de hojas */

{{DISPLAYTITLE:Trabajando con hojas}}

== Acceso a las hojas de un archivo Calc ==

Para acceder a todas las hojas de un archivo usamos el método '''getSheets'''.
<source lang=python>
doc = desktop.getCurrentComponent()
hojas = doc.getSheets()
</source>

Podemos devolver todos los nombres de las mismas.
<source lang=python>
doc = desktop.getCurrentComponent()
hojas = doc.getSheets()
nombres = hojas.getElementNames()
msgbox('\n'.join(nombres))
</source>

O acceder por nombre a la que nos interesa ('''getByName'''), tienes que validar ('''hasByName''') primero que existe esta hoja.

<source lang=python>
doc = desktop.getCurrentComponent()
hojas = doc.getSheets()
nombre = 'Hoja1'
if hojas.hasByName(nombre):
hoja = hojas.getByName(nombre)
else:
msgbox('No existe la hoja: %s' % nombre)
</source>

Podemos acceder a una hoja por su índice, recuerda que los índices en AOO empiezan en cero, en las hojas, la numeración empieza de izquierda a derecha.

<source lang=python>
doc = desktop.getCurrentComponent()
hojas = doc.getSheets()
indice = 1
hoja = hojas.getByIndex(indice)
msgbox (hoja.getName())
</source>

Del mismo modo que por el nombre, si tratas de acceder a una hoja por un índice que no exista, te dará un error, lo podemos comprobar asegurándonos que el numero de índice a consultar siempre es menor al total de las hojas.

<source lang=python>
doc = desktop.getCurrentComponent()
hojas = doc.getSheets()
indice = 1
if indice < hojas.getCount():
hoja = hojas.getByIndex(indice)
msgbox (hoja.getName())
else:
msgbox(u'No existe este índice: %s' % indice)
</source>

Podemos acceder a cada hoja por su índice, pero toma en cuenta que si mueves una hoja de posición en relación con las demás, su índice cambiara, no así su nombre, pero el nombre es susceptible de ser cambiado por el usuario, así que siempre comprueba que exista una hoja antes de intentar acceder a ella.

<source lang=python>
doc = desktop.getCurrentComponent()
hojas = doc.getSheets()
for i in range(hojas.getCount()):
msgbox(hojas.getByIndex(i).getName())
</source>

También es posible devolver la hoja activa.
<source lang=python>
doc = desktop.getCurrentComponent()
hoja = doc.getCurrentController().getActiveSheet()
msgbox(hoja.getName())
</source>

Creamos una función genérica para devolver una hoja.
<source lang=python>
def devuelve_hoja(doc, nombre):
if doc.getSheets().hasByName(nombre):
return doc.getSheets().getByName(nombre)
</source>

Para usarse de forma sencilla.
<source lang=python>
doc = desktop.getCurrentComponent()
nombre = 'Hoja2'
hoja = devuelve_hoja(doc, nombre)
if hoja:
msgbox(hoja.getName())
else:
msgbox('No se encontró la hoja: %s' % nombre)re)
</source>

== Insertando hojas ==
Para insertar nuevas hojas, usamos el método: '''insertNewByName(Nombre, Posición)''', en donde necesitamos el nombre de la nueva hoja a insertar y la posición donde la queremos, la siguiente macro agrega una hoja nueva al inicio de las demás.
<source lang=python>
hojas = doc.getSheets()
hojas.insertNewByName('Nuevos datos', 0)
</source>

Ejecuta la macro anterior dos veces y notaras que te dará un error, pues no puedes tener dos hojas con el mismo nombre, entonces, tenemos que verificar si la hoja existe o no.
<source lang=python>
nombre = 'Nueva hoja'
hojas = doc.getSheets()
if not hojas.hasByName(nombre):
hojas.insertNewByName(nombre, 0)
nueva_hoja = doc.getSheets().getByName(nombre)
doc.getCurrentController().setActiveSheet(nueva_hoja)
</source>

Observa que solo agregamos la hoja si esta no existe, entonces solo hacemos una referencia a ella. La ultima linea para activar la hoja no es necesaria para que la manipules, solo en caso de que quieras que el usuario haga o manipule algo en ella, si no, puedes omitirla.
{{Documentation/Note| Es sumamente frecuente en programadores noveles, querer '''activar''' toda hoja que se quiera manipular, esto no es necesario, solo activala, si estas seguro que esto es lo que quieres}}

También podemos agregar la hoja al final de todas las demás.
<source lang=python>
nombre = 'Otra hoja'
hojas = doc.getSheets()
if not hojas.hasByName(nombre):
hojas.insertNewByName(nombre, hojas.getCount())
nueva_hoja = doc.getSheets().getByName(nombre)
doc.getCurrentController().setActiveSheet(nueva_hoja)
</source>

Observa entonces que el argumento posición puede tomar valores desde 0 y hasta el total de hojas devuelto por '''getCount()''' pero incluso si es mayor a este valor, no te dará error y la insertara al final de las demás hojas. Si quieres insertar la hoja antes o después de la hoja activa, primero tienes que encontrar el índice de la hoja activa.
<source lang=python>
activa = doc.getCurrentController().getActiveSheet()
indice = activa.getRangeAddress().Sheet
msgbox(u'El índice de la hoja activa es: %s' % indice)
</source>

Que podemos convertir en una submacro. Nota como estamos estableciendo un '''valor por default''' para el ultimo argumento que será la posición deseada para la nueva hoja.
<source lang=python>
def nueva_hoja(doc, nombre, pos=0):
hojas = doc.getSheets()
if not hojas.hasByName(nombre):
activa = doc.getCurrentController().getActiveSheet()
indice = activa.getRangeAddress().Sheet
if pos == 1:
pos = indice
elif pos == 2:
pos = indice + 1
elif pos > 2:
pos = hojas.getCount()
hojas.insertNewByName(nombre, pos)
return hojas.getByName(nombre)
</source>

Ahora ya podemos insertar una nueva hoja en la posición que sea.
<source lang=python>
doc = desktop.getCurrentComponent()

nombre = 'Al inicio'
nueva = nueva_hoja(doc, nombre)

nombre = 'Antes de la activa'
nueva = nueva_hoja(doc, nombre, 1)

nombre = 'Despues de la activa'
nueva = nueva_hoja(doc, nombre, 2)

nombre = 'Al final'
nueva = nueva_hoja(doc, nombre, 3)
</source>

== Borrando hojas ==
Para borrar hojas, usamos el método '''removeByName(Nombre)''', donde '''''Nombre''''' es el nombre de la hoja que queremos borrar, no esta de más recomendarte usar con cuidado el borrado de hojas, aunque algo que me gusta mucho de AOO, es que muchas de las acciones que hacemos por código, son susceptibles de deshacerse de forma normal con la barra de herramientas o con CTRL+Z, el borrado de hojas es una de ellas, compruébalo.
<source lang=python>
hojas = doc.getSheets()
hojas.removeByName('Hoja3')
</source>

Por supuesto no puedes borrar una hoja que no exista, así que verifícalo.
<source lang=python>
nombre = 'Hoja2'
hojas = doc.getSheets()
if hojas.hasByName(nombre):
hojas.removeByName(nombre)
else:
msgbox('No existe la hoja: %s' % nombre)
</source>

Puedes borrar la hoja activa.
<source lang=python>
activa = doc.getCurrentController().getActiveSheet()
hojas = doc.getSheets()
hojas.removeByName(activa.getName())
</source>

Ejecuta la macro anterior hasta que no quede ni una, claro, no te dejara por que un documento de hoja de calculo por lo menos debe de tener una hoja, para evitar el error que te da al tratar de borrar la ultima hoja, valida que siempre quede más de una.
<source lang=python>
nombre = 'borrame'
hojas = doc.getSheets()
if hojas.hasByName(nombre) and hojas.getCount() > 1:
hojas.removeByName(nombre)
else:
msgbox('La hoja no existe o solo queda una')
</source>

== Moviendo hojas ==
Para mover hojas usamos el método '''moveByName(NombreHoja, PosicionNueva)''', donde '''''NombreHoja''''' tiene que ser el nombre de una hoja existente. En el siguiente ejemplo movemos la hoja al inicio.
<source lang=python>
hojas = doc.getSheets()
hojas.moveByName('Hoja3', 0)
</source>

Ahora, la movemos al final.
<source lang=python>
hojas = doc.getSheets()
hojas.moveByName('Hoja3', hojas.getCount())
</source>

Vamos a hacer algo muy divertido, como ya sabemos obtener los nombres e índices de cada hoja, y ahora hemos aprendido a mover hojas, hagamos una macro que nos ordene alfabéticamente nuestras hojas.
<source lang=python>
hojas = doc.getSheets()
nombres = sorted(hojas.getElementNames())
for i,v in enumerate(nombres):
hojas.moveByName(v, i)
</source>

== Copiando hojas ==
Para copiar hojas usamos el método '''copyByName(NombreHoja, NombreNuevo, Posicion)''' de la siguiente manera.
<source lang=python>
hojas = doc.getSheets()
hojas.copyByName('Hoja2', 'Nueva hoja2', 0)
</source>

Por supuesto el nombre de la hoja a copiar debe de existir y el nombre nuevo de la hoja no debe existir, lo mejor, es evaluarlo antes.
<source lang=python>
nombre = 'Datos'
nombre_nuevo = 'Datos nuevos'
hojas = doc.getSheets()
if hojas.hasByName(nombre) and not hojas.hasByName(nombre_nuevo):
hojas.copyByName(nombre, nombre_nuevo, hojas.getCount())
else:
msgbox('No se copio la hoja')
</source>

Podemos intentar copiar una hoja y asegurarnos de que el nombre no exista, tomando como base el nombre actual de la hoja, por ejemplo.
<source lang=python>
hojas = doc.getSheets()
nombre = doc.getCurrentController().getActiveSheet().getName()
co1 = 1
nombre_nuevo = '%s_%s' % (nombre, co1)
while hojas.hasByName(nombre_nuevo):
co1 += 1
nombre_nuevo = '%s_%s' % (nombre, co1)
hojas.copyByName(nombre, nombre_nuevo, hojas.getCount())
hoja = hojas.getByName(nombre_nuevo)
doc.getCurrentController().setActiveSheet(hoja)
</source>

== Renombrando hojas ==

Para renombrar hojas usamos el método '''setName(NuevoNombre)''', de la siguiente manera.
<source lang=python>
hojas = doc.getSheets()
hojas.getByName('Hola').setName('Prueba')
</source>

También puedes usar el índice para referirte a la hoja.
<source lang=python>
hojas = doc.getSheets()
hojas.getByIndex(0).setName('Prueba')
</source>

Es recomendable validar que la hoja a renombrar exista y que el nuevo nombre no.
<source lang=python>
hojas = doc.getSheets()
actual = 'Resumen'
nuevo = 'Terminado'
# Validamos que la hoja exista y el nuevo nombre no
if hojas.hasByName(actual) and not hojas.hasByName(nuevo):
hojas.getByName(actual).setName(nuevo)
else:
msgbox('No es posible renombrar la hoja')
</source>

Solo para divertirnos, cambiamos los nombres de las hojas por números.
<source lang=python>
hojas = doc.getSheets()
for i in range(hojas.getCount()):
hojas.getByIndex(i).setName(i+1)
</source>

Ahora por letras, el código siguiente podría fallar en algunas circunstancias, tu tarea es decirnos ¿porqué? y corregirlo.
<source lang=python>
hojas = doc.getSheets()
for i in range(hojas.getCount()):
hojas.getByIndex(i).setName(chr(i+65))
</source>

O los meses del año:
<source lang=python>
import uno
import datetime
import locale
locale.setlocale(locale.LC_ALL, '')

def pruebas():
ctx = uno.getComponentContext()
sm = ctx.getServiceManager()

desktop = sm.createInstanceWithContext('com.sun.star.frame.Desktop', ctx)
doc = desktop.getCurrentComponent()

hojas = doc.getSheets()
for i in range(hojas.getCount()):
hojas.getByIndex(i).setName(datetime.date(2013, i+1, 1).strftime('%B'))
return
</source>

Observa que hacemos uso de dos nuevas librerias de Python, '''datetime''' que tiene muchas utiles funciones para trabajar con fechas y tiempo, y '''locale''' para que los meses nos salgan en español.

== Ocultando y mostrando hojas ==

Mostrar y ocultar hojas es muy sencillo, solo hay que establecer su propiedad '''IsVisible''' en verdadero (True) o falso (False) según se requiera de la siguiente manera.
<source lang=python>
activa = doc.getCurrentController().getActiveSheet()
activa.IsVisible = False
</source>

La macro anterior te ocultara la hoja activa, si la ejecutas varias veces te ira ocultando tus hojas hasta que solo quede una, si solo hay una no te dará error, pero la dejará visible por que, como sabes, tiene que haber al menos una hoja visible en un documento de Calc. Si ocultas una hoja, esta no cambia de índice por lo que puedes usar el mismo para acceder a ella, aunque este oculta, la siguiente macro alterna entre mostrar y ocultar la segunda hoja del documento.
<source lang=python>
hoja = doc.getSheets().getByIndex(1)
hoja.IsVisible = not hoja.IsVisible
doc.getCurrentController().setActiveSheet(hoja)
</source>

Como ya habrás intuido, para mostrar una hoja oculta simplemente hay que establecer esta propiedad en verdadero (True). El siguiente código te oculta todas las hojas, excepto la hoja activa.

<source lang="oobas">
hojas = doc.getSheets()

activa = doc.getCurrentController().getActiveSheet().getRangeAddress().Sheet
for i in range(hojas.getCount()):
if i != activa:
hojas.getByIndex(i).IsVisible = False
</source>

Tu tarea es hacer la función inversa, muestra todas las hojas ocultas.

== Protección y desprotección de hojas ==

Para terminar este capítulo, veamos como proteger una hoja, es decir, establecer una contraseña para evitar modificaciones a la misma, además, recuerda que para que la protección de celdas individuales sea efectiva, la hoja debe estar protegida. Para proteger una hoja, usamos el método '''protect(contraseña)''', pasándole como argumento, la contraseña que queremos establecer, por supuesto, puedes pasarle una contraseña vacía, con lo que la hoja no estará muy protegida que digamos, pero créeme, muchos usuarios no saben desproteger una hoja, aun sin contraseña.
<source lang=python>
activa = doc.getCurrentController().getActiveSheet()
activa.protect('letmein')
</source>

Y para desproteger, usamos el método '''unprotect(contraseña)''', si la hoja tiene contraseña hay que pasársela como argumento, si no es correcta, el método no te devolverá ningún error como en la interfaz del usuario que te avisa que la contraseña es incorrecta, para saber si tuvo éxito o no la desprotección, hay que verificar la propiedad '''isProtected''', si es verdadera (True) la hoja sigue protegida, si es falsa (False), la hoja esta desprotegida.
<source lang=python>
activa = doc.getCurrentController().getActiveSheet()
if activa.isProtected():
msgbox('Hoja protegida, se va a desproteger')
activa.unprotect('letmein')
if activa.isProtected():
msgbox('Contraseña incorrecta')
else:
msgbox('Hoja desprotegida correctamente')
else:
msgbox('La hoja no esta protegida')
</source>

Como comentarios finales, si intentas proteger una hoja que ya tiene contraseña, no obtendrás ningún error, pero la hoja permanecerá con la contraseña original, para cambiarla, primero tienes que desprotegerla y después cambiarla. Cuando proteges una hoja e intentas hacer modificaciones a esta, por ejemplo, escribir en una celda, tampoco retornará ningún error, pero no será efectiva la modificación.

{{ES/Foro|macros}}

[[Category:ES]][[Category:Manuales]][[Category:ES/Python]]

ES/Manuales/GuiaAOO/TemasAvanzados/Macros/Python/PythonCalc/TrabajandoConHojas

2013-05-10T05:02:49Z

Mauriciobaeza: /* Protección y desprotección de hojas */

{{DISPLAYTITLE:Trabajando con hojas}}

== Acceso a las hojas de un archivo Calc ==

Para acceder a todas las hojas de un archivo usamos el método '''getSheets'''.
<source lang=python>
doc = desktop.getCurrentComponent()
hojas = doc.getSheets()
</source>

Podemos devolver todos los nombres de las mismas.
<source lang=python>
doc = desktop.getCurrentComponent()
hojas = doc.getSheets()
nombres = hojas.getElementNames()
msgbox('\n'.join(nombres))
</source>

O acceder por nombre a la que nos interesa ('''getByName'''), tienes que validar ('''hasByName''') primero que existe esta hoja.

<source lang=python>
doc = desktop.getCurrentComponent()
hojas = doc.getSheets()
nombre = 'Hoja1'
if hojas.hasByName(nombre):
hoja = hojas.getByName(nombre)
else:
msgbox('No existe la hoja: %s' % nombre)
</source>

Podemos acceder a una hoja por su índice, recuerda que los índices en AOO empiezan en cero, en las hojas, la numeración empieza de izquierda a derecha.

<source lang=python>
doc = desktop.getCurrentComponent()
hojas = doc.getSheets()
indice = 1
hoja = hojas.getByIndex(indice)
msgbox (hoja.getName())
</source>

Del mismo modo que por el nombre, si tratas de acceder a una hoja por un índice que no exista, te dará un error, lo podemos comprobar asegurándonos que el numero de índice a consultar siempre es menor al total de las hojas.

<source lang=python>
doc = desktop.getCurrentComponent()
hojas = doc.getSheets()
indice = 1
if indice < hojas.getCount():
hoja = hojas.getByIndex(indice)
msgbox (hoja.getName())
else:
msgbox(u'No existe este índice: %s' % indice)
</source>

Podemos acceder a cada hoja por su índice, pero toma en cuenta que si mueves una hoja de posición en relación con las demás, su índice cambiara, no así su nombre, pero el nombre es susceptible de ser cambiado por el usuario, así que siempre comprueba que exista una hoja antes de intentar acceder a ella.

<source lang=python>
doc = desktop.getCurrentComponent()
hojas = doc.getSheets()
for i in range(hojas.getCount()):
msgbox(hojas.getByIndex(i).getName())
</source>

También es posible devolver la hoja activa.
<source lang=python>
doc = desktop.getCurrentComponent()
hoja = doc.getCurrentController().getActiveSheet()
msgbox(hoja.getName())
</source>

Creamos una función genérica para devolver una hoja.
<source lang=python>
def devuelve_hoja(doc, nombre):
if doc.getSheets().hasByName(nombre):
return doc.getSheets().getByName(nombre)
</source>

Para usarse de forma sencilla.
<source lang=python>
doc = desktop.getCurrentComponent()
nombre = 'Hoja2'
hoja = devuelve_hoja(doc, nombre)
if hoja:
msgbox(hoja.getName())
else:
msgbox('No se encontró la hoja: %s' % nombre)re)
</source>

== Insertando hojas ==
Para insertar nuevas hojas, usamos el método: '''insertNewByName(Nombre, Posición)''', en donde necesitamos el nombre de la nueva hoja a insertar y la posición donde la queremos, la siguiente macro agrega una hoja nueva al inicio de las demás.
<source lang=python>
hojas = doc.getSheets()
hojas.insertNewByName('Nuevos datos', 0)
</source>

Ejecuta la macro anterior dos veces y notaras que te dará un error, pues no puedes tener dos hojas con el mismo nombre, entonces, tenemos que verificar si la hoja existe o no.
<source lang=python>
nombre = 'Nueva hoja'
hojas = doc.getSheets()
if not hojas.hasByName(nombre):
hojas.insertNewByName(nombre, 0)
nueva_hoja = doc.getSheets().getByName(nombre)
doc.getCurrentController().setActiveSheet(nueva_hoja)
</source>

Observa que solo agregamos la hoja si esta no existe, entonces solo hacemos una referencia a ella. La ultima linea para activar la hoja no es necesaria para que la manipules, solo en caso de que quieras que el usuario haga o manipule algo en ella, si no, puedes omitirla.
{{Documentation/Note| Es sumamente frecuente en programadores noveles, querer '''activar''' toda hoja que se quiera manipular, esto no es necesario, solo activala, si estas seguro que esto es lo que quieres}}

También podemos agregar la hoja al final de todas las demás.
<source lang=python>
nombre = 'Otra hoja'
hojas = doc.getSheets()
if not hojas.hasByName(nombre):
hojas.insertNewByName(nombre, hojas.getCount())
nueva_hoja = doc.getSheets().getByName(nombre)
doc.getCurrentController().setActiveSheet(nueva_hoja)
</source>

Observa entonces que el argumento posición puede tomar valores desde 0 y hasta el total de hojas devuelto por '''getCount()''' pero incluso si es mayor a este valor, no te dará error y la insertara al final de las demás hojas. Si quieres insertar la hoja antes o después de la hoja activa, primero tienes que encontrar el índice de la hoja activa.
<source lang=python>
activa = doc.getCurrentController().getActiveSheet()
indice = activa.getRangeAddress().Sheet
msgbox(u'El índice de la hoja activa es: %s' % indice)
</source>

Que podemos convertir en una submacro. Nota como estamos estableciendo un '''valor por default''' para el ultimo argumento que será la posición deseada para la nueva hoja.
<source lang=python>
def nueva_hoja(doc, nombre, pos=0):
hojas = doc.getSheets()
if not hojas.hasByName(nombre):
activa = doc.getCurrentController().getActiveSheet()
indice = activa.getRangeAddress().Sheet
if pos == 1:
pos = indice
elif pos == 2:
pos = indice + 1
elif pos > 2:
pos = hojas.getCount()
hojas.insertNewByName(nombre, pos)
return hojas.getByName(nombre)
</source>

Ahora ya podemos insertar una nueva hoja en la posición que sea.
<source lang=python>
doc = desktop.getCurrentComponent()

nombre = 'Al inicio'
nueva = nueva_hoja(doc, nombre)

nombre = 'Antes de la activa'
nueva = nueva_hoja(doc, nombre, 1)

nombre = 'Despues de la activa'
nueva = nueva_hoja(doc, nombre, 2)

nombre = 'Al final'
nueva = nueva_hoja(doc, nombre, 3)
</source>

== Borrando hojas ==
Para borrar hojas, usamos el método '''removeByName(Nombre)''', donde '''''Nombre''''' es el nombre de la hoja que queremos borrar, no esta de más recomendarte usar con cuidado el borrado de hojas, aunque algo que me gusta mucho de AOO, es que muchas de las acciones que hacemos por código, son susceptibles de deshacerse de forma normal con la barra de herramientas o con CTRL+Z, el borrado de hojas es una de ellas, compruébalo.
<source lang=python>
hojas = doc.getSheets()
hojas.removeByName('Hoja3')
</source>

Por supuesto no puedes borrar una hoja que no exista, así que verifícalo.
<source lang=python>
nombre = 'Hoja2'
hojas = doc.getSheets()
if hojas.hasByName(nombre):
hojas.removeByName(nombre)
else:
msgbox('No existe la hoja: %s' % nombre)
</source>

Puedes borrar la hoja activa.
<source lang=python>
activa = doc.getCurrentController().getActiveSheet()
hojas = doc.getSheets()
hojas.removeByName(activa.getName())
</source>

Ejecuta la macro anterior hasta que no quede ni una, claro, no te dejara por que un documento de hoja de calculo por lo menos debe de tener una hoja, para evitar el error que te da al tratar de borrar la ultima hoja, valida que siempre quede más de una.
<source lang=python>
nombre = 'borrame'
hojas = doc.getSheets()
if hojas.hasByName(nombre) and hojas.getCount() > 1:
hojas.removeByName(nombre)
else:
msgbox('La hoja no existe o solo queda una')
</source>

== Moviendo hojas ==
Para mover hojas usamos el método '''moveByName(NombreHoja, PosicionNueva)''', donde '''''NombreHoja''''' tiene que ser el nombre de una hoja existente. En el siguiente ejemplo movemos la hoja al inicio.
<source lang=python>
hojas = doc.getSheets()
hojas.moveByName('Hoja3', 0)
</source>

Ahora, la movemos al final.
<source lang=python>
hojas = doc.getSheets()
hojas.moveByName('Hoja3', hojas.getCount())
</source>

Vamos a hacer algo muy divertido, como ya sabemos obtener los nombres e índices de cada hoja, y ahora hemos aprendido a mover hojas, hagamos una macro que nos ordene alfabéticamente nuestras hojas.
<source lang=python>
hojas = doc.getSheets()
nombres = sorted(hojas.getElementNames())
for i,v in enumerate(nombres):
hojas.moveByName(v, i)
</source>

== Copiando hojas ==
Para copiar hojas usamos el método '''copyByName(NombreHoja, NombreNuevo, Posicion)''' de la siguiente manera.
<source lang=python>
hojas = doc.getSheets()
hojas.copyByName('Hoja2', 'Nueva hoja2', 0)
</source>

Por supuesto el nombre de la hoja a copiar debe de existir y el nombre nuevo de la hoja no debe existir, lo mejor, es evaluarlo antes.
<source lang=python>
nombre = 'Datos'
nombre_nuevo = 'Datos nuevos'
hojas = doc.getSheets()
if hojas.hasByName(nombre) and not hojas.hasByName(nombre_nuevo):
hojas.copyByName(nombre, nombre_nuevo, hojas.getCount())
else:
msgbox('No se copio la hoja')
</source>

Podemos intentar copiar una hoja y asegurarnos de que el nombre no exista, tomando como base el nombre actual de la hoja, por ejemplo.
<source lang=python>
hojas = doc.getSheets()
nombre = doc.getCurrentController().getActiveSheet().getName()
co1 = 1
nombre_nuevo = '%s_%s' % (nombre, co1)
while hojas.hasByName(nombre_nuevo):
co1 += 1
nombre_nuevo = '%s_%s' % (nombre, co1)
hojas.copyByName(nombre, nombre_nuevo, hojas.getCount())
hoja = hojas.getByName(nombre_nuevo)
doc.getCurrentController().setActiveSheet(hoja)
</source>

== Renombrando hojas ==

Para renombrar hojas usamos el método '''setName(NuevoNombre)''', de la siguiente manera.
<source lang=python>
hojas = doc.getSheets()
hojas.getByName('Hola').setName('Prueba')
</source>

También puedes usar el índice para referirte a la hoja.
<source lang=python>
hojas = doc.getSheets()
hojas.getByIndex(0).setName('Prueba')
</source>

Es recomendable validar que la hoja a renombrar exista y que el nuevo nombre no.
<source lang=python>
hojas = doc.getSheets()
actual = 'Resumen'
nuevo = 'Terminado'
# Validamos que la hoja exista y el nuevo nombre no
if hojas.hasByName(actual) and not hojas.hasByName(nuevo):
hojas.getByName(actual).setName(nuevo)
else:
msgbox('No es posible renombrar la hoja')
</source>

Solo para divertirnos, cambiamos los nombres de las hojas por números.
<source lang=python>
hojas = doc.getSheets()
for i in range(hojas.getCount()):
hojas.getByIndex(i).setName(i+1)
</source>

Ahora por letras, el código siguiente podría fallar en algunas circunstancias, tu tarea es decirnos ¿porqué? y corregirlo.
<source lang=python>
hojas = doc.getSheets()
for i in range(hojas.getCount()):
hojas.getByIndex(i).setName(chr(i+65))
</source>

O los meses del año:
<source lang=python>
import uno
import datetime
import locale
locale.setlocale(locale.LC_ALL, '')

def pruebas():
ctx = uno.getComponentContext()
sm = ctx.getServiceManager()

desktop = sm.createInstanceWithContext('com.sun.star.frame.Desktop', ctx)
doc = desktop.getCurrentComponent()

hojas = doc.getSheets()
for i in range(hojas.getCount()):
hojas.getByIndex(i).setName(datetime.date(2013, i+1, 1).strftime('%B'))
return
</source>

Observa que hacemos uso de dos nuevas librerias de Python, '''datetime''' que tiene muchas utiles funciones para trabajar con fechas y tiempo, y '''locale''' para que los meses nos salgan en español.

== Ocultando y mostrando hojas ==

Mostrar y ocultar hojas es muy sencillo, solo hay que establecer su propiedad '''IsVisible''' en verdadero (True) o falso (False) según se requiera de la siguiente manera.
<source lang=python>
activa = doc.getCurrentController().getActiveSheet()
activa.IsVisible = False
</source>

La macro anterior te ocultara la hoja activa, si la ejecutas varias veces te ira ocultando tus hojas hasta que solo quede una, si solo hay una no te dará error, pero la dejará visible por que, como sabes, tiene que haber al menos una hoja visible en un documento de Calc. Si ocultas una hoja, esta no cambia de índice por lo que puedes usar el mismo para acceder a ella, aunque este oculta, la siguiente macro alterna entre mostrar y ocultar la segunda hoja del documento.
<source lang=python>
hoja = doc.getSheets().getByIndex(1)
hoja.IsVisible = not hoja.IsVisible
doc.getCurrentController().setActiveSheet(hoja)
</source>

Como ya habrás intuido, para mostrar una hoja oculta simplemente hay que establecer esta propiedad en verdadero (True). El siguiente código te oculta todas las hojas, excepto la hoja activa.

<source lang="oobas">
hojas = doc.getSheets()

activa = doc.getCurrentController().getActiveSheet().getRangeAddress().Sheet
for i in range(hojas.getCount()):
if i != activa:
hojas.getByIndex(i).IsVisible = False
</source>

Tu tarea es hacer la función inversa, muestra todas las hojas ocultas.

== Protección y desprotección de hojas ==

Para terminar este capítulo, veamos como proteger una hoja, es decir, establecer una contraseña para evitar modificaciones a la misma, además, recuerda que para que la protección de celdas individuales sea efectiva, la hoja debe estar protegida. Para proteger una hoja, usamos el método '''protect(contraseña)''', pasándole como argumento, la contraseña que queremos establecer, por supuesto, puedes pasarle una contraseña vacía, con lo que la hoja no estará muy protegida que digamos, pero créeme, muchos usuarios no saben desproteger una hoja, aun sin contraseña.
<source lang=python>
activa = doc.getCurrentController().getActiveSheet()
activa.protect('letmein')
</source>

Y para desproteger, usamos el método '''unprotect(contraseña)''', si la hoja tiene contraseña hay que pasársela como argumento, si no es correcta, el método no te devolverá ningún error como en la interfaz del usuario que te avisa que la contraseña es incorrecta, para saber si tuvo éxito o no la desprotección, hay que verificar la propiedad '''isProtected''', si es verdadera (True) la hoja sigue protegida, si es falsa (False), la hoja esta desprotegida.
<source lang=python>
activa = doc.getCurrentController().getActiveSheet()
activa = doc.getCurrentController().getActiveSheet()
if activa.isProtected():
msgbox('Hoja protegida, se va a desproteger')
activa.unprotect('letmein')
if activa.isProtected():
msgbox('Contraseña incorrecta')
else:
msgbox('Hoja desprotegida correctamente')
else:
msgbox('La hoja no esta protegida')
</source>

Como comentarios finales, si intentas proteger una hoja que ya tiene contraseña, no obtendrás ningún error, pero la hoja permanecerá con la contraseña original, para cambiarla, primero tienes que desprotegerla y después cambiarla. Cuando proteges una hoja e intentas hacer modificaciones a esta, por ejemplo, escribir en una celda, tampoco retornará ningún error, pero no será efectiva la modificación.

{{ES/Foro|macros}}

[[Category:ES]][[Category:Manuales]][[Category:ES/Python]]

ES/Manuales/GuiaAOO/TemasAvanzados/Macros/Python/PythonCalc/TrabajandoConHojas

2013-05-10T04:46:53Z

Mauriciobaeza: /* Ocultando y mostrando hojas */

ES/Manuales/GuiaAOO/TemasAvanzados/Macros/Python/PythonCalc/TrabajandoConHojas

2013-05-10T04:30:58Z

Mauriciobaeza: /* Renombrando hojas */

{{DISPLAYTITLE:Trabajando con hojas}}

== Acceso a las hojas de un archivo Calc ==

Para acceder a todas las hojas de un archivo usamos el método '''getSheets'''.
<source lang=python>
doc = desktop.getCurrentComponent()
hojas = doc.getSheets()
</source>

Podemos devolver todos los nombres de las mismas.
<source lang=python>
doc = desktop.getCurrentComponent()
hojas = doc.getSheets()
nombres = hojas.getElementNames()
msgbox('\n'.join(nombres))
</source>

O acceder por nombre a la que nos interesa ('''getByName'''), tienes que validar ('''hasByName''') primero que existe esta hoja.

<source lang=python>
doc = desktop.getCurrentComponent()
hojas = doc.getSheets()
nombre = 'Hoja1'
if hojas.hasByName(nombre):
hoja = hojas.getByName(nombre)
else:
msgbox('No existe la hoja: %s' % nombre)
</source>

Podemos acceder a una hoja por su índice, recuerda que los índices en AOO empiezan en cero, en las hojas, la numeración empieza de izquierda a derecha.

<source lang=python>
doc = desktop.getCurrentComponent()
hojas = doc.getSheets()
indice = 1
hoja = hojas.getByIndex(indice)
msgbox (hoja.getName())
</source>

Del mismo modo que por el nombre, si tratas de acceder a una hoja por un índice que no exista, te dará un error, lo podemos comprobar asegurándonos que el numero de índice a consultar siempre es menor al total de las hojas.

<source lang=python>
doc = desktop.getCurrentComponent()
hojas = doc.getSheets()
indice = 1
if indice < hojas.getCount():
hoja = hojas.getByIndex(indice)
msgbox (hoja.getName())
else:
msgbox(u'No existe este índice: %s' % indice)
</source>

Podemos acceder a cada hoja por su índice, pero toma en cuenta que si mueves una hoja de posición en relación con las demás, su índice cambiara, no así su nombre, pero el nombre es susceptible de ser cambiado por el usuario, así que siempre comprueba que exista una hoja antes de intentar acceder a ella.

<source lang=python>
doc = desktop.getCurrentComponent()
hojas = doc.getSheets()
for i in range(hojas.getCount()):
msgbox(hojas.getByIndex(i).getName())
</source>

También es posible devolver la hoja activa.
<source lang=python>
doc = desktop.getCurrentComponent()
hoja = doc.getCurrentController().getActiveSheet()
msgbox(hoja.getName())
</source>

Creamos una función genérica para devolver una hoja.
<source lang=python>
def devuelve_hoja(doc, nombre):
if doc.getSheets().hasByName(nombre):
return doc.getSheets().getByName(nombre)
</source>

Para usarse de forma sencilla.
<source lang=python>
doc = desktop.getCurrentComponent()
nombre = 'Hoja2'
hoja = devuelve_hoja(doc, nombre)
if hoja:
msgbox(hoja.getName())
else:
msgbox('No se encontró la hoja: %s' % nombre)re)
</source>

== Insertando hojas ==
Para insertar nuevas hojas, usamos el método: '''insertNewByName(Nombre, Posición)''', en donde necesitamos el nombre de la nueva hoja a insertar y la posición donde la queremos, la siguiente macro agrega una hoja nueva al inicio de las demás.
<source lang=python>
hojas = doc.getSheets()
hojas.insertNewByName('Nuevos datos', 0)
</source>

Ejecuta la macro anterior dos veces y notaras que te dará un error, pues no puedes tener dos hojas con el mismo nombre, entonces, tenemos que verificar si la hoja existe o no.
<source lang=python>
nombre = 'Nueva hoja'
hojas = doc.getSheets()
if not hojas.hasByName(nombre):
hojas.insertNewByName(nombre, 0)
nueva_hoja = doc.getSheets().getByName(nombre)
doc.getCurrentController().setActiveSheet(nueva_hoja)
</source>

Observa que solo agregamos la hoja si esta no existe, entonces solo hacemos una referencia a ella. La ultima linea para activar la hoja no es necesaria para que la manipules, solo en caso de que quieras que el usuario haga o manipule algo en ella, si no, puedes omitirla.
{{Documentation/Note| Es sumamente frecuente en programadores noveles, querer '''activar''' toda hoja que se quiera manipular, esto no es necesario, solo activala, si estas seguro que esto es lo que quieres}}

También podemos agregar la hoja al final de todas las demás.
<source lang=python>
nombre = 'Otra hoja'
hojas = doc.getSheets()
if not hojas.hasByName(nombre):
hojas.insertNewByName(nombre, hojas.getCount())
nueva_hoja = doc.getSheets().getByName(nombre)
doc.getCurrentController().setActiveSheet(nueva_hoja)
</source>

Observa entonces que el argumento posición puede tomar valores desde 0 y hasta el total de hojas devuelto por '''getCount()''' pero incluso si es mayor a este valor, no te dará error y la insertara al final de las demás hojas. Si quieres insertar la hoja antes o después de la hoja activa, primero tienes que encontrar el índice de la hoja activa.
<source lang=python>
activa = doc.getCurrentController().getActiveSheet()
indice = activa.getRangeAddress().Sheet
msgbox(u'El índice de la hoja activa es: %s' % indice)
</source>

Que podemos convertir en una submacro. Nota como estamos estableciendo un '''valor por default''' para el ultimo argumento que será la posición deseada para la nueva hoja.
<source lang=python>
def nueva_hoja(doc, nombre, pos=0):
hojas = doc.getSheets()
if not hojas.hasByName(nombre):
activa = doc.getCurrentController().getActiveSheet()
indice = activa.getRangeAddress().Sheet
if pos == 1:
pos = indice
elif pos == 2:
pos = indice + 1
elif pos > 2:
pos = hojas.getCount()
hojas.insertNewByName(nombre, pos)
return hojas.getByName(nombre)
</source>

Ahora ya podemos insertar una nueva hoja en la posición que sea.
<source lang=python>
doc = desktop.getCurrentComponent()

nombre = 'Al inicio'
nueva = nueva_hoja(doc, nombre)

nombre = 'Antes de la activa'
nueva = nueva_hoja(doc, nombre, 1)

nombre = 'Despues de la activa'
nueva = nueva_hoja(doc, nombre, 2)

nombre = 'Al final'
nueva = nueva_hoja(doc, nombre, 3)
</source>

== Borrando hojas ==
Para borrar hojas, usamos el método '''removeByName(Nombre)''', donde '''''Nombre''''' es el nombre de la hoja que queremos borrar, no esta de más recomendarte usar con cuidado el borrado de hojas, aunque algo que me gusta mucho de AOO, es que muchas de las acciones que hacemos por código, son susceptibles de deshacerse de forma normal con la barra de herramientas o con CTRL+Z, el borrado de hojas es una de ellas, compruébalo.
<source lang=python>
hojas = doc.getSheets()
hojas.removeByName('Hoja3')
</source>

Por supuesto no puedes borrar una hoja que no exista, así que verifícalo.
<source lang=python>
nombre = 'Hoja2'
hojas = doc.getSheets()
if hojas.hasByName(nombre):
hojas.removeByName(nombre)
else:
msgbox('No existe la hoja: %s' % nombre)
</source>

Puedes borrar la hoja activa.
<source lang=python>
activa = doc.getCurrentController().getActiveSheet()
hojas = doc.getSheets()
hojas.removeByName(activa.getName())
</source>

Ejecuta la macro anterior hasta que no quede ni una, claro, no te dejara por que un documento de hoja de calculo por lo menos debe de tener una hoja, para evitar el error que te da al tratar de borrar la ultima hoja, valida que siempre quede más de una.
<source lang=python>
nombre = 'borrame'
hojas = doc.getSheets()
if hojas.hasByName(nombre) and hojas.getCount() > 1:
hojas.removeByName(nombre)
else:
msgbox('La hoja no existe o solo queda una')
</source>

== Moviendo hojas ==
Para mover hojas usamos el método '''moveByName(NombreHoja, PosicionNueva)''', donde '''''NombreHoja''''' tiene que ser el nombre de una hoja existente. En el siguiente ejemplo movemos la hoja al inicio.
<source lang=python>
hojas = doc.getSheets()
hojas.moveByName('Hoja3', 0)
</source>

Ahora, la movemos al final.
<source lang=python>
hojas = doc.getSheets()
hojas.moveByName('Hoja3', hojas.getCount())
</source>

Vamos a hacer algo muy divertido, como ya sabemos obtener los nombres e índices de cada hoja, y ahora hemos aprendido a mover hojas, hagamos una macro que nos ordene alfabéticamente nuestras hojas.
<source lang=python>
hojas = doc.getSheets()
nombres = sorted(hojas.getElementNames())
for i,v in enumerate(nombres):
hojas.moveByName(v, i)
</source>

== Copiando hojas ==
Para copiar hojas usamos el método '''copyByName(NombreHoja, NombreNuevo, Posicion)''' de la siguiente manera.
<source lang=python>
hojas = doc.getSheets()
hojas.copyByName('Hoja2', 'Nueva hoja2', 0)
</source>

Por supuesto el nombre de la hoja a copiar debe de existir y el nombre nuevo de la hoja no debe existir, lo mejor, es evaluarlo antes.
<source lang=python>
nombre = 'Datos'
nombre_nuevo = 'Datos nuevos'
hojas = doc.getSheets()
if hojas.hasByName(nombre) and not hojas.hasByName(nombre_nuevo):
hojas.copyByName(nombre, nombre_nuevo, hojas.getCount())
else:
msgbox('No se copio la hoja')
</source>

Podemos intentar copiar una hoja y asegurarnos de que el nombre no exista, tomando como base el nombre actual de la hoja, por ejemplo.
<source lang=python>
hojas = doc.getSheets()
nombre = doc.getCurrentController().getActiveSheet().getName()
co1 = 1
nombre_nuevo = '%s_%s' % (nombre, co1)
while hojas.hasByName(nombre_nuevo):
co1 += 1
nombre_nuevo = '%s_%s' % (nombre, co1)
hojas.copyByName(nombre, nombre_nuevo, hojas.getCount())
hoja = hojas.getByName(nombre_nuevo)
doc.getCurrentController().setActiveSheet(hoja)
</source>

== Renombrando hojas ==

Para renombrar hojas usamos el método '''setName(NuevoNombre)''', de la siguiente manera.
<source lang=python>
hojas = doc.getSheets()
hojas.getByName('Hola').setName('Prueba')
</source>

También puedes usar el índice para referirte a la hoja.
<source lang=python>
hojas = doc.getSheets()
hojas.getByIndex(0).setName('Prueba')
</source>

Es recomendable validar que la hoja a renombrar exista y que el nuevo nombre no.
<source lang=python>
hojas = doc.getSheets()
actual = 'Resumen'
nuevo = 'Terminado'
# Validamos que la hoja exista y el nuevo nombre no
if hojas.hasByName(actual) and not hojas.hasByName(nuevo):
hojas.getByName(actual).setName(nuevo)
else:
msgbox('No es posible renombrar la hoja')
</source>

Solo para divertirnos, cambiamos los nombres de las hojas por números.
<source lang=python>
hojas = doc.getSheets()
for i in range(hojas.getCount()):
hojas.getByIndex(i).setName(i+1)
</source>

Ahora por letras, el código siguiente podría fallar en algunas circunstancias, tu tarea es decirnos ¿porqué? y corregirlo.
<source lang=python>
hojas = doc.getSheets()
for i in range(hojas.getCount()):
hojas.getByIndex(i).setName(chr(i+65))
</source>

O los meses del año:
<source lang=python>
import uno
import datetime
import locale
locale.setlocale(locale.LC_ALL, '')

def pruebas():
ctx = uno.getComponentContext()
sm = ctx.getServiceManager()

desktop = sm.createInstanceWithContext('com.sun.star.frame.Desktop', ctx)
doc = desktop.getCurrentComponent()

hojas = doc.getSheets()
for i in range(hojas.getCount()):
hojas.getByIndex(i).setName(datetime.date(2013, i+1, 1).strftime('%B'))
return
</source>

Observa que hacemos uso de dos nuevas librerias de Python, '''datetime''' que tiene muchas utiles funciones para trabajar con fechas y tiempo, y '''locale''' para que los meses nos salgan en español.

== Ocultando y mostrando hojas ==

== Protección y desprotección de hojas ==

[[Category:ES/Python]]

ES/Manuales/GuiaAOO/TemasAvanzados/Macros/Python/Apendices

2013-05-09T15:43:03Z

Mauriciobaeza:

{{DISPLAYTITLE: Apéndices}}
== Obtener lista de filtros soportados por AOO ==
<source lang=python>
def obtener_filtros():
ctx = uno.getComponentContext()
sm = ctx.getServiceManager()
desktop = sm.createInstanceWithContext('com.sun.star.frame.Desktop', ctx)

ff = sm.createInstance('com.sun.star.document.FilterFactory')
filtros = ff.getElementNames()

ruta = 'private:factory/swriter'
doc = desktop.loadComponentFromURL(ruta, '_blank', 0, ())
doc.getText().setString('\n'.join(filtros))
return
</source>

{{ES/Foro|macros}}

[[Category:ES]][[Category:Manuales]][[Category:ES/Python]]

ES/Manuales/GuiaAOO/TemasAvanzados/Macros/Python/PythonCalc

2013-05-09T15:42:22Z

Mauriciobaeza:

{{DISPLAYTITLE: Trabajando con Calc}}
En todos los temas de esta sección, asumimos que el lector ha leído y comprendido, todos los temas introductorios a este.

<big>
:*[[ES/Manuales/GuiaAOO/TemasAvanzados/Macros/Python/PythonCalc/TrabajandoConHojas|Trabajando con hojas]]
:*[[ES/Manuales/GuiaAOO/TemasAvanzados/Macros/Python/PythonCalc/ReferenciaARangos|Referencia a rangos]]
:*[[ES/Manuales/GuiaAOO/TemasAvanzados/Macros/Python/PythonCalc/ManipulandoRangos|Manipulando rangos]]
:*[[ES/Manuales/GuiaAOO/TemasAvanzados/Macros/Python/PythonCalc/ManipulandoDatos|Manipulando datos]]
:*[[ES/Manuales/GuiaAOO/TemasAvanzados/Macros/Python/PythonCalc/DandoFormato|Dando formato]]
:*[[ES/Manuales/GuiaAOO/TemasAvanzados/Macros/Python/PythonCalc/Imprimiendo|Imprimiendo]]
:*[[ES/Manuales/GuiaAOO/TemasAvanzados/Macros/Python/PythonCalc/RangosDeDatos|Rangos de datos]]
:*[[ES/Manuales/GuiaAOO/TemasAvanzados/Macros/Python/PythonCalc/BasesDeDatos|Bases de datos]]
:*[[ES/Manuales/GuiaAOO/TemasAvanzados/Macros/Python/PythonCalc/GraficandoDatos|Graficando datos]]
:*[[ES/Manuales/GuiaAOO/TemasAvanzados/Macros/Python/PythonCalc/TrabajandoConElementosGraficos|Trabajando con elementos gráficos]]
:*[[ES/Manuales/GuiaAOO/TemasAvanzados/Macros/Python/PythonCalc/ConfiguracionGlobalCalc|Configuración global de Calc]]
</big>

{{ES/Foro|macros}}

[[Category:ES]][[Category:Manuales]][[Category:ES/Python]]

ES/Manuales/GuiaAOO/TemasAvanzados/Macros/Python/PythonAOO

2013-05-09T15:40:58Z

Mauriciobaeza:

{{DISPLAYTITLE:Trabajando con Apache OpenOffice}}

== Conceptos iniciales==

Este es el tema más importante para crear macros, de forma sencilla, pero se ven las bases para trabajar con todo AOO, por eso es importante no avanzar en estas notas, sin antes haber comprendido a cabalidad los temas presentes.

'''UNO''' (Universal Network Objects), es la especificación que da acceso a todos los objetos de Apache OpenOffice. Todo lo que quieras saber de esta especificación, lo puedes encontrar en la [[http://wiki.openoffice.org/wiki/Documentation/DevGuide/OpenOffice.org_Developers_Guide Guía del desarrollador]] (en ingles).

El '''API''' (Application Programer Interface) de Apache OpenOffice proporciona el acceso a toda la funcionalidad de AOO, independientemente del lenguaje. Todo el API de AOO esta en <idl>com.sun.star.module-ix</idl> (solo ingles).

La comunicación entre objetos UNO se basa en '''interfaces''' de objeto. Las interfaces pueden ser vistos desde el exterior o el interior de un objeto y proporcionan formas de ver o manipular el objeto.

Los '''servicios''' son agrupaciones lógicas de interfaces, son la forma en que un mismo objeto pueda ofrecer la funcionalidad de varias interfaces.

Los servicios se pueden implementar en librerías compartidas llamadas '''componentes UNO''', con Python podemos crear componentes nuevos y generalmente el usuario final las recibe como una extensión OXT.

Los '''modulos''' pueden agrupar submodulos, servicios, excepciones, constantes, enumeraciones, etc, se utilizan para especificar bloques coherentes en la API, esto permite tener un API bien estructurada.

== Creando servicios ==
Para crear un servicio, usamos la '''fabrica de servicios''' (<idl>com.sun.star.lang.XMultiComponentFactory</idl>), una interfaz especial para crear nuevos servicios, pero para llegar a ella, tenemos que hacerlo a traves de la interfaz '''ComponentContext''' (<idl>com.sun.star.uno.XComponentContext</idl>), como puedes verlo en la siguiente imagen.
[[Image:UseServices1.png|none|thumb|400px|ComponentContext y ServiceManager]]

En pyUNO tenemos dos formas de acceder a esta interfaz, las dos son equivalentes por lo que puedes usar la que prefieras. En la introducción a Python se mencionó que la mayoría de sus herramientas están disponibles en librerias, estás librerias tienen que importarse '''antes''' de poder usarse, en nuestro caso importaremos la librería '''uno''' que nos da acceso (entre otras cosas) al contexto de ejecución de AOO.
<source lang=python>
import uno

def pruebas():
ctx1 = XSCRIPTCONTEXT.getComponentContext()
ctx2 = uno.getComponentContext()
return
</source>
{{Documentation/Note| Si te gusta investigar, busca el archivo '''pythonscript.py''' en la carpeta de instalación de AOO, ahí puedes ver de donde sale XSCRIPTCONTEXT}}

Ahora si, podemos acceder a la fábrica de servicios con el '''método getServiceManager()'''.
<source lang=python>
import uno

def pruebas():
ctx = uno.getComponentContext()
sm = ctx.getServiceManager()
return
</source>

Pero... ¿como sabemos que este '''objeto (ComponentContext)''' tiene este '''método getServiceManager()'''? porque lo estamos demostrando, si, también por eso, pero también porque puedes ver su documentación (<idl>com.sun.star.uno.XComponentContext</idl>) en el API de AOO, pero más importante aún, porque podemos hacer que el mismo objeto te diga todo lo que sabe hacer. Para ello haremos uso de una magnifica extensión que te tiene que acompañar el resto de tus días como programador de macros Python, nos referimos a [http://extensions.services.openoffice.org/project/MRI MRI]. Instala (tal vez tengas que reiniciar AOO para poder usarla) y la probamos de la siguiente manera.
<source lang=python>
import uno

def pruebas():
ctx = uno.getComponentContext()
# llamamos a la extensión MRI y le pasamos el objeto a inspeccionar
mri(ctx)
sm = ctx.getServiceManager()
return

def mri(target):
ctx = uno.getComponentContext()
sm = ctx.getServiceManager()
mri = sm.createInstanceWithContext('mytools.Mri', ctx)
mri.inspect(target)
return
</source>

Observa en la imágen siguiente, como hemos seleccionado los métodos del objeto y nos lista todos los que tenga, hemos remarcado el que por ahora nos interesa '''getServiceManager()''', observa al final de la línea que efectivamente este método nos devuelve una '''instancia''' de la interfaz <idl>com.sun.star.lang.XMultiComponentFactory</idl>.
[[Image:Py_img_0006.png|none|thumb|500px|Usando la extensión MRI]]

La gran ventaja de usar esta extensión (que por cierto esta hecha en Python), es que siempre te devolverá la información directamente del objeto, a esto se le llama '''instrospección'''. Acostumbrate a usarla.

Ahora si, ya podemos crear una instancia de cualquier servicio o interfaz disponible en AOO, por ejemplo, el servicio <idl>com.sun.star.frame.Desktop</idl>.
<source lang=python>
import uno

def pruebas():
ctx = uno.getComponentContext()
sm = ctx.getServiceManager()
desktop = sm.createInstanceWithContext('com.sun.star.frame.Desktop', ctx)
return
</source>

Existe una forma alternativa de crear este servicio, usando '''XSCRIPTCONTEXT''' de la siguiente manera.
<source lang=python>
XSCRIPTCONTEXT.getDesktop()
</source>
{{Documentation/Note| Si vuelves a mirar el archivo '''pythonscript.py''' notaras que usa el mismo método para instanciar este servicio}}

¿Y para que sirve este servicio? Entre otras cosas para crear nuevos documentos.
<source lang=python>
nuevo = desktop.loadComponentFromURL('private:factory/scalc', '_default', 0, ())
</source>

Más adelante veremos a detalle este método y otros relacionados con los documentos de AOO.

El servicio <idl>com.sun.star.frame.Desktop</idl> es la instancia de la administración central para todas las aplicaciones AOO. Todas las ventanas de la aplicación AOO se organizan en una jerarquía de marcos que contienen componentes visibles.

[[Image:DesktopOverview.png|none|thumb|400px|Desktop administra los componentes y marcos.]]

Para los fines de crear macros es suficiente que recuerdes que, Desktop es el marco raíz de toda la jerarquía de documentos.

Para crear la instancia del servicio <idl>com.sun.star.frame.Desktop</idl> usamos un contexto y usamos el método '''createInstanceWithContext'''. Otros servicios no requieren de contexto para ser instanciados y usados, por ejemplo, el servicio <idl>com.sun.star.util.PathSettings</idl> que nos sirve para obtener las rutas de trabajo actuales en AOO, para estos casos usamos el método '''createInstance'''.
<source lang=python>
rutas = sm.createInstance('com.sun.star.util.PathSettings')
# mostramos la ruta de trabajo del usuario
print (rutas.Work)
</source>

Ahora que ya sabemos instanciar servicios, veamos de nuevo nuestra macro para mostrar un mensaje en pantalla y analicemosla línea a línea para que veas que sencillo es, además, nos servirá para ver otros detalles al programar con Python en AOO. La macro tiene ahora unos ligeros cambios para que trabaje mejor y para explicar algunas cosas, veamos cuales.
<source lang=python>
def msgbox(message):
from com.sun.star.awt import Rectangle
from com.sun.star.awt.MessageBoxButtons import BUTTONS_OK

if not isinstance(message, (unicode, str)):
message = str(message)
ctx = uno.getComponentContext()
sm = ctx.getServiceManager()
toolkit = sm.createInstanceWithContext('com.sun.star.awt.Toolkit', ctx)
MsgBox = toolkit.createMessageBox(
toolkit.getDesktopWindow(),
Rectangle(),
'infobox',
BUTTONS_OK,
'pyUNO',
message)
return MsgBox.execute()
</source>

En la primer línea '''declaramos''' nuestra macro, su nombre y los argumentos que necesita, en este caso solo uno '''message''' que será el mensaje a mostrar.
<source lang=python>
def msgbox(message):
</source>

En la segunda línea, estamos importando ('''import''') la estructura '''Rectangle''' desde ('''from''') el modulo <idl>com.sun.star.awt.module-ix</idl>.
<source lang=python>
from com.sun.star.awt import Rectangle
</source>
Las estructuras son un conjunto de valores relacionados, valores que pueden ser de tipos diferentes, pero que son mostrados como una unidad lógica, por ejemplo, la estructura <idl>com.sun.star.awt.Rectangle</idl> hace referencia a un área rectangular estableciendo su posición y tamaño, en este caso, solo sirve para cumplir los argumentos del método para mostrar nuestro mensaje.

En la tercer línea, hacemos otra importación, pero esta vez la hacemos de una constante, específicamente la constante para mostrar el botón '''Aceptar''' (OK), estas constantes las puedes ver aquí: <idl>com.sun.star.awt.MessageBoxButtons</idl>
<source lang=python>
from com.sun.star.awt.MessageBoxButtons import BUTTONS_OK
</source>

La cuarta línea esta vacía solo para separar la parte de importacion con el resto del código. En la siguiente línea hacemos una validación del argumento pasado a nuestra macro, si el argumento '''no''' es una instancia de la clase '''unicode''' o de la clase '''str''', entonces la convertimos a '''str''', esto nos permite pasar a nuestra macro, listas, tuplas, diccionarios y practicamente cualquier objeto, del cual, podremos ver su representación en texto, muchas veces, con información bastante útil.
<source lang=python>
if not isinstance(message, (unicode, str)):
message = str(message)
</source>

La siguiente línea ya la hemos estudiado, creamos una instancia del contexto donde se ejecuta AOO.
<source lang=python>
ctx = uno.getComponentContext()
</source>

La siguiente línea también ya la hemos estudiado, creamos una instancia de la fabrica de servicios, una de las instancias más importantes y que usaras constantemente.
<source lang=python>
sm = ctx.getServiceManager()
</source>

En la siguiente línea creamos una instancia con contexto de un nuevo servicio <idl>com.sun.star.awt.Toolkit</idl>, este servicio sirve, entre otras muchas cosas para crear ventanas y mensaje de texto, como el de nuestra macro.
<source lang=python>
toolkit = sm.createInstanceWithContext('com.sun.star.awt.Toolkit', ctx)
</source>

En la penultima línea, usamos el método '''createMessageBox''' del servicio <idl>com.sun.star.awt.Toolkit</idl> para crear nuestro cuadro de mensaje, todos los argumentos de este método puedes verlo aquí: <idl>com.sun.star.awt.XMessageBoxFactory</idl>, pero aquí los explicamos uno a uno.
<source lang=python>
MsgBox = toolkit.createMessageBox(
toolkit.getDesktopWindow(),
Rectangle(),
'infobox',
BUTTONS_OK,
'pyUNO',
message)
</source>
Aunque veas muchas líneas, el interpete la considera una sola, esto se logra al estar todos los argumentos entre paréntesis.
* El primer argumento es la ventana padre ('''parent''') donde será mostrado el cuadro de mensaje, observa como usamos de nuevo el servicio '''toolkit''' para recuperar ('''getDesktopWindow''') la ventana padre de AOO.
* El segundo argumento es el área rectangular del cuadro de mensaje, observa los dos paréntesis al final del nombre de la estructura, son necesarios para inicializarla.
* El tercer argumento es el tipo de mensaje, dependiendo de este argumento se muestra el icono correspondiente, los valores permitidos son: '''infobox, warningbox, errorbox, querybox y messbox''', si usas '''infobox''', el siguiente argumento es ignorado.
* El cuarto argumento sirve para mostrar botones de comando diferentes, como: '''Si, No, Cancelar''', etc, que están establecidos en las constantes vistas más arriba.
* El quinto argumento es el título del cuadro de mensaje.
* Y por ultimo, el mensaje a mostrar, el cual ya validamos.

En la ultima línea al mismo tiempo que mostramos ('''ejecute''') estamos retornando el cuadro de mensaje, esto nos da la posibilidad de capturar el botón al que le haya dado click el usuario, lo cual, veremos más adelante. Todas las macros retornan un valor, aun y cuando este sea un valor vacío (None).
<source lang=python>
return MsgBox.execute()
</source>

Resumiendo, los servicio los instanciamos y las estructuras y constantes las importamos, y el punto más importante; '''acostúmbrate a usar, manejar y dominar, la extensión MRI''', ella te dice todo lo necesario para trabajar con los objetos UNO de AOO, los demás, es sencillo.

== El documento activo ==

Tenemos dos formas de acceder al documento activo.

<source lang=python>
doc1 = XSCRIPTCONTEXT.getDocument()
doc2 = desktop.getCurrentComponent()
print (doc1.getIdentifier())
print (doc2.getIdentifier())
</source>

{{Documentation/Note| Mira en el archivo '''pythonscript.py''' la forma en que trabaja el método '''getDocument'''}}

Si seguiste nuestra recomendación de asignar la macro de pruebas a una combinación de teclas disponible en todo AOO, prueba a abrir cada uno de los tipos de documentos que puedes ver en el menú '''Archivo->Nuevo->'''.
[[Image:Py_img_0007.png|none|thumb|500px|Tipos de documentos en AOO]]

Y a ejecutar la siguiente macro, teniendo como documento activo cada uno de ellos, es decir, activas uno y ejecutas la macro, activas otro y vuelves a llamar a la macro y así sucesivamente con todos.
<source lang=python>
def pruebas():
ctx = uno.getComponentContext()
sm = ctx.getServiceManager()
desktop = sm.createInstanceWithContext('com.sun.star.frame.Desktop', ctx)
doc = desktop.getCurrentComponent()
print (doc.getIdentifier())
return
</source>

Los mensajes devueltos en cada documento, son bastante ilustrativos de que '''tipo de documento''' se trata. Pero si probaste con todos, habrás notado que con la base de datos nos devuelve un error, si no lo has probado hazlo ahora. Para resolver este caso tenemos varias posibilidades, la primera es controlar la excepción como ya aprendimos en la introducción a Python.
<source lang=python>
doc = desktop.getCurrentComponent()
try:
print (doc.getIdentifier())
except:
print ('Error al obtener el tipo de documento')
</source>

Pero... ¿estamos realmente seguros que ese es el error?, es mejor especificarlo y asegurarnos de que este es el error.
<source lang=python>
doc = desktop.getCurrentComponent()
try:
print (doc.getIdentifier())
except AttributeError:
print ('Error al obtener el tipo de documento')
</source>

Tenemos otra alternativa donde no usamos controlador de excepciónes, si no una función que nos dice si un cierto atributo lo posee o no un objeto.
<source lang=python>
doc = desktop.getCurrentComponent()
if hasattr(doc, 'getIdentifier'):
print (doc.getIdentifier())
else:
print ('Sin atributo getIdentifier')
</source>

Es mucho mejor esta segunda opción. Aun así, no podemos estar 100% seguros de que cuando no la tenga, el documento sea una base de datos, simplemente estamos excluyendo la posibilidad pero no lo estamos asegurando, probemos con otra propiedad.
<source lang=python>
doc = desktop.getCurrentComponent()
print (doc.getImplementationName())
</source>

Mucho mejor, ahora ya no tenemos errores, pero si probaste de nuevo con todos los tipos de documentos, habrás notado que con '''Impres''' y con '''Draw''' obtenemos el mismo resultado, por lo que no tenemos la certeza de que tipo de documento es, por lo que descartamos esta propiedad para nuestra finalidad que es identificar fehacientemente cada tipo de documento.

Ya vimos que cada objeto UNO soporta diferentes servicios e interfaces, asì que cada documento de AOO ('''que son objetos''') soportan diferentes servicios, algunos son iguales, es decir, comúnes a todos, pero algunos pueden ser únicos para cada documento. Ya vimos como saber si un documento soporta una propiedad, pero para saber si soporta un servicio completo, cambiamos de método, ahora usamos '''supportsService''' que nos devuelve falso o verdadero según soporte o no el nombre del servicio pasado como argumento.
<source lang=python>
res = doc.supportsService('com.sun.star.sheet.SpreadsheetDocument')
mensaje = u'No soy una hoja de cálculo'
if res:
mensaje = u'Soy una hoja de cálculo'
print(mensaje)
</source>

Y mejor aun, podemos saber todos los servicios que soporta un objeto con el método '''getSupportedServiceNames''' que nos devuelve una tupla con todos sus nombres.
<source lang=python>
doc = desktop.getCurrentComponent()
servicios = doc.getSupportedServiceNames()

print(servicios)
</source>

Te queda de tarea probar esta macro en cada uno de los documentos abiertos, incluso puedes probar también el IDE para AOOBasic que incorpora AOO y determinar que servicio usar para diferenciar sin duda cada tipo de documento.

== Los documentos abiertos ==

Para acceder a todos los documentos abiertos en la sesión de AOO, usamos el método '''getComponents''' del objeto '''Desktop''', si usas '''MRI''', notarás que este método nos devuelve una instancia de la interfaz <idl>com.sun.star.container.XEnumerationAccess</idl>
<source lang=python>
desktop = sm.createInstanceWithContext('com.sun.star.frame.Desktop', ctx)
documentos = desktop.getComponents()
</source>

Esta interfaz (<idl>com.sun.star.container.XEnumerationAccess</idl>) tiene un solo método llamado '''createEnumeration''' que nos duelve una instancia de la interfaz <idl>com.sun.star.container.XEnumeration</idl> la cual a su vez tiene solo dos métodos, el primero para saber si tenemos más elementos en la enumeración: '''hasMoreElements''' y el segundo para acceder al siguiente elemento '''nextElement''', veamoslo con un ejemplo.
<source lang=python>
def pruebas():
ctx = uno.getComponentContext()
sm = ctx.getServiceManager()

desktop = sm.createInstanceWithContext('com.sun.star.frame.Desktop', ctx)
documentos = desktop.getComponents()
enum = documentos.createEnumeration()
# mientras tengamos elementos
while enum.hasMoreElements():
# obtenemos el siguiente elemento
doc = enum.nextElement()
# mostrámos el tipo de documento
mensaje = obtener_tipo(doc)
print(mensaje)
return

def obtener_tipo(doc):
tipo = {'com.sun.star.sheet.SpreadsheetDocument': 'Calc',
'com.sun.star.text.TextDocument': 'Writer',
'com.sun.star.presentation.PresentationDocument': 'Impress',
'com.sun.star.drawing.DrawingDocument': 'Draw',
'com.sun.star.sdb.OfficeDatabaseDocument': 'Base',
'com.sun.star.formula.FormulaProperties': 'Math',
'com.sun.star.script.BasicIDE': 'Basic'}
# iteramos entre los tipos de documentos
for t in tipo:
# validamos si soporta el servicio
if doc.supportsService(t):
# devolvemos el tipo de documento
return 'Soy %s' % tipo[t]
# si termina sin encontrar un tipo
return 'No se que tipo soy'
</source>

Observa como usamos una macro de apoyo para saber que tipo de documento es. Una enumeración no es más que una lista de objetos y es una forma muy común y a veces la única de acceder a ciertos objetos en AOO, es importante que la recuerdes.

== Rutas de archivos y directorios ==

Apache OpenOffice, al ser multiplataforma, hace uso de las rutas de archivos y directorios, en el formato URL, por ejemplo.

file:///home/usuario/datos/miarchivo.ods

file:///d:/datos/miarchivo.ods

Toma en cuenta que este formato hace uso de los caracteres 0-9, a-z y A-Z, y cualquier otro carácter será convertido y mostrado con su respectivo código, por ejemplo, los espacios los reemplazara con '''%20'''. Siempre que le pases una ruta de archivo a cualquier servicio de AOO, hazlo, casi como una regla, pasarle la ruta en formato Url, para ello, la libreria '''uno''' cuenta con dos funciones muy útiles que hacen el trabajo '''systemPathToFileUrl''' y '''fileUrlToSystemPath''', veamos como se usan.
<source lang=python>
import uno

def rutas():

ruta = "/home/mau/Mi archivo de Calc.ods"
print (ruta)

# La convertimos al formato URL
ruta = uno.systemPathToFileUrl(ruta)
print (ruta)

# Regresamos al formato local
ruta = uno.fileUrlToSystemPath(ruta)
print (ruta)

return
</source>

Abre varios documentos existentes y ejecuta la siguiente macro desde cada uno:
<source lang=python>
import uno
import os

def info_ruta():
ctx = uno.getComponentContext()
sm = ctx.getServiceManager()
desktop = sm.createInstanceWithContext('com.sun.star.frame.Desktop', ctx)

doc = desktop.getCurrentComponent()
# obtenemos la ruta en disco
ruta = doc.getURL()
# obtenemos las diferentes partes de la ruta
ruta, archivo = os.path.split(ruta)
nombre, extension = os.path.splitext(archivo)

print (ruta)
print (uno.fileUrlToSystemPath(ruta))
print (archivo)
print (nombre)
print (extension)

return
</source>

Hemos importado una nueva librería de Python, '''os''' que entre otras muchas cosas, nos permite obtener información de las rutas de archivos como en la macro anterior.

En nuestros siguientes temas, veremos la importancia de usar las rutas de archivos y directorios en formato Url y recuerda que en S.O. Linux, se tiene en cuenta la diferencia entre mayúsculas y minúsculas.

== Creando nuevos documentos ==

El método que nos permite crear nuevos documentos se llama '''loadComponentFromURL''' y es un método del servicio <idl>com.sun.star.frame.XComponentLoader</idl>, por ejemplo, para crear una nueva hoja de calculo.
<source lang=python>
ctx = uno.getComponentContext()
sm = ctx.getServiceManager()
desktop = sm.createInstanceWithContext('com.sun.star.frame.Desktop', ctx)

ruta = 'private:factory/scalc'
nuevo_doc = desktop.loadComponentFromURL(ruta, '_default', 0, ())
</source>

Solo hay que hacer un pequeño cambio para crear un nuevo documento de texto.
<source lang=python>
ctx = uno.getComponentContext()
sm = ctx.getServiceManager()
desktop = sm.createInstanceWithContext('com.sun.star.frame.Desktop', ctx)

ruta = 'private:factory/swriter'
nuevo_doc = desktop.loadComponentFromURL(ruta, '_default', 0, ())
</source>

Y los demás tipos de documentos.
<source lang=python>
ruta = 'private:factory/simpress'
nuevo_doc = desktop.loadComponentFromURL(ruta, '_default', 0, ())

ruta = 'private:factory/sdraw'
nuevo_doc = desktop.loadComponentFromURL(ruta, '_default', 0, ())

ruta = 'private:factory/smath'
nuevo_doc = desktop.loadComponentFromURL(ruta, '_default', 0, ())
</source>

¿Y una base de datos?, probemos.
<source lang=python>
ruta = 'private:factory/sbase'
nuevo_doc = desktop.loadComponentFromURL(ruta, '_default', 0, ())
</source>

Nos da un error ¿verdad?
[[Image:Py_img_0008.png|none|thumb|500px|Error al crear base de datos]]

No esta soportado. Para saber por que nos da un error, intenta abrir una base de datos nueva, observa como primero, si queremos trabajar con ella, el asistente nos “obliga” primero a guardarla con un nombre y después ya podemos manipularla, esto, solo pasa con las bases de datos, de los demás documentos podemos crear tantos nuevos documentos como queramos sin tener que guardar nada, entonces ¿como creamos una nueva base de datos?, la respuesta es sencilla, del mismo modo que lo hacemos desde la interfaz de usuario, es decir, tenemos que guardar primero la base de datos.
<source lang=python>
ctx = uno.getComponentContext()
sm = ctx.getServiceManager()
desktop = sm.createInstanceWithContext('com.sun.star.frame.Desktop', ctx)

ruta = "/home/mau/Mi_Base_Datos.odb"
# Creamos el servicio que nos permite manipular bases de datos
dbcon = sm.createInstance('com.sun.star.sdb.DatabaseContext')
# creamos una instancia de una nueva base de datos
base = dbcon.createInstance()
# establecemos el tipo de base
base.URL = "sdbc:embedded:hsqldb"
# y la guardamos
base.DatabaseDocument.storeAsURL(ruta, ())
</source>

Toma en cuenta dos cosas muy importantes en la macro anterior, el nombre que uses, si ya existe, simplemente lo reemplazara, no te preguntara nada, así que ten cuidado de no usar una ruta o nombre de una base importante que tengas y segundo, la base de datos así creada, no quedara “registrada” en AOO, con lo que no tendrás acceso desde otros programas de la aplicación, más adelante veremos como registrar una base de datos por código.

== Abriendo, guardando y cerrando documentos ==
Abrir archivos existentes es sumamente sencillo, usamos el mismo método usado
para crear nuevos documentos <idl>com.sun.star.frame.XComponentLoader</idl>, pero en el parámetro ruta, le especificamos la ubicación del archivo a abrir de la siguiente manera.
<source lang=python>
def documento1():
ctx = uno.getComponentContext()
sm = ctx.getServiceManager()
desktop = sm.createInstanceWithContext('com.sun.star.frame.Desktop', ctx)

ruta = uno.systemPathToFileUrl('/home/mau/Mi_archivo_de_Calc.ods')
doc_c = desktop.loadComponentFromURL(ruta, '_default', 0, ())

ruta = uno.systemPathToFileUrl('/home/mau/Mi_archivo_de_Writer.odt')
doc_w = desktop.loadComponentFromURL(ruta, '_default', 0, ())

return
</source>

Si tus archivos existen (esto se puede validar), el código anterior los abrirá, '''siempre''' utiliza
'''uno.systemPathToFileUrl''' cuando uses rutas de archivos o directorios en
funciones de AOO que las requieran como argumentos. Ya vimos que el primer
agumento del método '''loadComponentFromURL''', es la ruta del archivo a
abrir, el segundo argumento es una cadena con el nombre del macro (frame)
donde será mostrado el documento abierto, generalmente si existe este frame se
usa si no se crea uno nuevo.
<source lang=python>
ruta = uno.systemPathToFileUrl('/home/mau/Mi_archivo_de_Calc.ods')
doc_c = desktop.loadComponentFromURL(ruta, 'nuevo_cal', 0, ())

ruta = uno.systemPathToFileUrl('/home/mau/Mi_archivo_de_Writer.odt')
doc_w = desktop.loadComponentFromURL(ruta, 'nuevo_writer', 0, ())
</source>

Existen nombre especiales para este agumento, los más usuales son dos, primero
que ya hemos estado usando '''_default''' que usa el frame actual y
'''_blank''' que siempre crea un nuevo frame.
<source lang=python>
ruta = uno.systemPathToFileUrl('/home/mau/Mi_archivo_de_Calc.ods')
doc_c = desktop.loadComponentFromURL(ruta, '_blank', 0, ())

ruta = uno.systemPathToFileUrl('/home/mau/Mi_archivo_de_Writer.odt')
doc_w = desktop.loadComponentFromURL(ruta, '_blank', 0, ())
</source>

La recomendación es que uses siempre '''_default''' o '''_blank''', un
escenario puede ser que habrás con '''_default''' una instancia, y después de
forma oculta uno nuevo con '''_blank''', más abajo vemos como abrir un
documento de forma oculta.

Si abres una plantilla, esta se comportará de forma normal, es decir, te abrirá una copia de dicha plantilla.
<source lang=python>
ruta = uno.systemPathToFileUrl('/home/mau/Mi_plantilla.ots')
doc = desktop.loadComponentFromURL(ruta, '_blank', 0, ())
</source>

Pero también podrías querer abrir la plantilla para editarla, en este caso,
le indicamos en las opciones de apertura esta opción, y aquí vemos como usar
el cuarto argumento del método '''loadComponentFromURL'''.
<source lang=python>
from com.sun.star.beans import PropertyValue

ctx = uno.getComponentContext()
sm = ctx.getServiceManager()
desktop = sm.createInstanceWithContext('com.sun.star.frame.Desktop', ctx)

opciones = PropertyValue()
opciones.Name = 'AsTemplate'
opciones.Value = False

ruta = uno.systemPathToFileUrl('/home/mau/archivo.ots')
doc = desktop.loadComponentFromURL(ruta, '_blank', 0, (opciones,))
</source>

Observa como hemos importado una nueva estructura <idl>com.sun.star.beans.PropertyValue</idl>.
<source lang=python>
from com.sun.star.beans import PropertyValue
</source>

Observa como la instanciamos y asignamos sus valores.
<source lang=python>
opciones = PropertyValue()
opciones.Name = 'AsTemplate'
opciones.Value = False
</source>

Muy importante, el cuarto argumento del método '''loadComponentFromURL'''
espera una tupla, por eso es que usamos la coma al final del nombre del
argumento '''(opciones,)'''
<source lang=python>
doc = desktop.loadComponentFromURL(ruta, '_blank', 0, (opciones,))
</source>

La estructura <idl>com.sun.star.beans.PropertyValue</idl> esta conformada por
un par de valores, un nombre y un valor y es muy frecuentemente usada cuando se
programa en AOO, para este ejemplo solo hemos usado un par de agumentos,
siempre van en pares, pero muy bien puede tener más opciones como veremos más
adelante. En la macro anterior le estamos indicando la propiedad
'''AsTemplate''''' (que seria algo así como Es Plantilla), si el valor es
falso (False), le estamos indicando que queremos abrir la plantilla para
editarla, en caso contrario (True) abrirá una copia de la plantilla. Lo
interesante de esta propiedad es que perfectamente la puedes aplicar a archivos
existentes, es decir, archivos que '''no''' necesariamente sean plantillas, con
esta propiedad podemos forzarlos a comportarse como plantillas, por ejemplo, prueba el siguiente código con algún archivo existente que no sea plantilla.
<source lang=python>
opciones = PropertyValue()
opciones.Name = 'AsTemplate'
opciones.Value = True

ruta = uno.systemPathToFileUrl('/home/mau/Mi_archivo_de_Writer.odt')
doc = desktop.loadComponentFromURL(ruta, '_blank', 0, (opciones,))
</source>

Observa como el archivo es un documento de texto normal (ODT), pero con la
propiedad '''AsTemplate''', forzamos su apertura como una plantilla.

Otras propiedades interesantes son '''ReadOnly''' (Solo Lectura) para abrir un
archivo como solo lectura.

<source lang=python>
opciones = PropertyValue()
opciones.Name = 'ReadOnly'
opciones.Value = True

ruta = uno.systemPathToFileUrl('/home/mau/Mi_archivo_de_Writer.odt')
doc = desktop.loadComponentFromURL(ruta, '_blank', 0, (opciones,))
</source>

Y '''Password''' (Contraseña) para abrir archivos con contraseña.
<source lang=python>
opciones = PropertyValue()
opciones.Name = 'Password'
opciones.Value = 'letmein'

ruta = uno.systemPathToFileUrl('/home/mau/Archivo_con_contrasena.odt')
doc = desktop.loadComponentFromURL(ruta, '_blank', 0, (opciones,))
</source>

Por supuesto puedes combinar cualquier cantidad de opciones siempre y cuando no
entren en conflicto, es importante que al final, sea una tupla lo que le pasas
al método, si no, te dará un error.
<source lang=python>
# creamos una lista vacía
opciones = []
# creamos la primer propiedad
opcion = PropertyValue()
opcion.Name = 'ReadOnly'
opcion.Value = True
# y la agregamos a la lista
opciones.append(opcion)
# creamos la segunda propiedad
opcion = PropertyValue()
opcion.Name = 'Password'
opcion.Value = 'letmein'
# y la agregamos a la lista
opciones.append(opcion)

ruta = uno.systemPathToFileUrl('/home/mau/Archivo_con_contrasena.odt')
# nota que la lista la convertimos en tupla
doc = desktop.loadComponentFromURL(ruta, '_blank', 0, tuple(opciones))
</source>

Si la contraseña es incorrecta, no obtendrás ningún mensaje, simplemente no
lo abrira y la variable '''doc''' será vacía, puedes validar esto:
<source lang=python>
if doc is None:
print ('No se abrio el documento')
return
</source>

Más adelante veremos otras formas de validar y depurar nuestras macros para
los dificiles casos en donde no obtengamos ningún mensaje de error, pero
simplemente nuestra macro se niega a hacer su trabajo.

Mientras un formato de archivo sea soportado por AOO, lo podrás abrir con el
método '''loadComponentFromURL''', en el siguiente ejemplo, abrimos un archivo tipo Doc, un Html y un Xls.
<source lang=python>
ruta = uno.systemPathToFileUrl('/home/mau/archivo_word.doc')
doc_w = desktop.loadComponentFromURL(ruta, '_blank', 0, ())

ruta = uno.systemPathToFileUrl('/home/mau/archivo_web.html')
doc_h = desktop.loadComponentFromURL(ruta, '_blank', 0, ())

ruta = uno.systemPathToFileUrl('/home/mau/archivo_excel.xls')
doc_x = desktop.loadComponentFromURL(ruta, '_blank', 0, ())
</source>

¿Qué otras opciones tengo para abrir archivos?. La mayoría están descritas
en el servicio <idl>com.sun.star.document.MediaDescriptor</idl>, aquí veremos
las más usadas.

Cuando abres un archivo por código y este contiene macros, tu puedes
establecer si se abre con las macros activadas, de forma predeterminada lo abre
con las macros desactivadas, así que solo nos resta saber como abrirlo con las
macros activadas, las constanes que puedes usar puedes verlas aquí
<idl>com.sun.star.document.MacroExecMode</idl>
<source lang=python>
from com.sun.star.document.MacroExecMode import ALWAYS_EXECUTE_NO_WARN

opciones = PropertyValue()
opciones.Name = 'MacroExecutionMode'
opciones.Value = ALWAYS_EXECUTE_NO_WARN

ruta = uno.systemPathToFileUrl('/home/mau/archivo_calc.ods')
doc = desktop.loadComponentFromURL(ruta, '_blank', 0, (opciones,))
</source>

Otra opción interesante, es la que nos permite abrir una presentación e iniciarla inmediatamente.
<source lang=python>
opciones = PropertyValue()
opciones.Name = 'StartPresentation'
opciones.Value = True

ruta = uno.systemPathToFileUrl('/home/mau/archivo_impress.odp')
doc = desktop.loadComponentFromURL(ruta, '_blank', 0, (opciones,))
</source>

Puedes abrir un archivo como vista previa, útil para evitar que el usuario haga cambios en el, en este estado, los cambios que intente hacer el usuario no se guardaran.
<source lang=python>
opciones = PropertyValue()
opciones.Name = 'Preview'
opciones.Value = True

ruta = uno.systemPathToFileUrl('/home/mau/archivo_writer.odt')
doc = desktop.loadComponentFromURL(ruta, '_blank', 0, (opciones,))
</source>

Por supuesto, la idea general de abrir un archivo es para obtener datos de el o para manipularlo, ya sea un documento nuevo o uno existente, veamos como guardar los cambios realizados y cerrar el archivo.
<source lang=python>
ruta = uno.systemPathToFileUrl('/home/mau/archivo_calc.ods')
doc = desktop.loadComponentFromURL(ruta, '_blank', 0, ())

# aquí va todo el código que quieras para manipular el archivo
msgbox('Archivo abierto correctamente, presiona Aceptar para gaurdarlo y cerrarlo')

# guardamos los cambios
doc.store()
# cerramos el archivo
doc.close(True)
</source>

El código anterior funcionara con un archivo existente, pero con uno nuevo no,
te dará un error, por supuesto no me creas, compruébalo. Los documentos
tienen un método ('''hasLocation''') que nos informa si un documento ya esta guardado o no.
<source lang=python>
ruta = 'private:factory/scalc'
doc = desktop.loadComponentFromURL(ruta, '_blank', 0, ())
msgbox(doc.hasLocation())
doc.close(True)

ruta = uno.systemPathToFileUrl('/home/mau/archivo_calc.ods')
doc = desktop.loadComponentFromURL(ruta, '_blank', 0, ())
msgbox(doc.hasLocation())
doc.close(True)
</source>

El primer mensaje debe mostrarte falso (False) porque es un documento nuevo y
el segundo verdadero (True) por ser un archivo abierto del disco.

También tenemos una propiedad que nos ayuda a saber si un documento ha sido modificado o no, ejecuta la siguiente macro, llamándola desde diferentes documentos, unos ábrelos y modifícalos antes de ejecutarla, otros, solo ábrelos y ejecútala para que notes la diferencia.
<source lang=python>
def esta_modificado():
ctx = uno.getComponentContext()
sm = ctx.getServiceManager()
desktop = sm.createInstanceWithContext('com.sun.star.frame.Desktop', ctx)
doc = desktop.getCurrentComponent()

msgbox(doc.isModified())
return
</source>

Y otra más que nos informa si el documento es de solo lectura ('''isReadonly''').
<source lang=python>
ruta = 'private:factory/scalc'
doc = desktop.loadComponentFromURL(ruta, '_blank', 0, ())
msgbox(doc.isReadonly())

opciones = PropertyValue()
opciones.Name = 'ReadOnly'
opciones.Value = True

ruta = uno.systemPathToFileUrl('/home/mau/archivo_calc.ods')
doc = desktop.loadComponentFromURL(ruta, '_blank', 0, (opciones,))
msgbox(doc.isReadonly())
</source>

Es importante que valides antes de intentar guardar un archivo, si este ha sido
modificado o es de solo lectura. Ahora veamos como guardar un archivo nuevo con el método '''storeAsUrl'''.
<source lang=python>
ruta = 'private:factory/scalc'
doc = desktop.loadComponentFromURL(ruta, '_blank', 0, ())

msgbox('Ahora guardaremos el archivo')

ruta = uno.systemPathToFileUrl('/home/mau/archivo_nuevo_calc.ods')
doc.storeAsURL(ruta, ())
</source>

Observa como requiere dos parámetros, la ruta del archivo y una matriz de
propiedades, algunas de las cuales veremos a continuación. Toma nota de que si
el archivo ya existe lo reemplazara sin avisarte por lo que es buena practica
de programación validar esto, observa como volvemos a usar la librería
'''os''' para saber si un archivo existe ya.
<source lang=python>
import uno
import os

def pruebas():
documentos()
return

def documentos():
ctx = uno.getComponentContext()
sm = ctx.getServiceManager()
desktop = sm.createInstanceWithContext('com.sun.star.frame.Desktop', ctx)

ruta = 'private:factory/scalc'
doc = desktop.loadComponentFromURL(ruta, '_blank', 0, ())

msgbox('Ahora guardaremos el archivo')

ruta = '/home/mau/archivo_nuevo_calc.ods'
if os.path.exists(ruta):
msgbox(u'El archivo existe, no se guardará el nuevo')
return

ruta = uno.systemPathToFileUrl(ruta)
doc.storeAsURL(ruta, ())
return
</source>

De la macro anterior, '''es muy importante''' que tomes nota que para todos
los métodos de Python que usen rutas de archivos o directorios, se les tienen
que pasar en las rutas nativas del sistema operativo donde estes trabajando,
'''solo''' a los métodos de AOO, es a los que se les pasa en notación URL.

Veamos algunas propiedades interesantes para guardar archivos, por ejemplo, guardar con contraseña.
<source lang=python>
from com.sun.star.beans import PropertyValue

ctx = uno.getComponentContext()
sm = ctx.getServiceManager()
desktop = sm.createInstanceWithContext('com.sun.star.frame.Desktop', ctx)

ruta = 'private:factory/scalc'
doc = desktop.loadComponentFromURL(ruta, '_blank', 0, ())

msgbox(u'Ahora guardaremos el archivo pero con contraseña')

opciones = PropertyValue()
opciones.Name = 'Password'
opciones.Value = 'letmein'

ruta = uno.systemPathToFileUrl('/home/mau/archivo_protegido.ods')
doc.storeAsURL(ruta, (opciones,))
</source>

Como sabes, AOO, soporta la importación/exportación de múltiples formatos de archivos, veamos como guardar, por ejemplo, en formato DOC.
<source lang=python>
from com.sun.star.beans import PropertyValue

ctx = uno.getComponentContext()
sm = ctx.getServiceManager()
desktop = sm.createInstanceWithContext('com.sun.star.frame.Desktop', ctx)

ruta = 'private:factory/swriter'
doc = desktop.loadComponentFromURL(ruta, '_blank', 0, ())

msgbox(u'Ahora guardaremos el archivo en formato DOC')

opciones = PropertyValue()
opciones.Name = 'FilterName'
opciones.Value = 'MS Word 97'

ruta = uno.systemPathToFileUrl('/home/mau/archivo_word.doc')
doc.storeAsURL(ruta, (opciones,))
</source>

Es importante que cuando exportes, uses un formato compatible, es decir, no
puedes guardar una hoja de calculo como documento de texto. En el [[ES/Manuales/GuiaAOO/TemasAvanzados/Macros/Python/Apendices|Apéndice]]
mostramos una macro para obtener todos los filtros que soporta AOO.

El método storeAsURL también lo puedes usar para abrir un archivo existente y guardarlo con otro nombre.
<source lang=python>
ruta = uno.systemPathToFileUrl('/home/mau/archivo_calc.ods')
doc = desktop.loadComponentFromURL(ruta, '_blank', 0, ())

msgbox(u'Ahora guardaremos con otro nombre')

ruta = uno.systemPathToFileUrl('/home/mau/archivo_calc_nuevo.ods')
doc.storeAsURL(ruta, ())
</source>

Para terminar esta sección, vamos a hacer un poco más interactiva la apertura
y guardado de archivos, permitamos que el usuario escoja la ruta y el archivo
desde un cuadro de dialogo, para ello, usaremos el servicio
<idl>com.sun.star.ui.dialogs.FilePicker</idl>, que nos permite hacer esto.
<source lang=python>
ctx = uno.getComponentContext()
sm = ctx.getServiceManager()
desktop = sm.createInstanceWithContext('com.sun.star.frame.Desktop', ctx)

dlg = sm.createInstance('com.sun.star.ui.dialogs.FilePicker')
# podemos establecer el título
dlg.setTitle('Selecciona un archivo')
if dlg.execute():
# el primer elemento es la ruta seleccionada
ruta = dlg.getFiles()[0]
doc = desktop.loadComponentFromURL(ruta, '_blank', 0, ())
else:
msgbox('Proceso cancelado')
</source>

Si estableces la propiedad '''MultiSelectionMode''' en verdadero, le
permitiras al usuario seleccionar más de un archivo.
<source lang=python>
ctx = uno.getComponentContext()
sm = ctx.getServiceManager()
desktop = sm.createInstanceWithContext('com.sun.star.frame.Desktop', ctx)

dlg = sm.createInstance('com.sun.star.ui.dialogs.FilePicker')
dlg.setTitle('Selecciona un archivo')
dlg.setMultiSelectionMode(True)
if dlg.execute():
archivos = dlg.getFiles()
if len(archivos) == 1:
# si selecciona uno, devuelve la ruta completa
desktop.loadComponentFromURL(archivos[0], '_blank', 0, ())
else:
# si selecciona varios, el primer elemento es la carpeta
folder = archivos[0]
# los demás elementos son los archivos seleccionados
for f in range(1, len(archivos)):
desktop.loadComponentFromURL(folder + archivos[f], '_blank', 0, ())
else:
msgbox('Proceso cancelado')
</source>

Si lo notaste, con la macro anterior el usuario puede seleccionar cualquier
archivo, para limitar las opciones, agrega un filtro con el método
'''appendFilter''' con solo los tipos de
archivos que necesites, usa una línea por cada filtro, este método requiere
dos argumentos, el primero es el título, lo que verá el usuario y el segundo
es el filtro en si.
<source lang=python>
dlg.appendFilter('Hoja de calculo ODF (.ods)', '*.ods')
</source>

Ahora, mostramos el cuadro de dialogo Guardar Como, para permitir al usuario
seleccionar carpeta y nombre de archivo donde guardar su archivo, se usa el
mismo servicio <idl>com.sun.star.ui.dialogs.FilePicker</idl> solo cambiando
algunas de sus propiedades.
<source lang=python>
from com.sun.star.ui.dialogs.TemplateDescription import FILESAVE_AUTOEXTENSION_PASSWORD

ctx = uno.getComponentContext()
sm = ctx.getServiceManager()
desktop = sm.createInstanceWithContext('com.sun.star.frame.Desktop', ctx)

dlg = sm.createInstance('com.sun.star.ui.dialogs.FilePicker')
dlg.setTitle('Guardar archivo')
dlg.appendFilter('Hoja de calculo ODF (.ods)', '*.ods')
# con esta opción le indicamos que use guardar como con otras opciones
dlg.initialize((FILESAVE_AUTOEXTENSION_PASSWORD,))
if dlg.execute():
ruta = dlg.getFiles()[0]
msgbox(ruta)
</source>

Nota que el argumento del método '''initialize''' es una tupla.

Ahora si, para terminar, te mostramos como abrir un archivo de forma oculta.
<source lang=python>
from com.sun.star.beans import PropertyValue

ctx = uno.getComponentContext()
sm = ctx.getServiceManager()
desktop = sm.createInstanceWithContext('com.sun.star.frame.Desktop', ctx)

opciones = PropertyValue()
opciones.Name = 'Hidden'
opciones.Value = True

ruta = uno.systemPathToFileUrl('/home/mau/archivo_calc.ods')
doc = desktop.loadComponentFromURL(ruta, '_blank', 0, (opciones,))

msgbox('Archivo abierto de forma oculta, ahora lo cerraremos')

doc.store()
doc.close(True)
</source>

Es '''muy importante''', que cuando abras un archivo oculto siempre uses el argumento '''_blank''', a menos claro esta, que sepas lo que haces, y que, mantengas una referencia a el, para poder cerrarlo en cuanto no lo necesites.

== Algunas tareas comunes en documentos ==

=== Exportando a PDF ===

Para exportar a PDF solo hay que establecer el filtro correcto, nota como construimos el nombre del filtro de acuerdo al tipo de documento y como construimos la ruta de acuerdo a la ruta actual donde este guardado el documento solo reemplazando la extensión para que quede en PDF. Estamos haciendo uso de la macro '''obtener_tipo''' con unos ligeros cambios para este propósito.
<source lang=python>
import uno
import os

def pruebas():
export_pdf()
return

def export_pdf():
from com.sun.star.beans import PropertyValue

ctx = uno.getComponentContext()
sm = ctx.getServiceManager()
desktop = sm.createInstanceWithContext('com.sun.star.frame.Desktop', ctx)

doc = desktop.getCurrentComponent()
tipo = obtener_tipo(doc)
soportados = 'calc,writer,draw,impress,math'
if tipo in soportados:
# establecemos el filtro como PDF
opciones = PropertyValue()
opciones.Name = 'FilterName'
opciones.Value = '%s_pdf_Export' % tipo
# obtenemos la ruta y reemplazados la extensión por PDF
ruta, archivo = os.path.split(doc.getURL())
nombre, _ = os.path.splitext(archivo)
ruta = os.path.join(ruta, nombre + '.pdf')
# guardamos
doc.storeToURL(ruta, (opciones,))
msgbox(u'Documento exportado correctamente a PDF')
else:
msgbox(u'Aplicación no soportada')
return

def obtener_tipo(doc):
tipo = {'com.sun.star.sheet.SpreadsheetDocument': 'calc',
'com.sun.star.text.TextDocument': 'writer',
'com.sun.star.presentation.PresentationDocument': 'impress',
'com.sun.star.drawing.DrawingDocument': 'draw',
'com.sun.star.sdb.OfficeDatabaseDocument': 'base',
'com.sun.star.formula.FormulaProperties': 'math',
'com.sun.star.script.BasicIDE': 'basic'}
for t in tipo:
if doc.supportsService(t):
return tipo[t]
return 'No se que tipo soy'
</source>

La forma de descomponer la ruta en sus diferentes partes, ya la vimos anteriormente, en este caso, observa como la extensión actual del documento ya no la usaremos por lo que la omitimos con un guión bajo.
<source lang=python>
nombre, _ = os.path.splitext(archivo)
</source>

=== Ocultando y mostrando ventanas ===

Para ocultar una ventana, hay que acceder a la ventana contenedora.
<source lang=python>
ctx = uno.getComponentContext()
sm = ctx.getServiceManager()

desktop = sm.createInstanceWithContext('com.sun.star.frame.Desktop', ctx)
documentos = desktop.getComponents()
enum = documentos.createEnumeration()
while enum.hasMoreElements():
doc = enum.nextElement()
# obtenemos una referencia a la ventana contenedora
ventana = doc.getCurrentController().getFrame().getContainerWindow()
# y la ocultamos
ventana.setVisible(False)

msgbox('Se han ocultado todas las ventanas, presiona Aceptar para mostrarlas')

# tienes que crear de nuevo la enumeración
enum = documentos.createEnumeration()
while enum.hasMoreElements():
doc = enum.nextElement()
ventana = doc.getCurrentController().getFrame().getContainerWindow()
# ahora las mostramos
ventana.setVisible(True)
</source>

Esta técnica la puedes usar también para mostrar un archivo que abriste de forma oculta previamente.
<source lang=python>
from com.sun.star.beans import PropertyValue

ctx = uno.getComponentContext()
sm = ctx.getServiceManager()
desktop = sm.createInstanceWithContext('com.sun.star.frame.Desktop', ctx)

opciones = PropertyValue()
opciones.Name = 'Hidden'
opciones.Value = True

ruta = uno.systemPathToFileUrl('/home/mau/archivo_calc.ods')
doc = desktop.loadComponentFromURL(ruta, '_blank', 0, (opciones,))

msgbox('Archivo abierto de forma oculta, ahora lo mostraremos')

ventana = doc.getCurrentController().getFrame().getContainerWindow()
ventana.setVisible(True)

msgbox('Archivo visible, ahora lo cerramos')

doc.close(True)
</source>

=== Activando ventanas ===

Para usamos el método '''setFocus''' de la ventana contenedora.
<source lang=python>
import uno
import time

def pruebas():
ctx = uno.getComponentContext()
sm = ctx.getServiceManager()

desktop = sm.createInstanceWithContext('com.sun.star.frame.Desktop', ctx)
documentos = desktop.getComponents()
enum = documentos.createEnumeration()
while enum.hasMoreElements():
doc = enum.nextElement()
# obtenemos una referencia a la ventana contenedora
ventana = doc.getCurrentController().getFrame().getContainerWindow()
# esperamos 3 segundos y mostramos la ventana
time.sleep(3)
ventana.setFocus()
return
</source>

=== Controlando la barra de estado ===

La barra de estado, generalmente en la parte inferior de las aplicaciones, es útil para dar información al usuario, generalmente de un proceso en progreso.
<source lang=python>
import uno
import time

def barra_estado():
ctx = uno.getComponentContext()
sm = ctx.getServiceManager()
desktop = sm.createInstanceWithContext('com.sun.star.frame.Desktop', ctx)

doc = desktop.getCurrentComponent()
barra = doc.getCurrentController().getStatusIndicator()
barra.start(u'Se procesaran líneas en tres segundos', 10)
# esta pausa es solo para que veas el mensaje anterior en la barra de estado
time.sleep(3)
for i in range(1, 11):
barra.setValue(i)
barra.setText(u'Procesando línea: %s' % i)
# pausa de un segundo
time.sleep(1)
# importante para regresar el control a la aplicación
barra.end()
return
</source>

=== Controlando el zoom de la vista ===
La porcentaje del zoom de la vista del documento se puede modificar con la propiedad '''ZoomValue''' del controlador del documento.
<source lang=python>
doc = desktop.getCurrentComponent()
ctl = doc.getCurrentController()
# cambiamos el zoom a 120%
ctl.ZoomValue = 120
</source>

=== Cambiando posición y tamaño de ventana ===

Para eso usamos el método '''setPosSize''' de la ventana contenedora, es importante decirle que valores queremos aplicar con las constantes <idl>com.sun.star.awt.PosSize</idl>
<source lang=python>
from com.sun.star.awt.PosSize import POSSIZE

ctx = uno.getComponentContext()
sm = ctx.getServiceManager()
desktop = sm.createInstanceWithContext('com.sun.star.frame.Desktop', ctx)

doc = desktop.getCurrentComponent()
ventana = doc.getCurrentController().getFrame().getContainerWindow()
# movemos la ventana a la posicion X = 0, Y = 0
# establecemos el ancho (width) = 800 y el alto (height) = 600
ventana.setPosSize(0, 0, 800, 600, POSSIZE)
</source>

{{ES/Foro|macros}}

[[Category:ES]][[Category:Manuales]][[Category:ES/Python]]

ES/Manuales/GuiaAOO/TemasAvanzados/Macros/Python/IntroduccionPython

2013-05-09T15:39:05Z

Mauriciobaeza:

{{DISPLAYTITLE:Introducción a Python}}

== Agradecimientos ==

{{Documentation/Note|'''''Nota''''': Estas notas están basadas en el excelente libro de Raúl González Duque [http://mundogeek.net/tutorial-python Python para todos]}}

En la red hay muchos y muy buenos manuales de Python, en la introducción ya recomendamos algunos y estas notas le deben mucho a ellos. En esta sección solo veremos los elementos mínimos de Python para poder continuar con nuestro aprendizaje de macros en AOO. Empecemos.

'''Python''' tiene una sintaxis muy sencilla pero el '''interprete''', es decir, el programa que se encarga de validar y ejecutar nuestro código es muy '''estricto''', recuerda bien esto, '''es muy estricto'''. Los espacios, los tabuladores y hasta los nombres que asignamos, pueden tener repercusión en la ejecución de nuestro código, también pueden ser fuente de múltiples frustraciones que deseamos se reduzcan con estas notas.

{{Documentation/Note|'''''Sintaxis''''': conjunto de reglas}}

Reiteramos, '''Python es muy estricto en su sintaxis''', por ello y por otras buenas razones, Python cuenta con una guía de estilo de programación, que, en mayor medida, intentamos seguir la mayoría de los pythonistas, esta guía se le llama PEP8 y fue escrita, entre otros, por el mismo autor de Python, Guido van Rossum, tenemos una excelente traducción de nuestro amigo; Raúl González Duque, el autor del libro ya mencionado '''Python para todos''', que puedes ver aquí: http://mundogeek.net/traducciones/guia-estilo-python.htm

== Declarando y llamando macros ==

La estructura básica para una macro es.

<source lang=python>
def nombre_de_la_macro():
# Instrucciones de nuestra macro
return
</source>

En el tema anterior ya vimos como '''llamar a otras macros''', repasemoslo aquí.
<source lang=python>
def inicio():
solicitar_datos()
procesar_datos()
mostrar_info()
print ('Fin')
return

def solicitar_datos():
return

def procesar_datos():
return

def mostrar_info():
return
</source>

Es '''muy importante''' que respetes la indentación de las líneas, más adelante veremos que importantes son. ¿Recuerdas que comentamos que Python es '''muy estricto'''?, comprobemoslo.
<source lang=python>
import uno

def pruebas():
macro03
return

def macro03():
return
</source>

¿Ya lo notaste? nos falto poner los paréntesis al '''llamar''' la macro. Veamos otra.
<source lang=python>
import uno

def pruebas():
macro03()
return

def macro03()
return
</source>

Ahora si, AOO nos muestra un mensaje de error. Observa como nos indica el archivo y la línea donde esta el error. En este caso, nos faltaron los dos puntos al final de la declaración de la macro. Lo repetiremos muchas veces: '''Python es muy estricto'''

[[File:Py_img_0005.png]]

== Variables - Tipos básicos ==

No es necesario declarar el tipo de dato que contendrá una variable en Python, a esta característica se le llama: '''tipado dinámico'''. Ejemplos:
<source lang=python>
import uno

def pruebas():
variables()
return

def variables():
texto = 'Soy un texto'
numero_entero = 10
numero_flotante = 3.1416
booleanos = True # o False
return
</source>

{{Documentation/Note|'''''Nota''''': de aquí en adelante, solo mostraremos los nuevos ejemplos, en el entendido de que tienen que ser ejecutados desde nuestra macro inicial '''pruebas'''}}

Para saber el tipo de valor que contiene una variable, usamos la función '''type'''.
<source lang=python>
def variables():
texto = 'Soy un texto'
numero_entero = 10
numero_flotante = 3.1416
booleanos = True # o False

print (type(texto))
print (type(numero_entero))
print (type(numero_flotante))
print (type(booleanos))
return
</source>

'''Cuidado''', el que no necesites declarar el tipo de variable, no significa que puedas usarlas cuando quieras, recuerda, '''solo puedes usar variables asignadas previamente''', la siguiente macro te tiene que dar un error.
<source lang=python>
def variables():
t = 'Hola mundo'
print (t)
print (s)
return
</source>

== Variables - Colecciones ==

Estos tipos de variables permiten almacenar más de un valor.

=== Listas ===

La lista es un tipo de colección ordenada. Sería equivalente a lo que en otros lenguajes se conoce por arrays, o vectores. Las listas pueden contener cualquier tipo de dato: números, cadenas, booleanos, ... y también listas, para crear una lista, se usan los corchetes y sus elementos separados por comas.
<source lang=python>
def variables():
# lista de número enteros
mi_lista1 = [1, 2, 3, 4]
# lista de cadenas
mi_lista2 = ['Noemi', 'Paola', 'Claudia']
# lista mixta
mi_lista3 = [10, 'Alejandra', 3.14, True, [9, 8, 7]]
return
</source>

Observa que en la ultima lista, su ultimo elemento es otra lista. Más abajo mira algunas de las operaciones que podemos hacer con las listas. Para hacer referencia a un elementos de la lista, usamos su indice o posición, este, siempre empieza en cero.
<source lang=python>
print (mi_lista3[1])
</source>

Puedes modificar cualquier elemento de la lista.
<source lang=python>
mi_lista3[2] = 3.1416
print (mi_lista3)
</source>

Puedes realizar las siguiente operaciones con las listas.
<source lang=python>
# agregar un elemento al final
mi_lista.append(10)
print (mi_lista)

# extender la lista con otra secuencia
mi_lista.extend([100,200,300])
print (mi_lista)

# borra un elemento
mi_lista.remove(200)
print (mi_lista)

# insertar un elemento en la posición determinada
mi_lista.insert(4, 500)
print (mi_lista)
</source>

=== Tuplas ===
Son muy parecidas a las listas, se diferencian en su forma de crearse y en que son inmutables, es decir, no puede modificar sus elementos como en las listas. Para crear una tupla, usamos los paréntesis, si creas una tupla de un solo elemento, es importante uses la coma para crearla.
<source lang=python>
mi_tupla1 = ('Un solo elemento',)
mi_tupla2 = (12, 13, 14)
mi_tupla3 = (10, 'Estela', False, (1,3,5))
</source>

Observa que de nuevo en la ultima tupla, en su ultimo elemento, tenemos una tupla.

=== Diccionarios ===
Los diccionarios, también llamados matrices asociativas, son colecciones que relacionan una clave y un valor, para crearlos se usan las llaves de la siguiente manera.
<source lang=python>
peliculas = {'Vivir': 'Akira Kurosawa',
'El Gran Pez': 'Tim Burton',
'Amores Perros': 'Alejandro González Iñárritu'}
</source>

El primer valor se trata de la clave y el segundo del valor asociado a la clave. Como clave podemos utilizar cualquier valor inmutable: podríamos usar números, cadenas, booleanos, tuplas, ... pero no listas o diccionarios, dado que son mutables. La diferencia principal entre los diccionarios y las listas o las tuplas es que a los valores almacenados en un diccionario se les accede no por su índice, porque de hecho no tienen orden, sino por su clave.
<source lang=python>
print (peliculas['Vivir'])
</source>

Puedes usar esta misma clave para cambiar su valor.
<source lang=python>
peliculas['Vivir'] = 'Zhang Yimou'
</source>

== Variables - Secuencias ==
Las listas, las tuplas y las cadenas de texto, son secuencias por que se puede acceder a sus elementos a través de un índice, no son los únicos en Python. Entre sus características están.
* No es necesario conocer cuantos elementos contendrá la secuencia.
* Pueden guardar cualquier tipo de objeto.
* No hay limite para la cantidad de elementos que guardará.

Para acceder a cualquier elemento de la secuencia, usamos un índice.
<source lang=python>
def secuencias():
mi_lista = [5, 9, 12, 1, 56]
mi_tupla = (23, 89, 12, 56, 23)
mi_cadena = 'Python es facil y divertido'

print (mi_lista[0])
print (mi_tupla[1])
print (mi_cadena[2])
return
</source>

Si intentas usar un índice inexistente, el interprete te mostrará un error. También puedes usar índices negativos, con lo cual la cuenta empezará desde el ultimo elemento.
<source lang=python>
def secuencias():
print (mi_lista[-1])
print (mi_tupla[-2])
print (mi_cadena[-3])
</source>

Puedes usar funciones comunes a las secuencias, como contar su número de elementos, obtener el máximo o el mínimo.
<source lang=python>
print (len(mi_lista))
print (len(mi_tupla))
print (len(mi_cadena))

print (max(mi_lista))
print (max(mi_tupla))
print (max(mi_cadena))

print (min(mi_lista))
print (min(mi_tupla))
print (min(mi_cadena))
</source>

Puedes conocer el índice del primer elemento encontrado.
<source lang=python>
print (mi_lista.index(12))
print (mi_tupla.index(56))
print (mi_cadena.index('d'))
</source>

Puedes conocer el número de veces que aparece un elemento.
<source lang=python>
print (mi_lista.count(9))
print (mi_tupla.count(89))
print (mi_cadena.count('o'))
</source>

Puedes ordenar los elementos, para ello, usamos la función '''sorted'''.
<source lang=python>
print (sorted(mi_lista))
print (sorted(mi_tupla))
print (sorted(mi_cadena))
</source>

Puedes devolver solo una parte de la secuencia, a esta operación se le llama '''slices''' y se usan índices enteros (pueden ser positivos o negativos) de la forma [x:y:z], donde:
* x = elemento inicial.
* y = elemento final, cuidado, la posición '''y''' no es devuelta, por lo que el fin real es '''y-1'''.
* z = salto entre elementos, de forma predeterminada '''z = 1'''.
<source lang=python>
print (mi_cadena[7:15:1])
print (mi_cadena[0:20:2])
print (mi_cadena[-1:-10:-1])
</source>

Se pueden omitir los argumentos.
<source lang=python>
# devolvemos los primeros diez
print (mi_cadena[:10])
# devolvemos los últimos diez
print (mi_cadena[-10:])
# mira que divertido
print (mi_cadena[::-1])
</source>

Podemos saber si un elemento pertenece a una secuencia con el operador '''in'''.
<source lang=python>
print (12 in mi_lista)
print (100 in mi_tupla)
print ('es' in mi_cadena)
</source>

Puedes '''sumar''' dos secuencias, con la única condición de que sean del mismo tipo, en el siguiente ejemplo, la ultima línea te dará un error.
<source lang=python>
print (mi_lista + ['a', 'b', 'c'])
print (mi_tupla + ('x', 'y', False))
print (mi_cadena + (5, 10, 20))
</source>

Puedes '''multiplicar''' una secuencia por un entero, recuerda que la multiplicación es una suma abreviada.
<source lang=python>
print (['a', 'b', 'c'] * 3)
print (('x', 'y') * 4)
print ('adios' * 5)
</source>

== Conversión del tipo de la variable ==

No se permite tratar a una variable como si fuera de un tipo distinto al que tiene, es necesario convertir de forma explícita dicha variable al nuevo tipo previamente, a esta característica se le llama '''fuertemente tipado'''. Para convertir variables de un tipo a otro usamos las siguientes funciones.
<source lang=python>
# convertimos un entero en cadena
mi_entero = 100
print (type(mi_entero))
mi_entero = str(mi_entero)
print (type(mi_entero))

# convertimos un flotante en cadena
mi_numero = 3.14
print (type(mi_numero))
mi_numero = str(mi_numero)
print (type(mi_numero))

# convertimos una cadena, en entero y luego el entero en flotante
mi_cadena = '1000'
print (type(mi_cadena))
mi_cadena = int(mi_cadena)
print (type(mi_cadena))
mi_cadena = float(mi_cadena)
print (type(mi_cadena))

# convertimos una cadena (secuencia) en una lista, luego la lista en tupla
# y al final de nuevo en cadena, CUIDADO con la ultima conversión.
mi_cadena = 'Hola Mundo'
print (type(mi_cadena))
mi_cadena = list(mi_cadena)
print (type(mi_cadena))
mi_cadena = tuple(mi_cadena)
print (type(mi_cadena))
mi_cadena = str(mi_cadena)
print (type(mi_cadena))

</source>

== Operadores ==
Los operadores aritméticos son los siguientes:
<source lang=python>
# suma
t = 10 + 20

# resta
r = 100 - 45

# multiplicación
m = 34 * 45

# exponenciación
e = 2 ** 6

# división
d = 50.5 / 2

# división entera
de = 3.5 / 2

# modulo, resto de una división
mo = 7 % 2

print (t, r, m, e, d, de, mo)
</source>

Los operadores de relación y booleanos son los siguientes.
<source lang=python>
# igualdad
r = 10 == 10
print (r)
r = 10 == 20
print (r)

# diferencia
r = 'A' != 'A'
print (r)
r = 'A' != 'B'
print (r)

# menor que
r = 10 < 20
print (r)
r = 10 < 5
print (r)

# mayor que
r = 20 > 5
print (r)
r = 10 > 100
print (r)

print '\n'
# and
r = True and True
print (r)
r = True and False
print (r)
r = False and True
print (r)
r = False and False
print (r)

# or
r = True or True
print (r)
r = True or False
print (r)
r = False or True
print (r)
r = False or False
print (r)

# negación
r = not False
print (r)
r = not True
print (r)
</source>

== Condicionales ==
Estas estructuras nos permiten evaluar una instrucción y tomar un camino, dependiendo si esa es Falsa(False) o Verdadera (True), por ejemplo.
<source lang=python>
edad = 15
if edad < 18:
print ('Eres menor de edad')
</source>

{{Documentation/Note|'''''Importante''''': Observa los dos puntos al final de la evaluación de la condición y la sangría al inicio de la siguiente línea, la sangría le dice al interprete, que esta línea esta '''dentro''' de la estructura '''if'''}}

Si solo tienes dos alternativas, puedes complementar la estructura con la instrucción ''else'''.
<source lang=python>
edad = 25
if edad < 18:
print ('Eres menor de edad')
else:
print ('Eres mayor de edad')
</source>

Si tienes varias alternativas, entonces complementa con la instrucción '''elif'''.
<source lang=python>
# observa la asignacion que usa un solo signo igual
calificacion = 7
if calificacion < 6:
print ('Reprobado')
# observa la comparación que usa dos signos igual
elif calificacion == 6:
print ('De panzaso pasaste')
elif calificacion > 6 and calificacion <= 7:
print ('Hay que esforzarse más')
elif calificacion > 7 and calificacion <= 9:
print ('Bien Hecho')
else:
print ('Excelente')
</source>

Nota que independiente de la cantidad de comparaciones, cada línea termina en dos puntos y las líneas '''dentro''' de dicha condición tienen una sangría para indicarle que son parte de dicha condición. Toman en cuenta que como condición; ''se puede usar cualquier expresión susceptible de ser evaluada como verdadera(True) o falsa(False)''. Cualquier variable vacía o cero, serán evaluados como falsas, cualquier otra como verdaderas.
<source lang=python>
# números
numero = 10
if numero:
print (numero)
numero = 0
if not numero:
print ('Cero')

# cadenas
cadena = 'PyUNO'
if cadena:
print (cadena)
cadena = ''
if not cadena:
print ('Cadena vacia')

# listas
lista = []
if not lista:
print ('Lista vacia')
lista = [1, 2, 3]
if lista:
print (lista)

# tuplas
tupla = ()
if not tupla:
print ('Tupla vacia')
tupla = (1, 2, 3)
if tupla:
print (tupla)

# diccionario
dic = {}
if not dic:
print ('Diccionario vacio')
dic = {'Nombre': 'Noemi Hernandez'}
if dic:
print (dic)

# valor Nulo
otro = None
if not otro:
print ('Sin valor')
otro = 100
if otro:
print (otro)
</source>

Por ultimo, en Python no hay una estructura '''Select...Case''' de otros lenguajes, sencillamente ''porque no es necesaria''.

== Bucles ==

Para ejecutar una fragmento de código varias veces, usamos los bucles. La estructura '''for...in''' y la estructura '''while'''. Lo decimos una vez más; '''Python es muy estricto''', y en el caso de los bucles lo podrás notar, pues el bloque de estas estructuras quedan delimitados por la indentación del código, no se usan paréntesis o llaves como en otros lenguajes, simplemente la sangría de las líneas es lo que determina la pertenencia y la validez de una estructura.

=== Estructura for..in ===
Esta estructura nos permite iterar en una secuencia, por ejemplo.
<source lang=python>
for i in [1,2,3,4,5]:
print (i)
</source>

{{Documentation/Note|'''''Importante''''': Observa los dos puntos al final de la primer línea y la sangría al inicio de la segunda, la sangría le dice al interprete, que esta línea esta '''dentro''' de la estructura for...in}}

Puedes apoyarte en la función '''range''' si quieres iterar un número determinado de veces.
<source lang=python>
for i in range(5):
print (i)
</source>

'''Observa''' que, los dos ejemplos previos, iteran el mismo número de veces (cinco), pero no en el mismo rango, esto es por que mientras no le indiques lo contrario, la función rango empieza en 0. Puedes generar un rango determinado, pasandole los argumentos correctos.
<source lang=python>
for i in range(10, 21):
print (i)
</source>

Como ya habrás notado, la función '''range''' recibo los mismos argumentos usados en las secuencias.
<source lang=python>
for i in range(100, 1001, 100):
print (i)
</source>

Incluyendo los enteros negativos.
<source lang=python>
for i in range(0, -500, -50):
print (i)
</source>

Como ya mencionamos, esta estructura puede iterar en los elementos de una secuencia.
<source lang=python>
mi_lista = [5, 9, 12, 1, 56]
mi_tupla = (23, 89, 12, 56, 23)
mi_cadena = 'pyUNO'

for i in mi_lista:
print (i)
print ('\n')

for i in mi_tupla:
print (i)
print ('\n')

for i in mi_cadena:
print (i)
print ('\n')
</source>

{{Documentation/Note|'''''Observa''''': la forma de mostrar un salto de línea en pantalla, usando la secuencia de escape '\n'}}

Puedes iterar en una secuencia y numerar sus elementos, usando la función '''enumerate'''.
<source lang=python>
mi_tupla = ('Noemi', 'Claudia', 'Paola', 'Estela')
for i,v in enumerate(mi_tupla):
print (i, v)
</source>

De un modo similar puedes iterar un diccionario y devolver su clave y el valor de dicha clave.
<source lang=python>
dic = {1: 'Uno', 2: 'Dos', 3: 'Tres', 4: 'Cuatro', 5: 'Cinco'}
for k,v in dic.items():
print (k,v)
</source>

Por ultimo, puedes tener estructuras anidadas.
<source lang=python>
datos = (
('A1', 'B1', 'C2', 'D1', 'E1'),
('A2', 'B2', 'C2', 'D2', 'E2'),
('A3', 'B3', 'C3', 'D3', 'E3'),
('A4', 'B4', 'C4', 'D4', 'E4'),
('A5', 'B5', 'C5', 'D5', 'E5'),
)
for r in datos:
print (r)
for c in r:
print (c)
</source>

{{Documentation/Note|'''''Importante''''': si, ya lo mencionamos, pero toma nota de la '''correcta sangría''' en cada línea}}

Otras instrucciones que complementan a esta estructura son: '''break''' que nos permite salir de un ciclo de forma anticipada y '''continue''' que nos permite saltar directamente al siguiente ciclo, por ejemplo.
<source lang=python>
# observa como no imprime las dos ultimas cifras
datos = (13, 67, 45, 0, 34, 56)
for v in datos:
if v == 0:
break
else:
print (v)
print ('\n')
# observa como no imprime el cero, pero si las dos ultimas cifras
datos = (13, 67, 45, 0, 34, 56)
for v in datos:
if v == 0:
continue
else:
print (v)
</source>

=== Estructura while ===
Esta estructura nos permite ejecutar fragmentos de código mientras se cumpla o hasta que se cumpla una condición dada, por ejemplo.
<source lang=python>
# valor inicial
edad = 5
# condición para continuar
while edad < 18:
# aumentamos la edad en uno
edad += 1
# mostramos la edad
print ('Tienes ' + str(edad) + ' años')
</source>

Más adelante veremos formas más ''elegantes'' de formatear cadenas de texto. Hay que tener algo de precaución cuando se defina la condición de una estructura '''while''', cuando se es novel es común caer en condiciones que nunca se cumplen y por lo tanto quedar ''atrapados'' en bucles infinitos.

Al igual que en la estructura '''for...in''', en la estructura '''while''' podemos usar las instrucciones '''break''' y '''continue'''.

== Funciones incorporadas ==

La mayor parte de las herramientas de Python, están desarrolladas en módulos independientes que hay que importar de forma explicita cada vez que se requieran, este tema lo veremos más adelante. En esta sección veremos algunas de las funciones incorporadas, algunas de las cuales ya vimos en temas anteriores, por ejemplo.

Para ver el tipo de una variable usamos '''type'''.
<source lang=python>
n = 1001
print (type(n))
n = 'AOO'
print (type(n))
</source>

Para devolver el valor absoluto de un número usamos '''abs'''.
<source lang=python>
n = -1001
print (abs(n))
n = -3.1416
print (abs(n))
</source>

Para convertir una variable en tipo booleana usamos '''bool'''.
<source lang=python>
v = ''
b = bool(v)
print (b)

v = 'AOO'
b = bool(v)
print (b)
</source>

Para devolver el valor ASCII del entero pasado usamos '''chr'''.
<source lang=python>
v = chr(97)
print (v)
</source>

Para convertir una cadena o entero en flotante, usamos '''float'''.
<source lang=python>
texto = '100'
n = float(texto)
print n
texto = '-10.5'
n = float(texto)
print n
</source>

Para convertir una cadena en entero, usamos '''int'''.
<source lang=python>
numero = '100'
i = int(numero)
print (i)
</source>

Para saber si una variable es de un tipo(clase) determinado, usamos '''isinstance'''.
<source lang=python>
numero = '100'
if isinstance(numero, str):
print ('Es una cadena')

numero = 100
if isinstance(numero, int):
print ('Es un entero')i)
</source>

Para devolver la longitud de una secuencia o diccionario usamos '''len'''.
<source lang=python>
lista = [1, 2, 3]
print (len(lista))

tupla = ('a', 'b', 'c', 'd', 'e')
print (len(tupla))

cadena = 'Apache OpenOffice'
print (len(cadena))

dic = {'Uno': 'Dos', 'Tres': 'Cuatro'}
print (len(dic))
</source>

Para convertir una secuencia en lista usamos '''list'''.
<source lang=python>
tupla = ('a', 'b', 'c', 'd', 'e')
lista = list(tupla)
print (type(lista), lista)
</source>

Para convertir una cadena o número en entero largo usamos '''long'''.
<source lang=python>
cadena = '100000'
n = long(cadena)
print (type(n), n)a)
</source>

Para devolver el máximo de una secuencia usamos '''max'''.
<source lang=python>
tupla = (10, 100, 0, 500, 999)
print (max(tupla))
</source>

Para devolver el mínimo de una secuencia usamos '''min'''.
<source lang=python>
tupla = (10, 100, 0, 500, 999)
print (min(tupla))
</source>

Para abrir un archivo y escribir en el usamos usamos '''open'''. Más adelante veremos el trabajo con archivos a detalle.
<source lang=python>
f = open('detalle.txt', 'w')
f.write('Aprendiendo python')
f.close()
</source>

Para elevar un número a una potencia usamos '''pow'''. El siguiente número te tiene que resultar familiar.

<source lang=python>
print (pow(2,10))
print (2 ** 10)
</source>

Para devolver una lista con una progresión aritmética usamos '''range'''.

<source lang=python>
print (range(11))
print (range(1000, 10000, 500))
print (range(-100, -500, -50))
</source>

Para devolver una secuencia en reversa '''reversed'''. Toma en cuenta que tienes que convertir de nuevo al tipo de secuencia original.

<source lang=python>
tupla = (10, 100, 0, 500, 999)
print (tuple(reversed(tupla)))

lista = ['a', 'd', 'p', 'g', 'z']
print (list(reversed(lista)))
</source>

Para redondear un número flotante usamos '''round'''.

<source lang=python>
numero = 3.1499
print (round(numero, 2))
# si omites el segundo argumento
print (round(numero))
</source>

Para ordenar secuencias usamos '''sorted'''. Más adelante veremos otras técnicas de ordenamiento para secuencias y diccionarios.

<source lang=python>
tupla = (10, 100, 0, 500, 999)
print (sorted(tupla))

lista = ['a', 'd', 'p', 'g', 'z']
print (sorted(lista))
</source>

Para devolver la representación impresa de un objeto usamos '''str'''.

<source lang=python>
lista = [1, 2, 3]
print (str(lista))

tupla = ('a', 'b', 'c', 'd', 'e')
print (str(tupla))

dic = {'Uno': 'Dos', 'Tres': 'Cuatro'}
print (str(dic))
</source>

Para devolver la suma de una secuencia usamos '''sum''', esta, solo debe contener números.

<source lang=python>
lista = [1, 2, 3]
print (sum(lista))

tupla = [1, 2, 3, 4, 5]
print (sum(tupla))
</source>

Para convertir una secuencia en tupla usamos '''tuple'''.

<source lang=python>
lista = [1, 2, 3]
print (tuple(lista))

cadena = 'Apache'
print (tuple(cadena))
</source>

== Ámbito de variables ==

El ámbito de las variables se refiere al espacio donde son validas, al lugar desde donde se puede '''verlas''' y hacer referencia a ellas y donde no, veamos el siguiente ejemplo.
<source lang=python>
# -*- coding: utf-8 -*-
import uno

def pruebas():
macro_uno()
macro_dos()
return

def macro_uno():
var = 'Hola'
print (var)
return

def macro_dos():
var = 'Mundo'
print (var)
return
</source>

Nota, al ejecutar, que las variables, aun teniendo el mismo nombre, se muestran correctamente, a este ámbito se le llama local. Para usar la misma variable en diferentes macros, asignala a nivel de modulo.
<source lang=python>
var2 = 'pyUNO'

def pruebas():
print (var2)
macro_uno()
macro_dos()
return

def macro_uno():
var = 'Hola'
print (var)
print (var2)
return

def macro_dos():
var = 'Mundo'
print (var)
print (var2)
return
</source>

Más adelante veremos más opciones y alternativas para ver nuestras variables.

== Excepciones ==

Los errores, presentes en toda actividad, son susceptibles de capturarse, Python nos provee de la estructura '''try...except''' para esto.
<source lang=python>
def errores():
# intentamos mostrar una variable no declarada
print texto
return
</source>

Ahora, controlemos este error.
<source lang=python>
def errores():
try:
print texto
except:
print ('Variable no declarada')
return
</source>

Ahora, un error diferente.
<source lang=python>
def errores():
try:
r = 10 / 0
except:
print ('División entre cero')
return
</source>

Ahora, los dos errores en la misma macro.
<source lang=python>
def errores():
try:
r = 10 / 0
print texto
except:
print ('No se que fallo')
return
</source>

Para determinar el tipo de error, puedes complementar con el tipo de error de la siguiente manera.
<source lang=python>
def errores():
try:
r = 10 / 0
print texto
except (NameError, ZeroDivisionError):
print ('Variable no declarada o división entre cero')
return
</source>

Aunque lo mejor es tratar cada error de forma separada.
<source lang=python>
def errores():
try:
r = 10 / 0
print texto
except NameError:
print ('Variable no declarada')
except ZeroDivisionError:
print ('División entre cero')
return
</source>

Nota, que en el ejemplo anterior, siempre te mostrará el primer error capturado, por ello, es una mala practica intentar meter todo tu código entre líneas '''try...except''', resistete a esto y trata de usar la captura de errores cuando realmente se requiera, esto, solo lo sabrás con la experiencia y consultando código de otros, algo, que podemos hacer con el software libre.

La captura de errores también tiene una clausula '''else''' que se ejecuta solo cuando no ocurrió ningún error.
<source lang=python>
def errores():
try:
texto = 'Correct'
r = 10 / 5
print texto
except ZeroDivisionError:
print ('División entre cero')
else:
print ('Todo correcto')
return
</source>

Y por ultimo, la clausula '''finally''' que se ejecuta siempre, haya ocurrido o no un error.
<source lang=python>
def errores():
try:
texto = 'Correct'
r = 10 / 0
print texto
except ZeroDivisionError:
print ('División entre cero')
else:
print ('Todo correcto')
finally:
print ('Siempe se ejecuta')
return
</source>

Python permite incluso declarar tus errores personalizados, tema que se verá más adelante.

{{ES/Foro|macros}}

[[Category:ES]][[Category:Manuales]][[Category:ES/Python]]

ES/Manuales/GuiaAOO/TemasAvanzados/Macros/Python/ConceptosIniciales

2013-05-09T15:38:26Z

Mauriciobaeza:

{{DISPLAYTITLE: Conceptos iniciales}}
=== Organización de macros ===
Las macros en PyUNO, se organizan en archivos con extensión '''py''', donde cada archivo es una biblioteca y cada función una macro. Más adelante veremos que también podemos organizarlas en clases.

=== Configurando nuestro entorno de trabajo ===
Dado que AOO no incorpora ningún editor para macros en Python, tenemos que hacer uso de algún editor externo. Para empezar, recomendamos el uso de [http://geany.org Geany], un IDE multiplataforma y multilenguaje que soporta Python.

[[File:Pymacros001.png]]

La configuración recomendada de trabajo para este editor es la siguiente:

[[File:Pymacros002.png]]

[[File:Pymacros003.png]]

[[File:Pymacros004.png]]

[[File:Pymacros005.png]]

Como ya se vio en la introducción, nuestras macros pueden estar en tres diferentes lugares: sección mis macros, solo disponible para el usuario actual, sección macros del sistema, disponibles para todos los usuarios y dentro de un archivo de AOO. De aquí en adelante, asumiremos que estamos trabajando en la sección mis macros, pues en este sitio es el de más fácil acceso para todos.

Dentro de la carpeta '''python''' crea un archivo que se llame '''mismacros.py''', dentro de el escribe la siguiente macro y guardala:
<source lang=python>
import uno

def pruebas():
print ('Todo correcto')
return None
</source>

Ahora, si estas usando Linux, abre una terminal de comandos y ejecuta Apache OpenOffice (AOO de aquí en adelante) con la siguiente instrucción:
<pre>
$ soffice -calc
</pre>
Ve a Herramientas -> Macros -> Ejecutar macros... y selecciona la macro '''pruebas''' recién creada.

[[File:py_img_0001.png]]

Ejecuta la macro y mira el resultado en la ventana del terminal.

[[File:py_img_0002.png]]

Si eres usuario de otro sistema operativo, puedes usar la siguiente alternativa para mostrar cualquier mensaje en pantalla. No te preocupes por ahora de estas líneas, cada una será usada y explicada en su momento.
<source lang=python>
import uno

def pruebas():
msgbox ('Todo correcto')
return

def msgbox(message):
from com.sun.star.awt import Rectangle

ctx = uno.getComponentContext()
sm = ctx.getServiceManager()
toolkit = sm.createInstanceWithContext('com.sun.star.awt.Toolkit', ctx)
MsgBox = toolkit.createMessageBox(
toolkit.getDesktopWindow(),
Rectangle(),
'infobox',
1,
'UNOPython',
str(message))
return MsgBox.execute()
</source>

Por supuesto, verifica que funcione:

[[File:Py_img_0004.png]]

Solo para probar nuestro entorno de trabajo, agrega dos nuevas macros y '''llámalas''' desde la primera, guarda y prueba. Recuerda de cambiar los '''print''' (puedes dejarlos si quieres) y usar nuestra macro '''msgbox''' si prefieres, también puedes ejecutar la macro '''pruebas''' con la combinación de teclas definida en el punto siguiente.
<source lang=python>
import uno

def pruebas():
macro01()
macro02()
return

def macro01():
print ('Otra macro')
return

def macro02():
print ('Una tercera')
return
</source>

Por ultimo, para que sea sencillo '''llamar''' a esta macro, asignala a la combinación de teclas que más te guste y que, por supuesto, no este usada por AOO, se recomienda asignar esta combinación de teclas a todo AOO, para que puedas llamar la macro desde cualquier aplicación, como puedes ver en la siguiente imagen.

[[File:Py_img_0003.png]]

Resumiendo, mientras no se indique lo contrario, todas nuestras macros de ejemplo mostradas, serán '''ejecutadas''' desde la primer macro llamada '''pruebas''', de preferencia, con una combinación de teclas.

=== Utilidades de apoyo ===
Las siguientes herramientas, nos ayudarán en el desarrollo y estudio de macros con Python, por ahora, solo asegúrate de dejarlas trabajando como en los ejemplos, más adelante, explicaremos como trabajan y como puedes desarrollar las tuyas.

Instala la siguiente extensión [http://extensions.services.openoffice.org/project/MRI MRI], esta maravillosa extensión nos ayudará a obtener toda la información de un '''objeto'''.

{{ES/Foro|macros}}

[[Category:ES]][[Category:Manuales]][[Category:ES/Python]]

ES/Manuales/GuiaAOO/TemasAvanzados/Macros/Python/ConceptosIniciales

2013-05-09T15:37:25Z

Mauriciobaeza:

ES/Manuales/GuiaAOO/TemasAvanzados/Macros/Python/Introduccion

2013-05-09T15:35:09Z

Mauriciobaeza:

{{DISPLAYTITLE: Introducción}}

=== ¿Que es PyUNO? ===
Apache OpenOffice (AOO de aquí en adelante), cuenta con la posibilidad de escribir macros en varios lenguajes interpretados, uno de ellos es [http://www.python.org Python]. El componente que nos da acceso a la Interfaz de programación de aplicaciones (IPA o API de aquí en adelante por sus siglas del inglés Application Programming Interface) de AOO con este lenguaje se le llama [http://www.openoffice.org/udk/python/python-bridge.html PyUNO].

=== ¿Que necesito saber? ===
Si bien trataremos de ir de menor a más detalle y complejidad, son necesarios un mínimo de requisitos para aprovechar estas notas y todo el poder de PyUNO, entre más familiarizado estés con la programación en general y con lenguajes como C,C++, Java y otros, te será más fácil adentrarte en PyUNO, si vienes de un lenguajes tipo Basic, requerirás un poco más de esfuerzo por las inercias inherentes a este lenguaje como su permisividad en su sintaxis.
* Conocimientos básicos de programación.
* Conocimientos básicos de programación con Python - Recomendamos los siguientes cursos para adentrarte en el lenguaje de programación Python.
** [http://mundogeek.net/tutorial-python Python para todos] excelente curso de Raúl González Duque.
** [http://www.maestrosdelweb.com/editorial/guia-python/ Guía de Python] excelente curso para iniciarse en Python por Eugenia Bahit
** [http://manuales.gfc.edu.co/python/tlc/thinkCSpy.es.pdf Aprenda a Pensar Como un Programador con Python] este libro tiene dos finalidades, enseñarte a pensar como un programador y enseñarte Python, puede ser una buena opción si vas empezando a programar. Puedes encontrar en tu buscador favorito muchos vínculos para descargar este libro en PDF.
* Conocimientos medios/avanzados de OpenOffice.org - Definitivamente, entre más domines la herramienta que queremos controlar por código, tendrás menos problemas y tu curva de aprendizaje será menos pronunciada, en los [http://forum.openoffice.org/es/forum/viewforum.php?f=50 foros oficiales de Apache OpenOffice], puedes resolver muchas de tus dudas, incluyendo claro esta, las que surgan durante tu aprendizaje con PyUNO. Procura tener siempre la ultima versión estable del programa.
* Y mucha practica, esfuerzo y dedicación, si alguien te ha dicho que programar es fácil, tal vez involuntariamente, pero te ha engañado, programar requiere, como decía Thomas Alva Edison: 1% inspiración y 99% transpiración.

=== ¿Donde empiezo? ===
Si tienes instalado correctamente OpenOffice.org (por ahora no importa el sistema operativo que uses), tienes todo lo necesario para empezar con PyUNO, para comprobarlo, veamos como ejecutar una macro que incluye OpenOffice.org de forma predeterminada. Abre Writer, es importante que sea Writer, esta macro solo funciona en este programa. Ve al menú Herramientas | Macros | Organizar macros | Python... tal como se muestra en la siguiente imagen.

[[File:pyuno001.png|1000px]]

La acción anterior te mostrará el cuadro de diálogo "Macros de Python", en este cuadro de diálogo, selecciona las siguientes opciones:
# Selecciona y expande la rama Macros de OpenOffice.org
# Selecciona y expande la subrama HelloWorld
# Selecciona la macro HelloWorldPython
# Da un clic en el botón de comando Ejecutar

[[File:pyuno002.png]]

El resultado tiene que ser el siguiente:

[[File:pyuno003.png|900px]]

{{ES/Foro|macros}}

[[Category:ES]][[Category:Manuales]][[Category:ES/Python]]

ES/Manuales/GuiaAOO/TemasAvanzados/Macros/Python/Introduccion

2013-05-09T15:33:37Z

Mauriciobaeza:

=== ¿Que es PyUNO? ===
Apache OpenOffice (AOO de aquí en adelante), cuenta con la posibilidad de escribir macros en varios lenguajes interpretados, uno de ellos es [http://www.python.org Python]. El componente que nos da acceso a la Interfaz de programación de aplicaciones (IPA o API de aquí en adelante por sus siglas del inglés Application Programming Interface) de AOO con este lenguaje se le llama [http://www.openoffice.org/udk/python/python-bridge.html PyUNO].

=== ¿Que necesito saber? ===
Si bien trataremos de ir de menor a más detalle y complejidad, son necesarios un mínimo de requisitos para aprovechar estas notas y todo el poder de PyUNO, entre más familiarizado estés con la programación en general y con lenguajes como C,C++, Java y otros, te será más fácil adentrarte en PyUNO, si vienes de un lenguajes tipo Basic, requerirás un poco más de esfuerzo por las inercias inherentes a este lenguaje como su permisividad en su sintaxis.
* Conocimientos básicos de programación.
* Conocimientos básicos de programación con Python - Recomendamos los siguientes cursos para adentrarte en el lenguaje de programación Python.
** [http://mundogeek.net/tutorial-python Python para todos] excelente curso de Raúl González Duque.
** [http://www.maestrosdelweb.com/editorial/guia-python/ Guía de Python] excelente curso para iniciarse en Python por Eugenia Bahit
** [http://manuales.gfc.edu.co/python/tlc/thinkCSpy.es.pdf Aprenda a Pensar Como un Programador con Python] este libro tiene dos finalidades, enseñarte a pensar como un programador y enseñarte Python, puede ser una buena opción si vas empezando a programar. Puedes encontrar en tu buscador favorito muchos vínculos para descargar este libro en PDF.
* Conocimientos medios/avanzados de OpenOffice.org - Definitivamente, entre más domines la herramienta que queremos controlar por código, tendrás menos problemas y tu curva de aprendizaje será menos pronunciada, en los [http://forum.openoffice.org/es/forum/viewforum.php?f=50 foros oficiales de Apache OpenOffice], puedes resolver muchas de tus dudas, incluyendo claro esta, las que surgan durante tu aprendizaje con PyUNO. Procura tener siempre la ultima versión estable del programa.
* Y mucha practica, esfuerzo y dedicación, si alguien te ha dicho que programar es fácil, tal vez involuntariamente, pero te ha engañado, programar requiere, como decía Thomas Alva Edison: 1% inspiración y 99% transpiración.

=== ¿Donde empiezo? ===
Si tienes instalado correctamente OpenOffice.org (por ahora no importa el sistema operativo que uses), tienes todo lo necesario para empezar con PyUNO, para comprobarlo, veamos como ejecutar una macro que incluye OpenOffice.org de forma predeterminada. Abre Writer, es importante que sea Writer, esta macro solo funciona en este programa. Ve al menú Herramientas | Macros | Organizar macros | Python... tal como se muestra en la siguiente imagen.

[[File:pyuno001.png|1000px]]

La acción anterior te mostrará el cuadro de diálogo "Macros de Python", en este cuadro de diálogo, selecciona las siguientes opciones:
# Selecciona y expande la rama Macros de OpenOffice.org
# Selecciona y expande la subrama HelloWorld
# Selecciona la macro HelloWorldPython
# Da un clic en el botón de comando Ejecutar

[[File:pyuno002.png]]

El resultado tiene que ser el siguiente:

[[File:pyuno003.png|900px]]

Si por alguna razón no has obtenido este resultado o te muestra algún mensaje de error, háznoslo saber [http://forum.openoffice.org/es/forum/viewforum.php?f=50 aquí].

[[Category:Manuales]]

ES/Manuales/GuiaAOO/TemasAvanzados/Macros/Python/MiPrimeraMacro

2013-05-09T15:30:51Z

Mauriciobaeza:

{{DISPLAYTITLE:Mi primer macro}}
=== Mi primer macro ===

Vamos a crear nuestra primer macro con Python con el clásico "Hola Mundo", que, acabas de ver en acción, pero lo haremos paso a paso y esta vez usaremos una hoja de calculo que tienes que tener activa cuando ejecutes las pruebas.
* Abre tu editor de texto plano favorito:
** En Linux; geany, gedit, kate, vi, nano, etc, etc...
** En Windows puedes usar el Block de notas, presiona WIN+R y escribes "notepad" (sin las comillas)
** En Mac OS puedes usar TextMate que ahora es software libre.

Escribe o copia el siguiente código:

<source lang=python>
import uno

def HolaMundo():
# Accedemos al modelo del documento actual
model = XSCRIPTCONTEXT.getDocument()
# Accedemos a la primer hoja del documento
hoja = model.getSheets().getByIndex(0)
# Accedemos a la celda A1 de la hoja
celda = hoja.getCellRangeByName("A1")
# Escribimos en la celda
celda.setString("Hola Mundo en Python")
return None
</source>

Aquí, es importante mencionar que Python es muy estricto con la indentación, algunos procesadores de texto plano insertan espacios en lugar de tabulaciones, Python puede trabajar sin problemas con unos y otros, el único requisito es que sean consistentes, asegúrate de que estas efectivamente insertando tabulaciones o espacios según prefieras trabajar en cada línea de código. Guarda este código como '''holamundo.py'''

=== ¿Dónde se guardan las macros? ===
Dependiendo del sistema operativo y versión de Apache OpenOffice que uses (recomendamos usar siempre la ultima versión estable), las macros pueden guardarse en:
* La carpeta del usuario, macros solo disponibles para dicho '''USUARIO''':
** En Linux y OOo 3.4 en: /home/'''USUARIO'''/config/.openoffice.org/3/user/Scripts/python
** En Windows 7 y OOo 3.4 en: C:\Users\'''USUARIO'''\AppData\Roaming\OpenOffice.org\3\user\Scripts\python
** En Windows XP y OOo 3.4 en: C:\Documents and Settings\'''USUARIO'''\Datos de programa\OpenOffice.org\3\user\Scripts\python

* La carpeta del programa, macros disponibles para todos los usuarios:
** En Linux y OOo 3.4 en: /opt/openoffice.org/basis3.2/share/Scripts/python
** En Windows 7 y OOo 3.4 en: C:\Program Files\OpenOffice.org 3\Basis\share\Scripts\python
** En Windows XP y OOo 3.4 en: C:\Archivos de programa\OpenOffice.org 3\Basis\share\Scripts\python

Estas rutas son las predeterminadas, pueden cambiar en instalaciones personalizadas o en versiones de Apache OpenOffice alternas a la oficial. Nuestra recomendación es que siempre uses e instales la ultima versión estable oficial que puedes descargar desde [http://es.openoffice.org/ aquí].
En el caso de las carpetas de usuario, es posible que no encuentres la carpeta '''python''', si es el caso, créala manualmente, escribe el nombre de esta carpeta en minúsculas. En la carpeta del programa, para escribir en ella, en Linux necesitaras permisos de administrador (root), en Windows, dependerá de las políticas de acceso del sistema.

* Dentro del documento:
Un archivo de Apache OpenOffice es realmente un archivo ZIP con una estructura determinada, por lo que puedes, también, manipularlos con tu programa favorito para este tipo de archivos. Crea y guarda un archivo nuevo de Calc, ciérralo y ábrelo ahora con tu programa ZIP. Crea las carpetas Scripts/python en la raíz del archivo. Dentro de esta carpeta agrega los archivos con las macros, para nuestro ejemplo '''holamundo.py'''. Ahora, edita el archivo manifest.xml que esta en la carpeta META-INF, a cuyo contenido agrégale las siguientes líneas, justo antes del cierre '''</manifest:manifest>'''.

<source lang=xml>
<manifest:file-entry manifest:media-type="" manifest:full-path="Scripts/python/holamundo.py"/>
<manifest:file-entry manifest:media-type="application/binary" manifest:full-path="Scripts/python/"/>
<manifest:file-entry manifest:media-type="application/binary" manifest:full-path="Scripts/"/>
</manifest:manifest>
</source>

Guarda los cambios y cierra el archivo.

=== Ejecutando nuestra macro ===
El archivo '''holamundo.py''' copialo a cualquiera de las ubicaciones vistas en el apartado anterior, como ejemplo, nosotros lo hemos copiado en las tres ubicaciones, por lo que al ir al menú Herramientas | Macros | Organizar macros | Python..., podrás ver la macro en las siguientes secciones:

# El archivo del usuario Mis Macros...
# Las macros del programa
# Dentro del documento

[[File:pyuno004.png]]

Selecciona cualquiera de las tres y presiona Ejecutar, el resultado, debe ser igual al de la siguiente imagen:

[[File:pyuno005.png]]

{{ES/Foro|macros}}

[[Category:ES]][[Category:Manuales]][[Category:ES/Python]]

ES/Manuales/GuiaAOO/TemasAvanzados/Macros/Python/MiPrimeraMacro

2013-05-09T15:30:09Z

Mauriciobaeza:

{{DISPLAYTITLE:Mi primer macro}}
=== Mi primer macro ===

Vamos a crear nuestra primer macro con Python con el clásico "Hola Mundo", que, acabas de ver en acción, pero lo haremos paso a paso y esta vez usaremos una hoja de calculo que tienes que tener activa cuando ejecutes las pruebas.
* Abre tu editor de texto plano favorito:
** En Linux; geany, gedit, kate, vi, nano, etc, etc...
** En Windows puedes usar el Block de notas, presiona WIN+R y escribes "notepad" (sin las comillas)
** En Mac OS puedes usar TextMate que ahora es software libre.

Escribe o copia el siguiente código:

<source lang=python>
import uno

def HolaMundo():
# Accedemos al modelo del documento actual
model = XSCRIPTCONTEXT.getDocument()
# Accedemos a la primer hoja del documento
hoja = model.getSheets().getByIndex(0)
# Accedemos a la celda A1 de la hoja
celda = hoja.getCellRangeByName("A1")
# Escribimos en la celda
celda.setString("Hola Mundo en Python")
return None
</source>

Aquí, es importante mencionar que Python es muy estricto con la indentación, algunos procesadores de texto plano insertan espacios en lugar de tabulaciones, Python puede trabajar sin problemas con unos y otros, el único requisito es que sean consistentes, asegúrate de que estas efectivamente insertando tabulaciones o espacios según prefieras trabajar en cada línea de código. Guarda este código como '''holamundo.py'''

=== ¿Dónde se guardan las macros? ===
Dependiendo del sistema operativo y versión de Apache OpenOffice que uses (recomendamos usar siempre la ultima versión estable), las macros pueden guardarse en:
* La carpeta del usuario, macros solo disponibles para dicho '''USUARIO''':
** En Linux y OOo 3.4 en: /home/'''USUARIO'''/config/.openoffice.org/3/user/Scripts/python
** En Windows 7 y OOo 3.4 en: C:\Users\'''USUARIO'''\AppData\Roaming\OpenOffice.org\3\user\Scripts\python
** En Windows XP y OOo 3.4 en: C:\Documents and Settings\'''USUARIO'''\Datos de programa\OpenOffice.org\3\user\Scripts\python

* La carpeta del programa, macros disponibles para todos los usuarios:
** En Linux y OOo 3.4 en: /opt/openoffice.org/basis3.2/share/Scripts/python
** En Windows 7 y OOo 3.4 en: C:\Program Files\OpenOffice.org 3\Basis\share\Scripts\python
** En Windows XP y OOo 3.4 en: C:\Archivos de programa\OpenOffice.org 3\Basis\share\Scripts\python

Estas rutas son las predeterminadas, pueden cambiar en instalaciones personalizadas o en versiones de Apache OpenOffice alternas a la oficial. Nuestra recomendación es que siempre uses e instales la ultima versión estable oficial que puedes descargar desde [http://es.openoffice.org/ aquí].
En el caso de las carpetas de usuario, es posible que no encuentres la carpeta '''python''', si es el caso, créala manualmente, escribe el nombre de esta carpeta en minúsculas. En la carpeta del programa, para escribir en ella, en Linux necesitaras permisos de administrador (root), en Windows, dependerá de las políticas de acceso del sistema.

* Dentro del documento:
Un archivo de Apache OpenOffice es realmente un archivo ZIP con una estructura determinada, por lo que puedes, también, manipularlos con tu programa favorito para este tipo de archivos. Crea y guarda un archivo nuevo de Calc, ciérralo y ábrelo ahora con tu programa ZIP. Crea las carpetas Scripts/python en la raíz del archivo. Dentro de esta carpeta agrega los archivos con las macros, para nuestro ejemplo '''holamundo.py'''. Ahora, edita el archivo manifest.xml que esta en la carpeta META-INF, a cuyo contenido agrégale las siguientes líneas, justo antes del cierre '''</manifest:manifest>'''.

<source lang=xml>
<manifest:file-entry manifest:media-type="" manifest:full-path="Scripts/python/holamundo.py"/>
<manifest:file-entry manifest:media-type="application/binary" manifest:full-path="Scripts/python/"/>
<manifest:file-entry manifest:media-type="application/binary" manifest:full-path="Scripts/"/>
</manifest:manifest>
</source>

Guarda los cambios y cierra el archivo.

=== Ejecutando nuestra macro ===
El archivo '''holamundo.py''' copialo a cualquiera de las ubicaciones vistas en el apartado anterior, como ejemplo, nosotros lo hemos copiado en las tres ubicaciones, por lo que al ir al menú Herramientas | Macros | Organizar macros | Python..., podrás ver la macro en las siguientes secciones:

# El archivo del usuario Mis Macros...
# Las macros del programa
# Dentro del documento

[[File:pyuno004.png]]

Selecciona cualquiera de las tres y presiona Ejecutar, el resultado, debe ser igual al de la siguiente imagen:

[[File:pyuno005.png]]

Cualquier duda, comentario o error, háznoslo saber [http://forum.openoffice.org/es/forum/viewforum.php?f=50 aquí].

[[Category:Manuales]]

ES/Manuales/GuiaAOO/TemasAvanzados/Macros/Python/MiPrimeraMacro

2013-05-09T15:29:28Z

Mauriciobaeza:

{{DISPLAYTITLE:Mi primera macro}}
=== Mi primer macro ===

Vamos a crear nuestra primer macro con Python con el clásico "Hola Mundo", que, acabas de ver en acción, pero lo haremos paso a paso y esta vez usaremos una hoja de calculo que tienes que tener activa cuando ejecutes las pruebas.
* Abre tu editor de texto plano favorito:
** En Linux; geany, gedit, kate, vi, nano, etc, etc...
** En Windows puedes usar el Block de notas, presiona WIN+R y escribes "notepad" (sin las comillas)
** En Mac OS puedes usar TextMate que ahora es software libre.

Escribe o copia el siguiente código:

<source lang=python>
import uno

def HolaMundo():
# Accedemos al modelo del documento actual
model = XSCRIPTCONTEXT.getDocument()
# Accedemos a la primer hoja del documento
hoja = model.getSheets().getByIndex(0)
# Accedemos a la celda A1 de la hoja
celda = hoja.getCellRangeByName("A1")
# Escribimos en la celda
celda.setString("Hola Mundo en Python")
return None
</source>

Aquí, es importante mencionar que Python es muy estricto con la indentación, algunos procesadores de texto plano insertan espacios en lugar de tabulaciones, Python puede trabajar sin problemas con unos y otros, el único requisito es que sean consistentes, asegúrate de que estas efectivamente insertando tabulaciones o espacios según prefieras trabajar en cada línea de código. Guarda este código como '''holamundo.py'''

=== ¿Dónde se guardan las macros? ===
Dependiendo del sistema operativo y versión de Apache OpenOffice que uses (recomendamos usar siempre la ultima versión estable), las macros pueden guardarse en:
* La carpeta del usuario, macros solo disponibles para dicho '''USUARIO''':
** En Linux y OOo 3.4 en: /home/'''USUARIO'''/config/.openoffice.org/3/user/Scripts/python
** En Windows 7 y OOo 3.4 en: C:\Users\'''USUARIO'''\AppData\Roaming\OpenOffice.org\3\user\Scripts\python
** En Windows XP y OOo 3.4 en: C:\Documents and Settings\'''USUARIO'''\Datos de programa\OpenOffice.org\3\user\Scripts\python

* La carpeta del programa, macros disponibles para todos los usuarios:
** En Linux y OOo 3.4 en: /opt/openoffice.org/basis3.2/share/Scripts/python
** En Windows 7 y OOo 3.4 en: C:\Program Files\OpenOffice.org 3\Basis\share\Scripts\python
** En Windows XP y OOo 3.4 en: C:\Archivos de programa\OpenOffice.org 3\Basis\share\Scripts\python

Estas rutas son las predeterminadas, pueden cambiar en instalaciones personalizadas o en versiones de Apache OpenOffice alternas a la oficial. Nuestra recomendación es que siempre uses e instales la ultima versión estable oficial que puedes descargar desde [http://es.openoffice.org/ aquí].
En el caso de las carpetas de usuario, es posible que no encuentres la carpeta '''python''', si es el caso, créala manualmente, escribe el nombre de esta carpeta en minúsculas. En la carpeta del programa, para escribir en ella, en Linux necesitaras permisos de administrador (root), en Windows, dependerá de las políticas de acceso del sistema.

* Dentro del documento:
Un archivo de Apache OpenOffice es realmente un archivo ZIP con una estructura determinada, por lo que puedes, también, manipularlos con tu programa favorito para este tipo de archivos. Crea y guarda un archivo nuevo de Calc, ciérralo y ábrelo ahora con tu programa ZIP. Crea las carpetas Scripts/python en la raíz del archivo. Dentro de esta carpeta agrega los archivos con las macros, para nuestro ejemplo '''holamundo.py'''. Ahora, edita el archivo manifest.xml que esta en la carpeta META-INF, a cuyo contenido agrégale las siguientes líneas, justo antes del cierre '''</manifest:manifest>'''.

<source lang=xml>
<manifest:file-entry manifest:media-type="" manifest:full-path="Scripts/python/holamundo.py"/>
<manifest:file-entry manifest:media-type="application/binary" manifest:full-path="Scripts/python/"/>
<manifest:file-entry manifest:media-type="application/binary" manifest:full-path="Scripts/"/>
</manifest:manifest>
</source>

Guarda los cambios y cierra el archivo.

=== Ejecutando nuestra macro ===
El archivo '''holamundo.py''' copialo a cualquiera de las ubicaciones vistas en el apartado anterior, como ejemplo, nosotros lo hemos copiado en las tres ubicaciones, por lo que al ir al menú Herramientas | Macros | Organizar macros | Python..., podrás ver la macro en las siguientes secciones:

# El archivo del usuario Mis Macros...
# Las macros del programa
# Dentro del documento

[[File:pyuno004.png]]

Selecciona cualquiera de las tres y presiona Ejecutar, el resultado, debe ser igual al de la siguiente imagen:

[[File:pyuno005.png]]

Cualquier duda, comentario o error, háznoslo saber [http://forum.openoffice.org/es/forum/viewforum.php?f=50 aquí].

[[Category:Manuales]]

ES/Manuales/GuiaAOO/TemasAvanzados/Macros/Python/PythonCalc/TrabajandoConHojas

2013-05-09T04:38:30Z

Mauriciobaeza: /* Copiando hojas */

ES/Manuales/GuiaAOO/TemasAvanzados/Macros/Python/PythonCalc/TrabajandoConHojas

2013-05-09T04:13:02Z

Mauriciobaeza: /* Moviendo hojas */

ES/Manuales/GuiaAOO/TemasAvanzados/Macros/Python/PythonCalc/TrabajandoConHojas

2013-05-09T04:11:42Z

Mauriciobaeza: /* Moviendo hojas */

ES/Manuales/GuiaAOO/TemasAvanzados/Macros/Python/PythonCalc/TrabajandoConHojas

2013-05-09T04:01:28Z

Mauriciobaeza: /* Borrando hojas */

ES/Manuales/GuiaAOO/TemasAvanzados/Macros/Python/PythonCalc/TrabajandoConHojas

2013-05-08T05:30:47Z