Home > Gtk3, PyGObject, python > PyGObject: Gtk.CellRenderer

PyGObject: Gtk.CellRenderer

13 Aprile 2020

torna all’indice appunti

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:

torna all'indice degli appunti
Gtk3 CellRenderers

Categorie:Gtk3, PyGObject, python Tag: , ,
I commenti sono chiusi.