Tutorial python gtk3 Entry

En esta ocasión vamos a aprender a usar cajas de entrada de texto usando Python + Gtk. Los entry se usan para introducir texto,o mostrar texto en forma muy corta.

Para crear un entry se crea un objeto de la clase Gtk.Entry(),los cuales pueden tener algunos parámetros,funciones para hacer un entry mas customizado y funcional:

self.entry = Gtk.Entry()

Este es un entry muy muy básico:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

# -*- coding: latin-1 -*- from gi.repository import Gtk, GObject class Ejemplo(Gtk.Window): def __init__(self): Gtk.Window.__init__(self, title="Ejemplo entry") self.set_size_request(200, 100) self.entry = Gtk.Entry() self.add(self.entry) ventana = Ejemplo() ventana.connect("delete-event", Gtk.main_quit) ventana.show_all() Gtk.main()

Ahora vamos a ver algunas funciones:

Añadir texto al crearlo:

Para añadir texto vamos a usar el argumento explicito text,al crearlo:

self.entry = Gtk.Entry(text="Hola Mundo!!")

 Si se desea colocar texto en el entry aun cuando ya esta creado el objeto,podemos usar la función set_text("texto"):

self.entry.set_text("Hola Mundo!!")

De igual manera tenemos una función opuesta que llama el texto que se haya introducido :

self.entry.get_text()

Ejemplo de intercambiar texto de un entry a otro:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32

# -*- coding: latin-1 -*- from gi.repository import Gtk, GObject class Ejemplo(Gtk.Window): def __init__(self): Gtk.Window.__init__(self, title="Ejemplo entry") self.set_size_request(200, 100) self.pos = [Gtk.Orientation.HORIZONTAL,Gtk.Orientation.VERTICAL] self.vbox = Gtk.Box() self.vbox.set_spacing(1) self.vbox.set_orientation(self.pos[1]) self.entry = Gtk.Entry(text="Hola Mundo!!") # Inicia con el texto "Hola Mundo!!" self.vbox.pack_start(self.entry,True,False,1) # Lo añadimos al box self.button = Gtk.Button(label="Cambiar") # Añadimos un boton self.vbox.pack_start(self.button,True,False,1) self.button.connect("clicked", self.cambiar) # Si el boton se cliquea vamos a la funcion cambiar self.entry2 = Gtk.Entry() self.vbox.pack_start(self.entry2,True,False,1) self.add(self.vbox) def cambiar(self,widget): texto = self.entry.get_text() # El texto es igual al get_text() del entry1 self.entry2.set_text(texto) # Ponemos el texto del entry1 en el entry2 ventana = Ejemplo() ventana.connect("delete-event", Gtk.main_quit) ventana.show_all() Gtk.main()

También contamos con funciones para esconder el texto ingresado:

Para ello solo usamos la función set_visibility(bool) con un valor booleano,en este caso False:

self.entry.set_visibility(False)

Ejemplo de login:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38

from gi.repository import Gtk, GObject class Ejemplo(Gtk.Window): def __init__(self): Gtk.Window.__init__(self, title="Ejemplo entry") self.set_size_request(200, 100) self.pos = [Gtk.Orientation.HORIZONTAL,Gtk.Orientation.VERTICAL] self.vbox = Gtk.Box() self.vbox.set_spacing(1) self.vbox.set_orientation(self.pos[1]) self.entry = Gtk.Entry() self.vbox.pack_start(self.entry,True,False,1) self.entry2 = Gtk.Entry() self.entry2.set_visibility(False) self.vbox.pack_start(self.entry2,True,False,1) self.button = Gtk.Button(label="Login") self.button.connect("clicked", self.login) self.vbox.pack_start(self.button,True,False,1) self.add(self.vbox) def login(self,widget): user = self.entry.get_text() password = self.entry2.get_text() if (user == "Gtk" and password == "Gtk"): print "Login correcto" else: print "Login incorrecto" ventana = Ejemplo() ventana.connect("delete-event", Gtk.main_quit) ventana.show_all() Gtk.main()

En ese mismo ejemplo podemos usar algo que se usan en muchos logins,asignar un máximo de letras al usar el entry:

self.entry.set_max_length(numero_de_letras)

Tambien en el ejemplo de arriba si quisieramos indicar de que o para que sirve el entry podemos usar un placeholder,esto para que nos muestre de que sirve sin añadir un widget extra y que no estorbe en funcionalidad:

self.entry.set_placeholder_text("Texto")

Si quisiéramos hacer que el testo mostrado,por ejemplo desde el principio (como se ve arriba) fuera inmutable,podemos usar set_editable(), al cual le pasamos como argumento un bool,para ver si se podrá editar:

self.entry.set_editable(False) # Evita cambio

