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

PyGObject: Gtk.Notebook

13 Aprile 2020

torna all’indice appunti

Notebook

Il widget Gtk.Notebook è un Gtk.Container i cui widget child sono pagine sulle
quali posso spostarmi agilmente semplicemente utilizzando i tab presenti sul proprio bordo.
E’ possibile scegliere su quale bordo posizionare i tabs utilizzando il metodo .set_tab_pos(),
qualora invece i tabs dovessere essere troppi, rispetto allo spazio disponibile, potremo
aggiungere le scrolling arrows, utilizzando il metodo set_scrollable().
Infine sarà possibile aggiungere dei popup menu con il metodo popup_enable().

Le properties ereditate da Gtk.Container sono:

Name Type Flags Short Description
enable-popup bool r/w/en Se True, premendo con il bottone destro del mouse
apparirà un popup menu che permetterà di scegliere la pagina su cui spostarsi
group-name str r/w/en Il nome del Group per il drag and drop dei tab
page int r/w/en l’indice della pagina corrente
scrollable bool r/w/en Se True, abilitiamo le scroll arrows da usare se ci sono troppe tabs
show-border bool r/w/en Se visualizzare il bordo
show-tabs bool r/w/en Se visualizzare i tabs
tab-pos Gtk.PositionType r/w/en Su quale bordo del notebook mettere i tabs

Le properties relative ai children sono:

Name Type Default Flags Short Description
detachable bool False r/w se il tab è “staccabile”
menu-label str None r/w la label visualizzata nel menu entry del child
position int 0 r/w L’indice del child nel notebook
reorderable bool False r/w Se il tab è is riordinabile
tab-expand bool False r/w Se espandere il tab del child
tab-fill bool True r/w Se il tab del child riempie lo spazio allocato
tab-label str None r/w La label visualizzata sul tab del child

Segnali

I principali segnali sono:

Name Short Description
create-window Il segnale “create-window” viene emesso quando un tab “detachable” viene rimosso dalla root window
page-added Il segnale “page-added” viene emesso nel notebook appena una pagina viene aggiunta al notebook
page-removed Il segnale “page-removed” viene emesso quando una pagina viene rimossa dal notebook
page-reordered Il segnale “page-reordered” viene emesso quando la pagine vengono riordinate
switch-page Emesso quando lo User o una funzione, cambia la pagina corrente

Metodi

Oltre ai soliti getter e setter relativi alle properties dell’oggetto Gtk.Notebook,
i principali metodi sono:

new()

Crea un nuovo widget Gtk.Notebook privo di pagine.

append_page(child, tab_label)

Aggiunge una pagina (append) al notebook e ritorna l’indice della pagina.
Se l’operazione fallisce, il metodo ritorna -1.

>>> import gi
... gi.require_version('Gtk', '3.0')
... from gi.repository import Gtk
>>> notebook = Gtk.Notebook.new()
>>> page_1 = Gtk.Label(label="First content")
>>> notebook.append_page(child=page_1, tab_label=Gtk.Label(label='First Page'))
0

Parametri:
child: il widget da utilizzare come contenuto della pagina;
tab_label: il widget da usare come label della pagina, o None
per usare la label di default “page N”;

append_page_menu(child, tab_label, menu_label)

Aggiunge una pagina (append) al notebook specificando il widget da usare come label nel popup
menu. Se l’operazione fallisce, il metodo ritorna -1.
Parametri:
child: il widget da utilizzare come contenuto della pagina;
tab_label: il widget da usare come label della pagina, o None
per usare la label di default “page N”;
menu_label: il widget da usare come label per il page-switch menu,
se questo è abilitato. Se menu_label=None e tab_label è un widget Gtk.Label (o None), allora la
label del menu sarà una nuova label creata con lo stesso testo di tab_label;
se invece tab_label non è una Gtk.Label, menu_label deve essere specificato in caso di utilizzo
del page-switch menu;

detach_tab(child)

Rimuove un child dal notebook.

>>> page_temp = Gtk.Label(label="Temp content")
>>> notebook.append_page(child=page_temp, tab_label=Gtk.Label(label='Temp Page'))
1
>>> notebook.get_children()
[<Gtk.Label object at 0x000000000583ae80 (GtkLabel at 0x0000000004d851f0)>, <Gtk.Label object at 0x0000000005815200 (GtkLabel at 0x0000000004d85530)>]
>>> notebook.detach_tab(page_temp)
>>> notebook.get_children()
[<Gtk.Label object at 0x000000000583ae80 (GtkLabel at 0x0000000004d851f0)>]

