Bien, hoy estando aburrido decidi programar esto xD

#!/usr/bin/env python
#[Z]tuX
#Importamos las librerias de GTK
import pygtk
pygtk.require("2.0")
import gtk
import hashlib, base64

class Ventana_Inicial:   
    def cerrar(self,widget,data="None"):
        gtk.main_quit()              
              
    def md5(self,widget):
        texto = self.CajaEntrada.get_text() #Pedimos el Texto
        texto = hashlib.md5(texto).hexdigest() #Encriptamos El Texto   
        self.EntradaEncriptar.set_text(texto) #Mostramos el Texto
    
    def code_base64(self,wideget):
        texto = self.CajaEntrada.get_text()
        texto = base64.b64encode(texto)
        self.EntradaEncriptar.set_text(texto)
        
    def sha1(self,widget):
        texto = self.CajaEntrada.get_text() #Pedimos el Texto
        texto = hashlib.sha1(texto).hexdigest() #Encriptamos El Texto   
        self.EntradaEncriptar.set_text(texto) #Mostramos el Texto
    
    def sha256(self,widget):
        texto = self.CajaEntrada.get_text() #Pedimos el Texto
        texto = hashlib.sha256(texto).hexdigest() #Encriptamos El Texto   
        self.EntradaEncriptar.set_text(texto) #Mostramos el Texto
        
    def sha384(self,widget):
        texto = self.CajaEntrada.get_text() #Pedimos el Texto
        texto = hashlib.sha384(texto).hexdigest() #Encriptamos El Texto   
        self.EntradaEncriptar.set_text(texto) #Mostramos el Texto
        
    def sha512(self,widget):
        texto = self.CajaEntrada.get_text() #Pedimos el Texto
        texto = hashlib.sha512(texto).hexdigest() #Encriptamos El Texto   
        self.EntradaEncriptar.set_text(texto) #Mostramos el Texto
        
    def option(self,widget):
        opc = widget.get_active_text()
        if opc=="MD5":
            self.md5(widget)
        elif opc=="Base64":
            self.code_base64(widget)
        elif opc=="sha1":
            self.sha1(widget)
        elif opc=="sha256":
            self.sha256(widget)
        elif opc=="sha384":
            self.sha384(widget)
        elif opc=="sha512":
            self.sha512(widget)
        else:
            self.EntradaEncriptar.set_text("Hash NO Valido...")
       
    def __init__(self):
        self.window = gtk.Window(gtk.WINDOW_TOPLEVEL)
        self.window.set_position(gtk.WIN_POS_MOUSE)#Posicion Por Default
        self.window.set_title("EncryptMe by [Z]tuX") #Titulo
        self.window.set_size_request(250,160) #Tamanio
        
        #Botones########################################
        self.Titulo = gtk.Label("Texto a Encriptar: ")
        self.CajaEntrada = gtk.Entry()
        self.Hash = gtk.Label(">Hash")
        #COMBOBOX#######################################
        self.ComboBox = gtk.combo_box_entry_new_text()
        self.ComboBox.connect("changed",self.option)
        self.ComboBox.append_text("Base64")
        self.ComboBox.append_text("MD5")
        self.ComboBox.append_text("sha1")
        self.ComboBox.append_text("sha256")
        self.ComboBox.append_text("sha384")
        self.ComboBox.append_text("sha512")
        ################################################
        self.EtiquetaEncriptar= gtk.Label("> Texto Encriptado")
        self.EntradaEncriptar= gtk.Entry()      
        self.BotonSalir = gtk.Button(">Salir") #BotonSalir
        ###############FIN BOTONES#######################
        
        
        #Llmamos a las Funciones de Botones y Cajas
        self.CajaEntrada.connect("changed",self.md5)
        self.CajaEntrada.connect("changed",self.code_base64)
        self.BotonSalir.connect("clicked",self.cerrar)
        
        #Posicion de Botones y Cajas de Entrada
        Colocar = gtk.Fixed()
        Colocar.put(self.Titulo,10,5)
        Colocar.put(self.CajaEntrada,10,25)
        Colocar.put(self.Hash,10,55)
        Colocar.put(self.ComboBox,10,75)
        Colocar.put(self.EtiquetaEncriptar,10,105)
        Colocar.put(self.EntradaEncriptar,10,125)
        Colocar.put(self.BotonSalir,180,125)
        
        self.window.add(Colocar)#Mostramos
        self.window.show_all()
        self.window.connect("destroy",self.cerrar)
            
    def main(self):
        gtk.main()
 
if __name__=="__main__":
    WindowIni = Ventana_Inicial()
    WindowIni.main()

Ya habia hecho una version en modo Consola xD, la pueden ver aquí...
Y una Captura:
Salud[OS]
[Z]tuX

Bien iniciamos con esto:

#!/usr/bin/env python

#Importamos las librerias Necesarias de GTK
import pygtk
pygtk.require("2.0")
import gtk