Si queremos que nuestro entry nos autocomplete podemos usar un EntryCompletion,esto lo veremos cuando veamos los Liststore,pero de momento pueden ver esta función que crea un EntryCompletion:

1 2 3 4 5 6 7 8 9 10 11 12 13

def set_completation(self): sistemas = [ "Ubuntu","Arch","Gentoo","Debian","Mint","openSUSE", ] liststore = Gtk.ListStore(str) for sistema in sistemas: liststore.append([sistema]) completion = Gtk.EntryCompletion() completion.set_model(liststore) completion.set_text_column(0) return completion

Esa función devuelve una EntryCompletion ahora solo tenemos que asignarla al entry,con la funcion

self.entry.set_completion(self.set_completation())

Este es un ejemplo que pregunta que distribución de Linux usas:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48

from gi.repository import Gtk, GObject class Ejemplo(Gtk.Window): def __init__(self): Gtk.Window.__init__(self, title="Ejemplo entry") self.set_size_request(200, 100) self.pos = [Gtk.Orientation.HORIZONTAL,Gtk.Orientation.VERTICAL] self.vbox = Gtk.Box() self.vbox.set_spacing(1) self.vbox.set_orientation(self.pos[1]) self.entry = Gtk.Entry() self.entry.set_placeholder_text("Que sistema Linux usas?") self.entry.set_completion(self.set_completation()) self.vbox.pack_start(self.entry,True,False,1) self.button = Gtk.Button(label="Aceptar") self.button.connect("clicked", self.uso) self.vbox.pack_start(self.button,True,False,1) self.add(self.vbox) def set_completation(self): sistemas = [ "Ubuntu","Arch","Gentoo","Debian","Mint","openSUSE", ] liststore = Gtk.ListStore(str) for sistema in sistemas: liststore.append([sistema]) completion = Gtk.EntryCompletion() completion.set_model(liststore) completion.set_text_column(0) return completion def uso(self,widget): if self.entry.get_text() != "": print "Uso %s" %(self.entry.get_text()) ventana = Ejemplo() ventana.connect("delete-event", Gtk.main_quit) ventana.show_all() Gtk.main()

Si quisiéramos que hubiera un boton en el mismo entry para no usar uno ajeno haríamos esto:

Primero añadimos un icono,por ejemplo uno de los stocks :

self.entry.set_icon_from_stock(icon_pos,stock)

En stock añadimos uno de los siguientes:

Enlace 

Y en icon_pos,podemos usar:

Gtk.EntryIconPosition.SECONDARY # Derecha

Gtk.EntryIconPosition.PRIMARY # Izquierda

Ahora nos quedaría así,un boton para limpiar el texto(borrar el texto del entry):

self.entry.set_icon_from_stock(Gtk.EntryIconPosition.SECONDARY,Gtk.STOCK_CLEAR)

Con eso añadiríamos el boton,pero ahora hay que definir la función,para ellor tendriamos que añadir la señal de icono presionado:

self.entry.connect("icon-press",self.limpiar,None)

El primer argumento es el tipo de señal,el segundo la función a llamar,y el tercero es algún parámetro extra.

Por ultimo podemos añadir un tooltip al boton del entry para que nos diga por ejemplo en este ejemplo que es lo que hace,en este caso borrar el texto,par ello solo debemos llamar la función set_icon_tooltip_text, y pasarle rn el primer parametro la posision(igual que arriba) y en el segundo el tooltip:

 self.entry.set_icon_tooltip_text(Gtk.EntryIconPosition.SECONDARY, "Borrar texto")

Ejemplo completo:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55

# -*- coding: latin-1  -*- from gi.repository import Gtk, GObject class Ejemplo(Gtk.Window): def __init__(self): Gtk.Window.__init__(self, title="Ejemplo entry") self.set_size_request(200, 100) self.pos = [Gtk.Orientation.HORIZONTAL,Gtk.Orientation.VERTICAL] self.vbox = Gtk.Box() self.vbox.set_spacing(1) self.vbox.set_orientation(self.pos[1]) self.entry = Gtk.Entry() self.entry.set_placeholder_text("Que sistema Linux usas?") self.entry.set_completion(self.set_completation()) self.entry.set_icon_tooltip_text(Gtk.EntryIconPosition.SECONDARY, "Borrar texto") self.entry.set_icon_from_stock(Gtk.EntryIconPosition.SECONDARY,Gtk.STOCK_CLEAR) self.entry.connect("icon-press",self.limpiar,None) self.vbox.pack_start(self.entry,True,False,1) self.button = Gtk.Button(label="Aceptar") self.button.connect("clicked", self.uso) self.vbox.pack_start(self.button,True,False,1) self.add(self.vbox) def limpiar(self,*args): self.entry.set_text("") def set_completation(self): sistemas = [ "Ubuntu","Arch","Gentoo","Debian","Mint","openSUSE", ] liststore = Gtk.ListStore(str) for sistema in sistemas: liststore.append([sistema]) completion = Gtk.EntryCompletion() completion.set_model(liststore) completion.set_text_column(0) return completion def uso(self,widget): if self.entry.get_text() != "": print "Uso %s" %(self.entry.get_text()) ventana = Ejemplo() ventana.connect("delete-event", Gtk.main_quit) ventana.show_all() Gtk.main()

