The reading was followed by an interview on stage with John Sutherland, with questions from the floor after that. There was also the obligatory signing once the formal part was over.

Many topics were discussed but a few topics recurred and stuck with me. One was the political nature of the new book compared with the previous books to which he stated that he wouldn't be offended if someone considered Neuromancer (which was set some time in the future) anti-Regan, and in the same way, Spook Country (which I haven't yet read, but is set in the very near future) could be called by someone anti-Bush without causing offence to the author. I liked the way he phrased the sentiment, but his thinking is that all his books have some political angle, and the time of the setting makes little difference.

Reference was also repeatedly made to Node Magazine and the interactiveness of modern fiction. He considers that we are already in a world of interactive fiction and that he planted many pages on the internet for people to find when reading his books and performing web searches on the characters and other things mentioned in the narrative. This was very much the case with Spook Country but was also the case with Pattern Recognition but to a much smaller degree, and with less community involvement.

He mentioned he'd been working that day on the Wikipedia entry for the Bigend character in the book, which raised a chuckle from Prof Sutherland and he offered a more French-like pronounciation to replace Mr Gibson's overtly Engligh-based take on the fictional name.

See also:

• the official William Gibson Books site,
• the (unofficial) Spook Country UK Blog, which has a brief write-up of the evening,
• the (unofficial) William Gibson Board whose members were out in force and in style,
• Flickr's collection of photos of the evening.

You can see it live too at http://pdr.cx/dstats/ but note that it will come up with a broken image the first time you load it (I have fixed that now, but it's not in a version ready for the live site) so just click on the broken image to select the server, statistic and time period.

I don't have exactly oodles of outgoing bandwidth, but locally it is very quick to load. It updates every minute, and the stats are acurate to the minute with no real lag involved. It can actually be quite difficult to see the graph moving but believe me, it actually is - no more refresh meta tags for updating stats pages!

A week on from last week's release and it has really moved on in leaps and bounds. The following is a list of the recent improvements:

• The variety of decorators has been replaced with one, egg.eggify, which intelligently decides how to wrap the method
• Toolbar support has been added
• Statusbar support has been added

Anyway, on with an example:

#!/usr/bin/python

import egg, gtk

class EGGFileView(egg.App):
  """A file viewer example application for EGG."""

  # Set up filename as a context since some functions require an open file.
  # When set to None, 0 or False, it will disable widgets needing this context.
  filename = egg.context(None)

  # The egg.eggify() decorator wraps all our callback methods in order to
  # provide necessary widgets automatically
  @egg.eggify()
  def open(self, filename):
    # Note that method docstrings are in the imperative
    """Open a file (read-only)"""
    # Pretty rough code: just read the *whole* file into a gtk TextBuffer
    file = open(filename)
    mytext = "".join(file.readlines())
    file.close()
    self.textbuffer.set_text(mytext)
    self.textbuffer.apply_tag(self.mytexttag, self.textbuffer.get_start_iter(), self.textbuffer.get_end_iter())
    # Tell the user what we've done
    self.feedback(filename + " opened.")
    # Provide the filename context, enabling appropriate widgets
    self.filename = filename

  # We provide the filename as our context to the eggify decorator function,
  # since we can't perform a close() without a non-None filename
  @egg.eggify(context=filename)
  def close(self):
    """Close the current file"""
    self.textbuffer.set_text("")
    # Tell the user what we've done
    self.feedback(self.filename + " closed.")
    # Remove the filename context, disabling functions requiring an open file
    self.filename = None

  def __init__(self):
    egg.App.__init__(self,
                     menu=[["_File", self.open, self.close, None, self.quit],
                           ["_Help", self.about]],
                     tools=[self.open, self.close, self.quit],
                     version="1.0",
                     authors=["Pete Ryland "],
                     copyright="Copyright (c) 2006 Pete Ryland",
                     license=egg.GPL
                    )
    # The below is standard gtk-type code.  This gives you an idea of what
    # we're saving ourselves from by using EGG.  Of course, EGG will eventually
    # provide TextView setup stuff somehow.  Please let me know if you have any
    # good ideas about this or other unprovided stuff like layouts.
    self.mytexttag = gtk.TextTag()
    self.mytexttag.props.family = "Monospace"
    self.textbuffer = gtk.TextBuffer()
    self.textbuffer.get_tag_table().add(self.mytexttag)
    textview = gtk.TextView(self.textbuffer)
    scrolltextview = gtk.ScrolledWindow()
    scrolltextview.add(textview)
    scrolltextview.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
    self.set_contents(scrolltextview)

if __name__ == "__main__":
  a=EGGFileView()
  a()

Here's a few things to note:

• The menu and toolbar are set up in the egg.App.__init__ call with lists of methods. The About information is set there too.
• The methods are called open and close which happen to resemble the names of gtk stock items, and so those items along with their standard shortcuts and pretty icons are used.
• Because open takes a single argument called filename, eggify automatically knows to launch a file selection dialog first, and send it the filename. The method name and its argument are used to determine whether the file selection with be an "open" or "save" one, work on directories, and/or allow multiple selections.
• The inherited feedback method sets the statusbar message, but it's still very early days for this part of the API.

Well, please do try it out, the tarball is linked at the top. And don't hesitate to send me an email with any feedback you may have (whether positive or negative!).

Well, after a brief amount of hacking about, egg now supports menus, buttons, the about dialog and the start of file selection support. On to the first example:

#!/usr/bin/python

import egg

class ButtonExample(egg.App):
  """A button example for EGG."""

  @egg.button()
  def clickMe(self):
    """Prints a message to standard ouput"""
    print "You pressed my button!"

  def __init__(self):
    egg.App.__init__(self, version="1.0")
    mybutton = self.clickMe.getbutton(self)
    self.set_contents(mybutton)

if __name__ == "__main__":
  a=ButtonExample()
  a()

• Default menus are provided, with File->Quit and Help->About
• A default About dialog is provided automatically
• A button factory (clickMe.getbutton) is created automatically by the egg.button() decorator, and connects the button to the callback
• The callback doesn't need to receive the widget that caused it as an argument
• The docstring for the button is used for the tooltip and the callback method's name is used for the button's label string
• The docstring for the App is used as the AboutDialog comment, and the class's name is used for the application name by default

#!/usr/bin/python

import egg

class MenuExample(egg.App):
  """A simple example of how to do menus in EGG!"""

  @egg.menuitem(accel=ord('n'))
  def newWindow(self):
    """Creates a new window"""
    print "My callback was called!"

  @egg.stockmenuitem(stock_id=egg.STOCK_OPEN)
  @egg.fileselector()
  def open(self, filename):
    print "Opening:", filename

  def __init__(self):
    egg.App.__init__(self, version="1.0",
                     menu=[["_File", self.newWindow, self.open, None, self.quit],
                           ["_Help", self.about]]
                    )

if __name__ == "__main__":
  a=MenuExample()
  a()

So, I've decided to take on the challange of writing a more pythonic higher-level API for gtk, building on pygtk and pygnome (and their hard work) using more pythonesque features, including some newer ones such as decorators. The intention is to create an API that is primarily easy to use, so will do things like allow gui objects to be provided automatically by simply decorating a method with the appropriate wrapper, and provide sensible, working defaults to enable users to get something working quickly, a bit like scaffolding in RoR.

First things first then, the name. After not too much thought, I came up with EGG, Easy Gnome Gubbins. So there we have it. Expect to see some more about this in the very near future!