31 dic. 2009

Desarrollo de aplicaciones gráficas con python+gtk+glade. Parte 8. Calendario

Este tutorial trata sobre el uso del widget calendario, como capturar la fecha al dar clip y mostrarla en la misma ventana.
La figura muestra el diseño de la aplicación

A continuación se muestra el código de la aplicación:


#!/usr/bin/env python
# -*- coding: utf-8 -*-


import gtk, time

class App:
def __init__(self):
#Manejo del archivo glade por medio de gtkbuilder
self.glade_file = "ej8.ui"
self.glade = gtk.Builder()
self.glade.add_from_file(self.glade_file)
# cargar los widgets de la interfaz
self.window = self.glade.get_object('window1')
self.button1 = self.glade.get_object('button1')
self.button2 = self.glade.get_object('button2')
self.calendario = self.glade.get_object('calendar1')
self.label1 = self.glade.get_object('label1')
self.label2 = self.glade.get_object('label2')
self.label3 = self.glade.get_object('label3')
self.label4 = self.glade.get_object('label4')
#Asociar los eventos de los 2 botones y de la ventana
self.window.connect("destroy",self.on_window1_destroy)
self.button1.connect ("clicked",self.on_button1_clicked)
self.button2.connect ("clicked",self.on_button2_clicked)
#Tupla que maneja los meses del año
self.meses = ('Enero','Febrero','Marzo','Abril','Mayo','Junio','Julio','Agosto','Septiembre','Octubre','Noviembre','Diciembre')
#Se muestra todos los widgets
self.window.show_all()

def on_window1_destroy(self,*args):
#Cerrar aplicación
gtk.main_quit()

def on_button1_clicked(self,*args):
#Cerrar Aplicación
gtk.main_quit()

def on_button2_clicked(self,*args):
#Capturar los datos del calendario y presentarlos en las etiquetas
agno, mes, dia = self.calendario.get_date()
texto_agno = "Año: %s" %agno
texto_mes = "Mes: %s" %self.meses[mes]
texto_dia = "Dia: %s" %dia
self.label2.set_text(texto_agno)
self.label3.set_text(texto_mes)
self.label4.set_text(texto_dia)

def main(self):
gtk.main()




if __name__ == "__main__":
app = App()
app.main()






En la siguiente figura se muestra la aplicación en funcionamiento:

25 dic. 2009

Desarrollo de aplicaciones gráficas con python+gtk+glade. Parte 7. Barra de progreso y boton biestado

Continuando con la serie de tutoriales sobre pygtk. Este trata del desarrollo de una sencilla aplicación que contiene una barra de progreso que avanzará cada segundo mostrando el tiempo el cual trancurre la barra de progreso. En este tutorial como se ejecuta un proceso que puede congelar la ventana se usará hilos para evitarlo, adicionalmente se muestra el uso de botones biestado para controlar la barra de progreso.

En la figura se muestra el diseño de la aplicación.

El código se muestra a continuación:
#!/usr/bin/env python
# -*- coding: utf-8 -*-
# sin ej6.py
#
# Copyright 2009 Ernesto Nadir Crespo Avila
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
# MA 02110-1301, USA.
#Importar los módulos gtk, time, threading, thread, gobject
import gtk, time
import threading
import thread
import gobject
#Iniciando el hilo sin usarlo
gtk.gdk.threads_init()



#La clase App hereda threading.Thread
class App(threading.Thread):
def __init__(self):
#Método constructor, asociando los widgets
self.glade_file = "ej6.ui"
self.glade = gtk.Builder()
self.glade.add_from_file(self.glade_file)
self.window1 = self.glade.get_object('window1')
self.togglebutton1 = self.glade.get_object('togglebutton1')
self.button1 = self.glade.get_object('button1')
self.progressbar1 = self.glade.get_object('progressbar1')
self.new_val = 0.0
self.rango =60
#Definiendo el valor inicial de la barra de proceso, definiendo los saltos en 0.1
self.progressbar1.set_fraction(self.new_val)
self.progressbar1.set_pulse_step(0.1)
self.window1.connect("destroy",self.on_window1_destroy)
self.button1.connect('clicked', self.on_button1_clicked)
self.togglebutton1.connect('toggled',self.on_togglebutton1_toggled)
#Iniciando el hilo en el constructor
threading.Thread.__init__(self)

self.window1.show_all()




def __iteracion__(self):
#Iteración en segundos cambiando el valor en la barra de progreso.
for i in range(self.rango):
if self.togglebutton1.get_active() == True:
self.new_val = self.progressbar1.get_fraction() + 0.01
if self.new_val > 1.0:
self.new_val = 0.0
self.togglebutton1.set_active(False)
break
else:
time.sleep(1)
self.x = self.new_val*100
self.progressbar1.set_text("%s" %self.x)
self.progressbar1.set_fraction(self.new_val)
else:
return