Eso es todo :D

Referencia : developer.gnome.org/

Leer más...

Tutorial python gtk3 Spinner y ProgressBar

En muchas ocasiones necesitamos mostrar una pequeña señal de que algo esta pasando,cuando estamos ejecutando una tarea y necesitamos que algo este respondiendo a dicha acción,por ejemplo cuando descargamos algo,cuando movemos archivos,cuando salvamos un documento,etc.

En muchos casos de muchos sistemas vemos los spinners,loc cuales son un widget que giran o se hacen presentes hasta que son necesarios,por ejemplo en windows cuando esta una tarea ocupada vemos que el cursor se convierte en un spinner,luego en otros casos cuando necesitamos un dialogo mas preciso nos encontramos con las barras de progreso o progressbar en ingles,los barras de progreso nos muestran una información mas exacta en casos en los cuales los spinners no son suficientes,en este caso veremos como funcionan ambos widgets en Gtk3 + Python.

Spinner:

Para crear un spinner se usa el constructor Gtk.Spinner(),al cual le podemos pasar el parámetro active para que le digamos al constructor si queremos que comience en movimiento:

self.spinner = Gtk.Spinner(active=True) # Comienza en movimiento

self.spinner = Gtk.Spinner() # Comienza quieto

Las únicas dos funciones que tenemos en este widget es start y stop una para iniciar y otro para comenzar,vamos a crear una ventana de ejemplo para ver como funciona:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37

# -*- coding: latin-1 -*- from gi.repository import Gtk, GObject class SpinnerEjemplo(Gtk.Window): def __init__(self): Gtk.Window.__init__(self, title="Spinner") self.set_border_width(5) self.connect("delete-event", Gtk.main_quit) self.vbox = Gtk.Box(spacing=5) self.button = Gtk.ToggleButton("Girar") self.button.connect("toggled", self.on_start) # Este boton manipula el spinner self.button.set_active(False) self.vbox.pack_start(self.button,True,False,10) self.spinner = Gtk.Spinner() # Creamos un spinner self.vbox.pack_start(self.spinner,True,False,10) self.add(self.vbox) self.show_all() def on_start(self, widget): if widget.get_active(): # widget es el boton si esta activo self.spinner.start() # Iniciamos el widget self.button.set_label("Detener") else: # Si no self.spinner.stop() # Lo detenemos self.button.set_label("Girar") myspinner = SpinnerEjemplo() Gtk.main()

Como vemos es muy simple mostrar un  spinner,en el caso del progressbar es un poco mas complicado pero a la vez esto nos da mas posibilidades de personalización y una mayor descripción de la situación:

ProgresBar:

Para crear un ProgressBar se usa el constructor Gtk.ProgressBar(),primero que nada vamos a crear un ejemplo sencillo:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44

# -*- coding: latin-1 -*- from gi.repository import Gtk, GObject class SpinnerEjemplo(Gtk.Window): def __init__(self): Gtk.Window.__init__(self, title="Progressbar") self.set_border_width(5) self.connect("delete-event", Gtk.main_quit) self.vbox = Gtk.Box(spacing=5) self.button = Gtk.ToggleButton("Iniciar") self.button.connect("toggled", self.on_control) # Este boton manipula el spinner self.button.set_active(False) self.vbox.pack_start(self.button,True,False,10) self.progressbar = Gtk.ProgressBar() # Creamos un ProgressBar self.vbox.pack_start(self.progressbar,True,False,10) self.timeout_id = GObject.timeout_add(100, self.on_start, None) # Esta funcion es mantiene el ciclo de on_start # en milisegunos self.controller = False # Creamos un controlador self.add(self.vbox) self.show_all() def on_control(self,widget): self.controller = widget.get_active() # Cambiamos el valor del controlador al valor del boton if self.controller: self.button.set_label("Pausar") else: self.button.set_label("Continuar") def on_start(self, widget): # Esta funcion se ejecuta cada 100 milisegundos basado en el retorno de la misma if self.controller: # Si el controlador es True new_value = self.progressbar.get_fraction() + 0.01 # Añade una centecima if new_value > 1: # Si el valor es uno(completo) new_value = 0 # Reiniciamos a cero(vacio) self.progressbar.set_fraction(new_value) # Colocamos la fraccion return True myspinner = SpinnerEjemplo() Gtk.main()

