Añadir ícono a la bandeja del sistema

6 comentarios

Veamos cómo añadir un ícono para nuestras aplicaciones en la bandeja del sistema, y cómo agregar un menú a este ícono.

Como siempre, en los tutoriales trabajamos con Geany y Glade 3.

Hagamos un sencillo programa que consista sólo de un ícono en la bandeja del sistema, que muestre un mensaje si recibe un click izquierdo, y despliegue un menú si recibe uno derecho.

Crear el ícono
Abrimos Glade y agregamos un "Ícono de Estado" (nombre que le da GTK+ al ícono que va en la bandeja):

Le damos nombre y una imagen, yo le puse "iconobandeja" y usé esta imagen. La imagen la seleccionamos en la propiedad "Pixbuf":

Ahora le damos manipuladores a las señales "activate" y "popup_menu":

Guardamos el archivo y abrimos nuestro IDE (Geany). Para este tutorial guardé el archivo como "interfaz.xml".

Importamos los módulos necesarios, creamos la clase y el constructor, y corremos el programa:

import pygtk
import gtk

class icono:
   def __init__(self):
      builder = gtk.Builder()
      builder.add_from_file("interfaz.xml")
      self.iconobandeja = builder.get_object("iconobandeja")

      builder.connect_signals(self)

icono()
gtk.main()


Click izquierdo en el ícono
El programa anterior no hace en realidad nada más que mostrar el ícono en la bandeja. Programemos ahora el manipulador de la señal "activate", que se ejecuta cuando el ícono recibe un click izquierdo.

Hagamos que se muestre una ventana con un mensaje. Para hacer más interesante esto (y no estar creando la ventana en Glade), hagamos la ventana en Gtk+ puro (es importante conocer al menos lo básico).

Agregamos el siguiente método a nuestra clase:

   def on_iconobandeja_activate(self, widget, data=None):
      ventana = gtk.Window()
      etiqueta = gtk.Label()
      etiqueta.set_label("Ventana hecha con Gtk+ puro!")
      ventana.add(etiqueta)
      ventana.show_all()


Lo que hacemos es, explicando línea por línea: creamos una ventana, creamos una etiqueta, establecemos el texto de la etiqueta, la agregamos a la ventana, y por último la mostramos.

Click derecho en el ícono
Programemos ahora el manipulador de la señal "popup_menu", que se ejecuta con un click derecho del ratón, para mostrar un menú.

Abrimos Glade y creamos el menú ("Menu Emergente"). Le ponemos un nombre, en mi caso simplemente le puse "menu".

Luego, a la derecha, en donde dice Widgets damos click derecho al menu que creamos y seleccionamos la opción "Edit...". Vamos a la pestaña Jerarquía y hacemos click en "Añadir" para agregar un elemento.

Vamos a crear un solo elemento para este programa, que permita salir del mismo. Le ponemos nombre y etiqueta ("salir", por ejemplo) y cerramos la ventana de edición del menú.

Le damos el manipulador "on_salir_activate" a la señal activate del elemento que acabamos de crear para nuestro menú.




Guardamos el archivo y vamos al IDE a escribir el código.

Agregamos el menu al constructor:
      self.menu = builder.get_object("menu")
      self.salir = builder.get_object("salir")


Creamos el método del manipulador de la señal popup_menu, para desplegar el menú cuando se reciba un click derecho:
   def on_iconobandeja_popup_menu(self, widget, button, activate_time):
      self.menu.popup(None, None, None, button, activate_time)


Por último programamos el elemento que agregamos a nuestro menú:
   def on_salir_activate(self, widget, data=None):
      gtk.main_quit()


El resultado debería de ser el siguiente:

Con un click derecho debe de aparecer un menú con un elemento que diga "Salir", y al hacer click en éste el programa debe terminar.

Descargar programa ejemplo

Cómo usar: ComboBox (II)

5 comentarios

Veamos algunos ejemplos más.

Popular ComboBox desde un archivo de texto:
Supongamos que tenemos almacenada una serie de datos en un archivo de texto, por ejemplo:

