## page was renamed from Programmazione/Python/GUI
## page was renamed from LinguaggioPython/GUI
#format wiki
#language it
<<BR>>
<<Indice(depth=1)>>
<<Informazioni(forum="https://forum.ubuntu-it.org/viewtopic.php?f=46&t=631491"; rilasci="18.04 16.04 14.04")>>

= Introduzione =

All'interno di questa pagina sono presenti degli esempi di come creare delle semplici interfacce grafiche usando programmi come '''wxPython''', '''PyGTK''' e '''!PyQt'''. 

 * tutto ciò che viene scritto preceduto dal carattere # è considerato dall'interprete come un commento.
 * questi esempii sono scritti per l'interprete '''Python 2.7.xx''',  per la guida nella più recente versione '''Python 3.x''', vedi [[Programmazione/Python/InterfacceGrafichePython3 | InterfacceGrafichePython3]] 

= PyGTK =

'''GTK+''' è un toolkit per la creazione di interfacce grafiche è stato progettato inizialmente come ausilio alla programmazione per [[Grafica/Gimp|GIMP]] ed è diventato una parte fondamentale dell'ambiente [[AmbienteGrafico/Gnome| GNOME]].

'''PyGTK''' è un set di moduli che permettono l'interfacciamento tra '''Python''' e le librerie '''GTK,''' è un toolkit orientato agli oggetti, permette quindi la possibilità di riutilizzare dello stesso codice in più applicazioni.

== Esempio di applicazione ==

Questa è una versione del programma `AreaTriangolo2.py`, presente all'interno di [[Programmazione/Python/Listati#areatraingolo2| questa pagina]].
{{{#!python
#!/usr/bin/python

# Importiamo la funzione sqrt (radice quadrata) dal modulo math
from math import sqrt

# Importiamo le librerie per l'interfaccia grafica GTK
import pygtk
pygtk.require('2.0')
import gtk

# Definiamo una classe Triangolo con tre metodi:
# un costruttore, un metodo che calcola il perimetro e uno che calcola l'area del triangolo.
class Triangolo:

    # Attributi della classe (le misure dei tre lati)
    a, b, c = 0, 0, 0

    # Metodo costruttore, in python i costruttori hanno il nome speciale __init__
    def __init__(self,a,b,c):
        # Controlliamo se i tre valori dati possono effettivamente 
        #essere le misure dei lati di un triangolo.
        # Caso contrario solleviamo una bella eccezione! 
        if ((a+b>c) and (a+c>b) and (b+c>a)):
            self.a=a
            self.b=b
            self.c=c 
        else: 
            raise "TriangoloImpossibile" , "I lati non possono formare un triangolo"
            # abbiamo dato un nome ed un essaggio di errore all'eccezione
    # Metodo che calcola il perimetro
    def perimetro(self):
        return self.a + self.b + self.c

    # Metodo che calcola l'area (tramite formula di Erone)
    def area(self):
        p=self.perimetro()/2.0
        return sqrt(p*(p-self.a)*(p-self.b)*(p-self.c))

#questa e' la classe che definisce l'interfaccia grafica
class Dialogo:
    def __init__(self):
        self.window = gtk.Window(gtk.WINDOW_TOPLEVEL)  # definiamo la finestra
        self.window.set_title("Calcolo area triangolo")# le diamo in titolo
        self.window.connect("destroy", self.distruggi) # catturiamo l'evento destroy 
                                                       #(es. la X che chiude la finestra)
                                                       # e lo indirizziamo a una funzione
                                                       # che termina il programma
        self.window.set_resizable(False)            # la finestra non e' modificabile in dimensioni
        self.window.set_position(gtk.WIN_POS_MOUSE) # e compare nell'attuale posizione del muose
        self.bottone = gtk.Button("Calcolo")        # definiamo il bottone calcolo
        self.bottone.connect("clicked", self.calcola) # catturiamo il click e lo indirizzo 
                                                      # alla funzione che esegue il calcolo
        self.etichetta1 = gtk.Label("Lato 1      ")   # testo che richiede la lunghezza del 1 lato
        self.entrata1 = gtk.Entry(10)                 # casella per l'inserimento della lunghezza
                                                      # del 1 lato
        self.riga1 = gtk.HBox()      # creiamo un contenitore dove 
                                     # gli oggetti sono disposti in orizzontale (una riga)
        self.riga1.pack_start(self.etichetta1) # inseriamo l'etichetta e la casella di input nella 1 riga 
        self.riga1.pack_start(self.entrata1)
        self.etichetta2 = gtk.Label("Lato 2      ") # e cosi' via ...
        self.entrata2 = gtk.Entry(10)
        self.riga2 = gtk.HBox()
        self.riga2.pack_start(self.etichetta2)
        self.riga2.pack_start(self.entrata2)
        self.etichetta3 = gtk.Label("Lato 3      ")
        self.entrata3 = gtk.Entry(10)
        self.riga3 = gtk.HBox()
        self.riga3.pack_start(self.etichetta3)
        self.riga3.pack_start(self.entrata3)
        self.risultato = gtk.Label(" -- ") # creiamo un'etichetta per il risultato
        self.colonna = gtk.VBox()          # creiamo un contenitore dove 
                                           # gli oggetti sono disposti in verticale (una colonna)
        self.colonna.pack_start(self.riga1) # e vi inseriamo le righe, il pulsante e l'etichetta del risultato
        self.colonna.pack_start(self.riga2)
        self.colonna.pack_start(self.riga3)
        self.colonna.pack_start(self.bottone)
        self.colonna.pack_start(self.risultato)
        self.window.add(self.colonna)  # inseriamo il tutto nella finestra
        self.window.show_all()         # comando che visualizza la finestra ed il suo contenuto
    
    # funzione che raccoglie gli input, crea un'istanza Triangolo e ne richiede il calcolo dell'area
    def calcola(self, widget,data = None): 
        try:
            a = float(self.entrata1.get_text()) # legge i dati inseriti nella 1 casella
            b = float(self.entrata2.get_text())
            c = float(self.entrata3.get_text())
            triangolo = Triangolo(a, b, c)
            self.risultato.set_text(str(triangolo.area()))
        except ValueError: # catturo l'eccezione
            self.risultato.set_text("Devi inserire valori numerici.")
        except "TriangoloImpossibile": # catturo la seconda eccezione
            self.risultato.set_text("I lati immessi non possono formare un triangolo")
    # funzione di uscita
    def distruggi(self, widget,data = None):
        print data
        return gtk.main_quit()
    # funzione di lancio della GUI
    def main(self):
        gtk.main()

# avvio del programma a condizione che non sia caricato come modulo
print __name__
if __name__ == "__main__":
    base = Dialogo()
    base.main()

}}} ''Listato del programma !AreaTriangolo2.py con interfaccia grafica GTK+''
<<BR>>

= Tkinter =

'''Tk''' è un piccolo toolkit per la creazione di interfacce grafiche è stato successivamente portato anche verso altri linguaggi come '''Python''', '''Ruby''', '''Lisp''', ecc.. '''Tkinter''' è il modulo '''Python''' che permette l'interfacciamento con '''Tk'''.

== Esempio di applicazione ==

Di seguito viene mostrato un esempio di programma:
{{{#!python
#!/usr/bin/python

# Importiamo la funzione sqrt (radice quadrata) dal modulo math
from math import sqrt
# Importiamo i widgets dal modulo Tkinter
from Tkinter import *

# Definiamo una classe Triangolo con tre metodi:
# un costruttore, un metodo che calcola il perimetro e uno che calcola l'area del triangolo.
class Triangolo:

      # Attributi della classe (le misure dei tre lati)
      a, b, c = 0, 0, 0

      # Metodo costruttore
      def __init__(self,a,b,c):
         # Controlliamo se i tre valori dati possono effettivamente essere le misure dei lati di un triangolo.
         # Caso contrario solleviamo una bella eccezione! 
         if ((a+b>c) and (a+c>b) and (b+c>a)):
            self.a=a
            self.b=b
            self.c=c
         else:
            # abbiamo dato un nome ed un essaggio di errore all'eccezione
            raise "TriangoloImpossibile" , "I lati non possono formare un triangolo"

      # Metodo che calcola il perimetro
      def perimetro(self):
         return self.a + self.b + self.c

      # Metodo che calcola l'area (tramite formula di Erone)
      def area(self):
         p=self.perimetro()/2.0
         return sqrt(p*(p-self.a)*(p-self.b)*(p-self.c))


# questa e' la classe che definisce l'interfaccia grafica
class Dialogo(Frame):

     def __init__(self):
        Frame.__init__(self)
        self.master.title("Area triangolo.") # Diamo il titolo alla finestra.
        self.master.minsize(250,150) # Dimensioni minime della finestra
        self.grid(sticky=E+W+N+S)

        self.ris=StringVar() # Questa variabile stringa viene usata per
        self.ris.set("---")  # aggiornare la gui quando il risultato cambia.

        # Rendiamo ridimensionabile la finestra dell'applicazione
        top=self.winfo_toplevel()         
        top.rowconfigure(0, weight=1)
        top.columnconfigure(0, weight=1)

        for i in range(5): self.rowconfigure(i, weight=1)
        self.columnconfigure(1, weight=1)


        self.etichetta1=Label(self, text="Lato 1    ") # Etichetta del lato 1
        self.etichetta1.grid(row=0, column=0, padx=2)  
 
        self.entrata1=Entry(self) # Casella d'inserimento del lato 1
        self.entrata1.grid(row=0, column=1, pady=2, padx=2, sticky=E+W+N+S)

        self.etichetta2=Label(self, text="Lato 2    ") # Etichetta del lato 2
        self.etichetta2.grid(row=1, column=0, padx=2)

        self.entrata2=Entry(self) # Casella d'inserimento del lato 2
        self.entrata2.grid(row=1, column=1, pady=2, padx=2, sticky=E+W+N+S)

        self.etichetta3=Label(self, text="Lato 3    ") # Etichetta del lato 3
        self.etichetta3.grid(row=2, column=0, padx=2)

        self.entrata3=Entry(self) # Casella d'inserimento del lato 3
        self.entrata3.grid(row=2, column=1, pady=2, padx=2, sticky=E+W+N+S)

        self.bottone=Button(self, text="Calcola", command=self.calcola) # Bottone "Calcola"
        self.bottone.grid(row=3, column=0, columnspan=2, pady=2, padx=2, sticky=E+W+N+S)

        self.risultato=Label(self, textvariable=self.ris) # Testo che motra il risultato.
        self.risultato.grid(row=4, column=0, columnspan=2, pady=2, padx=2, sticky=E+W+N+S)


     # Raccogliamo l'input e calcoliamo l'area
     def calcola(self):
        try :
          a=float(self.entrata1.get())
          b=float(self.entrata2.get())
          c=float(self.entrata3.get())
          t=Triangolo(a,b,c)
          self.ris.set("Area = "+str(t.area()))
        except ValueError: self.ris.set("Devi inserire valori numerici.")
        except "TriangoloImpossibile": self.ris.set("I lati immessi non possono formare un triangolo") 

          
# Avvio del programma a condizione che non sia caricato come modulo
if __name__=="__main__":
   d=Dialogo()
   d.mainloop()
}}}

= wxPython =

Questa è una versione del programma `AreaTriangolo2.py`, presente all'interno di [[Programmazione/Python/Listati#areatraingolo2| questa pagina]], che utilizza le librerie '''wxpython'''.

== Esempio di applicazione ==

{{{#!python
#!/usr/bin/python

import wx #importiamo l'interfaccia grafica          

from string import digits # importiamo una variabile per il controllo dei dati in input
from math import sqrt # importiamo la funzione sqrt per il calcolo della radicequadrata dal modulo math

class Finestra(wx.Frame):
    #inizializza la finestra grafica   
    def __init__(self,parent,id=-1,title='',pos = wx.Point(0,0),size = wx.Size(400,300),style = wx.DEFAULT_FRAME_STYLE,name = 'frame'):
        pre=wx.PreFrame()
        pre.Create(parent,id,title,pos,size,style,name)
        self.this = pre.this
        self.VwXinit()
        
    #quando si clicca X [angolo superiore destro della finestra] per chiudere la finestra    	
    def __del__(self):
        self.Ddel()
        return

    #definizione della presentazione della finestra e dei suoi oggetti interni
    def VwXinit(self):
        self.SetTitle("Finestra principale ")  # titolo della finestra
      
        self.SetFont(wx.Font(11,74,90,90,0,"Modern No. 20"))
        self.StBar = self.CreateStatusBar(1,wx.ST_SIZEGRIP)
        self.StBar.SetStatusWidths([-1])
        self.StBar.SetStatusText("Calcolo dell'area di un triangolo noti i lati",0)
        self.StBar.SetForegroundColour(wx.RED)
        self.SetBackgroundColour(wx.GREEN)
        self.st1 = wx.StaticText(self,-1,"Calcolo Area del Triangolo formula Erone ",wx.Point(20,30),wx.Size(400,30))
        
        self.st1.SetFont(wx.Font(11,74,90,90,0,"Modern No. 20"))
        self.st1.SetForegroundColour(wx.RED)
        self.lato1 = wx.StaticText(self, -1, "Inserisci il 1 Lato [1..9]  :",wx.Point(10,63))
        self.latoa = wx.TextCtrl(self, -1, "", wx.Point(200, 60), wx.Size(100,-1))
        
        self.lato2 = wx.StaticText(self, -1, "Inserisci il 2 Lato [1..9]  :",wx.Point(10,93))
        self.latob = wx.TextCtrl(self, -1, "", wx.Point(200, 90), wx.Size(100,-1))
        		
        self.lato3 = wx.StaticText(self, -1, "Inserisci il 3 Lato [1..9]  :",wx.Point(10,123))
        self.latoc = wx.TextCtrl(self, -1, "", wx.Point(200, 120), wx.Size(100,-1))
        			
        self.bt1 = wx.Button(self,-1,"",wx.Point(155,220),wx.Size(90,30))
        self.bt1.SetLabel('Inserisci')
        self.bt1.SetFont(wx.Font(12,74,90,90,0,"Modern No. 20"))
        self.bt1.SetForegroundColour(wx.Colour(0,130,255))

        wx.EVT_BUTTON(self.bt1,-1,self.Acquisisci)	#manda in esecuzione i controlli e 
	                                                # se superati calcola l'area
		
	return
    #acquisisce i dati inseriti li controlla e se puo' calcola l'area
    def Acquisisci(self,event): 
	a=str(self.latoa.GetValue())
	b=str(self.latob.GetValue())
	c=str(self.latoc.GetValue())
	
	vero = Finestra.Contronum(self,a)
	if vero == "F":
		avviso = "Il lato a ="+ a+"  <-- non e' di tipo numerico; Riprova "
                msg = wx.MessageBox( avviso, 'Errore',wx.OK | wx.ICON_ERROR)   
		return
        vero = Finestra.Contronum(self,b)
	if vero == "F":
		avviso = "Il lato b ="+ b+"  <-- non e' di tipo numerico; Riprova "
                msg = wx.MessageBox( avviso, 'Errore',wx.OK | wx.ICON_ERROR)  
		return		
	vero =Finestra.Contronum(self,c)	
	if vero == "F":
		avviso = "Il lato c ="+ c+"  <-- non e' di tipo numerico; Riprova "
                msg = wx.MessageBox( avviso, 'Errore',wx.OK | wx.ICON_ERROR) 
		return
	# li trasforma in virgola mobile e poi verifica che corrispondano ad un triangolo
	a= float(a)
	b=float(b)
	c=float(c)	
	
	p = (a+b+c)/2.0
	
	if p <=a or  p <= b or p <= c:
		avviso ='I dati immessi non sono quelli di un triangolo; Riprova'
                msg = wx.MessageBox( avviso, 'Errore',wx.OK | wx.ICON_ERROR)     
                return    
	else:
		# calcolo area triangolo
		area =sqrt(p*(p-a)*(p-b)*(p-c)) 
		avviso =" L'area del triangolo misura  Mq "+str(area)
		msg = wx.MessageBox( avviso, 'Risultato',wx.OK )     
		
	return
        
    def Contronum(self,valore): # serve per la verifica che i dati immessi siano di tipo numerico

        vero = "F"
        for i in range(len(valore)):

            if valore[i]  in digits :

                vero = "T"

                continue

            else:

                vero = "F"

                break            
	return vero

    def Ddel(self): #serve per la chiusura della finestra

        return 



class App(wx.App):# finestra  da cui derivano tutte le finestre successive
    def OnInit(self):

        self.main = Finestra(None,-1,'')
        self.main.Show()
        
        return 1

def main():#lancia il programma in quanto non  caricato come modulo
   
    application = App(0)
    application.MainLoop()

if __name__ == '__main__':
       main()
}}}

= Ulteriori risorse =

 * [[http://wiki.python.org/moin/GuiProgramming|Programmare interfacce grafiche con Python]]
 * [[http://www.wxpython.org|Sito ufficiale di wxpython]]
 * [[http://www.pygtk.org/|Sito ufficiale di PyGTK]]
 * [[http://www.tcl.tk/|Sito degli sviluppatori tcl/tk]]
 * [[http://www.python.it/|Sito di riferimento per i programmatori python italiani]]
 * [[http://www.python.org/|Il sito ufficiale del linguaggio python]]

----
CategoryProgrammazione