def on_togglebutton1_toggled(self,*args):
#Si cambia el evento en el boton biestado se inicia la iteración entre los hilos.
variable = self.togglebutton1.get_active()
self.rango = 100
if variable == True:
lock = thread.allocate_lock()
lock.acquire()
thread.start_new_thread( self.__iteracion__, ())
lock.release()
else:
#Se detiene la barra de progreso
self.progressbar1.set_fraction(self.new_val)
self.progressbar1.set_text("%s" %self.x)
return




def on_window1_destroy(self,*args):
#Se cierra la aplicación
gtk.main_quit()

def on_button1_clicked(self,*args):
#Se cierra la aplicación al darle clip al boton salir.
gtk.main_quit()


def main(self):
#Inicia la aplicación
gtk.main()






if __name__ == '__main__':
app = App()
app.main()

En la siguiente figura se muestra la aplicación:

21 dic. 2009

Desarrollo de interfaz gráfica para la configuración de accesos rápidos de teclado para gconf

En el anterior artículo se mostró el desarrollo de una aplicación en python que configura vía línea de comandos los accesos rápidos de teclado para gnome por medio de gconf.

La interfáz gráfica de la aplicación la pueden bajar del siguiente enlace , el código python de la aplicación lo pueden bajar acá y el módulo configGconf.py .

La interfaz gráfica fue creada con glade usando gtkbuilder en vez de libglade, esa es una de las diferencias principales con otros desarrollos gráficos mostrados en este blog. La interfaz tiene varios botones de verificación para seleccionar cuales opciones de teclas rápidas se quieren configurar.
La siguiente figura muestra la interfaz desarrollada con glade.

A continuación el código fuente de la aplicación:

#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
Name: pyconfig-accessgnome-uy
Description: Aplicación gráfica que permite configurar los accesos rápidos de teclado a gconf
Version:0.1
License: GPLv3
Copyright: Copyright (C) 2009 Libre Accesibilidad
Author: Ernesto Nadir Crespo Avila
Email: ecrespo@gmail.com