class Base:
    def destruir(self,widget, data="None"):
        gtk.main_quit()
     
    def __init__(self):
        self.window = gtk.Window(gtk.WINDOW_TOPLEVEL)
#TITULO DEL PROGRAMA
        self.window.set_title("Python & GTK With [Z]tuX xD!")
#AJUSTES DE LA VENTANA
        self.window.set_position(gtk.WIN_POS_MOUSE)
        self.window.set_size_request(600,200)
#BOTONES
        self.BotonSalir = gtk.Button("Salir")
        self.BotonSalir.connect("clicked",self.destruir)
        #Posicionamos el Boton usando Fixed
        Posicion = gtk.Fixed() #Creamos un objeto para posicionar el boton
        Posicion.put(self.BotonSalir, 20 ,30) #Especificamos el boton que quermos ajustar
                                              #Y ponemos el boton en la coordenada (20,30)
         
                
#MOSTRAMOS LA VENTANA 
        self.window.add(Posicion)
        #self.window.show()  --> Vamos a cambiar esta linea por la de abajo... :D
        self.window.show_all() #Para mostrar TODOS lo que esta contendido 
        self.window.connect("destroy",self.destruir)
   
    def main(self):
        gtk.main()

if __name__=="__main__":
    base = Base()
    base.main()

:O No se espanten, es muy sencillo bien que es esto?:

self.BotonSalir = gtk.Button("Salir")
self.BotonSalir.connect("clicked",self.destruir)

Simplemente estamos creando un botón nuevo, que lo llamamos "BotonSalir", es un objeto de tipo "Button" (Botón) y dentro del paréntesis ("Salir") se coloca el texto que se desea mostrar en el botón...
La segunda linea nos dice que a "BotonSalir" cuando se haga click en el botón [("clicked") --> Importante eso en paréntesis ] el botón va a llamar a la función  "destruir", que ya habíamos creado anteriormente, asi que al hacer click en ese botón la ventana se cerrará...

Ahora bien, las lineas:

#Posicionamos el Boton usando Fixed
        Posicion = gtk.Fixed() #Creamos un objeto para posicionar el boton
        Posicion.put(self.BotonSalir, 20 ,30) #Especificamos el boton que quermos ajustar
                                              #Y ponemos el boton en la coordenada (20,30)

Estas lineas nos ayudaran a posicionar el botón en la ventana... Primero asignamos a "Posicion" un ajuste:

Posicion = gtk.Fixed() #Creamos un objeto para posicionar el botón

Después ponemos ("put") dicho botón en algún lugar de la ventana, para ello, la linea:

Posicion.put(self.BotonSalir, 20 ,30)

Nos ayudara a colocar el "BotonSalir" en la coordenada (20,30).

Como se darán cuenta dentro del paréntesis se escribe algo como:
(self.BotonQueQueremos, Coordenada X, Coordenada Y)

Ahora lo importante... mostrar dichos botones D:
Es sencillo... Simplemente hacemos:

#MOSTRAMOS LA VENTANA 
        self.window.add(Posicion)
        #self.window.show()  --> Vamos a cambiar esta linea por la de abajo... :D
        self.window.show_all() #Para mostrar TODOS lo que esta contendido 
        self.window.connect("destroy",self.destruir)

En self.window.add(Posicion) ---> Lo que hacemos es añadir a la ventana principal "Posicion", pero "Posicion" como sabemos esta definido como de tipo Ajuste...

#Posicionamos el Boton usando Fixed
        Posicion = gtk.Fixed() #Creamos un objeto para posicionar el boton

Entonces lo que hacemos es añadir los botones a la ventana, después cambiamos  show() por show_all(), para mostrar TODO, y eso es todo....
Al final tenemos:

self.window.connect("destroy",self.destruir)

Que sirve para terminar la aplicación correctamente en caso de cerrar la ventana con el Botón "Close" (la x que esta en la esquina)

Así que si hacemos correr el programa, podremos ver algo como esto:


Si damos click en "Salir" el programa se cerrará con éxito... :D
Pero también podemos añadir una Ayuda ese botón, lo que haremos ahora es que cuando pasemos el puntero arriba de el botón salir nos muestre un cuadro de ayuda que diga algo como "Este botón cerrara la aplicación", bien para ello agregaremos las lineas:

self.BotonSalir.set_tooltip_text(u"Este botón cerrará la aplicación")  

Guardamos nuestro archivo y probamos... Claro está que esta linea se agrega despues de haber creado el boton, no antes, si no obviamente python no encontrara el botón y nos tirará un error...
Otra cosa, si se dan cuenta en el texto hay Acentos o Tildes, python asi como asi no las va a reconocer y nos va a tirar un error de algo como:

"SyntaxError: Non-ASCII character '\xc3' in file interfaz1.py on line 27, but no encoding declared; see http://www.python.org/peps/pep-0263.html for details
"
Para esto agregamos una "u" antes de el texto en comillas y agregamos:
# -*- encoding: utf-8  -*-
Una vez hecho esto tenemos algo como:

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

