PyGObject: Gtk.CellRenderer
CellRenderer
Il widget Gtk.CellRenderer viene utilizato per la rappresentazione dei dati (renderizzazione)
all’interno di widget come Gtk.TreeView o Gtk.ComboBox.
Esistono 6 sottoclassi principali di CellRenderer a seconda del dato che dobbiamo renderizzare:
Gtk.CellRendererText
Gtk.CellRendererToggle
Gtk.CellRendererPixbuf
Gtk.CellRendererCombo
Gtk.CellRendererProgress
Gtk.CellRendererSpin
CellRendererText
Il widget Gtk.CellRendererText renderizza una stringa di testo all’interno della
sua cella, usando le informazioni font, color e style
definite nelle proprie properties.
Il testo, se troppo lungo, verrà troncato con l’ellipse settando a True
la property “ellipsize-set”.
Di default una cella con CellRendererText non è editabile, ma settando la property “editable” a
True, lo diventerà con l’ausilio di una entry.
Le properties principali sono:
Name | Type | Flags | Short Description |
---|---|---|---|
alignment | Pango.Alignment | r/w/en | Come allineare le linee |
attributes | Pango.AttrList | r/w | Una lista di style attributes da applicare al testo del renderer |
background | str | w | Colore di Background in formato stringa |
background-rgba | Gdk.RGBA | r/w | Colore di Background in formato Gdk.RGBA |
editable | bool | r/w | Se il testo può essere modificato dall’utente |
ellipsize | Pango.EllipsizeMode | r/w/en | Il posto dove mettere l’ellipse quando il testo è maggiore dello spazio disponibile |
family | str | r/w | Il nome del font family (Sans, Helvetica, Times, Monospace) |
font | str | r/w | La descrizione del Font come stringa (“Sans Italic 12”) |
font-desc | Pango.FontDescription | r/w | La descrizione del Font come struct Pango.FontDescription |
foreground | str | w | Il colore di Foreground in formato stringa |
foreground-rgba | Gdk.RGBA | r/w | Il colore di Foreground come Gdk.RGBA |
language | str | r/w | Il linguaggio al quale il testo appartiene, in codice ISO |
markup | str | w | Testo in formato Mark up |
max-width-chars | int | r/w/en | la larghezza massima della cella, in caratteri |
placeholder-text | str | r/w | Il testo di placeholder quando la cella è vuota |
rise | int | r/w | Offset del testo sopra la baseline (se rise è negativo, il testo sarà sotto alla baseline) |
scale | float | r/w | Il fattore di scala del Font |
single-paragraph-mode | bool | r/w/en | Fissa il testo in un singolo paragrafo |
size | int | r/w | Il Font size |
size-points | float | r/w | Il Font size espresso in punti |
stretch | Pango.Stretch | r/w | Lo stretch del Font |
strikethrough | bool | r/w | Se il testo è barrato o meno |
style | Pango.Style | r/w | Il Font style |
text | str | r/w | Il testo da renderizzare |
underline | Pango.Underline | r/w | Il tipo di sottolineatura del testo |
variantPango.Variant | r/w | Il Font variant | |
weight | int | r/w | Il Font weight |
width-chars | int | r/w/en | La larghezza della label desiderata, in caratteri |
wrap-mode | Pango.WrapMode | r/w/en | Come spezzare la stringa in linee multiple, se non c’è abbastanza spazio per la stringa |
wrap-width | int | r/w/en | La larghezza del wrap da effettuare sul testo quando non c’è spazio a sufficienza |
Metodi
I metodi fondamentali sono rappresentati dai getter e dai setter relativi alle properties del
CellRendererText. Quindi, per rendere ad esempio editabile una cella, via cellrenderer:
>>> import gi ... gi.require_version('Gtk', '3.0') ... from gi.repository import Gtk >>> renderer = Gtk.CellRendererText() >>> renderer.set_property("editable", True)
Segnali
Il segnale di riferimento al quale connettersi è “edited”
Ecco un codice di esempio:
import gi gi.require_version('Gtk', '3.0') from gi.repository import Gtk class GWindow(Gtk.Window): def __init__(self): super().__init__(title="CellRendererText Example") self.set_default_size(200, 200) self.liststore = Gtk.ListStore(str, str) self.liststore.append(["Portiere", "HANDANOVIC Samir"]) self.liststore.append(["Difensore", "SKRINIAR Milan"]) self.liststore.append(["Difensore", "GODIN Diego"]) treeview = Gtk.TreeView(model=self.liststore) # renderers rnd_text = Gtk.CellRendererText() rnd_text.set_property("foreground", "Blue") rnd_text.set_property("font", "Arial Bold 9") col_text = Gtk.TreeViewColumn(title="Ruolo", cell_renderer=rnd_text, text=0) treeview.append_column(col_text) rnd_etext = Gtk.CellRendererText() rnd_etext.set_property("editable", True) col_etext = Gtk.TreeViewColumn(title="Giocatore", cell_renderer=rnd_etext, text=1) treeview.append_column(col_etext) # bindings rnd_etext.connect("edited", self.text_edited) self.add(treeview) def text_edited(self, widget, path, text): self.liststore[path][1] = text if __name__ == "__main__": win = GWindow() win.connect("destroy", Gtk.main_quit) win.show_all() Gtk.main()
Gtk.CellRendererToggle
Il widget Gtk.CellRendererToggle renderizza un toggle button nella cella, e
sarà o un check o un radio a seconda di come sarà settata la property “radio”.
Quando questo button sarà attivato, verrà emesso il segnale “toggled”.
I metodi fondamentali sono rappresentati dai getter e dai setter relativi alle properties
del CellRendererToggle.
Le properties principali sono:
Name | Type | Flags | Short Description |
---|---|---|---|
activatable | bool | r/w/en | Il toggle button può essere attivato |
active | bool | r/w/en | lo stato del toggle button |
inconsistent | bool | r/w/en | lo stato “inconsistent” del toggle button |
indicator-size | int | d/r/w/en | la dimensione dell’indicatore check/radio |
radio | bool | r/w/en | renderizza il toggle come radio |
Metodi
I principali metodi del Gtk.CellRendererToggle sono:
get_activatable()
Ritorna True se la cella è attivabile
get_active()
Ritorna True se la cella è attiva
get_radio()
Ritorna True se invece di un checkbox, nella cella viene renderizzato un radio toggle.
set_activatable(setting)
Rende la cella attivabile o meno
Parametri:
setting: il booleano che settato a True rende la cella attivabile,
False per non renderla attivabile
set_active(setting)
Attiva o disattiva la cella
Parametri:
setting: il boolean che settato a True attiva la cella;
False la disattiva
set_radio(radio)
Setta se utilizzare nella cella un toggle radio o check
Parametri:
radio: il boolean che settato a True utilizza un radio toggle
nella cella, con False utilizza un check toggle
Segnali
Il segnale di riferimento al quale connettersi è “toggled”.
Ecco un codice di esempio:
import gi gi.require_version('Gtk', '3.0') from gi.repository import Gtk class GWindow(Gtk.Window): def __init__(self): super().__init__(title="CellRendererToggle Example") self.set_default_size(200, 200) self.liststore = Gtk.ListStore(str, bool, bool) self.liststore.append(["HANDANOVIC", True, True]) self.liststore.append(["PADELLI", True, False]) self.liststore.append(["BERNI", False, False]) treeview = Gtk.TreeView(model=self.liststore) rnd_text = Gtk.CellRendererText() col_text = Gtk.TreeViewColumn(title="Portiere", cell_renderer=rnd_text, text=0) treeview.append_column(col_text) rnd_toggle = Gtk.CellRendererToggle() col_toggle = Gtk.TreeViewColumn(title="Convocato", cell_renderer=rnd_toggle, active=1) treeview.append_column(col_toggle) rnd_radio = Gtk.CellRendererToggle() rnd_radio.set_radio(True) col_radio = Gtk.TreeViewColumn(title="Titolare", cell_renderer=rnd_radio, active=2) treeview.append_column(col_radio) self.add(treeview) # bindings rnd_toggle.connect("toggled", self.on_cell_toggled) rnd_radio.connect("toggled", self.on_cell_radio_toggled) def on_cell_toggled(self, widget, path): self.liststore[path][1] = not self.liststore[path][1] def on_cell_radio_toggled(self, widget, path): selected_path = Gtk.TreePath(path) for row in self.liststore: row[2] = True if row.path == selected_path else False if __name__ == "__main__": win = GWindow() win.connect("destroy", Gtk.main_quit) win.show_all() Gtk.main()
Gtk.CellRendererCombo
Il Gtk.CellRendererCombo renderizza un testo in una cella come il Gtk.CellRendererText, dal quale
deriva, ma, mentre il Gtk.CellRendererText mette a disposizione una Gtk.Entry per modificare il
testo in modalità edit, il Gtk.CellRendererCombo offre come widget una combobox dalla quale
selezionare i valori.
Le properties principali sono:
Name | Type | Flags | Short Description |
---|---|---|---|
has-entry | bool | r/w/en | Se False, non permette di inserire strings a parte quella scelta |
model | Gtk.TreeModel | r/w | Il model contenente i possibili valori della combobox |
text-column | int | r/w/en | Una colonna nel data model dal quale prendere le strings |
Metodi
I metodi fondamentali sono rappresentati dai getter e dai setter relativi alle properties del
CellRendererText dal quale deriviamo.
Segnali
Il segnale di riferimento al quale connettersi è, come per il Gtk.CellRendererText dal quale
deriviamo, “edited”.
Ecco un codice di esempio:
import gi gi.require_version('Gtk', '3.0') from gi.repository import Gtk class GWindow(Gtk.Window): def __init__(self): super().__init__(title="CellRendererCombo Example") self.set_default_size(300, 200) self.liststore_pos = Gtk.ListStore(str, str) self.liststore_pos.append(["Vincente", "Inter"]) self.liststore_pos.append(["Seconda", "Lazio"]) self.liststore_pos.append(["Terza", "Juventus"]) treeview = Gtk.TreeView(model=self.liststore_pos) # combobox source data liststore_teams = Gtk.ListStore(str) for team in ["Inter", "Juventus", "Lazio", "Napoli", "Roma", "Milan"]: liststore_teams.append([team]) # cellrenderers rnd_text = Gtk.CellRendererText() col_text = Gtk.TreeViewColumn("Posizione", rnd_text, text=0) rnd_combo = Gtk.CellRendererCombo() rnd_combo.set_property("editable", True) rnd_combo.set_property("model", liststore_teams) rnd_combo.set_property("text-column", 0) rnd_combo.set_property("has-entry", False) col_combo = Gtk.TreeViewColumn("Squadra", rnd_combo, text=1) treeview.append_column(col_text) treeview.append_column(col_combo) self.add(treeview) # bindings rnd_combo.connect("edited", self.on_combo_changed) def on_combo_changed(self, widget, path, text): self.liststore_pos[path][1] = text print("INFO: team '%s' selected" % text) if __name__ == "__main__": win = GWindow() win.connect("destroy", Gtk.main_quit) win.show_all() Gtk.main() <a href="http://bancaldo.altervista.org/wp-content/uploads/2020/02/cellrenderercombo.png"><img src="http://bancaldo.altervista.org/wp-content/uploads/2020/02/cellrenderercombo-300x226.png" alt="" width="300" height="226" class="aligncenter size-medium wp-image-3693" /></a> <span style="color:red"><strong>Gtk.CellRendererProgress</strong></span> Il Gtk.CellRendererProgress renderizza una progressbar nella cella ed eventualmente un testo sopra di essa. Le properties principali sono: <table> <tr><th>Name</th><th>Type</th><th>Flags</th><th>Short Description</th></tr> <tr><td>inverted</td><td>bool</td><td>r/w/en</td><td>Inverte la direzione di riempimento della progressbar</td></tr> <tr><td>pulse</td><td>int</td><td>r/w/en</td><td>Settato a valori positivi indica un progresso indefinito indicato con un blocchetto che pulsa nella progressbar</td></tr> <tr><td>text</td><td>str</td><td>r/w</td><td>Il Testo presente sulla progressbar</td></tr> <tr><td>text-xalign</td><td>float</td><td>r/w</td><td>L'allineamento orizzontale del testo nella progressbar, da 0 (sinistra) a 1 (destra)</td></tr> <tr><td>text-yalign</td><td>float</td><td>r/w</td><td>L'allineamento verticale del testo nella progressbar, da 0 (top) a 1 (bottom)</td></tr> <tr><td>value</td><td>int</td><td>r/w/en</td><td>Il valore dell'avanzamento della progressbar</td></tr> </table> <span style="color:green"><strong>Metodi</strong></span> I metodi fondamentali sono rappresentati dai getter e dai setter relativi alle properties del CellRendererProgress. <span style="color:green"><strong>Segnali</strong></span> Sono tutti i segnali ereditati da <a href="https://lazka.github.io/pgi-docs/Gtk-3.0/classes/CellRenderer.html#gtk-cellrenderer-signals">Gtk.CellRenderer</a> dal quale deriviamo. Ecco un codice di esempio: import gi gi.require_version('Gtk', '3.0') from gi.repository import Gtk, GLib class GWindow(Gtk.Window): def __init__(self): super().__init__(title="CellRendererProgress Example") self.set_default_size(300, 150) self.liststore = Gtk.ListStore(str, int, bool) self.current_iter = self.liststore.append(["package_1.deb", 0, False]) self.liststore.append(["package_2.deb", 0, False]) self.liststore.append(["package_3.deb", 0, False]) treeview = Gtk.TreeView(model=self.liststore) # cellrenderers rnd_text = Gtk.CellRendererText() col_text = Gtk.TreeViewColumn(title="Package name", cell_renderer=rnd_text, text=0) treeview.append_column(col_text) rnd_progress = Gtk.CellRendererProgress() col_progress = Gtk.TreeViewColumn(title="Progress", cell_renderer=rnd_progress, value=1, inverted=2) treeview.append_column(col_progress) rnd_toggle = Gtk.CellRendererToggle() col_toggle = Gtk.TreeViewColumn(title="Inverted", cell_renderer=rnd_toggle, active=2) treeview.append_column(col_toggle) self.add(treeview) # bindings rnd_toggle.connect("toggled", self.on_inverted_toggled) self.timeout_id = GLib.timeout_add(20, self.on_timeout, None) def on_inverted_toggled(self, widget, path): self.liststore[path][2] = not self.liststore[path][2] def on_timeout(self, user_data): new_value = self.liststore[self.current_iter][1] + 1 if new_value > 100: self.current_iter = self.liststore.iter_next(self.current_iter) if self.current_iter is None: # sono arrivato in fondo self.reset_model() new_value = self.liststore[self.current_iter][1] + 1 self.liststore[self.current_iter][1] = new_value return True def reset_model(self): for row in self.liststore: row[1] = 0 # azzero tutte le progressbar self.current_iter = self.liststore.get_iter_first() # ricomincio if __name__ == "__main__": win = GWindow() win.connect("destroy", Gtk.main_quit) win.show_all() Gtk.main()
Gtk.CellRendererPixbuf
Il Gtk.CellRendererPixbuf renderizza una immagine nella cella, sia attraverso la property "pixbuf"
sia con la property "icon-name".
Le properties principali sono:
Name | Type | Flags | Short Description |
---|---|---|---|
gicon | Gio.Icon | r/w | L'immagine Gio.Icon visualizzata |
icon-name | str | r/w | Il nome dell'icona che deriva dal tema icone |
pixbuf | GdkPixbuf.Pixbuf | r/w | il pixbuf da rappresentare |
pixbuf-expander-closed | GdkPixbuf.Pixbuf | r/w | Il Pixbuf per closed expander |
pixbuf-expander-open | GdkPixbuf.Pixbuf | r/w | Il Pixbuf per open expander |
stock-detail | str | r/w | Il Render detail da passare al theme engine |
stock-size | int | r/w | Il valore Gtk.IconSize che specifica la dimensione della icona renderizzata |
surface | cairo.Surface | r/w | La superficie da renderizzare |
Metodi
I metodi fondamentali sono rappresentati dai getter e dai setter relativi alle properties del
CellRendererProgress.
Segnali
Sono tutti i segnali ereditati da Gtk.CellRenderer
dal quale deriviamo.
Ecco un codice di esempio:
import gi gi.require_version('Gtk', '3.0') from gi.repository import Gtk class GWindow(Gtk.Window): def __init__(self): super().__init__(title="CellRendererPixbuf Example") self.set_default_size(200, 200) self.liststore = Gtk.ListStore(str, str) self.liststore.append(["New", "document-new"]) self.liststore.append(["Open", "document-open"]) self.liststore.append(["Save", "document-save"]) treeview = Gtk.TreeView(model=self.liststore) rnd_text = Gtk.CellRendererText() col_text = Gtk.TreeViewColumn(title="Text", cell_renderer=rnd_text, text=0) treeview.append_column(col_text) rnd_pixbuf = Gtk.CellRendererPixbuf() col_pixbuf = Gtk.TreeViewColumn(title="Image", cell_renderer=rnd_pixbuf, icon_name=1) treeview.append_column(col_pixbuf) self.add(treeview) if __name__ == "__main__": win = GWindow() win.connect("destroy", Gtk.main_quit) win.show_all() Gtk.main()
Gtk.CellRendererSpin
Il Gtk.CellRendererSpin renderizza un testo in una cella come il Gtk.CellRendererText, dal quale
deriva, ma, mentre il Gtk.CellRendererText mette a disposizione una Gtk.Entry per modificare il
testo in modalità edit, il Gtk.CellRendererSpin offre come widget uno spin button per settare i
valori.
Le properties principali sono:
Name | Type | Flags | Short Description |
---|---|---|---|
adjustment | Gtk.Adjustment | r/w | L'arrotondamento che gestisce il valore dello spin button |
climb-rate | float | r/w | Il rapporto di accelerazione nel momento in cui teniamo premuto il buttone |
digits | int | r/w/en | Il numero di decimali da visualizzare |
Metodi
I metodi fondamentali sono rappresentati dai getter e dai setter relativi alle properties comprese
quelle del CellRendererText dal quale deriviamo.
Segnali
Il segnale di riferimento al quale connettersi è, come per il Gtk.CellRendererText dal quale
deriviamo, "edited".
Ecco un codice di esempio:
import gi gi.require_version('Gtk', '3.0') from gi.repository import Gtk class GWindow(Gtk.Window): def __init__(self): super().__init__(title="CellRendererSpin Example") self.set_default_size(200, 200) self.liststore = Gtk.ListStore(str, int) self.liststore.append(["Oranges", 5]) self.liststore.append(["Apples", 4]) self.liststore.append(["Bananas", 2]) treeview = Gtk.TreeView(model=self.liststore) rnd_text = Gtk.CellRendererText() col_text = Gtk.TreeViewColumn(title="Fruit", cell_renderer=rnd_text, text=0) treeview.append_column(col_text) rnd_spin = Gtk.CellRendererSpin() rnd_spin.set_property("editable", True) adjustment = Gtk.Adjustment(value=0, lower=0, upper=100, step_increment=1, page_increment=10,) rnd_spin.set_property("adjustment", adjustment) col_spin = Gtk.TreeViewColumn(title="Amount", cell_renderer=rnd_spin, text=1) treeview.append_column(col_spin) self.add(treeview) # bindings rnd_spin.connect("edited", self.on_amount_edited) def on_amount_edited(self, widget, path, value): self.liststore[path][1] = int(value) if __name__ == "__main__": win = GWindow() win.connect("destroy", Gtk.main_quit) win.show_all() Gtk.main()
link di riferimento:
Commenti recenti