Como vemos,he usado una función de la clase de ProgressBar,las cuales es:

set_fraction(new_value) # new_value es un entero a punto flotante 0,por ejemplo:

0.99,0.10,0.01,etc # 1 es lleno

También tenemos otras mas:

pulse() # Esta función hace que sea indefinida la barra de progreso,ya que solo va de un lado a otro.

set_inverted(bool) # Esta función invierte la forma que se llena el progressbar si el parámetro pasado es True.

set_orientation(orientacion) # Esta función cambia la forma de la orientación,por defecto es horizontal,pero podemos cambiarla a vertical pasandole como parámetro Gtk.Orientation.VERTICAL.

set_show_text("Porcentaje") # Muestra el progreso de la barra en porcentaje.

set_text("Texto") # Coloca texto a la barra.

De momento eso es todo,en otra ocasión veremos las labels,menus,etc.

Leer más...

Tutorial python Gtk3 botones y layouts

Si vieron el script que programe hace unos días se habrán dado cuenta que use un programa muy útil que se llama zenity,este programa nos crea ventanas fácilmente para usarlas en script's de shell,eso lo menciono porque existen niveles de programación y lo que seria zenity seria muy alto,no muy alto de que es muy buen coder el que lo usa si no de que esta muy preparado para usarse lo cual nos quita la capacidad de personalización por asi decirlo ya que trae hechas las GUI que podemos usar,las cuales nos devuelven un valor,si nos damos cuenta cuando ya lleven por lo menos otro tutorial ademas de este sera muy facil programar un zenity propio para usarlo en scripts en bash,ya que la programación de Gtk desde python es mas bajo nivel que la de zenity,ya que nos permite armar todo un front end,con botones,menus,notebooks,texviews,etc.

En este caso veremos lo que es botones y layouts,para poder armar una pequeña GUI,lo mas importante serian los layouts o contenedores ya que es lo que le da forma al programa,primero vamos a ver lo mas básico para ir fusionandolo entre si:

VBOX

Una vbox(Caja vertical) es un widget que almacena otros widgets adentro de ella de manera vertical,por defecto los widgets que se añaden a la ventana son solo uno,si añadimos mas colapsamos el programa.

Una pequeña pausa:

El esqueleto de los programas de python+Gtk3 debe ser siempre este(por lo menos en estos tutoriales):

#!/usr/bin/env python3

# -*- coding: utf-8 -*- # Codificacion
from gi.repository import Gtk # Importacion de Gtk

class CLase(Gtk.Window): # Una Clase principal que herede Window
    def __init__(self): # Constructor de la clase
        Gtk.Window.__init__(self,title="Titulo de la ventana") # Constructor de la clase padre

obje = EjemploRadioB() # Objeto creado de clase principal

obje.connect("delete-event",Gtk.main_quit) # Metodo de cerrar ventana

obje.show_all() # Mostramos todo

Gtk.main() # Bucle que mantiene abierta la ventana

Bien veamos un ejemplo de como añadiríamos un botón:

#!/usr/bin/env python3

# -*- coding: utf-8 -*-
from gi.repository import Gtk

class Ejemplo(Gtk.Window):
    def __init__(self):
        Gtk.Window.__init__(self,title="Ejemplo de un boton")
        button = Gtk.Button("Un boton")
        self.add(button)
     
ejem = Ejemplo()

ejem.connect("delete-event",Gtk.main_quit)

ejem.show_all()

Gtk.main()

Ahora veamos como usarlos VBOX para añadir mas botones de forma vertical:

Para empezar un objeto tipo caja se define de esta manera (objeto = Gtk.Box()) no importa si es en forma vertical o horizontal,a ese objeto le podemos pasar unos parametros,definiendolos por nombre para no cometer errores de posicion de parametros,por ejemplo podemos poner el espacio entre cada widget que almacenaremos,(pixeles) y entre ello tambien tenemos el parametro orientacion que es el que nos interesa,como python es orientado a objetos la orientacion de la caja no es una excepción debemos definir primero una lista para que no se vea tan largo el codigo(esto es opcional ya que asi lo hago yo):

pos = [Gtk.Orientation.HORIZONTAL,Gtk.Orientation.VERTICAL]

Ahi tenemos una lista con los valores de horizontal y vertical,esto es un poco raro pero asi me gusta hacerlo por si debemos intercambiar el valor solo cambiamos la forma de las constantes,por ejemplo:

pos = [Gtk.Orientation.VERTICAL,Gtk.Orientation.VERTICAL]

Para no andar cambiando una por una.

Ahora vamos a pasarle el parametro a la caja para que sea vertical(por defecto es horizontal):

vbox = Gtk.Box(spacing=5,orientation=pos[0])

