PyGTK Description:
GTK is the Gnome desktop graphics library first developed for Gimp, the GNU Image Manipulation Program.
The GTK libraries were packaged into a Python GUI library known as PyGTK.
These libraries closely resemble the capabilities of the GTK "C" libraries.
Alternative GUI development libraries exist for Python including those based on VW_windows, Qt and the Tk tool kit.
Python and PyGTK Installation:
Python and PyGTK are typically native packages on Linux and are easily installed on MS/Windows as MSI installations.
Linux: (example RHEL6/CentOS 6)
- python (native package: 2.6.5)
- pygtk2 (native package: 2.16.0)
Linux: (example Ubuntu 11.04)
- python2.7 (native package: 2.7.1)
- python-gtk2 (native package: 2.22.0)
Linux: (example Ubuntu 8.10)
- python2.5 (native package: 2.5.2)
- python-gtk2 (native package: 2.13.0)
MS/Windows: (dependencies listed are all 32 bit)
- python: http://www.python.org/download/
msi install: http://python.org/ftp/python/2.7.3/python-2.7.3.msi
(Be sure to add C:\Python27\ folder to the PATH to pick up python.exe)
- PyGTK: http://www.pygtk.org/downloads.html 32 bit all in one installer
http://ftp.gnome.org/pub/GNOME/binaries/win32/pygtk/2.22/pygtk-all-in-one-2.22.6.win32-py2.7.msi
PyGTK GUI Layout:
All pyGTK layouts are organized in a tree structure with the root of the tree being the main display window.
GUI Window:
gtk.Window(type=gtk.WINDOW_TOPLEVEL)
Options:
- set_title(title)
- set_position(position)
- set_focus(focus)
- set_default(default_widget)
- set_resizable(resizable)
- ...
13 | app_window = gtk.Window(gtk.WINDOW_TOPLEVEL) |
14 | app_window.set_size_request(500, 350) |
15 | app_window.set_border_width(10) |
16 | app_window.set_title("MyProgram title") |
17 | app_window.connect("delete_event", lambda w,e: gtk.main_quit()) |
29 | if __name__ == "__main__": |
Basic Python GTK GUI program framework to draw the main window.
GUI Layout:
In order to layout graphics, display test, display text entry boxes and other GUI widgets one can use a network of horizontal or vertical layout widgets.
If laying out widgets in two dimensions one can use a table of horizontal and vertical rows and collumns.
- Horizontal boxes
gtk.HBox(homogeneous=False, spacing=0)
- homogeneous: True = equal space allocations for al child objects.
- spacing: The additional horizontal space between child objects in pixels
- Vertical Boxes
gtk.VBox(homogeneous=False, spacing=0)
- homogeneous: True = equal space allocations for al child objects.
- spacing: The additional vertical space between child objects in pixels
- Table
gtk.Table(rows=4, columns=3, homogeneous=False)
- homogeneous: True = equal space allocations for al child objects.
- rows: number of rows
- columns: number of columns
There are lots of modifiers available:
- resize(rows, columns)
- set_row_spacing(row, spacing)
- set_column_spacing(column, spacing)
- attach(child, left_attach, right_attach, top_attach, bottom_attach, xoptions=gtk.EXPAND|gtk.FILL, yoptions=gtk.EXPAND|gtk.FILL, xpadding=0, ypadding=0)
- ...
The following uses HBox(), VBox() and Table() to layout text and button widgets in the display window:
13 | app_window = gtk.Window(gtk.WINDOW_TOPLEVEL) |
14 | app_window.set_size_request(500, 350) |
15 | app_window.set_border_width(10) |
16 | app_window.set_title("MyProgram title") |
17 | app_window.connect("delete_event", lambda w,e: gtk.main_quit()) |
19 | vbox_app = gtk.VBox(False, 0) |
20 | app_window.add(vbox_app) |
23 | label_app = gtk.Label("Application name: ") |
25 | vbox_app.pack_start(label_app, False, False, 6) |
29 | table_layout = gtk.Table(rows=2, columns=2, homogeneous=True) |
30 | label_a = gtk.Label("AAA") |
32 | table_layout.attach(label_a, 0, 1, 0, 1, 0,0,0,0) |
33 | label_b = gtk.Label("BBB") |
35 | table_layout.attach(label_b, 0, 1, 1, 2, 0,0,0,0) |
36 | label_c = gtk.Label("CCC") |
38 | table_layout.attach(label_c, 1, 2, 0, 1, 0,0,0,0) |
39 | label_d = gtk.Label("DDD") |
41 | table_layout.attach(label_d, 1, 2, 1, 2, 0,0,0,0) |
43 | vbox_app.add(table_layout) |
47 | hbox_close = gtk.HBox(False, 0) |
48 | label_close = gtk.Label("Close aplication: ") |
49 | hbox_close.pack_start(label_close, True, True, 0) |
52 | button_close = gtk.Button(stock=gtk.STOCK_CLOSE) |
53 | button_close.connect("clicked", lambda w: gtk.main_quit()) |
54 | button_close.set_flags(gtk.CAN_DEFAULT) |
55 | hbox_close.pack_start(button_close, True, True, 0) |
59 | vbox_app.add(hbox_close) |
63 | button_close.grab_default() |
73 | if __name__ == "__main__": |
Resulting GUI layout:
Button Widgets:
Button widgets provide a mechanism to provide functionality for the user action of selecting the button.
Thus the programmer must provide a Python callback function to be executed when the button is pressed.
gtk.Button(label=None, stock=None, use_underline=True)
Options:
- set_label(label)
- set_relief(newstyle)
- set_alignment(xalign, yalign)
- set_image(image)
- set_image_position(position)
- ...
Code to display a button:
04 | hbox_buttons = gtk.HBox(False, 0) |
06 | button_a = gtk.Button("Execute process A") |
07 | button_a_data = (arg_1, arg_2, arg_3, arg_4) |
08 | button_a.connect("clicked", self.button_a_callback, button_a_data) |
09 | button_a.set_flags(gtk.CAN_DEFAULT) |
11 | hbox_buttons.pack_start(button_a, True, True, 0) |
Variable "button_a" must be attached to a layout widget.
In this example snippet the button is attached to the
hbox_buttons layout widget.
Callback function to execute if button is pressed:
01 | def button_a_callback(self, widget, data_a): |
04 | first_fn_arg = data_a[0] |
05 | second_fn_arg = data_a[1] |
06 | third_fn_arg = data_a[2] |
07 | fourth_fn_arg = data_a[3] |
Text and Text Entry:
Text entry widgets require a callback function to manage and receive the text.
In this example we have a callback (callback enter_callback_b()) defined by the programmer when the widget is defined and the callback assigned to the widget by the call to the "connect" function call: entry_b.connect("changed", self.enter_callback_b, entry_b).
Note that the callback is called initially when the default text is assigned and every time the text entry is changed.
In this example we also added a label to display the intent of the text entry box to the user. A default entry is also assigned.
The variable entry_text_b can be passed to the location in the code where it is to be used but also can be assigned to a global variable.
gtk.Entry(gtk.Widget, gtk.Editable, gtk.CellEditable)
gtk.Entry(max=0)
Options:
- set_has_frame(setting)
- set_max_length(max) : max string length alowed to be enetered. Set to "0" for upper limit (65536).
- set_width_chars(n_chars) : width of the text entry box
- set_text(text) : Set the default text entry
- set_alignment(xalign)
- set_overwrite_mode(overwrite)
- ...
08 | def enter_callback_b(self, widget, entry_b): |
09 | entry_text_b = entry_b.get_text() |
10 | print "Text entry: %s\n" % entry_text_b |
17 | app_window = gtk.Window(gtk.WINDOW_TOPLEVEL) |
18 | app_window.set_size_request(500, 100) |
19 | app_window.set_border_width(10) |
20 | app_window.set_title("My program title") |
21 | app_window.connect("delete_event", lambda w,e: gtk.main_quit()) |
24 | entry_checker_default_b = "abc def default text" |
27 | hbox_b = gtk.HBox(False, 0) |
28 | app_window.add(hbox_b) |
29 | label_b = gtk.Label("Enter text: ") |
31 | hbox_b.pack_start(label_b, False, False, 0) |
35 | entry_b.set_max_length(80) |
36 | entry_b.set_width_chars(50) |
37 | entry_b.connect("changed", self.enter_callback_b, entry_b) |
38 | entry_b.set_text(entry_checker_default_b) |
39 | entry_b.select_region(0, len(entry_b.get_text())) |
41 | hbox_b.pack_start(entry_b, False, False, 0) |
51 | if __name__ == "__main__": |
Check Box:
The check box/button is a typical GTK widget which requires a callback function which is assigned to the widget.
In this example we use a frame widget to generate a visual frame to encapsulate the displayed widget. In addition we used a global variable to pass the variable around to potential functions which could use the variable.
gtk.CheckButton(label=None, use_underline=True)
- label : String to be used as a text label
- use_underline : True=underscore in the text label indicates "alt" accelerator key
08 | b_entry_checkbox = True |
12 | def entry_checkbox(self, widget, checkbox): |
13 | global b_entry_checkbox |
14 | b_entry_checkbox = checkbox.get_active() |
23 | global b_entry_checkbox |
26 | app_window = gtk.Window(gtk.WINDOW_TOPLEVEL) |
27 | app_window.set_size_request(500, 100) |
28 | app_window.set_border_width(10) |
29 | app_window.set_title("My program title") |
30 | app_window.connect("delete_event", lambda w,e: gtk.main_quit()) |
32 | frame_checkbox = gtk.Frame("Check for true:") |
33 | frame_checkbox.set_shadow_type(gtk.SHADOW_IN) |
35 | app_window.add(frame_checkbox) |
37 | check_box = gtk.CheckButton("Checkbox text string") |
38 | check_box.connect("toggled", self.entry_checkbox, check_box) |
39 | check_box.set_active(True) |
42 | frame_checkbox.add(check_box) |
51 | if __name__ == "__main__": |
Combo Boxes:
Combo boxes allow for a selection of assigned options.
Like all other widgets, it must be assigned to a layout widget to be displayed.
gtk.ComboBox(model=None)
gtk.combo_box_new_text()
Options:
- set_entry_text_column(text_column)
- set_wrap_width(width)
- set_active(index)
- append_text(text)
- ...
Code to display the combo box:
03 | global g_combo_selected |
06 | combo_box = gtk.combo_box_new_text() |
07 | combo_box.append_text("Choose option:") |
08 | combo_box.append_text("option-a") |
09 | combo_box.append_text("option-b") |
10 | combo_box.append_text("option-c") |
11 | combo_box.append_text("option-d") |
12 | combo_box.connect('changed', self.combo_select_callback) |
13 | combo_box.set_active(0) |
Combo box callback:
01 | def combo_select_callback(self, widget): |
02 | global g_combo_selected |
03 | model = widget.get_model() |
04 | index = widget.get_active() |
06 | print 'Option selected: ', model[index][0] |
07 | g_combo_selected = model[index][0] |
08 | if g_checker_selected == "Choose option:": |
09 | print "Error! Choose an option" |
Combo box:
Other combo box types include:
- gtk.Combo
- gtk.ComboBoxEntry
- gtk.ComboBoxText
Dialog Boxes:
The dialog box presents a pop-up message box to inform the application user.
gtk.MessageDialog(parent=None, flags=0, type=gtk.MESSAGE_INFO, buttons=gtk.BUTTONS_NONE, message_format=None)
- flags : gtk.DIALOG_MODAL, gtk.DIALOG_DESTROY_WITH_PARENT or 0 for no flags. Can be combined.
- type: The pyGTK libraries provides default message box symbology for the following purposes:
- Error message: gtk.MESSAGE_ERROR
- Warning message: gtk.MESSAGE_WARNING
- Information message: gtk.MESSAGE_INFO
- Question message: gtk.MESSAGE_QUESTION
- buttons:
- gtk.BUTTONS_NONE
- gtk.BUTTONS_OK
- gtk.BUTTONS_CLOSE
- gtk.BUTTONS_CANCEL
- gtk.BUTTONS_YES_NO
- gtk.BUTTONS_OK_CANCEL
- message format: string containing the message text or None
Options:
- set_markup(str)
- set_image(image)
- ...
Information message dialog:
2 | message_for_user = "Check sign of value entered" |
3 | md = gtk.MessageDialog(app_window, |
4 | gtk.DIALOG_DESTROY_WITH_PARENT, |
The message dialog box displayed will provide a "Close" button to remove the message box from display after the message is read.
Note that the variable "md" is not attached to a layout widget or any other entity in the application.
It is not required to "show()" the widget either.
It stands alone and can be placed anywhere in the code as a mechanism to present a message to the user.
 |
 |
 |
| gtk.MESSAGE_ERROR |
gtk.MESSAGE_WARNING |
gtk.MESSAGE_INFO |
Bitmap Graphics and Images:
The following code snippet shows how to embed and display an X Pixmap image (XPM) within a Python pyGTK script.
Any bitmap image (gif, jpeg, etc) can be converted to an "xpm" file using image manipulation software such as XV or Gimp and performing a "Save as ...".
XPM is a "C" text string representation of a color bit mapped image.
Graphic software conversion typically prepares the XPM in this mode to be embedded into "C" programs.
Only minor changes are required to use the XPM image in a Python/pyGTK script.
It must be changed from a "C" char to a Python string.
The original native XPM image file:
01 | static char * YoLinux_logo_xpm[] = { |
15 | " . L@M@S@T@U@V@W@X@Y@Z@`@ #.#+#@###$#%#&#*#=#-#;#>#,#'#)#!#~#{#]#^#/#(#_#:#:#<#[#}#. ", |
16 | " |#1#2#8#9#0#a#b#c#d#: e#f#g#h#i#. . j#k#l#m#n#o#p#q#r#. s#t#u#v#w#x#y#z#,.A#B#C#D#E#% ", |
17 | " F#G#H#I#N#a 1+, O#>+P#Q#R#S#T#U#V#W#X#Y#Z#`# $.$+$@$#$$$%$&$*$=$-$;$>$,$'$)$!$~${$]$^$/$ ", |
18 | " P#O ,*'*)*!*H&~*{*9 ]*,%^*/*(*_*:*<*[*}*|*1*2*3*4*5*6*7*8*9*0*a*b*c*d*e*f*g*h*i* ", |
19 | " . . . $ p*,*q*'*r*W@D$s*t*u*v*w*x*y*z*A*B*C*D*E*F*|*G*H*I*1*J*K*L*M*N*O*P*Q*R*Q*S*T*U* ", |
Convert native XPM "C" string to a Python string:
15 | " . L@M@S@T@U@V@W@X@Y@Z@`@ #.#+#@###$#%#&#*#=#-#;#>#,#'#)#!#~#{#]#^#/#(#_#:#:#<#[#}#. ", |
16 | " |#1#2#8#9#0#a#b#c#d#: e#f#g#h#i#. . j#k#l#m#n#o#p#q#r#. s#t#u#v#w#x#y#z#,.A#B#C#D#E#% ", |
17 | " F#G#H#I#N#a 1+, O#>+P#Q#R#S#T#U#V#W#X#Y#Z#`# $.$+$@$#$$$%$&$*$=$-$;$>$,$'$)$!$~${$]$^$/$ ", |
18 | " P#O ,*'*)*!*H&~*{*9 ]*,%^*/*(*_*:*<*[*}*|*1*2*3*4*5*6*7*8*9*0*a*b*c*d*e*f*g*h*i* ", |
19 | " . . . $ p*,*q*'*r*W@D$s*t*u*v*w*x*y*z*A*B*C*D*E*F*|*G*H*I*1*J*K*L*M*N*O*P*Q*R*Q*S*T*U* ", |
Code to display XPM:
04 | logo_pixbuf = gtk.gdk.pixbuf_new_from_xpm_data(YoLinux_logo_xpm) |
07 | logo.set_from_pixbuf(logo_pixbuf) |
Variable "logo" must be attached to a layout widget.
PyGTK Notes:
- Lots of other pyGTK widgets are avaialable including:
- progress bar: gtk.ProgressBar()
(Progress defined as 0 to 1. Widget also displays text messages.)
- About pop-up: gtk.AboutDialog()
- Arrow: gtk.Arrow()
- Date selection: gtk.Calendar()
- Cells: gtk.CellEditable(), gtk.CellLayout(), gtk.CellRenderer(), ...
- Clipboard: gtk.Clipboard()
- Menus: gtk.Menu(), gtk.MenuBar(), gtk.MenuItem(), gtk.MenuShell(), ...
- ...
See pyGTK reference
- Programatically one can change the display of widgets:
- Turn off: widget_name.hide()
- Turn on: widget_name.show()
This allows a display customization targeted for entries and selections defined as the user makes entries.
- Log files are helpful:
08 | logFile = open("AppLog.txt","w") |
09 | now = datetime.datetime.now() |
10 | current_time= now.strftime("%Y-%m-%d %H:%M") |
11 | logFile.write("Application run: " + current_time+"\n") |
14 | logFile.write(str_a + "\n") |
17 | logFile.write("Run complete!\n") |
- PyGTK is cross platform. Keep your Python program cross platform as well:
06 | if os.name == "posix": |
07 | command_purge = "rm -Rf /tmp" + os.sep + intermediate_dir |
09 | command_purge = "DEL /Q C:" + os.sep + intermediate_dir |
It is very helpful to use os.sep as it avoids editor syntax highlighting errors with "\t" (tab), "\a", "\b", etc with DOS style file paths.
Links:
Books:
