Latest recipes tagged "gtk"

List MySql databases in a Gtk.TreeView (Python)

2013-11-27T14:03:21-08:00

Python recipe 578774 by Anonimista (database, gtk, gui, mysqldb, user_interface).

List MySql databases in a Gtk.TreeView

Delete a Gtk.TreeView row (Python)

2013-11-27T13:59:58-08:00

Python recipe 578773 by Anonimista (gtk, gui).

Delete a Gtk.TreeView row

Basic Gtk.TreeView Example with two sortable columns (Python)

2013-11-27T13:56:38-08:00

Python recipe 578772 by Anonimista (gtk, user_interface).

Basic Gtk.TreeView Example with two sortable columns

Splash Screen GTK (Python)

2011-10-24T13:34:29-07:00

Python recipe 577919 by Nicolas Coelho (gtk, python, screen, simple, splash).

This is a simple example showing how to put a splash screen to work in a GTK app.

Generic flash-videos downloader using webkit (Python)

2010-04-04T11:56:25-07:00

Python recipe 577167 by Arnau Sanchez (download, flash, gtk, pygtk, webkit).

This recipe shows how to build a generic resource logger of webpages using PyGtkWebkit. The demo code implements a generic downloader for flash-video sites.

Run asynchronous tasks using coroutines (Python)

2010-08-06T16:16:20-07:00

Python recipe 577129 by Arnau Sanchez (coroutine, event, generator, gobject, gtk, gui, network, nonblocking, pygtk). Revision 20.

This recipe shows a simple, transparent (and hopefully pythonic) way of running asynchronous tasks when writing a event-driven application (i.e. GUI). The aim is to allow a programmer to write time-consuming functions (usually IO-bound, but not only) with sequential-looking code, instead of scattering the logic over a bunch of callbacks. We will take advantage of the coroutines introduced in Python 2.5 (see http://www.python.org/dev/peps/pep-0342).

The goal: wouldn't it be great if we could write something like this?

def myjob(entry, arg1, arg2, arg3):
    result1 = function_that_takes_eons_to_complete(arg1, arg2)    
    result2 = another_function_that_downloads_a_big_really_big_file(result1, arg3)
    entry.set_text("The result is: %d" % result2)

def on_start_button___clicked(button, entry):
    myjob(entry, 1, 2, 3)

...    
gtk.main()

Indeed, but we can't! The GUI will hang until the job is done and the user will be rightfully angry. Coroutines to the rescue: the absolute minimal change we can make to this code is transforming myjob into a coroutine and yield every time we do blocking stuff:

def myjob(entry, arg1, arg2, arg3):
    result1 = yield some_task(arg1, arg2)    
    result2 = yield some_other_task(result1, arg3)
    entry.set_text("The result is: %d" % result2)

def on_start__clicked(button, entry):
    start_job(myjob(entry, 1, 2, 3))

some_task and some_other_task are here the asynchronous implementation of the sequential tasks used in the first fragment, and start_job the wrapper around the coroutine. Note that we still have to implement non-blocking versions of the tasks, but they are usually pretty generic (wait some time, download a file, ...) and can be re-used. If you happen to have a CPU-bound function or even a IO-bound code you cannot split (urllib2 anyone?), you can always use a generic threaded task (granted, the whole point of using co-routines should be avoiding threads, but there is no alternative here).

At the end, all the plumbing we need to make it work is just 1 function: start_job (wrapper around the job to manage the flow of the coroutine). The rest of the code -two asynchronous tasks (sleep_task, threaded_task) and a demo app- are shown solely as an example.

Printing with Python and pyGTK (Python)

2009-06-25T13:54:34-07:00

Python recipe 576820 by Mark Muzenhardt (drawingarea, gtk, print, pygtk). Revision 2.

PyGTK is a very powerful GUI-Toolkit. Nearly everything is well documented, except how to print. I messed around for hours just to solve this problem so I decided to share this cool piece of code!

GtkWorker (Python)

2007-06-03T09:06:42-07:00

Python recipe 521881 by Thomas Ahle (blocking, glib, gtk, swingworker, threads).

I got inspired to this class, after having read about the java SwingWorker. The problem is that you sometimes have a tough task you want to do in a GUI program, but you don't want the UI to lock. This recipe solves the problem by running the tough code in a background thread, while still letting you do useful interaction with it, like getting the progress or the latest results.