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.

alternate text

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ò.

alternate text

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!)