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

PyGObject: Gtk.Image

13 Aprile 2020

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: , ,
I commenti sono chiusi.