Con eso tenemos un objeto vbox y podemos usar todos sus atributos,otra cosa es que esto ya se supone que se debe saber para el nivel de estos tutoriales,pero no lo he comentado es que en python usamos funciones de objetos similares a beans ,lo cual hace que algunos atributos que le podamos pasar como parámetros también tengan funciones que simplemente sirven para cambiarlos,por ejemplo es lo mismo esto:

vbox = Gtk.Box(spacing=5,orientation=pos[0])

Que esto:

vbox = Gtk.Box()

vbox.set_spacing(5)

vbox.set_orientation(pos[0])

Bien,eso se debe estudiar mas a fondo pero por el momento creo que se entiende,ahora vamos a ver las funciones que añaden los widgets,el cual son dos:

pack_start(widget,expand,fill,padding)

Esta funcion sirve para añadir widgets de principio a fin,osea desde el primero o el que sigue del ultimo que añadimos,le tenemos que pasar algunos parametros los cuales son:

widget # Un widget

expand # Un booleano para decir si se va a expandir basado en el widget que lo acompaña

fill # Un booleano para decir si se va a rellenar basado en la ventana

padding # Un numero entero,es contrario a spacing,añade espacio del otro lado.

También contamos con pack_end():

pack_start(widget,expand,fill,padding)

Tiene los mimos parametros,solo que se añade del final,osea al final de derecha a izquierda.

Bien como nos queda el codigo?

Primero vamos a ver como crear un botón normal para que podamos meterlo en :

Un objeto boton se define de la siguiente manera:

boton = Gtk.Button()

Le podemos pasar varios parámetros desde la creación o con funciones,por ejemplo el texto que mostrara(label) un stock(icono) y otros mas complejos como toltips(texto que se muestra cuando pasamos el cursor por arriba de un widget).

Un boton normal seria asi:

boton = Gtk.Button("Un boton")

De esa manera le estamos pasando un parámetro el cual es la label Un botón,no hay problema de hacerlo así ya que es el primer parámetro,pero también lo podríamos hacer así:

boton = Gtk.Button(label="Un boton")

O así:

boton = Gtk.Button()

boton.set_label("Un boton")

Un simple boton tiene muchas funciones,yo del metodo autodidacta que uso les recomiendo que vean las funciones que tiene usando dir:

Por ejemplo:

class Ejemplo(Gtk.Window):
    def __init__(self):
        Gtk.Window.__init__(self,title="Funciones de boton")
        self.button = Gtk.Button(label="Un boton",use_underline=False)
        for i in dir(self.button):
            print i
        self.add(self.button)

ejem =  Ejemplo()

ejem.connect("delete-event",Gtk.main_quit)

ejem.show_all()

Gtk.main()

Lo ejecutan y en la terminal les salen todas las funciones asociadas a esa clase,luego ya solo vemos que parametros usan o googleamos por informacion.

Antes de ver el codigo final queda repasar lo que vimos en la entrada pasada,un widget envia señales las cuales manipulamos con funciones,asi que una buena forma de programacion seria definir el objeto,luego definir sus funciones(si las usamos),luego definir las funciones de sus señales y luego añadirlas a una caja,por ejemplo:

boton = Gtk.Button() # Definicion 
boton.set_label("Boton 1") # Una que otra funcion del objeto
boton.connect("clicked", self.clic, "1") # Señales
vbox.pack_start(boton, False, False, 0) # Añadimos

Bien vamos a ver nuestro ejemplo de una ventana con dos botones:

Enlace

Como vemos se crea una ventana con dos botones en forma vertical,sobre su contrario,que seria hbox(caja horizontal),no hay mucho que explicar solo se tiene que definir que es horizontal o no pasarle el parámetro de orientation,también podemos anidar cajas dentro de cajas,por ejemplo dos cajas verticales dentro de una horizontal:

Enlace

Ahora vamos a ver otros tipos de botones:

RadioButton,el botón radio o botones redondos son muy vistos en algunos programas para elegir una opción,yo mismo los he usado en algunas ocasiones,pero si no los conocen son aquellos que tienen varias opciones pero cuando elegimos opción, cambia a esta y las otras quedan libres,para crear uno de estos botones primero necesitamos saber usar cajas como las de arriba lo cual ya vimos asi que vamos a comenzar creado una caja horizontal para añadir nuestros botones:

hbox = Gtk.Box(spacing=10)

Para definir el primer boton lo hacemos así:

rb = Gtk.RadioButton() # rb es radio button

Le tenemos que pasar algunos parámetros como la label y el grupo al que va a pertenecer,la label sera la opción que veremos,así que ponemos la que queramos y en grupo ponemos None ya que no hay grupo aun:

rb = Gtk.RadioButton(label="Ubuntu",group=None)