Parametri:
child: il widget che rappresenta il child da rimuovere.

get_action_widget(pack_type)

Ritorna l’action widget con il pack_type passato come argomento, o None se non è stato settato
alcun action widget. Vedere Gtk.Notebook.set_action_widget().
Parametri:
pack_type: il Gtk.PackType dell’action widget;
L’enum Gtk.PackType rappresenta il tipo di impacchettamento, che può essere: START (0) o END (1).

get_current_page()

Ritorna il numero della pagina corrente del Notebook. Se il notebook non ha ancora pagine, il
metodo ritornerà -1.

get_group_name()

Ritorna il nome del Group corrente.

get_menu_label(child)

Ritorna la label del menu se presente, o None se la pagina del notebook non ha label di menu che
non siano quelle di default (la label del Tab).

>>> notebook.get_menu_label(page_1)
>>> page_2 = Gtk.Label(label="Second content")
>>> notebook.append_page_menu(child=page_2, tab_label=Gtk.Label(label='Second Page'),
...                           menu_label=Gtk.Label(label='Second page menu label'))
1
>>> notebook.get_menu_label(page_2)
<Gtk.Label object at 0x000000000571bd40 (GtkLabel at 0x0000000004d85a10)>

Parametri:
child: il widget contenuto in una pagina del notebook;

get_menu_label_text(child)

Ritorna il testo della label del menu relativo alla pagina passata in argomento.

>>> notebook.get_menu_label_text(page_2)
'Second page menu label'

Parametri:
child: il widget contenuto in una pagina del notebook;

get_n_pages()

Ritorna il numero di pagine del notebook.

get_nth_page(page_num)

Ritorna il child widget della pagina con l’indice passato come argomento, o None.

>>> notebook.get_nth_page(0)
<Gtk.Label object at 0x000000000583ae80 (GtkLabel at 0x0000000004d851f0)>

Parametri:
page_num: l’indice della pagina nel notebook o -1 per ritornare
l’ultima pagina;

get_scrollable()

Ritorna True se sono presenti le scrollabe arrows nell’area dei tabs.
Vedere Gtk.Notebook.set_scrollable() per il settaggio.

get_show_border()

Ritorna True se viene disegnato il bordo del notebook.
Vedere Gtk.Notebook.set_show_border() per il settaggio.

get_show_tabs()

Ritorna True se vengono visualizzati i tabs.
Vedere Notebook.set_show_tabs() per il settaggio.

get_tab_detachable(child)

Ritorna True se il tab relativo al child passato in argomento, è “staccabile”.

Parametri:
child: il child widget di cui vogliamo la caratteristica del tab;

get_tab_label(child)

Ritorna il widget che fa da label al tab, del child passato come argomento.

>>> notebook.get_tab_label(page_1)
<Gtk.Label object at 0x0000000005815080 (GtkLabel at 0x0000000004d85390)>

Parametri:
child: la pagina della quale vogliamo il widget label del tab;

get_tab_label_text(child)

Ritorna il testo della label, del tab, del child passato come argomento.

>>> notebook.get_tab_label_text(page_1)
'First Page'

Parametri:
child: la pagina della quale vogliamo il testo della tab label;

get_tab_pos()

Ritorna il Gtk.PositionType che rappresenta il bordo sul quale appaiono i tabs.

>>> notebook.get_tab_pos()
<enum GTK_POS_TOP of type Gtk.PositionType>

get_tab_reorderable(child)

Ritorna True se il tab del child passato come argomento, può essere riordinato via drag and drop.

insert_page(child, tab_label, position)

Inserisce una pagina nel notebook, alla posizione specificata.
Parametri:
child: il widget usato come contenuto della pagina;
tab_label: il widget usato come label per la pagina, o None
per utilizzare la label di default “page N”;
position: l’indice (partendo da 0) al quale inserire la pagina.
Passando -1, la pagina verrà inserita alla fine (append);

insert_page_menu(child, tab_label, menu_label, position)

