/dev/stu

Processing with Jython and Nodebox/Shoebot libraries

stu — Wed, 10 Feb 2010 22:44:21 +0000

Using Processing from Jython is a promising idea, so I took the base from this post on backspaces.net where they explained how to use Jython and built on it a little.

This is great as Shoebot/Nodebox have great libraries for data manipulation, while processing is more focused on graphics.

The result is the attached Netbeans project which demonstrates using the nodebox web library and drawing with processing.

Slowcessing

The glue code is in slowcessing.py

Theres a special version of PApplet (PJApplet), and ‘pj_frame’ which can put this in a JFrame.

The other method is ’shoebot_imports’ adds the shoebot imports to the library path

In case anybody doesn’t want to download the whole project, heres the code:

imagestrip.py

from slowcessing import PJApplet, pj_frame, shoebot_imports
from processing.opengl import *

shoebot_imports()
import web
import thread

class ImageQueue(list):
    """
    Download images in the background and add them to a list
    """
    def __init__(self, search, size):
        list.__init__(self)
        self._search = search
        self._image_size = size
        thread.start_new_thread(self._get_images, ())

    def _image_downloaded(self, path):
        p = PJApplet()
        self.append(p.loadImage(path))

    def _get_images(self):
        for image in self._search:
            image.download(self._image_size, asynchronous=False)
            self._image_downloaded(image.path)

class WebTest (PJApplet):
  def setup(self):
    self.size(400, 400, self.P3D)
    self.images = ImageQueue(web.morguefile.search("sweets", max=1), size='small')

  def draw(self):
    self.background(0);
    y = (self.height * 0.2) - self.mouseY * (len(self.images) * 0.58)
    for image in self.images:
        self.image(image, 20, y)
        y += image.height

if __name__ == '__main__':
    pj_frame(WebTest)

slowcessing.py

from javax.swing import JFrame

from processing.core import PApplet

class PJApplet(PApplet):
  # rqd due to PApplet's using frameRate and frameRate(n) etc.
  def getField(self, name):
      return PApplet.getDeclaredField(name).get(self)

def pj_frame(pj_applet, **kwargs):
    from time import sleep

    frame = JFrame(kwargs.get('title', 'Slowcessing'))
    frame.defaultCloseOperation = kwargs.get('defaultCloseOperation', JFrame.EXIT_ON_CLOSE)
    frame.resizable = kwargs.get('resizable', False)

    panel = pj_applet()
    frame.add(panel)
    panel.init()

    while panel.defaultSize and not panel.finished:
        sleep(0.5)

    frame.pack()
    frame.visible = 1

    return frame

def shoebot_imports():
    """
    Allow import of the shoebot libraries
    """
    ##APP = 'shoebot'
    import sys
    DIR = sys.prefix + '/share/shoebot/locale'
    ##locale.setlocale(locale.LC_ALL, '')
    ##gettext.bindtextdomain(APP, DIR)
    ###gettext.bindtextdomain(APP)
    ##gettext.textdomain(APP)
    ##_ = gettext.gettext

    LIB_DIR = sys.prefix + '/share/shoebot/lib'
    sys.path.append(LIB_DIR)

Problems

There are some things I couldn’t work :

The callback to say that images have been downloaded happens before the whole file is available, for this reason there are grey parts on the images on the first run.

Nodebox web…

While I did manage to fix things to get this working in Jython and get Morguefile working, I had a lot of trouble understanding what was going on here.

Processing…

Some parts of PApplet to do with image loading seem to be static, which may also explain problems I was getting.

Download

If you want to have a go, you’ll need to:

Install Netbeans 6.8

Install Jython by installing the Netbeans python module

Add python to the path (if using Netbeans it’s copy is where Netbeans is installed).

Download my fork of shoebot-web and install it with:

jython setup.py install

In Netbeans, add all the jars in the processing\lib folder to the Jython classpath, and opengl\library\opengl.jar

Download the PythonOnProcessing (tested on Netbeans 6.8)

Using Cairo to generate SVG in Django

stu — Wed, 03 Feb 2010 00:36:27 +0000

Cairo is a 2D vector graphics api used by Firefox, Gtk and other desktop projects.

I’m going to show here that it can also be used to generate web content, using Django.

I’m going to port two examples from the Michael Urmans Cairo Tutorial for PyGTK Programmers.

