PyGTK - Guida rapida

PyGTK è un insieme di wrapper scritti in Python e C per la libreria GUI GTK +. Fa parte del progetto GNOME. Offre strumenti completi per la creazione di applicazioni desktop in Python. Sono disponibili anche collegamenti Python per altre popolari librerie GUI.

PyQtè un port Python della libreria QT. Il nostro tutorial PyQt può essere trovatohere. Allo stesso modo, wxPython toolkit è l'associazione Python per wxWidgets, un'altra popolare libreria GUI multipiattaforma. È disponibile il nostro tutorial su wxPythonhere.

GTK+, o GIMP Toolkit, è un toolkit multipiattaforma per la creazione di interfacce utente grafiche. Offrendo un set completo di widget, GTK + è adatto per progetti che vanno da piccoli strumenti unici a suite di applicazioni complete.

GTK + è stato progettato da zero per supportare un'ampia gamma di lingue. PyGTK è un wrapper Python per GTK +.

GTK + è costruito attorno alle seguenti quattro librerie:

  • Glib- Una libreria di base di basso livello che costituisce la base di GTK +. Fornisce la gestione della struttura dati per C.

  • Pango - Una libreria per il layout e il rendering del testo con un'enfasi sull'internazionalizzazione.

  • Cairo - Una libreria per grafica 2D con supporto per più dispositivi di output (incluso il sistema X Window, Win32)

  • ATK - Una libreria per una serie di interfacce che forniscono strumenti di accessibilità come lettori di schermo, ingranditori e dispositivi di input alternativi.

PyGTK semplifica il processo e ti aiuta a creare programmi con un'interfaccia utente grafica utilizzando il linguaggio di programmazione Python. La libreria GTK + sottostante fornisce tutti i tipi di elementi visivi e utilità per sviluppare applicazioni complete per il desktop GNOME. PyGTK è una libreria multipiattaforma. È un software gratuito distribuito con licenza LGPL.

PyGTK è costruito attorno a GTK + 2.x. Per creare applicazioni per GTK +3, sono disponibili anche i collegamenti PyGObject.

PyGTK per Microsoft Windows

L'installazione di PyGTK per Microsoft Windows prevede i seguenti passaggi:

  • Step 1 - Installa un interprete Python a 32 bit (ultima distribuzione Python 2.7)

  • Step 2 - Scarica e installa il runtime GTK +.

  • Step 3 - Scarica e installa il runtime GTK + -https://ftp.gnome.org

  • Step 4 - Si consiglia inoltre di scaricare i moduli PyCairo e PyGobject dai seguenti URL: https://ftp.gnome.org https://ftp.gnome.org/pub

  • Step 5- Per comodità, è disponibile anche un programma di installazione all-in-one che gestisce tutte le dipendenze di PyGTK. Scarica e installa l'ultimo programma di installazione all-in-one per Windows dal seguente URL:https://ftp.gnome.org/pub/GNOME

PyGTK per Linux

PyGTK è incluso nella maggior parte delle distribuzioni Linux (incluse Debian, Fedora, Ubuntu, RedHat ecc.); il codice sorgente può anche essere scaricato e compilato dal seguente URL

https://ftp.gnome.org/pub/GNOME/sources/pygtk/2.24/

Creare una finestra usando PyGTK è molto semplice. Per procedere, dobbiamo prima importare il modulo gtk nel nostro codice.

import gtk

Il modulo gtk contiene la classe gtk.Window. Il suo oggetto costruisce una finestra di primo livello. Deriviamo una classe da gtk.Window.

class PyApp(gtk.Window):

Definisci il costruttore e chiama il file show_all() metodo della classe gtk.window.

def __init__(self):
   super(PyApp, self).__init__()
   self.show_all()

Ora dobbiamo dichiarare l'oggetto di questa classe e avviare un ciclo di eventi chiamando il suo metodo main ().

PyApp()
gtk.main()

Si consiglia di aggiungere un'etichetta “Hello World” nella finestra genitore.

label = gtk.Label("Hello World")
self.add(label)

Quello che segue è un codice completo da visualizzare “Hello World”-

import gtk

class PyApp(gtk.Window):
   def __init__(self):
      super(PyApp, self).__init__()
      self.set_default_size(300,200)
      self.set_title("Hello World in PyGTK")
      label = gtk.Label("Hello World")
      self.add(label)
      self.show_all()
PyApp()
gtk.main()

L'implementazione del codice precedente produrrà il seguente output:

Il modulo PyGTK contiene vari widget. La classe gtk.Object funge da classe base per la maggior parte dei widget così come per alcune classi non widget. La finestra di primo livello per le applicazioni desktop che utilizzano PyGTK è fornita dalla classe gtk.Window. La tabella seguente elenca i widget importanti e le loro funzioni:

S.NO Classi e descrizione
1

gtk.Widget

Questa è una classe gtk.base per tutti i widget PyGTK. gtk.Widget fornisce un insieme comune di metodi e segnali per i widget.

2

gtk.Window

Questa è una finestra di primo livello che contiene un widget figlio. gtk.Window è un'area di visualizzazione decorata con una barra del titolo e elementi per consentire all'utente di chiudere, ridimensionare e spostare la finestra.

3

gtk.Button

Questo è un widget a pulsante che emette un segnale quando viene cliccato. gtk.Button viene solitamente visualizzato come un pulsante con un'etichetta di testo e viene generalmente utilizzato per allegare una funzione di callback.

4

gtk.Entry

Questo è un widget di immissione di testo a riga singola.

5

gtk.Label

Questo widget mostra una quantità limitata di testo di sola lettura.

6

gtk.ButtonBox

Questa è una classe base per widget che contiene più pulsanti.

7

gtk.HBox

Questo è un contenitore che organizza i suoi widget figlio in una singola riga orizzontale.

8

gtk.VBox

Questo è un contenitore che organizza i suoi widget figlio in una singola colonna.

9

gtk.Fixed

Questo è un contenitore che può posizionare widget figlio in posizioni fisse e con dimensioni fisse, espresse in pixel.

10

gtk.Layout

Ciò fornisce un'area scorrevole infinita contenente widget figlio e disegni personalizzati.

11

gtk.MenuItem

Questo widget implementa l'aspetto e il comportamento delle voci di menu. Le sottoclassi dei widget derivati ​​di gtk.MenuItem sono gli unici elementi secondari validi dei menu. Quando selezionati da un utente, possono visualizzare un menu a comparsa o richiamare una funzione o un metodo associato

12

gtk.Menu

Si tratta di un menu a tendina costituito da un elenco di oggetti MenuItem che possono essere navigati e attivati ​​dall'utente per eseguire le funzioni dell'applicazione.

13

gtk.MenuBar

Visualizza le voci di menu orizzontalmente in una finestra dell'applicazione o in una finestra di dialogo.

14

gtk.ComboBox

Questo widget viene utilizzato per scegliere da un elenco di elementi.

15

gtk.Scale

Questo è un controllo di scorrimento orizzontale o verticale per selezionare un valore numerico.

16

gtk.Scrollbar

Visualizza una barra di scorrimento orizzontale o verticale.

17

gtk.ProgressBar

Viene utilizzato per visualizzare lo stato di avanzamento di un'operazione di lunga durata.

18

gtk.Dialog

Viene visualizzata una finestra popup per le informazioni e le azioni dell'utente.

19

gtk.Notebook

Questo widget è un contenitore i cui figli sono pagine sovrapposte che possono essere alternate utilizzando le etichette delle schede.

20

gtk.Paned

Questa è una classe base per widget con due riquadri, disposti orizzontalmente o verticalmente. I widget figlio vengono aggiunti ai riquadri del widget. La divisione tra i due bambini può essere regolata dall'utente.

21

gtk.TextView

Questo widget mostra il contenuto di un oggetto TextBuffer.

22

gtk.Toolbar

Questo contenitore contiene e gestisce una serie di pulsanti e widget in una barra orizzontale o verticale.

23

gtk.TreeView

Questo widget mostra il contenuto di TreeModel standard (ListStore, TreeStore, TreeModelSort)

24

gtk.DrawingArea

Questo widget aiuta nella creazione di elementi dell'interfaccia utente personalizzati. gtk.DrawingArea è essenzialmente un widget vuoto contenente una finestra su cui puoi disegnare.

25

gtk.Calendar

Questo widget visualizza un calendario e consente all'utente di selezionare una data.

26

gtk.Viewport

Questo widget mostra una parte di un widget più grande.

Un oggetto della classe gtk.Window fornisce un widget che gli utenti comunemente pensano come una Wwindow. Questo widget è un contenitore, quindi può contenere un widget figlio. Fornisce un'area visualizzabile decorata con barra del titolo e controlli di ridimensionamento.

La classe gtk.Window ha il seguente costruttore:

gtk.Window(type)

Il parametro di tipo accetta uno dei seguenti valori:

gtk.WINDOW_TOPLEVEL (predefinito) Questa finestra non ha un genitore. Le finestre Toplevel sono la finestra principale dell'applicazione e le finestre di dialogo.
gtk.WINDOW_POPUP Questa finestra non ha cornice o decorazioni. Una finestra popup viene utilizzata per i menu e i suggerimenti.

Alcuni dei metodi importanti della classe gtk.Window sono elencati di seguito:

S.NO Metodi e descrizione
1

set_title(string)

Questo imposta la proprietà "title" di gtk.window sul valore specificato da title. Il titolo di una finestra verrà visualizzato nella barra del titolo.

2

get_title()

Questo restituisce il titolo di una finestra se impostato.

3

set_position()

Questo imposta la posizione della finestra. Le costanti di posizione predefinite sono:

  • gtk.WIN_POS_NONE

  • gtk.WIN_POS_CENTER

  • gtk.WIN_POS_MOUSE

  • gtk.WIN_POS_CENTER_ALWAYS

  • gtk.WIN_POS_CENTER_ON_PARENT

3

set_focus()

Questo imposta il widget specificato come widget focus per la finestra.

4

set_resizable()

Questo è vero per impostazione predefinita. set_resizable () aiuta l'utente a impostare la dimensione di una finestra.

5

set_decorated()

Questo è vero per impostazione predefinita. Se false, la barra del titolo e i controlli di ridimensionamento della finestra saranno disabilitati.

6

set_modal()

Se true, la finestra diventa modale e l'interazione con altre finestre viene impedita. Viene utilizzato per i widget di dialogo.

7

set_default_size()

Questo imposta la dimensione predefinita della finestra sulla larghezza e l'altezza specificate in pixel.

Il widget gtk.Window emette i seguenti segnali:

attivare-default Viene emesso quando il widget figlio predefinito della finestra viene attivato solitamente dall'utente premendo il tasto Invio o Invio.
attiva la messa a fuoco Viene emesso quando il widget figlio con il focus viene attivato solitamente dall'utente premendo il tasto Space.
spostare la messa a fuoco Viene emesso quando lo stato attivo viene modificato all'interno dei widget figlio della finestra quando l'utente preme Tab, Maiusc + Tab o i tasti freccia su, giù, sinistra o destra.
messa a fuoco Viene emesso quando il focus cambia in widget in window.

Il widget gtk.Button viene solitamente visualizzato come un pulsante con un'etichetta di testo. Viene generalmente utilizzato per allegare una funzione o un metodo di callback che viene chiamato quando si fa clic sul pulsante.

La classe gtk.Button ha il seguente costruttore:

gtk.Button(label = None, stock = None, use_underline = True)

In cui,

  • Label - Il testo che deve essere visualizzato dall'etichetta del pulsante

  • Stock- L'ID stock che identifica l'immagine stock e il testo da utilizzare nel pulsante. L'impostazione predefinita è Nessuno.

  • Underline - Se True, un carattere di sottolineatura nel testo indica che il carattere successivo deve essere sottolineato e utilizzato per l'acceleratore mnemonico.

Alcune delle costanti predefinite per il parametro stock sono:

  • STOCK_OK
  • STOCK_STOP
  • STOCK_YES
  • STOCK_NO
  • STOCK_QUIT
  • STOCK_CANCEL
  • STOCK_CLOSE

La classe Button ha i seguenti metodi importanti:

S.NO Metodi e descrizione
1

set_label()

Questo imposta il testo dell'etichetta del pulsante su etichetta. Questa stringa viene utilizzata anche per selezionare l'articolo in magazzino se la proprietà "use_stock" è True.

2

get_label()

Questo recupera il testo dall'etichetta del pulsante

3

set_focus_on_click()

Se True, il pulsante acquisisce lo stato attivo quando viene cliccato con il mouse.

4

set_alignment()

Questo è l'allineamento orizzontale e verticale del widget figlio. Il valore varia da 0,0 a 1,0.

5

set_image()

Questo imposta la proprietà dell'immagine sul valore dell'immagine. La proprietà "gtkbutton-images" dovrebbe essere impostata su True.

I seguenti segnali vengono emessi dal widget Button:

attivare Viene emesso quando gtk.Widget's activate()viene chiamato il metodo. Per un pulsante provoca l'emissione del segnale "cliccato".
cliccato Viene emesso quando il pulsante del mouse viene premuto e rilasciato mentre il puntatore si trova sul pulsante o quando il pulsante viene attivato con la tastiera.

Un widget Etichetta è utile per visualizzare testo non modificabile. L'etichetta viene utilizzata internamente da molti altri widget. Ad esempio, Button ha un'etichetta per mostrare il testo sul viso. Allo stesso modo, gli oggetti MenuItem hanno un'etichetta. Un'etichetta è un oggetto senza finestre, quindi non può ricevere eventi direttamente.

La classe Label ha un semplice costruttore -

gtk.Label(str = None)

I seguenti metodi utili possono essere utilizzati con l'oggetto Label:

S.NO Metodi e descrizione
1

set_text()

Questo imposta il nuovo testo come etichetta

2

get_text()

Ciò restituisce il testo dall'etichetta

3

set_use_underline()

Se vero, un carattere di sottolineatura nel testo indica che il carattere successivo deve essere utilizzato per il tasto di scelta rapida mnemonico.

4

set_justify

Questo imposta l'allineamento delle linee nel testo dell'etichetta l'una rispetto all'altra.

I valori possibili sono: gtk.JUSTIFY_LEFT, gtk.JUSTIFY_RIGHT, gtk.JUSTIFY_CENTER e gtk.JUSTIFY_FILL.

5

Set_line_wrap()

Se è vero, la riga verrà mandata a capo

6

set_selectable()

Se true, il testo nell'etichetta può essere selezionato per il copia-incolla

7

set_width_chars()

Imposta la larghezza di un'etichetta

I seguenti segnali vengono emessi dal widget etichetta:

attiva-collegamento-corrente Viene emesso quando l'utente attiva un collegamento nell'etichetta.
attiva-collegamento Viene emesso per attivare un URI.
copia-appunti Viene emesso quando il testo viene copiato dall'etichetta negli appunti.

Il widget di immissione è un widget di immissione di testo a riga singola. Se il testo inserito è più lungo dell'allocazione del widget, il widget scorrerà in modo che la posizione del cursore sia visibile.

Il campo di immissione può essere convertito in modalità password utilizzando il metodo set_visibility () di questa classe. Il testo inserito viene sostituito dal carattere scelto dal metodo invisible_char (), il valore predefinito è "*".

La classe Entry ha il seguente costruttore:

gtk.Entry(max = 0)

Qui, max indica la lunghezza massima del campo di immissione in caratteri. Il parametro assume un valore numerico (0-65536).

La tabella seguente mostra i metodi importanti di una classe Entry:

S.NO Metodi e descrizione
1

set_visibility(visible)

Se falso, il contenuto viene oscurato sostituendo i caratteri con il carattere invisibile predefinito - '*'

2

set_invisible_char(char)

I caratteri predefiniti "*" nel campo di immissione sono sostituiti da char

3

set_max_length(x)

Questo imposta la proprietà "max-length" sul valore di x. (0-65536)

4

set_text(str)

Questo imposta la proprietà "text" sul valore di str. La stringa instr sostituisce il contenuto corrente della voce.

5

get_text()

Ciò restituisce il valore della proprietà "text" che è una stringa contenente il contenuto della voce.

6

set_alignment()

Questo imposta la proprietà "xalign" sul valore di xalign. set_alignment () controlla il posizionamento orizzontale dei contenuti nel campo di immissione.

I seguenti segnali vengono emessi dal widget di ingresso:

attivare Viene emesso quando la voce viene attivata dall'azione dell'utente o a livello di codice con il gtk.Widget.activate() metodo.
backspace Viene emesso quando il Backspace il tasto viene immesso dalla tastiera.
copia-appunti Viene emesso quando il testo di selezione nella voce viene copiato negli appunti.
cut-clipboard Viene emesso quando la selezione nella voce viene tagliata e inserita negli appunti.
incolla-appunti Viene emesso quando il contenuto degli appunti viene incollato nella voce.

A differenza di un'applicazione in modalità console, che viene eseguita in modo sequenziale, un'applicazione basata su GUI è guidata dagli eventi. Ilgtk.main()la funzione avvia un ciclo infinito. Gli eventi che si verificano sulla GUI vengono trasferiti alle funzioni di callback appropriate.

Ogni widget PyGTK, derivato dalla classe GObject, è progettato per emettere ‘signal’in risposta a uno o più eventi. Il segnale da solo non esegue alcuna azione. Invece, è "connesso" a una funzione di callback.

Alcuni segnali vengono ereditati dal widget, mentre alcuni segnali sono specifici del widget. Ad esempio, il segnale "toggle" viene emesso dal widget toggleButton.

Un gestore del segnale viene impostato invocando il connect() metodo della classe gtk.widget.

handler_id = object.connect(name, func, func_data)
  • Il primo argomento, name, è una stringa contenente il nome del segnale che desideri catturare.

  • Il secondo argomento, func, è la funzione di richiamata che desideri venga chiamata quando viene rilevata.

  • Il terzo argomento, func_data, i dati che si desidera passare a questa funzione.

  • L'id del gestore, che viene utilizzato per identificare in modo univoco il metodo di callback.

Ad esempio, per richiamare la funzione onClicked () quando si fa clic su un pulsante, utilizzare la seguente sintassi:

btn.connect("clicked",onClicked,None)

La funzione onClicked () è definita come -

def onClicked(widget, data=None):

Se il metodo di callback è un metodo oggetto, riceve self come argomento aggiuntivo -

def onClicked(self, widget, data=None):

Esempio

Nell'esempio seguente, un Button viene aggiunto a gtk.Window. Il messaggio "Hello World" viene stampato quando si fa clic sul pulsante.

import gtk
class PyApp(gtk.Window):
   def __init__(self):
      super(PyApp, self).__init__()
      self.set_title("Hello World in PyGTK")
      self.set_default_size(400,300)
      self.set_position(gtk.WIN_POS_CENTER)
		
      self.label = gtk.Label("Enter name")
      self.entry = gtk.Entry()
		
      self.btn = gtk.Button("Say Hello")
      self.btn.connect("clicked",self.hello)
		
      fixed = gtk.Fixed()
      fixed.put(self.label, 100,100)
      fixed.put(self.entry, 100,125)
      fixed.put(self.btn,100,150)
		
      self.add(fixed)
      self.show_all()
		
   def hello(self,widget):
      print "hello",self.entry.get_text()
PyApp()
gtk.main()

Esegui il codice sopra dal prompt di Python. Verrà visualizzato il seguente output:

Quando si preme il pulsante, sulla console viene visualizzato il seguente output:

Hello TutorialsPoint