Zapatos,Camisas,Pantalones,Remeras,Shorts,Gorras

En este archivo tenemos varios elementos separados por comas. Llamémoslo "Archivo.txt".
Para cargar los elementos a partir de este archivo usamos la siguiente función:

   def popularcombo(self):
      listaelementos=gtk.ListStore(str)
      archivo = open("Archivo.txt","r")
      for line in archivo.readlines():
         i = 0
         cadena = ""
         while i<len(line):
            if line[i] == ",":
               listaelementos.append([cadena])
               cadena = ""
               i = i+1
            else:
               cadena = cadena + line[i]
               i = i+1

      self.combo.set_model(listaelementos)
      render=gtk.CellRendererText()
      self.combo.pack_start(render, True)
      self.combo.add_attribute(render, 'text', 0)

Expliquemos cada línea:
Creamos la función y el objeto listaelementos, en el que vamos a almacenar nuestros elementos:
   def popularcombo(self):
      listaelementos=gtk.ListStore(str)

Abrimos el archivo:
      archivo = open("Archivo.txt","r")

Utilizamos el bucle for para que el proceso se repita por cada línea del archivo (en este ejemplo el archivo tiene una sola línea) e inicializamos algunas variables auxiliares:
      for line in archivo.readlines():
         i = 0
         cadena = ""

Con un bucle while vamos examinando cada caracter de la línea del archivo. Si se encuentra una coma, se agrega a la lista el contenido de la cadena y se vacía la cadena. Si se encuentra cualquier otro caracter, se lo añade a la cadena:
         while i<len(line):
            if line[i] == ",":
               listaelementos.append([cadena])
               cadena = ""
               i = i+1
            else:
               cadena = cadena + line[i]
               i = i+1

Por último le asignamos la lista al ComboBox y mostramos los elementos:
      self.combo.set_model(listaelementos)
      render=gtk.CellRendererText()
      self.combo.pack_start(render, True)
      self.combo.add_attribute(render, 'text', 0)

Descargar programa ejemplo

Popular ComboBox desde una base de datos SQLite:
Supongamos que tenemos una tabla con planetas y sus radios. Para mostrarlos en el ComboBox es simplemente modificar la función anterior de modo que quede de la siguiente manera (Obs.: para trabajar con bases de datos SQLite se debe importar el módulo sqlite3):

   def popularcombo(self):
      listaelementos=gtk.ListStore(str,int)
      bd = sqlite3.connect("Archivo.dat")
      cursor = bd.cursor()
      cursor.execute('SELECT * FROM planetas')
         for row in cursor:
            listaelementos.append(row)

      self.combo.set_model(listaelementos)
      render=gtk.CellRendererText()
      self.combo.pack_start(render, True)
      self.combo.add_attribute(render, 'text', 0)

Explicando:
Cargamos la base de datos y creamos el objeto cursor:
      bd = sqlite3.connect("Archivo.dat")
      cursor = bd.cursor()

Seleccionamos todos los elementos de la tabla "planetas" de nuestra base de datos y añadimos a nuestra lista cada par de datos:
      cursor.execute('SELECT * FROM planetas')
        for row in cursor:
            listaelementos.append(row)

Descargar programa ejemplo

Cómo usar: ComboBox (I)

1 comentarios


Vamos a analizar en este tutorial el uso de los ComboBox.
Como siempre, vamos a utilizar Geany como IDE, Glade y Python.

Comencemos:
Abrimos Glade y creamos una ventana, una botonera de un solo elemento, y dentro de esta botonera, un ComboBox (caja combo).

Le damos nombres a los elementos (es bueno acostumbrarse a hacerlo). Para este tutorial le puse “ventanaprincipal” a la ventana y “combo” al ComboBox.
Damos el manipulador “on_ventanaprincipal_destroy” a la señal destroy de la ventana y guardamos el archivo, en mi caso le puse el nombre “combo.xml”.

Popular el ComboBox:
Veamos como hacer que nuestro ComboBox muestre una lista de elementos.