To understand the cairo and it’s drawing model I’d recommend his his Cairo Tutorial for Python Programmers.

Note: In this example I’ll be generating SVGs… as I.E. (as of 2010) does not support them, you might want to generate PNG or PDF – if you need to do this with cairo, look for one of the many cairo tutorials on the web.

The example django project can be downloaded at the end of the article.

Prerequisites

You’ll need django and pycairo installed… and a little bit of Django knowledge.

In Windows you can do use easy_install to get the python dependencies:

easy_install pycairo
easy_install django

In linux you’ll need to use your favourite package manager.

Onto the code…

Hosting Framework

The pygtk example starts by building a simple hosting framework

#! /usr/bin/env python
import pygtk
pygtk.require('2.0')
import gtk, gobject, cairo

# Create a GTK+ widget on which we will draw using Cairo
class Screen(gtk.DrawingArea):

    # Draw in response to an expose-event
    __gsignals__ = { "expose-event": "override" }

    # Handle the expose-event by drawing
    def do_expose_event(self, event):

        # Create the cairo context
        cr = self.window.cairo_create()

        # Restrict Cairo to the exposed area; avoid extra work
        cr.rectangle(event.area.x, event.area.y,
                event.area.width, event.area.height)
        cr.clip()

        self.draw(cr, *self.window.get_size())

    def draw(self, cr, width, height):
        # Fill the background with gray
        cr.set_source_rgb(0.5, 0.5, 0.5)
        cr.rectangle(0, 0, width, height)
        cr.fill()

# GTK mumbo-jumbo to show the widget in a window and quit when it's closed
def run(Widget):
    window = gtk.Window()
    window.connect("delete-event", gtk.main_quit)
    widget = Widget()
    widget.show()
    window.add(widget)
    window.present()
    gtk.main()

if __name__ == "__main__":
    run(Screen)

This needs to be made ready for the web and the Gtkisms removed:

cairodraw.py

from cairo import Context, SVGSurface

# Create a GTK+ widget on which we will draw using Cairo
class CairoWidget:

    def __init__(self, Surface = None):
        if Surface == None:
            Surface = SVGSurface

        self.Surface = Surface

    def draw(self, cr, width, height):
        # Fill the background with gray
        cr.set_source_rgb(0.5, 0.5, 0.5)
        cr.rectangle(0, 0, width, height)
        cr.fill()

def draw_widget(dest, Widget, Surface = SVGSurface, width = 100, height = 100):
    """
    Convenience function to output CairoWidget to a buffer
    """
    widget = Widget(Surface)
    surface = widget.Surface(dest, width, height)
    widget.draw(Context(surface), width, height)
    surface.finish()

Changes:

Screen class is now CairoWidget as Screen made less sense in this context.
run() is replaced with draw_widget() and it has some new parameters to help it be rendered with django.
The new file is ‘cairodraw.py’, not ‘framework.py’

Initial view…

Heres the initial views.py

# Create your views here.

from django.http import HttpResponse
from cairo import SVGSurface

import cairodraw

from math import pi

class Shapes(cairodraw.CairoWidget):
    def draw(self, cr, width, height):
        cr.set_source_rgb(0.5, 0.5, 0.5)
        cr.rectangle(0, 0, width, height)
        cr.fill()

        # draw a rectangle
        cr.set_source_rgb(1.0, 1.0, 1.0)
        cr.rectangle(10, 10, width - 20, height - 20)
        cr.fill()

        # draw lines
        cr.set_source_rgb(0.0, 0.0, 0.8)
        cr.move_to(width / 3.0, height / 3.0)
        cr.rel_line_to(0, height / 6.0)
        cr.move_to(2 * width / 3.0, height / 3.0)
        cr.rel_line_to(0, height / 6.0)
        cr.stroke()

        # and a circle
        cr.set_source_rgb(1.0, 0.0, 0.0)
        radius = min(width, height)
        cr.arc(width / 2.0, height / 2.0, radius / 2.0 - 20, 0, 2 * pi)
        cr.stroke()
        cr.arc(width / 2.0, height / 2.0, radius / 3.0 - 10, pi / 3, 2 * pi / 3)
        cr.stroke()