Inserisce una pagina alla posizione specificata, specificando anche il widget da usare come label
nel popup menu.
Parametri:
child: il widget usato come contenuto della pagina;
tab_label: il widget usato come label per la pagina, o None
per utilizzare la label di default “page N”;
menu_label: il widget da usare come label per il page-switch menu,
se questo è abilitato. Se menu_label=None e tab_label è un widget Gtk.Label (o None), allora la
label del menu sarà una nuova label creata con lo stesso testo di tab_label;
se invece tab_label non è una Gtk.Label, menu_label deve essere specificato in caso di utilizzo
del page-switch menu;
position: l’indice (partendo da 0) al quale inserire la pagina.
Passando -1, la pagina verrà inserita alla fine (append);

next_page()

Passa alla pagina successiva. Se siamo già all’ultima, non succede nulla.

page_num(child)

Ritorna l’indice della pagina che contiene il child passato come argomento.
Se il child non è nel notebook, il metodo ritorna -1.

Parametri:
child: il widget di cui vogliamo l’indice nel notebook;

popup_disable()

Disabilita il popup menu.

popup_enable()

Abilita il popup menu: se lo user clicca con il bottone destro sui tabs, apparirà un menu con
tutte le pagine del notebook.

prepend_page(child, tab_label)

Antepone una pagina al notebook.
Parametri:
child: il widget usato come contenuto della pagina;
tab_label: il widget usato come label per la pagina, o None
per utilizzare la label di default “page N”;

prepend_page_menu(child, tab_label, menu_label)

Antepone una pagina al notebook, specificando il widget da usare come label nel popup menu.
Parametri:
child: il widget usato come contenuto della pagina;
tab_label: il widget usato come label per la pagina, o None
per utilizzare la label di default “page N”;
menu_label: il widget da usare come label per il page-switch menu,
se questo è abilitato. Se menu_label=None e tab_label è un widget Gtk.Label (o None), allora la
label del menu sarà una nuova label creata con lo stesso testo di tab_label;
se invece tab_label non è una Gtk.Label, menu_label deve essere specificato in caso di utilizzo
del page-switch menu;

prev_page()

Passa alla pagina precedente. Se siamo nella prima pagina, non succede nulla.

remove_page(page_num)

Rimuove la pagina specificata dall’indice passato come argomento.
Parametri:
page_num: l’indice della pagina del notebook (partendo da 0) da
rimuovere. Se page_num = -1, verrà rimossa l’ultima pagina.

reorder_child(child, position)

Riordina la pagina contenente il child passato in argomento, cosicchè appaia nella posizione
specificata. Se position è maggiore o uguale al numero di children nella lista o -1, il child
specificato verrà spostato alla fine della lista.
Parametri:
child: il widget child da spostare;
position: la nuova positione in cui spostare il child, o -1
per spostare il child alla fine;

set_action_widget(widget, pack_type)

Setta il widget come appartenente al gruppo degli action widgets. A seconda del tipo di pack type,
il widget sarà posizionato prima o dopo i tabs. Nel caso si vogliano impacchettare più widget
dallo stesso lato, utilizzare un widget contenitore come Gtk.Box.
Notare che gli action widgets con child “interni” del notebook, quindi non sono inclusi nella
lista di children ritornata con il metodo Gtk.Container.foreach().
Parametri:
widget: un Gtk.Widget da settare come action widget;
pack_type: il tipo di Gtk.PackType dell’action widget;

set_current_page(page_num)

Passa alla pagina indicata dall’indice passato come argomento. Questa diventa la pagina corrente.
Parametri:
page_num: l’indice della pagina a cui passare (partendo da 0).
Se l’indice è -1, la pagina corrente diventerà l’ultima. Se l’indice è maggiore del numero di
pagine presenti nel notebook, non accadrà nulla.

set_group_name(group_name)

Setta un group name per il notebook. I Notebook con lo stesso group name potranno scambiarsi
i tabs tramite drag and drop.
Parametri:
group_name: il group name da associare al group;

set_menu_label(child, menu_label)

Setta il widget della label, del menu, della pagina contenente il child passato come argomento.
Parametri:
child: il widget usato come contenuto della pagina;
menu_label: il widget della label del menu, o None per il default;

set_menu_label_text(child, menu_text)

Setta il testo della label, del menu, della pagina contenente il child passato come argomento.
Parametri:
child: il widget usato come contenuto della pagina;
menu_text: il testo della label del menu;

