myBox
Bene oggi vedremo il nostro primo template per i widgets.
Non potevamo che iniziare dai contenitori! Lo chiameremo my01Box. Vi chiederete perchè inserisco dei prefissi numerici ai nomi degli script. E’ una maniacale usanza che mi permette di tenere ordinati per importanza i vari files.
Inoltre quando devo richiamarli, da terminale, è sufficiente dare in genere le prime 4 lettere seguite da un Tab per avere velocemente la scelta del file interessato. Non fateci caso ma nel mondo nix succedono anche queste cose.
Per chi non lo sapesse nix sta ad indicare tutto quello che deriva da unix.
my01Box
#!/usr/bin/env python
# -*- coding: utf-8 -*-
""" lista degli oggetti definiti:
- myViewObject
- myBox - myBoxList
- myFrame - myFraList
- myBoxEvent - myBoxEveList
"""
myRev = "(rev.150824)"
#-----------------------------------------------------------------------------
# Modules
#-----------------------------------------------------------------------------
from my00init import *
from gi.repository import Pango
#-----------------------------------------------------------------------------
# myModules
#-----------------------------------------------------------------------------
from myWind import MyWind #(contiene my00initGtk)
#-----------------------------------------------------------------------------
# myDefines
#-----------------------------------------------------------------------------
def myViewObject(obje, othe):
"visualizza le istanze degli oggetti nel contenitore"
print " obje:", obje
# view objects
for ind, ele in enumerate(othe):
print "row%02d:" %ind, ele
#-----------------------------------------------------------------------------
# myBox
#-----------------------------------------------------------------------------
def myBox(tBox='v', homo=False, spac=0):
""" crea un contenitore del tipo richiesto
-> tBox tipo di contenitore v/h
-> homo tipo omogeneita'
-> spac spazio da mantenere intorno all'oggetto
"""
if tBox == 'v':
# creo un Vertical Box
xBox = Gtk.VBox(homo,spac)
elif tBox == 'h':
# creo un Horizontal Box
xBox = Gtk.HBox(homo,spac)
xBox.show()
# <-
return xBox
#-----------------------------------------------------------------------------
def testBox():
#myBox
xBox = myBox('h', homo=False, spac=0)
#child, expand=True, fill=True, padding=1
#xBox.pack_start(obje, False, False, 1)
# inserisco alcuni oggetti
for ele in ("yellow","blue","green","red","brown"):
# labels
labe = Gtk.Label(" I am %s" %ele)
labe.show()
# events
# istanzio l'oggetto
eBox = Gtk.EventBox()
# lo rendo visibile
eBox.show()
# imposto il colore di sfondo
eBox.modify_bg(Gtk.STATE_NORMAL, Gdk.color_parse(ele))
# xBox
# inerisco nei contenitori
eBox.add(labe)
#child, expand=True, fill=True, padding=1
xBox.pack_start(eBox, False, False, 1)
#myFrame
# fram, [labe, xBox]
fram, othe = myFrame(name='Box', obje=xBox, colo='black',
bord=2, shad=Gtk.SHADOW_ETCHED_OUT,
tBox='v', aBox=[False, False, 1] )
# <-
return fram
I metodi myBox e myFrame li abbiamo già visti nel post Contenitori per cui non li commenterò.
myViewObject
#-----------------------------------------------------------------------------
def myViewObject(obje, othe):
"visualizza le istanze degli oggetti nel contenitore"
print " obje:", obje
# view objects
for ind, ele in enumerate(othe):
print "row%02d:" %ind, ele
E’ una utility che serve in fase di debug per visualizzare le istanze degli oggetti creati. Normalmente viene richiamato, se necessario, dopo una istanza di un oggetto complesso per visualizzare la sua struttura. Un esempio d’ uso lo vederemo nella istanza di liste di oggetti.
Nota
Per visualizzare il risultato dovete avviare lo script da terminale.
Liste di oggetti
In questo modulo, myBox.py, sono presenti oltre che la definizione di metodi tradizionali anche la definizione di liste di oggetti. Questi metodi si riconosco dal post suffisso List dato al nome del metodo stesso. Sono molto utili quando si prevede l’ utilizzo di un insieme di oggetti simili.
Vediamo un esempio concreto.
myBoxList
#-----------------------------------------------------------------------------
# myBoxList
#-----------------------------------------------------------------------------
def myBoxList(name=["Obj1","Obj2"],
tBox='v', aBox=[False, False, 1],
func=None):
# istanzio il contenitore
xBox = myBox(tBox)
listObj = []
for ind, ele in enumerate(name):
# istanza gli oggetti
obje,othe = func(ind)
listObj.append([obje,othe])
#child, expand=True, fill=True, padding=0
xBox.pack_start(obje, *aBox)
# <-
return xBox, listObj
#-----------------------------------------------------------------------------
def testBoxList():
#myBoxList
# funzione che istanzia gli oggetti tipo
def myList(ind, *para):
# istanzio una label
labe = Gtk.Label(nam[ind])
# la rendo visibile
labe.show()
# imposto il colore
labe.modify_fg(Gtk.STATE_NORMAL, Gdk.color_parse(col[ind]))
# <-
return labe, None
# define attributes
nam = ("Obj1","Obj2","Obj3")
col = ('blue','green','red')
# xBox, listObj
obje, othe = myBoxList(name= nam,
tBox='h', aBox=[False, False, 1],
func=myList)
#debug
myViewObject(obje, othe)
# <-
return obje
E’ un esempio di pura dimostrazione ma serve a comprendere la potenzialità di usare le liste nella programmazione in genere.
Come potete vedere dal codice del nostro template myBoxList passiamo una lista dei nomi degli oggetti che vogliamo istanziare, nel nostro caso sono box. Subito dopo passiamo gli attributi tbox e aBox che andranno a caratterizzare gli stessi. Ed infine una funzione di supporto.
Mi voglio soffermare su questa ultimo parametro passato. Questa funzione torna molto utile. Ci permette di integrare una ulteriore elaborazione durante l’ istanza dell’ oggetto. Nell’ esempio di testBoxList viene utilizzata per inserire delle labes per enfatizzare lo scopo dell’ esempio stesso.

testBoxList in esecuzione.
Nota
per maggiori informazioni dei contenitori consiglio di rivedere il post Contenitori
myFrameList
#-----------------------------------------------------------------------------
# myFrame
#-----------------------------------------------------------------------------
def myFrame(name='myFrame', obje=None, colo='blue',
bord=2, shad=Gtk.SHADOW_ETCHED_OUT,
tBox='v', aBox=[False, False, 1],
xtBox='', xaBox=[False, False, 1],
):
""" crea una cornice con un titolo
-> name nome associato alla label
-> obje oggetto da inserire
-> colo colore label
-> bord bordo riservato all'esterno
-> shad tipo di cornice
Gtk.SHADOW_NONE, Gtk.SHADOW_IN, Gtk.SHADOW_OUT,
Gtk.SHADOW_ETCHED_IN, Gtk.SHADOW_ETCHED_OUT
-> tBox tipo di contenitore v/h interno
-> aBox attributi del contenitore interno
-> xtBox tipo di contenitore v/h esterno
-> xaBox attributi del contenitore esterno
"""
#frame
if name != "":
name = " "+name+" "
fram = Gtk.Frame(label=name)
# la rendo visibile
fram.show()
# imposto il bordo (esterno)
fram.set_border_width(bord)
fram.set_shadow_type(shad)
#label
# referenzio la label della Frame
labe = fram.get_label_widget()
# attivo il markup
labe.set_markup("<b>%s</b>" %name)
# imposto il colore
labe.modify_fg(Gtk.STATE_NORMAL, Gdk.color_parse(colo))
#myBox (interno)
xBox = myBox(tBox)
fram.add(xBox)
#object
if obje != None:
#child, expand=True, fill=True, padding=1
xBox.pack_start(obje, *aBox)
#myBox (esterno)
if (xtBox == 'v') or (xtBox == 'h'):
yBox = myBox(xtBox)
#child, expand=True, fill=True, padding=1
yBox.pack_start(fram, *xaBox)
# <-
return yBox, [labe, xBox, fram]
else:
# <-
return fram, [labe, xBox]
#-----------------------------------------------------------------------------
def testFrame():
#label
if 0:
lab1 = None
else:
#str
lab1 = Gtk.Label()
# uso il markup
lab1.set_markup(' <b>prova</b> ')
# la rendo visibile
lab1.show()
# imposto il colore
lab1.modify_fg(Gtk.STATE_NORMAL, Gdk.color_parse('blue'))
#myFrame
# <- fram,[labe,xBox]
obje, othe = myFrame(name='myFrame', obje=lab1, colo='#f000f0',
bord=2, shad=Gtk.SHADOW_ETCHED_OUT,
tBox='v', aBox=[False, False, 10])
# <-
return obje
Questo è un’altro esempio di lista di oggetti. E’ molto simile alla precedente cambiano solo gli attributi all’ ingresso che rispecchiano quelli del nuovo oggetto frame. Per cui non li commenterò.

testBoxList in esecuzione.
Package
La struttura del nostro package ora è la seguente:
l00_start.py
l01_startGtk.py
my00init.py
myWidg/
__init__.py
my00init.py
my00initGtk.py
my01Box.py
myWind.py
myApp.py
Per scaricare la nuova versione 20150825.zip
Saluti
Nel prossimo post vedremo una variante dell’ oggetto box.
Ciao alla prossima. (stay tune!)