25 de ene. de 2010

Tutorial de python+qt. Parte 2

En ese tutorial se explicará como colocarle un icono a la ventana, crear un botón para salir de la aplicación y todo el código se desarrollará orientado a objetos.



#!/usr/bin/env python

# -*- coding: utf-8 -*-

#Importar módulo sys
import sys
#De PyQt4 importar QtGui y QtCore

from PyQt4 import QtGui, QtCore
#Se crea la clase QuitButton que hereda de la clase QWidget.
class QuitButton(QtGui.QWidget):
def __init__(self, parent=None):
QtGui.QWidget.__init__(self, parent)
#Se define el tamaño de la ventana
self.setGeometry(400, 400, 250, 150)
#Se le coloca un título a la ventana y se asocia un icono.
self.setWindowTitle('Prueba de boton para salir')

self.setWindowIcon(QtGui.QIcon('./icono.png'))

#Se crea el botón salir con su tamaño

quit = QtGui.QPushButton('Salir', self)

quit.setGeometry(10, 10, 60, 35)

#Se asocia la señal del botón con quit

self.connect(quit, QtCore.SIGNAL('clicked()'),QtGui.qApp, QtCore.SLOT('quit()'))


#Se ejecuta el programa principal

if __name__ == "__main__":
#Se instancia la clase QApplication

app = QtGui.QApplication(sys.argv)

#Se instancia el objeto QuitButton

qb = QuitButton()

#Se muestra la aplicación

qb.show()

#Se sale de la aplicación

sys.exit(app.exec_())




La siguiente figura muestra la aplicación ejecutandose.

Tutorial de python+qt. Parte 1

Luego de unos cuantos artículos sobre gtk empezaré a publicar artículos sobre pyqt debido a que me asignaron a otro proyecto estoy evaluando desarrollar en pyqt o en wxwidget.

Los primeros tutoriales se enfocarán al desarrollo de la interfaz a pie sin utilizar qtdesigner.

Este ejemplo simplemente muestra una ventana con un tamaño definido y el título de la misma.

#!/usr/bin/env python
# -*- coding: utf-8 -*-
#Importar módulo sys
import sys
#importar QTGui de pyQt4
from PyQt4 import QtGui

#Se instancia la clase QApplication pasandole sys.argv
app = QtGui.QApplication(sys.argv)

#Se crea la instancia de QWidget.
widget = QtGui.QWidget()
#Se define el tamaño de la ventana
widget.resize(250, 150)
#Se le coloca el título a la ventana
widget.setWindowTitle('Es una prueba')
#Se muestra la ventana
widget.show()
#Se sale de la aplicación
sys.exit(app.exec_())


La figura muestra la ventana que se creó:

2 de ene. de 2010

Desarrollo de aplicaciones gráficas con python+gtk+glade. Parte 10. Generador de código de barra

En este artículo se explicará como usar los botones de radio y manejar imágenes. El programa es un generador de códigos de barra.

Python tiene un módulo para crear imágenes svg con código de barra, Este módulo se llama pyBarcode; para poder instalar este módulo se requiere python2.6 y en el equipo por defecto python2.5. Se instaló la versión 2.6 y se compilo pyBarcode con esta versión. Por esa razón se creo un script para generar el código de barras que usa python 2.6 y el programa gráfico usa python2.5.

En el programa gráfico se le puede pasar un número de 12 dígitos para generar un código de barras o generar el código de forma aleatoria.

El diseño gráfico de la aplicación se muestra en la siguiente figura:

El código del script que genera el código de Barras es el siguiente:

#!/opt/python/bin/python2.6
# -*- coding: utf-8 -*-
#Importar barcode y sys
import barcode,sys


#Funcion generar codigo se le pasa el numero para generar el codigo
def generar_codigo(dato):
#Se usara EAN13
EAN = barcode.get_barcode('ean13')
ean = EAN(u'%s' %dato)
#Se salva el archivo en formato svg
fullname = ean.save('ean13_barcode')
fullname


if __name__ == "__main__":
#se importa el modulo commands
import commands
#Se borra el archivo anterior
commands.getstatusoutput("rm ean13_barcode.svg")
#Se toma el argumento para generar el codigo
dato =sys.argv[1]
#Se ejecuta la funcion
generar_codigo(dato)


El código de la aplicación gráfica es el siguiente:

#!/usr/bin/env python
# -*- coding: utf-8 -*-
#Importar modulo gtk,commands y random
import gtk, commands, random

class App:
def __init__(self):
#Manejo del archivo glade por medio de gtkbuilder
self.glade_file = "ej13.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('dialog1')
self.button1 = self.glade.get_object('button1')
self.button2 = self.glade.get_object('button2')
self.button3 = self.glade.get_object('button3')
self.radiobutton1 = self.glade.get_object('radiobutton1')
self.radiobutton2 = self.glade.get_object('radiobutton2')
self.entrada = self.glade.get_object('entry1')
self.imagen = self.glade.get_object('image1')
#Valores iniciales de la aplicacion Titulo y tama?o de la ventana
self.window.set_title("Ejemplo de generacion de codigo de barra")
self.window.set_default_size(600, 400)


