bancaldo.altervista.org
Open in
urlscan Pro
104.21.75.212
Public Scan
Submitted URL: https://www.bancaldo.altervista.org/
Effective URL: https://bancaldo.altervista.org/
Submission: On August 21 via automatic, source certstream-suspicious — Scanned from US
Effective URL: https://bancaldo.altervista.org/
Submission: On August 21 via automatic, source certstream-suspicious — Scanned from US
Form analysis 1 forms found in the DOM
GET https://bancaldo.altervista.org
<form action="https://bancaldo.altervista.org" method="get">
<div class="content">
<input type="text" class="textfield searchtip" name="s" size="24" value="">
<input type="submit" class="button" value="">
</div>
</form>Text Content
BANCALDO™
I n t e r d i b i l e
* Home
* Statuto F.C.Inter 1908
* Grosso Guaio a ChinaTown
*
PYGOBJECT: GTK.BUILDER
13 Aprile 2020 bancaldo Commenti chiusi
torna all’indice appunti
Builder
Un Gtk.Builder è un oggetto che legge una descrizione testuale di una UI e ne
istanzia gli
oggetti, in essa descritti.
Per creare un Gtk.Builder da una descrizione testuale, si utilizza il metodo
Gtk.Builder.new_from_file(), se la stringa che descrive la UserInterface è
contenuta in un file, oppure Gtk.Builder.new_from_resource(), oppure
Gtk.Builder.new_from_string() se abbiamo un’unica stringa descrittiva.
Il Gtk.Builder tiene un riferimento di tutti gli oggetti che crea fino a che non
finalizza la UI.
Le funzioni Gtk.Builder.get_object() e Gtk.Builder.get_objects()
vengono usate per accedere ai widgets della UI, grazie ai nomi assegnati ad essi
all’interno della
descrizione testuale della UI.
Le Toplevel windows ritornate da queste funzioni rimarranno “vive” fino a chè
l’utente non le
distruggerà esplicitamente con il metodo Gtk.Widget.destroy().
Se la UI definition viene inserita in un file, è convenzione dara a tale file,
estensione “.ui”
Faremo riferimento a questa descrizione come “Gtk.Builder UI definitions” e non
sarà da confondere
con “GtkUIManager UI Definitions”, che è molto più limitata.
Gtk.Builder UI definitions Syntax
Gtk.Builder esegue l’analisi (parsing) della descrizione testuale della UI in
formato XML secondo
lo schema seguente:
L’elemento toplevel è
1
<interface>
.
Opzionalmente accetta un attributo “domain” che farà cercare al builder le
stringhe tradotte in
base al dominio specificato. Questo si ottiene anche chiamando il metodo
Gtk.Builder.set_translation_domain().
Gli oggetti sono descritti nei tag , che possono contenere elementi , che
descrivono le proprietà
degli oggetti (elementi), che connettono i segnali agli handlers, ed elementi ,
che descrivono i
child objects (molto spesso i widgets dentro ai contenitori, ma anche le actions
dentro agli
action group, o le colonne nel tree-model).
Banalmente un elemento contiene un altro elemento elemento che descrive il child
object.
La versione del toolkit viene descritta dall’elemento
1
<requires>
.
L’attributo “lib” specifica la libreria dei widget (attualmente l’unica
supportata è “gtk+”).
L’attributo “version” specifica la versione in formato
1
<major>.<minor>
.
Se i requisiti di versione non vengono raggiunti, il builder darà errore.
Il tipo di oggetto rappresentato da un elemento viene specificato dall’attributo
“class”.
Se il tipo di oggetto non è ancora stato caricato, GTK+ tenta di trovare il
metodo
get_type() dal nome della classe; questo funziona quasi sempre, in caso
contrario
è possibile specificare il nome della funzione get_type() esplicitamente, usando
l’attributo
“type-func”.
Come caso speciale, Gtk.Builder permette di usare un oggetto che è stato
costruito da un
Gtk.UIManager in un’altra parte della definizione UI, specificando l’id del
Gtk.UIManager nell’attributo “constructor” ed il nome dell’oggetto,
nell’attributo “id”.
Agli oggetti è possibile dare un nome con l’attributo “id”, che a sua volta
permette all’app di
recuperare l’oggetto, tramite il medodo del builder Gtk.Builder.get_object(id).
Il settaggio delle properties degli oggetti è molto semplice grazie all’elemento
1
<property>
.
L’attributo “name” è il nome della property e il contenuto dell’elemento, il suo
valore.
Se l’attributo “translatable” è settato a True, GTK+ userà gettext()
(o dgettext() se il builder ha settato un translation domain) per la traduzione
del valore.
Gtk.Builder può fare l’analisi di testi che rappresentino i tipi più comuni di
properties:
caratteri, stringhe, interi, numeri floating-point, booleans (stringhe come
“True”, “t”, “yes”,
“y”, “1” sono interpretate come True, mentre stringhe come “False”, “f”, “no”,
“n”, “0”,
interpretate come False), enums (possono essere specificati con il loro “name”,
“nick” o
valore intero), flags (possono essere specificate dal loro “name”, “nick”,
valore intero,
opzionalmente combinate con “|”, ad esempio “GTK_VISIBLE|GTK_REALIZED”) e colori
(in un formato
leggibile con Gdk.RGBA.parse()).
GVariants vengono specificati nel formato leggibile da GLib.Variant.parse(), e
pixbufs specificati come filename di un file immagine da caricare.
I Signal handlers sono settati con l’elemento
1
<signal>
.
L’attributo “name” specifica il nome del segnale, e l’attributo “handler”,
specifica la funzione
da connettere al segnale.
A volte è necessario fare riferimento a widget che sono stati costruiti in
maniera implicita da
GTK+ come parte di un widget composto, per settare le properties su di essi
aggiungere ulteriori
children (ad esempio il vbox di un Gtk.Dialog).
Questo può essere ottenuto settando la property “internal-child” dell’elemento a
True.
I widgets hanno posti diversi dove aggiungere un child (ad esempio i contenuti
di tabs e page nei
notebooks). Questo può essere definito nella “UI definition” specificando
l’attributo “type”
nell’elemento
1
<child>
.
Un esempio di UI Definition per Gtk.Builder
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
<interface>
<object class="GtkDialog" id="dialog1">
<child internal-child="vbox">
<object class="GtkBox" id="vbox1">
<property name="border-width">10</property>
<child internal-child="action_area">
<object class="GtkButtonBox" id="hbuttonbox1">
<property name="border-width">20</property>
<child>
<object class="GtkButton" id="ok_button">
<property name="label">gtk-ok</property>
<property name="use-stock">TRUE</property>
<signal name="clicked" handler="ok_button_clicked"/>
</object>
</child>
</object>
</child>
</object>
</child>
</object>
</interface>
Le properties principali sono:
Name Type Flags Short Description translation-domain str r/w Il translation
domain usato da gettext()
Metodi
Oltre ai soliti getter e setter relativi alle properties dell’oggetto
Gtk.Builder,
i principali metodi sono:
new()
Crea un nuovo oggetto Gtk.Builder vuoto.
Questo metodo è utile nel caso si vogliano caricare porzioni di descrizione
derivanti da fonti
diverse, con metodi come Gtk.Builder.add_from_file(),
Gtk.Builder.add_from_resource(), o Gtk.Builder.add_from_string().
Qualora la sorgente dovesse essere unica, sarebbero più comodi i class_methods
Gtk.Builder.new_from_file(), Gtk.Builder.new_from_resource(),
o Gtk.Builder.new_from_string().
new_from_file(filename)
Costruisce la UI definition presente nel filename passato come argomento.
Parametri:
filename: il nome del file contenente la UI description
new_from_resource(resource_path)
Costruisce la UI definition presente alla resource_path.
Parametri:
resource_path: l’oggetto Gio.Resource con il resource path;
new_from_string(string, length)
Costruisce la UI definition descritta dalla stringa.
Parametri:
string: la stringa contenente la UI definition (XML);
length: la lunghezza della stringa, o -1 se la stringa è None-terminated;
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
>>> TOOLBAR_INFO = """
... <?xml version="1.0" encoding="UTF-8"?>
... <interface>
... <!-- interface-requires gtk+ 3.0 -->
... <object class="GtkToolbar" id="toolbar">
... <property name="visible">True</property>
... <property name="can_focus">False</property>
... <property name="hexpand">True</property>
... <property name="show_arrow">False</property>
... <child>
... <object class="GtkToolButton" id="new_button">
... <property name="use_action_appearance">False</property>
... <property name="visible">True</property>
... <property name="can_focus">False</property>
... <property name="use_action_appearance">False</property>
... <property name="is_important">True</property>
... <property name="action_name">win.new</property>
... <property name="label" translatable="yes">New</property>
... <property name="use_underline">True</property>
... <property name="stock_id">gtk-new</property>
... </object>
... <packing>
... <property name="expand">False</property>
... <property name="homogeneous">True</property>
... </packing>
... </child>
... </object>
... </interface>
... """
>>> builder = Gtk.Builder.new_from_string(TOOLBAR_INFO, -1)
add_callback_symbol(callback_name, callback_symbol)
Aggiunge il callback_symbol allo scope del builder sotto il nome della callback.
Questo metodo sovrascrive cioò che è stato settato con il metodo
Gtk.Builder.connect_signals(),
per ogni callback symbols che viene aggiunto.
L’utilizzo di questo metodo permette un miglior incapsulamento inquanto non
occorre dichiarare i
callback symbols nel global namespace.
Parametri:
callback_name: il nome della callback, come previsto nell’XML;
callback_symbol: il GObject.Callback, ovver il callback pointer;
add_from_file(filename)
Esegue l’analisi di un file contenente una UI definition e la unisce con il
contenuto corrente del
builder. Se la UI definition risiede in un unico file è consigliabile l’utilizzo
di
Gtk.Builder.new_from_file().
Parametri:
filename: il nome file di cui analizziamo il contenuto (parsing);
add_from_resource(resource_path)
Analizza un resource file con una UI definition e la unisce al contenuto
corrente del builder.
Se la UI definition risiede in un unico resource file è consigliabile l’utilizzo
di
Gtk.Builder.new_from_resource().
Parametri:
resource_path: il percorso del resource file da analizzare;
add_from_string(buffer, length=-1)
Analizza una stringa contenente una UI definition e la unisce al contenuto
corrente del builder.
Se la UI definition risiede in un unica stringa è consigliabile l’utilizzo di
Gtk.Builder.new_from_string().
Parametri:
buffer: la stringa da analizzare;
length: la lunghezza del buffer;
add_objects_from_file(filename, object_ids)
Analizza un file contenente una UI definition costruendo solo gli oggetti
richiesti e li unisce
al contenuto corrente del builder. Se stiamo aggiungendo un oggetto che dipende
da un oggetto che
non è suo child (ad esempio un Gtk.TreeView che dipende dal proprio
Gtk.TreeModel), dobbiamo
metterlo esplicitamente nella lista object_ids.
Parametri:
filename: il nome del file da analizzare;
object_ids: una lista di stringhe con gli oggetti da costruire;
add_objects_from_resource(resource_path, object_ids)
Analizza un resource file contenente una UI definition costruendo solo gli
oggetti richiesti e li
unisce al contenuto corrente del builder. Se stiamo aggiungendo un oggetto che
dipende da un
oggetto che non è suo child (ad esempio un Gtk.TreeView che dipende dal proprio
Gtk.TreeModel),
dobbiamo metterlo esplicitamente nella lista object_ids.
Parametri:
resource_path: il percorso del resource file da analizzare;
object_ids: la lista “nul-terminated” di stringhe corrispondenti
agli oggetti da costruire;
add_objects_from_string(buffer, object_ids)
Analizza una stringa contenente una UI definition costruendo solo gli oggetti
richiesti e li
unisce al contenuto corrente del builder. Se stiamo aggiungendo un oggetto che
dipende da un
oggetto che non è suo child (ad esempio un Gtk.TreeView che dipende dal proprio
Gtk.TreeModel),
dobbiamo metterlo esplicitamente nella lista object_ids.
Parametri:
buffer: la stringa da analizzare;
object_ids: una lista di stringhe con gli oggetti da costruire;
connect_signals(self, obj_or_map)
Connette i segnali specificati ai rispettivi handler, come indicato nel
dizionario passato come
argomento. L’handler (value) del segnale (key), può anche essere una tupla in
forma
(handler [,arg1 [,argN]]), se all’handler è necessario passare degli argomenti.
esempio di applicazione:
1
builder.connect_signals({'on_clicked': (on_clicked, arg1, arg2)})
Parametri:
obj_or_map: il dizionario dove chiave/valore sono rispettivamente
il segnale e l’handler corrispondente;
connect_signals_full(func, *user_data)
Utilizza una funzione per connettere i segnali.
Parametri:
func: l’oggetto Gtk.BuilderConnectFunc, cioè la funzione usata
per connettere i segnali;
user_data: i dati che possono essere passati alla funzione;
expose_object(name, object)
Aggiunge un oggetto all’ oggetto condiviso del builder cosicchè possa essere
referenziato dagli altri oggetti costruiti dal builder.
Parametri:
name: il nome dell’oggetto “esposto” al builder;
object: l’oggetto da esporre;
get_application()
Ritorna l’oggetto Gtk.Application associato al builder, oggetto utilizzato per
creare i proxies
delle actions come richiesto dall’XML che il builder sta caricando. Di default,
il builder usa
l’application di default (Gio.Application.get_default()).
Se vuoi usare un’altra application per la costruzione dei proxies, usare il
metodo
Gtk.Builder.set_application().
get_object(name)
Ritorna l’oggetto con il nome passato come argomento.
Parametri:
name: il nome dell’oggetto che vogliamo recuperare dal builder;
1
2
3
4
>>> builder.get_object("new_button")
<Gtk.ToolButton object at 0x00000000035b5f40 (GtkToolButton at
0x000000000318d1c0)>
>>> builder.get_object("new_button").get_label()
'New'
get_objects()
Ritorna tutti gli oggetti che sono stati costruiti dal builder.
1
2
3
4
5
>>> for obj in builder.get_objects():
... print(type(obj))
...
<class 'gi.overrides.Gtk.ToolButton'>
<class 'gi.repository.Gtk.Toolbar'>
get_translation_domain()
Ritorna il translation domain del builder.
get_type_from_name(type_name)
Ritorna il tipo di oggetto (GObject.GType) dal nome passato come argomento, o
GObject.TYPE_INVALID
se nessun tipo viene trovato.
Parametri:
type_name: il nome da cui ricavare il tipo di oggetto;
1
2
3
4
>>> builder.get_type_from_name("GtkToolbar")
<GType GtkToolbar (80271280)>
>>> builder.get_type_from_name("GtkToolButton")
<GType GtkToolButton (54634240)>
set_application(application)
Associa l’applicazione al builder.
Questo metodo si usa solo se ci sono più di un oggetto Gio.Application nel
nostro processo.
Parametri:
application: l’oggetto Gtk.Application da associare al builder,
non può essere None;
set_translation_domain(domain)
Setta il translation domain del builder.
Parametri:
domain: la stringa con il translation domain o None;
value_from_string(pspec, string)
Questa funzione converte la rappresentazione XML di un valore, nell’oggetto di
default
(demarshal). In pratica il metodo chiama GObject.Value.init()
sul valore, così non deve essere inizializzato anticipatamente.
Questa funzione può gestire i tipi di valore str, uchar, boolean, int, uint,
long, ulong, enum,
flags, float, double, string, Gdk.Color, Gdk.RGBA e Gtk.Adjustment
Parametri:
pspec: l’oggetto GObject.ParamSpec per la property;
string: la stringa che rappresenta il valore;
value_from_string_type(type, string)
Come il metodo Gtk.Builder.value_from_string(), questo esegue il demarshal di un
valore da una stringa, ma prende un oggetto GObject.GType invece di un oggetto
GObject.ParamSpec.
In pratica il metodo chiama GObject.Value.init() sul valore, così non deve
essere inizializzato anticipatamente.
Parametri:
type: il GObject.GType del valore;
string: la stringa che rappresenta il valore;
Ecco un codice di esempio:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
import gi
gi.require_version('Gtk', '3.0')
from gi.repository import Gtk, Gio
TOOLBAR_INFO = """
<?xml version="1.0" encoding="UTF-8"?>
<interface>
<!-- interface-requires gtk+ 3.0 -->
<object class="GtkToolbar" id="toolbar">
<property name="visible">True</property>
<property name="can_focus">False</property>
<property name="hexpand">True</property>
<property name="show_arrow">False</property>
<child>
<object class="GtkToolButton" id="new_button">
<property name="use_action_appearance">False</property>
<property name="visible">True</property>
<property name="can_focus">False</property>
<property name="use_action_appearance">False</property>
<property name="is_important">True</property>
<property name="action_name">win.new</property>
<property name="label" translatable="yes">New</property>
<property name="use_underline">True</property>
<property name="stock_id">gtk-new</property>
</object>
<packing>
<property name="expand">False</property>
<property name="homogeneous">True</property>
</packing>
</child>
<child>
<object class="GtkToolButton" id="open_button">
<property name="use_action_appearance">False</property>
<property name="visible">True</property>
<property name="can_focus">False</property>
<property name="use_action_appearance">False</property>
<property name="is_important">True</property>
<property name="action_name">win.open</property>
<property name="label" translatable="yes">Open</property>
<property name="use_underline">True</property>
<property name="stock_id">gtk-open</property>
</object>
<packing>
<property name="expand">False</property>
<property name="homogeneous">True</property>
</packing>
</child>
</object>
</interface>
"""
class AppWindow(Gtk.ApplicationWindow):
def __init__(self):
super().__init__(title="Toolbar Example")
self.set_default_size(250, 100)
builder = Gtk.Builder.new_from_string(TOOLBAR_INFO, -1)
act_new = Gio.SimpleAction.new(name='new', parameter_type=None)
act_open = Gio.SimpleAction.new(name='open', parameter_type=None)
self.add_action(act_new)
self.add_action(act_open)
tool_bar = builder.get_object('toolbar')
tool_bar.set_style(Gtk.ToolbarStyle.BOTH)
box = Gtk.Box(orientation=Gtk.Orientation.VERTICAL)
box.pack_start(tool_bar, False, False, 0)
self.add(box)
# bindings
act_new.connect('activate', self.on_menu)
act_open.connect('activate', self.on_menu)
self.connect('destroy', Gtk.main_quit)
def on_menu(self, action, value):
print("INFO: menu <%s>" % action.props.name)
if __name__ == "__main__":
win = AppWindow()
win.connect("destroy", Gtk.main_quit)
win.show_all()
Gtk.main()
link di riferimento:
torna all’indice degli appunti
Gtk3 Builder
Categorie:Gtk3, PyGObject, python Tag: gtk3, PyGObject, python
PYGOBJECT: GTK.IMAGE
13 Aprile 2020 bancaldo Commenti chiusi
torna all’indice appunti
Image
Il widget Gtk.Image visualizza un’immagine.
Generalmente verrà caricato un GdkPixbuf.Pixbuf (“pixel buffer”) da un file.
La classe Gtk.Image fornisce un metodo per fare questa operazione,
Gtk.Image.new_from_file():
1
2
3
4
>>> import gi
... gi.require_version('Gtk', '3.0')
... from gi.repository import Gtk, Gio
>>> image = Gtk.Image.new_from_file("image.png")
Se l’immagine non verrà caricata correttamente, l’oggetto image conterrà una
icona “broken image”.
Come detto in precedenza, caricare un’immagine passando da un oggetto
GdkPixbuf.Pixbuf
permetterà di gestire gli eventuali errori in caricamento:
1
2
3
4
5
6
7
8
>>> from gi.repository import GdkPixbuf
>>> pixbuf = GdkPixbuf.Pixbuf.new_from_file("image.png")
Traceback (most recent call last):
File "<input>", line 1, in <module>
gi.repository.GLib.GError: g-file-error-quark: Apertura del file «image.png» non
riuscita: No such file or directory (4)
>>> # correggiamo il percorso o aggiungiamo il file mancante
>>> pixbuf = GdkPixbuf.Pixbuf.new_from_file("image.png")
>>> image = Gtk.Image.new_from_pixbuf(pixbuf)
Il file image può anche contenere un’animazione, in tal caso Gtk.Image
visualizzerà l’animazione
via GdkPixbuf.PixbufAnimation, invece che un’immagine statica.
L’oggetto Gtk.Image è una sottoclasse di Gtk.Misc, che implica che possiamo
allinearla (center, left, right) e aggiungere il padding ad essa, grazie ai
metodi di Gtk.Misc.
Gtk.Image è un widget “no window”, che significa che non riceve eventi.
Se vogliamo ricevere eventi sull’oggetto image, ad esempio quando clicchiamo
sopra all’immagine,
dobbiamo inserirlo dentro ad un widget Gtk.EventBox,
quindi connettere i segnali all’eventbox stesso.
Le properties principali sono:
Name Type Flags Short Description file str r/w il nome del file da caricare e
visualizzare gicon Gio.Icon r/w La Gio.Icon che sarà visualizzata icon-name str
r/w Il nome dell’icona dell’icon theme icon-size int r/w/en Il Symbolic size da
usare per stock icon, icon set o named icon pixbuf GdkPixbuf.Pixbuf r/w Il
GdkPixbuf.Pixbuf da visualizzare pixbuf-animation GdkPixbuf.PixbufAnimation r/w
il GdkPixbuf.PixbufAnimation da visualizzare pixel-size int r/w/en Pixel size to
use for named icon resource str r/w Il resource path da visualizzare
storage-type Gtk.ImageType r la rappresentazione da usare per i dati immagine
surface cairo.Surface r/w Il cairo.Surface da visualizzare use-fallback bool
r/w/en Se usare gli icon names fallback
Metodi
Oltre ai soliti getter e setter relativi alle properties dell’oggetto Gtk.Image,
i principali metodi sono:
new()
Crea un nuovo widget Gtk.Image vuoto.
new_from_animation(animation)
Crea una Gtk.Image che visualizza l’animazione data.
I frames dell’animazione vengono visualizzati usando un timeout con
GLib.PRIORITY_DEFAULT.
Quando usiamo le animations per indicare che l’applicazione sta lavorando,
ricordarsi che tali
animazioni verranno visualizzate solo se il main loop non è occupato da un
processo con priorità maggiore.
Parametri:
animation: l’oggetto GdkPixbuf.PixbufAnimation con l’animazione;
new_from_file(filename)
Crea un nuovo Gtk.Image che visualizza il file passato come argomento.
Se il file non viene trovato o non può essere caricato, il Gtk.Image risultante
visualizzeà una
icona “broken image” icon.
Questo metodo non ritorna mai None, ma sempre un widget Gtk.Image valido.
Se il file contiene un’animazione, allora il widget image conterrà
un’animazione.
Se vogliamo gestire gli errori di caricamento file (ad esempio l’assenza del
file nel percorso
di ricerca), è necessario usare GdkPixbuf.Pixbuf.new_from_file() per caricare il
file, quindi creare il widget Gtk.Image dal pixbuf precedente.
Per le animazioni, per la stessa ragione, usare
GdkPixbuf.PixbufAnimation.new_from_file().
Parametri:
filename: la stringa con il nome file che contiene l’immagine;
new_from_gicon(icon, size)
Crea un widget Gtk.Image che visualizza una icona dal tema icone corrente.
Se il nome icona non è riconosciuto, verrà visualizzata un’icona di tipo “broken
image”.
Se viene modificato il tema icone, l’icona sarà aggiornata.
Parametri:
icon: un oggetto Gio.Icon che rappresenta un’icona;
size: un oggetto Gtk.IconSize con la dimensionde dell’icona;
new_from_icon_name(icon_name, size)
Crea un widget Gtk.Image che visualizza un’icona da tema icone corrente.
Se il nome icona non è riconosciuto, verrà visualizzata un’icona di tipo “broken
image”.
Se viene modificato il tema icone, l’icona sarà aggiornata.
Parametri:
icon_name: una stringa con il nome icona, o None;
size: un oggetto Gtk.IconSize con la dimensionde dell’icona;
new_from_pixbuf(pixbuf)
Crea un widget Gtk.Image che visualizza un pixbuf.
Questo metodo crea solo un widget Gtk.Image dal pixbuf, ma non reagirà ai
cambiamenti di stato.
E’ consigliabile in tal caso utilizzare Gtk.Image.new_from_icon_name().
Parametri:
pixbuf: il ‘oggetto GdkPixbuf.Pixbuf da cui creare il widget
Gtk.Image, o None;
new_from_resource(resource_path)
Crea un widget Gtk.Image che visualizza il resource file.
Se il file non viene trovato o non può essere caricato, il widget image
risultante, mostrerà
un’immagine di tipo “broken image”.
Questo metodo ritorna sempre un widget Gtk.Image valido e mai None.
Se il file contiene un’animazione, allora il widget image conterrà
un’animazione.
Se vogliamo gestire gli errori di caricamento file (ad esempio l’assenza del
file nel percorso
di ricerca), è necessario usare GdkPixbuf.Pixbuf.new_from_file() per caricare il
file, quindi creare il widget Gtk.Image dal pixbuf precedente.
Per le animazioni, per la stessa ragione, usare
GdkPixbuf.PixbufAnimation.new_from_file().
Parametri:
resource_path: la stringa che rappresenta un resource path;
new_from_surface(surface)
Crea un widget Gtk.Image che visualizza un surface.
Parametri:
surface: un oggetto cairo.Surface o None.
clear()
Svuota il widget Gtk.Image dai suoi contenuti.
get_animation()
Ritorna l’oggetto GdkPixbuf.PixbufAnimation visualizzato dal widget Gtk.Image.
Lo storage type dell’immagine deve essere uno tra Gtk.ImageType.EMPTY,
o Gtk.ImageType.ANIMATION (vedere Gtk.Image.get_storage_type()).
get_gicon()
Ritorna una tupla con gli oggetti Gio.Icon e Gtk.IconSize, del widget Gtk.Image.
Lo storage type dell’immagine deve essere Gtk.ImageType.EMPTY, o
Gtk.ImageType.GICON
(vedere Gtk.Image.get_storage_type()).
get_icon_name()
Ritorna una tupla con il nome dell’icona e l’oggetto Gtk.IconSize delle
dimensioni della stessa.
Lo storage type dell’immagine deve essere Gtk.ImageType.EMPTY, o
Gtk.ImageType.ICON_NAME
(vedere Gtk.Image.get_storage_type()).
get_pixbuf()
Ritorna il GdkPixbuf.Pixbuf visualizzato dal widgetg Gtk.Image.
Lo storage type dell’immagine deve essere Gtk.ImageType.EMPTY, o
Gtk.ImageType.PIXBUF
(vedere Gtk.Image.get_storage_type()).
get_pixel_size()
Ritorna la dimensione in pixel, utilizzata per le named icons.
get_storage_type()
Ritorna il tipo di rappresentazione usato dal Gtk.Image per salvare i dati
dell’immagine.
Se Gtk.Image non ha dati immagine il valore ritornato sarà Gtk.ImageType.EMPTY.
1
2
>>> image.get_storage_type()
<enum GTK_IMAGE_PIXBUF of type Gtk.ImageType>
set_from_animation(animation)
Fa sì che il widget Gtk.Image visualizzi l’animazione data.
Parametri:
animation: l’oggetto GdkPixbuf.PixbufAnimation che rappresenta
l’animazione da visualizzare o None;
set_from_file(filename)
Vedere il class method Gtk.Image.new_from_file().
Parametri:
filename: la stringa con il nome del file o None;
set_from_gicon(icon, size)
Vedere Gtk.Image.new_from_gicon().
Parametri:
icon: un oggetto Gio.Icon che rappresenti un’icona;
size: un oggetto Gtk.IconSize con la dimensione dell’icona;
set_from_icon_name(icon_name, size)
vedere Gtk.Image.new_from_icon_name().
Parametri:
icon_name: la stringa con il nome dell’icona o None;
size: un oggetto Gtk.IconSize con la dimensione dell’icona;
set_from_pixbuf(pixbuf)
Vedere Gtk.Image.new_from_pixbuf().
Parametri:
pixbuf: un oggetto GdkPixbuf.Pixbuf o None;
set_from_resource(resource_path)
Vedere Gtk.Image.new_from_resource().
Parametri:
resource_path: la stringa con il resource path o None;
set_from_surface(surface)
Vedere Gtk.Image.new_from_surface().
Parametri:
surface: un oggetto cairo.Surface o None;
set_pixel_size(pixel_size)
Setta la dimensione in pixel da usare per le named icons. Se il pixel_size viene
settato ad un
valore positivo, tale valore verrà usato al posto dell’icon size settato dal
metodo
Gtk.Image.set_from_icon_name().
Parametri:
pixel_size: la dimensione in pixel da settare per le named icons;
Nota:
siccome Gtk.IconSize è deprecato, per creare un’icona è conveniente passare
attraverso Gtk.IconTheme.
Il procedimento è semplice:
si ottiene il default icon-theme con il metodo Gtk.IconTheme.get_default() e
con l’oggetto Gtk.IconTheme ritornato si chiama il metodo
Gtk.IconTheme.load_icon(icon_name, size, flags), che restituisce l’oggetto
pixbuf
relativo all’icona desiderata.
Infine si creerà il widget Gtk.Image con il metodo
Gtk.Image.new_from_pixbuf(pixbuf).
Di seguito un codice di esempio:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
import gi
gi.require_version('Gtk', '3.0')
from gi.repository import Gtk
class GWindow(Gtk.Window):
def __init__(self):
super().__init__(title="Image example")
box = Gtk.Box(spacing=6)
box.set_homogeneous(True)
default_theme = Gtk.IconTheme.get_default()
for icon_name in ("edit-copy", "edit-paste",
"mail-send-receive-symbolic"):
pixbuf = default_theme.load_icon(icon_name, 64, 0)
icon_image = Gtk.Image.new_from_pixbuf(pixbuf)
box.pack_start(icon_image, True, True, 0)
image = Gtk.Image.new_from_file("image.png")
box.pack_start(image, True, True, 0)
self.add(box)
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 Image
Adwaita icon theme
Categorie:Gtk3, PyGObject, python Tag: gtk3, PyGObject, python
PYGOBJECT: GDKPIXBUF.PIXBUF
13 Aprile 2020 bancaldo Commenti chiusi
torna all’indice appunti
Pixbuf
Il widget GdkPixbuf.Pixbuf è la struttura principale della libreria GdkPixbuf.
Viene usato per rappresentare un’immagine e contiene tutte le informazioni della
stessa come:
i dati dei pixel dell’immagine, il suo color space, i bits per sample,
larghezza e altezza e il rowstride (il numero dibytes tra l’inizio di una riga e
l’inizio della successiva).
Ne consegue che le properties relative alla classe GdkPixbuf.Pixbuf sono:
Name Type Flags Short Description bits-per-sample int r/w/co/en il numero di bit
per sample colorspace GdkPixbuf.Colorspace r/w/co/en Il colorspace nel quale i
samples sono interpretati has-alpha bool r/w/co/en Se il pixbuf ha un canale
alpha height int r/w/co/en il numero di righe del pixbuf n-channels int
r/w/co/en Il numero di samples per pixel pixel-bytes GLib.Bytes r/w/co/en I dati
del pixel ReadOnly pixels int r/w/co/en I pixel data del pixbuf rowstride int
r/w/co/en I bytes tra l’inizio di una riga e l’inizio della successiva width int
r/w/co/en Il numero di colonne del pixbuf
Metodi
Oltre ai soliti getter e setter relativi alle properties dell’oggetto
GdkPixbuf.Pixbuf,
i principali metodi sono:
calculate_rowstride(colorspace, has_alpha, bits_per_sample, width, height)
Calcola il rowstride che un’immagine creata con i parametri passati come
argomenti dovrebbe avere.
Parametri:
colorspace: il GdkPixbuf.Colorspace per l’immagine;
has_alpha: un boolean per avere informazioni sulla trasparenza;
bits_per_sample: il numero di bit per color sample;
width: larghezza dell’immagine in pixels, deve essere > 0;
height: altezza dell’immagine in pixels, deve essere > 0;
get_file_info(filename)
Esegue il parsing di un file immagine e ritorna una tupla con il formato
dell’immagine come
oggetto GdkPixbuf.PixbufFormat e le dimensioni dell’immagine stessa.
Se il formato dell’immagine non viene riconosciuto viene ritornato None e lo
stesso discorso vale per le dimensioni:
1
2
3
4
5
6
7
8
>>> import gi
... gi.require_version('Gtk', '3.0')
... from gi.repository import Gtk
... from gi.repository import GdkPixbuf
>>> GdkPixbuf.Pixbuf.get_file_info("image.png")
(<GdkPixbuf.PixbufFormat object at 0x00000000040c6be0 (GdkPixbufFormat at
0x0000000004fa90c0)>, width=48, height=48)
>>> GdkPixbuf.Pixbuf.get_file_info("unknown.png")
(None, width=0, height=0)
Parametri:
filename: il nome del file da identificare;
get_file_info_async(filename, cancellable, callback, *user_data)
In modo asincrono esegue il parsing di un file immagine e ritorna una tupla
contenente il formato
e le dimensioni dell’immagine. Per maggiorni dettagli vedi
GdkPixbuf.Pixbuf.get_file_info(),
che è la versione sincrona di questo metodo.
Quando l’operazione è terminata la callback in argomento, verrà chiamata nel
thread principale.
A quel punto si chiamerà il metodo GdkPixbuf.Pixbuf.get_file_info_finish() per
avere il risultato.
Parametri:
filename: la stringa con il nome del file da identificare;
cancellable: un oggetto Gio.Cancellable opzionale o None;
callback: una callback Gio.AsyncReadyCallback da invocare quando
le informazioni dell’immagine sono disponibili, o None;
user_data: i dati opzionali da passare alla callback;
get_file_info_finish(async_result)
Termina un’operazione di parsing asincrona, iniziata con
GdkPixbuf.Pixbuf.get_file_info_async() e
ritorna un oggetto GdkPixbuf.PixbufFormat che descrive il formato dell’immagine
del file, o
None se il file non è stato riconosciuto.
Parametri:
async_result: un oggetto Gio.AsyncResult;
get_formats()
Ritorna la lista degli oggetti GdkPixbuf.PixbufFormat,
che rappresentano i formati supportati dal pixbuf.
1
2
3
4
5
6
7
8
9
10
>>> for format in GdkPixbuf.Pixbuf.get_formats():
... print(format.get_description())
...
WMF
EMF
Windows animated cursor
BMP
GIF
MacOS X icon
...
init_modules(path)
Inizializza i moduli del loader di gdkpixbuf referenziati dal file loaders.cache
presente nella
directory.
Parametri:
path: la stringa col percorso della directory dove il file
loaders.cache è installato.
new(colorspace, has_alpha, bits_per_sample, width, height)
Crea un nuovo GdkPixbuf.Pixbuf e alloca un buffer per esso. Il buffer ha un
rowstride ottimale:
1
2
3
4
>>> pixbuf = GdkPixbuf.Pixbuf.new(colorspace=colorspace, has_alpha=True,
... bits_per_sample=8, width=48, height=48)
>>> pixbuf.get_rowstride()
192
Parametri:
colorspace: il GdkPixbuf.Colorspace per l’immagine;
has_alpha: un boolean per avere informazioni sulla trasparenza;
bits_per_sample: il numero di bit per color sample;
width: larghezza dell’immagine in pixels, deve essere > 0;
height: altezza dell’immagine in pixels, deve essere > 0;
new_from_bytes(data, colorspace, has_alpha, bits_per_sample, width, height,
rowstride)
Crea un nuovo GdkPixbuf.Pixbuf out of in-memory readonly image data.
Al momento sono supportate solo immagini RGB con 8 bits per sample.
Questa è la variante GLib.Bytes del metodo GdkPixbuf.Pixbuf.new_from_data().
Parametri:
data: i dati immagine in formato 8-bit/sample;
colorspace: il GdkPixbuf.Colorspace per l’immagine;
has_alpha: un boolean per avere informazioni sulla trasparenza;
bits_per_sample: il numero di bit per color sample;
width: larghezza dell’immagine in pixels, deve essere > 0;
height: altezza dell’immagine in pixels, deve essere > 0;
rowstride: distanza in bytes tra gli inizi riga;
new_from_data(data, colorspace, has_alpha, bits_per_sample, width, height,
rowstride, destroy_fn, *destroy_fn_data)
Crea un nuovo GdkPixbuf.Pixbuf out of in-memory image data.
Al momento sono supportate solo immagini RGB con 8 bits per sample.
Dal momento che forniamo un pixel buffer pre allocato, dobbiamo anche
specificare un modo per
liberare quei dati. Questo è ottenuto con una funzione
GdkPixbuf.PixbufDestroyNotify.
Quando un pixbuf è finalizzato la nostra “destroy notification function” viene
chiamata e sarà
incaricata di liberare i dati relativi ai pixel. Vedere anche
GdkPixbuf.Pixbuf.new_from_bytes().
Parametri:
data: i dati immagine in formato 8-bit/sample;
colorspace: il GdkPixbuf.Colorspace per l’immagine;
has_alpha: un boolean per avere informazioni sulla trasparenza;
bits_per_sample: il numero di bit per color sample;
width: larghezza dell’immagine in pixels, deve essere > 0;
height: altezza dell’immagine in pixels, deve essere > 0;
rowstride: distanza in bytes tra gli inizi riga;
destroy_fn: la funzione GdkPixbuf.PixbufDestroyNotify utilizzata
a pixbuf finalizzato, o None se non importa distruggere i dati;
destroy_fn_data: i dati da passare alla destroy notification
function;
new_from_file(filename)
Crea un nuovo pixbuf caricando l’immagine da un file. Il formato del file viene
riconosciuto
automaticamente. Se si dovessere verificare errori nell’operazione, verrà
ritornato None.
Parametri:
filename: la stringa con il nome del file da caricare;
new_from_file_at_scale(filename, width, height, preserve_aspect_ratio)
Crea un nuovo pixbuf caricando l’immagine da un file. Il formato del file viene
riconosciuto
automaticamente. Se si dovessere verificare errori nell’operazione, verrà
ritornato None.
L’immagine sarà scalata sulle dimensioni richieste, opzionalmente preservando
l’aspect ratio.
Quando preserviamo l’aspect ratio, con width=-1 scaliamo l’immagine sull’altezza
data,
con height=-1 scaliamo l’immagine sulla larghezza data.
Se non preserviamo l’aspect ratio, width=-1 o height=-1 significa non scalare
l’immagine su
quella dimensione.
1
2
3
4
5
6
7
8
9
10
11
>>> pixbuf = GdkPixbuf.Pixbuf.new_from_file("image.png")
>>> pixbuf.get_width()
48
>>> pixbuf.get_height()
48
>>> sc_pixbuf = GdkPixbuf.Pixbuf.new_from_file_at_scale("image.png", width=64,
height=82,
...
preserve_aspect_ratio=True)
>>> sc_pixbuf.get_width()
64
>>> sc_pixbuf.get_height() # forced by aspect ratio
64
Parametri:
filename: la stringa con il nome del file da caricare;
width: la larghezza che l’immagine dovrà avere o -1 per non
forzare la dimensione;
height: : l’altezza che l’immagine dovrà avere o -1 per non
forzare la dimensione;
preserve_aspect_ratio il boolean che decide se preservare o meno
l’aspect ratio dell’immagine;
new_from_file_at_size(filename, width, height)
Crea un nuovo pixbuf caricando l’immagine da un file. Il formato del file viene
riconosciuto
automaticamente. Se si dovessere verificare errori nell’operazione, verrà
ritornato None.
L’immagine sarà scalata sulle dimensioni richieste, preservando però l’aspect
ratio,
potrebbe quindi capitare che il pixbuf risultante sia più piccolo rispetto a
larghezza e altezza
richieste, proprio a causa dell’aspect ratio.
Per rispettare in toto le dimensioni richieste senza tenere conto dell’aspect
ratio,
utilizzare il metodo GdkPixbuf.Pixbuf.new_from_file_at_scale().
Parametri:
filename: la stringa con il nome del file da caricare;
width: la larghezza che l’immagine dovrebbe avere;
height: l’altezza che l’immagine dovrebbe avere;
new_from_resource(resource_path)
Crea un nuovo pixbuf caricando un’immagine da una “resource”.
Il formato del file viene riconosciuto
automaticamente. Se si dovessere verificare errori nell’operazione, verrà
ritornato None.
Parametri:
resource_path: la stringa con il path della risorsa;
new_from_resource_at_scale(resource_path, width, height, preserve_aspect_ratio)
Crea un nuovo pixbuf caricando un’immagine da una “resource”.
Il formato del file viene riconosciuto automaticamente.
Se si dovessere verificare errori nell’operazione, verrà ritornato None.
L’immagine sarà scalata sulle dimensioni richieste, opzionalmente preservando
l’aspect ratio.
Quando preserviamo l’aspect ratio, con width=-1 scaliamo l’immagine sull’altezza
data,
con height=-1 scaliamo l’immagine sulla larghezza data.
Se non preserviamo l’aspect ratio, width=-1 o height=-1 significa non scalare
l’immagine su
quella dimensione.
Nota: Lo stream non viene chiuso da questo metodo.
Parametri:
resource_path: la stringa con il path della risorsa;
width: la larghezza che l’immagine dovrà avere o -1 per non
forzare la dimensione;
height: : l’altezza che l’immagine dovrà avere o -1 per non
forzare la dimensione;
preserve_aspect_ratio il boolean che decide se preservare o meno
l’aspect ratio dell’immagine;
new_from_stream(stream, cancellable)
Crea un nuovo pixbuf caricando un’immagine da uno stream in input.
Il formato del file viene riconosciuto automaticamente.
Se si dovessere verificare errori nell’operazione, verrà ritornato None.
Il cancellable può essere usato per abortire l’operazione da un altro thread.
Se l’operazione viene cancellata viene ritornato l’errore
Gio.IOErrorEnum.CANCELLED.
Nota: Lo stream non viene chiuso da questo metodo.
Parametri:
stream: un Gio.InputStream dal quale caricare il pixbuf;
cancellable: un Gio.Cancellable opzionale o None;
new_from_stream_async(stream, cancellable, callback, *user_data)
Crea un nuovo pixbuf in maniera asincrona, caricando un’immagine da uno stream
in input.
Per maggiori dettagli vedere GdkPixbuf.Pixbuf.new_from_stream(), che è la
versione sincrona del
metodo in oggetto. Quando l’operazione è terminata, una callback viene invocata
nel main thread.
E’ possibile quindi chiamare il metodo GdkPixbuf.Pixbuf.new_from_stream_finish()
per ottenere il
risultato di questa operazione.
Parametri:
stream: un Gio.InputStream dal quale caricare il pixbuf;
cancellable: un oggetto Gio.Cancellable opzionale o None;
callback: una callback Gio.AsyncReadyCallback da invocare quando
le informazioni dell’immagine sono disponibili, o None;
user_data: i dati opzionali da passare alla callback;
new_from_stream_at_scale(stream, width, height, preserve_aspect_ratio,
cancellable)
Crea un nuovo pixbuf caricando un’immagine da uno stream in input.
Il formato del file viene riconosciuto automaticamente.
Se si dovessere verificare errori nell’operazione, verrà ritornato None.
Il cancellable può essere usato per abortire l’operazione da un altro thread.
Se l’operazione viene cancellata viene ritornato l’errore
Gio.IOErrorEnum.CANCELLED.
L’immagine sarà scalata sulle dimensioni richieste, opzionalmente preservando
l’aspect ratio.
Quando preserviamo l’aspect ratio, con width=-1 scaliamo l’immagine sull’altezza
data,
con height=-1 scaliamo l’immagine sulla larghezza data.
Se non preserviamo l’aspect ratio, width=-1 o height=-1 significa non scalare
l’immagine su
quella dimensione.
Nota: Lo stream non viene chiuso da questo metodo.
Parametri:
stream: un Gio.InputStream dal quale caricare il pixbuf;
width: la larghezza che l’immagine dovrà avere o -1 per non
forzare la dimensione;
height: : l’altezza che l’immagine dovrà avere o -1 per non
forzare la dimensione;
preserve_aspect_ratio il boolean che decide se preservare o meno
l’aspect ratio dell’immagine;
cancellable: un oggetto Gio.Cancellable opzionale o None;
new_from_stream_at_scale_async(stream, width, height, preserve_aspect_ratio,
cancellable, callback, *user_data)
Crea un nuovo pixbuf in maniera asincrona, caricando un’immagine da uno stream
in input.
Per maggiori dettagli vedere GdkPixbuf.Pixbuf.new_from_stream_at_scale(), che è
la versione
sincrona del metodo in oggetto. Quando l’operazione è terminata, una callback
viene invocata nel
main thread. E’ possibile quindi chiamare il metodo
GdkPixbuf.Pixbuf.new_from_stream_finish() per
ottenere il risultato di questa operazione.
Parametri:
stream: un Gio.InputStream dal quale caricare il pixbuf;
width: la larghezza che l’immagine dovrà avere o -1 per non
forzare la dimensione;
height: : l’altezza che l’immagine dovrà avere o -1 per non
forzare la dimensione;
preserve_aspect_ratio il boolean che decide se preservare o meno
l’aspect ratio dell’immagine;
cancellable: un oggetto Gio.Cancellable opzionale o None;
callback (Gio.AsyncReadyCallback or None) – a Gio.AsyncReadyCallback to call
when the pixbuf is loaded
user_data (object or None) – the data to pass to the callback function
callback: una callback Gio.AsyncReadyCallback da invocare quando
le informazioni dell’immagine sono disponibili, o None;
user_data: i dati opzionali da passare alla callback;
new_from_stream_finish(async_result)
Termina un’operazione asincrona di creazione di un pixbuf iniziata con il metodo
GdkPixbuf.Pixbuf.new_from_stream_async().
Parametri:
async_result: un oggetto Gio.AsyncResult;
new_from_xpm_data(data)
Crea un nuovo pixbuf analizzando i dati XPM in memoria.
Questi dati sono comunemente il risultato dell’inclusione di un file XPM in una
sorgente C.
Parametri:
data: i dati XPM inline;
save_to_stream_finish(async_result)
Termina un’operazione asincrona di salvataggio pixbuf.
Parametri:
async_result: un oggetto Gio.AsyncResult;
add_alpha(substitute_color, r, g, b)
Prende un pixbuf esistente e aggiunge un canale alpha (trasparenza) ad esso.
Se il pixbuf ha già un canale alpha, i valori del canale sono copiati
dall’originale,
altrimenti il canale alpha viene inizializzato a 255 (opacità piena).
Se substitute_color è True, allora ai colori specificati da “r”, “g”, “b”, sarà
assegnata opacità zero. Esempio, se passiamo (255, 255, 255) per il substitute
color,
tutti i pixel bianchi diventeranno completamente trasparenti.
Parametri:
substitute_color: boolean per settare un colore a opacità zero;
Se falso, gli argomenti r, g, b vengono ignorati.
r: il valore Red da sostituire;
g: il valore Green da sostituire;
b: il valore Blue da sostituire;
apply_embedded_orientation()
Prende un pixbuf esistente e controlla che sia presente un’opzione/tag
“orientation”associato,
il quale può essere fornito dal loader jpeg (che legge il teg “exif
orientation”), o dal loader
tiff (che legge il tag tiff orientation e lo compensa per le trasformazioni
eseguite da libtiff).
Se è presente un’opzione/tag “orientation”, verrà eseguita l’appropriata
trasformazione, così
da orientare il pixbuf correttamente. Verrà quindi ritornato il nuovo Pixbuf o
None.
composite(dest, dest_x, dest_y, dest_width, dest_height, offset_x, offset_y,
scale_x, scale_y, interp_type, overall_alpha)
Crea una trasformazione del pixbuf scalandolo secondo “scale_x” e “scale_y” e
traslandolo secondo
gli offset “offset_x” e “offset_y”. Questo da un’immagine nelle coordinate del
pixbuf di
destinazione. Il rettangolo (dest_x, dest_y, dest_width, dest_height) è quindi
“alpha blended” sul
rettangolo corrispondente dell’immagine di destinazione originale.
Quando il rettangolo di destinazione contiene parti non presenti nell’immagine
sorgente,
i dati ai bordi dell’immagine sorgente vengono replicati all’infinito.
Vedere Alpha compositing/blending
Parametri:
dest: il GdkPixbuf.Pixbuf nel quale fare il render del risultato;
dest_x: la coord. X (sx) della regione su cui fare il render;
dest_y: la coord. Y (top) della regione su cui fare il render;
dest_width: la larghezza della regione su cui fare il render;
dest_height: l’altezza della regione su cui fare il render;
offset_x: l’offset (float) in direzione X;
offset_y: l’offset (float) in direzione Y;
scale_x: il fattore di scala (float) in direzione X;
scale_y: il fattore di scala (float) in direzione Y;
interp_type: l’interpolazione GdkPixbuf.InterpType per la trasf.;
overall_alpha: l’alpha totale per l’immagine sorgente (0-255);
composite_color(dest, dest_x, dest_y, dest_width, dest_height, offset_x,
offset_y, scale_x, scale_y, interp_type, overall_alpha, check_x, check_y,
check_size, color1, color2)
Crea una trasformazione del pixbuf scalandola secondo “scale_x” e “scale_y” e
traslandolo secondo
gli offset “offset_x” e “offset_y”, quindi esegue l’alpha blending del
risultato, sul rettangolo
di destinazione (“dest_x”, “dest_y”, “dest_width”, “dest_height”) con un
checkboard dei colori
“color1” e “color2” ed esegue il render sull’immagine di destinazione.
Se l’immagine di sorgente non ha un alpha channel, e overall_alpha=255, viene
usata una
scorciatoia omettendo l’alpha blending ed eseguendo solo la scalatura
dell’immagine.
Parametri:
dest: il GdkPixbuf.Pixbuf nel quale fare il render del risultato;
dest_x: la coord. X (sx) della regione su cui fare il render;
dest_y: la coord. Y (top) della regione su cui fare il render;
dest_width: la larghezza della regione su cui fare il render;
dest_height: l’altezza della regione su cui fare il render;
offset_x: l’offset (float) in direzione X;
offset_y: l’offset (float) in direzione Y;
scale_x: il fattore di scala (float) in direzione X;
scale_y: il fattore di scala (float) in direzione Y;
interp_type: l’interpolazione GdkPixbuf.InterpType per la trasf.;
overall_alpha: l’alpha totale per l’immagine sorgente (0-255);
check_x: l’offset X del checkboard;
check_y: l’offset Y del checkboard;
check_size: il size dei controlli nel checkboard (potenza di 2)
color1: il colore del check al superiore sinistro (checkboard);
color2: il colore dell’altro check;
Vedere GdkPixbuf.Pixbuf.composite_color_simple() per una variante più semplice
di questo metodo.
composite_color_simple(dest_width, dest_height, interp_type, overall_alpha,
check_size, color1, color2)
Crea un nuovo GdkPixbuf.Pixbuf scalandolo con “dest_width x dest_height” ed
eseguendo l’alpha
blending del risultato con un checkboard di colori “color1” e “color2”.
Parametri:
dest_width: la larghezza dell’immagine di destinazione;
dest_height: l’altezza dell’immagine di destinazione;
interp_type: l’interpolazione GdkPixbuf.InterpType per la trasf.;
overall_alpha: l’alpha totale per l’immagine sorgente (0-255);
check_size: il size dei controlli nel checkboard (potenza di 2)
color1: il colore del check al superiore sinistro (checkboard);
color2: il colore dell’altro check;
copy()
Crea un nuovo GdkPixbuf.Pixbuf con una copia delle informazioni presenti nel
pixbuf.
Questo non copia le opzioni settate nel pixbuf originali, per eseguire una copia
completa usare
il metodo GdkPixbuf.Pixbuf.copy_options().
copy_area(src_x, src_y, width, height, dest_pixbuf, dest_x, dest_y)
Copia un’area rettangolare dal pixbuf, al “dest_pixbuf”. La conversione del
formato, avviene in
maniera automatica. Se il rettangolo sorgente si sovrappone al rettangolo di
destinazione sullo
stesso pixbuf, sarà sovrascritto durante la copia, perciò non possiamo usare
questo metodo per
fare lo scroll di un pixbuf.
Parametri:
src_x: La coord. X del rettangolo sorgente;
src_y: La coord. Y del rettangolo sorgente;
width: La larghezza dell’area da copiare;
height: L’altezza dell’area da copiare;
dest_pixbuf: il GdkPixbuf.Pixbuf di destinazione;
dest_x: La coord. X del pixbuf di destinazione;
dest_y: La coord. Y del pixbuf di destinazione;
copy_options(dest_pixbuf)
Copia le coppie key/value relative alle opzioni di un GdkPixbuf.Pixbuf, in un
altro.
Questo è comodo per mantenere i metadata originali dopo aver modificato un file.
Comunque fare attenzione a rimuovere i metadata che abbiamo già applicato, come
ad esempio
l’opzione “orientation” dopo la rotazione dell’immagine.
Parametri:
dest_pixbuf: il GdkPixbuf.Pixbuf su cui copiare le opzioni;
fill(pixel)
Cancella un pixbuf al valore RGBA dato, convertendo il valore RGBA nel formato
pixel del pixbuf.
Il valore alpha sarà ignorato se il pixbuf non ha un alpha channel.
Parametri:
pixel: il pixel RGBA da cancellare (0xffffffff è bianco opaco,
mentre 0x00000000 è nero trasparente)
flip(horizontal)
Capovolge un pixbuf orizzontalmente o verticalmente e ritorna il pixbuf
risultante.
Parametri:
horizontal: il boolean che settato a True
capovolge il pixbuf orizzontalmente, mentre a False, verticalmente;
get_bits_per_sample()
Ritorna il numero di bits per color sample nel pixbuf.
get_byte_length()
Ritorna la lunghezza in bytes dei pixel data.
get_colorspace()
Ritorna il GdkPixbuf.Colorspace del pixbuf.
get_has_alpha()
Ritorna True se il pixbuf ha un alpha channel, altrimenti False.
L’alpha channel è l’informazione relativa all’opacità del pixbuf.
get_height()
Ritorna l’altezza del pixbuf espressa in pixels.
get_n_channels()
Ritorna il numero di canali di un pixbuf.
get_option(key)
Cerca la chiave nel dizionario i opzioni che sono state associate al pixbuf
quando questo è stato
caricato o che potrebbe essere stata settata in seguito con
GdkPixbuf.Pixbuf.set_option().
Alcuni esempi:
Il loader ANI fornisce le opzioni “Title” e “Artist”.
I loaders ICO, XBM, e XPM forniscono le opzioni hot-spot “x_hot” e “y_hot” per
la definizione del
cursore. Il loader PNG fornisce, come opzioni, le coppie chiave/valore
tEXt-ancillary-chunk.
I loaders TIFF e JPEG ritornano un’opzione “orientation” corrispondente al tag
“orientation”
TIFF/Exif (se presente).
Il loader TIFF setta l’opzione “multipage” a “yes” quando un TIFF multi-page
viene caricato.
I loaders JPEG e PNG settano le opzioni “x-dpi” e “y-dpi” se il file contiene
informazioni
sulla densitò di immagine in punti per pollice.
Il loader JPEG setta l’opzione “comment” con il tag EXIF.
Parametri:
key: la stringa con la quale della quale chiediamo il valore;
get_options()
Ritorna un dizionario GLib.HashTable di chiavi/valori contenente le opzioni che
possono essere
state settate, quando il pixbuf è stato caricato o che potrebbero essere state
aggiunte in seguito
con GdkPixbuf.Pixbuf.set_option().
Vedere GdkPixbuf.Pixbuf.get_option() per maggiori dettagli.
get_pixels()
Ritorna i pixel data di un pixbuf.
1
2
>>> pixbuf.get_pixels()
b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0...
get_rowstride()
Ritorna il rowrowstride del pixbuf, ovvero la distanza, in bytes, tra l’inizio
di una riga e
l’inizio della riga successiva.
1
2
3
4
5
6
>>> pixbuf.get_rowstride()
192
>>> len(pixbuf.get_pixels())/pixbuf.get_rowstride()
48.0
>>> pixbuf.get_height()
48
get_width()
Ritorna la larghezza in pixels di un pixbuf.
new_subpixbuf(src_x, src_y, width, height)
Crea un nuovo pixbuf che rappresenta una “sottoregione” del pixbuf in oggetto.
Il nuovo pixbuf condivide i propri pixels con il pixbuf originale, così facendo
la scrittura
di un bixbuf ha effetto su entrambi.
Il nuovo pixbuf mantiene un riferimento sul pixbuf di partenza, così il pixbuf
in oggetto non
verrà finalizzato fino a che il nuovo pixbuf non lo sarà.
Se il pixbuf di partenza è in sola lettura, questo metodo lo forzerà in
scrittura.
Parametri:
src_x: la coordinata X del pixbuf sorgente;
src_y: la coordinata Y del pixbuf sorgente;
width: la larghezza della regione nel pixbuf;
height: l’altezza della regione nel pixbuf;
read_pixel_bytes()
Ritorna un oggetto GLib.Bytes contenente i dati raw del pixel.
Questi dati non devono essere modificati.
Questo metodo permette di saltare la copia implicita che deve essere fatta se il
metodo
GdkPixbuf.Pixbuf.get_pixels() viene chiamato su un pixbuf read-only.
1
2
>>> pixbuf.read_pixel_bytes()
<GLib.Bytes object at 0x000000000396f5e0 (GBytes at 0x0000000004a45960)>
read_pixels()
Ritorna il raw pixel data.
Questi dati non devono essere modificati.
Questo metodo permette di saltare la copia implicita che deve essere fatta se il
metodo
GdkPixbuf.Pixbuf.get_pixels() viene chiamato su un pixbuf read-only.
1
2
>>> pixbuf.read_pixels()
32
remove_option(key)
Rimuove l’opzione (key) dal dizionario delle opzioni/valori creata quando il
pixbuf è stato
caricato. Ritorna True se l’eliminazione va a buon fine.
Parametri:
key: la stringa con il nome dell’opzione (key) da rimuovere;
rotate_simple(angle)
Ruota il pixbuf di un multiplo di 90 gradi e ritorna il risultato in un nuovo
pixbuf.
Se l’angolo è 0, viene ritornata una copia del pixbuf senza rotazione.
Parametri:
angle: il GdkPixbuf.PixbufRotation, cioè quanto ruotare il pixbuf;
saturate_and_pixelate(dest, saturation, pixelate)
Modifica la saturazione e opzionalmente esegue la pixelatura del pixbuf,
mettendo il risultato
dell’operazione nel pixbuf di destinazione.
Se la saturation=1.0 la saturazione non viene modificata.
Con valori minori di 1.0, la saturazione viene ridotta (l’immagine si trasforma
in scala di
grigio); se saturation è maggiore di 1.0, la saturazione viene incrementata
(l’immagine assume
colori più vividi). Se pixelate=True, allora i pixels vengono sbiaditi in un
pattern
“checkerboard” per creare un’immagine pixelata.
Il pixbuf sorgente e di destinazione devono avere lo stesso formato, dimensione
e rowstride.
Parametri:
dest: il GdkPixbuf.Pixbuf su cui piazzare il pixbuf modificato;
saturation: il fattore di saturazione (float);
pixelate: il boolean per pixelare o meno il pixbuf risultante;
save_to_bufferv(type, option_keys, option_values)
Salva il pixbuf in un nuovo buffer nel tipo di formato “jpeg”, “tiff”, “png”,
“ico” o “bmp”.
Parametri:
type: stringa con il nome del formato file;
option_keys: una di chiavi corrispondenti alla opzioni da settare;
option_values: una lista di valori corrispondenti alle opzioni;
save_to_callbackv(save_func, user_data, type, option_keys, option_values)
Salva il pixbuf in una callback nel tipo di formato “jpeg”, “png”, “tiff”, “ico”
o “bmp”.
Se si verifica un errore, viene ritornato False.
Parametri:
save_func: un oggetto GdkPixbuf.PixbufSaveFunc, ovvero una
funzione chiamata per salvare ogni blocco di dati generata dalla routine di
salvataggio;
user_data: i dati da passare alla funzione;
type: stringa con il nome del formato file;
option_keys: una di chiavi corrispondenti alla opzioni da settare;
option_values: una lista di valori corrispondenti alle opzioni;
save_to_streamv(stream, type, option_keys, option_values, cancellable)
Salva il pixbuf in uno stream di output. I formati di file supportati sono
“jpeg”, “tiff”, “png”,
“ico” or “bmp”. Se il pixbuf viene salvato correttamente, il metodo ritorna
True,
altrimenti False.
Parametri:
stream: un Gio.OutputStream su cui salvare il pixbuf;
type: stringa con il nome del formato file;
option_keys: una di chiavi corrispondenti alla opzioni da settare;
option_values: una lista di valori corrispondenti alle opzioni;
cancellable: un Gio.Cancellable opzionale o None;
save_to_streamv_async(stream, type, option_keys, option_values, cancellable,
callback, *user_data)
Salva il pixbuf in uno stream di output in modo asincrono.
Per maggiori dettagli, vedere GdkPixbuf.Pixbuf.save_to_streamv(), che è la
versione sincrona del
metodo in oggetto. Quando l’operazione è terminata la callback sarà chiamata nel
thread
principale e quindi possiamo chiamare GdkPixbuf.Pixbuf.save_to_stream_finish()
per ottenere il
risultato dell’operazione.
Parametri:
stream: un Gio.OutputStream su cui salvare il pixbuf;
type: stringa con il nome del formato file;
option_keys: una di chiavi corrispondenti alla opzioni da settare;
option_values: una lista di valori corrispondenti alle opzioni;
cancellable: un Gio.Cancellable opzionale o None;
callback: un Gio.AsyncReadyCallback da invocare quandi il pixbuf
viene salvato;
user_data: i dati da passare alla callback;
savev(filename, type, option_keys, option_values)
Salva il pixbuf in un file di tipo “jpeg”, “png”, “tiff”, “ico” or “bmp”.
Se il pixbuf viene salvato correttamente, il metodo ritorna True, altrimenti
False.
Parametri:
filename:la stringa con il nome del file da salvare;
type: stringa con il nome del formato file;
option_keys: una di chiavi corrispondenti alla opzioni da settare;
option_values: una lista di valori corrispondenti alle opzioni;
scale(dest, dest_x, dest_y, dest_width, dest_height, offset_x, offset_y,
scale_x, scale_y, interp_type)
Trasforma l’immagine sorgente scalandola su “scale_x” e “scale_y” e imposta
l’offset definito da
“offset_x” e “offset_y”, quindi rappresenta il rettangolo (dest_x, dest_y,
dest_width,
dest_height) dell’immagine risultante, sull’immagine di destinazione,
rimpiazzando i contenuti
precedenti. Se non ci sono esigenze particolari si consiglia l’utilizzo del
metodo
GdkPixbuf.Pixbuf.scale_simple().
Se il rettangolo del sorgente si sovrappone al rettangolo di destinazione sullo
stesso pixbuf,
sarà sovrascritto durante la scalatura generando dei “rendering artifacts”.
Parametri:
dest: il GdkPixbuf.Pixbuf nel quale fare il render del risultato;
dest_x: la coord. X (sx) della regione su cui fare il render;
dest_y: la coord. Y (top) della regione su cui fare il render;
dest_width: la larghezza della regione su cui fare il render;
dest_height: l’altezza della regione su cui fare il render;
offset_x: l’offset (float) in direzione X;
offset_y: l’offset (float) in direzione Y;
scale_x: il fattore di scala (float) in direzione X;
scale_y: il fattore di scala (float) in direzione Y;
interp_type: l’interpolazione GdkPixbuf.InterpType per la trasf.;
scale_simple(dest_width, dest_height, interp_type)
Crea un nuovo GdkPixbuf.Pixbuf contenente una copia del pixbuf scalato a
dest_width x dest_height.
Non influenza il pixbuf di origine. Per avere la massima velocità
nell’operazione, il valore del
tipo di interpolazione deve essere settato a GdkPixbuf.InterpType.NEAREST.
(ma nelle operazioni if you want maximum speed
(but nelle operazioni di ridimensionamento è molto poco efficiente).
Il tipo di interpolazione di default dovrebbe essere
GdkPixbuf.InterpType.BILINEAR, che offre
un rapporto qualità/velocità ragionevole.
Possiamo scalare una porzione di pixbuf, creando un sub-pixbuf
(GdkPixbuf.Pixbuf.new_subpixbuf()).
Se “dest_width” e “dest_height” sono uguali alla larghezza e altezza del pixbuf
di origine,
viene ritornata una copia del pixbuf di origine stesso, evitando la scalatura.
Per scalature e alpha-blending più complicati, consultare rispettivamente i
metodi
GdkPixbuf.Pixbuf.scale() e GdkPixbuf.Pixbuf.composite().
Parametri:
dest_width: la larghezza dell’immagine di destinazione;
dest_height: l’altezza dell’immagine di destinazione;
interp_type: il tipo di interpolazione (GdkPixbuf.InterpType);
set_option(key, value)
Associa un’opzione in forma chiave/valore al GdkPixbuf.Pixbuf.
Se la chiave esiste già nel dizionario delle opzioni, il nuovo valore viene
ignorato ed il metodo
ritorna False.
Parametri:
key: l’opzione (chiave del dizionario) da associare al pixbuf;
value: il valore dell’opzione;
Di seguito un codice di esempio:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
import gi
gi.require_version('Gtk', '3.0')
from gi.repository import Gtk
from gi.repository import GdkPixbuf
class GWindow(Gtk.Window):
def __init__(self):
super().__init__(title="Pixbuf example")
self.set_default_size(300, 150)
box = Gtk.Box(spacing=6)
box.set_homogeneous(True)
pixbuf = GdkPixbuf.Pixbuf.new_from_file("image.png")
image = Gtk.Image.new_from_pixbuf(pixbuf)
pixbuf2 = pixbuf.rotate_simple(90)
pixbuf2.saturate_and_pixelate(pixbuf2, 3.0, True)
image2 = Gtk.Image.new_from_pixbuf(pixbuf2)
s_height = pixbuf.get_height() * 2
s_width = pixbuf.get_width() * 2
pixbuf3 = pixbuf.scale_simple(dest_width=s_width, dest_height=s_height,
interp_type=GdkPixbuf.InterpType.BILINEAR)
image3 = Gtk.Image.new_from_pixbuf(pixbuf3)
box.pack_start(image, True, True, 0)
box.pack_start(image2, True, True, 0)
box.pack_start(image3, True, True, 0)
self.add(box)
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 Pixbuf
Categorie:Gtk3, PyGObject, python Tag: gtk3, PyGObject, python
PYGOBJECT: GIO.SIMPLEACTION
13 Aprile 2020 bancaldo Commenti chiusi
torna all’indice appunti
SimpleAction
Una Gio.SimpleAction, come indica il nome, è una semplice implementazione
dell’interfaccia di
Gio.Action, quindi rappresenta il modo più semplice per creare una Action.
La principale interfaccia di una Action è che può essere attivata con
Gio.Action.activate().
Tale metodo causa l’emissione del segnale “activate”.
Una Action può opzionalmente avere uno stato, che può essere settato utilizzando
il metodo
Gio.Action.change_state().
La classe Gio.Action è responsabile della memorizzazione del nome dell’azione,
del tipo di
parametro, dello stato opzionale e dell’emissione del segnale appropriato quando
lo stato cambia.
L’utilizzo delle Actions è un modo per associare un particolare attività ad un
nome, tale attività
verrà eseguita dall’applicazione o da un widget, semplicemente facendo
riferimento a tale nome.
In questo modo si possono tenere separate la logica dell’azione, dalla UI.
Un tipico esempio di utilizzo di Actions è dato dai Menu.
Le properties principali sono quelle ereditate da Gio.Action:
Name Type Flags Short Description enabled bool r Se la Action può essere
attivata name str r Il nome usato per invocare la Action parameter-type
GLib.VariantType r Il tipo di GLib.Variant passato al metodo activate() state
GLib.Variant r Lo stato in cui si trova la Action state-type GLib.VariantType r
Il tipo di stato tenuto dalla Action
Segnali
I segnale relativi al Gio.SimpleAction sono:
Name Short Description activate Indica che la Action è stata appena attivata
change-state Indica che la Action ha appena ricevuto una richiesta di cambiare
il proprio stato
Il segnale activate si aspetta due parametri, simple_action” e “parameter”.
Basterà connettere la action al segnale “activate” con un handler che tenga
presente di questi
parametri:
1
2
3
4
5
6
7
8
9
>>> import gi
... gi.require_version('Gtk', '3.0')
... from gi.repository import Gtk
... from gi.repository import Gio
>>> action = Gio.SimpleAction.new(name='Bancaldo', parameter_type=None)
action.connect("activate", lambda a, p: print("INFO: action '%s' activated!" %
a.get_name()))
8
>>> action.activate()
INFO: action 'Bancaldo' activated!
Il segnale change-state si aspetta due parametri, simple_action” e “value”.
Basterà connettere la action al segnale “activate” con un handler che tenga
presente di questi
parametri:
1
2
3
4
5
6
7
8
9
10
11
>>> variant = GLib.Variant.new_boolean(True)
>>> stateful_action = Gio.SimpleAction.new_stateful(name="BancaldoStateful",
... parameter_type=None,
... state=variant)
>>> stateful_action.connect("change-state", lambda a, v: print("INFO: '%s' state
changed to %s!" %
(a.get_name(),
v)))
10
>>> stateful_action.change_state(GLib.Variant.new_boolean(True))
INFO: 'BancaldoStateful' state changed to true!
>>> stateful_action.change_state(GLib.Variant.new_boolean(False))
INFO: 'BancaldoStateful' state changed to false!
Metodi
Oltre ai soliti getter e setter relativi alle properties dell’oggetto
Gtk.SimpleAction,
i principali metodi sono:
new(name, parameter_type)
Crea una nuova Action stateless.
Per creare una Action che abbia uno stato, utilizzare il metodo
Gio.SimpleAction.new_stateful().
1
2
3
4
>>> action = Gio.SimpleAction.new(name='Bancaldo', parameter_type=None)
>>> action.get_state()
>>>
Parametri:
name: il nome della Action;
parameter_type: il tipo di parametro (GLib.VariantType o None) che
sarà passato agli handlers del segnale “activate” dell’oggetto Gio.SimpleAction,
o None
per none passare nessun parametro;
new_stateful(name, parameter_type, state)
Crea una nuova stateful Action.
Ovviamente tutti i futuri valori di “state”, devono essere dello stesso
GLib.Variant definito
in fase di costruzione.
1
2
3
4
5
6
7
>>> from gi.repository import GLib
>>> variant = GLib.Variant.new_boolean(True)
>>> stateful_action = Gio.SimpleAction.new_stateful(name="BancaldoStateful",
... parameter_type=None,
... state=variant)
>>> stateful_action.get_state()
GLib.Variant('b', true)
Parametri:
name: il nome della Action;
parameter_type: il tipo di parametro (GLib.VariantType o None) che
sarà passato agli handlers del segnale “activate” dell’oggetto Gio.SimpleAction,
o None
per none passare nessun parametro;
state: lo stato iniziale (GLib.Variant) della Action;
set_enabled(enabled)
Abilita o disabilita una Action. Ovviamente una Action deve essere abilitata per
poter essere
attivata o cambiare il proprio stato dall’esterno.
Parametri:
enabled: il boolean che abilita/disabilita la Action;
set_state(value)
Setta lo stato della Action. Questo metodo aggiorna direttamente la property
“state”.
Non dovrebbe essere chiamato dall’utente per modificare lo stato della Action; è
preferibile utilizzare il metodo Gio.Action.change_state().
1
2
3
4
>>> new_state = GLib.Variant.new_boolean(False)
>>> stateful_action.set_state(new_state)
>>> stateful_action.get_state()
GLib.Variant('b', false)
Parametri:
value: il nuovo GLib.Variant con cui modificheremo lo stato;
set_state_hint(state_hint)
Setta l’hint (suggerimento) dello stato, per la Action.
Parametri:
state_hint: il GLib.Variant (o None) che rappresenta lo state hint
della Action.
1
2
3
4
>>> state_hint = GLib.Variant.new_string("Bancaldo's Boolean")
>>> stateful_action.set_state_hint(state_hint)
>>> stateful_action.get_state_hint()
GLib.Variant('s', "Bancaldo's Boolean")
Ecco un codice di esempio:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
#!/usr/bin/env python3
import gi
gi.require_version('Gtk', '3.0')
from gi.repository import Gtk
from gi.repository import Gio
class AppWindow(Gtk.ApplicationWindow):
def __init__(self):
super().__init__()
self.set_default_size(200, 100)
# actions
act_file = Gio.SimpleAction.new(name='FileNew', parameter_type=None)
act_quit = Gio.SimpleAction.new(name='FileQuit', parameter_type=None)
act_info = Gio.SimpleAction.new(name='AboutInfo', parameter_type=None)
self.add_action(act_file)
self.add_action(act_quit)
self.add_action(act_info)
# model menu
menu_model = Gio.Menu.new()
# 1st menu
menu_file = Gio.Menu.new()
file_new = Gio.MenuItem.new('New', 'win.FileNew')
file_quit = Gio.MenuItem.new('Quit', 'win.FileQuit')
menu_file.append_item(file_new)
menu_file.append_item(file_quit)
# 2nd menu
menu_about = Gio.Menu.new()
about_info = Gio.MenuItem.new('Info', 'win.AboutInfo')
menu_about.append_item(about_info)
menu_model.append_submenu('File', menu_file)
menu_model.append_submenu('About', menu_about)
menu_bar = Gtk.MenuBar.new_from_model(menu_model)
# layout
layout = Gtk.Box(orientation=Gtk.Orientation.VERTICAL)
layout.pack_start(menu_bar, False, False, 0)
self.add(layout)
# bindings
act_file.connect('activate', self.on_menu)
act_quit.connect('activate', self.on_quit)
act_info.connect('activate', self.on_menu)
self.connect('destroy', Gtk.main_quit)
def on_menu(self, action, value):
print('INFO: menu <%s>' % action.props.name)
@staticmethod
def on_quit(action, param):
Gtk.main_quit()
if __name__ == '__main__':
win = AppWindow()
win.connect("destroy", Gtk.main_quit)
win.show_all()
Gtk.main()
link di riferimento:
torna all’indice degli appunti
Gtk3 Gio.Action
GLib.Variant
GLib.VariantType
Categorie:Gtk3, PyGObject, python Tag: gtk3, PyGObject, python
PYGOBJECT: GIO.ACTIONMAP
13 Aprile 2020 bancaldo Commenti chiusi
torna all’indice appunti
ActionMap
L’interfaccia Gio.ActionMap è implementata da Gio.ActionGroup.
Ha la funzione di contenere istanze di Gio.Action.
Un’applicazione comune di questa interfaccia è quella di mappare le actions
provenienti da vari
gruppi (come Gtk.Application e Gtk.ApplicationWindow) utilizzando nomi con
prefissi
identificativi, come ad esempio “app.” e “win.
Attenzione! Gio.ActionMap e Gio.ActionGroup sono Interfacce e non classi con un
metodo costruttore. Non è pertanto possibile costruirne delle istanze
direttamente.
1
2
3
4
5
6
7
8
9
>>> import gi
... gi.require_version('Gtk', '3.0')
... from gi.repository import Gtk
... from gi.repository import Gio
...
>>> action_map = Gio.ActionMap()
Traceback (most recent call last):
File "<input>", line 1, in <module>
NotImplementedError: ActionMap can not be constructed
E’ quindi necessario utilizzare delle classi che, oltre ad implementare la
stessa interfaccia,
mettano a disposizione i metodi costruttori necessari allo scopo:
1
2
3
>>> myapp = Gtk.ApplicationWindow()
>>> action = Gio.SimpleAction.new(name='Bancaldo', parameter_type=None)
>>> myapp.add_action(action)
Non ci sono properties per Gio.ActionMap.
Segnali
Non ci sono segnali per Gio.ActionMap.
Metodi
I principali metodi sono:
add_action(action)
Aggiunge una action all’ActionMap. Se l’ActionMap contiene già una action con lo
stesso nome,
la vecchia action viene rimossa dell’ActionMap stesso.
Parametri:
action: l’oggetto Gio.Action da aggiungere al Gio.ActionMap;
add_action_entries(entries, user_data)
Questo è un metodo che permette di aggiungere ad un Gio.ActionMap, una lista di
Gio.ActionEntry.
Parametri:
entries: la lista di Gio.ActionEntry da agiungere all’ActionMap;
user_data: i dati per le connessioni ai segnali;
lookup_action(action_name)
Ritorna la action con il nome passato come argomento, o None se non ci sono
corrispondenze.
1
2
3
4
5
>>> myapp.lookup_action("Bancaldo")
>>> action = Gio.SimpleAction.new(name='Bancaldo', parameter_type=None)
>>> myapp.add_action(action)
>>> myapp.lookup_action("Bancaldo")
<Gio.SimpleAction object at 0x000000000365bfc0 (GSimpleAction at
0x0000000004b049c0)>
Parametri:
action_name: il nome della action;
remove_action(action_name)
Rimuove la action con il nome passato come argomento, dall’ActionMap.
Parametri:
action_name: il nome della action che vogliamo rimuovere;
– I metodi ereditati da Gio.ActionGroup sono:
action_added(action_name)
Emette il segnale “action-added” di Gio.ActionGroup.
Parametri:
action_name: il nome della action nel gruppo;
action_enabled_changed(action_name, enabled)
Emette il segnale “action-enabled-changed” di Gio.ActionGroup.
Parametri:
action_name: il nome della action nel gruppo;
enabled: il boolean che abilita/disabilita la action;
action_removed(action_name)
Emette il segnale “action-removed” di Gio.ActionGroup.
Parametri:
action_name: il nome della action nel gruppo;
action_state_changed(action_name, state)
Emette il segnale “action-state-changed” di Gio.ActionGroup.
Parametri:
action_name: il nome della action nel gruppo;
state: il nuovo stato GLib.Variant della action;
activate_action(action_name, parameter)
Attiva la action all’interno del gruppo. Se la action si aspetta un parametro,
viene passato
il tipo corretto di parametro richiesto, altrimenti None.
Vedere Gio.ActionGroup.get_action_parameter_type().
Parametri:
action_name: il nome della action nel gruppo;
parameter: i parametri GLib.Variant all’attivazione (o None);
change_action_state(action_name, value)
Cambia lo stato della action con il valore passato come argomento.
La action deve essere stateful e il valore deve essere del tipo corretto.
Vedere Gio.ActionGroup.get_action_state_type().
Parametri:
action_name: il nome della action nel gruppo;
value: il nuovo stato GLib.Variant
get_action_enabled(action_name)
Controlla se la action all’interno del gruppo, è abilitata.
Una action per essere attivata o per poter cambiare il proprio stato, deve
essere abilitata.
Parametri:
action_name: il nome della action nel gruppo;
get_action_parameter_type(action_name)
Ritorna il tipo di parametro che deve essere fornito quando si attiva la action.
Quando si attiva una action usando il metodo Gio.ActionGroup.activate_action(),
il GLib.Variant
passato a questo metodo deve essere lo stesso tipo ritornato dal metodo in
oggetto, se invece
questo metodo ritorna None, allora None dovrà essere passato a
Gio.ActionGroup.activate_action().
Parametri:
action_name: il nome della action nel gruppo;
get_action_state(action_name)
Ritorna lo stato corrente della action con il nome passato come argomento.
Se la action non è stateful allora verrà ritornato None.
Se la action è stateful allora verrà ritornato il tipo di valore che
corrisponderà al tipo
ritornato dal metodo Gio.ActionGroup.get_action_state_type().
Parametri:
action_name: il nome della action nel gruppo;
get_action_state_hint(action_name)
Ritorna un hint (suggerimento) sul range valido di valori per lo stato della
action.
Se la action non è stateful o non è stato settato alcun hint, allora verrà
ritornato None.
Se viene ritornata una lista di GLib.Variant, allora ogni elemento della lista
sarà un possibile
valore dello stato della action.
Se viene ritornata una coppia di GLib.Variant (tupla) allora la tupla
specificherà i valori
minimo e massimo dello stato.
Parametri:
action_name: il nome della action nel gruppo;
get_action_state_type(action_name)
Ritorna il tipo di stato della action.
Se la action è stateful, il metodo ritorna il GLib.VariantType dello stato della
action e tutte le
chiamate al metodo Gio.ActionGroup.change_action_state() devono avere un
GLib.Variant di
questo tipo e Gio.ActionGroup.get_action_state() ritornerà ovviamento lo stesso
tipo di
GLib.Variant. Se la action non è stateful verrà ritornato None.
Parametri:
action_name: il nome della action nel gruppo;
has_action(action_name)
Controlla se la action esiste all’interno dell’ActionGroup.
Parametri:
action_name: il nome della action nel gruppo;
list_actions()
Lista le actions presenti nell’ActionGroup.
query_action(action_name)
Ritorna una ResultTuple con tutti i parametri della action con nome passato come
argomento.
Questo metodo acquisisce tutte le informazioni disponibili da
Gio.ActionGroup.has_action(),
Gio.ActionGroup.get_action_enabled(),
Gio.ActionGroup.get_action_parameter_type(),
Gio.ActionGroup.get_action_state_type(), Gio.ActionGroup.get_action_state_hint()
e
Gio.ActionGroup.get_action_state() con una singola chiamata.
Se la action esiste, viene ritornato True e tutti i valori diversi da None.
Se la action non esiste, viene ritornato False.
1
2
>>> myapp.query_action("Bancaldo")
(True, enabled=True, parameter_type=None, state_type=None, state_hint=None,
state=None)
Parametri:
action_name: il nome della action nel gruppo;
link di riferimento:
torna all’indice degli appunti
Gtk3 Gio.ActionMap
Gtk3 Gio.ActionGroup
Categorie:Gtk3, PyGObject, python Tag: gtk3, PyGObject, python
PYGOBJECT: GTK.EVENTBOX
13 Aprile 2020 bancaldo Commenti chiusi
torna all’indice appunti
EventBox
Un widget Gtk.EventBox è una sottoclasse di Gtk.Bin che possiede una propria
Window.
Viene spesso utilizzato quando vogliamo catturare gli eventi per quei widget che
non possiedono
una propria finestra, come ad esempio le Immagini.
Le properties principali sono:
Name Type Flags Short Description above-child bool r/w/en Se la finestra della
eventbox, si trova sopra la finestra del widget figlio, invece che sotto di essa
visible-window bool r/w/en Se la event box è visibile, anzichè invisibile ed
usata solo per intercettare gli eventi
Segnali
I segnali sono quelli ereditati da Gtk.Container, Gtk.Widget e GObject.Object.
Metodi
Oltre ai soliti getter e setter relativi alle properties dell’oggetto
Gtk.EventBox,
i principali metodi sono:
new()
Crea un nuovo widget Gtk.EventBox.
1
2
3
4
5
6
7
>>> import gi
... gi.require_version('Gtk', '3.0')
... from gi.repository import Gtk
...
>>> image = Gtk.Image.new_from_file("image.png")
>>> eventbox = Gtk.EventBox.new()
>>> eventbox.add(image)
get_above_child()
Ritorna True se la finestra della eventbox è sopra alla window del proprio
child,
altrimenti ritorna False, se si trova sotto.
Vedere Gtk.EventBox.set_above_child() per i dettagli.
get_visible_window()
Ritorna True se la finestra della eventbox è visibile, altrimenti False
Vedere Gtk.EventBox.set_visible_window() per i dettagli.
set_above_child(above_child)
Setta se la finestra dell’event box debba essere posizionato sopra la finestra
del suo widget
child, anzichè sotto. Se la finestra e sopra, tutti gli eventi dentro la event
box andranno alla
eventbox. Se la finestra e sotto, gli eventi nella finestra del child, prima
andranno al child
stesso, poi al suo genitore. Il default è tenere la finestra sotto alla finestra
del child widget.
Parametri:
above_child: il boolean che a True pone la finestra dell’event box
sopra alla finestra del child widget;
set_visible_window(visible_window)
Setta se l’event box debba usare una finestra visibile o invisibile.
Il default è usare una finestra visibile.
In una finestra di event box invisibile, la window creata per l’event box è di
tipo
Gdk.WindowWindowClass.INPUT_ONLY, che significa appunto che è invisibile e serve
solo per
ricevere eventi. Una finestra di event box visibile, è di tipo
Gdk.WindowWindowClass.INPUT_OUTPUT,
cioè che agisce da parent window per tutti i widgets contenuti nell’event box.
Per intercettare solo gli eventi, la finestra di event box dovrebbe essere
invisibile.
Creare una finestra visibile, potrebbe generare anche degli artifacts visibili
all’utente,
specialmente se l’utente sta usando un tema con gradienti o pixmaps.
La ragione di creare un event box non input-only è se vogliamo settare un
background o disegnare
su di essa.
C’è un problema per gli event box invisibili che hanno la loro finestra sotto al
child (vedere
Gtk.EventBox.set_above_child(). Dal momento che la finestra input-only non è una
finestra
genitore di ogni finestra creata dai widgets discendenti dell’event box, gli
eventi su queste
finestre non sono propagati dal windowing system, ma solo da GTK+.
In pratica se un evento non è nell’event mask della finestra discendente (vedere
Gtk.Widget.add_events()), non sarà ricevuta dall’event box.
Questo non succede per gli event box visibili, perchè in tal caso, la finestra
della event box
è genitore delle finestre discendenti.
Parametri:
visible_window: il boolean che rende la finestra dell’event box
visibile;
Ecco un codice di esempio:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
import gi
gi.require_version('Gtk', '3.0')
from gi.repository import Gtk
class GWindow(Gtk.Window):
def __init__(self):
super().__init__(title="EventBox example")
self.set_default_size(250, 100)
image = Gtk.Image.new_from_file("image.png")
eventbox = Gtk.EventBox.new()
eventbox.add(image)
self.add(eventbox)
eventbox.connect("button_press_event", self.on_click)
def on_click(self, widget, param):
print("INFO: clicked on %s" % widget.get_child().get_property("file"))
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 EventBox
Categorie:Gtk3, PyGObject, python Tag: gtk3, PyGObject, python
PYGOBJECT: GTK.ICONVIEW
13 Aprile 2020 bancaldo Commenti chiusi
torna all’indice appunti
IconView
Un Gtk.IconView è un widget che visualizza una collezione di icone in una vista
a griglia.
Supporta il drag and drop, le selezioni multiple e il riordinamento degli
elementi.
Come per il Gtk.TreeView, il Gtk.IconView utilizza un Gtk.ListStore come
modello.
Invece di utilizzare i cell renderers, Gtk.IconView richiede che una delle sue
colonne, nel
proprio Gtk.ListStore, contenga oggetti GdkPixbuf.Pixbuf.
Le properties principali sono:
Name Type Flags Short Description activate-on-single-click bool r/w/en Attiva
una row con single click cell-area Gtk.CellArea r/w/co La Gtk.CellArea usata per
il layout delle celle column-spacing int r/w/en Spazio tra le colonne della
griglia columns int r/w/en Numero delle colonne da visualizzare item-orientation
Gtk.Orientation r/w/en Come sono posizionati testo e icona di ogni elemento
item-padding int r/w/en Padding tra gli elementi dell’icon view item-width int
r/w/en La larghezza usata per ogni elemento markup-column int r/w/en La colonna
del Model usata per il testo se usiamo Pango markup model Gtk.TreeModel r/w Il
model per l’icon view pixbuf-column int r/w/en La colonna del Model usata per i
pixbuf reorderable bool r/w/en la View è riordinabile row-spacing int r/w/en
Spazio tra le righe della griglia selection-mode Gtk.SelectionMode r/w/en Il
selection mode spacing int r/w/en Spazio tra le celle di un elemento text-column
int r/w/en La colonna del Model usata per il testo tooltip-column int r/w/en La
colonna nel model che contiene i testi dei tooltip per gli elementi
Segnali
I principali segnali di Gtk.IconView sono:
Name Short Description activate-cursor-item Un keybinding signal emesso quando
lo user attiva l’elemento in focus item-activated Il segnale “item-activated”
viene emesso quando chiamiamo il metodo Gtk.IconView.item_activated(), quando lo
user fa doppio click
su un elemento con la property “activate-on-single-click” settata a False, o
quando lo user clicca un elemento con property “activate-on-single-click”
settata a True move-cursor il segnale “move-cursor” è un keybinding signal
emesso quando lo user muove il cursore select-all Un keybinding signal emesso
quando lo user seleziona tutti gli elementi select-cursor-item Un keybinding
signal emesso quando lo user seleziona l’elemento in focus selection-changed Il
segnale “selection-changed” viene emesso quando la selezione cambia
toggle-cursor-item Un keybinding signal emesso quando lo user cambia lo stato
dell’elemento (toggle) unselect-all Un keybinding signal emesso quando lo user
deseleziona tutti gli elementi
Metodi
Oltre ai soliti getter e setter relativi alle properties dell’oggetto
Gtk.IconView, i principali metodi sono:
new()
Crea un nuovo widget Gtk.IconView.
1
2
3
4
>>> import gi
... gi.require_version('Gtk', '3.0')
... from gi.repository import Gtk
>>> iconview = Gtk.IconView.new()
new_with_area(area)
Crea un nuovo Gtk.IconView usando l’area specificata per il layout delle celle.
Parametri:
area: il Gtk.CellArea da usare per il layout delle celle;
new_with_model(model)
Crea un nuovo Gtk.IconView con il model passato come argomento.
Parametri:
model: il Gtk.TreeModel, ovvero il model dell’iconview;
convert_widget_to_bin_window_coords(wx, wy)
Converte le coordinate del widget in coordinate per la bin_window, come ci si
aspetta, ad esempio,
da Gtk.IconView.get_path_at_pos().
Parametri:
wx: le coord. X relative al widget;
wy: le coord. Y relative al widget;
create_drag_icon(path)
Crea una rappresentazione cairo.Surface dell’elemento al percorso at path.
Questa immagine è usata per una drag icon.
Parametri:
path (Gtk.TreePath): un Gtk.TreePath nell’iconview;
enable_model_drag_dest(targets, actions)
Rende l’iconview un Drop Destination (drop) durante un DragAndDrop automatico.
La chiamata a questo metodo setta la property “reorderable” si Gtk.IconView a
False.
Parametri:
targets: ([Gtk.TargetEntry]) – the table of targets that the drag will support
actions: (Gdk.DragAction) – the bitmask of possible actions for a drag to this
widget
enable_model_drag_source(start_button_mask, targets, actions)
Rende l’iconview un drag source (drag) per il DragAndDrop automatico.
La chiamata a questo metodo setta la property “reorderable” si Gtk.IconView a
False.
Parametri:
start_button_mask: il Gdk.ModifierType) cioè il mask dei buttons
abilitati ad iniziare il drag;
targets: il Gtk.TargetEntry, cioè la table dei targets che il
drag supporterà;
actions: la Gdk.DragAction, ovvero il bitmask delle possibili
azioni per il drag da questo widget;
get_activate_on_single_click()
Ritorna il settaggio effettuato con Gtk.IconView.set_activate_on_single_click(),
ovvero
ritorna True se l’elemento viene attivato con single click.
get_cell_rect(path, cell)
Ritorna False se non c’è alcun elemento altrimenti True, inoltre ritorna il
Gdk.Rectangle relativo
al path e cellrenderer passati come argomenti.
Parametri:
path: un Gtk.TreePath;
cell: un Gtk.CellRenderer o None;
get_column_spacing()
Ritorna il valore della spaziatura (property “column-spacing”) tra le colonne
dell’iconview.
get_columns()
Ritorna il numero delle colonne (property “columns”).
get_cursor()
Ritorna un boolean, il percorso corrente del cursore e la cella corrente con il
focus.
Il boolean sarà True se il cursore è settato, altrimenti False.
Se il cursore non è settato, il path ritornato sarà None. Se nessuna cella ha il
focus, allora la
cella ritornata sarà None.
get_dest_item_at_pos(drag_x, drag_y)
Determina l’elemento di destinazione in base alla posizione data. Se non ci sono
elementi alla
posizione data, ritorna None, altrimenti un tupla contenente il path
dell’elemento e la posizione
di drop.
Parametri:
drag_x: la posizione X per determinare l’elemento di destinazione;
drag_y: la posizione Y per determinare l’elemento di destinazione;
get_drag_dest_item()
Ritorna le informazioni sull’elemento che è stato evidenziato durante il drag.
Le info sono il path dell’elemento evidenziato (Gtk.TreePath) e la posizione di
drop
(Gtk.IconViewDropPosition)
get_item_at_pos(x, y)
Ritorna una tupla contenente il path (Gtk.TreePath) dell’elemento esistente alla
posizione data e
il renderer responsabile della cella alla posizione data (Gtk.CellRenderer).
Se non esiste alcun elemento alla posizione data, ritorna None.
Il path ritornato è relativo alle coordinate di bin_window.
A differenza di Gtk.IconView.get_path_at_pos(), questo metodo ottiene anche la
cella alla
posizione data.
Parametri:
x: La posizione X da identificare;
y: La posizione Y da identificare;
get_item_column(path)
Ritorna la colonna nella quale è visualizzato l’elemento con il path
specificato.
Parametri:
path: il Gtk.TreePath dell’elemento;
get_item_orientation()
Ritorna la posizione dei testi relativamente alla icone (property
“item-orientation”).
get_item_padding()
Ritorna il padding intorno agli elementi (property “item-padding”).
get_item_row(path)
Ritorna la riga nella quale è visualizzato l’elemento con il path specificato.
Parametri:
path: il Gtk.TreePath dell’elemento;
get_item_width()
Ritorna la larghezza del singolo elemento (property “item-width”).
get_margin()
Ritorna il valore dello spazio (property “margin”) lasciato ai bordi (top,
bottom, left, right)
dell’iconview.
get_markup_column()
Ritorna la colonna dedicata al markup o -1 se non è settata.
get_model()
Ritorna il model (Gtk.TreeModel) su cui si basa il Gtk.IconView.
get_path_at_pos(x, y)
Ritorna il Gtk.TreePath corrispondente all’icona esistente alla posizione data,
o None.
Il path trovato è relativo alle coordinate di bin_window. Vedere
Gtk.IconView.get_item_at_pos(),
se si è interessati anche alla cella presente alla posizione data.
Vedere Gtk.IconView.convert_widget_to_bin_window_coords() per la conversione di
coordinate widget
in coordinate bin_window.
Parametri:
x: La posizione X da identificare;
y: La posizione Y da identificare;
get_pixbuf_column()
Ritorna la colonna dedicata ai Pixbufs o -1 se non è stata settata.
get_reorderable()
Ritorna True se la lista può essere riordinata. Vedere
Gtk.IconView.set_reorderable().
get_row_spacing()
Ritorna il valore della spaziatura (property “row-spacing”) tra righe
dell’iconview.
get_selected_items()
Ritorna la lista (GLib.List) con i paths (Gtk.TreePath) di tutti gli elementi
selezionati.
get_selection_mode()
Ritorna il selection mode (Gtk.SelectionMode) dell’iconview.
get_spacing()
Ritorna il valore della spaziatura (property “spacing”) tra le celle di un
elemento,
ad esempio lo spazio che c’è tra l’icona e il testo.
get_text_column()
Ritorna la colonna dedicata al testo o -1 se non è stata settata.
get_tooltip_column()
Ritorna la colonna dedicata al tooltip delle righe dell’iconview o -1 se non è
stata settata.
get_tooltip_context(x, y, keyboard_tip)
Ritorna un boolean che indica se il tooltip dato punta ad un elemento, la
coordinata X,
la coordinata Y, il model (Gtk.TreeModel), il path (Gtk.TreePath),
l’iter(Gtk.TreeIter).
I valori x, y e keyboard_tip che sono ricevuti nel signal handler, devono essere
passati a
questo metodo. In pratica il valore ritornato indica se esiste un elemento
dell’iconview alle
coordinate date (True) o meno (False) per i mouse tooltips.
Per i keyboard tooltips l’elemento ritornato sarà l’elemento del cursore.
Parametri:
x: la coordinata X relativa alle coordinate del widget;
y: la coordinata Y relativa alle coordinate del widget;
keyboard_tip: True se è un keyboard tooltip altrimenti False;
get_visible_range()
Ritorna None se non c’è un range visible, oppure una tupla contenente: l’inizio
della regione,
la fine della regione: (start_path: Gtk.TreePath, end_path: Gtk.TreePath).
item_activated(path)
Attiva l’elemento determinato dal path passato come argomento.
Parametri:
path: il Gtk.TreePath dell’elemento da attivare;
path_is_selected(path)
Ritorna True se l’icona a cui punta il path è selezionata.
Se il path non punta ad una posizione valida, viene ritornato False.
Parametri:
path: il Gtk.TreePath da controllare;
scroll_to_path(path, use_align, row_align, col_align)
Parametri:
path: (Gtk.TreePath) – The path of the item to move to.
use_align: (bool) – whether to use alignment arguments, or False.
row_align: (float) – The vertical alignment of the item specified by path.
col_align: (float) – The horizontal alignment of the item specified by path.
Muove gli alignments dell’iconview alla posizione specificata da path.
row_align determina dove la row è posizionata, e col_align determina la colonna.
Entrambe richiedono valori tar 0.0 e 1.0, dove 0.0 sta per left/top alignment,
1.0 sta per
right/bottom alignment, 0.5 sta per centrato.
Se use_align è False, gli argomenti alignment vengono ignorati, e il tree
richiederà un lavoro
minimo per scorrere l’elemento. Se l’elemento è già visibile a schermo, non
succederà nulla.
Questo metodo funziona solo se è settato un model e path è una riga valida del
model.
Se il model cambia prima che l’iconview venga generato, il path centrato, verrà
modificato
per essere coerente con la modifica del model.
select_all()
Seleziona tutte le icone.
select_path(path)
Seleziona la riga con il path passato come argomento.
Parametri:
path: il Gtk.TreePath da cui selezionare la riga;
selected_foreach(func, *data)
Chiama una funzione per ogni icona selezionata. Il model non può essere
modificato all’interno
di questa funzione.
Parametri:
func: la Gtk.IconViewForeachFunc, ovvero la funzione da chiamare
per ogni icona selezionata;
data: i dati da passare alla funzione;
set_activate_on_single_click(single)
Causa l’emissionde del segnale “item-activated” con un single click invece che
con doppio click.
Parametri:
single: il boolean che settato a True emette un segnale
“item-activated” su un single click;
set_column_spacing(column_spacing)
Setta la property “column-spacing” che specifica la spaziatura tra le colonne
dell’iconview.
Parametri:
column_spacing: il valore della spaziatura tra colonne;
set_columns(columns)
Setta la property “columns” che determina quante colonne sono presenti
nell’iconview.
Se columns è -1, il numero di colonne sarà scelto automaticamente per riempire
l’area disponibile.
Parametri:
columns: il numero di colonne presenti nell’iconview;
set_cursor(path, cell, start_editing)
Setta il corrente keyboard focus a path, e lo seleziona.
Questo è comodo quando vogliamo richiamare l’attenzione dell’utente mettendo il
focus su
un determinato elemento. Se cell non è None, il focus viene dato alla cella
stessa.
Se start_editing è True, l’editing verrà iniziato nella cella specificata.
Parametri:
path: il Gtk.TreePath o None;
cell: il Gtk.CellRenderer o None;
start_editing: True se la cella specificata deve essere editata;
set_drag_dest_item(path, pos)
Setta l’elemento che viene evidenziato per il feedback.
Parametri:
path: il Gtk.TreePath (o None) dell’elemento da evidenziare;
pos: il Gtk.IconViewDropPosition che specifica dove eseguire il
drop, relativo all’elemento;
set_item_orientation(orientation)
Setta la property “item-orientation” che determina se le label sono disegnate a
fianco delle
icone, invece che sotto.
Parametri:
orientation: il Gtk.Orientation ovvero la posizione dei testi
rispetto alle icone. Il valore dell’enum Gtk.Orientation può essere
Gtk.Orientation.VERTICAL e
Gtk.Orientation.HORIZONTAL;
set_item_padding(item_padding)
Setta la property di Gtk.IconView “item-padding” che specifica il padding
attorna ad ogni elemento
dell’iconview.
Parametri:
item_padding: il padding attorno ad ogni elemento;
set_item_width(item_width)
Setta la property “item-width” che specifica la larghezza da usare per ogni
elemento.
Se viene settata a -1, l’iconview determinerà automaticamente la dimensione più
adatta.
Parametri:
item_width: la larghezza di ogni elemento;
set_margin(margin)
Setta la property “margin” che specifica lo spazio inserito ai bordi (top,
bottom, left, right)
dell’iconview.
Parametri:
margin: il valore del margine da settare;
set_markup_column(column)
Setta la colonna con le info di markup per l’iconview. La colonna di markup deve
essere di tipo
GObject.TYPE_STRING.
Parametri:
column: l’indice della colonna da settare o -1 per non
visualizzare il markup text;
set_model(model)
Setta il model del Gtk.IconView. Se l’iconview ha già un model settato, questo
verrà rimosso prima
di settare il model nuovo. Se model è None, allora verrà rimosso il vecchio
model.
Parametri:
model: il Gtk.TreeModel (o None) dell’iconview;
set_pixbuf_column(column)
Parametri:
column: l’indice della colonna da settare per i pixbufs o -1
per disabilitarla;
Setta la colonna con i pixbufs
set_reorderable(reorderable)
Parametri:
reorderable: True se la lista di elementi può essere riordinata;
Questo metodo permette di riordinare models che supportano
Gtk.TreeDragSourceIface e
Gtk.TreeDragDestIface. Sia Gtk.TreeStore che Gtk.ListStore supportano questa
funzionalità.
Se reorderable è True, lo user può riordinare il model facendo drag and drop con
le righe.
E’ possibile intercettare tali cambiamenti collegando i segnali del model
“row_inserted” e
“row_deleted”. Il riordinamento è implementato settando l’iconview come drag
source
e destination.
set_row_spacing(row_spacing)
Setta la property “row-spacing” che specifica la spaziatura tra le righe
dell’iconview.
Parametri:
row_spacing: il valore della spaziatura tra le righe;
set_selection_mode(mode)
Setta il selection mode dell’iconview. I valori dell’enum Gtk.SelectionMode
possono assumere i
seguenti valori:
NONE (0): nessuna selezione è possibile;
SINGLE (1): nessuno o un elemento solo può essere selezionato;
BROWSE (2): esattamente un elemento può essere selezionato;
MULTIPLE (3): può essere selezionato qualsiasi numero di elementi;
Parametri:
mode: il Gtk.SelectionMode dell’iconview.
set_spacing(spacing)
Setta la property “spacing” che specifica la spaziatura presente tra le celle di
un elemento
(ad esempio tra icona e testo).
Parametri:
spacing: il valore della spaziatura tra le celle di un elemento;
set_text_column(column)
Setta la colonna con il testo, e deve essere di tipo GObject.TYPE_STRING.
Parametri:
column: l’indice della colonna del model con il testo o -1 per
non visualizzare il testo;
set_tooltip_cell(tooltip, path, cell)
Setta la tip area del tooltip. Vedere anche Gtk.Tooltip.set_tip_area() o, per
una semplice
alternativa, Gtk.IconView.set_tooltip_column().
Parametri:
tooltip: il Gtk.Tooltip da settare;
path: il Gtk.TreePath;
cell: il Gtk.CellRenderer (o None) su cui settare il tooltip;
set_tooltip_column(column)
Se vogliamo avere tooltips semplici (solo testo) a pieno elemento, possiamo
usare questo metodo
per far gestire i tooltip automaticamente dal Gtk.IconView.
column deve essere settata alla colonna del model che contiene i testi dei
tooltipis, o -1 per
disabilitare questo aspetto. Quando abilitato, la property “has-tooltip” di
Gtk.Widget sarà
settata a True e l’iconview sarà connesso all’handler del segnale
“query-tooltip” di Gtk.Widget.
Nota: l’handler di segnale setta il testo con il metodo
Gtk.Tooltip.set_markup(), così facendo
è necessario l’escape dei caratteri quali &, <. Parametri:
column: l’indice della colonna per i tooltips;
set_tooltip_item(tooltip, path)
Setta la tip area del tooltip per essere coperta dall’elemento con percorso
path.
Vedere anche Gtk.IconView.set_tooltip_column() per una semplice alternativa, o
Gtk.Tooltip.set_tip_area().
Parametri:
tooltip: il Gtk.Tooltip;
path: il Gtk.TreePath dell’elemento che coprirà il tooltip;
unselect_all()
Deseleziona tutte le icone.
unselect_path(path)
Deseleziona la riga di percorso path.
Parametri:
path: il Gtk.TreePath della row da deselezionare;
unset_model_drag_dest()
Annulla l’effetto di Gtk.IconView.enable_model_drag_dest().
La chiamata a questo metodo setta la property “reorderable” a False.
unset_model_drag_source()
Annulla l’effetto di Gtk.IconView.enable_model_drag_source().
La chiamata a questo metodo setta la property “reorderable” a False.
Di seguito un codice di esempio:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
import gi
gi.require_version('Gtk', '3.0')
from gi.repository import Gtk
from gi.repository.GdkPixbuf import Pixbuf
class GWindow(Gtk.Window):
def __init__(self):
super().__init__(title="IconView example")
self.set_default_size(150, 200)
icons = ["edit-cut", "edit-paste", "edit-copy"]
model = Gtk.ListStore(Pixbuf, str)
iconview = Gtk.IconView.new()
iconview.set_model(model)
iconview.set_pixbuf_column(0)
iconview.set_text_column(1)
iconview.set_item_orientation(Gtk.Orientation.HORIZONTAL)
iconview.set_reorderable(True)
for icon in icons:
pixbuf = Gtk.IconTheme.get_default().load_icon(icon, 64, 0)
model.append([pixbuf, icon.split("-")[1]])
self.add(iconview)
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 IconView
Categorie:Gtk3, PyGObject, python Tag: gtk3, PyGObject, python
PYGOBJECT: SIGNALS
13 Aprile 2020 bancaldo Commenti chiusi
torna all’indice appunti
Main loop e Signals
GTK+ utilizza un modello di programmazione event-driven, ovvero GTK+ attende nel
mainloop che un
utente esegua un’azione. Quando questo avviene, ad esempio un click su un
pulsante,
il mainloop se ne accorge e spedisce l’evento corrispondente a GTK+.
Quando un widget (es. Button) riceve un evento (es. viene premuto), emette uno o
più segnali.
Questi segnali notificano al programma che sta accadendo qualcosa di
interessante ed invocano le
funzioni (callbacks) che ad essi sono collegate.
Quando la callback ha terminato il suo compito, GTK+ ritorna nel mainloop
attendendo una nuova
azione da parte dell’utente.
Il metodo che lega un widget ad un evento è connect(event, callback, *data):
1
handler_id = widget.connect("event", callback, data)
widget: è un’istanza di un widget creata in precedenza;
Parametri:
event: è l’evento al quale siamo interessati. In genere ogni
widget ha un evento particolare, ad esempio Button sarà interessato all’evento
“clicked”.
callback: il nome della funzione di callback che verrà invocata
quando quel determinato evento accadrà;
data: opzionale ed indica i valori da passare alla callback;
Il metodo connect(), ritorna il numero identificativo dell’handler che gestisce
la coppia signal-callback.
1
2
3
4
5
6
7
8
>>> import gi
>>> gi.require_version("Gtk", "3.0")
>>> from gi.repository import Gtk
>>> button = Gtk.Button(label="Ok")
>>> button.connect("clicked", lambda widget: print("clicked"))
23
>>> button.clicked()
clicked
Qualora dovessimo disconnettere il widget da quel segnale, è possibile
utilizzare il metodo
disconnect(handler_id):
1
2
3
4
>>> button.disconnect(23)
>>> button.clicked()
>>>
E’ possibile anche disconnettere un widget da un evento, via funzione, con il
metodo
disconnect_by_func(callback):
1
2
3
4
5
6
7
8
9
10
11
12
>>> def on_click(button):
... print("clicked")
...
>>> button.connect("clicked", on_click)
24
>>> button.clicked()
clicked
>>> button.disconnect_by_func(on_click)
1
>>> button.clicked()
>>>
Gtk.main_quit()
Connettere l’applicazione al segnale “destroy” della top-level window.
Quando l’utente chiude la toplevel window, l’handler di default per questo
segnale distrugge
la window, ma non termina l’applicazione.
Connettendo il segnale “destroy” della top-level window alla Gtk.main_quit()
darà invece il
risultato desiderato.
1
window.connect("destroy", Gtk.main_quit)
La chiamata a Gtk.main_quit() fa ritornare il main loop precedentemente creato
con Gtk.main().
Objects
GObject è il “tipo” fondamentale che fornisce gli attributi e i metodi per tutti
i tipi di oggetto di GTK+, Pango e le altre librerie basate su GObject.
La classe GObject.GObject fornisce i metodi per la costruzione e la distruzione
degli oggetti, i metodi per l’accesso alle properties degli oggetti, il supporto
ai segnali.
Signals
I Signals connettono eventi arbitrari ai “listeners” di competenza.
Per esempio in GTK+, ogni evento (pressione di un tasto o movimento del mouse),
viene ricevuto dal
server X che genera un evento GTK+ sotto forma di emissione di segnale.
Ogni segnale viene registrato nel type system insieme al type, sul quale può
eseere emesso.
Per quel type, verrà registrata una funzione che sarà invocata ogni volta che
sarà emesso quel
segnale specifico. Un segnale può essere emesso anche volontariamente o si può
decidere di fermare
l’emissione del segnale dall’interno di una delle funzioni connesse a quel
segnale.
Creare un nuovo segnale
Possiamo creare nuovi segnali aggiungendoli al dizionario
GObject.GObject.__gsignals__:
Quando un nuovo segnale viene creato, può essere definito anche un
method-handler, che sarà
invocato ogni volta che il segnale verrà emesso.
1
2
3
4
5
class CustomObject(GObject.GObject):
__gsignals__ = {'custom_signal': (GObject.SIGNAL_RUN_FIRST, None, (int,)),}
def emit_signal(self, arg):
print("method handler for 'custom_signal' called with argument", arg)
Parametri:
GObject.SIGNAL_RUN_FIRST: indica che questo segnale invocherà
il method handler definito (emit_signal()) nella fase di prima emissione.
Le alternative sono:
GObject.SIGNAL_RUN_LAST: il method handler sarà invocato nella terza fase di
emissione;
GObject.SIGNAL_RUN_CLEANUP: invoca il method handler nell’ultima fase di
emissione.
None: indica cosa ritorna il segnale, di solito None.
(int,): indica gli argomenti del segnale.
Nel nostro caso il segnale prende un solo argomento di tipo int.
I segnali possono essere emessi con il metodo GObject.GObject.emit():
1
2
3
4
5
6
7
8
9
10
>>> from gi.repository import GObject
>>> class CustomObject(GObject.GObject):
... __gsignals__ = {'custom_signal': (GObject.SIGNAL_RUN_FIRST, None,
(int,)),}
...
... def do_custom_signal(self, arg):
... print("method handler for 'custom_signal' called with argument",
arg)
...
>>> obj = CustomObject()
>>> obj.emit("custom_signal", 23)
method handler for 'custom_signal' called with argument 23
link di riferimento:
torna all’indice degli appunti
python gtk3 tutorial
Gtk3
Categorie:Gtk3, PyGObject, python Tag: gtk3, PyGObject, python
PYGOBJECT: PROPERTIES
13 Aprile 2020 bancaldo Commenti chiusi
torna all’indice appunti
Properties
Le Properties descrivono la configurazione e lo stato dei widgets.
Come per i segnali, ogni widget ha il proprio set di properties.
Ad esempio un Button ha la property “label” che contiene il testo della label
dentro al button.
Quando creiamo un’istanza di un widget, possiamo specificare il nome e il valore
di una property,
passandola come keyword argument.
Ad esempio per creare una label allineata sulla destra con il testo “Hello
World” ed un angolo
di 25 gradi, useremo la sintassi:
1
label = Gtk.Label(label="Hello World", angle=25, halign=Gtk.Align.END)
che è l’equivalente di scrivere:
1
2
3
4
label = Gtk.Label()
label.set_label("Hello World")
label.set_angle(25)
label.set_halign(Gtk.Align.END)
Invece di usare i getters e i setters, possiamo ottenere e settare le properties
attraverso la
property props, con la sintassi:
1
widget.props.prop_name = value
Per sapere quali properties sono disponibili per un widget, possiamo scrivere:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
>>> for prop in dir(button.props):
... print(prop)
...
action_name
action_target
always_show_image
app_paintable
...
>>> button.props.label
'Ok'
>>> button.props.label = "Click"
>>> button.props.label
'Click'
Utilizzo di properties esistenti
La classe GObject.GObject fornisce le seguenti funzioni per gestire le
properties esistenti:
GObject.GObject.get_property() e GObject.GObject.set_property().
Come accennato in precedenza, alcune properties hanno funzioni ad esse dedicate
(getter e setter).
Ad esempio per la property “label” di un Button, ci sono 2 funzioni, la getter
Gtk.Button.get_label()
e la setter Gtk.Button.set_label(label).
Creare nuove properties
Una property viene definita tramite “name” e “type”.
Nonostante Python stesso sia tipizzato dinamicamente, non potremo modificare una
property,
una volta che questa è stata definita. Per creare una property utilizzaiamo
GObject.Property:
1
2
3
4
5
6
7
8
from gi.repository import GObject
class CustomObject(GObject.GObject):
pr_string = GObject.Property(type=str, default='bancaldo')
pr_float = GObject.Property(type=float)
def __init__(self):
super().__init__()
Possiamo decidere che una property sia “readable”, “writable”, o “readwrite”.
Per farlo è necessario settare alcuni flags, in fase di definizione della
property stessa.
Queste Flags sono:
GObject.ParamFlags.READABLE: solo accesso in lettura;
GObject.ParamFlags.WRITABLE: solo accesso in scrittura;
GObject.ParamFlags.READWRITE: property pubblica, con accesso in
lettura e scrittura.
1
2
pr_1 = GObject.Property(type=str, flags = GObject.ParamFlags.READABLE) # non
scrivibile
pr_2 = GObject.Property(type=str, flags = GObject.ParamFlags.WRITABLE) # non
leggibile
Per definire una nuova property read-only possiamo utilizzare un metodo
con decoratore GObject.Property:
1
2
3
4
5
6
7
8
9
10
from gi.repository import GObject
class CustomObject(GObject.GObject):
def __init__(self):
super().__init__()
@GObject.Property
def readonly(self):
return 'This is read-only property.'
Per accedere a questa property:
1
2
3
4
5
>>> myobj = CustomObject()
>>> myobj.readonly
'This is read-only property.'
>>> myobj.get_property("readonly")
'This is read-only property.'
La API di GObject.Property è molto simile alla built-in property() di python.
Possiamo creare i setter in maniera simile:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
class CustomObject(GObject.Object):
value = 0
@GObject.Property
def readonly(self):
'Read only property.'
return 1
@GObject.Property(type=int)
def my_int(self):
'Read-write integer property.'
return self.value
@my_int.setter
def my_int(self, value):
self.value = value
1
2
3
4
5
6
7
8
>>> myobj = CustomObject()
>>> myobj.readonly
1
>>> myobj.my_int
0
>>> myobj.my_int = 2
>>> myobj.my_int
2
Ad esempio è possibile anche definire un valore minimo e massimo per i numeri:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
from gi.repository import GObject
class CustomObject(GObject.GObject):
__gproperties__ = {
"int-prop": (int, # type
"integer prop", # nick
"A property that contains an integer", # desc
1, # min
5, # max
2, # default
GObject.ParamFlags.READWRITE # flags
),
}
def __init__(self):
super().__init__()
self.int_prop = 2
def do_get_property(self, prop):
return self.int_prop
def do_set_property(self, prop, value):
self.int_prop = value
Le properties, come si nota, vanno definite nel dizionario __gproperties__ di
GObject.GObject, e gestite con i metodi:
do_get_property e do_set_property.
1
2
3
4
5
6
7
8
9
10
11
>>> obj = CustomObject()
>>> obj.get_property("int-prop")
2
>>> obj.set_property("int-prop", 10)
<string>:1: Warning: value "10" of type 'gint' is invalid or out of range for
property 'int-prop' of type 'gint'
>>> obj.set_property("int-prop", -2)
<string>:1: Warning: value "-2" of type 'gint' is invalid or out of range for
property 'int-prop' of type 'gint'
>>> obj.set_property("int-prop", 4)
>>> obj.get_property("int-prop")
4
se la property richiesta non è esistente, ovvero non fa parte del dizionario
__gproperties__,
verrà sollevata una eccezione TypeError:
1
2
3
4
5
6
7
8
obj = CustomObject()
myprop = "int-propp"
try:
obj.get_property(myprop)
except TypeError:
print("ERROR: %s property not found!" % myprop)
ERROR: int-propp property not found!
Segnale modifica property
Quando una property viene modificata, viene emesso un segnale il cui nome è
“notify::property-name”.
E’ quindi possibile connettere il segnale di modifica della property, del nostro
oggetto, ad una
callback, con il metodo connect(signal, callback):
1
2
3
4
5
6
7
>>> def on_notify_int_prop(obj, string):
... print("INFO: 'int-prop' property changed")
...
>>> obj.connect("notify::int-prop", on_notify_int_prop)
1
>>> obj.set_property("int-prop", 2)
INFO: 'int-prop' property changed
Nota:
Per convenzione il nome della callback da usare con il metodo connect(), per un
segnale
“notify::property-name”, sarà “on_notify_property_name”.
API
Ricapitolando vediamo i metodi principali della classe GObject.GObject:
get_property(property_name)
Recupera il valore di una property di nome “property_name”.
set_property(property_name, value)
Setta il valore di una property di nome “property_name” al valore “value”,
passato come argomento.
emit(signal_name, …)
Emette un segnale di nome “signal_name”. Gli argomenti opzionali da passare al
segnale devono
seguire “signal_name”. Se ad esempio il nostro segnale è di tipo (int,), viene
emesso come segue:
1
self.emit(signal_name, 42)
freeze_notify()
Questo metodo congela tutti i segnali “notify::” (che vengono cioè emessi ogni
volta che una
property viene modificata), finchè non viene invocato il metodo thaw_notify().
E’ consigliato utilizzare il metodo freeze_notify(), all’interno di un
with statement, in modo da assicurarsi che il metodo thaw_notify(),
sia invocato implicitamente alla fine del blocco with utilizzato.
1
2
3
with an_object.freeze_notify():
# Do stuff
...
thaw_notify()
“scongela” tutti i segnali “notify::” che erano stati congelati dal metodo
freeze_notify().
Come detto in precedenza non è consigliato utilizzare thaw_notify()
esplicitamente,
ma utilizzare freeze_notify() con un with statement.
handler_block(handler_id)
Blocca un handler di un’istanza che non potrà essere chiamato durante
l’emissione di un segnale
che lo coinvolga, fino a chè non sarà chiamato il complementare
handler_unblock().
Questo blocco significa disattivare l’handler temporaneamente.
Un signal-handler deve essere sbloccato lo stesso numero di volte che è stato
bloccato, prima di
tornare attivo. Come per freeze/thaw, è raccomandato utilizzare handler_block()
all’interno di un with statement, che, raggiunta la fine, chiamerà
implicitamente
handler_unblock():
1
2
3
with an_object.handler_block(handler_id):
# Do stuff
...
handler_unblock(handler_id)
Annulla l’effetto di handler_block(). Un handler boccato viene saltato durante
l’emissione di un segnale e non sarà invocato fino a quando non verrà sbloccato
lo stesso numero
di volte per cui è stato bloccato.
Come già visto non è consigliabile chiamare handler_unblock() esplicitamente,
ma usare handler_block() all’interno di un with statement.
__gsignals__
Un dizionario dove le classi ereditate possono definire nuovi segnali.
Ogni elemento nel dizionario è un nuovo segnale. La chiave è il nome del
segnale, il valore
invece, una tupla con la forma (GObject.SIGNAL_RUN_FIRST, None, (int,))
GObject.SIGNAL_RUN_FIRST: può essere rimpiazzato con
GObject.SIGNAL_RUN_LAST o GObject.SIGNAL_RUN_CLEANUP.
None: ciò che ritorna quel segnale;
(int,): lista dei parametri del segnale, deve finire con virgola.
__gproperties__
Un dizionario dove è possibile definire le properties del nostro oggetto.
Questo non è il metodo raccomandato per definire nuove proprietà, ma è utile per
aggiungere
caratteristiche supplementari come valore minimo e massimo ammessi.
La chiave è il nome della property, mentre il valore è una tupla che descrive
tale property.
Il numero degli elementi di questa tupa è variabile e dipende dal primo
elemento, ma la tuple
conterrà sempre, almeno i seguenti elementi in questo ordine:
property’s type esmepio int, float,
property’s nick name: una breve descrizione della property
(utilizzato da programmi come Glade);
property’s description (blurb): un’altra stringa con descrizione
più esaustiva (usata da Glade e programmi simili);
property’s flags: indica il tipo di accesso alla property,
GObject.PARAM_READABLE, GObject.PARAM_WRITABLE o GObject.PARAM_READWRITE;
In base al primo elemento della tupla (property’s type), possono seguire altri
elementi.
gli scenari sono:
– il primo elemento è di tipo bool o str, l’elemento successivo sarà:
default: valore di default della property;
– il type è int o float:
minimum: il minimo valore accettato,
maximum: il valore massimo accettato;
default: valore di default della property;
– il type non è nessuno di essi: nessun extra elemento
GObject.SIGNAL_RUN_FIRST
Invoca il method handler dell’oggetto nel primo stadio dell’emissione;
GObject.SIGNAL_RUN_LAST
Invoca il method handler dell’oggetto nel terzo stadio dell’emissione;
GObject.SIGNAL_RUN_CLEANUP
Invoca il method handler dell’oggetto nell’ultimo stadio dell’emissione;
GObject.ParamFlags.READABLE
La property è in sola lettura e non soggetta a modifica;
GObject.ParamFlags.WRITABLE
La property è in scrittura e quindi soggetta a modifica;
GObject.ParamFlags.READWRITE
La property è in lettura e scrittura (pubblica);
Unicode
Da Python3.0, tutte le stringhe sono memorizzate come Unicode in un’istanza di
str type.
Le Encoded strings, d’altro canto, sono rappresentate come binary data, in forma
di istanza di byte type.
In parole povere str fa riferimento a text, mentre bytes
fa riferimento a data.
Per convertire da str a bytes, usare str.encode(),
da bytes a str, usare bytes.decode().
Inoltre non è più possibile mixare strings con encoded strings:
1
2
3
4
5
6
7
8
9
10
>>> s = "àòè"
>>> s.encode()
b'\xc3\xa0\xc3\xb2\xc3\xa8'
>>> s.encode("utf-8")
b'\xc3\xa0\xc3\xb2\xc3\xa8'
>>> b = s.encode("utf-8")
>>> b
b'\xc3\xa0\xc3\xb2\xc3\xa8'
>>> b.decode("utf-8")
'àòè'
In GTK+ le cose sono molto più comode perchè PyGObject fa automaticamente
l’encode/decode da/in
UTF-8, quando passeremo una stringa ad un metodo, o un metodo ritornerà una
stringa.
In ogni caso verrà sempre rappresentato un testo/stringa come instanza di str:
1
2
3
4
5
6
7
8
9
10
11
>>> import gi
>>> gi.require_version("Gtk", "3.0")
>>> from gi.repository import Gtk
>>> label = Gtk.Label()
>>> text = "\xc3\xa7\xc3\xa7\xc3\xa7"
>>> label.set_text(text)
>>> txt = label.get_text()
>>> type(txt), txt
(<class 'str'>, 'ççç')
>>> txt == text
True
link di riferimento:
torna all’indice degli appunti
python gtk3 tutorial
Gtk3
Categorie:Gtk3, PyGObject, python Tag: gtk3, PyGObject, python
PYGOBJECT: DRAG AND DROP
13 Aprile 2020 bancaldo Commenti chiusi
torna all’indice appunti
Drag and drop
Impostare un Drag and Drop tra widgets consiste nel selezionare un Drag Source,
ovvero il widget dal quale cominceremo il Drag, selezionare un Drag Destination,
ovvero il widget sul quale eseguiremo il Drop, gestire i segnali su entrambi i
widget.
In maniera molto generica, un Drag Source viene selezionato con il metodo
Gtk.Widget.drag_source_set(),
mentre il Drag Destination, viene selezionato con il metodo
Gtk.Widget.drag_dest_set().
Alcuni widget specializzati, come Gtk.TreeView and Gtk.IconView, usano metodi
specifici per questa
operazione.
Un drag and drop basico richiede che il source sia connesso al segnale
“drag-data-get”
e il destination sia connesso al segnale “drag-data-received”.
Se invece abbiamo bisogno di maggior complessità, come aree di drop specifiche,
o icone di drag
personalizzate, sarà necessaria la connessione a segnali aggiuntivi e dovremo
interagire con
l’oggetto Gdk.DragContext.
Per trasferire dati tra source e destination, dobbiamo
interagire con la variabile Gtk.SelectionData fornita nei segnali
“drag-data-get”
e “drag-data-received”, usando i metodi getter e setter di Gtk.SelectionData.
Target Entries
Per permettere al drag source e al destination di conoscere quali dati stanno
rispettivamente
spedendo e ricevendo, è necessaria una lista comune di Gtk.TargetEntry.
Possiamo costruirla creando direttamente una lista di istanze Gtk.TargetEntry, o
creando
un oggetto Gtk.TargetList:
1
2
3
4
5
6
7
8
9
10
>>> targets = [
... Gtk.TargetEntry.new("STRING", Gtk.TargetFlags.SAME_APP, 0),
... Gtk.TargetEntry.new("image/png", Gtk.TargetFlags.SAME_APP, 1),
... ]
>>> targets = Gtk.TargetList.new([
... Gtk.TargetEntry.new("STRING", Gtk.TargetFlags.SAME_APP, 0),
... Gtk.TargetEntry.new("image/png", Gtk.TargetFlags.SAME_APP, 1),
... ])
>>> targets.find(Gdk.Atom.intern_static_string("STRING"))
(True, info=0)
Oppure utilizzare i metodi che mette a disposizione la classe Gtk.TargetList:
Gtk.TargetList.add_image_targets(info, writable),
Gtk.TargetList.add_text_targets(info), ecc.
Una volta creata la lista targets e abilitati i widget all’operazione di drag
and drop con
i metodi enable_model_drag_source(button_mask, targets, actions) ed
enable_model_drag_dest(targets, actions), non resta che associarla ai widget
source e destination, preposti al drag and drop, con i metodi
drag_dest_set_target_list(targets) e
drag_source_set_target_list(targets).
1
2
3
4
5
6
7
>>> drag_source = Gtk.IconView()
>>>
drag_source.enable_model_drag_source(start_button_mask=Gdk.ModifierType.BUTTON1_MASK,
targets=[],
... actions=Gdk.DragAction.COPY)
>>> drag_dest = Gtk.IconView()
>>> drag_dest.enable_model_drag_dest(targets=[], actions=Gdk.DragAction.COPY)
>>> drag_source.drag_source_set_target_list(targets)
>>> drag_dest.drag_dest_set_target_list(targets)
Segnali
Drag Source Signals:
Name Emesso Scopo drag-begin Quando lo User unizia il drag Setta la icona di
drag drag-data-get Quando i dati sono richiesti dal destination Trasferisce i
dati del drag da source a destination drag-data-delete Quando un drag con la
action Gdk.DragAction.MOVE è completata Elimina i dati dal source per completare
il “move” drag-end Quando il drag è completo Anunlla quello fatto in drag-begin
Drag Destination Signals:
Name Emesso Scopo drag-motion Quando la icon Drag va sopra un’area di drop
Permette di eseguire il drop solo su certe aree drag-drop Quando la icona viene
lasciata su un’area di drop Permette di eseguire il drop solo su certe aree
drag-data-received Quando i dati di drag sono ricevuti dal destination
Trasferisce i dati del drag da source a destination
Ecco un codice di esempio:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
import gi
gi.require_version('Gtk', '3.0')
from gi.repository import Gtk, Gdk, GdkPixbuf
class GWindow(Gtk.Window):
def __init__(self):
super().__init__(title="Drag and Drop Example")
self.set_default_size(300, 400)
label_source = Gtk.Label(label="Drag source")
label_destination = Gtk.Label(label="Drop Area")
self.drag_source = DragSourceIconView() # Source widget
self.drag_dest = DragDestination() # Destination widget
button_img = Gtk.RadioButton.new_with_label_from_widget(
None, "Drag image only")
button_text = Gtk.RadioButton.new_with_label_from_widget(
button_img, "Drag text only")
# layout
vbox = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=6)
label_box = Gtk.Box(spacing=12)
label_box.pack_start(label_source, True, True, 0)
label_box.pack_start(label_destination, True, True, 0)
dnd_box = Gtk.Box(spacing=5)
dnd_box.pack_start(self.drag_source, True, True, 0)
dnd_box.pack_start(self.drag_dest, True, True, 0)
button_box = Gtk.Box(spacing=6)
button_box.pack_start(button_img, True, False, 0)
button_box.pack_start(button_text, True, False, 0)
vbox.pack_start(label_box, True, False, 0)
vbox.pack_start(dnd_box, True, False, 0)
vbox.pack_start(button_box, True, False, 0)
self.add(vbox)
# bindings
button_img.connect("toggled", self.add_image_targets)
button_text.connect("toggled", self.add_text_targets)
self.add_image_targets()
def add_image_targets(self, button=None):
targets = Gtk.TargetList.new([])
targets.add_image_targets(info=1, writable=True)
self.drag_dest.drag_dest_set_target_list(targets)
self.drag_source.drag_source_set_target_list(targets)
def add_text_targets(self, button=None):
targets = Gtk.TargetList.new([])
targets.add_text_targets(info=0)
self.drag_dest.drag_dest_set_target_list(targets)
self.drag_source.drag_source_set_target_list(targets)
class DragSourceIconView(Gtk.IconView):
def __init__(self):
super().__init__()
self.set_text_column(0)
self.set_pixbuf_column(1)
model = Gtk.ListStore(str, GdkPixbuf.Pixbuf)
self.set_model(model)
for text, icon in [("Item 1", "image-missing"),
("Item 2", "help-about"), ("Item 3", "edit-copy")]:
pixbuf = Gtk.IconTheme.get_default().load_icon(icon, 32, 0)
self.get_model().append([text, pixbuf])
self.enable_model_drag_source(
start_button_mask=Gdk.ModifierType.BUTTON1_MASK, targets=[],
actions=Gdk.DragAction.COPY)
# bindings
self.connect("drag-data-get", self.on_drag_data_get)
def on_drag_data_get(self, widget, drag_context, data, info, time):
selected_path = self.get_selected_items()[0]
selected_iter = self.get_model().get_iter(selected_path)
if info == 0:
text = self.get_model().get_value(selected_iter, 0)
data.set_text(text, -1)
elif info == 1:
pixbuf = self.get_model().get_value(selected_iter, 1)
data.set_pixbuf(pixbuf)
class DragDestination(Gtk.IconView):
def __init__(self):
super().__init__()
self.set_text_column(0)
self.set_pixbuf_column(1)
model = Gtk.ListStore(str, GdkPixbuf.Pixbuf)
self.set_model(model)
self.enable_model_drag_dest(targets=[], actions=Gdk.DragAction.COPY)
# bindings
self.connect("drag-data-received", self.on_drag_data_received)
def on_drag_data_received(self, w, context, x, y, data, info, time, *args):
model = w.get_model()
pixbuf = text = None
if info == 0:
text = data.get_text() # None if 'only image' is toggled
elif info == 1:
pixbuf = data.get_pixbuf() # None if 'only text' is toggled
model.append([text, pixbuf])
if __name__ == "__main__":
win = GWindow()
win.connect("destroy", Gtk.main_quit)
win.show_all()
Gtk.main()
link di riferimento:
torna all’indice degli appunti
Drag and Drop
Categorie:Gtk3, PyGObject, python Tag: gtk3, PyGObject, python
Articoli precedenti
RSS
* Google
* Youdao
* Xian Guo
* Zhua Xia
* My Yahoo!
* newsgator
* Bloglines
* iNezha
UBUNTU COUNTER
CLUSTERMAPS
TAG CLOUD
channels conky django euler events flask git gtk3 iot kubuntu linux mqtt nfs pip
plex PyGObject pyinstaller pyodbc PyQt5 python pytyhon redis scrapy steam
sublimetext ubuntu venv virtualenv windows wx wxpython Xfce4 Xfwm4 xpath Xubuntu
BLOGROLL
* Bancaldo @ wordpress.com
COMMENTI RECENTI
* Visto nel Web – 173 | Ok, panico su Virtualbox: ubuntu15.04 risoluzione
monitor 640×480
* bancaldo su Notte magica: grazie Inter
* LUCIO su Notte magica: grazie Inter
* bancaldo su Philips serie 7 e PS3 Media Server
* Christian Meneghini (@XeviaN360) su Philips serie 7 e PS3 Media Server
META
* Accedi
* Inserimenti feed
* Feed dei commenti
* WordPress.org
ARTICOLI RECENTI
* PyGObject: Gtk.Builder
* PyGObject: Gtk.Image
* PyGObject: GdkPixbuf.Pixbuf
* PyGObject: Gio.SimpleAction
* PyGObject: Gio.ActionMap
* PyGObject: Gtk.EventBox
* PyGObject: Gtk.IconView
* PyGObject: Signals
* PyGObject: Properties
* PyGObject: Drag and Drop
* PyGObject: Gtk.Notebook
* PyGObject: Gtk.MessageDialog
* PyGObject: Gtk.TextView
* PyGObject: Gtk.Toolbar
* PyGObject: Gtk.ComboBox
Vai su WordPress
Copyright © 2007-2020 bancaldo™
Tema di NeoEase. XHTML 1.1 e CSS 3 convalidati.