"""




#Importar módulo gtk y el módulo de cambios de opciones de teclado
import gtk,configGconf


#Clse AccessGnomeCOnfig
class AccessGnomeConfig:
def __init__(self):

#Uso de la interfaz desarrollada con gtkbuilder y llamado del mismo.
self.glade_file = "ui.glade"
self.glade = gtk.Builder()
self.glade.add_from_file(self.glade_file)
# Asociación de todos los widgets
self.window = self.glade.get_object('dialog1')
self.button1 = self.glade.get_object('button1')
self.button2 = self.glade.get_object('button2')
self.checkbutton1 = self.glade.get_object('checkbutton1')
self.checkbutton2 = self.glade.get_object('checkbutton2')
self.checkbutton3 = self.glade.get_object('checkbutton3')
self.checkbutton4 = self.glade.get_object('checkbutton4')
self.checkbutton5 = self.glade.get_object('checkbutton5')
self.checkbutton6 = self.glade.get_object('checkbutton6')
self.checkbutton7 = self.glade.get_object('checkbutton7')
self.checkbutton8 = self.glade.get_object('checkbutton8')
self.checkbutton9 = self.glade.get_object('checkbutton9')
self.checkbutton10 = self.glade.get_object('checkbutton10')
self.checkbutton11 = self.glade.get_object('checkbutton11')
self.checkbutton12 = self.glade.get_object('checkbutton12')
self.checkbutton13 = self.glade.get_object('checkbutton13')
self.aplicaciones = []



# asociar las señales de los widgets con los métodos de la clase
self.window.connect ("close",self.on_dialog1_close)
self.window.connect("destroy",self.on_dialog1_destroy)
self.button1.connect ("clicked",self.on_button1_clicked)
self.button2.connect ("clicked",self.on_button2_clicked)
self.checkbutton1.connect("toggled",self.on_checkbutton1_toggled)
self.checkbutton2.connect("toggled",self.on_checkbutton2_toggled)
self.checkbutton3.connect("toggled",self.on_checkbutton3_toggled)
self.checkbutton4.connect("toggled",self.on_checkbutton4_toggled)
self.checkbutton5.connect("toggled",self.on_checkbutton5_toggled)
self.checkbutton6.connect("toggled",self.on_checkbutton6_toggled)
self.checkbutton7.connect("toggled",self.on_checkbutton7_toggled)
self.checkbutton8.connect("toggled",self.on_checkbutton8_toggled)
self.checkbutton9.connect("toggled",self.on_checkbutton9_toggled)
self.checkbutton10.connect("toggled",self.on_checkbutton10_toggled)
self.checkbutton11.connect("toggled",self.on_checkbutton11_toggled)
self.checkbutton12.connect("toggled",self.on_checkbutton12_toggled)
self.checkbutton13.connect("toggled",self.on_checkbutton13_toggled)
#Configuración del widget ventana, agregandole un título.
self.window.set_title("Configuración de accesos rapidos de Aplicaciones en Gnome")
self.window.show_all()
#Métodos de utilización de los botones de verificación cuando se selecciona o no.
#Cuando se selecciona se agrega el elemento a una lista
#Cuando se deselecciona se elimina el elemento de la lista.
def on_checkbutton1_toggled(self,*args):
variable = self.checkbutton1.get_active()
if variable == True:
self.aplicaciones.append("orca")
else:
self.__eliminacion("orca")

def on_checkbutton2_toggled(self,*args):
variable = self.checkbutton2.get_active()
if variable == True:
self.aplicaciones.append("nautilus")
else:
self.__eliminacion("nautilus")

def on_checkbutton3_toggled(self,*args):
variable = self.checkbutton3.get_active()
if variable == True:
self.aplicaciones.append("oowriter")
else:
self.__eliminacion("oowriter")

def on_checkbutton4_toggled(self,*args):
variable = self.checkbutton4.get_active()
if variable == True:
self.aplicaciones.append("iceweasel")
else:
self.__eliminacion("iceweasel")

def on_checkbutton5_toggled(self,*args):
variable = self.checkbutton5.get_active()
if variable == True:
self.aplicaciones.append("pidgin")
else:
self.__eliminacion("pidgin")

def on_checkbutton6_toggled(self,*args):
variable = self.checkbutton6.get_active()
if variable == True:
self.aplicaciones.append("gedit")
else:
self.__eliminacion("gedit")

def on_checkbutton7_toggled(self,*args):
variable = self.checkbutton7.get_active()
if variable == True:
self.aplicaciones.append("ooimpress")
else:
self.__eliminacion("ooimpress")

def on_checkbutton8_toggled(self,*args):
variable = self.checkbutton8.get_active()
if variable == True:
self.aplicaciones.append("gnome-calculator")
else:
self.__eliminacion("gnome-calculator")

def on_checkbutton9_toggled(self,*args):
variable = self.checkbutton9.get_active()
if variable == True:
self.aplicaciones.append("oocalc")
else:
self.__eliminacion("oocalc")

def on_checkbutton10_toggled(self,*args):
variable = self.checkbutton10.get_active()
if variable == True:
self.aplicaciones.append("rhythmbox")
else:
self.__eliminacion("rhythmbox")

def on_checkbutton11_toggled(self,*args):
variable = self.checkbutton11.get_active()
if variable == True:
self.aplicaciones.append("gnome-terminal")
else:
self.__eliminacion("gnome-terminal")

def on_checkbutton12_toggled(self,*args):
pass
"""
variable = self.checkbutton12.get_active()
if variable == True:
print "daltonicos"
else:
print "nada de daltonicos"
"""
def __eliminacion(self,aplicacion):
#Elimina un elemento de la lista
if len(self.aplicaciones) >= 2:
for i in range(len(self.aplicaciones)):
if self.aplicaciones[i] == aplicacion:
self.aplicaciones[i:i+1] = []
break
else:
continue
elif len(self.aplicaciones) == 1:
if self.aplicaciones[0] == aplicacion:
self.aplicaciones = []
else:
pass
else:
pass


def on_checkbutton13_toggled(self,*args):
#Selecciona todos los botones de verificación o los deselecciona a todos.
variable = self.checkbutton13.get_active()
if variable == True:
self.checkbutton1.set_active(1)
self.checkbutton2.set_active(1)
self.checkbutton3.set_active(1)
self.checkbutton4.set_active(1)
self.checkbutton5.set_active(1)
self.checkbutton6.set_active(1)
self.checkbutton7.set_active(1)
self.checkbutton8.set_active(1)
self.checkbutton9.set_active(1)
self.checkbutton10.set_active(1)
self.checkbutton11.set_active(1)
#self.checkbutton12.set_active(1)
else:
self.checkbutton1.set_active(0)
self.checkbutton2.set_active(0)
self.checkbutton3.set_active(0)
self.checkbutton4.set_active(0)
self.checkbutton5.set_active(0)
self.checkbutton6.set_active(0)
self.checkbutton7.set_active(0)
self.checkbutton8.set_active(0)
self.checkbutton9.set_active(0)
self.checkbutton10.set_active(0)
self.checkbutton11.set_active(0)
#self.checkbutton12.set_active(0)


def on_dialog1_close(self,*args):
#Cierra la ventana de dialogo
gtk.main_quit()

def on_dialog1_destroy(self,*args):
#Cierra la ventana de dialogo
gtk.main_quit()

def on_button1_clicked(self,*args):
#Cierra la ventana de dialogo
gtk.main_quit()

def on_button2_clicked(self,*args):

#Llama al módulo configGconf para aplicar los cambios con gconf

Config = configGconf.Conf()
Config.modificar_opcion(self.aplicaciones)

def main(self): #Método que ejecuta el programa
gtk.main()




if __name__ == "__main__":
Instancia del objeto AccessGnomeConfig y ejecución del programa

app = AccessGnomeConfig()
app.main()


La opción de applet para daltónicos no está habilitada en este momento ya que se está trabajando en agregar el applet automaticamente a la barra superior de gnome por medio de gconf. La próxima mejora será eliminar configuraciones del gconf.

En próximo artículo se creará el paquete .tar.gz de python para subirlo al repositorio oficial de python y luego crear un paquete para debian.

11 dic. 2009

Script en python que configura los accesos rápidos de teclado a aplicaciones en gnome con gconf

El script lo pueden bajar de googlecode .
Este programa tiene su ayuda:
./pyconfig-accessgnome.py --help
pyconfig-orca options
option : --help : Print this help
option : --list : List gconf for gnome-orca
option : --all : add all config access key in gconf
option : --nautilus : add gconf access key to nautilus
option : --gnome-terminal : add gconf access key to gnome-terminal
option : --oowriter : add gconf access key to oowriter
option : --pidgin : add gconf access key to pidgin
option : --gedit : add gconf access key to gedit
option : --gnome-calculator : add gconf access key to gnome-calculator
option : --ooimpress : add gconf access key to ooimpress
option : --oocalc : add gconf access key to oocalc
option : --rhythmbox : add gconf access key to rhythmbox
option : --orca : add gconf access key to orca
option : --iceweasel : add gconf access key to iceweasel

La opción --all permite configurar todas las opciones de una vez, también se puede configurar unas aplicaciones nada más.
./pyconfig-accessgnome.py --all
./pyconfig-accessgnome.py --pidgin --orca --iceweasel

El código del programa a continuación:

#!/usr/bin/env python
# -*- coding: utf-8 -*-


"""
Name: pyconfig-accessgnome
Description: Aplicación y módulo que permite modificar los accesos rápido de teclas a programas
Version:0.2
License: GPLv3
Copyright: Copyright (C) 2009 Libre Accesibilidad
Author: Ernesto Nadir Crespo Avila
Email: ecrespo@gmail.com
Changelog:
* Agregada multiples opciones de configuración