#Importamos las librerias Necesarias de GTK
import pygtk
pygtk.require("2.0")
import gtk

class Base:
    def destruir(self,widget, data="None"):
        gtk.main_quit()
     
    def __init__(self):
        self.window = gtk.Window(gtk.WINDOW_TOPLEVEL)
#TITULO DEL PROGRAMA
        self.window.set_title("Python & GTK With [Z]tuX xD!")
#AJUSTES DE LA VENTANA
        self.window.set_position(gtk.WIN_POS_MOUSE)
        self.window.set_size_request(600,200)
#BOTONES
        self.BotonSalir = gtk.Button("Salir")
        self.BotonSalir.connect("clicked",self.destruir)
        #Posicionamos el Boton usando Fixed
        Posicion = gtk.Fixed() #Creamos un objeto para posicionar el boton
        Posicion.put(self.BotonSalir, 20 ,30) #Especificamos el boton que quermos ajustar
                                              #Y ponemos el boton en la coordenada (20,30)
        #Ayuda Del Boton
        self.BotonSalir.set_tooltip_text(u"Este botón cerrara la aplicación")    
                
#MOSTRAMOS LA VENTANA 
        self.window.add(Posicion)
        #self.window.show()
        self.window.show_all() #Para mostrar TODO lo que esta contendido 
        self.window.connect("destroy",self.destruir)
   
    def main(self):
        gtk.main()

if __name__=="__main__":
    base = Base()
    base.main()

Y finalmente corremos el programa y podremos ver la ayuda:


[Z]tuX

Bien, siguiendo con el code que anteriormente habíamos trabajado:

#!/usr/bin/env python

#Importamos las librerias Necesarias de GTK
import pygtk
pygtk.require("2.0")
import gtk

class Base:
    def destruir(self,widget, data="None"):
        gtk.main_quit()

    def __init__(self):
        self.window = gtk.Window(gtk.WINDOW_TOPLEVEL)
        self.window.show()
        self.window.connect("destroy",self.destruir)

    def main(self):
        gtk.main()

if __name__=="__main__":
    base = Base()
    base.main()

Ahora vamos a aprender a darle algunos ajustes muy básicos a la ventana... En primera, el posicionamiento de la ventana cuando se inicia la aplicación. Podemos hacer que por "default" la ventana se muestre en el centro, para esto agregamos la linea:

self.window.set_position(gtk.WIN_POS_CENTER)

Esta linea la colocaremos dentro de la función inicial...


También podemos probar con:

self.window.set_position(gtk.WIN_POS_MOUSE) 
#Posicionamos la ventana En donde se encuentre el Puntero

self.window.set_position(gtk.WIN_CENTER_ALWAYS) 
#La ventana siempre aparecerá Centrada

self.window.set_position(gtk.WIN_POS_CENTER_ON_PARENT)
#La ventana se posiciona centrada según otras ventanas

Recuerden, estas lineas van dentro de la función inicial:

#!/usr/bin/env python

#Importamos las librerias Necesarias de GTK
import pygtk
pygtk.require("2.0")
import gtk

class Base:
    def destruir(self,widget, data="None"):
        gtk.main_quit()

    def __init__(self):
        self.window = gtk.Window(gtk.WINDOW_TOPLEVEL)
        #AJUSTES DE LA VENTANA
        self.window.set_position(gtk.WIN_POS_CENTER_ON_PARENT)  

        #MOSTRAMOS LA VENTANA   
        self.window.show()
        self.window.connect("destroy",self.destruir)

    def main(self):
        gtk.main()

if __name__=="__main__":
    base = Base()
    base.main()

También podemos cambiar el tamaño de la ventana... La siguiente linea También va dentro de la función inicial, para ello usamos:

self.window.set_size_request(600,200)

Y dentro de los paréntesis va el tamaño de la ventana, esto es: (columnas,filas)

#!/usr/bin/env python

#Importamos las librerias Necesarias de GTK
import pygtk
pygtk.require("2.0")
import gtk

class Base:
    def destruir(self,widget, data="None"):
        gtk.main_quit()

    def __init__(self):
        self.window = gtk.Window(gtk.WINDOW_TOPLEVEL)
        #AJUSTES DE LA VENTANA
        self.window.set_position(gtk.WIN_POS_MOUSE)
        self.window.set_size_request(600,200)
        #MOSTRAMOS LA VENTANA   
        self.window.show()
        self.window.connect("destroy",self.destruir)

    def main(self):
        gtk.main()

if __name__=="__main__":
    base = Base()
    base.main()

También podemos agregar un titulo a nuestra ventana. Bien para ello usamos set_title("Nombre del Programa"), donde dentro de los paréntesis colocamos el texto que deseamos mostrar, y como esto es parte del objeto "window", tenemos que escribir algo como:

self.window.set_title("Python & GTK With [Z]tuX xD!")

Y bien eso es todo por el momento, ya pronto veremos como agregar botones y demás cosas...
Salud[OS]