set_scrollable(scrollable)

Setta la presenza o meno delle scrolling arrows, in caso ci siano più tabs dello spazio
disponibile nella tab area del notebook.
Parametri:
scrollable: il boolean che settato a True visualizza le scrollable
arrows;

set_show_border(show_border)

Settato a True visualizza il bordo attorno alle pagine del notebook.
Parametri:
show_border: il boolean che settato a True visualizza il bordo;

set_show_tabs(show_tabs)

Settato a True visualizza i tabs.
Parametri:
show_tabs: il boolean che settato a True visualizza i tabs;

set_tab_detachable(child, detachable)

Settato a True permette al tab di essere svincolato dal notebook per un altro notebook o widget.
Ovviamente perchè questo passaggio accada, i due notebooks devono condividere lo stesso name group
(vedi Gtk.Notebook.set_group_name()), così facendo i tabs potranno essere intercambiabili.
Se vogliamo che un widget interagisca con il notebook via Drag and Drop (ad esempio accetti i tabs
trascinati dal notebook stesso), dobbiamo settarlo come drop destination e accettare
il target “GTK_NOTEBOOK_TAB”. Così facendo il notebook salverà sulla selection
(Gtk.SelectionData) il child widget corrispondente al tab rimosso dal notebook.
Quando dovremo rimuovere il tab dal notebook (source), per completare l’operazione di drag and
drop sul widget (destination), dovremo utilizzare il metodo Gtk.Notebook.detach_tab().
Il drag and drop tra differenti notebook non è automatico, quindi dovremo codificarlo manualmente.
Parametri:
child: il widget che vogliamo rendere svincolabile;
detachable: il boolean che settato a True rende il tab detachable;

set_tab_label(child, tab_label)

Modifica il widget della label del tab, del child passato come argomento.
Se tab_label è None verrà utilizzata la label di default “page N”.
Parametri:
child: il widget usato per il contenuto della pagina;
tab_label: il widget della label del tab, o None per il default;

set_tab_label_text(child, tab_text)

Modifica il testo della label del tab, del child passato come argomento.
Parametri:
child: il widget usato per il contenuto della pagina;
tab_text: il testo della label;

set_tab_pos(pos)

Setta la posizione dove verranno visualizzati i tabs per spostarsi tra le pagine.
Parametri:
pos: l’enum Gtk.PositionType che indica il bordo dove verranno
visualizzati i tabs. I valori di Gtk.PositionType possono essere:
LEFT (0): i tabs vengono visualizzati sul bordo sinistro del notebook;
RIGHT (1): i tabs vengono visualizzati sul bordo destro del notebook;
TOP (2): i tabs vengono visualizzati nella parte superiore del notebook;
BOTTOM (3): i tabs vengono visualizzati nella parte inferiore del notebook;

set_tab_reorderable(child, reorderable)

Settato a True rende il tab del child passato come argomento, riordinabile tramite drag and drop.
Parametri:
child: il widget usato per il contenuto della pagina;
reorderable: il boolean che rende il tab riordinabile o meno;

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="Simple Notebook Example")
        self.set_border_width(3)
        self.set_default_size(200, 200)

        notebook = Gtk.Notebook.new()
        notebook.popup_enable()

        page_1 = Gtk.Box()
        page_1.set_border_width(10)
        page_1.add(Gtk.Label(label='Default Page!'))
        notebook.append_page_menu(child=page_1,
                                  tab_label=Gtk.Label(label='Plain Title'),
                                  menu_label=Gtk.Label(label='First Page'))
        page_2 = Gtk.Box()
        page_2.set_border_width(10)
        page_2.add(Gtk.Label(label='A page with an image for a Title.'))
        image = Gtk.Image.new_from_icon_name("go-next", Gtk.IconSize.MENU)
        notebook.append_page_menu(child=page_2, tab_label=image,
                                  menu_label=Gtk.Label(label='Second Page'))
        notebook.set_tab_reorderable(page_2, True)

        self.add(notebook)
        #bindings
        notebook.connect("switch-page", self.on_change_cur_page)

    def on_change_cur_page(self, notebook, page, page_num):
        print("INFO: current page is '%s'" % notebook.get_menu_label_text(page))


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 Notebook

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