Archivio

Posts Tagged ‘python’

PyGObject: Gtk.Builder

13 Aprile 2020 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 è

<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

<requires>

.
L’attributo “lib” specifica la libreria dei widget (attualmente l’unica supportata è “gtk+”).
L’attributo “version” specifica la versione in formato

<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

<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

<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

<child>

.

Un esempio di UI Definition per Gtk.Builder

<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;

>>> 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:

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;

>>> 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.

>>> 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;

>>> 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:

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: , ,

PyGObject: Gtk.Image

13 Aprile 2020 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():

>>> 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:

>>> 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.

>>> 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:

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: , ,

PyGObject: GdkPixbuf.Pixbuf

13 Aprile 2020 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:

>>> 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.

>>> 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:

>>> 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.

>>> 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.

>>> 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.

>>> 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.

>>> 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.

>>> 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:

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: , ,

PyGObject: Gio.SimpleAction

13 Aprile 2020 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:

>>> 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:

>>> 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().

>>> 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.

>>> 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().

>>> 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.

>>> 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:

#!/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: , ,

PyGObject: Gio.ActionMap

13 Aprile 2020 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.

>>> 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:

>>> 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.

>>> 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.

>>> 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: , ,

PyGObject: Gtk.EventBox

13 Aprile 2020 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.

>>> 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:

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: , ,

PyGObject: Gtk.IconView

13 Aprile 2020 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.

>>> 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:

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: , ,

PyGObject: Signals

13 Aprile 2020 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):

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.

>>> 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):

>>> button.disconnect(23)
>>> button.clicked()

>>>

E’ possibile anche disconnettere un widget da un evento, via funzione, con il metodo
disconnect_by_func(callback):

>>> 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.

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.

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():

>>> 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: , ,

PyGObject: Properties

13 Aprile 2020 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:

label = Gtk.Label(label="Hello World", angle=25, halign=Gtk.Align.END)

che è l’equivalente di scrivere:

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:

widget.props.prop_name = value

Per sapere quali properties sono disponibili per un widget, possiamo scrivere:

>>> 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:

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.

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:

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:

>>> 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:

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
>>> 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:

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.

>>> 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:

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):

>>> 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:

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.

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():

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:

>>> 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:

>>> 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: , ,

PyGObject: Drag and Drop

13 Aprile 2020 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:

>>> 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).

>>> 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:

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: , ,