class Transform(cairodraw.CairoWidget):
    def draw(self, cr, width, height):
        cr.set_source_rgb(0.5, 0.5, 0.5)
        cr.rectangle(0, 0, width, height)
        cr.fill()

        # draw a rectangle
        cr.set_source_rgb(1.0, 1.0, 1.0)
        cr.rectangle(10, 10, width - 20, height - 20)
        cr.fill()

        # set up a transform so that (0,0) to (1,1)
        # maps to (20, 20) to (width - 40, height - 40)
        cr.translate(20, 20)
        cr.scale((width - 40) / 1.0, (height - 40) / 1.0)

        # draw lines
        cr.set_line_width(0.01)
        cr.set_source_rgb(0.0, 0.0, 0.8)
        cr.move_to(1 / 3.0, 1 / 3.0)
        cr.rel_line_to(0, 1 / 6.0)
        cr.move_to(2 / 3.0, 1 / 3.0)
        cr.rel_line_to(0, 1 / 6.0)
        cr.stroke()

        # and a circle
        cr.set_source_rgb(1.0, 0.0, 0.0)
        radius = 1
        cr.arc(0.5, 0.5, 0.5, 0, 2 * pi)
        cr.stroke()
        cr.arc(0.5, 0.5, 0.33, pi / 3, 2 * pi / 3)
        cr.stroke()

def shapes(request):
    response = HttpResponse(mimetype='image/svg+xml')
    cairodraw.draw_widget(response, Shapes)
    return response

def transform(request):
    response = HttpResponse(mimetype='image/svg+xml')
    cairodraw.draw_widget(response, Transform)
    return response

The main difference is that Shape and Transform are the same, except they extend cairodraw.CairoWidget.

urls.py

This is pretty straightforward.

(r'^shapes/shapes/$', 'shapes.views.shapes'),

(r'^shapes/transform/$', 'shapes.views.transform'),

Taking stock…

This is a good stage to try things out, heres the django project so far: django_cairo_1a.

Enter the svgsite directory and run

python manage.py runserver

If all is well it should output something like this:

Validating models...
0 errors found

Django version 1.1.1, using settings 'svgsite.settings'
Development server is running at http://127.0.0.1:8000/
Quit the server with CTRL-BREAK.

If you visit the two URLs in most browsers except I.E. the output will look like this:

http://127.0.0.1:8000/shapes/transform/

http://127.0.0.1:8000/shapes/shapes/

Inline SVG and templates…

The previous examples output straight SVG, however it would be much better to be able to incorperate SVG into templates and use it with HTML.

Luckily modern browsers support this, and with a couple of changes we can make templates that will output mixed documents like this.

Example template:


 
 SVG embedded inline in XHTML
 
 
 Transform
 {{transform|safe}}
 Full screen svg
 Shapes
 {{shapes|safe}}
 Full screen svg

The variables ’shapes’ and ‘transform’ will be the svg, the key is the ‘|safe’, which means the XML won’t be processed by django.

Changes to views to support inline

To use templates the SVG data is needed as a string to pass to the template.

Heres an index view demonstrating this:

def index(request):
    buff = StringIO()
    cairodraw.draw_widget(buff, Shapes)
    shapes = buff.getvalue()[38:]

    buff = StringIO()
    cairodraw.draw_widget(buff, Transform)
    transform = buff.getvalue()[38:]

    return render_to_response(
    'shapes_index.html',
    {"transform": transform, "shapes": shapes},
    mimetype='application/xhtml+xml')

The main differences are that -
cairodraw.draw_widget() is called with a temporary buffer, we use templates.

Evil hack alert:

OK, I did something naughty… notice the [38:] ? Unfortunately django doesn’t like having in the middle of the output. I couldn’t find a way to turn this off so we chop it off the beginning of the string.

Apart from the evil hack this works well and you get output like this:

http://127.0.0.1:8000/shapes/

Final Version

Cool, every thing seems to be working !

The final version to try django_cairo_1b.

Next time….

I’ll be looking at using a Cairo based library, PyCha library with django to output smooth looking charts in SVG.

Scripts to help workflow now on google code.

stu — Mon, 25 Jan 2010 14:33:21 +0000

I’ve uploaded my scripts to help workflow to google code, naming the project batch flow.

Heres a summary of some of the things you can do.

Clipboard integration

Go to a directory in the clipboard.

If you have the address bar enabled in explorer:

Copy the location, go to the prompt and enter ‘pcd’ to go to that folder