El segundo botón podemos añadirlo con la función new_from_widget,el cual le pasamos un parámetro que es el primer botón y así reconoce el grupo al que pertenece:

rb2 = Gtk.RadioButton.new_from_widget(rb1)

Luego podemos ponerle una label con la función set_label(muchos widgets tienen esta función):

rb2.set_label("Windows")

También podemos poner su señal que en este caso no es clicked si no que es toggled:

rb1.connect("toggled", self.clic, "Ubuntu")

Vamos a ver un ejemplo:

Enlace

Vamos a ver ahora el CheckButton,este botón también es muy conocido,ya que para configurar opciones,el cual es un botón con una paloma,si esta palomeado esta activa esa opción,si no no esta activa,es para definir solo dos opciones,ya que el radio button es para definir infinidad de opciones,para crearlo lo hacemos así:

Gtk.CheckButton(label="Hola mundo")

Luego también tenemos su señal que es toggled,y tenemos algunos beans para ver si esta activo:

set_active(boleano)

get_active() # Retorna boleano

Veamos un ejemplo:

Enlace

Hay otro botón que se parece mucho a este, el cual lo he visto en rhythmbox,el boton es el boton Toggled,el cual tiene las mismas funciones que el CheckButton pero con otro aspecto,para definirlo los hacemos así:

tb = Gtk.ToggleButton(label="Hola mundo",stock=Gtk.STOCK_ADD)

Veamos el mismo ejemplo:

Enlace

Otro botón con el que contamos y sirve para darle un poco de fama a nuestros programas es el link button el cual abre una uri,con el navegador que tengamos configurado por defecto en el sistema,(lo que seria xdg-open en linux),para definirlo solo le pasamos la label y la uri que mostrara,podemos hacerlo sin etiquetar los argumentos ya que el primero es la uri y el segundo es la label:

lb = Gtk.LinkButton("http://www.itimetux.com", "Ejemplo por Tiempo de Tux")

Por ejemplo:

Enlace

Por ultimo tenemos el boton spin,que es un tanto raro,ya que no lo he visto mucho,por ejemplo se podría usar para ajustar el tamaño de una fuente,el volumen de una aplicación,etc,pero no lo he visto mucho ya que para eso que mencione hay otros widgets dedicados,pero bueno,para definir un boton spin lo hacemos de la siguiente manera:

sb = Gtk.SpinButton()

Antes de usarlo tenemos que añadir un ajuste con otro widget,el cual se llama Adjustment,a este widget le pasamos algunos parámetros,el primero es el valor inicial(al abrir la ventana),el segundo es el valor mínimo(cuando le demos hacia atrás),el tercero es el valor máximo(hasta donde puede contar),el cuarto es de cuanto en cuanto va a contar,el quinto y sexto son argumentos mas avanzados los cuales no son muy necesarios,ya que con los primeros parámetros podemos hacer una cuenta normal,este widget lo usan otros ademas del spinbutton así que lo veremos de nuevo despumes,de momento vamos a definirlo así:

adjustment = Gtk.Adjustment(0, 0, 10, 2, 0, 0) # Comienza en 0,el mínimo es 0 y el máximo es 10,cuenta de 2 en 2

Las señales que otros widgets envía señales solo que son varias,la que podemos usar de ejemplo es value-changed,en la documentación oficial hay la información necesaria sobre señales,así que al final pondré el enlace,de momento podemos ver este ejemplo:

spinbutton = Gtk.SpinButton() # Definimos
spinbutton.set_adjustment(adjustment) # Añadimos el ajuste
spinbutton.connect("value-changed", self.clic,None) # Desviamos la señal a una funcion

Un ejemplo completo podría ser así:

Enlace

Ahora que ya conocemos los botones podemos pasar a ver las otras dos maneras de crear layouts,una de ellas es Grid,con la cual nos da una forma mas potente de añadir widgets que un box,primero definimos nuestro grid asi:

grid = Gtk.Grid()

Luego tenemos que añadir un widget(con la función add) para empezar,supongamos que tenemos un botón:

grid.add(boton)

Luego añadimos los otros con la función attach_next_to,a la cual le pasamos algunos parámetros:

attach_next_to(widget,despues,posicion,alto,ancho)

En widget ponemos el widget que vamos a añadir.

En después ponemos el widget del que queremos poner despues el widget del parametro 1.

En posición vamos a definir si va a estar arriba,abajo,izquierda o derecha,solo que vamos a usuar objetos especiales:

Gtk.PositionType.LEFT # Izquierda
Gtk.PositionType.RIGHT # Derecha
Gtk.PositionType.TOP # Arriba
Gtk.PositionType.BOTTOM # Abajo

En alto va a ser un dato int,el cual es el numero de widgets que estén disponibles,lo que seria las celdas a ocupar.

En ancho es igual que alto,solo que horizontal.