Oltre al meccanismo del segnale, gli eventi del sistema a finestre possono anche essere collegati alle funzioni di callback. Il ridimensionamento della finestra, la pressione di un tasto, l'evento di scorrimento ecc. Sono alcuni degli eventi comuni del sistema delle finestre. Questi eventi vengono segnalati al ciclo principale dell'applicazione. Da lì, vengono trasmessi tramite segnali alle funzioni di callback.

Alcuni degli eventi di sistema sono elencati di seguito:

  • button_press_event
  • button_release_event
  • scroll_event
  • motion_notify_event
  • delete_event
  • destroy_event
  • expose_event
  • key_press_event
  • key_release_event

Il metodo connect () viene utilizzato per associare l'evento alla funzione di callback seguendo la sintassi:

Object.connect(name, function, data)

Qui, il nome sta per la stringa corrispondente al nome dell'evento che deve essere catturato. E,function è il nome del callbackfunzione che deve essere chiamata quando si verifica un evento. I dati sono l'argomento da passare alla funzione di callback.

Quindi, il codice seguente collega un widget Button e cattura l'evento button_press -

self.btn.connect("button_press_event", self.hello)

Il seguente sarà il prototipo della funzione hello () -

def hello(self,widget,event):

Esempio

Di seguito è riportato il codice per il gestore di eventi del pulsante:

import gtk
class PyApp(gtk.Window):
   def __init__(self):
      super(PyApp, self).__init__()
      self.set_title("Hello World in PyGTK")
      self.set_default_size(400,300)
      self.set_position(gtk.WIN_POS_CENTER)
		
      self.label = gtk.Label("Enter name")
      self.entry = gtk.Entry()
      self.btn = gtk.Button("Say Hello")
      self.btn.connect("button_press_event", self.hello)
		
      fixed = gtk.Fixed()
      fixed.put(self.label, 100,100)
      fixed.put(self.entry, 100,125)
      fixed.put(self.btn,100,150)
		
      self.add(fixed)
      self.show_all()
		
   def hello(self,widget,event):
      print "hello",self.entry.get_text()

PyApp()
gtk.main()

Quando si esegue il codice sopra, viene visualizzato il seguente output sulla console:

Hello TutorialsPoint

La libreria PyGTK fornisce diverse classi contenitore per controllare il posizionamento dei widget all'interno di una finestra. Il modo più semplice è usare un filefixed container class e posizionare un widget al suo interno specificando le sue coordinate assolute misurate in pixel.

Seguiamo ora questi passaggi:

Step 1 - Dichiarare un oggetto del fixed class

fixed = gtk.Fixed()

Step 2 - Crea un widget pulsante e aggiungilo al contenitore fisso utilizzando put()metodo che necessita di coordinate x e y. Qui, il pulsante verrà posizionato nella posizione (100,100).

btn = gtk.Button("Hello")
fixed.put(btn, 100,100)

Step 3- È possibile posizionare più controlli nel contenitore fisso. E aggiungilo alla finestra di primo livello e richiama il fileshow_all() metodo

self.add(fixed)
self.show_all()

Questo layout assoluto, tuttavia, non è adatto per i seguenti motivi:

  • La posizione del widget non cambia anche se la finestra viene ridimensionata.
  • L'aspetto potrebbe non essere uniforme su diversi dispositivi di visualizzazione con risoluzioni diverse.
  • La modifica del layout è difficile in quanto potrebbe essere necessario ridisegnare l'intero modulo.

Quello che segue è il file original window -

Quello che segue è il file resized window -

La posizione del pulsante è invariata qui.

L'API PyGTK fornisce classi container per una migliore gestione del posizionamento dei widget all'interno del container. I vantaggi dei gestori di layout rispetto al posizionamento assoluto sono:

  • I widget all'interno della finestra vengono ridimensionati automaticamente.
  • Assicura un aspetto uniforme su dispositivi di visualizzazione con diverse risoluzioni.
  • È possibile aggiungere o rimuovere widget dinamicamente senza dover riprogettare.

gtk.Container funge da classe base per le seguenti classi:

  • gtk.ButtonBox
  • gtk.Box
  • gtk.Alignment
  • gtk.EventBox
  • gtk.Table

La classe gtk.Box è una classe astratta che definisce la funzionalità di un contenitore in cui i widget sono posti in un'area rettangolare. I widget gtk.HBox e gtk.VBox sono derivati ​​da esso.

I widget figlio in gtk.Hbox sono disposti orizzontalmente nella stessa riga. D'altra parte, i widget figlio di gtk.VBox sono disposti verticalmente nella stessa colonna.

La classe gtk.Box utilizza il seguente costruttore:

gtk.Box(homogenous = True, spacing = 0)

La proprietà omogenea è impostata su True per impostazione predefinita. Di conseguenza, a tutti i widget figlio viene assegnata la stessa allocazione.

gtk.Box utilizza il meccanismo di impacchettamento per posizionare widget figlio in esso con riferimento a una posizione particolare, con riferimento all'inizio o alla fine. Il metodo pack_start () posiziona i widget dall'inizio alla fine. Al contrario, il metodo pack_end () inserisce i widget dall'inizio alla fine. In alternativa, puoi usare il metodo add () che è simile a pack_start ().

I seguenti metodi sono disponibili per gtk.HBox e gtk.VBox:

  • gtk_box_pack_start ()

  • gtk_box_pack_end ()

gtk_box_pack_start ()

Questo metodo aggiunge child alla scatola, imballata con riferimento all'inizio della scatola -

pack_start(child, expand = True, fill = True, padding = 0)

I seguenti sono i parametri:

  • child - Questo è l'oggetto widget da aggiungere a box

  • expand- Questo è impostato su True se al bambino deve essere assegnato spazio aggiuntivo nella casella. Lo spazio extra è diviso tra tutti i bambiniwidgets.

  • fill- Se True, lo spazio extra verrà assegnato al bambino. In caso contrario, questo parametro viene utilizzato come riempimento.

  • padding - Questo è lo spazio in pixel tra i widget nella casella.

gtk_box_pack_end ()

Questo aggiunge bambino alla scatola, imballata con riferimento alla fine della scatola.

pack_end (child, expand = True, fill = True, padding = 0)

I seguenti sono i parametri:

  • child - Questo è l'oggetto widget da aggiungere

  • expand- Questo è impostato su True se al bambino deve essere assegnato spazio aggiuntivo nella casella. Questo spazio extra è diviso tra tutti i widget figlio.

  • fill - Se True, lo spazio extra verrà assegnato al bambino altrimenti utilizzato come riempimento.

  • padding - Questo è lo spazio in pixel tra i widget nella casella.

set_spacing (spacing) è la funzione che imposta il numero di pixel da posizionare tra i figli del riquadro.

Il metodo add (widget)è ereditato dalla classe gtk.Container. Aggiunge widget al contenitore. Questo metodo può essere utilizzato al posto del metodo pack_start ().

Esempio

Nell'esempio riportato di seguito, la finestra di primo livello contiene un box verticale (box oggetto gtk.VBox). A sua volta ha un oggetto VBox vb e un oggetto HBox hb. Nella casella superiore, un'etichetta, un widget di immissione e un pulsante sono posizionati verticalmente. Nella casella inferiore, un altro set di etichette, voci e pulsanti sono posizionati verticalmente.

Rispettare il codice seguente:

import gtk
class PyApp(gtk.Window):
   def __init__(self):
      super(PyApp, self).__init__()
         self.set_title("Box demo")
		
      box = gtk.VBox()
      vb = gtk.VBox()
      lbl = gtk.Label("Enter name")
		
      vb.pack_start(lbl, expand = True, fill = True, padding = 10)
      text = gtk.Entry()
		
      vb.pack_start(text, expand = True, fill = True, padding = 10)
      btn = gtk.Button(stock = gtk.STOCK_OK)
		
      vb.pack_start(btn, expand = True, fill = True, padding = 10)
      hb = gtk.HBox()
		
      lbl1 = gtk.Label("Enter marks")
      hb.pack_start(lbl1, expand = True, fill = True, padding = 5)
      text1 = gtk.Entry()
		
      hb.pack_start(text1, expand = True, fill = True, padding = 5)
      btn1 = gtk.Button(stock = gtk.STOCK_SAVE)
		
      hb.pack_start(btn1, expand = True, fill = True, padding = 5)
      box.add(vb)
      box.add(hb)
      self.add(box)
      self.show_all()
PyApp()
gtk.main()

Il codice precedente produrrà il seguente output:

La classe ButtonBox nell'API gtk funge da classe base per i contenitori per contenere più pulsanti orizzontalmente o verticalmente. Due sottoclassi HButtonBox e VButtonBox derivano dalla classe ButtonBox, che a sua volta è una sottoclasse della classe gtk.Box.

Una casella pulsante viene utilizzata per fornire un layout coerente dei pulsanti in tutta l'applicazione. Fornisce un layout predefinito e un valore di spaziatura predefinito che sono persistenti in tutti i widget.

Il set_spacing() metodo della classe gtk.Box può essere utilizzato per modificare la spaziatura predefinita tra i pulsanti nella casella del pulsante.

Il layout predefinito dei pulsanti può essere modificato dal set_default()metodo. I possibili valori del layout dei pulsanti sono:

  • gtk.BUTTONBOX_SPREAD

  • gtk.BUTTONBOX_EDGE

  • gtk.BUTTONBOX_START

  • gtk.BUTTONBOX_END.

Esempio

Nell'esempio seguente, un oggetto VBox all'interno della finestra di primo livello contiene internamente un oggetto VButtonBox e un oggetto HButtonBox, ciascuno contenente due pulsanti, disposti rispettivamente verticalmente e orizzontalmente.

Rispetta il codice -

import gtk

class PyApp(gtk.Window):
   def __init__(self):
      super(PyApp, self).__init__()
      
	  self.set_title("Button Box demo")
      self.set_size_request(200,100)
      self.set_position(gtk.WIN_POS_CENTER)
	  vb = gtk.VBox()
      box1 = gtk.VButtonBox()
      btn1 = gtk.Button(stock = gtk.STOCK_OK)
      btn2 = gtk.Button(stock = gtk.STOCK_CANCEL)
		
      box1.pack_start(btn1, True, True, 0)
      box1.pack_start(btn2, True, True, 0)
      box1.set_border_width(5)
		
      vb.add(box1)
      box2 = gtk.HButtonBox()
      btn3 = gtk.Button(stock = gtk.STOCK_OK)
      btn4 = gtk.Button(stock = gtk.STOCK_CANCEL)
		
      ent = gtk.Entry()
      box2.pack_start(btn3, True, True, 0)
      box2.pack_start(btn4, True, True, 0)
      box1.set_border_width(5)
		
      vb.add(box2)
      self.add(vb)
      self.show_all()

PyApp()
gtk.main()

Il codice precedente genera il seguente output:

Questo widget si rivela utile per controllare l'allineamento e la dimensione dei suoi widget figlio. Ha quattro proprietà chiamate xalign, yalign, xscale e yscale. Le proprietà di scala specificano quanto spazio libero verrà utilizzato dai widget figlio. Le proprietà di allineamento vengono utilizzate per posizionare il widget figlio all'interno dell'area disponibile.

Tutte e quattro le proprietà assumono un valore float compreso tra 0 e 1.0. Se le proprietà xscale e yscale sono impostate su 0, significa che il widget non assorbe lo spazio libero e se impostato su 1, il widget assorbe il massimo spazio libero rispettivamente in orizzontale o in verticale.

La proprietà xalign e yalign se impostata su 0, significa che non ci sarà spazio libero a sinistra o sopra il widget. Se impostato a 1, ci sarà il massimo spazio libero a sinistra o sopra il widget.

La classe gtk.alignment ha il seguente costruttore:

gtk.alignment(xalign = 0.0, yalign = 0.0, xscale = 0.0, yscale = 0.0)

Dove,

  • xalign - È la frazione dello spazio libero orizzontale a sinistra del widget figlio.

  • yalign - È la frazione dello spazio libero verticale sopra il widget figlio.

  • xscale - È la frazione di spazio libero orizzontale che il widget figlio assorbe.

  • yscale - È la frazione dello spazio libero verticale che il widget figlio assorbe.

Esempio

Il codice seguente mostra l'uso del widget gtk.alignment. Una Vbox nella finestra di primo livello ha una Vbox superiore e una Hbox inferiore posizionate in essa. Nella casella verticale superiore, un'etichetta e un widget Entry sono posizionati in modo tale che verso sinistra, il 50% dello spazio viene mantenuto libero e più del 25% di questo viene occupato assegnando 0,5 xalign e 0,25 alle proprietà yalign.

Nell'HBox inferiore, tutto lo spazio libero disponibile è sul lato sinistro. Ciò si ottiene assegnando 1 alla proprietà xalign. Quindi, due pulsanti nella casella orizzontale appaiono allineati a destra.

import gtk

class PyApp(gtk.Window):
   
   def __init__(self):
      super(PyApp, self).__init__()
      self.set_title("Alignment demo")
      self.set_size_request(400,200)
      self.set_position(gtk.WIN_POS_CENTER)
		
      vbox = gtk.VBox(False, 5)
      vb = gtk.VBox()
      hbox = gtk.HBox(True, 3)
      valign = gtk.Alignment(0.5,0.25, 0, 0)
		
      lbl = gtk.Label("Name of student")
      vb.pack_start(lbl, True, True, 10)
      text = gtk.Entry()
		
      vb.pack_start(text, True, True, 10)
      valign.add(vb)
      vbox.pack_start(valign)
		
      ok = gtk.Button("OK")
      ok.set_size_request(70, 30)
		
      close = gtk.Button("Close")
      hbox.add(ok)
      hbox.add(close)
		
      halign = gtk.Alignment(1, 0, 0, 0)
      halign.add(hbox)
		
      vbox.pack_start(halign, False, False, 3)
		
      self.add(vbox)
      self.connect("destroy", gtk.main_quit)
      self.show_all()
PyApp()
gtk.main()

Il codice precedente produce il seguente output:

Alcuni widget nel toolkit PyGTK non hanno una propria finestra. Tali widget senza finestra non possono ricevere segnali di eventi. Tali widget, ad esempio un'etichetta, se inseriti in un eventbox possono ricevere segnali.

EventBox è un contenitore invisibile che fornisce finestre a widget senza finestre. Ha un semplice costruttore senza alcun argomento -

gtk.EventBox()

Esempio

Nell'esempio seguente, due widget di gtk.EventBox sono posizionati nella finestra di primo livello. All'interno di ogni eventbox, viene aggiunta un'etichetta. L'eventbox è ora connesso a una funzione di callback per elaborare il button_press_event su di esso. Poiché la casella degli eventi stessa è invisibile, effettivamente l'evento si verifica sull'etichetta incorporata. Quindi, come e quando facciamo clic su qualsiasi etichetta, viene richiamata la funzione di callback corrispondente.

Rispetta il codice -

import gtk

class PyApp(gtk.Window):
   
   def __init__(self):
      super(PyApp, self).__init__()
      self.set_title("EventBox demo")
      self.set_size_request(200,100)
      self.set_position(gtk.WIN_POS_CENTER)
      fixed = gtk.Fixed()
      
      event1 = gtk.EventBox()
      label1 = gtk.Label("Label 1")
      event1.add(label1)
      fixed.put(event1, 80,20)
      
      event1.connect("button_press_event",self.hello1)
      event2 = gtk.EventBox()
      label2 = gtk.Label("Label 2")
      event2.add(label2)
      event2.connect("button_press_event",self.hello2)
      fixed.put(event2, 80,70)
      
      self.add(fixed)
      self.connect("destroy", gtk.main_quit)
      self.show_all()
		
   def hello1(self, widget, event):
      print "clicked label 1"
		
   def hello2(self, widget, event):
      print "clicked label 2"

PyApp()
gtk.main()

Il codice precedente genera il seguente output:

Quando si fa clic sull'etichetta 1 sulla console, viene stampato il messaggio "etichetta 1 selezionata". Allo stesso modo, quando si fa clic sull'etichetta 2, viene stampato il messaggio "etichetta 2 cliccata".

Gtk.Layout è un widget contenitore simile a gtk.Fixed. I widget vengono inseriti nel widget Layout specificando le coordinate assolute. Tuttavia, il layout differisce dal widget fisso nei seguenti modi:

  • Il widget di layout può avere larghezza e altezza infinite. Il valore massimo di larghezza e altezza è limitato dalla dimensione dell'intero senza segno.

  • Un widget gtk.DrawingArea può essere racchiuso in un contenitore di layout. DrawingArea è una tela su cui è possibile disegnare elementi 2D come linea, rettangolo, ecc.

  • Per mettere il contenitore Layout nella finestra di primo livello di dimensioni minori, può essere associato alle barre di scorrimento o può essere posizionato in una Finestra a scorrimento.

La classe gtk.Layout ha il seguente costruttore:

gtk.Layout(hadjustment = None, vadjustment = None)

Il hadjustment e vadjustment le proprietà rappresentano un oggetto con un valore limitato regolabile.

La tabella seguente elenca i metodi di layout utilizzati di frequente:

put (widget, x, y) Posiziona un widget figlio alle coordinate specificate
set_size (w, h) Imposta la dimensione del contenitore Layout sulla larghezza e l'altezza specificate

L'oggetto Layout emette il segnale set_scroll_adjustment quando vengono modificate le regolazioni ad esso associate.

Esempio

Nell'esempio seguente, un'etichetta viene stimolata al centro di un contenitore Layout, che a sua volta deve essere posizionato in una finestra di primo livello di dimensioni inferiori. Quindi, viene prima aggiunto a ScrolledWindow e ScrolledWindow viene quindi aggiunto alla finestra principale.

Rispetta il codice -

import gtk

class PyApp(gtk.Window):
   
   def __init__(self):
      super(PyApp, self).__init__()
      self.set_title("layout")
      self.set_size_request(300,200)
      self.set_position(gtk.WIN_POS_CENTER)
      sc = gtk.ScrolledWindow()
      lo = gtk.Layout()
      lo.set_size(400,400)
      button = gtk.Button("Press Me")
      lo.put(button, 125,200)
      sc.add(lo)
      self.add(sc)
      self.connect("destroy", gtk.main_quit)
      self.show_all()

PyApp()
gtk.main()

Il codice sopra genererà il seguente output:

ComboBox è un widget potente e popolare in qualsiasi toolkit GUI. Fornisce un elenco a discesa di elementi da cui un utente può scegliere. Il widget gtk.ComboBox implementa l'interfaccia CellLayout e fornisce una serie di metodi per gestire la visualizzazione degli elementi.

L'oggetto della classe gtk.ComboBox è associato a ListSore, che è un modello di elenco che può essere utilizzato con widget che visualizzano una raccolta di elementi. Gli elementi vengono aggiunti a ListStore con il metodo append (). Inoltre, un oggetto CellRendererText viene creato e impacchettato nella casella combinata.

Segui questi passaggi per configurare una casella combinata.

combobox = gtk.ComboBox()
store = gtk.ListStore(gobject.TYPE_STRING)
cell = gtk.CellRendererText()
combobox.pack_start(cell)
combobox.add_attribute(cell, 'text', 0)

PyGTK offre un metodo conveniente: gtk.combo_box_new_text()per creare una casella combinata invece di utilizzare un archivio di elenchi. I metodi di convenienza associati append_text (), prepend_text (), insert_text () e remove_text () vengono utilizzati per gestire i contenuti della casella combinata.

La classe gtk.ComboBox ha i seguenti metodi:

S.NO Metodi e descrizione
1

set_wrap_width()

Imposta il numero di colonne da visualizzare nel layout della tabella popup

2

get_active()

Restituisce il valore della proprietà "attiva" che è l'indice nel modello dell'elemento attualmente attivo