Go to the location of a setting in netbeans or eclipse:

Copy the location , go to the prompt and enter ‘pcd’ to go to the folder (or folder containing the file).

Get the current directory without dragging:

Enter ‘ccd’

Directory bookmarks

dirsave and dirload let you save named bookmarks.

Using hotkeys

If you use the alternate shell 4nt (or the free TCC/LE) you can use the supplied configuration and aliases to access the bookmark functionality from the keyboard:

In the 4nt or tcc/le prompt enter “option”, under the “TCStart/TCExit” path, change the location to the location where batch-flow is installed + “\conf”, for instance on my computer batch-flow is installed to c:\usr\batch-flow, so I set it to

c:\usr\batch-flow\conf

Now in new TCC/LE prompts F5-F10 are reserved for directories: Ctrl+Fkey to save, and Alt+Fkey to load. Alt-F12 lists these shortcuts.

Note: Alt-F12 only lists shortcuts on FKeys, to list these and other shortcuts enter dirload /l

batch-flow comes with other handy hotkeys, use ‘alias’ in TCC/LE to see what they are.

Path manipulation

addpath

It’s annoying after installing a program to have to add it to the path, so there is an ‘addpath’ command to do this.

regpath

This is a more general utility for viewing the registry path, you can list it, validate it, check for the location of files within it.

Also useful is ‘regpath /L’ which sets the local prompts path to the one in the registry.

Further help

Most of the commands have help builtin, which you can access by using the /? option.

Access files in a Linux virtual machine from Windows

stu — Thu, 21 Jan 2010 04:46:17 +0000

I recently found a neat way of accessing files in a linux VMWare image. This is really useful, as theres never really a good time to break your VMWare image, this is also handy if you don’t want to run the whole machine, but just access the files inside.

There is one caveat:

It only works if the filesystem is ext2 (ext3 works, and ext4 probably works).

Install VMWare DiskMount Utility

Accept the EULA, download and install the VMWare DiskMount utility.

For convenience add the utilities folder to the path:

C:\Program Files\VMware\VMware DiskMount Utility

Do this through the Windows Gui, or even use my addpath utility.

At this point you can mount Windows VMWare images.

The usage is: vmware-mount drive-letter vmdk-image.

Heres how I mount my Ubuntu image to the j: drive

[C:\vmware\Ubuntu]vmware-mount j: ubuntu.vmdk

[C:\vmware\Ubuntu]

No output here indicates success.

At this point everything seems fine, but a crucial piece of the puzzle is still missing; try and view the files and you still can’t:

The next step is to make Windows understand the ext2 filesystem, using a special driver.

Install ext2ifs

Grab ext2ifs from www.fs-driver.org and install.

If the following steps don’t work then you may need to reboot.

Thats it!

You should be now able to access files inside your VMWare image (assuming it’s ext2 and not reiserfs), remount the image and have a go:

In my case I did:

[C:\vmware\Ubuntu]vmware-mount j: ubuntu.vmdk

[C:\vmware\Ubuntu] dir j:

Heres the output – hooray, I can copy my work out of the image !

This is very useful, especially if you do dist-upgrade in ubuntu and can’t access the network.

Bonus tip:

Newer versions of VMWare player let you install VMWare tools from inside the GUI, this is another way to fix the kind of catestrophic problems you can cause yourself by accidentally upgrading the kernel in an image.

Some useful scripts for windows.

stu — Sun, 06 Sep 2009 01:32:43 +0000

Stoyan of PHPIED.com has found the joy using javascript for scripting in the OS…

I’ve put up a few scripts I find useful in windows (download at the end of the article):

addpath.js – Add a path to the registry path.
dt.cmd – Change to desktop folder.
e.cmd – Open explorer in current or specified folder.
regpath.js – Output the path stored in the registry.
updateenvironment.js – Updates running apps with any changed settings in the registry.

And a couple that use python and pywin32:

ccwd.py – Copy the current working directory to the clipboard
cpath.py – Copy the current path to the clipboard

All of have acompanying batch files to run them, I generally have everything in a folder c:\usr\cmd, but they should work from anywhere in the path.

Download cmd.zip

Using Java2Python to port a JavaCairo tutorial

stu — Fri, 21 Aug 2009 00:22:15 +0000

