PyGObject: Gtk.ProgressBar
torna all’indice degli appunti
ProgressBar
Il widget Gtk.ProgressBar è un widget utilizzato per visualizzare il progresso di un’operazione
di lunga durata. La progressbar può essere utilizzata in due modi, percentage
per visualizzare lo stato di avanzamento progressivo dell’operazione e activity,
per visualizzare un cursore rimbalzante.
Quando dobbiamo visualizzare lo stato di un’operazione dall’esito certo, ad esempio il download di
un file di grandezza nota, possiamo utilizzare la progressbar in percentage mode.
Questo richiede il periodico richiamo del metodo Gtk.ProgressBar.set_fraction(),
per aggiornare lo stato della progressbar.
Se invece non conosciamo l’ammontare del carico di lavoro, possiamo utilizzare una progressbar
in activity mode, il chè richiede la chiamata periodica al metodo
Gtk.ProgressBar.pulse(), che mostra un cursore che fa avanti e indietro indefinitivamente.
Per creare un ProgressBar si utilizza il costruttore Gtk.ProgressBar(**kwargs).
Le properties della progressbar sono le seguenti:
| Name | Type | Flags | Short Description |
|---|---|---|---|
| ellipsize | Pango.EllipsizeMode | r/w/en | l’oggetto Pango.EllipsizeMode che indica dove applicare l’ellipse (“…”) sulla stringa |
| fraction | float | r/w/en | la porzione completata della progressbar |
| inverted | bool | r/w/en | un boolean che settato a True, inverte la direzione della progress bar (da destra verso sinistra) |
| pulse-step | float | r/w/en | la porzione di progressbar da utilizzare come blocco in activity-mode (avanti e indietro) |
| show-text | bool | r/w/en | un boolean che settato a True permette di mostrare un testo sulla progressbar |
| text | str | r/w | la stringa di testo da visualizzare sulla progressbar |
E’ possibile settare le properties del widget successivamente alla sua costruzione, con i soliti metodi getter e setter
get_property(property_name) e set_property(property_name, property_value):
>>> import gi
... gi.require_version('Gtk', '3.0')
... from gi.repository import Gtk, GLib, Gdk
>>> progressbar = Gtk.ProgressBar()
>>> progressbar.set_property("text", "progress 0%")
>>> progressbar.get_property("text")
'progress 0%'
oppure con i metodi getter e setter specifici get_*property_name*() e
set_*property_name*(value):
>>> progressbar.get_inverted() False >>> progressbar.set_inverted(True) >>> progressbar.get_inverted() True
Metodi
Di seguito i metodi utilizzabili con il widget Gtk.ProgressBar:
new()
Metodo costruttore che crea un nuovo oggetto Gtk.ProgressBar.
get_ellipsize()
Ritorna l’oggetto Pango.EllipsizeMode con la posizione dell’ellipse (“…”)
utilizzata sulla stringa.
get_fraction()
Ritorna una frazione da 0.0 a 1.0 indicante la quantità di lavoro completato.
get_inverted()
Ritorna True se la progressbar è invertita, ovvero si riempie da destra verso sinistra.
get_pulse_step()
Ritorna la frazione utilizzata per il blocco in movimento nella activity mode.
get_show_text()
Ritorna True se il testo viene visualizzato nella progressbar.
get_text()
Ritorna il testo visualizzato nella progressbar, se presente, altrimenti ritorna None.
pulse()
Indica che un progresso indefinito è stato fatto, ma non è dato sapere quanto.
La chiamata a questo metodo causa l’entrata dell progressbar nell’ activity mode
(con un blocco che rimbalza avanti e indietro).
Ogni chiamata al metodo Gtk.ProgressBar.pulse() causa un piccolo spostamento del blocco e
questo piccolo spostamento viene settato con il metodo Gtk.ProgressBar.set_pulse_step().
set_ellipsize(mode)
Setta la posizione dell’ellipse da applicare al testo, quando non c’è abbastanza spazio per
visualizzare tutta la stringa.
Parametri:
mode: è un Enum Pango.EllipsizeMode
che definisce dove posizionare l’ellipse, e può assumere i seguenti valori:
NONE (0): nessuna ellipsization;
START (1): omette i caratteri all’inizio del testo;
MIDDLE (2): omette i caratteri a centro testo;
END (3): omette i caratteri alla fine del testo;
set_fraction(fraction)
Definisce il riempimento della progress bar, indicando cioè la frazione di lavoro completato
rispetto al totale previsto.
Parametri:
fraction: è il float che indica quanto lavoro è stato completato
e va da 0.0 (vuota) a 1.0 (piena) inclusi.
set_inverted(inverted)
Inverte il senso di riempimento della progressbar, partendo da destra e riempendosi verso sinistra.
Parametri:
inverted: è il boolean che settato a True, inverte la progressbar;
set_pulse_step(fraction)
Setta la frazione di progressbar da utilizzare come blocco in movimento in activity mode.
Parametri:
fraction: il float che indica che frazione di progressbar utilizzare per il blocco in movimento. Va da 0.0 a 1.0;
set_show_text(show_text)
Setta se mostrare o meno il testo nella progressbar.
Parametri:
show_text: è il boolean che settato a True mostra il testo nella
progressbar;
set_text(text)
Setta il testo da visualizzare nelle progressbar.
Se text=None e la property di Gtk.ProgressBar “show-text”=True, verrà visualizzato al posto del
testo, il valore corrente della property “fraction”.
Parametri:
text: il testo da visualizzare nella progressbar o None;
Di seguito un codice d’esempio:
import gi
gi.require_version('Gtk', '3.0')
from gi.repository import Gtk, GLib
class GWindow(Gtk.Window):
def __init__(self):
Gtk.Window.__init__(self, title="ProgressBar example")
self.value = 0
self.set_default_size(400, 100)
self.set_border_width(10)
self.progressbar = Gtk.ProgressBar()
self.progressbar.set_text("progress {}%".format(self.value))
self.progressbar.set_show_text(True)
self.button = Gtk.ToggleButton(label="Start")
# bindings
self.button.connect("toggled", self.on_toggle)
# layout
vbox = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=6)
vbox.pack_start(self.button, True, True, 0)
vbox.pack_start(self.progressbar, True, True, 0)
self.add(vbox)
def on_toggle(self, button):
GLib.timeout_add(50, self.on_timeout, 1.0)
def on_timeout(self, new_value):
if self.button.get_active():
self.button.set_label("Stop")
self.value = self.progressbar.get_fraction() + new_value/100
self.progressbar.set_text("progress {}%".format(
int(self.value*100)))
if self.value > 1:
self.value = 0
self.progressbar.set_fraction(self.value)
return True # chiamo di nuovo la callback on_timeout
else:
self.button.set_label("Start")
return False # fermo la chiamata alla callback
if __name__ == "__main__":
win = GWindow()
win.connect("destroy", Gtk.main_quit)
win.show_all()
Gtk.main()
In questo codice vediamo questa riga di codice particolare
GLib.timeout_add(50, self.on_timeout, 1.0)
La funzione di GLib timeout_add(time, callback, *args), permette di invocare una
callback dopo un determinato intervallo di tempo.
Questa callback viene richiamata fino a che non viene ritornato False.
Parametri:
time: è l’intervallo di tempo in millisecondi;
callback: è la funzione da chiamare;
*args: sono gli argomenti facoltativi da passare alla callback;
Qui sono reperibili le GLib functions.
Aspetto
Se volessimo modificare l’aspetto del widget, sarà possibile farlo ricorrendo a CSS.
Qui entrano in gioco 3 oggetti:
Gdk.Screen
Gtk.CssProvider
Gtk.StyleContext
L’oggetto Gdk.Screen viene utilizzato per specificare su quale Screen la top-level
window deve essere visualizzata.
CssProvider è un oggetto che implementa l’interfaccia Gtk.StyleProvider
e permette il parse di una stringa CSS-like, utilizzabile per personalizzare i widget.
Gtk.StyleContext memorizza le informazioni riguardanti la personalizzazione dei
widget e si occupa in tal senso, di chiedere le informazioni necessarie al Gtk.StyleProvider
collegato ad esso. L’iter è il seguente:
– si crea un’istanza di Gdk.Screen con il classmethod get_default(),
che ritorna lo screen di default per il display di default;
– si crea un’istanza di Gtk.CssProvider ed una di Gtk.StyleContext;
– Chiamiamo il metodo Gtk.StyleContext.add_provider_for_screen(screen, provider, priority),
con il quale associamo un global style-provider allo screen e decidendone la priorità.
Infine diciamo al provider di caricare la stringa CSS da parsare:
import gi
gi.require_version('Gtk', '3.0')
from gi.repository import Gtk, GLib, Gdk
class GWindow(Gtk.Window):
def __init__(self):
Gtk.Window.__init__(self, title="ProgressBar example")
self.value = 0
self.set_default_size(400, 100)
self.set_border_width(10)
self.progressbar = Gtk.ProgressBar()
self.progressbar.set_text("progress {}%".format(self.value))
self.progressbar.set_show_text(True)
css = b"""
trough {
min-height: 20px;
border: none;
}
text {
color: grey;
font: 12px Verdana;
}
progress {
border: none;
background-color: grey;
min-height: 20px;
}
"""
screen = Gdk.Screen.get_default()
provider = Gtk.CssProvider()
style_context = Gtk.StyleContext()
style_context.add_provider_for_screen(
screen, provider, Gtk.STYLE_PROVIDER_PRIORITY_APPLICATION
)
provider.load_from_data(css)
self.button = Gtk.ToggleButton(label="Start")
# bindings
self.button.connect("toggled", self.on_toggle)
# layout
vbox = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=6)
vbox.pack_start(self.button, True, True, 0)
vbox.pack_start(self.progressbar, True, True, 0)
self.add(vbox)
def on_toggle(self, button):
GLib.timeout_add(50, self.on_timeout, 1.0)
def on_timeout(self, new_value):
if self.button.get_active():
self.button.set_label("Stop")
self.value = self.progressbar.get_fraction() + new_value/100
self.progressbar.set_text("progress {}%".format(
int(self.value*100)))
if self.value > 1:
self.value = 0
self.progressbar.set_fraction(self.value)
return True # chiamo di nuovo la callback on_timeout
else:
self.button.set_label("Start")
return False # fermo la chiamata alla callback
if __name__ == "__main__":
win = GWindow()
win.connect("destroy", Gtk.main_quit)
win.show_all()
Gtk.main()
link di riferimento:
Commenti recenti