"""

import gconf


class Conf:
def __init__(self):
self.gconfClient = gconf.client_get_default()
self.aplicaciones = ("orca", "gnome-terminal","oowriter","iceweasel","nautilus","ooimpress","pidgin","oocalc","gedit","gnome-calculator","rhythmbox")
self.comando = "/apps/metacity/keybinding_commands/command_"
self.asignacion_teclado = "/apps/metacity/global_keybindings/run_command_"
self.teclas = {"orca":"o","gnome-terminal":"t","oowriter":"w","iceweasel":"n","nautilus":"h","ooimpress":"i","pidgin":"p","oocalc":"x","gedit":"e","gnome-calculator":"c","rhythmbox":"m"}
self.colorblind = {}

def modificar(self):
cont = 1
for aplicacion in self.aplicaciones:
ruta1 = "%s%s" %(self.comando,cont)
ruta2 = "%s%s" %(self.asignacion_teclado,cont)
self.gconfClient.set_string(ruta1, "%s" %aplicacion)
self.gconfClient.set_string(ruta2, "%s" %self.teclas[aplicacion])
cont = cont +1
def modificar_opcion(self,opciones_validas):
cont = 1
for aplicacion in opciones_validas:
if aplicacion in self.aplicaciones:
ruta1 = "%s%s" %(self.comando,cont)
ruta2 = "%s%s" %(self.asignacion_teclado,cont)
self.gconfClient.set_string(ruta1, "%s" %aplicacion)
self.gconfClient.set_string(ruta2, "%s" %self.teclas[aplicacion])
cont = cont +1
else:
print "please change this option: %s" %aplicacion
def listar(self):
cont = 1
for aplicacion in self.aplicaciones:
ruta1 = "%s%s" %(self.comando,cont)
ruta2 = "%s%s" %(self.asignacion_teclado,cont)
print self.gconfClient.get_string(ruta1),self.gconfClient.get_string(ruta2)
cont = cont +1


if __name__ == "__main__":
import sys
config = Conf()
global opciones
opciones = config.teclas.keys()
def mensaje():
print "pyconfig-orca options "
print "option : --help : Print this help"
print "option : --list : List gconf for gnome-orca"
print "option : --all : add all config access key in gconf"
for opcion in opciones:
print "option : --%s : add gconf access key to %s" %(opcion,opcion)
if len(sys.argv) == 1 :
mensaje()
elif len(sys.argv) == 2:
if sys.argv[1] == "--list" :
config.listar()
elif sys.argv[1] == "--all":
config.modificar()
elif sys.argv[1] == "--help" :
mensaje()
else:
for opcion in opciones:
if sys.argv[1] =="--%s" %opcion:
config.modificar_opcion(opcion)
elif len(sys.argv) > 2:
bandera = 0
opciones_validas = []
for opcion in sys.argv[1:]:
if opcion == "--list" :
bandera = 1
continue
elif opcion == "--all":
bandera = 1
continue
elif opcion == "--help":
bandera == 1
continue
else:
opciones_validas.append(opcion[2:])
if bandera == 1:
mensaje()
print "If you have a two option or more, please don\'t use --list,--all or --help."
else:
config.modificar_opcion(opciones_validas)
print "all change do it"



En próximo post se mostrará la interfaz gráfica para la aplicación.

8 oct. 2009

Desarrollo de aplicaciones gráficas con python+gtk+glade. Parte 6. Editor de Texto

En el tutorial anterior se mostró como abrir un archivo, mostrar el contenido en el widget textview, ahora se agrega la posibilidad de editar y guardar el archivo.

En la figura se muestra el diseño en glade.

A continuación el código del programa:
#!/usr/bin/env python
# -*- coding: utf-8 -*-
#Importación de módulos
import pygtk
pygtk.require('2.0')
import gtk, gtk.glade, inspect, sys
import string
#Creación de la clase ej1

class Editor:
#Creación del método constructor de la clase.
def __init__(self):
#Se captura el archivo xml de la interfaz
self.w_tree = gtk.glade.XML('ej1.glade')
#Se asocia la ventana1
self.ventana1 = self.w_tree.get_widget('ventana1')
#Se asocia el widget textview1
self.textview1 = self.w_tree.get_widget('editortexto')
#Se asocia el widget de la selección de archivo
self.seleccionararchivo = self.w_tree.get_widget('filechooserbutton1')
#Se asocia el widget de la selección de archivo
self.seleccionararchivo2 = self.w_tree.get_widget('filechooserbutton2')
#Se asocia el boton salir
self.botonsalir = self.w_tree.get_widget('bsalir')
#Se asocia los eventos con las señales
self.w_tree.signal_autoconnect(dict(inspect.getmembers(self)))
#Se asocia el objeto buffer de texto
self.buffertexto = gtk.TextBuffer()
#Se crea una lista vacía
self.lista = []
#Se crea la variable que contendrá el nombre del archivo seleccionado
self.archivo_name = ""
#Se asigna un título a la ventana
self.ventana1.set_title("Editor de texto")


#Se crea el método de selección de archivo
def on_filechooserbutton1_file_set(self,*args):
#Se captura el nombre del archivo en la variable
self.archivo_name = self.seleccionararchivo.get_filename()
#Se abre el archivo colocando su contenido en una lista
self.lista = open(self.archivo_name,"r").readlines()
#Se recorre la lista y se coloca el contenido en el buffer de texto
for i in range(len(self.lista)):
self.buffertexto.insert_at_cursor(self.lista[i])
#Se coloca el contenido del buffer en el textview
self.textview1.set_buffer(self.buffertexto)
#Se oculta la ventana de selección de archivo
self.seleccionararchivo.hide()
#Se crea el método para el boton salir


def on_filechooserbutton2_file_set(self,*args):
#Se captura el nombre del archivo en la variable
self.archivo_name2 = self.seleccionararchivo2.get_filename()
#Se captura el inicio y fin del buffer del textview
startiter, enditer = self.buffertexto.get_bounds()
#Se abre el archivo en modo escritura
archivo = open(self.archivo_name2,"w")
#Se escribe la información en el objeto archivo , tomando el texto del buffer
archivo.writelines(self.buffertexto.get_text(startiter,enditer))
#Se cierra el archivo
archivo.close()

#Salir
def on_bsalir_clicked(self,*args):
gtk.main_quit()




#Se crea el método para cerrar la aplicación
def on_ventana1_destroy(self,*args):
gtk.main_quit()
#Se crea el método main que muestra la ventana
def main(self,*args):
self.ventana1.show()
gtk.main()


if __name__ == "__main__":
app = Editor()
app.main()
La siguiente figura muestra la aplicación ejecutandose:



En la siguiente figura se muestra el contenido del archivo en el editor con posibiliad de editar:

7 oct. 2009

Agregar acceso a teclas rápidas con python

De la publicación anterior sobre uso de gconf con python, ahora se mostrará un script que agrega varios accesos rápido al gnome.

#Importar módulo gconf
import gconf

#Creando la clase Conf
class Conf:
def __init__(self):
#Se asocia al cliente de gconf
self.gconfClient = gconf.client_get_default()
#variable aplicaciones que contiene las aplicaciones a asociar
self.aplicaciones = ("orca", "gnome-terminal","oowriter","iceweasel","nautilus","ooimpress","pidgin","oocalc","gedit","gnome-calculator","rhythmbox")
#Asignación de las rutas de configuración del gconf
self.comando = "/apps/metacity/keybinding_commands/command_"
self.asignacion_teclado = "/apps/metacity/global_keybindings/run_command_"
#Asociación de las teclas rápidas con las aplicaciones
self.teclas = {"orca":"o","gnome-terminal":"t","oowriter":"w","iceweasel":"n","nautilus":"h","ooimpress":"i","pidgin":"p","oocalc":"x","gedit":"e","gnome-calculator":"c","rhythmbox":"m"}

#Modificación de la configuración de gconf
def modificar(self):
cont = 1
for aplicacion in self.aplicaciones:
ruta1 = "%s%s" %(self.comando,cont)
ruta2 = "%s%s" %(self.asignacion_teclado,cont)
self.gconfClient.set_string(ruta1, "%s" %aplicacion)
self.gconfClient.set_string(ruta2, "%s" %self.teclas[aplicacion])
cont = cont +1
#Listar las configuraciones de gconf relacionadas con las aplicaciones a ejecutar con los accesos rápidos
def listar(self):
cont = 1
for aplicacion in self.aplicaciones:
ruta1 = "%s%s" %(self.comando,cont)
ruta2 = "%s%s" %(self.asignacion_teclado,cont)
print self.gconfClient.get_string(ruta1),self.gconfClient.get_string(ruta2)
cont = cont +1


if __name__ == "__main__":
def mensaje():
#Mensaje de ayuda del comando
print "pyconfig-orca options "
print "option : --help : Print this help"
print "option : --list : List gconf for gnome-orca"
print "option : --change : Change gconf for gnome-orca"
#Importar módulo sys y instanciar la clase Conf
import sys
config = Conf()
#Si hay un argumento solamente (nombre del programa), muestra la ayuda
if len(sys.argv) == 1 :
mensaje()
#Si hay 2 argumentos (nombre del comando y acción)
elif len(sys.argv) == 2:
#Si argumento es --list se lista la configuración, sí es --change se cambia la configuración del gconf
if sys.argv[1] == "--list" :
config.listar()
elif sys.argv[1] == "--change":
config.modificar()
elif sys.argv[1] == "--help" :
mensaje()
else:
mensaje()
else:
mensaje()


El código fuente lo pueden bajar de google code de este enlace

17 jul. 2009

Cambiando la configuración de gnome con gconf desde python

En gnome se tiene la herramienta gconf-editor donde se puede cambiar la configuración del escritorio y de las aplicaciones.
la figura muestra el editor:


La idea es usar el módulo de python llamado gconf para manipular parámetros de configuración del escritorio.
Se importa el módulo gconf
>>> import gconf
#Conectarse con el escritorio gnome.
>>> gconfClient = gconf.client_get_default()
#Se le asigna el nombre de usuario a la aplicación apps/pyconchatter/
>>> gconfClient.set_string("/apps/pyconchatter/username", "ecrespo")
True
#Se obtiene el nombre de usuario de la aplicación pyconchatter
>>> usuario = gconfClient.get_string("/apps/pyconchatter/username")
>>> print usuario
ecrespo
>>>
>>> panel = gconfClient.get_string("/apps/panel/toplevels/panel_1/auto_hide")
>>> print panel
None
#Se obtiene los valores de los accesos rápidos del teclado para el orca.
>>> print gconfClient.get_string("/apps/metacity/keybinding_commands/command_1")
orca
>>> print gconfClient.get_string("/apps/metacity/global_keybindings/run_command_1")
o
>>>
#Devuelve el nombre del archivo del fondo de pantalla del escritorio.
>>> print gconfClient.get_string("/desktop/gnome/background/picture_filename")
/home/ernesto/Escritorio/12003375.jpg


Con este módulo se pueden hacer aplicaciones gráficas con gtk y los parámetros de configuración de la aplicación se puede manejar desde gconf con python.

12 jul. 2009

Python en Android

En la lista de python Argentina pasan el enlace de una aplicación para android que le da soporte para realizar programas en python; la aplicación se llama android-scripting es una aplicación que brinda a los usuarios una serie de lenguajes script entre ellos python.
La aplicación permite hacer lo siguiente:
  • Capturar eventos
  • Iniciar actividades
  • Realizar llamadas teléfonicas
  • Enviar mensajes de texto
  • Escanear códigos de barras
  • Localización
  • Usar text-to-speech: Osea se puede generar mensajes accesibles para las personas invidentes!

Más información en el wiki del proyecto. Espero pronto hacer pruebas y traducir algunos tutoriales.
http://google-opensource.blogspot.com/2009/06/introducing-android-scripting.html
http://code.google.com/p/android-scripting/
http://code.google.com/p/android-scripting/w/list

5 jul. 2009

Desarrollo de aplicaciones gráficas con python+gtk+glade. Parte 5

Utilizar el widget textview.
El siguiente ejemplo se explicará el uso del widget textview. Se creará una ventana con 4 widgets, una etiqueta que menciona la lectura de archivos, luego el textview donde se mostrará el contenido de un archivo, el boton de selección de archivo y el boton de salir.
La figura muestra el diseño de la interfaz:


A continuación se explica el código del desarrollo:

#!/usr/bin/env python
# -*- coding: utf-8 -*-
#Importación de módulos
import pygtk
pygtk.require('2.0')
import gtk, gtk.glade, inspect, sys
#Creación de la clase ej8
class ej8:
#Creación del método constructor de la clase.
def __init__(self):
#Se captura el archivo xml de la interfaz
self.w_tree = gtk.glade.XML('ej8.glade')
#Se asocia la ventana1
self.ventana1 = self.w_tree.get_widget('ventana1')
#Se asocia el widget textview1
self.textview1 = self.w_tree.get_widget('textview1')
#Se asocia el widget de la selección de archivo
self.seleccionararchivo = self.w_tree.get_widget('seleccionararchivo')
#Se asocia el boton salir
self.botonsalir = self.w_tree.get_widget('botonsalir')
#Se asocia los eventos con las señales
self.w_tree.signal_autoconnect(dict(inspect.getmembers(self)))
#Se asocia el objeto buffer de texto
self.buffertexto = gtk.TextBuffer()
#Se crea una lista vacía
self.lista = []
#Se crea la variable que contendrá el nombre del archivo seleccionado
self.archivo_name = ""
#Se crea el método de selección de archivo
def on_seleccionararchivo_file_set(self,*args):
#Se captura el nombre del archivo en la variable
self.archivo_name = self.seleccionararchivo.get_filename()
#Se abre el archivo colocando su contenido en una lista
self.lista = open(self.archivo_name,"r").readlines()
#Se recorre la lista y se coloca el contenido en el buffer de texto
for i in range(len(self.lista)):
self.buffertexto.insert_at_cursor(self.lista[i])
#Se coloca el contenido del buffer en el textview
self.textview1.set_buffer(self.buffertexto)
#Se oculta la ventana de selección de archivo
self.seleccionararchivo.hide()
#Se crea el método para el boton salir
def on_botonsalir_clicked(self,*args):
gtk.main_quit()
#Se crea el método para cerrar la aplicación
def on_ventana1_destroy(self,*args):
gtk.main_quit()
#Se crea el método main que muestra la ventana
def main(self,*args):
self.ventana1.show()
gtk.main()

if __name__ == "__main__":
app = ej8()
app.main()

A continuación de muestra la aplicación al ejecutarse:


Se selecciona el archivo y luego se muestra en el widget textview:

4 jul. 2009

Creado el proyecto python-autoaccesibilidad

La página del proyecto se encuentra en:

http://code.google.com/p/python-autoaccesibilidad/


La descripción del mismo se encuentra en el wiki:

Introducción

Este programa permitirá la instalación de aplicaciones accesibles en equipos con Debian ya instalados sin necesidad de tener una conexión a internet o un mirror en la red; es útil para laboratorios y centros de navegación.

Para los usuarios se tendrá 2 paquetes de Debian (metapaquete accesibilidad, accesibilidad-gnome-conf-spanish y accesibilidad-gnome-conf-english) que facilitará la instalación de sus equipos.

Detalles

La aplicación tendrá las siguientes características:

Los módulos que se necesitan son:

Contendrá 2 directorios:

Más información en el blog de libre accesibilidad:

http://libreaccesibilidad.blogspot.com/2009/07/proyecto-python-autoaccesibilidad.html

2 jul. 2009

Crear documentos ODF directamente desde python

Existe una herramienta y API para python que permite crear documentos y hojas de cálculo directamente desde un programa. El módulo se llama odfpy .

Bajar e instalar odfpy:
Se puede bajar desde el repositorio subversion:
svn export https://svn.forge.osor.eu/svn/odfpy/trunk odfpy
Luego se cambia al directorio odfpy
cd odfpy
Para instalar se ejecuta
python setup.py install

Desde easy_install:

easy_install odfpy

En este caso baja el paquete y lo instala.
Las herramientas que se instalan son:
  • mailodf - Envía un archivo ODF como html
  • odf2xhtml - Convierte ODF a (X)HTML
  • odf2xml - Crea un documento xml desde el archivo ODF
  • odf2mht - Convierte ODF a HTML
  • odf2war - Convierte ODF a archivo web de KDE
  • odfimgimport - Importa imagenes del documento
  • odflint - Verifica el archivo
  • odfmeta - Lista o cambia la información metadata de un archivo ODF
  • odfoutline - Muestra el documento fuera de línea
  • odfuserfield - Lista o cambia las los campos de declaración del usuario en un archivo ODF
  • xml2odf - Crea un archivo ODF a partir de un archivo XML
El ejemplo "Hola Mundo".
Se ejecuta el interpretador de comando de python
Importar los módulos de Opendocument
>>> from odf.opendocument import OpenDocumentText
Importar el módulo de manejo de documentos de texto
>>> from odf.text import P
Se usa el objeto que maneja documentos de texto
>>> textdoc = OpenDocumentText()
Se escribe Hola mundo en un elemento
>>> p = P(text="Hola mundo!")
Se agrega el elemento al documento
>>> textdoc.text.addElement(p)
Se salva el documento
>>> textdoc.save("holamundo",True)

En la siguiente imagen se muestra el documento creado.

17 jun. 2009

Desarrollo de aplicaciones gráficas con python+gtk+glade. Parte 4

El siguiente ejemplo explicará como manejar 2 ventanas en una aplicación.
La primera venta muestra 2 etiquetas una con un texto y la otra en blanco, luego una entrada de datos solicitando el nombre, 2 botones uno de capturar texto y otra de salir. Al darle al botón de capturar texto se abre otra ventana preguntando si está seguro de lo que desea hacer, si se le da aceptar presenta el texto en la etiqueta.

La siguiente figura muestra la interfaz desarrollado con glade.



El código del programa es el siguiente:

#!/usr/bin/env python
# -*- coding: utf-8 -*-

import pygtk
pygtk.require('2.0')
import gtk, gtk.glade, inspect, sys

class ej5:
def __init__(self):
#Se captura el archivo de la interfaz glade
self.w_tree = gtk.glade.XML('ej5.glade')
#Se asocian los widgets ventana1, etiqueta2, entrada, boton1, boton2
#ventana1, boton3 y boton4
self.ventana1 = self.w_tree.get_widget('ventana1')
self.etiqueta2 = self.w_tree.get_widget('etiqueta2')
self.entrada = self.w_tree.get_widget("entrada")
self.b_capturar = self.w_tree.get_widget('boton1')
self.b_salir = self.w_tree.get_widget('boton2')
self.ventana2 =self.w_tree.get_widget("ventana2")
self.baceptar = self.w_tree.get_widget("boton3")
self.bsalir = self.w_tree.get_widget("boton4")
#Se asocian las señales con los métodos
self.w_tree.signal_autoconnect(dict(inspect.getmembers(self)))
#Se define la variable texto en blanco.
self.texto = ""
#El método del boton2 salir, al darle clip se cierra la aplicación
def on_boton2_clicked(self,*args):
gtk.main_quit()
#El boton1 es para capturar el texto y luego se muestra la ventana2
def on_boton1_clicked(self,*args):
self.texto = self.entrada.get_text()
self.ventana2.show()

#El boton3 es el boton que acepta la captura de texto, se hace esto y se le
#pasa el texto a la etiqueta2, se cierra la ventan2.
def on_boton3_clicked(self,*args):
self.etiqueta2.set_text(self.texto)
self.ventana2.hide()
#Se cierra la ventana2
def on_boton4_clicked(self,*args):
self.ventana2.hide()
#Al presionar cerrar la ventana1 se cierra la aplicación
def on_ventana1_destroy(self,*args):
gtk.main_quit()
#Al presionar cerrar la ventana2 se oculta la misma
def on_ventana2_destroy(self,*args):
self.ventana2.hide()
#Se muestra la ventana1 y se oculta la ventana 2 al iniciar el programa.
def main(self,*args):
self.ventana2.hide()
self.ventana1.show()
gtk.main()

if __name__ == "__main__":
app = ej5()
app.main()


Al ejecutar el programa se muestra la siguiente figura:


Se escribe el nombre y se presiona capturar texto:


Al presiona capturar texto y se abre una ventana con la pregunta si se desea aceptar o salir de la aplicación.


Para finalizar se muestra la captura de texto en la etiqueta.