I recently came across Java2Python. As I’m interested in Cairo I thought it would be interesting to try porting one of the example tutorials from ZetCode.

I’ll run through the steps involved in porting then try and reach some conclusions at the end .

1. Get setup

This is easiest in Linux, I’m running Ubuntu (in vmware), and installed

antlr 2.x
python2.5.x
sun java6
pygtk
java-gnome

You can install them like this:

# sudo apt-get install antlr python2.5 sun-java6-bin libjava-gnome-java

Then install Python2Java with easy_install

# sudo easy_install-2.5 java2python

To test if it’s working run j2py -i. It should complain there is no file:

# j2py -i
Usage: j2py [options]

j2py: error: -i option requires an argument

If you get any other errors your missing some packages.

2. Get the Java Code from the Simple Example.

Save the ’simple.java’ example as ‘GSimple.java’

If java-gnome is running ok, compiling and running it you should see a window:

# javac GSimple.java
# java GSimple

Now we’ll run through the code, it’s important to understand what it does before we port it…

package com.zetcode;

import org.gnome.gdk.Event;
import org.gnome.gtk.Gtk;
import org.gnome.gtk.Widget;
import org.gnome.gtk.Window;
import org.gnome.gtk.WindowPosition;

/**
 * ZetCode Java Gnome tutorial
 *
 * This program is a simple Java Gnome
 * application.
 *
 * @author jan bodnar
 * website zetcode.com
 * last modified March 2009
 */

public class GSimple extends Window  {

    public GSimple() {

        setTitle("Simple");

        connect(new Window.DeleteEvent() {
            public boolean onDeleteEvent(Widget source, Event event) {
                Gtk.mainQuit();
                return false;
            }
        });

        setDefaultSize(250, 150);
        setPosition(WindowPosition.CENTER);
        show();
    }

    public static void main(String[] args) {
        Gtk.init(args);
        new GSimple();
        Gtk.main();
    }
}

Code Runthrough

Import java-gnome bindings
Create a class that extends org.gnome.gtk.Window
Set the size of the window
Connect the ‘delete’ event to an InnerClass. When a delete event arrives, ‘onDeleteEvent’ is called which in turn calls Gtk.mainQuit().

Gtk.mainQuit() will quit program and cleanup gtk.
set window size
show the window

3. Use j2py to create the initial python code.

The first stage is to generate the python.

# j2py -i GSimple.java > gsimple.py

Output [gsimple.py]:

#!/usr/bin/env python
# -*- coding: utf-8 -*-

class GSimple(Window):
    """ generated source for GSimple

    """

    def __init__(self):
        setTitle("Simple")

        def onDeleteEvent(self, source, event):
            Gtk.mainQuit()
            return False

        connect(Window.DeleteEvent())
        setDefaultSize(250, 150)
        setPosition(WindowPosition.CENTER)
        show()

    @classmethod
    def main(cls, args):
        Gtk.init(args)
        GSimple()
        Gtk.cls.main()

if __name__ == '__main__':
    import sys
    GSimple.main(sys.argv)

5. Analyze

Unfortunately j2py is not magic, it’s time to have a look at the code..

Things are missing and others look wrong, heres an initial list of problems:

no imports
’self’ not specified in class constructor
CamelCase used – this is suspicious, it’s unlikely the cairo bindings work like this
@classmethod is probably not nessacary here
Gtk.cls.main() – This looks particularly suspicious

Indeed – If you try and run it, the missing imports become apparent:

bagside@bagvapp:~/jythongnome$ python gsimple.py
Traceback (most recent call last):
  File "gsimple.py", line 5, in
    class GSimple(Window):
NameError: name 'Window' is not defined

6. Fixing the initial Problems

Some problems are easy to fix, others involve learning the differences between the java and python APIs.

Starting with the easiest…

’self’ not specified in class constructor

This looks easiest so we’ll tackle it first, heres the new constructor:

        self.setTitle("Simple")

        def onDeleteEvent(self, source, event):
            Gtk.mainQuit()
            return False

        self.connect(Window.DeleteEvent())
        self.setDefaultSize(250, 150)
        self.setPosition(WindowPosition.CENTER)
        self.show()

Doing this does emphasize how wrong the CamelCase looks, also the onDeleteEvent being a function in the constructor doesn’t look right, we could probably move it up a level.

No imports

In the java code there is