#Asociar los eventos de los 2 botones y de la ventana
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.button3.connect ("clicked",self.__on_button3_clicked)
self.radiobutton1.connect("toggled",self.__on_radiobutton1_toggled)
self.radiobutton2.connect("toggled",self.__on_radiobutton2_toggled)
#Se muestra todos los widgets
self.window.show_all()


def __on_radiobutton1_toggled(self,*args):
#Si este boton se selecciona se muestra la entrada de datos
self.entrada.show()


def __on_radiobutton2_toggled(self,*args):
#Si este boton se selecciona se oculta la entrada de datos
self.entrada.hide()

def __on_dialog1_close(self,*args):
#Se cierra la aplicacion
gtk.main_quit()

def __on_dialog1_destroy(self,*args):
#Se cierra la aplicacion
gtk.main_quit()

def __on_button1_clicked(self,*args):
#Creacion del codigo de barra
if self.radiobutton1.get_active() == True:
#Si el boton de radio esta activo se captura la entrada de texto
self.texto = self.entrada.get_text()
valor = int(self.texto)
elif self.radiobutton2.get_active() == True:
#Se el boton de radio esta activo se oculta la entrada de texto y se genera el numero
#de forma aleatoria
self.entrada.hide()
valor = int(random.random()*1000000000000)
#Se ejecuta el generador de codigo de barra
commands.getstatusoutput("./generador.py %s" %valor)
#Se carga la nueva imagen del codigo de barra generado
self.imagen.set_from_file('./ean13_barcode.svg')

def __on_button2_clicked(self,*args):
#El boton salir, se cierra la aplicacion
gtk.main_quit()

def __on_button3_clicked(self,*args):
#El boton se restaurar la aplicacion, se coloca una imagen en blanco
self.imagen.set_from_file('./1.png')


def main(self):
#Se inicia la aplicacion
gtk.main()


if __name__ == "__main__":
#Se crea una instancia del objeto y se ejecuta el metodo main
app = App()
app.main()

La siguiente gráfica muestra la ejecución de la aplicación:

1 de ene. de 2010

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

Continuando con los artículos de desarrollo de aplicaciones con python y gtk. Ahora uniré los artículos relacionados con matplotlib y gtk.
Se diseño una ventana de dialogo con una gráfica en el centro, 2 botones, uno para cargar la curva en la gráfica y el otro botón para cerrar la aplicación.
La figura muestra el diseño de la interfaz con glade.

El código de la creación de la aplicación es el siguiente:

#!/usr/bin/env python
# -*- coding: utf-8 -*-
#Importar módulo gtk y matplotlib
import gtk
import matplotlib

matplotlib.use('GTK')
#Importar la clase figure, subplot, figurecanvasgtk, figurecanvas
from matplotlib.figure import Figure
from matplotlib.axes import Subplot
from matplotlib.backends.backend_gtk import FigureCanvasGTK, NavigationToolbar
from matplotlib.backends.backend_gtkagg import FigureCanvasGTKAgg as FigureCanvas
#Importar numpy
import numpy as np
#Definición de la clase
class App:
def __init__(self):
#Manejo del archivo glade por medio de gtkbuilder
self.glade_file = "ej10.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('dialog1')
self.button1 = self.glade.get_object('button1')
self.button2 = self.glade.get_object('button2')
#Título de la ventana de dialogos
self.window.set_title("Ventana de dialogo para demostrar uso de matplotlib")
#Tamaño de la ventana de dialogos
self.window.set_default_size(600, 400)
#Asociación de los eventos con los widgets
self.window.connect("destroy",self.on_dialog1_destroy)
self.window.connect("close",self.on_dialog1_close)
self.button1.connect ("clicked",self.on_button1_clicked)
self.button2.connect ("clicked",self.on_button2_clicked)
#Definición del widget que manejará la gráfica
self.figura = Figure(figsize=(10, 8), dpi=100)
self.ax = self.figura.add_subplot(111)
self.ax.set_xlabel("Eje X")
self.ax.set_ylabel("Eje Y")
self.ax.set_title('Grafica')
self.ax.grid(True)
self.canvas = FigureCanvasGTK(self.figura)
self.canvas.show()
#Agregar la gráfica a la caja vertical
self.vbox1 = self.glade.get_object("vbox1")
self.vbox1.pack_start(self.canvas, True, True)
#Mostrar la ventana
self.window.show_all()

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

def on_button1_clicked(self,*args):
#Carga la curva en la gráfica
#Se oculta el canvas creado al inicio
self.canvas.hide()
#Generación de los valores X y Y
self.x = np.arange(0,2*np.pi, .01)
self.y = np.sin(self.x**2)*np.exp(-self.x)
#Dibuja la curva
self.ax.plot(self.x, self.y)
#Se agrega la curva al canvas
self.canvas = FigureCanvas(self.figura)
#Se muestra el canvas
self.canvas.show()
#Se agrega el canvas a la caja vertical
self.vbox1.pack_start(self.canvas, True, True)


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

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

def main(self):
#Ejecutar la aplicación gráfica
gtk.main()



if __name__ == "__main__":
#Creación de la instancia y ejecución del método main
app = App()
app.main()







La siguiente gráfica muestra la ejecución de la aplicación:


La siguiente gráfica muestra la aplicación luego de presionar el botón aplicar y cargar la curva:

AddThis