3

set_active()

Imposta l'elemento attivo della combo_box sull'elemento con l'indice del modello specificato

4

set_model()

Imposta il modello utilizzato dalla casella combinata

5

append_text()

Aggiunge la stringa specificata dal testo all'elenco di stringhe archiviate nell'archivio elenco delle caselle combinate

6

Insert_text()

Inserisce la stringa specificata dal testo nella casella combinata gtk.ListStore in corrispondenza dell'indice specificato dalla posizione

7

prepend_text()

Antepone la stringa specificata dal testo all'elenco di stringhe archiviate nell'archivio elenchi

8

remove_text()

Rimuove la stringa in corrispondenza dell'indice specificato dalla posizione nel liststore associato

9

get_active_text()

Restituisce la stringa attualmente attiva

Il widget ComboBox emette i seguenti segnali:

cambiato Viene emesso quando viene selezionato un nuovo elemento nella casella combinata
move_active Questo è un segnale di associazione dei tasti che viene emesso per spostare la selezione attiva.
Popdown Questo è un segnale di associazione dei tasti che viene emesso per visualizzare l'elenco delle caselle combinate. Le associazioni predefinite per questo segnale sono Alt + Su ed Esc
Apparire Questo è un segnale di associazione dei tasti che viene emesso per far apparire l'elenco della casella combinata. Le associazioni predefinite per questo segnale sono Alt + Giù.

Di seguito sono riportati due codici di esempio per la dimostrazione di ComboBox.

Esempio 1

In questo esempio, un ListStore è popolato con i nomi dei popolari toolkit della GUI Python ed è associato a un widget ComboBox. Quando un utente fa una scelta, viene emesso il segnale modificato. È collegato a una funzione di callback per visualizzare la scelta dell'utente.

import pygtk
pygtk.require('2.0')
import gtk

class PyApp(gtk.Window):
   def __init__(self):
      super(PyApp, self).__init__()
      self.set_title("ComboBox with ListStore")
      self.set_default_size(250, 200)
      self.set_position(gtk.WIN_POS_CENTER)
      
      combobox = gtk.ComboBox()
      store = gtk.ListStore(str)
      cell = gtk.CellRendererText()
      combobox.pack_start(cell)
      combobox.add_attribute(cell, 'text', 0)
      fixed = gtk.Fixed()
      lbl = gtk.Label("select a GUI toolkit")
      fixed.put(lbl, 25,75)
      fixed.put(combobox, 125,75)
      lbl2 = gtk.Label("Your choice is:")
      fixed.put(lbl2, 25,125)
      self.label = gtk.Label("")
      fixed.put(self.label, 125,125)
      self.add(fixed)
      
      store.append (["PyQt"])
      store.append (["Tkinter"])
      store.append (["WxPython"])
      store.append (["PyGTK"])
      store.append (["PySide"])
      combobox.set_model(store)
      combobox.connect('changed', self.on_changed)
      combobox.set_active(0)
      self.connect("destroy", gtk.main_quit)
      self.show_all()
      return
   
   def on_changed(self, widget):
      self.label.set_label(widget.get_active_text())
      return
      
if __name__ == '__main__':
PyApp()
gtk.main()

Al momento dell'esecuzione, il programma visualizza il seguente output:

Esempio 2

La seconda versione del programma utilizza il metodo conveniente combo_box_new_text()per creare una casella combinata e la funzione append_text () per aggiungere stringhe al suo interno. In entrambi i programmi, ilget_active_text() viene utilizzato per recuperare la selezione dell'utente e visualizzarla su un'etichetta nella finestra.

import gtk

class PyApp(gtk.Window):
   def __init__(self):
      super(PyApp, self).__init__()
      self.set_title("Simple ComboBox")
      self.set_default_size(250, 200)
      self.set_position(gtk.WIN_POS_CENTER)
      
      cb = gtk.combo_box_new_text()
      cb.connect("changed", self.on_changed)
      cb.append_text('PyQt')
      cb.append_text('Tkinter')
      cb.append_text('WxPython')
      cb.append_text('PyGTK')
      cb.append_text('PySide')
      
      fixed = gtk.Fixed()
      lbl = gtk.Label("select a GUI toolkit")
      fixed.put(lbl, 25,75)
      
      fixed.put(cb, 125,75)
      lbl2 = gtk.Label("Your choice is:")
      fixed.put(lbl2, 25,125)
      
      self.label = gtk.Label("")
      fixed.put(self.label, 125,125)
      self.add(fixed)
      self.connect("destroy", gtk.main_quit)
      self.show_all()
   
   def on_changed(self, widget):
      self.label.set_label(widget.get_active_text())
if __name__ == '__main__':
   PyApp()
   gtk.main()

L'output di questo programma è simile a quello del programma precedente.

Il widget ToggleButton è un gtk.Button con due stati: a pressed or active (o su) stato e a normal or inactive (or off)stato. Ogni volta che si preme il pulsante, lo stato si alterna. Lo stato del ToggleButton può anche essere modificato a livello di codice tramite il metodo set_active (). Per cambiare lo stato del pulsante, è disponibile anche il metodo toggled ().

La classe gtk.ToggleButton ha il seguente costruttore:

gtk.ToggleButton(label = None, use_underline = True)

Qui, l'etichetta è il test da visualizzare sul pulsante. La proprietà use_underline, se True, un trattino basso nel testo indica che il carattere successivo deve essere sottolineato e utilizzato per l'acceleratore mnemonico.

Alcuni dei metodi importanti della classe gtk.ToggleButton sono riportati nella tabella seguente:

set_active () Questo imposta il active proprietà al valore a True (attivo o premuto o acceso) o False (inattivo o normale o spento)
get_active () Questo recupera lo stato del pulsante
alternato () Questo emette il segnale "attivato / disattivato" sul pulsante di attivazione / disattivazione.

Il widget ToggleButton emette il seguente segnale:

Commutato Viene emesso quando lo stato del pulsante di attivazione / disattivazione cambia a livello di codice o dall'azione dell'utente.

Il codice fornito di seguito dimostra l'uso dei widget ToggleButton.

Due widget ToggleButtons e Label vengono inseriti in un contenitore VBox. Il segnale alternato emesso da Button1 è connesso a una funzione di callback on_toggled (). In questa funzione, lo stato di Button2 è impostato su True se quello di Button1 è False e viceversa.

if self.btn1.get_active() == True:
   self.btn2.set_active(False)
else:
   self.btn2.set_active(True)

Visualizza gli stati istantanei dei pulsanti sull'etichetta.

Esempio

Rispettare il codice seguente:

import gtk

 PyApp(gtk.Window):
   
   def __init__(self):
      super(PyApp, self).__init__()
      self.set_title("Toggle Button")
      self.set_default_size(250, 200)
      self.set_position(gtk.WIN_POS_CENTER)
      
      vbox = gtk.VBox()
      self.btn1 = gtk.ToggleButton("Button 1")
      self.btn1.connect("toggled", self.on_toggled)
      self.btn2 = gtk.ToggleButton("Button 2")
      self.lbl = gtk.Label()
      
      vbox.add(self.btn1)
      vbox.add(self.btn2)
      vbox.add(self.lbl)
      self.add(vbox)
      self.connect("destroy", gtk.main_quit)
      self.show_all()
   
   def on_toggled(self, widget, data = None):
      if self.btn1.get_active() == True:
         self.btn2.set_active(False)
      else:
         self.btn2.set_active(True)
         state = "Button1 : "+str(self.btn1.get_active())+" 
         Button2 : "+str(self.btn2.get_active())
         self.lbl.set_text(state)
if __name__ == '__main__':
   PyApp()
   gtk.main()

Il codice precedente genera il seguente output:

Un widget CheckButton non è altro che un ToggleButton disegnato come una casella di controllo e un'etichetta. Eredita tutte le proprietà e i metodi dalla classe ToggleButton. A differenza di ToggleButton in cui la didascalia si trova sulla faccia del pulsante, un CheckButton mostra un quadratino che è controllabile e ha un'etichetta alla sua destra.

Costruttore, metodi e segnali associati a gtk.CheckButton sono esattamente gli stessi di gtk.ToggleButton.

Esempio

L'esempio seguente mostra l'uso del widget CheckButton. Due CheckButtons e un'etichetta vengono inseriti in un VBox. Il segnale attivato / disattivato del primo CheckButton è connesso al metodo on_checked () che imposta lo stato del secondo pulsante su True se quello del primo è falso e viceversa.

Rispetta il codice -

import gtk

class PyApp(gtk.Window):
   
   def __init__(self):
      super(PyApp, self).__init__()
      self.set_title("Check Button")
      self.set_default_size(250, 200)
      self.set_position(gtk.WIN_POS_CENTER)

      vbox = gtk.VBox()
      self.btn1 = gtk.CheckButton("Button 1")
      self.btn1.connect("toggled", self.on_checked)
      self.btn2 = gtk.CheckButton("Button 2")
      self.btn2.connect("toggled", self.on_checked)
      self.lbl = gtk.Label()
		
      vbox.add(self.btn1)
      vbox.add(self.btn2)
      vbox.add(self.lbl)
		
      self.add(vbox)
      self.connect("destroy", gtk.main_quit)
      self.show_all()
		
   def on_checked(self, widget, data = None):
      state = "Button1 : "+str(self.btn1.get_active())+" 
         Button2 : "+str(self.btn2.get_active())
      self.lbl.set_text(state)
if __name__ == '__main__':
   PyApp()
   gtk.main()

Il codice sopra genererà il seguente output:

Un singolo widget RadioButton offre funzionalità simili a CheckButton. Tuttavia, quando più di un pulsante di opzione è presente nello stesso contenitore, è disponibile una scelta mutuamente esclusiva per l'utente che può scegliere tra una delle opzioni disponibili. Se ogni pulsante di opzione nel contenitore appartiene allo stesso gruppo, quando ne viene selezionato uno, gli altri vengono automaticamente deselezionati.

Quello che segue è un costruttore della classe gtk.RadioButton -

gtk.RadioButton(group = None, Label = None, unerline = None)

Per creare un gruppo di pulsanti, fornire group=None per il primo pulsante di opzione e per le opzioni successive, fornire l'oggetto del primo pulsante come gruppo.

Come nel caso di ToggleButton e CheckButton, anche il RadioButton emette the toggled signal. Nell'esempio riportato di seguito, tre oggetti del widget gtk.RadioButton sono posizionati in un VBox. Tutti sono collegati a una funzione di callback on_selected (), per elaborare il segnale commutato.

La funzione di callback identifica l'etichetta del widget RadioButton di origine e la visualizza sull'etichetta inserita nel VBox.

Esempio

Rispettare il codice seguente:

import gtk

class PyApp(gtk.Window):

   def __init__(self):
      super(PyApp, self).__init__()
      self.set_title("Radio Button")
      self.set_default_size(250, 200)
      self.set_position(gtk.WIN_POS_CENTER)
      vbox = gtk.VBox()
      
      btn1 = gtk.RadioButton(None, "Button 1")
      btn1.connect("toggled", self.on_selected)
      btn2 = gtk.RadioButton(btn1,"Button 2")
      btn2.connect("toggled", self.on_selected)
      btn3 = gtk.RadioButton(btn1,"Button 3")
      btn3.connect("toggled", self.on_selected)
      
      self.lbl = gtk.Label()
      vbox.add(btn1)
      vbox.add(btn2)
      vbox.add(btn3)
      vbox.add(self.lbl)
      self.add(vbox)
      self.connect("destroy", gtk.main_quit)
      self.show_all()
   
   def on_selected(self, widget, data=None):
      self.lbl.set_text(widget.get_label()+" is selected")
if __name__ == '__main__':
   PyApp()
   gtk.main()

Il codice sopra genererà il seguente output:

Una barra orizzontale appena sotto la barra del titolo di un gtk di livello superiore. La finestra è riservata alla visualizzazione di serie di menu. È un oggetto della classe gtk.MenuBar nell'API PyGTK.

Un oggetto della classe gtk.Menu viene aggiunto alla barra dei menu. Viene anche utilizzato per creare menu contestuali e menu popup. Ogni menu può contenere uno o più widget gtk.MenuItem. Alcuni di essi possono essere sottomenu e avere pulsanti MenuItem a cascata.

Gtk.MenuBar è una sottoclasse della classe gtk.MenuShell. Ha un semplice costruttore predefinito -

gtk.MenuBar()

Per aggiungere un menu a MenuBar, viene utilizzato il metodo append () della classe MenuBar.

Per costruire un menu, creare un widget MenuItem con un'etichetta che si desidera appaia nella barra dei menu e impostarla come sottomenu.

Ad esempio, il codice seguente viene utilizzato per impostare un menu File:

menu1 = gtk.Menu()
file = gtk.MenuItem("_File")
file.set_submenu(menu1)

Ora è possibile aggiungere uno o più widget della classe MenuItem nel menu.

item1 = gtk.MenuItem("New")
item2 = gtk.MenuItem("Open")

Questi MenuItem vengono aggiunti al widget Menu e l'oggetto menu a sua volta viene aggiunto alla barra dei menu.

menu1.append(item1)
menu1.append(item2)
mb.append(menu1)

Il toolkit PyGTK offre molti tipi di widget MenuItem. Un ImageMenuItem è una voce di menu a cui è associata un'immagine. È possibile utilizzare una qualsiasi delle immagini stock utilizzando il parametro Stock ID o assegnare qualsiasi altra immagine con il metodo set_image ().

Ad esempio, la voce di menu "Nuovo" con immagine viene creata nel modo seguente:

new = gtk.ImageMenuItem(gtk.STOCK_NEW)
menu1.append(new)

Allo stesso modo, è anche possibile aggiungere CheckMenuItem utilizzando il codice seguente:

chk = gtk.CheckMenuItem("Checkable")
menu1.append(chk)

È anche possibile aggiungere un gruppo di elementi radio utilizzando questo codice:

radio1 = gtk.RadioMenuItem(None,"Radio1")
radio2 = gtk.RadioMenuItem(radio1, "Radio2")
menu1.append(radio1)
menu1.append(radio2)

A volte, potresti voler aggiungere una linea di separazione tra le voci di menu. A tale scopo, ilSeparatorMenuItem è anche disponibile.

sep = gtk.SeparatorMenuItem()
menu1.append(sep)

Puoi anche assegnare scorciatoie da tastiera alle voci di menu. PyGTK ha acceleratori. Inizia creando un gruppo di acceleratori e collegalo alla finestra di primo livello.

acgroup = gtk.AccelGroup()
self.add_accel_group(acgroup)

Per assegnare la scorciatoia, usa add_accelerator() funzione con il seguente prototipo:

Item1.add_accelerator(signal, group, key, modifier, flags)

I seguenti sono alcuni dei modificatori predefiniti:

  • SHIFT_MASK
  • LOCK_MASK
  • CONTROL_MASK
  • BUTTON1_MASK
  • BUTTON1_MASK

Per assegnare la scorciatoia Ctrl + N alla voce Nuovo menu, utilizzare la seguente sintassi:

new = gtk.ImageMenuItem(gtk.STOCK_NEW,acgroup)
new.add_accelerator("activate", acgroup, ord('N'), 
   gtk.gdk.CONTROL_MASK, gtk.ACCEL_VISIBLE)

Esempio

L'esempio seguente mostra le funzionalità discusse sopra:

import gtk

class PyApp(gtk.Window):
   def __init__(self):
      
      super(PyApp, self).__init__()
      self.set_title("Menu Demo")
      self.set_default_size(250, 200)
      self.set_position(gtk.WIN_POS_CENTER)
      
      mb = gtk.MenuBar()
      
	  menu1 = gtk.Menu()
      file = gtk.MenuItem("_File")
      file.set_submenu(menu1)
      acgroup = gtk.AccelGroup()
      self.add_accel_group(acgroup)
      new = gtk.ImageMenuItem(gtk.STOCK_NEW,acgroup)
      new.add_accelerator("activate", acgroup, ord('N'), 
         gtk.gdk.CONTROL_MASK, gtk.ACCEL_VISIBLE)
      
      menu1.append(new)
      open = gtk.ImageMenuItem(gtk.STOCK_OPEN)
      
      menu1.append(open)
      chk = gtk.CheckMenuItem("Checkable")
      
      menu1.append(chk)
      radio1 = gtk.RadioMenuItem(None,"Radio1")
      radio2 = gtk.RadioMenuItem(radio1, "Radio2")
      
      menu1.append(radio1)
      menu1.append(radio2)
      sep = gtk.SeparatorMenuItem()
      
      menu1.append(sep)
      exit = gtk.ImageMenuItem(gtk.STOCK_QUIT)
      
      menu1.append(exit)
      menu2 = gtk.Menu()
      edit = gtk.MenuItem("_Edit")
      edit.set_submenu(menu2)
      copy = gtk.ImageMenuItem(gtk.STOCK_COPY)
      
      menu2.append(copy)
      cut = gtk.ImageMenuItem(gtk.STOCK_CUT)
      
      menu2.append(cut)
      paste = gtk.ImageMenuItem(gtk.STOCK_PASTE)
      
      menu2.append(paste)
      mb.append(file)
      mb.append(edit)
      vbox = gtk.VBox(False, 2)
      vbox.pack_start(mb, False, False, 0)
      
      self.add(vbox)
      self.connect("destroy", gtk.main_quit)
      self.show_all()
if __name__ == '__main__':
   PyApp()
   gtk.main()

Il codice precedente produrrà il seguente output:

La classe della barra degli strumenti viene ereditata dalla classe gtk.Container. Contiene e gestisce una serie di pulsanti e altri widget. Una o più strisce orizzontali di pulsanti sono normalmente visualizzate appena sotto la barra dei menu in una finestra di primo livello. La barra degli strumenti può anche essere inserita in una finestra rimovibile chiamata HandleBox. Per impostazione predefinita, i pulsanti nel widget gtk.Toolbar sono disposti orizzontalmente. La barra degli strumenti verticale può essere configurata impostando la proprietà di orientamento sugtk.ORIENTATION_VERTICAL.

La barra degli strumenti può essere configurata per mostrare pulsanti con icone, testo o entrambi. Gli enumeratori di stile sono:

gtk.TOOLBAR_ICONS Questi pulsanti visualizzano solo le icone nella barra degli strumenti.
gtk.TOOLBAR_TEXT Questi pulsanti visualizzano solo etichette di testo nella barra degli strumenti.
gtk.TOOLBAR_BOTH Questi pulsanti visualizzano testo e icone nella barra degli strumenti.
gtk.TOOLBAR_BOTH_HORIZ Questi pulsanti visualizzano icone e testo uno accanto all'altro, anziché impilati verticalmente.

Un widget della barra degli strumenti viene impostato utilizzando il seguente costruttore:

bar = gtk.Toolbar()

I componenti di Toolbar sono istanze di gtk.ToolItem. Gli elementi possono essere ToolButton, RadioToolButton, ToggleToolButton o SeparatorToolItem. Per assegnare un'icona all'oggetto ToolItem, è possibile utilizzare immagini con stock_ID predefinito oppure è possibile assegnare un'immagine personalizzata mediante il metodo set_image ().

I seguenti esempi mostrano come costruire diversi ToolItem:

ToolButton

newbtn = gtk.ToolButton(gtk.STOCK_NEW)

RadioToolButton

rb1 = gtk.RadioToolButton(None,gtk.STOCK_JUSTIFY_LEFT) 
rb2 = gtk.RadioToolButton(rb1,gtk.STOCK_JUSTIFY_RIGHT)