import org.gnome.gdk.Event;
import org.gnome.gtk.Gtk;
import org.gnome.gtk.Widget;
import org.gnome.gtk.Window;
import org.gnome.gtk.WindowPosition;

Googling for Window module and gtk you’ll end up at the pygtk site.
The documentation shows the Window class is in the gtk module. Further research on the site or in the python prompt shows most of the other classes are in the same module too.

# To do research in the python prompt, simply start python and try
import gtk
dir(gtk)
help(gtk)
help(gtk.Window)

It’s worth having a glance at the python help to see if the bindings look the same, start python and try:

import gtk
help(gtk.Window)

…[output snipped]…

 |  set_skip_taskbar_hint(...)
 |
 |  set_startup_id(...)
 |
 |  set_title(...)
 |
 |  set_transient_for(...)
 |
 |  set_type_hint(...)
 |
 |  set_urgency_hint(...)

It’s fairly obvious that CamelCase is not used here, as suspected (remember to change this later…)

As “Window” is quite generic, I’ll move everything into the ‘gtk’ namespace, add

import gtk

To the top of the code, and change all instances of the gtk classes to ‘gtk.ClassName’, e.g. gtk.Window:

#!/usr/bin/env python
# -*- coding: utf-8 -*-

import gtk

class GSimple(gtk.Window):
    """ generated source for GSimple

    """

    def __init__(self):
        self.setTitle("Simple")

        def onDeleteEvent(self, source, event):
            Gtk.mainQuit()
            return False

        self.connect(gtk.Window.DeleteEvent())
        self.setDefaultSize(250, 150)
        self.setPosition(WindowPosition.CENTER)
        self.show()

    @classmethod
    def main(cls, args):
        Gtk.init(args)
        GSimple()
        Gtk.cls.main()

if __name__ == '__main__':
    import sys
    GSimple.main(sys.argv)

And try running it:

Traceback (most recent call last):
  File "gsimple.py", line 31, in
    GSimple.main(sys.argv)
  File "gsimple.py", line 25, in main
    Gtk.init(args)
NameError: global name 'Gtk' is not defined

It’s complaining about the ‘main’ class method on GSimple, we can just remove it and move everything into the main method of the module:

if __name__ == '__main__':
    import sys
    Gtk.init(args)
    GSimple()
    Gtk.cls.main()

This still won’t work for sure as ‘Gtk’ is not in the namespace.

The first step is to work out whats going on, consult the java code then the relevant documentation.

[GSimple.java]
public static void main(String[] args) {
Gtk.init(args);
new GSimple();
Gtk.main();
}

OK, the code is the same, what does the java gnome documentation say about Gtk.init ?

init

public static void init(String[] args)

Initialize the GTK libraries. This must be called before any other org.gnome.* classes are used.

Parameters:
args – The command line arguments array. This is passed to the underlying library to allowing user (or window manager) to alter GTK’s behaviour.
Since:
4.0.0

Looking in pygtk there isn’t ‘init’ (it would be confusing having this and __init__ anyway).

