Hallo Welt!

Ein einfaches Programm hallo-welt.py, das eine Benutzeroberfläche aus der Datei hallo-welt.ui anzeigt.

Dieses Programm dient gleichzeitig als Grundgerüst für die anderen Beispiel-Programm in diesem Text.

Quellcode

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
#!/usr/bin/env python
#-*- coding: utf-8 -*-

import gtk


class MyApp(object):
    def __init__(self):
        self.builder = gtk.Builder()
        self.builder.add_from_file("hallo-welt.ui")
        self.builder.connect_signals(self)

    def obj(self, name):
    	"""
	Gibt Glade-Object 'name' zurück
	"""
        return self.builder.get_object(name)

    def run(self):
        """
	Startet die zentrale Warteschleife von Gtk
	"""
        try:
            gtk.main()
        except KeyboardInterrupt:
            pass
    
    def quit(self):
        """
        Verlässt die zentrale Warteschleife von Gtk

	"""
        gtk.main_quit()

###############################
## Signal-Behandlungsroutinen
###############################

#################
## Hauptfenster

    def on_window1_delete_event(self, *args):
        self.quit()





if __name__ == '__main__':
    app = MyApp()
    app.run()

Bildschirmfoto

Das Programm erzeugt ein einfaches Fenster:

_images/hallo-welt.png

Beschreibung

Die Struktur ist einfach: In Zeile 4 wird das Modul gtk importiert, dann wird in Zeile 7-24 eine Klasse MyApp definiert, die das eigentliche Programm enthält. Von dieser Klasse wird dann in Zeile 50-51 eine Instanz erzeugt und die Methode run aufgerufen.

In den Zeile 9-11 wird in der Methode __init__ ein gtk-Builder-Objekt erzeugt, die Benutzeroberfläche geladen und die Signal-Behandlungsroutinen verbunden (siehe Glade-Projektdateien laden).

Die Methode obj, die in den Zeilen 13-17 definiert wird, bekommt einen Namen als Parameter und gibt das zugehörige Objekt aus der Projektdatei zurück. Diese Methode wird hier noch nicht benutzt, sie ist aber in ernsthafteren Programmen oft nützlich.

Zeile 19-26 startet die Warteschliefe von GTK (siehe Signale und Ereignisse) und fängt KeyboardInterrupt ab, um eine Fehlermeldung zu vermeiden, falls das Programm mit Strg-C abgebrochen wird.

Die in Zeile 28-33 definierte Methode quit beendet die GTK-Warteschleife und damit das Programm.

In Zeile 42-43 wird eine Behandlungsroutine für das Signal delete-event des Fensters definiert, der die oben definierte Methode quit aufruft. Diese Behandlungsroutine wird aufgerufen, wenn das Fenster geschlossen wird, z.B. weil der Benutzer den entsprechenden Fester-Knopf angeklickt hat.

In den Zeilen 49-51 wird dann eine Instanz der Klasse MyApp erzeugt und deren Methode run aufrufen, um das Programm zu starten.