Veamos un ejemplo:

Enlace

Por ultimo tenemos el modo tabla,este es el mas avanzado de los tres,ya que manejamos celdas basadas en números,es como un tipo exel,o como un array de dos dimensiones,digamos que tenemos cuatro botones y queremos uno en cada esquina de la ventana,usando el método tabla tenemos que definir sus espacios basados en las celdas que ocupara cada widget:

Usamos la función attach y le pasamos algunos parámetros,el primero es el widget,pero los segundos son la celda que ocupara,basado en números:

izquierda, derecha, arriba, abajo

Primero creamos un objeto tabla con los parametros que serán el numero de filas y columnas para crear las celdas,supongamos 2x2:

table = Gtk.Table(2, 2, True) # El tercer parámetro es un bool 

Luego nos quedaría una ventana así:

Rojo es vertical y negro es horizontal.

Este es un ejemplo para que vean el modo de adición que vamos a usar.

Como vemos tenemos asignaciones numéricas,si quiero poner cuatro botones para que dibujen esa forma lo haría así:

Que el primer botón a la izquierda tenga cero para que este pegado a la izquierda,a la derecha tenga uno para que ocupe solo un espacio,que arriba comience en 0 para que este pegado a arriba,y abajo tenga 1 para que ocupe solo un espacio:

table.attach(boton1, 0, 1, 0, 1)

Ahora el segundo,que empiece en 1 a la izquierda,para que continue el espacio donde termina el primero,que a la derecha termine en 2,pegado a la otra orilla de la ventana,arriba y abajo es igual ya que usan la misma linea 0 y 1:

table.attach(boton2, 1, 2, 0, 1)

El tercer botón que empiece en 0 ya que estará pegado a la izquierda,a la derecha termine en 1,ya que es igual que el de arriba,arriba que comience en 1 para que este abajo del primero,y abajo termine en 2,pegado a la parte de abajo:

table.attach(boton3, 0, 1, 1, 2)

Por ultimo el cuarto que comience en 1,pegado al tercero,que termine en 2 a la derecha,pegado a la derecha,arriba y abajo es igual que el tercero 1 y 2:

table.attach(boton3, 1, 2, 1, 2)

Veamos el código entero:

Enlace

Es un poco raro,pero solo es cuestión de que se entienda como elegir las celdas de hecho Grid tambien cuenta con este modo de adición de widgets,con su función attach,pero quería mostrar el modo sencillo,también tenemos unas funciones para Table:

Estas son las que me gustan mas:

espacio = 10

table.set_row_spacings(espacio) # El espacio de serparacion de cada fila(pixeles)

table.set_col_spacings(espacio) # Eñ espacio de separacion de cada columna(pixeles)

Mas información el pagina oficial:

Enlace

developer.gnome.org/gtk3/stable/ch03.html 

Leer más...

Tutorial python Gtk3 Hola Mundo

Hola Mundo

Bueno este es el primer tutorial de programación Python/Gtk3, voy a realizar una serie de estos a ver que tal.

Y bueno,para comenzar este tutorial necesitamos tener una editor configurado para facil programación,recomiendo alguno de estos programas:

sublimetext

kate

gedit+plugins

vim-configurado

nano-configurado

eclipse+pydev

Bueno,también necesitamos el modulo Gtk3 que esta ya en la mayoría de distribuciones de Linux,así que no creo que lo necesiten instalar.

Y saber algo de programación en Python2 o Python3.

Primero que nada en este caso vamos a manipular un modulo,lo que seria como una libreria y la mayor parte del código van a ser clases o funciones del mismo modulo,por lo cual es necesario aprender python solamente antes para manipular bien Gtk3.

Comenzamos:

Primero que nada creamos una carpeta para trabajar limpio,en mi caso voy a usar solo la terminal:

mkdir -p ~/Documentos/python/pygtk && cd ~/Documentos/python/pygtk

Si usan un IDE como eclipse o un editor como gedit,kate pueden hacerlo visualmente a la hora de guardar el programa .py (solo es la forma de hacer las cosas).

Bien,comencemos creamos un archivo con extensión .py,por ejemplo ventana.py.

En mi caso voy a usar vim:

vim ventana.py

Y empezamos a escribir lineas de código.

Antes que nada vamos a definir el hashbang:

#!/usr/bin/env python

Yo voy a usar Python 2.7.

También vamos a usar utf8 para poder usar caracteres especiales,en el texto de las ventanas,etc.

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

Ahora vamos a importar el modulo Gtk3:

from gi.repository import Gtk

El modulo se llama Gtk3,si queremos que sea como en la version pasada podriamos hacer algo como esto:

from gi.repository import Gtk as gtk

Pero no es muy buena practica así que trabajaremos con el nombre real.

Vamos a crear una ventana con todo lo necesario para abrirse:

 win = Gtk.Window()  
 win.connect("delete-event",Gtk.main_quit)  
 win.set_title("Hola Mundo!!!")  
 win.show_all()  
 Gtk.main()  

Ahora ejecutamos en una terminal:

python ventana.py

Y se abre la ventana :D.

Ahora lo explico :

win = Gtk.Window() # Inicia un objeto ventana de Gtk

win.connect("delete-event",Gtk.main_quit)

^-Llamamos la funcion connect de la clase ventana,y le pasamos el parámetro ("delete-event") que es la señal que recibe(en este caso cuando le damos clic al boton de cerrar de nuestro window manager) y el parametro ("main_quit" de Gtk) que es lo que ejecuta cuando recibe el primer parametro,en este caso cerrar todo su main.

win.set_title("Hola Mundo!!!") # Llamamos la función que coloca un titulo en la ventana,con el parámetro string("Hola Mundo).

win.show_all() # Llamamos la función show_all que muestra la ventana en la pantalla.

Gtk.main() # Iniciamos el main de Gtk que crea un bucle infinito que mantiene la ventana abierta,hasta recibir la señal de cerrado.

Bien, explicado eso,ahora vamos a añadir un botón que nos salude en la terminal,para eso creamos una variable que sera igual al boton:

button = Gtk.Button(label="Saluda") # Le pasamos un parametro definido(label) que es el nombre que mostrara el boton

Y lo añadimos a la ventana:

win.add(button)

En estos momentos podemos ejecutar el script de nuevo y se ve así,sin embargo no hace nada,ya que no esta definida la función saludar,la definimos y se la pasamos como señal al botón así:

win.button.connect('clicked',saluda) # El primer argumento es la señal(event) y el segundo la respuesta a ejecutar(callback) y hay un tercero.

Y así la función:


def saluda(x): # La x es un argumento que nos pasa la respuesta del boton automáticamente (el tercero[widget]),no lo usaremos en este momento.
    print "Hola mundo!!!"

Así va el script hasta ahora:

 #!/usr/bin/env python  
 # -*- coding: utf-8 -*-  
 from gi.repository import Gtk  
 def saluda(x):  
   print "Hola mundo!!!"  
 win = Gtk.Window() # Inicia un objeto ventana de Gtk  
 win.connect("delete-event",Gtk.main_quit)  
 win.set_title("Hola Mundo!!!")  
 button = Gtk.Button(label="Saluda")  
 button.connect('clicked',saluda)  
 win.add(button)  
 win.show_all()  
 Gtk.main()  

Y funciona :D

Bien antes de continuar déjenme les digo que como estamos programando hasta ahora es programación imperativa al estilo perl,ya que todas las variables,funciones están libres,se puede programar así y yo así lo hago al ser perlero,pero de ahora en adelante vamos a usar programación orientada a objetos,como debe ser :D.

Eso que hicimos en OPP(Programación Orientada a Objetos), se ve así:

 #!/usr/bin/env python  
 # -*- coding: utf-8 -*-  
   
 from gi.repository import Gtk  
   
 class Win(Gtk.Window): # Heredamos de la clase Window
   def __init__(self):  
     Gtk.Window.__init__(self,title="Saluda") # Llamamos las variables y funciones de Window que estén en su __init__
     self.button = Gtk.Button(label="Hola Mundo!!!")  
     self.button.connect('clicked',self.saluda)  
     # Ya no necesitamos poner window.algo ya que como heredamos solo usamos self.  
     self.add(self.button)  
   def saluda(self,x):  
     print "Hola Mundo"  
   
 win = Win()  
   
 win.connect("delete-event",Gtk.main_quit)  
   
 win.show_all()  
 Gtk.main()  

Por ultimo vamos a hacer algo interesante que veremos en la siguiente parte:

 #!/usr/bin/env python  
 # -*- coding: utf-8 -*-  
   
 from gi.repository import Gtk  
   
 class Win(Gtk.Window):  
   def __init__(self):  
     Gtk.Window.__init__(self,title="Saluda")  
     self.button = Gtk.Button(label="Saluda")  
     self.button.connect('clicked',self.saluda)  
     self.box = Gtk.Box(spacing=10)  
     self.label = Gtk.Label()  
     self.label.set_label("Hola Mundo")  
     self.label.set_angle(25)  
     self.label.set_halign(Gtk.Align.END)  
     self.box.pack_start(self.button, True, True, 0)  
     self.box.pack_start(self.label, True, True, 0)  
     self.add(self.box)  
   def saluda(self,x):  
     self.label.set_angle(self.label.get_angle()+6)  
   
 win = Win()  
   
 win.connect("delete-event",Gtk.main_quit)  
   
 win.show_all()  
 Gtk.main()  

Leer más...