Abrimos Geany, creamos un archivo nuevo. Importamos los módulos necesarios, creamos la clase y el constructor:

import pygtk
import gtk

class combo:
def __init__(self):
builder = gtk.Builder()
builder.add_from_file("combo.xml")
self.ventanaprincipal = builder.get_object("ventanaprincipal")
self.combo = builder.get_object("combo")

builder.connect_signals(self)
self.ventanaprincipal.show()

Ahora escribamos una función (o método) para cargar los elementos y mostrarlos en nuestro ComboBox:

def popularcombo(self):
listaelementos=gtk.ListStore(str)
listaelementos.append(["Manzanas"])
listaelementos.append(["Peras"])
listaelementos.append(["Naranjas"])

self.combo.set_model(listaelementos)
render = gtk.CellRendererText()
self.combo.pack_start(render, True)
self.combo.add_attribute(render, 'text', 0)

Como se puede ver, lo primero que se hace es crear un objeto de la clase gtk.ListStore(), que nos servirá para almacenar los elementos; el argumento str indica que vamos a almacenar cadenas de texto. Luego agregamos los elementos a la lista, y por último asociamos esa lista a nuestro ComboBox usando self.combo.set_model(). Las tres últimas líneas son las que se encargan de mostrar los elementos en el ComboBox.

Programamos el método "on_ventanaprincipal_destroy", creamos un objeto de la clase combo (la que acabamos de crear) y llamamos a su función "popularcombo()":

def on_ventanaprincipal_destroy(self, widget, data=None):
gtk.main_quit()

ejemplo = combo()
ejemplo.popularcombo()
gtk.main()

Guardamos el archivo y ejecutamos el programa:

Obtener un elemento del ComboBox:
El programa anterior no sirve de mucho si no podemos recuperar ningún elemento del ComboBox. Hagamos unas modificaciones al programa de forma que al presionar un botón se obtenga el elemento activo en ese momento.

Abrimos Glade, agregamos un elemento más a la botonera del programa anterior y colocamos un boton en el nuevo espacio (al que para este tutorial llamé "boton" y le puse de etiqueta "Click aquí"). Le damos el manipulador "on_boton_clicked" a la señal clicked del botón y guardamos el archivo.

Hagamos las modificaciones necesarias al código de nuestro programa (las nuevas líneas están en cursiva):

import pygtk
import gtk

class combo:
def __init__(self):
builder = gtk.Builder()
builder.add_from_file("combo.xml")
self.ventanaprincipal = builder.get_object("ventanaprincipal")
self.combo = builder.get_object("combo")
self.boton = builder.get_object("boton")

builder.connect_signals(self)
self.ventanaprincipal.show()

def popularcombo(self):
listaelementos=gtk.ListStore(str)
listaelementos.append(["Manzanas"])
listaelementos.append(["Peras"])
listaelementos.append(["Naranjas"])

self.combo.set_model(listaelementos)
render = gtk.CellRendererText()
self.combo.pack_start(render, True)
self.combo.add_attribute(render, 'text', 0)

def on_ventanaprincipal_destroy(self, widget, data=None):
gtk.main_quit()

def on_boton_clicked(self, widget, data=None):
model = self.combo.get_model()
activo = self.combo.get_active()
if activo >= 0:
self.boton.set_label(model[activo][0])


ejemplo = combo()
ejemplo.popularcombo()
gtk.main()

Analicemos las nuevas líneas: en el constructor agregamos el botón y más abajo creamos un nuevo método ("on_boton_clicked"). En este método lo que hacemos es obtener el modelo que está asociado a nuestro ComboBox (la lista de los elementos), obtenemos el número del elemento activo en ese momento en el ComboBox, y por último le damos uso al elemento obtenido (en este tutorial lo usamos para cambiar la etiqueta del botón).
Obs.: Si no seleccionamos ningún elemento (por defecto), el número del elemento activo es -1.

Guardamos el archivo y ejecutamos:

Al dar click al botón:



Ver más ejemplos: Popular desde archivos de texto y desde bases de datos SQLite.