Looking in the pygtk documentation there is no ‘init’ method (which makes sense as it could be confused with ‘__init__’. There is however gtk.main:

gtk.main

def gtk.main()

The gtk.main() function runs the main loop until the gtk.main_quit() function is called. You can nest calls to gtk.main(). In that case the call to the gtk.main_quit() function will make the innermost invocation of the main loop return.

Here I confess some prior knowledge, I already had a vague idea the main loop might be involved as I’d worked with gtk before.

So we’ll try gtk.main, and commenting out the line calling main on the class as I’m not entirely sure what it does:

if __name__ == '__main__':
    import sys
    gtk.main()  # Note gtk.main takes no parameters
    GSimple()
    # Gtk.cls.main()

Try running

And… nothing happens – you have to quit with CTRL-C!

It looks like it’s not even getting to the constructor (as there should be errors here, maybe gtk.main() needs to run *after* the GSimple() constructor..

Sure enough:

# python gsimple.py
Traceback (most recent call last):
  File "gsimple.py", line 30, in
    GSimple()
  File "gsimple.py", line 13, in __init__
    self.setTitle("Simple")
AttributeError: 'GSimple' object has no attribute 'setTitle'

Fixing the CamelCase

The pygtk documentation seemed all be underscored_lowercase, it’s probably safe to speculatively change everything to this then fix any errors:

#!/usr/bin/env python
# -*- coding: utf-8 -*-

import gtk

class GSimple(gtk.Window):
    """ generated source for GSimple

    """

    def __init__(self):
        self.set_title("Simple")

        def on_delete_event(self, source, event):
            gtk.main_quit()
            return False

        self.connect(gtk.Window.DeleteEvent())
        self.set_default_size(250, 150)
        self.set_position(WindowPosition.CENTER)
        self.show()

if __name__ == '__main__':
    import sys
    GSimple()
    gtk.main()  # Note gtk.main takes no parameters
    #    Gtk.cls.main()

Output:

 python gsimple.py
gsimple.py:12: GtkWarning: gtk_window_set_title: assertion `GTK_IS_WINDOW (window)' failed
  self.set_title("Simple")
Traceback (most recent call last):
  File "gsimple.py", line 28, in
    GSimple()
  File "gsimple.py", line 18, in __init__
    self.connect(gtk.Window.DeleteEvent())
AttributeError: type object 'gtk.Window' has no attribute 'DeleteEvent'

Thats progress! It means the self.set_title call probably works, and there is a self.connect call too.

There is no DeleteEvent in the pygtk documentation… which is not suprising as it looks more java than python.
Better to step back and have a look at self.connect, in the end I googled

gtk connect delete event

And got to a getting started with pygtk page:

36  # When the window is given the "delete_event" signal (this is given
37  # by the window manager, usually by the "close" option, or on the
38  # titlebar), we ask it to call the delete_event () function
39  # as defined above. The data passed to the callback
40  # function is NULL and is ignored in the callback function.
41  self.window.connect("delete_event", self.delete_event)

Note here they have ‘window’ as their delegating, our generated code extends this class.

The signature is slightly different, also instead of ‘on_delete_event’ the function is just called ‘delete_event’, this seems more pythonic so we’ll do the same.

This would also be a good time to move the function into the main class, out of the constructor:

class GSimple(gtk.Window):
    """ generated source for GSimple

    """

    def __init__(self):
        self.set_title("Simple")

        self.connect('delete_event', delete_event)
        self.set_default_size(250, 150)
        self.set_position(WindowPosition.CENTER)
        self.show()

    def delete_event(self, source, event):
	gtk.main_quit()
	return False

And the output:

gsimple.py:12: GtkWarning: gtk_window_set_title: assertion `GTK_IS_WINDOW (window)' failed
  self.set_title("Simple")
Traceback (most recent call last):
  File "gsimple.py", line 29, in
    GSimple()
  File "gsimple.py", line 14, in __init__
    self.connect('delete_event', delete_event)
NameError: global name 'delete_event' is not defined

The first line assertion `GTK_IS_WINDOW (window)’ failed is the important one here; it makes sense, the constructor of the gtk.Window has not been called yet.

Add

gtk.Window.__init__(self)

to the top of the constructor and run.

Traceback (most recent call last):
File "gsimple.py", line 30, in 
GSimple()
File "gsimple.py", line 17, in __init__
self.set_position(WindowPosition.CENTER)
NameError: global name 'WindowPosition' is not defined

And again…

Repeating the same process for WindowPosition and set_position, you’ll find that the set_position line should look like this:

self.set_position(gtk.WIN_POS_CENTER)

And the output…

Huzzah! Success!

Final Source code

#!/usr/bin/env python
# -*- coding: utf-8 -*-

import gtk

class GSimple(gtk.Window):

    def __init__(self):
	gtk.Window.__init__(self)
        self.set_title("Simple")

        self.connect('delete_event', self.delete_event)
        self.set_default_size(250, 150)
        self.set_position(gtk.WIN_POS_CENTER)
        self.show()

    def delete_event(self, source, event):
	gtk.main_quit()
	return False

if __name__ == '__main__':
    import sys
    GSimple()
    gtk.main()

Conclusions

Although Cairo APIs are available for Java and Python they are of course quite different. One implication of this is that if you wanted to use Cairo from a Jython java applet (via native methods) it couldn’t have code 100% the same as a normal python app.
java2python is good, but you still need to put the work in.
Working in this way is also a good way to find differences within implementations of an API.

The Bloggage and slacking

stu — Fri, 07 Aug 2009 01:28:25 +0000

Just been checking out what Mr Palmer has been up to… quite a lot it seems… if I could get further than 2 chapters in 6 months with Getting Things Done maybe I could stop procrastination and start GTD too

And I’ve been checking out some online comics…

My 6 monthlyish check on SayUncle comics blog always makes me want to do some drawing.

Also Quite enjoying the Beartato in space storyline in nedroid.

Toast

stu — Fri, 09 Jan 2009 19:29:36 +0000

Lyrics

Router upgrade nixed xbmc

stu — Sun, 14 Dec 2008 23:26:50 +0000

It turns out my lack of networked media consumption utopia via xbmc was all down to upgrading my router… the xbox was fixed on 10.0.0.x while everything else moved over to 192.168.1.x …so I learned that SMB doesn’t like that at all.

Oh well, one task down… many more todo… maybe I can actually setup my kurobox in the next few days and then some really nice things might be possible.

Flex for developers – Bootstrapping

stu — Sat, 29 Nov 2008 23:31:10 +0000

A lot of information on the web is aimed at people who use flashdevelop and other guis to build flex apps, this article is aimed at developers. I’ll give you the information to get started with flex development quickly, using the free sdk and building with ant from the commandline.

A passing knowledge of ant wouldn’t hurt either.

This tutorial uses the file blankapp.zip to help bootstrap you into the world of flex / actionscript development.

Prerequisites

Flex SDK

You will need the flex sdk available from the flex developer center

Apache ant

You will need apache ant, make sure that the bin folder is in your path.

Copy flexTasks.jar from the flex ant lib into your own ant lib folder.

Setup

Extract the blankapp.zip to a folder

Open build.xml and change the line to point to the flex sdk.

Build

You can build it by typing

ant build

You should see some output like this

Buildfile: build.xml

clean:
   [delete] Deleting directory C:\Documents and Settings\Stuart\Desktop\projects\flex\blankapp\build

init:
    [mkdir] Created dir: C:\Documents and Settings\Stuart\Desktop\projects\flex\blankapp\build

build:
    [mxmlc] Loading configuration file C:\usr\flex\sdk3\frameworks\flex-config.xml
    [mxmlc] Initial setup: 172ms
    [mxmlc] Loaded 8 SWCs: 391ms
    [mxmlc] C:\Documents and Settings\Stuart\Desktop\projects\flex\blankapp\src\blankapp_333027.cache (The system cannot
 find the file specified)
    [mxmlc] Files: 328 Time: 1562ms
    [mxmlc] Linking... 16ms
    [mxmlc] Optimizing... 125ms
    [mxmlc] SWF Encoding... 47ms
    [mxmlc] C:\Documents and Settings\Stuart\Desktop\projects\flex\blankapp\build\blankapp.swf (159158 bytes)
    [mxmlc] Persisting 33 compilation units... 15ms
    [mxmlc] Total time: 2328ms
    [mxmlc] Peak memory usage: 59 MB (Heap: 33, Non-Heap: 26)

BUILD SUCCESSFUL
Total time: 2 seconds

A new file, blankapp.swf should now be in the build folder

Type

ant deploy

To copy it to the deploy directory (later you can customise this later).

If you open the blankapp.swf in the browser you should see something like this

It’s fairly bare, but demonstrates some basic techniques and a couple of widgets.

Mxml and Actionscript, how they link together

There are two important parts, the blankapp.mxml and org/blankapp/BlankApp.as.

The mxml file defines the layout while the actionscript contains code to be executed. In this case there is one mxml file, BlankApp.mxml which links to a single actionscript class, BlankApp (in the file src/org/blankapp/BlankApp.as).

The directory structure org/blankapp, defines the package, in much the same way as java packages.

The graphic below shows how the class is linked to the mxml and where the instance of the class is:

The app is very basic, but should provide a jumping off point.

Adding libraries

If you need to add any libraries, just place the swc files in the lib folder and they will be included, the build.xml can be changed if this isn’t satisfactory.

Afterword

I only wanted to get started with papervision, but found it a bit of hassle to get started, hopefully this post will help people get started quickly.

Acknowledgements

The ant build file is by no means my own, owes inspiration to previous ant files I’ve known, including the pyAMF one and information available on the web.

This blog entry: http://talsma.tv/post.cfm/ant-mxmlc-and-swc-files for the info on how to include swc files.