Notare che più pulsanti di opzione vengono inseriti nello stesso gruppo.

SeparatorToolItem

sep = gtk.SeparatorToolItem()

Questi elementi vengono inseriti nella barra degli strumenti chiamando il suo insert metodo.

gtk.Toolbar.insert(item, index)

Per esempio,

bar.insert(new,0)

Puoi anche assegnare un suggerimento al ToolButton usando il nethod set_tooltip_text (). Per esempio,New il tooltip viene assegnato al nuovo ToolButton.

newbtn.set_tooltip_text("New")

Esempio

Il codice seguente mostra una finestra di primo livello con una barra degli strumenti impostata per contenere un normale strumento, elementi radio e un elemento separatore.

import gtk

class PyApp(gtk.Window):

   def __init__(self):
      super(PyApp, self).__init__()
      self.set_title("Toolbar Demo")
      self.set_default_size(250, 200)
      self.set_position(gtk.WIN_POS_CENTER)
      
      toolbar = gtk.Toolbar()
      toolbar.set_style(gtk.TOOLBAR_ICONS)
      toolbar.set_orientation(gtk.ORIENTATION_HORIZONTAL)
      
      newbtn = gtk.ToolButton(gtk.STOCK_NEW)
      newbtn.set_tooltip_text("New")
      openbtn = gtk.ToolButton(gtk.STOCK_OPEN)
      savebtn = gtk.ToolButton(gtk.STOCK_SAVE)
      sep = gtk.SeparatorToolItem()
      
      rb1 = gtk.RadioToolButton(None,gtk.STOCK_JUSTIFY_LEFT)
      53
      rb2 = gtk.RadioToolButton(rb1,gtk.STOCK_JUSTIFY_RIGHT)
      
      prv = gtk.ToggleToolButton(gtk.STOCK_PRINT_PREVIEW)
      quitbtn = gtk.ToolButton(gtk.STOCK_QUIT)
      
      toolbar.insert(newbtn, 0)
      toolbar.insert(openbtn, 1)
      toolbar.insert(savebtn, 2)
      toolbar.insert(sep, 3)
      toolbar.insert(rb1,4)
      toolbar.insert(rb2,5)
      toolbar.insert(prv,6)
      toolbar.insert(quitbtn, 7)
      
      quitbtn.connect("clicked", gtk.main_quit)
      vbox = gtk.VBox(False, 2)
      vbox.pack_start(toolbar, False, False, 0)
      
      self.add(vbox)
      self.connect("destroy", gtk.main_quit)
      self.show_all()
   
   def on_checked(self, widget, data = None):
      state = "Button1 : "+str(self.btn1.get_active())+" 
         Button2 : "+str(self.btn2.get_active())
      self.lbl.set_text(state)
if __name__ == '__main__':
   PyApp()
   gtk.main()

Il codice sopra genererà il seguente output:

Alcuni widget nel toolkit PyGTK sono tali che le loro proprietà possono essere regolate su un intervallo specificato dall'utente utilizzando un mouse o una tastiera. Un widget come Viewport viene utilizzato per visualizzare una parte regolabile di dati di grandi dimensioni, ad esempio un testo multilinea nel controllo TextView.

PyGTK utilizza l'oggetto gtk.Adjustment da utilizzare in associazione con tali widget in modo che le modifiche dell'utente vengano passate a qualche funzione di callback per l'elaborazione. Un oggetto Adjustment contiene i limiti inferiore e superiore di un valore regolabile e i suoi parametri di incremento. Quando i parametri dell'oggetto di regolazione cambiano, emette segnali modificati o value_changed.

Quello che segue è il costruttore della classe gtk.Adjustment -

gtk.Adjustment(value = 0, lower = 0, upper = 0, step_incr = 0, 
   page_incr = 0, page_size = 0)

Il significato di ciascuno degli attributi nel costruttore è il seguente:

valore Il valore iniziale
inferiore Il valore minimo
superiore Il valore massimo
step_incr L'incremento del passo
page_incr L'incremento di pagina
dimensioni della pagina Le dimensioni della pagina

I seguenti segnali vengono emessi dall'oggetto Regolazione:

Cambiato Viene emesso quando uno (o più) degli attributi di regolazione (eccetto l'attributo del valore) è cambiato.
Valore modificato Viene emesso quando l'attributo del valore di regolazione è cambiato.

Come accennato in precedenza, l'oggetto Adjustment non è un widget fisico. Piuttosto, viene utilizzato in associazione con gli altri widget utilizzando i quali i suoi attributi vengono modificati. I widget intervallo vengono utilizzati insieme all'oggetto Regolazione.

Questa classe funge da classe base per i widget che consentono all'utente di regolare il valore di un parametro numerico tra i limiti inferiore e superiore. I widget di scala (gtk.Hscale e gtk.Vscale) e i widget della barra di scorrimento (gtk.HScrollbar e gtk.VScrollbar) derivano la funzionalità dalla classe Range. Questi widget Intervallo funzionano insieme all'oggetto Regolazione.

Le seguenti importanti funzioni della classe gtk.Range sono implementate dai widget Scale e Scrollbar:

  • set_update_policy()- Questo imposta la proprietà "update-policy" sul valore. La politica ha i seguenti valori:

gtk.UPDATE_CONTINUOUS ogni volta che il cursore dell'intervallo viene spostato, il valore dell'intervallo cambierà e verrà emesso il segnale "valore_cambiato".
gtk.UPDATE_DELAYED il valore verrà aggiornato dopo un breve timeout in cui non si verifica alcun movimento del cursore, quindi le modifiche del valore vengono ritardate leggermente anziché essere aggiornate continuamente.
gtk.UPDATE_DISCONTINUOUS il valore verrà aggiornato solo quando l'utente rilascia il pulsante e termina l'operazione di trascinamento dello slider.
  • set_adjustment()- Questo imposta la proprietà "regolazione". L'oggetto Regolazione viene utilizzato come modello per l'oggetto Intervallo.

  • set_increments() - Questo imposta il passo e le dimensioni della pagina per l'intervallo.

  • set_range() - Imposta i valori minimi e massimi consentiti per il widget Intervallo

  • set_value() - Questo imposta il valore corrente dell'intervallo sul valore specificato.

Le classi widget di scala - (HScale e VScale) derivano dalla classe gtk.Range.

Questa classe funge da classe base astratta per i widget HScale e VScale. Questi widget funzionano come un controllo a scorrimento e selezionano un valore numerico.

I seguenti metodi di questa classe astratta sono implementati dalla classe HScale e dalla classe VScale:

  • set_digits() - Imposta il numero di posizioni decimali da utilizzare per visualizzare il valore istantaneo del widget.

  • set_draw_value() - impostato su True, il valore corrente verrà visualizzato accanto al dispositivo di scorrimento.

  • set_value_pos()- Questa è la posizione in cui vengono disegnati i valori. Può essere gtk.POS_LEFT, gtk.POS_RIGHT, gtk.POS_TOP o gtk.POS_BOTTOM.

Un oggetto della classe gtk.HScale fornisce un cursore orizzontale, mentre un oggetto della classe gtk.VScale fornisce un cursore verticale. Entrambe le classi hanno costruttori identici -

gtk.HScale(Adjustment = None)
gtk.VScale(Adjustment = None)

L'oggetto di regolazione contiene molti attributi che forniscono accesso a valori e limiti.

Questa classe è una classe base astratta per i widget gtk.Hscrollbar e gtk.Vscrollbar. Entrambi sono associati a un oggetto di regolazione. La posizione del pollice della barra di scorrimento è controllata dalle regolazioni di scorrimento. Gli attributi dell'oggetto di regolazione vengono utilizzati come segue:

inferiore Il valore minimo della regione di scorrimento
superiore Il valore massimo della regione di scorrimento
valore Rappresenta la posizione della barra di scorrimento, che deve essere compresa tra inferiore e superiore
dimensioni della pagina Rappresenta la dimensione dell'area scorrevole visibile
step_increment Distanza da scorrere quando si fa clic sulle piccole frecce stepper
page_increment Distanza per scorrere quando il Page Up o Page Down tasti premuti

Il seguente programma mostra un widget HScale e HScrollbar inseriti in un VBox aggiunto alla finestra di livello superiore. Ciascuno di essi è associato a un oggetto di regolazione.

adj1 = gtk.Adjustment(0, 0, 101, 0.1, 1, 1)
self.adj2 = gtk.Adjustment(10,0,101,5,1,1)

Un widget gtk.HScale è un controllo a scorrimento collegato con adj1. La politica di aggiornamento, il numero e la posizione del valore di prelievo sono impostati come segue:

scale1 = gtk.HScale(adj1)
scale1.set_update_policy(gtk.UPDATE_CONTINUOUS)
scale1.set_digits(1)
scale1.set_value_pos(gtk.POS_TOP)
scale1.set_draw_value(True)

gtk.HScrollbar fornisce una barra di scorrimento orizzontale. È associato all'oggetto adj2. Anche la sua politica di aggiornamento è impostata su CONTINUO.

self.bar1 = gtk.HScrollbar(self.adj2)
self.bar1.set_update_policy(gtk.UPDATE_CONTINUOUS)

Per visualizzare il valore istantaneo della barra di scorrimento, il segnale di "valore modificato" di the adjustment object — adj2 è connesso alla funzione di richiamata on_scrolled(). La funzione recupera la proprietà value dell'oggetto di regolazione e la visualizza su un'etichetta sotto la barra di scorrimento.

self.adj2.connect("value_changed", self.on_scrolled)
   def on_scrolled(self, widget, data = None):
   self.lbl2.set_text("HScrollbar value: "+str(int(self.adj2.value)))

Esempio

Rispettare il codice seguente:

import gtk

class PyApp(gtk.Window):
   
   def __init__(self):
      super(PyApp, self).__init__()
      self.set_title("Range widgets Demo")
      self.set_default_size(250, 200)
      self.set_position(gtk.WIN_POS_CENTER)
      
      adj1 = gtk.Adjustment(0.0, 0.0, 101.0, 0.1, 1.0, 1.0)
      self.adj2 = gtk.Adjustment(10,0,101,5,1,1)
      
      scale1 = gtk.HScale(adj1)
      scale1.set_update_policy(gtk.UPDATE_CONTINUOUS)
      scale1.set_digits(1)
      scale1.set_value_pos(gtk.POS_TOP)
      scale1.set_draw_value(True)
      
      vb = gtk.VBox()
      vb.add(scale1)
      lbl1 = gtk.Label("HScale")
      
      vb.add(lbl1)
      self.bar1 = gtk.HScrollbar(self.adj2)
      self.bar1.set_update_policy(gtk.UPDATE_CONTINUOUS)
      vb.add(self.bar1)
      self.lbl2 = gtk.Label("HScrollbar value: ")
      
      vb.add(self.lbl2)
      self.adj2.connect("value_changed", self.on_scrolled)
      self.add(vb)
      self.connect("destroy", gtk.main_quit)
      self.show_all()
   
   def on_scrolled(self, widget, data=None):
      self.lbl2.set_text("HScrollbar value: "+str(int(self.adj2.value)))
if __name__ == '__main__':
   PyApp()
   gtk.main()

Il codice sopra genererà il seguente output:

Un widget Finestra di dialogo viene normalmente utilizzato come una finestra a comparsa sulla parte superiore di una finestra principale. L'obiettivo di una finestra di dialogo è raccogliere alcuni dati dall'utente e inviarli alla finestra principale. Il dialogo può essere modale (dove blocca il frame principale) o non modale (il frame di dialogo può essere ignorato).

Il widget Finestra di dialogo della libreria PyGTK è una finestra divisa verticalmente. Nella sua sezione superiore, c'è un gtk.VBox in cui sono imballati i widget di etichetta o voce. La sezione inferiore è chiamata action_area in cui sono posizionati uno o più pulsanti. Due aree sono separate da gtk.HSeparator.

La classe gtk.Dialog ha il seguente costruttore:

dlg = gtk.Dialog (Title = None, parent = None, flags = 0, buttons = None)

Dove,

  • Title - Il testo appare nella barra del titolo del widget di dialogo.

  • Parent - È il riferimento alla finestra di primo livello da cui si apre la finestra di dialogo.

  • Flag- Definisce le costanti che controllano il funzionamento della finestra di dialogo. Le costanti definite sono:

gtk.DIALOG_MODAL Se impostato, la finestra di dialogo cattura tutti gli eventi della tastiera
gtk.DIALOG_DESTROY_WITH_PARENT Se impostato, la finestra di dialogo viene distrutta quando il suo genitore è.
gtk.DIALOG_NO_SEPARATOR Se impostato, non è presente alcuna barra di separazione sopra i pulsanti.

Cos'è un pulsante?

Un Button è un oggetto tupla contenente coppie di gtk.Button con un ID stock (o testo) e i suoi ID di risposta.

L'ID risposta può essere un numero qualsiasi o una delle costanti ID risposta predefinite -

  • gtk.RESPONSE_NONE
  • gtk.RESPONSE_REJECT
  • gtk.RESPONSE_ACCEPT
  • gtk.RESPONSE_DELETE_EVENT
  • gtk.RESPONSE_OK
  • gtk.RESPONSE_CANCEL
  • gtk.RESPONSE_CLOSE
  • gtk.RESPONSE_YES
  • gtk.RESPONSE_NO
  • gtk.RESPONSE_APPLY
  • gtk.RESPONSE_HELP

I metodi importanti della classe gtk.Dialog sono riportati di seguito:

  • add_button() - Aggiunge un pulsante con il testo specificato da button_text (o un pulsante di borsa, se button_text è un ID di borsa) in action_area.

  • response() - Emette il segnale "response" con il valore specificato in response_id

  • run() - Visualizza la finestra di dialogo e restituisce response_id quando viene emesso delete_event.

  • set_default_response() - Imposta l'ultimo widget nell'area di azione della finestra di dialogo con il file specificato response_id come widget predefinito per la finestra di dialogo.

Il widget gtk.Dialog emette i seguenti segnali:

Vicino Viene emesso alla chiusura della finestra di dialogo.
Risposta Viene emesso quando viene attivato un widget action_area (pulsante "cliccato"), la finestra di dialogo riceve un delete_event o l'applicazione chiama il metodo response ().

Due pulsanti nella action_area del widget di dialogo utilizzano gli ID Stock gtk.STOCK.CANCEL e gtk.STOCK_OK. Sono associati agli ID di risposta gtk. RESPONSE_REJECT e gtk. RESPONSE_ACCEPT rispettivamente. La finestra di dialogo viene chiusa quando viene premuto un pulsante qualsiasi. I metodi run () restituiscono l'ID di risposta corrispondente che può essere utilizzato per ulteriori elaborazioni.

Il codice seguente mostra una finestra gtk.Window di primo livello con un pulsante al suo interno. Quando si fa clic sul pulsante, viene visualizzata una finestra di dialogo con un'etichetta e due pulsanti.

Esempio

Rispettare il codice seguente:

import gtk

class PyApp(gtk.Window):
   def __init__(self):
      super(PyApp, self).__init__()
      self.set_title("Dialog Demo")
      self.set_default_size(250, 200)
      fixed = gtk.Fixed()
      btn = gtk.Button("Show")
      btn.connect("clicked",self.show_sialog)
      fixed.put(btn,100,100)
      self.add(fixed)
      self.connect("destroy", gtk.main_quit)
      self.show_all()
      
   def show_sialog(self, widget, data=None):
      dialog = gtk.Dialog("My dialog",
         self,
         gtk.DIALOG_MODAL | gtk.DIALOG_DESTROY_WITH_PARENT,
         (gtk.STOCK_CANCEL, gtk.RESPONSE_REJECT,
         gtk.STOCK_OK, gtk.RESPONSE_ACCEPT))
      label = gtk.Label("Simple dialog")
      dialog.vbox.add(label)
      label.show()
      res = dialog.run()
      print res
      dialog.destroy()
if __name__ == '__main__':
   PyApp()
   gtk.main()

Il codice precedente produce il seguente output:

Widget di dialogo preconfigurati

L'API PyGTK ha una serie di widget di dialogo preconfigurati -

  • MessageDialog
  • AboutDialog
  • ColorSelectionDialog
  • FontSelectionDialog
  • FileChooserDialog

Per dimostrare il funzionamento della finestra di dialogo standard di cui sopra in PyGTK, un menu con una voce di menu che richiama ciascuna una finestra di dialogo quando viene cliccato, viene inserito in una finestra gtk.Window nel programma seguente. Vengono elencate le funzioni di richiamata che rispondono all'attivazione del segnale di ciascuna voce di menu. È inoltre possibile comprendere la spiegazione fornita per ogni tipo di widget di dialogo.

Esempio

Rispettare il codice seguente:

import gtk, pango

class PyApp(gtk.Window):
   def __init__(self):
      super(PyApp, self).__init__()
      self.set_title("Dialog Boxes")
      self.set_default_size(250, 200)
      self.set_position(gtk.WIN_POS_CENTER)
      
      mb = gtk.MenuBar()
      menu1 = gtk.Menu()
      file = gtk.MenuItem("_File")
      file.set_submenu(menu1)
      msg = gtk.MenuItem("MessageDialog")
      
      menu1.append(msg)
      abt = gtk.MenuItem("AboutDialog")
      menu1.append(abt)
      colo = gtk.MenuItem("colorDialog")
      menu1.append(colo)
      font = gtk.MenuItem("FontSelectionDialog")
      menu1.append(font)
      fl = gtk.MenuItem("FileChooserDialog")
      menu1.append(fl)
      mb.append(file)
      
      vbox = gtk.VBox(False, 2)
      vbox.pack_start(mb, False, False, 0)
      self.add(vbox)
      self.text = gtk.Label("TutorialsPoint")
      vbox.pack_start(self.text, True, True, 0)
      msg.connect("activate",self.on_msgdlg)
      abt.connect("activate",self.on_abtdlg)
      font.connect("activate",self.on_fntdlg)
      colo.connect("activate",self.on_color)
      
      fl.connect("activate", self.on_file)
      self.connect("destroy", gtk.main_quit)
      self.show_all()
   def on_msgdlg(self, widget):
      #MessageDialog usage code
   def on_abtdlg(self, widget):
      #AboutDialog usage code
   def on_fntdlg(self,widget):
      #FontSelectionDialog usage code
   def on_color(self, widget):
      #ColorChooserDialog usage cde
   Def on_file(self, widget):
      #FileChooserDialog usage code
if __name__ == '__main__':
   PyApp()
   gtk.main()

Il codice sopra genererà il seguente output:

Un widget Messagedialog è una finestra di dialogo configurata per visualizzare un'immagine che rappresenta il tipo di messaggio, cioè errore, domanda o testo informativo. Un oggetto MessageDialog viene dichiarato utilizzando il seguente costruttore:

gtk.MessageDialog(parent = None, flags = 0, type = gtk.MESSAGE_INFO, 
   buttons = gtk.BUTTONS_NONE, message_format = None)

I seguenti tipi di messaggi predefiniti vengono utilizzati per configurare la finestra di dialogo dei messaggi:

gtk.MESSAGE_INFO Questo è un messaggio informativo
gtk.MESSAGE_WARNING Questo è un messaggio di avviso non irreversibile
gtk.MESSAGE_QUESTION Questa domanda richiede una scelta
gtk.MESSAGE_ERROR Questo è un messaggio di errore irreversibile

È inoltre disponibile un set di set di pulsanti predefiniti.

gtk.BUTTONS_NONE Nessun pulsante
gtk.BUTTONS_OK Questo è un pulsante OK
gtk.BUTTONS_CLOSE Questo è un pulsante Chiudi
gtk.BUTTONS_CANCEL Questo è un pulsante Annulla
gtk.BUTTONS_YES_NO Questi sono i pulsanti Sì e No
gtk.BUTTONS_OK_CANCEL Questi sono i pulsanti OK e Annulla

Quando la voce di menu MessageBox è attivata, viene chiamata la seguente funzione di callback e viene visualizzata una finestra di messaggio come output.

def on_msgdlg(self, widget):
   md = gtk.MessageDialog(self,
      gtk.DIALOG_DESTROY_WITH_PARENT, gtk.MESSAGE_ERROR,
      gtk.BUTTONS_CLOSE, "Error message")
   md.run()

La funzione precedente genererà il seguente output:

Un modo semplice per visualizzare le informazioni su un programma come il suo logo, nome, copyright, sito web e licenza è offerto dal widget gtk.AboutDialog. Quando l'utente seleziona il fileAbout opzione dal Helpmenù. Tutte le parti della finestra di dialogo sono opzionali.

Il About Dialogpuò contenere URL e indirizzi email. gtk.AboutDialog offre hook globali quando l'utente fa clic su URL e ID e-mail

Quello che segue è un costruttore della classe gtk.AboutDialog -

dlg = gtk.AboutDialog()

I seguenti metodi vengono utilizzati per configurare il About Dialog

  • set_program_name() - Questo imposta il nome da visualizzare nel file About Dialog. il valore predefinito è application_name ().

  • set_version() - Questo imposta la proprietà "version"

  • set_copyright()- Questo imposta il "copyright". SeNone, l'avviso di copyright è nascosto.

  • set_license()- Questo imposta la "licenza". SeNone, il pulsante di licenza è nascosto.

  • set_website() - Questo imposta la proprietà "sito web" sulla stringa che dovrebbe essere un URL valido.

  • set_author() - Questo imposta la proprietà "autori" sull'elenco dei nomi degli autori visualizzati nella scheda autori della finestra di dialogo dei crediti secondari.

  • set_logo()- Questo imposta la proprietà "logo" sull'oggetto Pixbuf. Se Nessuno, verrà utilizzato il set di icone della finestra predefinita.

Quando si fa clic sul pulsante del menu AboutDialog, viene chiamata la seguente funzione di callback. Questa funzione genera la finestra di dialogo Informazioni su:

def on_abtdlg(self, widget):
   
   about = gtk.AboutDialog()
   about.set_program_name("PyGTK Dialog")
   about.set_version("0.1")
   about.set_authors("M.V.Lathkar")
   about.set_copyright("(c) TutorialsPoint")
   about.set_comments("About Dialog example")
   about.set_website("http://www.tutorialspoint.com")
   
   about.run()
   about.destroy()

La funzione sopra genera il seguente output:

Il widget gtk.FontSelection consente agli utenti di selezionare e applicare il carattere di un particolare nome, dimensione e stile. La finestra di dialogo ha una finestra di anteprima contenente del testo che verrà visualizzato nella descrizione del carattere selezionato e due pulsanti ANNULLA e OK.

L'API PyGTK contiene un modulo Pango che definisce le classi e le funzionalità richieste per rendere il testo internazionalizzato di alta qualità. La gestione dei caratteri e del testo in gtk è supportata da Pango. L'oggetto pango.Font rappresenta un font in modo indipendente dal sistema. L'oggetto pango.FontDescription contiene le caratteristiche di un carattere.

gtk.FontSelectionDialog restituisce un oggetto pango.Font. Per applicare il carattere selezionato, fontmetrics viene recuperato ottenendo l'oggetto pango.FontDescription da esso.

Quello che segue è un costruttore della classe FontSelectionDialog -

dlg = gtk.FontSelectionDialog(title)

I seguenti sono alcuni metodi usati di frequente di questa classe:

  • get_font_name() - Restituisce una stringa contenente il nome del carattere attualmente selezionato o Nessuno se non è selezionato alcun nome del carattere.

  • set_font_name() - Questo imposta il carattere corrente

  • set_preview_text() - Questo imposta il testo nella voce dell'area di anteprima

Il carattere selezionato viene applicato al testo in un widget utilizzando il metodo modify_font ().

Quando la voce di menu FontSelectionDialog è attivata, viene richiamata la seguente funzione di callback:

def on_abtdlg(self, widget):
   about = gtk.AboutDialog()
   about.set_program_name("PyGTK Dialog")
   about.set_version("0.1")
   about.set_authors("M.V.Lathkar")
   about.set_copyright("(c) TutorialsPoint")
   about.set_comments("About Dialog example")
   about.set_website("http://www.tutorialspoint.com")
   about.run()
   about.destroy()

Il carattere selezionato viene applicato al testo dell'etichetta posizionata nella finestra di primo livello.

Quello che segue è l'output:

Questa è una finestra di dialogo preconfigurata nell'API PyGTK che consente all'utente di selezionare e applicare il colore. Incorpora internamente un widget gtk.ColorSelection.

Il widget gtk.ColorScelection presenta una ruota dei colori e caselle di immissione per i parametri del colore come HSV e RGB. Il nuovo colore può essere selezionato manipolando la ruota dei colori o inserendo i parametri del colore. Il suo get_current_color è utile per ulteriori elaborazioni.

Di seguito è riportato il prototipo del costruttore della classe gtk.ColorSelectionDialog -

dlg = gtk.ColorSelectionDialog(title)

Il colore attualmente selezionato è ottenuto dall'attributo colorsel. Il colore selezionato viene applicato a un widget utilizzando i metodi modify_fg () o modify_bg ().

Quando il pulsante del menu ColorDialog è attivato, viene eseguita la seguente funzione di richiamata:

def on_color(self, widget):
   dlg = gtk.ColorSelectionDialog("Select color")
   col = dlg.run()
   sel = dlg.colorsel.get_current_color()
   self.text.modify_fg(gtk.STATE_NORMAL, sel)

Il colore scelto viene applicato al testo in un widget etichetta sulla finestra -

Quello che segue è l'output:

Questa finestra di dialogo è utile per consentire all'utente di selezionare la posizione e il nome del file che deve essere aperto o salvato. Incorpora FileChooserWidget e fornisce i pulsanti OK e CANCEL nella action_area.

Quello che segue è un costruttore della classe gtk.FileChooserDialog -

Dlg=gtk.FileChooserDialog (title = None, parent = None, 
   action = gtk.FILE_CHOOSER_ACTION_OPEN,  buttons = None, backend = None)

I parametri sono:

titolo Questo è il titolo della finestra di dialogo
genitore Il genitore temporaneo della finestra di dialogo o Nessuno
azione La modalità di apertura o salvataggio per la finestra di dialogo
pulsanti Questa è una tupla contenente coppie di ID etichetta-risposta pulsante o Nessuno
backend Il nome del backend del file system specifico da utilizzare.

Le seguenti sono le modalità di azione:

  • gtk.FILE_CHOOSER_ACTION_OPEN
  • gtk.FILE_CHOOSER_ACTION_SAVE
  • gtk.FILE_CHOOSER_ACTION_SELECT_FOLDER
  • gtk.FILE_CHOOSER_ACTION_CREATE_FOLDER

Se si desidera limitare i tipi di file da visualizzare, è possibile applicare un oggetto gtk.FileFilter utilizzando il metodo add_filter ().

Se si fa clic sul pulsante del menu FileChooserDialog, viene eseguita la seguente funzione di callback.

def on_file(self, widget):
   dlg = gtk.FileChooserDialog("Open..", None, gtk.FILE_CHOOSER_ACTION_OPEN,
      (gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL, gtk.STOCK_OPEN, gtk.RESPONSE_OK))
   response = dlg.run()
   self.text.set_text(dlg.get_filename())
   dlg.destroy()

Il file viene selezionato dalla finestra di dialogo -

Il file selezionato viene visualizzato sull'etichetta nel gtk di livello superiore.

Il widget Notebook è un contenitore a schede. Ogni scheda in questo contenitore contiene una pagina diversa e le pagine vengono visualizzate in modo sovrapposto. Qualsiasi pagina desiderata viene resa visibile facendo clic sull'etichetta della scheda. Le etichette possono essere configurate per essere visualizzate in alto o in basso oppure a sinistra oa destra. Sotto ogni pagina viene posizionato un widget contenitore con altri widget inseriti o un singolo widget.

Se i dati da visualizzare sono troppo grandi in una visualizzazione, vengono raggruppati in pagine diverse, ciascuna collocata in una scheda di un widget Notebook. Questo tipo di controllo è molto utilizzato. Il browser Internet, ad esempio, utilizza questa visualizzazione a schede per visualizzare pagine diverse in schede diverse.

Quello che segue è un costruttore della classe gtk.Notebook -

gtk.Notebook()

I seguenti sono i metodi usati di frequente della classe gtk.Notebook:

  • append_page(child, label)- Questo aggiunge una pagina al taccuino contenente un widget specificato da tab_label come etichetta sulla scheda. Se tab_label può essere Nessuno per utilizzare un'etichetta predefinita.

  • insert_page(child, label, position) - Questo inserisce una pagina nel blocco note nella posizione specificata da posizione.

  • remove_page(index) - Ciò rimuove una pagina all'indice specificato.

  • get_current_page() - Questo restituisce l'indice della pagina della pagina corrente.

  • set_current_page(index) - Questo passa al numero di pagina specificato dall'indice.

  • set_show_tabs()- Se false, le schede non saranno visibili. Questo è True per impostazione predefinita.

  • set_tab_pos(pos)- Questo imposta il bordo in corrispondenza del quale vengono disegnate le schede per cambiare pagina nel blocco note. Le costanti predefinite sono:

    • gtk.POS_LEFT

    • gtk.POS_RIGHT

    • gtk.POS_TOP

    • gtk.POS_BOTTOM

  • set_tab_label_text(child, text) - Questo crea una nuova etichetta con il testo specificato e la imposta come etichetta di tabulazione per la pagina che contiene il bambino.

Il widget gtk.Notebook emette i seguenti segnali:

cambia-pagina-corrente Viene emesso quando viene inviata la richiesta di pagina successiva o pagina precedente
focus-tab Viene emesso quando lo stato attivo viene modificato mediante tabulazione.
pagina aggiunta Viene emesso quando una pagina viene aggiunta al taccuino.
pagina rimossa Viene emesso dopo che una pagina viene rimossa dal blocco note.
seleziona-pagina Viene emesso quando viene selezionata una nuova pagina figlio.
switch-page Viene emesso quando viene modificata la pagina del taccuino.

Esempio

Nell'esempio seguente, un gtk.Notebook con tre pagine viene posizionato in una gtk.Window di primo livello. La prima pagina contiene un VBox in cui sono imballati un'etichetta e un campo di immissione. La seconda pagina denominata "qualifiche" ha un HButtonBox in cui vengono aggiunti tre widget RadioButton che si escludono a vicenda. La terza pagina ha un oggetto TextView. Le etichette delle pagine vengono visualizzate in alto.

Rispetta il codice -

import gtk
class PyApp(gtk.Window):
   def __init__(self):
      super(PyApp, self).__init__()
      self.set_title("Notebook Demo")
      self.set_default_size(250, 200)
		
      nb = gtk.Notebook()
      nb.set_tab_pos(gtk.POS_TOP)
      vbox = gtk.VBox(False, 5)
		
      vb = gtk.VBox()
      hbox = gtk.HBox(True, 3)
		
      valign = gtk.Alignment(0.5,0.25, 0, 0)
      lbl = gtk.Label("Name of student")
		
      vb.pack_start(lbl, True, True, 10)
      text = gtk.Entry()
		
      vb.pack_start(text, True, True, 10)
      valign.add(vb)
		
      vbox.pack_start(valign)
      nb.append_page(vbox)
      nb.set_tab_label_text(vbox, "Name")
      hb = gtk.HButtonBox()
		
      btn1 = gtk.RadioButton(None,"Degree")
      hb.add(btn1)
		
      btn2 = gtk.RadioButton(btn1,"P.G.")
      hb.add(btn2)
		
      btn3 = gtk.RadioButton(btn1,"Doctorate")
      hb.add(btn3)
		
      nb.append_page(hb)
      nb.set_tab_label_text(hb, "Qualification")
		
      tv = gtk.TextView()
      nb.append_page(tv)
      nb.set_tab_label_text(tv, "about")
		
      self.add(nb)
      self.connect("destroy", gtk.main_quit)
      self.show_all()
if __name__ == '__main__':
   PyApp()
   gtk.main()

All'esecuzione, il codice sopra mostra un Notebook con tre pagine -

La classe Frame è una sottoclasse della classe gtk.Bin. Disegna un bordo decorativo attorno al widget figlio posizionato al suo interno. La cornice può contenere un'etichetta la cui posizione può essere personalizzata.

Un oggetto gtk.Frame viene costruito con l'aiuto del seguente costruttore:

frame = gtk.Frame(label = None)

I seguenti sono i metodi della classe gtk.Frame () -

  • set_label(text) - Questo imposta l'etichetta come specificato da text. SeNone, l'etichetta corrente viene rimossa.

  • set_label_widget() - Questo imposta un widget diverso da gtk.Label come etichetta per il frame.

  • set_label_align(x, y) - Questo imposta l'allineamento del widget e della decorazione dell'etichetta della cornice (i valori predefiniti sono 0,0 e 0,5)

  • set_shadow_type() - Imposta il tipo di ombra della cornice.

I valori possibili sono:

  • gtk.SHADOW_NONE
  • gtk.SHADOW_IN
  • gtk.SHADOW_OUT
  • gtk.SHADOW_ETCHED_IN
  • tk.SHADOW_ETCHED_OUT

Il codice seguente mostra il funzionamento del widget Frame. Un gruppo di tre oggetti di gtk.RadioButton è posto in un HButtonBox.

btn1 = gtk.RadioButton(None,"Degree")
btn2 = gtk.RadioButton(btn1,"P.G.")
btn3 = gtk.RadioButton(btn1,"Doctorate")
hb = gtk.HButtonBox()
hb.add(btn1)
hb.add(btn2)
hb.add(btn3)

Per disegnare un bordo attorno al riquadro, viene inserito in un widget Cornice e viene aggiunto alla finestra di primo livello.

frm = gtk.Frame()
frm.add(hb)
self.add(frm)

Esempio

Rispettare il codice seguente:

import gtk

class PyApp(gtk.Window):
   def __init__(self):
      super(PyApp, self).__init__()
      self.set_title("Frame Demo")
      self.set_default_size(250, 200)
      self.set_border_width(5)
      frm = gtk.Frame()
      hb = gtk.HButtonBox()
      btn1 = gtk.RadioButton(None,"Degree")
      hb.add(btn1)
      btn2 = gtk.RadioButton(btn1,"P.G.")
      hb.add(btn2)
      btn3 = gtk.RadioButton(btn1,"Doctorate")
      hb.add(btn3)
      frm.add(hb)
      frm.set_label("Qualifications")
      self.add(frm)
      self.connect("destroy", gtk.main_quit)
      self.show_all()

if __name__ == '__main__':
   PyApp()
   gtk.main()

Il codice sopra genererà il seguente output:

gtk.AspectFrame è una sottoclasse della classe Frame. Il widget figlio in questo frame mantiene sempre le sue proporzioni (di larghezza e altezza) anche se la finestra principale viene ridimensionata.

La proprietà ratio del widget gtk.AspectFrame determina il rapporto larghezza: altezza del widget. Un rapporto di aspetto di 0,5 significa che la larghezza è la metà dell'altezza; un rapporto di aspetto di 2.0 significa che la larghezza è il doppio dell'altezza. Il valore predefinito per la proprietà "ratio" è 1.0.

La sintassi seguente viene utilizzata per il costruttore della classe gtk.AspectFrame:

gtk.AspectFrame (label = None, xalign = 0.5, yalign = 0.5, ratio = 1.0, obey_child = True)

Il xaligndetermina la frazione di spazio libero orizzontale a sinistra del figlio. 0.0 significa nessuno spazio libero a sinistra, 1.0 significa tutto lo spazio libero a sinistra.

Il yaligndetermina la frazione di spazio libero verticale sopra il bambino. 0.0 significa nessuno spazio libero sopra, 1.0 significa tutto lo spazio libero sopra.

Il rapporto tra larghezza e altezza del telaio viene mantenuto se obey_child la proprietà è falsa.

La proprietà obey_child determina se il rapporto deve essere ignorato. L'impostazione predefinita è True.

Il codice seguente è simile a quello utilizzato per la classe Frame. L'unica differenza è che il ButonBox è posizionato in un widget AspectFrame.

frm = gtk.AspectFrame(label = None, xalign = 0.5, yalign = 0.5, 
   ratio = 5.0, obey_child = False)

Note - La proprietà obey_child è impostata su False perché si desidera mantenere le proporzioni anche se la finestra viene ridimensionata.

Esempio

Rispettare il codice seguente:

import gtk

class PyApp(gtk.Window):
   def __init__(self):
      super(PyApp, self).__init__()
      self.set_title("Aspect Frame Demo")
      self.set_default_size(250, 200)
      self.set_border_width(5)
      frm = gtk.AspectFrame(label = None, xalign = 0.5, yalign = 0.5, 
         ratio = 5.0, obey_child = False)
      hb = gtk.HButtonBox()
      btn1 = gtk.RadioButton(None,"Degree")
      hb.add(btn1)
      btn2 = gtk.RadioButton(btn1,"P.G.")
      hb.add(btn2)
      btn3 = gtk.RadioButton(btn1,"Doctorate")
      hb.add(btn3)
      frm.add(hb)
      frm.set_label("Qualifications")
      self.add(frm)
      self.connect("destroy", gtk.main_quit)
      self.show_all()
      
if __name__ == '__main__':
   PyApp()
   gtk.main()

Il codice sopra produrrà le seguenti finestre originali e ridimensionate:

Original Window

Resized Window

Il widget Treeview mostra i contenuti di un modello che implementa l'interfaccia gtk.TreeModel. PyGTK fornisce i seguenti tipi di modelli:

  • gtk.ListStore
  • gtk.TreeStore
  • gtk.TreeModelSort

ListStore è un modello di elenco. Quando è associato a un widget gtk.TreeView, produce una casella di riepilogo contenente gli elementi da cui selezionare. Un oggetto gtk.ListStore viene dichiarato con la seguente sintassi:

store = gtk.ListStore(column_type)

Un elenco può avere più colonne, le costanti di tipo predefinite sono:

  • gobject.TYPE_BOOLEAN
  • gobject.TYPE_BOXED
  • gobject.TYPE_CHAR
  • gobject.TYPE_DOUBLE
  • gobject.TYPE_ENUM
  • gobject.TYPE_FLOAT
  • gobject.TYPE_INT
  • gobject.TYPE_LONG
  • gobject.TYPE_NONE
  • gobject.TYPE_OBJECT
  • gobject.TYPE_STRING
  • gobject.TYPE_UCHAR
  • gobject.TYPE_UINT
  • gobject.TYPE_ULONG
  • gtk.gdk.pixbuf ecc.

Ad esempio, un oggetto ListStore per memorizzare gli elementi stringa viene dichiarato come -

store = gtk.ListStore(gobject.TYPE_STRING

Per aggiungere articoli nel negozio, vengono utilizzati i metodi append ():

store.append (["item 1"])

TreeStore è un modello per il widget Albero a più colonne. Ad esempio, la seguente istruzione crea un negozio con una colonna con un elemento stringa.

Store = gtk.TreeStore(gobject.TYPE_STRING)

Per aggiungere elementi in un TreeStore, utilizzare il metodo append (). Il metodo append () ha due parametri, genitore e riga. Per aggiungere un elemento di primo livello, il genitore è Nessuno.

row1 = store.append(None, ['row1'])

È necessario ripetere questa istruzione per aggiungere più righe.

Per aggiungere righe figlie, passare la riga di livello superiore come parametro genitore al metodo append () -

childrow = store.append(row1, ['child1'])

È necessario ripetere questa istruzione per aggiungere più righe figlie.

Ora, crea un widget TreeView e usa l'oggetto TreeStore sopra come modello.

treeview = gtk.TreeView(store)

Ora dobbiamo creare TreeViewColumn per visualizzare i dati del negozio. L'oggetto di gtk.TreeViewColumn gestisce l'intestazione e le celle utilizzando gtk.CelRenderer. L'oggetto TreeViewColumn viene creato utilizzando il seguente costruttore:

gtk.TreeViewColumn(title, cell_renderer,…)

Oltre a title e renderer, sono necessarie zero o più coppie attributo = colonna per specificare da quale colonna del modello di albero deve essere recuperato il valore dell'attributo. Questi parametri possono anche essere impostati utilizzando i metodi della classe TreeViewColumn indicati di seguito.

Un gtk.CellRenderer è una classe base per un insieme di oggetti per il rendering di diversi tipi di dati. Le classi derivate sono CellRendererText, CellRendererPixBuf e CellRendererToggle.

I seguenti metodi della classe TreeViewColumn vengono utilizzati per configurare il suo oggetto:

  • TreeViewColumn.pack_start (cell, expand = True) - Questo metodo racchiude l'oggetto CellRenderer nella colonna iniziale. Se il parametro di espansione è impostato su True, l'intero spazio allocato delle colonne viene assegnato alla cella.

  • TreeViewColumn.add_attribute (cella, attributo, colonna): questo metodo aggiunge una mappatura di attributi all'elenco nella colonna dell'albero. Ilcolumn è la colonna del modello ad albero.

  • TreeViewColumn.set_attributes () - Questo metodo imposta le posizioni degli attributi di renderer usando il attribute = column coppie

  • TreeViewColumn.set_visible () - If True, la colonna treeview è visibile

  • TreeViewColumn.set_title () - Questo metodo imposta la proprietà "title" sul valore specificato.

  • TreeViewColumn.set_lickable () - Se impostato su True, l'intestazione può essere selezionata dalla tastiera ed essere cliccata.

  • TreeViewColumn.set_alignment (xalign) - Questo metodo imposta la proprietà "alignment" sul valore di xalign.

Il segnale "cliccato" viene emesso quando l'utente fa clic sul pulsante di intestazione treeviewcolumn .

Dopo aver configurato l'oggetto TreeViewColumn, viene aggiunto al widget TreeView utilizzando il metodo append_column ().

I seguenti sono i metodi importanti della classe TreeView:

  • TreevVew.set_model () - Imposta la proprietà "model" per la visualizzazione ad albero. Se il treeview ha già un set di modelli, questo metodo lo rimuoverà prima di impostare il nuovo modello. Semodel è None, disinserirà il vecchio modello.

  • TreeView.set_header_clickable () - Se impostato su True, è possibile fare clic sui pulsanti del titolo della colonna.

  • TreeView.append_column (): aggiunge l'elemento specificato TreeViewColumn all'elenco delle colonne.

  • TreeView.remove_column (): rimuove la colonna specificata dalla visualizzazione ad albero.

  • TreeView.insert_column (): inserisce l'oggetto specificato column nella visualizzazione ad albero nella posizione specificata da position.

Il widget TreeView emette i seguenti segnali:

cursore modificato Viene emesso quando il cursore si sposta o è impostato.
espandere-comprimere-riga-cursore Viene emesso quando la riga in corrispondenza del cursore deve essere espansa o compressa.
attivato dalla riga Viene emesso quando l'utente fa doppio clic su a treeview riga
riga crollata Viene emesso quando una riga viene compressa dall'utente o dall'azione programmatica.
espanso per righe Viene emesso quando una riga viene espansa tramite l'utente o l'azione programmatica.

Di seguito vengono forniti due esempi del widget TreeView. Il primo esempio usa un ListStore per produrre un semplice ListView.

Qui viene creato un oggetto ListStore e gli elementi stringa vengono aggiunti ad esso. Questo oggetto ListStore viene utilizzato come modello per l'oggetto TreeView -

store = gtk.ListStore(str)

treeView = gtk.TreeView()
treeView.set_model(store)

Quindi un CellRendererText viene aggiunto a un oggetto TreeViewColumn e lo stesso viene aggiunto a TreeView.

rendererText = gtk.CellRendererText()
column = gtk.TreeViewColumn("Name", rendererText, text = 0)
treeView.append_column(column)

L'oggetto TreeView viene posizionato nella finestra di primo livello aggiungendolo a un contenitore fisso.

Esempio 1

Rispettare il codice seguente:

import pygtk
pygtk.require('2.0')
import gtk

class PyApp(gtk.Window):
   def __init__(self):
      super(PyApp, self).__init__()
      self.set_title("TreeView with ListStore")
      self.set_default_size(250, 200)
      self.set_position(gtk.WIN_POS_CENTER)
		
      store = gtk.ListStore(str)
      store.append (["PyQt"])
      store.append (["Tkinter"])
      store.append (["WxPython"])
      store.append (["PyGTK"])
      store.append (["PySide"])
      
      treeView = gtk.TreeView()
      treeView.set_model(store)
		
      rendererText = gtk.CellRendererText()
      column = gtk.TreeViewColumn("Python GUI Libraries", rendererText, text=0)
      treeView.append_column(column)
      
      fixed = gtk.Fixed()
      lbl = gtk.Label("select a GUI toolkit")
      fixed.put(lbl, 25,75)
      fixed.put(treeView, 125,15)
		
      lbl2 = gtk.Label("Your choice is:")
      fixed.put(lbl2, 25,175)
      self.label = gtk.Label("")
		
      fixed.put(self.label, 125,175)
      self.add(fixed)
      
      treeView.connect("row-activated", self.on_activated)
      self.connect("destroy", gtk.main_quit)
      self.show_all()
		
   def on_activated(self, widget, row, col):
      
	  model = widget.get_model()
      text = model[row][0]
      self.label.set_text(text)
		
def main():
   gtk.main()
   return

if __name__ == "__main__":
   bcb = PyApp()
   main()

L'elemento selezionato dall'utente viene visualizzato su un'etichetta nella finestra come on_activated callback viene richiamata la funzione.

Esempio 2

Il secondo esempio crea un TreeView gerarchico da un TreeStore. Questo programma segue la stessa sequenza di costruzione del negozio, impostandolo come modello per TreeView, progettando una TreeViewColumn e aggiungendola a TreeView.

import gtk

class PyApp(gtk.Window):
   
   def __init__(self):
      super(PyApp, self).__init__()
      
	  self.set_title("TreeView with TreeStore")
      self.set_size_request(400,200)
      self.set_position(gtk.WIN_POS_CENTER)
      vbox = gtk.VBox(False, 5)
      
      # create a TreeStore with one string column to use as the model
      store = gtk.TreeStore(str)
      
      # add row
      row1 = store.append(None, ['JAVA'])
      
      #add child rows
      store.append(row1,['AWT'])
      store.append(row1,['Swing'])
      store.append(row1,['JSF'])
      
      # add another row
      row2 = store.append(None, ['Python'])
      store.append(row2,['PyQt'])
      store.append(row2,['WxPython'])
      store.append(row2,['PyGTK'])
      
      # create the TreeView using treestore
      treeview = gtk.TreeView(store)
      tvcolumn = gtk.TreeViewColumn('GUI Toolkits')
      treeview.append_column(tvcolumn)
		
      cell = gtk.CellRendererText()
      tvcolumn.pack_start(cell, True)
      tvcolumn.add_attribute(cell, 'text', 0)
      vbox.add(treeview)
		
      self.add(vbox)
      
	  self.connect("destroy", gtk.main_quit)
      self.show_all()

PyApp()
gtk.main()

Il seguente TreeView viene visualizzato come output:

La classe Paned è la classe base per i widget che possono visualizzare due riquadri regolabili orizzontalmente (gtk.Hpaned) o verticalmente (gtk.Vpaned). I widget figlio ai riquadri vengono aggiunti utilizzando i metodi pack1 () e pack2 ().

Il widget Paned disegna un cursore separatore tra due riquadri e fornisce una maniglia per regolare la loro larghezza / altezza relativa. Se la proprietà resize del widget figlio all'interno di un riquadro è impostata su True, verrà ridimensionata in base alle dimensioni dei riquadri.

I seguenti metodi sono disponibili per la classe HPaned e VPaned:

  • Paned.add1 (figlio): aggiunge il widget specificato da child nel riquadro superiore o sinistro

  • Paned.add2 (figlio): aggiunge il widget specificato da child nel riquadro inferiore o destro.

  • Paned.pack1 (child, resize, shrink) - Questo aggiunge il widget specificato da childnel riquadro superiore o sinistro con i parametri. Seresize è True, childdovrebbe essere ridimensionato quando il widget paned viene ridimensionato. Seshrink è True, child può essere ridotto rispetto alla dimensione minima richiesta.

  • Paned.pack2 (child, resize, shrink) - Imposta la posizione del divisore tra i due riquadri.

Entrambi i tipi di widget Paned emettono i seguenti segnali:

accettare-posizione Viene emesso quando paned ha il focus che causa l'attivazione del widget figlio con il focus.
posizione di annullamento Viene emesso quando il Esc il tasto viene premuto mentre paned ha l'obiettivo.
maniglia di spostamento Viene emesso quando paned ha il focus e il separatore viene spostato.

Esempio

L'esempio seguente utilizza un widget gtk.Hpaned. Nel riquadro sinistro viene aggiunto un widget TreeView e nel riquadro destro è presente un widget TextView. Quando una qualsiasi riga in TreeView è selezionata, emetterà un segnale row_activated che è connesso a una funzione di callback. Ilon_activated()function recupera il testo della riga e viene visualizzato nel pannello di visualizzazione del testo.

Rispetta il codice -

import gtk, gobject

class PyApp(gtk.Window):
   def __init__(self):
      super(PyApp, self).__init__()
      self.set_title("HPaned widget Demo")
      self.set_default_size(250, 200)
      vp = gtk.HPaned()
      sw = gtk.ScrolledWindow()
      sw.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC) 
		
      tree = gtk.TreeView()
      languages = gtk.TreeViewColumn()
      languages.set_title("GUI Toolkits")
      cell = gtk.CellRendererText()
      languages.pack_start(cell, True)
      languages.add_attribute(cell, "text", 0)
      treestore = gtk.TreeStore(str)
      it = treestore.append(None, ["Python"])
		
      treestore.append(it, ["PyQt"])
      treestore.append(it, ["wxPython"])
      treestore.append(it, ["PyGTK"])
      treestore.append(it, ["Pydide"])
		
      it = treestore.append(None, ["Java"])
      treestore.append(it, ["AWT"])
      treestore.append(it, ["Swing"])
      treestore.append(it, ["JSF"])
      treestore.append(it, ["SWT"])
		
      tree.append_column(languages)
      tree.set_model(treestore)
		
      vp.add1(tree)
      self.tv = gtk.TextView()
      vp.add2(self.tv)
      vp.set_position(100)
      self.add(vp)
		
      tree.connect("row-activated", self.on_activated)
      self.connect("destroy", gtk.main_quit)
      self.show_all()
		
   def on_activated(self, widget, row, col):
      model = widget.get_model()
      text = model[row][0]
      print text
		
      buffer = gtk.TextBuffer()
      buffer.set_text(text+" is selected")
      self.tv.set_buffer(buffer)

if __name__ == '__main__':
   PyApp()
   gtk.main()

Il codice sopra genererà il seguente output:

Un'area di notifica, solitamente nella parte inferiore di una finestra, è chiamata barra di stato. Qualsiasi tipo di messaggio di modifica dello stato può essere visualizzato sulla barra di stato. Ha anche una presa che può essere ridimensionata.

Il widget gtk.Statusbar mantiene una pila di messaggi. Quindi, il nuovo messaggio viene visualizzato sopra il messaggio corrente. Se viene visualizzato, il messaggio precedente sarà nuovamente visibile. L'origine del messaggio deve essere identificata da context_id per identificarlo in modo univoco.

Quello che segue è il costruttore del widget gtk.Statusbar -

bar = gtk.Statusbar()

I seguenti sono i metodi della classe gtk.Statusbar -

  • Statusbar.push(context_id, text) - Questo inserisce un nuovo messaggio nello stack di una barra di stato.

  • Statusbar.pop(context_id) - Questo rimuove il messaggio in alto con il file specificato context_id dallo stack della barra di stato.

I seguenti segnali vengono emessi dal widget della barra di stato:

testo spuntato Viene emesso quando un messaggio viene rimosso dallo stack dei messaggi della barra di stato.
testo inserito Viene emesso quando un messaggio viene aggiunto allo stack dei messaggi della barra di stato.

Il seguente esempio mostra il funzionamento di Statusbar. La finestra Toplevel contiene un VBox con due righe. La riga superiore ha un widget Fisso in cui vengono inseriti un'etichetta, un widget Entry e un pulsante. Mentre, nella riga inferiore, viene aggiunto un widget gtk.Statusbar.

Per inviare un messaggio alla barra di stato, è necessario recuperare il relativo context_id.

id1 = self.bar.get_context_id("Statusbar")

Il segnale 'cliccato' dell'oggetto Button è connesso a una funzione di callback attraverso la quale viene inserito un messaggio nella barra di stato. Inoltre, il segnale di "attivazione" viene emesso quando viene premuto il tasto Invio all'interno del widget Entry. Questo widget è connesso a un altro callback.

btn.connect("clicked", self.on_clicked, id1)
txt.connect("activate", self.on_entered, id1)

Entrambi i callback usano push() metodo per far lampeggiare il messaggio nell'area di notifica.

Esempio

Rispettare il codice seguente:

import gtk

class PyApp(gtk.Window):
   
   def __init__(self):
      super(PyApp, self).__init__()
      self.set_title("Statusbar demo")
      self.set_size_request(400,200)
      self.set_position(gtk.WIN_POS_CENTER)
		
      vbox = gtk.VBox()
      fix = gtk.Fixed()
      lbl = gtk.Label("Enter name")
		
      fix.put(lbl, 175, 50)
      txt = gtk.Entry()
      fix.put(txt, 150, 100)
		
      btn = gtk.Button("ok")
      fix.put(btn, 200,150)
		
      vbox.add(fix)
      self.bar = gtk.Statusbar()
      vbox.pack_start(self.bar, True, False, 0)
		
      id1 = self.bar.get_context_id("Statusbar")
      btn.connect("clicked", self.on_clicked, id1)
      txt.connect("activate", self.on_entered, id1)
		
      self.add(vbox)
      self.connect("destroy", gtk.main_quit)
      self.show_all()
		
      def on_clicked(self, widget, data=None):
         self.bar.push(data, "Button clicked
		
      def on_entered(self, widget, data):
         self.bar.push(data, "text entered")

PyApp()
gtk.main()

Al momento dell'esecuzione, il codice sopra mostrerà il seguente output:

Prova a digitare nella casella di testo e premi Invio per vedere il messaggio di "testo inserito" nella barra di stato.

Le barre di avanzamento vengono utilizzate per fornire all'utente l'indicazione visiva di un processo di lunga durata. Il widget gtk.ProgressBar può essere utilizzato in due modalità: modalità percentuale e modalità attività.

Quando è possibile stimare con precisione quanto lavoro è in attesa di essere completato, la barra di avanzamento può essere utilizzata in modalità percentuale e l'utente vede una barra incrementale che mostra la percentuale del lavoro completato. Se invece è possibile determinare con precisione la quantità di lavoro da completare, la barra di avanzamento viene utilizzata nella modalità attività in cui la barra mostra l'attività visualizzando un blocco che si muove avanti e indietro.

Il seguente costruttore inizializza il widget della classe gtk.ProgressBar -

pb = gtk.ProgressBar()

gtk.ProgressBar utilizza i seguenti metodi per gestire le funzionalità:

  • ProgressBar.pulse()- Questo spinge la barra di avanzamento per indicare che sono stati compiuti alcuni progressi, ma non sai quanto. Questo metodo modifica anche la modalità della barra di avanzamento in "modalità attività", in cui un blocco rimbalza avanti e indietro.

  • ProgressBar.set_fraction(fraction) - In questo modo la barra di avanzamento "riempie" la parte della barra specificata da fraction. Il valore difraction dovrebbe essere compreso tra 0,0 e 1,0.

  • ProgressBar.set_pulse_setup() - Questo imposta la porzione (specificata da fraction) della lunghezza totale della barra di avanzamento per spostare il blocco che rimbalza per ogni chiamata nel file pulse() metodo.

  • ProgressBar.set_orientation()- Questo imposta l'orientamento della barra di avanzamento. Può essere impostato su una delle seguenti costanti:

    • gtk.PROGRESS_LEFT_TO_RIGHT

    • gtk.PROGRESS_RIGHT_TO_LEFT

    • gtk.PROGRESS_BOTTOM_TO_TOP

    • gtk.PROGRESS_TOP_TO_BOTTOM

Nel seguente programma, il widget gtk.ProgressBar viene utilizzato in modalità attività. Quindi, la posizione iniziale di avanzamento è impostata su 0,0 daset_fraction() metodo.

self.pb = gtk.ProgressBar()
self.pb.set_text("Progress")
self.pb.set_fraction(0.0)

Per incrementare il progresso dell'1% dopo 100 millisecondi, viene dichiarato un oggetto timer e viene impostata una funzione di callback da richiamare ogni 100 ms in modo che la barra di avanzamento venga aggiornata.

self.timer = gobject.timeout_add (100, progress_timeout, self)

Qui, progress_timeout()è la funzione di callback. Incrementa il parametro diset_fraction() metodo dell'1 percento e aggiorna il testo nella barra di avanzamento per mostrare la percentuale di completamento.

def progress_timeout(pbobj):
   new_val = pbobj.pb.get_fraction() + 0.01
   pbobj.pb.set_fraction(new_val)
   pbobj.pb.set_text(str(new_val*100)+" % completed")
   return True

Esempio

Rispettare il codice seguente:

import gtk, gobject
   
def progress_timeout(pbobj):
   new_val = pbobj.pb.get_fraction() + 0.01
   pbobj.pb.set_fraction(new_val)
   pbobj.pb.set_text(str(new_val*100)+" % completed")
   return True

class PyApp(gtk.Window):
   
   def __init__(self):
      super(PyApp, self).__init__()
      self.set_title("Progressbar demo")
      self.set_size_request(300,200)
      self.set_position(gtk.WIN_POS_CENTER)
		
      fix = gtk.Fixed()
      self.pb = gtk.ProgressBar()
      self.pb.set_text("Progress")
      self.pb.set_fraction(0.0)
		
      fix.put(self.pb,80,100)
      self.add(fix)
      self.timer = gobject.timeout_add (100, progress_timeout, self)
      self.connect("destroy", gtk.main_quit)
      self.show_all()
PyApp()
gtk.main()

Il codice sopra genererà il seguente output:

Per utilizzare la barra di avanzamento in modalità attività, modificare la funzione di richiamata come segue ed eseguire:

def progress_timeout(pbobj):
   pbobj.pb.pulse()
   return True

Il movimento avanti e indietro di un blocco all'interno della barra di avanzamento mostrerà l'avanzamento dell'attività.

Se un widget ha un'area più grande di quella della finestra di primo livello, è associato a un contenitore ViewPort. Un widget gtk.Viewport fornisce funzionalità di regolazione da utilizzare in una ScrolledWindow. Un widget Etichetta, ad esempio, non ha alcuna regolazione. Quindi ha bisogno di un Viewport. Alcuni widget hanno un supporto di scorrimento nativo. Ma un widget Label o gtk.Table non ha un supporto per lo scorrimento integrato. Quindi devono usare Viewport.

La classe ViewPort ha il seguente costruttore:

gtk.Viewport(hadj, vadj)

Qui, hadj e vadj sono gli oggetti di regolazione associati alla finestra.

La classe gtk.ViewPort utilizza i seguenti metodi:

  • Viewport.set_hadjustment() - Questo imposta la proprietà "hadjustment"

  • Viewport.set_vadjustment() - Questo imposta la proprietà "vadjustment"

  • Viewport.set_shadow_type() - Questo imposta la proprietà "shadow-type" sul valore di type. Il valore ditype deve essere uno di -

    • gtk.SHADOW_NONE

    • gtk.SHADOW_IN

    • gtk.SHADOW_OUT

    • gtk.SHADOW_ETCHED_IN

    • gtk.SHADOW_ETCHED_OUT

L'oggetto gtk.Viewport emette il segnale di regolazione dello scorrimento del set quando uno o entrambi gli oggetti gtk.Adjustment orizzontale e verticale vengono modificati.

La finestra a scorrimento viene creata per accedere ad altri widget di un'area più grande della finestra principale. Alcuni widget come TreeView e TextView del supporto nativo per lo scorrimento. Per altri come Etichetta o Tabella, dovrebbe essere fornita una vista.

La sintassi seguente viene utilizzata per il costruttore della classe gtk.ScrolledWindow:

sw = gtk.ScrolledWindow(hadj, vadj)

I seguenti sono i metodi della classe gtk.ScrolledWindow -

  • ScrolledWindow.set_hadjustment() - Questo imposta la regolazione orizzontale su un oggetto gtk.Adjustment

  • ScrolledWindow.set_vadjustment() - Questo imposta la regolazione verticale su un oggetto gtk.Adjustment

  • ScrolledWindow.set_Policy (hpolicy, vpolicy)- Questo imposta le proprietà "hscrollbar_policy" e "vscrollbar_policy". Viene utilizzata una delle seguenti costanti predefinite:

    • gtk.POLICY_ALWAYS - La barra di scorrimento è sempre presente

    • gtk.POLICY_AUTOMATIC - La barra di scorrimento è presente solo se necessario, ovvero i contenuti sono più grandi della finestra

    • gtk.POLICY_NEVER - La barra di scorrimento non è mai presente

  • ScrolledWindow.add_with_viewport(child) - Questo metodo viene utilizzato per aggiungere un widget (specificato dal figlio) senza funzionalità di scorrimento native alla finestra a scorrimento. Questa è una funzione comoda che equivale ad aggiungerechild ad un gtk.Viewport, quindi aggiungendo la vista alla finestra a scorrimento.

Il codice seguente aggiunge una finestra a scorrimento attorno a un oggetto gtk.Table con dimensioni 10 per 10. Poiché un oggetto Table non supporta automaticamente le regolazioni, viene aggiunto in una finestra.

sw = gtk.ScrolledWindow()
table = gtk.Table(10,10)

Due cicli annidati vengono utilizzati per aggiungere 10 righe di 10 colonne ciascuna. Un widget gtk.Button viene posizionato in ogni cella.

for i in range(1,11):
   for j in range(1,11):
      caption = "Btn"+str(j)+str(i)
      btn = gtk.Button(caption)
      table.attach(btn, i, i+1, j, j+1)

Questa tabella abbastanza grande viene ora aggiunta nella finestra a scorrimento insieme a una finestra.

sw.add_with_viewport(table)

Esempio

Rispettare il codice seguente:

import gtk

class PyApp(gtk.Window):
   
   def __init__(self):
      super(PyApp, self).__init__()
      
	  self.set_title("ScrolledWindow and Viewport")
      self.set_size_request(400,300)
      self.set_position(gtk.WIN_POS_CENTER)
      sw = gtk.ScrolledWindow()
      table = gtk.Table(10,10)
      table.set_row_spacings(10)
      table.set_col_spacings(10)
      for i in range(1,11):
         for j in range(1,11):
            caption = "Btn"+str(j)+str(i)
            btn = gtk.Button(caption)
            table.attach(btn, i, i+1, j, j+1)
      sw.add_with_viewport(table)
      self.add(sw)
      
	  self.connect("destroy", gtk.main_quit)
      self.show_all()

PyApp()
gtk.main()

Il codice sopra genererà il seguente output:

L'oggetto gtk.Arrow viene utilizzato per disegnare una semplice freccia che punta verso quattro direzioni cardinali. Questa classe viene ereditata dagtk.Misc class e l'oggetto occuperanno qualsiasi spazio assegnato, ad esempio un widget Etichetta o Pulsante.

In genere, l'oggetto Arrow viene creato utilizzando il seguente costruttore:

Arr = gtk.Arrow(arrow_type, shadow_type)

Le costanti arrow_type predefinite sono:

  • gtk.ARROW_UP
  • gtk.ARROW_DOWN
  • gtk.ARROW_LEFT
  • gtk.ARROW_RIGHT

Le costanti shadow_type predefinite sono elencate nella tabella seguente:

gtk.SHADOW_NONE Nessun contorno.
gtk.SHADOW_IN Il contorno è smussato verso l'interno.
gtk.SHADOW_OUT Il contorno è smussato verso l'esterno come un bottone.
gtk.SHADOW_ETCHED_IN Il contorno stesso è una smussatura verso l'interno, ma la cornice smussa verso l'esterno.
gtk.SHADOW_ETCHED_OUT Il contorno è una smussatura verso l'esterno, la cornice smussa verso l'interno.

Esempio

Nell'esempio seguente, quattro widget Button vengono aggiunti a un Hbox. Sopra ogni pulsante, viene posizionato un oggetto gtk.Arrow che punta rispettivamente SU, GIÙ, SINISTRA e DESTRA. Il contenitore HBOX viene posizionato nella parte inferiore della finestra di livello superiore con l'aiuto di un contenitore di allineamento.

Rispetta il codice -

import gtk

class PyApp(gtk.Window):
   
   def __init__(self):
      super(PyApp, self).__init__()
      self.set_title("Arrow Demo")
      self.set_size_request(300, 200)
      self.set_position(gtk.WIN_POS_CENTER)
		
      vbox = gtk.VBox(False, 5)
      hbox = gtk.HBox(True, 3)
      valign = gtk.Alignment(0, 1, 0, 0)
      vbox.pack_start(valign)
		
      arr1 = gtk.Arrow(gtk.ARROW_UP, gtk.SHADOW_NONE)
      arr2 = gtk.Arrow(gtk.ARROW_DOWN, gtk.SHADOW_NONE)
      arr3 = gtk.Arrow(gtk.ARROW_LEFT, gtk.SHADOW_NONE)
      arr4 = gtk.Arrow(gtk.ARROW_RIGHT, gtk.SHADOW_NONE)
		
      btn1 = gtk.Button()
      btn1.add(arr1)
      btn2 = gtk.Button()
      btn2.add(arr2)
      btn3 = gtk.Button()
      btn3.add(arr3)
      btn4 = gtk.Button()
      btn4.add(arr4)
		
      hbox.add(btn1)
      hbox.add(btn2)
      hbox.add(btn3)
      hbox.add(btn4)
		
      halign = gtk.Alignment(0.5, 0.5, 0, 0)
      halign.add(hbox)
		
      vbox.pack_start(halign, False, True, 10)
      self.add(vbox)
      self.connect("destroy", gtk.main_quit)
      self.show_all()

PyApp()
gtk.main()

Il codice sopra genererà il seguente output:

Questa classe è anche ereditata dalla classe gtk.Misc. L'oggetto della classe gtk.Image mostra un'immagine. Di solito, l'immagine deve essere caricata da un file in un buffer di pixel che rappresenta la classe gtk.gdk.Pixbuf. Invece una funzione di comoditàset_from_file() è comunemente usato per visualizzare i dati dell'immagine da un file in un widget gk.Image.

Il modo più semplice per creare l'oggetto gtk.Image è utilizzare il seguente costruttore:

img = gtk.Image()

I seguenti sono i metodi della classe gtk.Image:

  • Image.set_from_file() - Imposta i dati dell'immagine dal contenuto del file.

  • Image.set_from_pixbuf() - Imposta i dati dell'immagine da pixmap in cui i dati dell'immagine vengono caricati per la manipolazione fuori schermo.

  • Image.set_from_pixbuf() - Questo imposta i dati dell'immagine usando pixbuf che è un oggetto contenente i dati che descrivono un'immagine utilizzando le risorse lato client.

  • Image.set_from_stock() - Imposta i dati di immagine dall'articolo in magazzino identificato da stock_id.

  • Image.clear() - Questo rimuove l'immagine corrente.

  • Image.set_from_image()- Questo imposta i dati dell'immagine da un buffer dell'immagine lato client nel formato pixel della visualizzazione corrente. Se l'immagine èNone, i dati dell'immagine corrente verranno rimossi.

Esempio

Nel seguente programma, l'oggetto gtk.Image è ottenuto da un file immagine. Viene ulteriormente aggiunto nella finestra di primo livello.

import gtk

class PyApp(gtk.Window):
   
   def __init__(self):
      super(PyApp, self).__init__()
      
	  self.set_title("PyGtk Image demo")
      self.set_size_request(300, 200)
      self.set_position(gtk.WIN_POS_CENTER)
      
	  image1 = gtk.Image()
      image1.set_from_file("python.png")
      self.add(image1)
      
	  self.connect("destroy", gtk.main_quit)
      self.show_all()

PyApp()
gtk.main()

Il codice sopra genererà il seguente output:

Il widget DrawingArea presenta una tela vuota contenente una gtk.gdk.Window su cui è possibile disegnare oggetti come linea, rettangolo, arco, ecc.

PyGTK usa la libreria Cairo per tali operazioni di disegno. Cairo è una popolare libreria di grafica vettoriale 2D. È scritto in C., sebbene abbia collegamenti nella maggior parte dei linguaggi come C ++, Java, Python, PHP ecc. La libreria Cairo può essere utilizzata per disegnare su dispositivi di output standard in vari sistemi operativi. Può anche essere utilizzato per creare file PDF, SVG e post-script.

Per eseguire diverse operazioni di disegno, dobbiamo recuperare il dispositivo sul testo dell'oggetto di output di destinazione. In questo caso, poiché il disegno appare nel widget gtk.DrawingArea, si ottiene il contesto di dispositivo di gdk.Window contenuto al suo interno. Questa classe ha un filecairo-create() metodo che restituisce il contesto del dispositivo.

area = gtk.DrawingArea()
dc = area.window.cairo_create()

Il widget DrawingArea può essere collegato ai callback in base ai seguenti segnali emessi da esso:

Rendersi conto Per eseguire le azioni necessarie quando il widget viene istanziato su un particolare display.
configure_event Per eseguire tutte le azioni necessarie quando il widget cambia dimensione.
expose_event Per gestire il ridisegno del contenuto del widget quando un'area di disegno viene visualizzata per la prima volta sullo schermo o quando è coperta da un'altra finestra e quindi scoperta (esposta).

Gli eventi Mouse e Tastiera possono essere utilizzati anche per richiamare i callback di add_events() method del gtk.Widget class.

Di particolare interesse è il segnale dell'evento di esposizione che viene emesso quando viene visualizzata per la prima volta l'area di disegno DrawingArea. I diversi metodi per disegnare oggetti 2D, definiti nella libreria Cairo, vengono richiamati da questo callback connesso al segnale dell'evento di esposizione. Questi metodi disegnano gli oggetti corrispondenti nel contesto del dispositivo Cairo.

I seguenti sono i metodi di disegno disponibili:

  • dc.rectangle (x, y, w, h) - Disegna un rettangolo alla coordinata in alto a sinistra specificata e con larghezza e altezza date.

  • dc.arc (x, y, r, a1, a2) - Disegna un arco circolare con un dato raggio e due angoli.

  • dc.line (x1, y1, x2, y2) - Disegna una linea tra due coppie di coordinate.

  • dc.line_to (x, y) - Disegna una linea dalla posizione corrente a (x, y)

  • dc.show_text (str) - disegna la stringa nella posizione corrente del cursore

  • dc.stroke () - disegna i contorni

  • dc.fill () - riempie la forma con il colore corrente

  • dc.set_color_rgb (r, g, b) - imposta il colore sul contorno e riempie con valori r, ge b compresi tra 0,0 e 1,0

Esempio

Lo script seguente disegna forme diverse e prova utilizzando i metodi Cairo.

import gtk
import math

class PyApp(gtk.Window):
   
   def __init__(self):
      super(PyApp, self).__init__()
      
	  self.set_title("Basic shapes using Cairo")
      self.set_size_request(400, 250)
      self.set_position(gtk.WIN_POS_CENTER)
      
	  self.connect("destroy", gtk.main_quit)
		
      darea = gtk.DrawingArea()
      darea.connect("expose-event", self.expose)
		
      self.add(darea)
      self.show_all()
		
      def expose(self, widget, event):
      cr = widget.window.cairo_create()
		
      cr.set_line_width(2)
      cr.set_source_rgb(0,0,1)
      cr.rectangle(10,10,100,100)
      cr.stroke()
		
      cr.set_source_rgb(1,0,0)
      cr.rectangle(10,125,100,100)
      cr.stroke()
		
      cr.set_source_rgb(0,1,0)
      cr.rectangle(125,10,100,100)
      cr.fill()
		
      cr.set_source_rgb(0.5,0.6,0.7)
      cr.rectangle(125,125,100,100)
      cr.fill()
		
      cr.arc(300, 50, 50,0, 2*math.pi)
      cr.set_source_rgb(0.2,0.2,0.2)
      cr.fill()
		
      cr.arc(300, 200, 50, math.pi,0)
      cr.set_source_rgb(0.1,0.1,0.1)
      cr.stroke()
		
      cr.move_to(50,240)
      cr.show_text("Hello PyGTK")
      cr.move_to(150,240)
      cr.line_to(400,240)
      cr.stroke()

PyApp()
gtk.main()

Lo script sopra genererà il seguente output:

Il widget SpinnButton, spesso chiamato Spinner è un widget gtk.Entry con frecce su e giù alla sua destra. Un utente può digitare un valore numerico direttamente al suo interno o aumentare o diminuire utilizzando le frecce su e giù. La classe gtk.SpinButton viene ereditata dalla classe gtk.Entry. Utilizza un oggetto gtk.Adjustment con il quale è possibile limitare l'intervallo e il passo del valore numerico nello spinner.

Il widget SpinButton viene creato utilizzando il seguente costruttore:

sp = gtk.SpinButton(adj, climb_rate, digits)

Qui, adj rappresenta il gtk.Adjustment object controlling range, climb_rate è un fattore di accelerazione e il numero di decimali specificato da cifre.

La classe gtk.SpinButton ha i seguenti metodi:

  • SpinButton.set_adjustment () - Imposta la proprietà "regolazione".

  • SpinButton.set_digits () - Questo imposta la proprietà "digits" sul valore per determinare il numero di posizioni decimali che devono essere visualizzate dallo spinbutton.

  • SpinButton.set_increments (step, page) - Questo imposta il valore del passo a cui è applicato un incremento per ogni pressione del pulsante sinistro del mouse e il valore della pagina che è l'incremento applicato per ogni pressione del pulsante centrale del mouse.

  • SpinButton.set_range (): imposta i valori minimo e massimo consentiti per spinbutton.

  • SpinButton.set_value (): imposta il pulsante di selezione su un nuovo valore a livello di codice.

  • SpinButton.update_policy () - I valori validi sono gtk.UPDATE_ALWAYS e gtk.UPDATE_VALID

  • SpinButton.spin (direction, increment = 1) - Questo incrementa o decrementa il valore di Spinner nella direzione specificata.

Le seguenti sono le costanti di direzione predefinite:

gtk.SPIN_STEP_FORWARD avanti di step_increment
gtk.SPIN_STEP_BACKWARD indietro di step_increment
gtk.SPIN_PAGE_FORWARD avanti di step_increment
gtk.SPIN_PAGE_BACKWARD indietro di step_increment
gtk.SPIN_HOME passare al valore minimo
gtk.SPIN_END passare al valore massimo
gtk.SPIN_USER_DEFINED aggiungere incremento al valore
  • SpinButton.set_wrap () - Se wrap è True, il valore del pulsante di selezione va a capo al limite opposto quando il limite superiore o inferiore dell'intervallo supera.

Il widget gtk.SpinButton emette i seguenti segnali:

valore di cambiamento Viene emesso quando il valore del pulsante di selezione viene modificato dall'azione della tastiera
ingresso Viene emesso quando il valore cambia.
produzione Viene emesso quando il valore di visualizzazione del pulsante di selezione viene modificato. ritornaTrue se il gestore imposta correttamente il testo e non sono necessarie ulteriori elaborazioni.
valore modificato Viene emesso quando viene modificata una qualsiasi delle impostazioni che modificano la visualizzazione del pulsante di selezione.
avvolto Viene emesso subito dopo che il pulsante di selezione torna dal valore massimo a quello minimo o viceversa.

Esempio

L'esempio seguente costruisce un semplice Date Selectorutilizzando tre widget SpinButton. Al selettore del giorno viene applicato un oggetto di regolazione per limitare il valore tra 1 e 31. Il secondo selettore è per il numero di mesi 1—12. Il terzo selettore seleziona l'intervallo di anni 2000—2020.

Rispetta il codice -

import gtk

class PyApp(gtk.Window):
   
   def __init__(self):
      super(PyApp, self).__init__()
      self.set_title("SpinButton Demo")
      self.set_size_request(300, 200)
      self.set_position(gtk.WIN_POS_CENTER)
      self.set_border_width(20)
		
      vbox = gtk.VBox(False, 5)
      hbox = gtk.HBox(True, 3)
      lbl1 = gtk.Label("Date")
      hbox.add(lbl1)
		
      adj1 = gtk.Adjustment(1.0, 1.0, 31.0, 1.0, 5.0, 0.0)
      spin1 = gtk.SpinButton(adj1, 0, 0)
      spin1.set_wrap(True)
		
      hbox.add(spin1)
      lbl2 = gtk.Label("Month")
      hbox.add(lbl2)
		
      adj2 = gtk.Adjustment(1.0, 1.0, 12.0, 1.0, 5.0, 0.0)
      spin2 = gtk.SpinButton(adj2, 0, 0)
      spin2.set_wrap(True)
		
      hbox.add(spin2)
      lbl3 = gtk.Label("Year")
      hbox.add(lbl3)
		
      adj3 = gtk.Adjustment(1.0, 2000.0, 2020.0, 1.0, 5.0, 0.0)
      spin3 = gtk.SpinButton(adj3, 0, 0)
      spin3.set_wrap(True)
      hbox.add(spin3)
		
      frame = gtk.Frame()
      frame.add(hbox)
      frame.set_label("Date of Birth")
		
      vbox.add(frame)
      self.add(vbox)
      self.connect("destroy", gtk.main_quit)
      self.show_all()
PyApp()
gtk.main()

Al momento dell'esecuzione, il codice precedente produrrà il seguente output:

Il widget Calendario nel toolkit di PyGTK mostra un semplice calendario con visualizzazione di un mese alla volta. I controlli di navigazione per cambiare mese e anno vengono visualizzati per impostazione predefinita. Le opzioni di visualizzazione possono essere opportunamente configurate.

Il valore della proprietà month è compreso tra 0 e 11 e quello della proprietà date è compreso tra 1 e 31.

C'è un semplice costruttore per creare un oggetto gtk.Calendar -

cal = gtk.Calendar()

Lo stile di visualizzazione predefinito mostra il mese e l'anno correnti nonché i nomi dei giorni.

La classe gtk.Calendar ha i seguenti metodi:

  • Calendar.select_month (mm, yy): cambia la visualizzazione del calendario in quella specificata mm e yy.

  • Calendar.select_day (dd): seleziona il file specificato dd sul calendario quando ha un valore compreso tra 1 e 31. If dd è 0 quindi la selezione del giorno corrente viene rimossa.

  • Calendar.display_options (): imposta le opzioni di visualizzazione del calendario sul valore specificato da flags. Le possibili opzioni di visualizzazione sono una combinazione di:

gtk.CALENDAR_SHOW_HEADING Specifica che devono essere visualizzati il ​​mese e l'anno.
gtk.CALENDAR_SHOW_DAY_NAMES Specifica che devono essere presenti tre descrizioni dei giorni di lettere.
gtk.CALENDAR_NO_MONTH_CHANGE Prevents the user from switching months with the calendar.
gtk.CALENDAR_SHOW_WEEK_NUMBERS Displays each week numbers of the current year, down the left side of the calendar.
gtk.CALENDAR_WEEK_START_MONDAY Starts the calendar week on Monday, instead of the default Sunday.
  • Calendar.get_date() — This retrieves the calendar's current year, month and selected day numbers as a tuple (year, month, day).

The gtk.Calendar widget emits the following signals −

day-selected This is emitted when a day is selected either by the user or programmatically.
month-changed This is emitted when the calendar month is changed programmatically or by the user.
next-month This is emitted when the user clicks the "next-month" navigation control in the calendar header.
next-year This is emitted when the user clicks the "next-year" navigation control in the calendar header.
prev-month This is emitted when the user clicks the "prev-month" navigation control in the calendar header.
prev-year This is emitted when the user clicks the "prev-year" navigation control in the calendar header.

In the following example, a gtk.Calendar control and four buttons are placed in the toplevel window.

When the 'heading' button is clicked, the Calendar's display options are set to SHOW_HEADING −

def heading(self, widget):
   self.cal.set_display_options(gtk.CALENDAR_SHOW_HEADING)

When the user clicks the 'day name' button, the callback sets display options to SHOW_DAY_NAMES −

def dayname(self, widget):
self.cal.set_display_options(gtk.CALENDAR_SHOW_DAY_NAMES)

Both the display options are enabled when 'both' button is pressed. To begin with, all flags of display options are removed by setting it to 0.

self.cal.set_display_options(0)

The 'set' button pops up a message box displaying the currently marked date.

tp = self.cal.get_date()
str1 = str(tp[0])
str2 = str(tp[1]+1)
str3 = str(tp[2])
label = gtk.Label("Date selected:"+str3+"-"+str2+"-"+str1)
dialog.vbox.add(label)
label.show()

Example

Observe the following code −

import gtk

class PyApp(gtk.Window):
   
   def __init__(self):
      super(PyApp, self).__init__()
      self.set_title("Calendar Demo")
      self.set_size_request(300, 200)
      self.set_position(gtk.WIN_POS_CENTER)
		
      vbox = gtk.VBox(False, 5)
      self.cal = gtk.Calendar()
      halign1 = gtk.Alignment(0.5, 0.5, 0, 0)
      halign1.add(self.cal)
		
      self.cal.set_display_options(0)
      valign = gtk.Alignment(0, 1, 0, 0)
      vbox.pack_start(halign1)
		
      self.btn1 = gtk.Button("set")
      self.btn2 = gtk.Button("heading")
      self.btn3 = gtk.Button("day name")
      self.btn4 = gtk.Button("Both")
		
      hbox = gtk.HBox(True, 3)
      hbox.add(self.btn1)
      hbox.add(self.btn2)
      hbox.add(self.btn3)
      hbox.add(self.btn4)
		
      halign = gtk.Alignment(0.5, 0.5, 0, 0)
      halign.add(hbox)
		
      vbox.pack_start(halign, False, True, 10)
      self.add(vbox)
		
      self.btn1.connect("clicked", self.selectdate)
      self.btn2.connect("clicked", self.heading)
      self.btn3.connect("clicked", self.dayname)
      self.btn4.connect("clicked", self.bothflags)
		
      self.connect("destroy", gtk.main_quit)
      self.show_all()
		
   def heading(self, widget):
      self.cal.set_display_options(gtk.CALENDAR_SHOW_HEADING)
		
   def dayname(self, widget):
      self.cal.set_display_options(gtk.CALENDAR_SHOW_DAY_NAMES)
		
   def bothflags(self, widget):
      self.cal.set_display_options(gtk.CALENDAR_SHOW_HEADING|gtk.CALENDAR_SHOW_DAY_NAMES)
   def selectdate(self, widget):
      tp = self.cal.get_date()
      dialog = gtk.Dialog("My dialog",
      self,
      gtk.DIALOG_MODAL | gtk.DIALOG_DESTROY_WITH_PARENT,
      (gtk.STOCK_OK, gtk.RESPONSE_ACCEPT))
		
      str1 = str(tp[0])
      str2 = str(tp[1]+1)
      str3 = str(tp[2])
		
      label = gtk.Label("Date selected:"+str3+"-"+str2+"-"+str1)
      dialog.vbox.add(label)
      label.show()
      res = dialog.run()
      dialog.destroy()

PyApp()
gtk.main()

Il codice sopra genererà il seguente output:

Un oggetto Appunti contiene dati condivisi tra due processi o due widget della stessa applicazione. Gtk.Clipboard è un'interfaccia di alto livello per la classe gtk.SelectionData.

Quello che segue è un prototipo del costruttore gtk.Clipboard -

gtk.Clipboard(display,selction)

Qui, il parametro di visualizzazione corrisponde all'oggetto gtk.gdk.Display per il quale devono essere creati o recuperati gli appunti. Per impostazione predefinita, è il dispositivo di output standard. Il parametro di selezione predefinito è APPUNTI, un oggetto che rappresenta una stringa interna.

PyGTK fornisce una comoda funzione per creare un oggetto appunti con i valori predefiniti.

gtk.clipboard.get()

La classe gtk.Clipboard ha i seguenti metodi:

  • Clipboard.store (): memorizza i dati degli appunti correnti da qualche parte in modo che rimangano in giro anche dopo che l'applicazione è stata chiusa.

  • Clipboard.clear (): rimuove il contenuto degli appunti.

  • Clipboard.set_text (testo): imposta il contenuto degli appunti sulla stringa.

  • Clipboard.request_text (): richiede il contenuto degli appunti come testo. Quando il testo viene ricevuto successivamente,callback verrà chiamato con i dati specificati da user_data. La firma dicallback è:

    • def callback (appunti, testo, dati) - il testo conterrà il file text recuperato dagli appunti.

Come dimostrazione degli appunti, il codice seguente utilizza due TextView e due pulsanti in una finestra gtk.Window di primo livello. Il pulsante "Imposta" richiama il fileon_set() funzione che mette il testo dal primo textView negli appunti.

buf = self.tv1.get_buffer()
text = buf.get_text(buf.get_start_iter(), buf.get_end_iter())
self.clipboard = gtk.clipboard_get()
self.clipboard.set_text(text)
self.clipboard.store()

Quando il secondo pulsante ('retrieved') viene premuto, i dati dagli appunti vengono recuperati dal metodo request_text () -

self.clipboard.request_text(self.readclipboard,        user_data = None)

Il contenuto di user_data va a un metodo di callback readclipboard() che lo visualizza nella seconda visualizzazione di testo.

def readclipboard(self, clipboard, text, data):
   buffer = gtk.TextBuffer()
   buffer.set_text(text)
   self.tv2.set_buffer(buffer)

Esempio

Quanto segue è l'intero codice per il funzionamento degli appunti:

import gtk

class PyApp(gtk.Window):
   
   def __init__(self):
      super(PyApp, self).__init__()
      
	  self.set_title("Clipboard demo")
      self.set_size_request(300,200)
      self.set_position(gtk.WIN_POS_CENTER)
		
      vbox = gtk.VBox(False, 5)
      self.tv1 = gtk.TextView()
		
      vbox.add(self.tv1)
      self.tv2 = gtk.TextView()
		
      vbox.add(self.tv2)
      hbox = gtk.HBox(True, 3)
		
      Set = gtk.Button("set")
      Set.set_size_request(70, 30)
		
      retrieve = gtk.Button("retrieve")
      hbox.add(Set)
      hbox.add(retrieve)
      halign = gtk.Alignment(1, 0, 0, 0)
      halign.add(hbox)
		
      vbox.pack_start(halign, False, False, 3)
      self.add(vbox)
      Set.connect("clicked", self.on_set)
      retrieve.connect("clicked", self.on_retrieve)
      self.connect("destroy", gtk.main_quit)
      self.show_all()
		
   def on_set(self, widget):
      buf = self.tv1.get_buffer()
      text = buf.get_text(buf.get_start_iter(), buf.get_end_iter())
      self.clipboard = gtk.clipboard_get()
      self.clipboard.set_text(text)
      self.clipboard.store()
		
   def on_retrieve(self, widget):
      self.clipboard.request_text(self.readclipboard, user_data=None)
		
   def readclipboard(self, clipboard, text, data):
      buffer = gtk.TextBuffer()
      buffer.set_text(text)
      self.tv2.set_buffer(buffer)

PyApp()
gtk.main()

Il codice sopra genererà il seguente output:

Questa è una classe base per i righelli orizzontali (gtk.Hruler) e verticali (gtk.Vruler) utili per mostrare la posizione del puntatore del mouse nella finestra. Un piccolo triangolo nel righello indica la posizione del puntatore.

Gli oggetti righello vengono creati con i rispettivi costruttori:

hrule = gtk.Hruler()
vrule = gtk.Vruler()

I seguenti metodi di classe gtk.Ruler sono disponibili per entrambe le classi derivate:

  • Ruler.set_metric () - Imposta l'unità di misura. Le costanti metriche predefinite sono: gtk.PIXELS (predefinito), gtk.INCHES e gtk.CENTIMETERS

  • Ruler.set_range () - Imposta i limiti inferiore e superiore, la posizione e la dimensione massima del righello.

Nell'esempio riportato di seguito, i righelli orizzontale e verticale sono posizionati sopra ea sinistra di un widget gtk.TextView.

La misura del righello orizzontale è in pixel. I suoi valori minimo e massimo sono rispettivamente 0 e 400. Si trova nella riga superiore di un gtk.VBox.

hrule = gtk.HRuler()
hrule.set_metric(gtk.PIXELS)
hrule.set_range(0, 4,0,0.5)
vbox.pack_start(hrule)

La riga inferiore di Vbox contiene un HBox. Sono inclusi un righello verticale e un widget TextView, in cui è possibile inserire un testo su più righe.

vrule=gtk.VRuler()
vrule.set_metric(gtk.PIXELS)
vrule.set_range(0, 4, 10, 0.5)
hbox.pack_start(vrule)

Esempio

Rispettare il codice seguente:

import gtk
class PyApp(gtk.Window):
   
   def __init__(self):
      super(PyApp, self).__init__()
      
	  self.set_title("Ruler demo")
      self.set_size_request(400,400)
      self.set_position(gtk.WIN_POS_CENTER)
		
      vbox = gtk.VBox()
      tv = gtk.TextView()
      tv.set_size_request(350,350)
		
      hrule = gtk.HRuler()
      hrule.set_metric(gtk.PIXELS)
      hrule.set_range(0, 4,0,0.5)
		
      vbox.pack_start(hrule)
      hbox = gtk.HBox()
      vrule = gtk.VRuler()
		
      vrule.set_metric(gtk.PIXELS)
      vrule.set_range(0, 4, 10, 0.5)
		
      hbox.pack_start(vrule)
      halign = gtk.Alignment(0.5, 0.5, 0, 0)
      halign.add(tv)
		
      hbox.pack_start(halign, False, True, 10)
      vbox.add(hbox)
		
      self.add(vbox)
      self.connect("destroy", gtk.main_quit)
      self.show_all()

PyApp()
gtk.main()

L'output generato dal programma precedente assomiglia a un documento MS Word -

Il modulo gobject dell'API PyGTK ha una funzione utile per creare una funzione di timeout che verrà chiamata periodicamente.

source_id = gobject.timeout_add(interval, function, …)

Il secondo argomento è la funzione di callback che desideri chiamare dopo ogni millisecondo che è il valore del primo argomento - intervallo. Argomenti aggiuntivi possono essere passati al callback come dati di funzione.

Il valore restituito da questa funzione è source_id. Usandolo, la funzione di callback viene interrotta dalla chiamata.

gobject.source_remove(source_id)

La funzione di callback deve restituire True per poter continuare a ripetere. Pertanto, può essere interrotto restituendo False.

Due pulsanti e due etichette vengono inseriti in una finestra di primo livello nel seguente programma. Un'etichetta mostra un numero crescente. Il btn1 chiamaon_click che imposta la funzione di timeout con un intervallo di 1000 ms (1 secondo).

btn1.connect("clicked", self.on_click)

def on_click(self, widget):
   self.source_id = gobject.timeout_add(1000, counter, self)

La funzione timeout è denominata come counter(). Incrementa il numero su un'etichetta ogni 1 secondo.

def counter(timer):
   c=timer.count+1
   print c
   timer.count=c
   timer.lbl.set_label(str(c))
   return True

La richiamata sul secondo pulsante rimuove la funzione di timeout.

btn2.connect("clicked", self.on_stop)
def on_stop(self, widget):
gobject.source_remove(self.source_id)

Esempio

Di seguito è riportato il codice completo per l'esempio Timeout:

import gtk, gobject

def counter(timer):
      c = timer.count+1
      print c
      timer.count = c
      timer.lbl.set_label(str(c))
      return True
      class PyApp(gtk.Window):
		
   def __init__(self):
      super(PyApp, self).__init__()
      self.set_title("Timeout Demo")
      self.set_size_request(300, 200)
      self.set_position(gtk.WIN_POS_CENTER)
		
      vbox = gtk.VBox(False, 5)
      hbox = gtk.HBox(True, 3)
		
      hb = gtk.HBox()
      lbl1 = gtk.Label("Counter: ")
		
      hb.add(lbl1)
      self.lbl = gtk.Label("")
      hb.add(self.lbl)
      valign = gtk.Alignment(0.5, 0.5, 0, 0)
      valign.add(hb)
      vbox.pack_start(valign, True, True, 10)
		
      btn1 = gtk.Button("start")
      btn2 = gtk.Button("stop")
		
      self.count = 0
      self.source_id = 0
		
      hbox.add(btn1)
      hbox.add(btn2)
		
      halign = gtk.Alignment(0.5, 0.5, 0, 0)
      halign.add(hbox)
		
      vbox.pack_start(halign, False, True, 10)
      self.add(vbox)
		
      btn1.connect("clicked", self.on_click)
      btn2.connect("clicked", self.on_stop)
		
      self.connect("destroy", gtk.main_quit)
      self.show_all()
		
   def on_click(self, widget):
      self.source_id = gobject.timeout_add(1000, counter, self)
		
   def on_stop(self, widget):
      gobject.source_remove(self.source_id)

PyApp()
gtk.main()

Quando viene eseguito, la finestra mostra due pulsanti in basso. Il numero sull'etichetta aumenterà periodicamente quando si fa clic sul pulsante Start e smetterà di aumentare quando si fa clic sul pulsante Stop.

Osserva l'output -

I widget a cui è associato X Window possono essere trascinati e rilasciati. Nel programma, è necessario prima designare un widget come origine e / o destinazione per il trascinamento. Il widget definito come sorgente può inviare i dati trascinati. Il widget di destinazione lo accetta quando i dati trascinati vengono rilasciati su di esso.

I seguenti passaggi sono coinvolti nella configurazione di un'applicazione abilitata al drag-and-drop:

Step 1 - Impostazione di un widget sorgente.

Step 2 - Il metodo drag_source_set () specifica i tipi di destinazione per un'operazione di trascinamento -

widget.drag_source_set(start_button_mask, targets, info)

Step 3 - L'argomento start_button_mask specifica una maschera di bit di pulsanti che avvia l'operazione di trascinamento.

Step 4 - L'argomento target è un elenco di tuple di questa struttura -

(target, flags, info)

L'argomento di destinazione è una stringa che rappresenta il tipo di trascinamento, ad esempio text / plain o image / x-xpixmap.

Step 6 - I seguenti flag sono predefiniti -

  • gtk.TARGET_SAME_APP
  • gtk.TARGET_SAME_WIDGET

Step 7 - Non ci saranno limitazioni poiché il flag è impostato su 0.

Se il widget non deve agire come sorgente, può essere disattivato:

widget.drag_source_unset()

Il segnale sorgente emette segnali. La tabella seguente elenca i segnali e le loro richiamate.

drag_begin def drag_begin_cb (widget, drag_context, data):
drag_data_get def drag_data_get_cb (widget, drag_context, selection_data, info, time, data):
drag_data_delete def drag_data_delete_cb (widget, drag_context, data):
drag_end def drag_end_cb (widget, drag_context, data):

Configurazione di un widget di destinazione

Il metodo drag_dest_set () specifica quale widget può ricevere i dati trascinati.

widget.drag_dest_set(flags, targets, action)

Il parametro flags può assumere una delle seguenti costanti:

gtk.DEST_DEFAULT_MOTION Questo controlla se il trascinamento corrisponde all'elenco di possibili obiettivi e azioni di questo widget, quindi chiama drag_status () come appropriato.
gtk.DEST_DEFAULT_HIGHLIGHT Questo disegna un'evidenziazione su questo widget fintanto che un trascinamento è su questo widget
gtk.DEST_DEFAULT_DROP Quando si verifica un rilascio, se il trascinamento corrisponde all'elenco di possibili obiettivi e azioni di questo widget chiama drag_get_data()per conto del widget. Che la caduta abbia successo o meno, chiamadrag_finish(). Se l'azione era una mossa e il trascinamento ha avuto successo, verrà passato TRUE per il parametro di cancellazione adrag_finish().
gtk.DEST_DEFAULT_ALL Se impostato, specifica che devono essere eseguite tutte le azioni predefinite.

La destinazione è un elenco di tuple contenenti informazioni sulla destinazione. L'argomento azioni è una maschera di bit o una combinazione di uno o più dei seguenti valori:

  • gtk.gdk.ACTION_DEFAULT
  • gtk.gdk.ACTION_COPY
  • gtk.gdk.ACTION_MOVE
  • gtk.gdk.ACTION_LINK
  • gtk.gdk.ACTION_PRIVATE
  • gtk.gdk.ACTION_ASK

Il gestore "drag-motion" deve determinare se i dati di trascinamento sono appropriati facendo corrispondere i target di destinazione con il gtk.gdk.DragContext target e, facoltativamente, esaminando i dati di trascinamento chiamando il file drag_get_data()metodo. Ilgtk.gdk.DragContext. drag_status() deve essere chiamato per aggiornare il drag_context stato.

Il gestore "drag-drop" deve determinare la destinazione corrispondente utilizzando il drag_dest_find_target() e quindi richiedere i dati di trascinamento utilizzando il drag_get_data()metodo. I dati saranno disponibili nel gestore "trascina-dati-ricevuti".