Planet Imendio

GTK+ css engine - now with border-image!

2008-11-18T17:24:35+00:00

Rob Straudinger recently added border-image support to his css markup-powered GTK+ Engine. This allows you to create really fancy buttons and other cool stuff in a rather simple way. Check out John Resig’s post about border-image implementation in Firefox for some cool demos of what you can do with this.

Back at GUADEC in Birmingham, when Garrett proposed using css-markup for widget themes, I thought it sounded a bit too cracky to be doable. Rob’s recent work, however, looks really sweet and since every designer and his mother out there knows css, this is a great way to lower the barriers of theme creation.

Rob is in great need of designers to test these things out in the wild though, so if you’re a designer with css knowledge who always wanted to create widget themes, don’t hesitate to check it out from svn and give it a shot.

svn checkout http://svn.gnome.org/svn/gtk-css-engine/trunk gtk-css-engine

You can find out more about the upcoming 0.3 release in the GNOME Theming blog.

Slowly but surely

2008-11-12T13:46:12+00:00

As I have mentioned before, I'm working on a native theme for the Mac OS X port of GTK+ from time to time. I recently spent some time on the theme engine to make Devhelp look a bit better on Mac, with focus on some widgets that are very visible in Devhelp: notebooks, scrolled windows (and other widgets) with shadows, and scrollbars.

It's clearly very difficult to get things to look exactly right and in some cases I think you will have to use platform specific code to arrange widgets differently to get a really good look. BUT, nevertheless it's getting better:

GNOME Art meeting tomorrow!

2008-11-09T22:29:52+00:00

Just a quick reminder that we’re going to hold our monthly GNOME Art Meeting tomorrow (Nov 10th) at 19:00 UTC in #gnome-art on irc.gnome.org

On the agenda so far is:

secondary GNOME Logo
Plans for GNOME 2.26
continued discussion about GNOME 3.0 plans

See the wiki page for more info.
Hope to see you there!

You’re a what?

2008-10-29T00:03:36+00:00

Nine out of ten times I tell people I’m a Icon Designer, they tend look at me like I’ve just told them I’m a Shrubbery Maker. Sometimes I just lie instead.

Blend astehetics

2008-10-27T17:43:23+00:00

Myself, Carlos and Hagen attended FSCons (Free Society Conference and Nordic Summit) this weekend and on Sunday I did a talk on the Tango Project.

As we all know by now, “The Tango Project is nothing less than an attempt to impose Gnome’s bland aesthetics on all other desktop environments.” [1], and the KDE artists decided to define their own look and feel as part of their visual refresh for KDE4.
This, at the time made me a bit worried, as having the other big desktop not buying into the idea of a cross-desktop look and feel makes things slightly harder for your friend the application developer to the point where he almost decides not to do any visual integration to with your free desktop at all.

Looking at the recent work on the smaller sizes on Oxygen and the work on bigger sizes in Tango, it turns out that perhaps my worries was for no reason though. [2]

So, I showed this to my girlfried. It turns out she couldn’t spot the difference between the styles. But ok, fair enough, she’s not used to looking and these, and might not spot the important differences. But what about the audience at my talk, who are used to staring at these graphical elements all day long?
Sorry guys, it turns out they guessed wrong in about 50% of the cases. Good news for ISV/ISD’s though I guess!

1. From the old “throw this stuff out now please”-thread on freedesktop.org
2. To be honest, sneaky as we are, we have been working on lowering the gaps between the styles. Sorry for that.

A little refreshment for Catfish

2008-10-24T21:27:39+00:00

Even though development of the next Catfish line is not exactly fast forwarding, it's time for a maintainance release. Translators have added new languages, which is totally great, and I fixed a handful of small things. Plus, notably, the package now includes the new logo which has already been on the website for some time.

So download catfish v0.3.2 already!

Devhelp assistant

2008-10-23T09:33:28+00:00

I've added a pretty useful feature to Devhelp in trunk, which in combination with some lisp code makes emacs extra helpful when coding. I'm already starting to get addicted to always having the right documentation available :)

Update: added screenshot. Click the image to see a video of it in action.

It should work well with all gtk-doc generated reference docs (like GTK+ & friends).

20.10.2008 Bugzilla Utility buglist.py

2008-10-20T12:10:48+00:00

Managing bug lists has become an ubiquitous task when dealing with the GNOME or Nokia bugzillas. At some point I became fed up with the involved cut and pasting, searching and sorting, so I cooked up a small command line utility to construct bug list URLs and format bug list summaries in text form. Here’s it in action:

    echo "junktext 556578 moretext 516885 " | buglist.py gnome
    http://bugzilla.gnome.org/buglist.cgi?bug_id=516885,556578
     516885 - Add RGBA support
     556578 - GIMP windows stay on top of other windows

It knows a good number of bugzillas, such as the ones from Gnome, FreeDesktop, Maemo, Nokia, OpenedHand, GCC, LibC and Mozilla. More bugzilla URLs can easily be added, and it handles HTTPS authentication that some of the corporate bugzilla installations require.

The script is available here: buglist.py (v0.4)

Have fun and send in patches. ;)

A minor version bump

2008-10-18T23:08:07+00:00

The version bump is long overdue. The last development cycle was
interesting in a way, there was refactoring, experiments that did not
turn out as good as intended, and a number of annoying bugs turned up,
but the #midori crew is pretty good at hunting bugs, and we came back to
a stablish build in the end. Among exciting new features are
customizable toolbar, error pages, the beginnings of user documentation,
overall various interface improvements, history support in the form of a
panel and allowing to hide the menubar.
The future will probably bring integration of history in the location, a
proper toolbar editor and support for importing netscape bookmark. We
will see what else there is going to be.

So download midori v0.1.0 already!

Abort, Retry, Fail?

2008-10-13T20:44:56+00:00

So let’s try this blogging thing again — now from an all new location (I am at blogs.gnome.org now) and a brand-new hackergotchi courtesy of Andreas. Wordpress Mu supports importing old LiveJournals these days, which also worked fine for me, except for all new lines to have disappeared. But who is interested in old news anyway?

This blog post is really long overdue. Over the summer I slowly started to hack on a full rewrite of GtkTreeView’s drag and drop implementation and related exported API. People familair with the matter know about the numerous problems. Unfamiliar people probably still know about #70479: “DnD with multiple selected items won’t work”. Yes, this bug has been open since 2002 and it feels really great to be finally getting somewhere. I think I’ve got the new API basically nailed (it really works beautifully and I am personally quite fond of it) and I am currently trying to get support for the old API back in place in some kind of compatible fashion. As I also rewrote all of the internal drag and drop signal handling in GtkTreeView, I really threw out everything and started from scratch. For me this also means I now have a fairly good knowledge of how drag and drop actually works ;) I got a huge amount of inspiration out of a reply from Federico on my earlier attempts to get multiple item DnD going.

Another thing that has been brewing originated at the GTK+ Hackfest earlier this year in Berlin. I sat down with both Johan Dahlin and Emmanuele Bassi to have a quick look at “simple list APIs” for GtkTreeView in python and perl (matching person and languange is left as an exercise for the reader ;). Here “simple list API” really means an easy to use wrapper around GtkTreeView (and its companion objects). From the API found in both language bindings, I devised a nice, simple and easy to use C API. The implementation for this is also already there.

Both of these projects are really getting somewhere so expect detailed API proposals and review on gtk-devel-list in 1.5 month or so. I don’t know yet what to tackle next, I really want to finish off these two first. However, my to do and idea list is infinite, so finding something else shouldn’t be hard.

In other news, the end of my time at a University is finally in sight. I really hope to have received my Master’s degree well before the start of Summer 2009. I am really enjoying the classes I am taking this semester, but still it will be great when I have finally finished my degrees. Having the end (finally) in sight here also gives me a lot more inspiration, hence the GTK+ stuff I am getting done these days. And I also reached the age of 24 years 1.5 weeks ago … I am really getting old now :/ ;)

False rumors

2008-10-09T17:55:45+00:00

Vincent is a filthy liar, I’m not getting married.
Might be that he’s nervous because he’s going to be a father next month so that his mind plays tricks on him.

07.10.2008 Recent Interviews

2008-10-07T15:17:19+00:00

Two weeks ago, Bruce Byfield did an interview with me about Manju. The article is now up at linux.com and gives a general overview of the project scope: Manju Project Article.

There’s also been a German interview with Sven Herzberg and me some months back at the Berlin Hackfest, which covers some historical background around Gtk+, some technical bits, possible future directions and how it relates to GNOME. The German podcast of this is up at Chaosradio Express: GTK+ und GNOME Podcast (DE).

To fail 1000 or 1024 times?

2008-09-30T20:25:49+00:00

Christian, I did ask my girlfriend about it. I’m sorry to tell you that she don’t get the whole Kilobyte, Megabyte, Gigabyte-thing at all because she honestly finds it way too abstract.
This is true for a whole bunch of other people I know, that needs their computers to get stuff done, as well.
So yeah, we fail. Hard.

Das GTK+/GNOME-Entwicklerhandbuch

2008-09-26T13:20:02+00:00

Matthias Warkus hat es endlich geschafft; die Neuauflage des hübschen orangenen Buchs…

GTK+ OS X framework

2008-09-24T10:19:12+00:00

Finally we have a binary build for the native GTK+ Mac OS X port! You can check it out here. The download is an installer that comes with frameworks for GTK+ and friends. The installed frameworks can be used directly in the Xcode IDE and come with a project template that sets all the necessary flags and variables to build against the frameworks.

You can also use the frameworks for building normal autotools based projects. This requires a bit of magic, so you will need a special jhbuild setup for it to work, which is currently work in progress but should be ready soon.

What is missing still is support for creating standalone apps, i.e. packages that contain the run-time parts of the frameworks needed to run the app. Also note that this is a beta version so please let me know if you run into any problems so we can work them out.

The binaries are Intel only, and require Mac OS X 10.4 or newer. Note that the Xcode integration is only tested with 3.x so feedback on using 2.5 is appreciated.

Launching Imendio Labs

2008-09-24T09:29:37+00:00

Today we’re proud to announce Imendio Labs, a window to the crazy software experiments that go on inside the Imendio headquarters.
We’re not only intending to blog about our own discoveries and inventions there, but about other things that we find interesting as well.

First out is the sweet GTK+ Mac OS X Framework that Richard already blogged about.
Expect more cool stuff in Labs shortly!

GNOME 2.24 Release Party in Gothenburg

2008-09-20T10:05:43+00:00

GNOME 2.24 is soon upon us. In order to celebrate the release Kalle Persson, Clemens Buss, Henrik Sandklef and myself is going to meet at Flygarns Haga on Friday the 26th around 19.00 or so and have some beers.
You can add yourself to the wiki page if you’re coming.

It seems that some of the London hackers have similar ideas.

In other news
Oh, and here is a random photo from our hackfest:

So anyway, Henrik is also one of the organizers behind the upcoming FSCons conference in Gothenburg during 24-26th of October, make sure to come there. I’m doing a talk on Tango and there is going to be a talk on GTK+ from Carlos. Last year was quite fun and I expect nothing less this year.

GTK+ and GStreamer on Mac

2008-09-20T08:12:06+00:00

I've used Gossip and Giggle in the past as examples of creating Mac bundles of GTK+ apps. Now I have another example that is a bit more complex, in that it uses GStreamer. The test case this time is the good old...

Jamboree music player!

I dug it up from the GNOME SVN archive and it worked pretty much out of the box after cleaning up the makefiles a bit and adding support for the Mac integration library to hook up the menubar.

The latest version of the Mac bundler and the bundle file here results in a nice little bundle.

It looks like this:

GStreamer works nicely, and using the QuickTime wrapper element gives access to all formats supported by the platform.

Mac integration

2008-09-20T08:10:39+00:00

If you've followed the development of Gimp, Gossip or Giggle, you've probably noticed that they can be built on Mac OS X, using the GTK+ OS X port and that they can use the global menu bar on that system. The code to do that has been floating around for a while as a cut-and-paste file you could use in your app, but after copying it one time too many I went ahead and made a real package of it instead. It's available here.

It also has the beginnings of integration with some other parts like the dock and bundle APIs.

The mandatory screenshot of it in action:

09.09.2008 The Manju Project

2008-09-09T20:35:45+00:00

Andreas Nilsson and I recently started the Manju project which aims at creating graphical widget toolkit themes from SVG files in a toolkit independent fashion.

It combines the idea of a pixmap theme engine, Jimmac’s “One Canvas Workflow”, SVG markup features and Inkscape export functionality to fully automate the creation of a scalable and stretchable pixmap theme from an SVG source.

We’re currently working out the SVG theme file specification, the binary pixmap theme file format, as well as sample files and sample code to demonstrate toolkit side rendering.

Everybody is invited to participate and at this early stage feedback on every aspect is highly appreciated.

We’re particularly looking for people who like to review our specs, implement widgets or theme engines and who like to create alternate themes.

The project is hosted as a git repository:

	http://git.testbit.eu/Manju

And provides a communication forum and web presence:

	http://groups.google.com/group/manju-project

Automated snapshots of our ongoing work are also provided:

	http://pages.testbit.eu/manju/snapshots/nordic.png

New version of GTK+ Mac app bundler

2008-09-04T07:13:50+00:00

I've released a new version of the Mac bundler, 0.5. The changes are:

Correct the GTK_DATA_PREFIX variable
Add beginnings of framework support
Clarifications in README and example bundle file
Remove support for non-included Pango font module
Fix locale in the launcher script

Download here.

GTK+ Application bundles on Mac

2008-09-04T07:13:34+00:00

I previously wrote about Mac integration for GTK+ applications, and another important part of that is to create app bundles. An app bundle is a self-contained packaged up version of your application that can be distributed easily and put wherever the user wants by using simple drag and drop. This is a very common way of distributing applications on Mac.

To make it easier to create such packages of GTK+ applications, we have created a tool that does most of the work. All you have to do is to setup a small configuration file that points the tool to your binary and any data files that you want to ship. All dependent libraries are sucked in automatically. The application must be able to find its data files dynamically of course, since there is no hard coded path where it will end up.

You can take a look at the bundle file for Gossip for a quite simple example.

I have some plans to add support for dragging in frameworks and not just libraries, and to add better support for translations and other specific resources.

Hack weekend

2008-09-03T21:09:01+00:00

As the observant Daniel already noted, I had a small hackfest at my apartment in Gothenburg this weekend.
The attendees was Kalle Persson, Clemens Buss and myself + this odd fellow that Clemens brought along.

We had quite a nice time. Discussed some ideas around GNOME, Clemens did some Emblem hacking and Kalle and I designed a website and drew some icons. We’re definitely doing this again soon and I hope more people will be interested in joining.

Fast and fervent follow up

2008-08-31T15:45:13+00:00

This is a rather early follow up release, mainly early because of GIO issues that were rather hard to reproduce and made Midori unusable for some users. Also waf was updated because the previous version wouldn't build on OpenBSD.

Two new features, so it's also worth a look for those who were not affected by the above issues: if you hide the statusbar Midori will now show the loading progress inside the location entry. Also typing an address in the location and pressing Alt + Enter will open the address in a new tab.

So download midori v0.0.21 already!

Moving to Xfce land

2008-08-25T00:35:20+00:00

Behind the scenes there were a few changes and I still didn't announce anything, since I still hadn't done all bits of it yet. The last bit being the first release of Midori under the hood of Xfce Goodies.

What does Midori moving in with Xfce bring us? The repository moved to git.xfce.org/kalikiana/midori, which has a fancy web interface for the repository. There is a Midori FAQ in the Xfce wiki now, that everybody can read and also add to and improve. Releases are from now on done via the Xfce Goodies Release Manager which generates checksums automatically and sends notifications to the Xfce mailing list. Neither the website nor the bug tracker will change, though, no need to change bookmarks for those.

What does Midori having moved in with Xfce mean for non-Xfce users? Basically, nothing will change for the average user, Midori is still as portable as before. Are there going to be efforts towards integration with Xfce? Yes, but not exclusively. If you want Midori to work better on your favourite system, let's talk about it. And maybe some day in the future Xfce users will see Midori as their default web browser. But anything will be optional, there are no plans with regard to essential dependencies on Xfce libraries. No need to worry there.

By the way, #midori on irc.freenode.net is a happy place, be welcome to join us for a little chat. ^_^

I love portability

2008-08-24T01:42:47+00:00

Time for a new Midori release. There are probably not as many visible changes as with the previous release, but one thing that is a major selling point for some users, is single instance support. Provided you have libUnique which is based on dBus, subsequent calls of "midori" will call the original instance instead of spawning independant processes. More importantly "midori http://www.twotoasts.de" will open a website in a new tab. Incidentally instances are per display, so you can still run Midori on different X servers. (Note that multiple instances will still overwrite each other's config files, though).
Support for userscripts is being improved with time, for example Midori started to read the names of scripts and show them in the panel and the list is updated if you add new files to the folder. Also userstyles are supported now, they go in ~/.local/share/midori/styles, similar to scripts.
Oh, and curiously, we have an Extension icon now. The actual extension support is still incomplete but it's a start. Apart from that I actually made an effort to have *some* stock icon for any possibly missing icon in the interface except for the throbber. That still means you should have an XDG compliant theme but you won't see only broken images if icons are missing.

So much for that, it's nice to see Midori coming along well. There seem to be users on more platforms than I can even claim to have seen myself by now. Midori fans use Linux, BSD, Gnome, KDE, Xfce, Openbox, MacOS, Windows, E-Ink, Maemo, ... there may be more. I am happy to observe how portability can actually work and not only serve as a marketing term.

So download midori v0.0.20 already!

GTK+ code rewriter

2008-08-13T18:23:10+00:00

I have been looking at the compiler framework llvm/clang recently in order to do automatic refactoring and code rewriting. One use case for this is to move code that does things like:

gdk_window_foo (widget->window);

gdk_window_foo (gtk_widget_get_window (widget));

automatically, to get code working with a sealed GTK+.

Another useful thing that can be done automatically is to change code so that only gtk/gtk.h is included, which is the recommended way, instead of many individual header files. There are more examples of things that can help developers clean up their code, such as spotting common mistakes like not chaining up in finalizers etc etc. Clang makes it quite easy to implement those ideas.

I have started working on a tool to do the accessor and header file rewriting as a first step. Please check it out and let me know if there are any issues or if you want to help out!

Native Mac theme

2008-08-03T14:57:19+00:00

A frequent comment I get is that the GTK+ OS X screenshots look like... GTK+. As opposed to native Mac applications, of course. I started a native theme engine quite a while ago but got sidetracked with other things, so it's been sitting around in a git repo for some time now. It could be a fun hack if someone wants to get involved in GTK+ OS X hacking, and there is plenty of low hanging fruit to take care of. It's quite rewarding to play around with, as the result of the work is so immediately visible.

You can check it out here:

  svn co svn.gnome.org/svn/gtk-quartz-engine/trunk gtk-quartz-engine

Here's an example of what it looks like on 10.5:

Update

The repo was moved to GNOME subversion, I've updated the info above to reflect that.

Using Spot colors in Scribus

2008-08-02T16:38:13+00:00

A while ago, Máirín blogged about creating print originals in Inkscape and Scribus, and I can only chime in on her praise of these tools. Since I joined Imendio, a large amount of what I’ve done on a daily basis have been print work (stickers, t-shirts, rollups, tattoos etc.) and all of it have been done using a free software workflow!

A common obstacle you run into when using Scribus for print is the lack of support for predefined spot colors from Pantone, something that usually comes handy when you need more exact colors that you looked up in a color swatch. The reason that Scribus can’t include these is, as usual, because of legal reasons.
Luckily there exists a small howto in the Scribus Wiki how to get hold of and use these in your designs.

About time for Midori 0.0.19

2008-08-02T12:55:48+00:00

While there wasn't much to hear about Midori from my side lately, the development is going better than ever. The bug tracker is doing a good job managing bugs that were previously shared over IRC and e-mail. Poking me directly for bugs is still great and I don't mind it, but having bugs publicly visible at the same time obviously makes it easier for others to help out and track development. And in fact, the number of contributors is increasing. Special thanks to Arnaud and Dale here, who tackled non-trivial tasks.

Now about the new release, Midori 0.0.19. People like to ask, whether building from git is worth it. And the answer is, lately it was a remarkable difference, but of course it can break once in a while, that's always the risk. As for the features, we have better Greasemonkey compatibility with userscripts, Midori has a logo, you can zoom, you can see source code of websites (if you have GIO), you can see favicons (again, GIO required atm), there is the fancy new location entry which isn't finished but coming along promising and sessions are finally saved during runtime, so even if Midori passes away, it will remember your tabs. Oh, and support for multiple windows is much better, even though only the first window's tabs can be saved currently. Oh, and as a bonus, Midori applies a trick to make selected text in web pages work with the primary clipboard until it's fixed for good in WebKit.

So download midori v0.0.19 already!

(Post) Guadec hack

2008-07-21T12:01:48+00:00

No! this isn’t another “added tabs to $APP” [1], Instead I decided to spend my hacking time on getting MPX work with GTK+. Surprisingly, gdk is 99% prepared to handle multiple pointers, so besides adding support there for the new XInput method to handle device grabs, most of the remaining work should just be focused on making GtkWidgets deal sanely with multiple pointers (madness awaits there…). Here’s a “screencast” of my proof app, apologies for the quality, trying to record and use both the nipple thingy and the touchpad isn’t quite easy

Also, I’ve spent one extra week in Istanbul and surroundings with Mitch and Pia, It has proven to be a really beautiful place full of life, returning to Turkey is a must.

[1] You caught me guys :), I was seriously concerned about your sanity for a while

Update: In case it isn’t clear, the patch isn’t really far from the “evil hack” state, I’ll just submit it to bugzilla as soon as there’s some reasonable base work in which other smaller patches can be developed incrementally.

Oringen 2008

2008-07-18T14:04:09+00:00

Going on vacation tomorrow for a week of orienteering in Sälen, Sweden. The terrain will vary from a more classic swedish orienteering for the first two stages and the go over to an alpine terrain with more open areas and higher altitude differences for the third and fourth stage. The last stage seems to be back to more classic terrain again with a mix of small hills and marshes.

In total the event (in my class) will be about 30km as the birds fly which should translate into something like 45-50km of terrain running over the course of five days. Hopefully I’ve exercised enough, I’ve tried to do 4-5 sessions per week over the last couple of weeks and luckily Guadec had little impact on the overall fitness as this week felt really good.

Share This

16.07.2008 GUADEC 2008 Wrapup

2008-07-16T08:45:10+00:00

Guadec has been in interesting conference, particularly because it took place in Istanbul this year. I tried to keep a few notes throughout the days to wrap up the experience and discussions here.

Sunday

Headed off for Istanbul, partial Imendio meet-up at the airport in Vienna, gathered remaining Imendians at the airport in Istanbul. Like many others, we stayed at the Golden Long Hotel near the seaside.

Monday

Kris and I met up with the Gnome release team where we summarized the Gtk+-3.0 ideas that have been cooked up during and after the Berlin Gtk+ Hackfest.

Tuesday

I was planning to attend the Maemo BOF in the morning, but shortly after arriving at the conference venue, Federico literally dragged me into the DVCS BOF. Still, I only managed to attend the second half of it which was almost exclusively about Bazaar features. People told me the first hour had been quite the contrary and focused mostly on Git hyping. Clearly, there was no consensus after the meeting on what the future versioning system in Gnome will be.
I’m not surprised that is the case. As things currently stand, SVN has very active development and user communities, Git is very actively developed, Bazaar is as well, as are a couple other VCSes. Active developer and user communities are generally a good sign for a healthy project and also an indicator for future relevance. Thus, in any larger community such as the Gnome community, it’s easy to find lots of critics and lots of supporters for each of the bigger versioning systems and that’s unlikely to change much. Consequently, there’ll not be an easy consensus on switching to a single versioning system any time soon, so I think the most productive approach for Gnome to take is to prepare the hosting of multiple VCSes, certainly SVN, Git and Bazaar. Needless to say that cross-VCS integration will also become increasingly important in the future, so focus on maturing and extending git-svn, bzr-svn, bzr-git and the like makes a lot of sense.

Later that day, we had a Gtk+ Developers meeting in the medium sized presentation room. The place was a bit too large to have the planned face to face discussions so we’ve had to sacrifice some of the spontaneity to microphone resource sharing. Kris took minutes during the meeting and will probably post those to gtk-devel-list once he’s found a minute to process them. The meeting was quite productive nevertheless, we discussed the upcoming Gtk+ 2.14, features and schedule for 2.16 and 3.0 and a bit of the post-3.0 road map.
Right after that discussion, Kris and I attended the advisory board meeting where we briefly wrapped up the developers meeting, the Gtk+ Hackfest in Berlin and the improvements the Gtk+ project has seen since the State of the Gtk+ Maintenance email. In particular, we stressed that we now have the GtkTasks and Gtk+ 3.0 Tasks wiki pages which can serve as an entry point for contributors and assistants to the project at various experience levels, in particular for companies that want to sponsor developer resources. Also for people that have an interest in long term Gtk+ project involvement, feel free to read up on how to become a Gtk+ maintainer.

Pizza looks weird in Istanbul BTW:

Wednesday

Almost by accident (I was mostly looking for an air conditioned hall in the afternoon), I happened to be watching “Gnome Documentation: A year in review” by Don Scorgie where he described the new user documentation tool Mallard. For some time now, I’ve been working on a Wiki syntax parser for Doxer to unify the markup I have to use for my blog, inline documentation and CMS content markup at testbit.eu. (I have a blog entry in the queue on this for another day.) In this context, implementing a Doxer markup backend that generates Mallard’s XML input could be an attractive markup alternative for future Gnome documentation - it at least ended up on my ever growing TODO list. ;)

Lots of people approached me throughout this and the following days for a chat about Gtk+-3.0 and what comes after that. With the merging of the GSEAL branch into upstream trunk recently, there’s been a lot of focus on the technical preparative work we’re doing for the actual 3.0 release which is planned as an ABI break to Gtk+-2.16 without adding any new features (it’s basically just a re-release with all deprecated code removed and current “private” API really made private by moving it to non-installed source files).

What has been lacking emphasis in this course is that 3.0 is going to be the necessary enabler, needed to work on implementing future visions of Gtk+ and to refactor the code base back to a healthy state where it becomes maintainable again. Quite expectedly, the need for the sealing and accompanied ABI break has been questioned several times, so I’ll reiterate the reasoning here:

Everybody falls the first time.
Code development in open source projects is very evolutionary, especially for projects that don’t clone or reimplement existing specified APIs like Libc. A whole chapter is spent on prototypes in The Mythical Man-Month:
“Plan to throw one away; you will, anyhow.”
So newly added components and APIs are almost certain to need fixups or revamps in future iterations (likely more than once). If critical internals are being exposed and eternal ABI stability has been promised, this however becomes impossible. Given the development history of Gtk+ and the variety of interests in this project, it is vital for its future success to prepare for future changes and allow iterative improvements. After all, progressive improvements, appreciation of contributions and adaptions to changing circumstances is where the free software development model shows its strength. The waterfall design model is not it.
Gtk+-2.x is essentially a dead end.
Everybody agrees that Gtk+-2.x is pretty much dead in a few revisions because of the huge work involved in its maintenance and no relief in sight with its current ABI maintenance policy. This is at least true for all current and past core team members (i.e. everyone who actively tried maintaining 2.x over a significant period). The question is whether we move to an entirely new toolkit (Clutter, Rapicorn, Qt, HippoCanvas, etc) or whether that “new” toolkit is Gtk+-3.0 which may be largely API compatible with Gtk+-2.x. In either case, applications and libraries will need to migrate to a new toolkit base with a different ABI, the main difference is the involved porting effort.
GLib and Gtk+ do have a means to deal with API changes:
1) We provide new alternative interfaces (functions).
2) We deprecate old interfaces (functions) or provide compatibility code in old interfaces.
Notably, this does only work for API that is exported via function symbols. Structure fields that are directly accessed from application code can’t be deprecated and removed without breaking ABI, and there is no compatibility code upstream could provide for these kind of accesses either. That’s why we want to move away from exposing any structure internals in 3.0 and beyond.
3.0 will ABI-incompatibly remove all deprecated and private APIs.
Of course, the above described deprecation scheme only scales well if deprecated APIs are really removed from the code base at some point. Technically, this is an ABI break which is why GLib/Gtk+ have not been doing this since 2.0. However, lots of other vendors do this to keep a healthy code base, e.g. Qt does break ABI between major releases, Python 3.0 will be incompatible with 2.5, Apple does remove long deprecated APIs in newer releases of Mac OS X, Symbian broke API and ABI in 9.x, Microsoft broke behavior from .NET 1.1 to 2.0, and the list goes on…
By exposing only function symbols as future public interfaces, we’ll be able to provide arbitrary compatibility functionality for old interfaces on top of new components, add helpful runtime warnings for iterative migration and constrain future ABI breaks to removal of properly deprecated interfaces.
User visible gains are post-3.0 features:
Since GLib and Gtk+ are largely volunteer contribution based projects, it’s close to impossible to plan exact arrival of future features. However the following is a list of things that have (partially) been discussed as post-3.0 work during the Gtk+ Hackfest already:
- Full support of alpha transparency for all widgets;
- Support for (partial) stacking of widgets (needs transparency);
- Offering easier layouting facilities;
- Support for animated visible transitions between widget states;
- Providing new UI metaphors based on simulation of physical effects like acceleration, 3D browsing of image collections, 3D skimming through notebook pages, and more;
- Using IDL based type data generators and code generators to improve the way widgets are implemented;
- Implementing a new theming system for the toolkit;
- Moving towards exposing widget features only via interfaces that have their own handle (asymmetric query_interface).

This is how GSEAL, the Gtk+-3.0 release and a couple remaining outstanding tasks are going to enable development of exciting future user visible features. The next step for Gtk+ to get work in visionary areas off the ground is to start consideration of feature feasibility and implementations, required resources and tentative schedules.

At the end of the day, we had the Opening Cocktails Party, during which I managed to catch Hallski tattooing J5:

Thursday

Thursdays most interesting event was of course the keynote by Kris which got hijacked by the Gnome release team for the announcement of Gnome 3.0 which is essentially Gnome 2.30 cleaned up and based on Gtk+-3.x. Kris’ slides are available online:

	http://people.imendio.com/kris/gtk-state-of-the-union-2008.pdf

The slides provide a good overview of what Gtk+-2.14 will bring, prospects for 2.16 and visions/requests from the community for Gtk+’s future. As previously described, Gtk+-3.0 is about enabling refactorings and development of new features, and the plan is to do our best to make the transition away from old deprecated code as easy as possible. Other than properly porting an existing Gtk+-2.x application to work with the G_DISABLE_DEPRECATED, GTK_DISABLE_DEPRECATED, GSEAL_ENABLE switches, no additional changes will be required to build and run an application on Gtk+-3.0.

At the end of the day, there was the boat trip through the Bosporous which provided a beautiful sight along the coast line.

Friday

I managed to attend the latter half of the lightning talks which was as always quite interesting. I should probably ignore my laziness and actually prepare short lightning talks for next year about Rapicorn and possibly Doxer… ;)

I took particular interest in Transifex, an online translation platform that can work together with multiple VCSes and that we’d ideally move all Gnome translations to in the future. There are two things I’d like to see fixed in a future translation workflow from a developer perspective:

The .po templates should really be generated by the developers of the upstream project by automatic means, e.g.:
make update-po -C po/
So the upstream version of intltool and po/Makefile.* are used instead of possibly broken or outdated intltool/gettext versions on the translators system.
Developers should be able to determine merge points for translations, and also review related non-po file changes, rather than having translators wildly commit into upstream repositories (which may conflict with other VCS workflows like branch merges or commits around release phases).

Later on, Federico presented his ideas for timeline tabs for the desktop. This should make it rather easy to find documents or URLs from previous days or weeks, because out of natural necessity, humans generally have good chronological associations. So the new and nice part about this approach is that it can provide good visual access to the chronologic dimension, something a file system doesn’t usually reveal easily, and that’s not easily made accessible by the most prominent desktop metaphors either.

I feel very tempted to start an implementation of the desktop tabs with Rapicorn, however with a few refinements of Federico’s proposal:

The view should provide a “chronological zoom” slider to switch the view between years/months/weeks/days/hours.
To be most useful, we’ll need a crawler that tries to (re-)construct past file modification history without relying on programs pushing journal entries about file edits. This will be needed anyway unless every program on this planet provides file editing journal information.
I think the journaling hooks need to be implemented via DBus and not rely on Nautilus, so they’re usable by all cross-desktop applications and non-GUI programs.
Various filters by file extensions, magic and possibly more will also be needed in the tab view (this was partly raised during the discussion phase at the end of the presentation).

Saturday

About half of the Imendians headed home on Saturday, we had some early leaves on Friday already and left some others in Istanbul for additional vacations.

Oh, and since I’ve been asked about my nickname here and there, I decided to add tabs to my hackergotchi for clarification:

Aftermath

There have been quite some discussions on the Gtk+-3.0 plan after Kris’ keynote. One thing that was brought up is that releasing an ABI incompatible but featureless new version of Gtk+ and calling it 3.0 is rather unconventional. An alternative scheme could involve releasing the ABI incompatible cleaned up version as 2.99.0, make 2.99.x the new development branch and release 3.0 with cleaned up ABI and new features (would have been 3.2 in the original plan).

Back from Guadec

2008-07-15T23:18:45+00:00

Somewhat back to normal routines after a week in beautiful Istanbul. As people reading Planet GNOME have seen from others, it was a great Guadec this year.

I found the schedule to be a bit uninspiring but that left more time for discussions and hacking. Among the sessions I went to I really enjoyed going to Alp’s session about Webkit and Blizzards on Mozilla. Some really interesting things coming from these projects.

Kris did a great job wrapping up the current state in GTK+ during his now traditional ‘GTK+ State of the Union’ talk and happy to see that the discussion around future GTK+ is getting started throughout the community. I spent a lot of time this year talking and listening to peoples feedback on the proposed plans. Realized that some things have been a bit left out from the discussions after the hackfest and that we need to do a better job at communicating what we plan to work on besides the cleanups and enabling of future development.

Finally a warm welcome to Stormy as executive director of the GNOME Foundation Board.

Share This

More GUADEC!

2008-07-11T15:53:00+00:00

Okay, I am actually getting hacking done (okay okay it is more like reviewing) and I just committed the fix for #316087 “Resizing columns is chaotic” to gtk+ trunk (finally!). Should be in the next 2.13 releases. This patch does modify the internals of tree view column size allocation, so if people could give the latest gtk+ from trunk a test drive that would be really appreciated :) By the way, you can find the slides from yesterday&aposs GTK+ state of the Union here. The plans from the release team for GNOME3 sound cool, exciting times ahead :)

GNOME Art BOF at GUADEC

2008-07-09T23:28:20+00:00

We decided to have the GNOME Art BOF on Thursday afternoon 15.30 (turkish time). We’ll try to add notes in #art-meeting on IRC (gimpnet) during the meeting. We haven’t decided on a room yet, but we’ll meet in the lobby, and go and find somewhere to sit down.
Hope to see you there!

Update: I screwed up a bit. It’s 16.30, same place.

GUADEC GUADEC GUADEC

2008-07-09T13:54:00+00:00

My talk “GTK+ State of the Union” at GUADEC has been moved from Friday morning to Thursday 14:30 (the cancelled keynote slot). This was noted in the schedule on the GUADEC website before, but unfortunately this schedule was reverted to the original version as also found on the badges this morning. But the move of the talk is still on :) Minutes from the GTK+ developer&aposs meeting we had yesterday will follow soon, hopefully early next week. Ah yeah, and during GUADEC I am hacking on Bug 316087, or better known as “column resizing with expand=TRUE columns is entirely fucked up”. Seems we are very close to getting this fixed now. I will probably also hang out at the parties during the upcoming days, so see you all there ;)

Totem on GTK+ OS X

2008-07-07T13:35:30+00:00

It's too hot in Istanbul to have the energy to write something useful right now, but since I promised Bastien a screenshot, here it is:

This is Totem running on GTK+ OS X, but without any nice integration with the global menubar and there is no clean patch that can be committed. (The changes are mostly commenting out some X11 and GNOME dependencies.)

It's using a video sink that renders into a GdkWindow (actually it's backing NSView) through OpenGL, based on the Cocoa video sink that comes with GStreamer.

Heading to Guadec

2008-07-05T22:14:53+00:00

Posting this just before going to bed for an early rise to fly to Guadec in Istanbul. Unless someone gets sick last minute the entire Imendio crew will be arriving tomorrow and staying at the Golden Horn Sultanahmet.

See you all there!

Share This

New website

2008-07-02T22:21:36+00:00

During the last few days I was working on the website for a change. In fact my dear Nancy was doing the lion share of this work. She even made a new Catfish logo on the way. Afterall we are going to share this new site, for programs I work on and artwork Nancy will publish here. The URL moved from software.twotoasts.de to the toplevel www.twotoasts.de. The old file links should silently redirect, including downloads, screenshots and git repository. The sub pages have changed but will all lead to the homepage now, which shouldn't be a problem. Of course I recommend everyone to update your links and bookmarks to www.twotoasts.de now.

23.06.2008 Writing Unit Tests with GLib

2008-06-24T15:14:04+00:00

Every other week, someone asks how to use the new unit testing framework in GLib (released with GLib-2.16.0) and Gtk+ (to be released with the next stable). First, here is a write-up from last December that summarizes all important aspects: Test Framework Mini Tutorial.

For people building packages that use the new framework, the following new Makefile rules will be of interest:

make test
Run all tests recursively from $(TEST_PROGS), abort on first error.
make test-report
Run all tests recursively, continue on errors and generate test-report.xml.
make perf-report
Run all tests recursively, enable performance tests (this usually takes significantly longer), continue on errors, generate perf-report.xml.
make full-report
Run all tests recursively, enable performance tests, enable slow (thorough) tests, continue on errors, generate full-report.xml.
make check
Run make test in addition to automake checks.

After GUADEC, we will be looking into getting build machines setup that’ll regularly build GLib, Gtk+ and friends, run the unit testing suites and provide reports online.

For those pondering to write unit tests, but too lazy to look at the tutorial:

Implementing a test program is very easy, the only things needed are:

  // initialize test program
  gtk_test_init (&argc, &argv);
  // hook up your test functions
  g_test_add_func ("/Simple Test Case", simple_test_case);
  // run tests from the suite
  return g_test_run();

In most cases, a test function can be as simple as:
```
  static void
  simple_test_case (void)
  {
    // a suitable test
    g_assert (g_bit_storage (1) == 1);
    // a test with verbose error message
    g_assert_cmpint (g_bit_storage (1), ==, 1);
  }
```
Tests that abort, e.g. via g_assert() or g_error(), are registered as failing tests with the framework. Also, the gtester utility used to implement the above Makefile rules will restart a test binary after a test function failed and continue to run remaining tests if g_test_add_func() has been used multiple times.
Checks in tests can be written with if() and g_error() or exit(1), or simply by using variants of g_assert(). For unit tests in particular, an extended set of assertions has been added, the benefit of using these are the printouts of the involved values when an assertion doesn’t hold:
```
  g_assert_cmpstr   (stringa, cmpop, stringb);
  g_assert_cmpint   (int64a,  cmpop, int64b);
  g_assert_cmpuint  (uint64a, cmpop, uint64b);
  g_assert_cmphex   (uint64a, cmpop, uint64b);
  g_assert_cmpfloat (doublea, cmpop, doubleb);
```
For instance:
char *string = "foo"; g_assert_cmpstr (string, ==, "bar");
yields:
ERROR: assertion failed (string == "bar"): ("foo" == "bar")

The framework makes it easy to test program output in unit tests:

  static void
  test_program_output (void)
  {
    if (g_test_trap_fork (0, G_TEST_TRAP_SILENCE_STDOUT |
                             G_TEST_TRAP_SILENCE_STDERR))
      {
        g_print ("some stdout text: somagic17\n");
        g_printerr ("some stderr text: semagic43\n");
        exit (0);
      }
    g_test_trap_assert_passed();
    g_test_trap_assert_stdout ("*somagic17*");
    g_test_trap_assert_stderr ("*semagic43*");
  }

And it is similarly easy to test and verify intentional program abortion:

  static void
  test_fork_fail (void)
  {
    if (g_test_trap_fork (0, G_TEST_TRAP_SILENCE_STDERR))
      {
        g_assert_not_reached();
      }
    g_test_trap_assert_failed();
    g_test_trap_assert_stderr ("*ERROR*test_fork_fail*not*reached*");
  }

The above and more tests are showcased in GLib: glib/tests/testing.c.

There’s of course lots of room left to improve GLib and Gtk+ unit tests, and also to improve the current framework. For a speculative, non-comprehensive list, here are some ideas from the unit testing section of my personal TODO:

Introduce 2D marker recognition for graphical unit testing of Gtk+ layouts (prototyped in Rapicorn).
Provide functionality to determine image similarities to allow for pixel image based unit tests (port this from Rapicorn).
Implement state dumps to automate result specification and verification in unit tests. (This will allow us to avoid adding lots of abusable testing hooks to our API.)
Integrate performance statistics (like #354457) and other related information into test reports.
Publically install a variant of the Makefile.decl file used in Gtk+ to implement the test framework rules and Xvfb swallowing of test programs. This is needed by other projects to run unit tests the way Gtk+ does.
Implement the unit test ideas that are outlined at the end of this email: Gtk+ unit tests (brainstorming).

Removing a remote branch in Git

2008-06-21T15:27:49+00:00

This is something I’ve had to checkup a few times so I figured it would be useful both for myself and for others to keep around in a blog post.

To remove a remote branch you created in Git just push to it like:

$ git push origin :name-of-branch

Share This

16.06.2008 Sinfex - Simple Infix Expression Evaluator

2008-06-16T22:10:35+00:00

The XML GUI definition files used in Rapicorn and also in Beast (described briefly in an earlier blog post) supported a simple $(function,arguments...) evaluation syntax, similar to GNU Make. I’ve never been very happy with this syntax, but it was fairly easy to implement at the start and followed naturally from early $VARIABLE expansion features. At some point last year I considered various alternative syntax variants and discussed the ideas with Stefan Westerfeld. Over the course of the last two months, I finally got around to implement them.

I’ve never grown familiar with reverse polish notation, and although Guile is the canonical scripting language for Beast, I’ve always found myself very inefficient with expressing my thoughts in lisp expressions. So the new syntax definitely had to support infix expressions - despite the more complex parsing logic required to parse them. Bison already ships with an example calculator that parses infix expressions, so that’s a quick start as far as the syntax rules go. Integration is quite a different story though, more on that later.

Since in Rapicorn the expressions are used to compute widget property values, they are likely to be executed very often, i.e. each time a widget is created from an XML file description. Consequently, I wanted to use a pre-parsed AST to carry out the evaluation and avoid mixing evaluation logic with parser logic, which would have forced reparsing expressions upon each evaluation. At first I quickly threw together some C++ classes for the arithmetic operators and used those as nodes for the AST, similar to:

  class ASTNodeNot : virtual public ASTNode {
    ASTNode &m_operand;
  public:
    explicit ASTNodeNot (ASTNode &operand) :
      m_operand (a)
    {}
    virtual Value
    eval (Env *env) const
    {
      Value a = m_operand.eval();
      return Value (!a.asbool());
    }
  };

The supported syntax is quickly summarized:

  Operators: ( + - * / ** < > <= >= == != or and not )
  Functions: name ( args... )
  Inputs:    FloatingPoint 'SingleQuotedString' "DoubleQuotedString"

In this notation, FloatingPoint includes hexadecimal numbers and of course integers and the quoted strings support C style escape sequences like octal numbers, ‘\n‘, ‘\t‘ and so on. The functions can be implemented by the parser API user, but a good set of standard arithmetic functions is already supported like ceil(), floor(), min(), max(), log(), etc. So it’s a very basic parser, but covers the vast majority of expressions needed to position widgets or configure packing properties.

One thing that turned out to be tricky is the binary operator semantics for strings. At the very least, I wanted support for "string" + "string" and "string" == "string". Since both operators are supported for numbers as well, the exact behavior of "string" + FloatingPoint and "string" == FloatingPoint had to be defined. I managed to find a few programming language precedents here in Perl, Python, and ECMAScript (Javascript). They of course all handle the cases differently. In the end I settled with ECMAScript semantics:

  Value1 == Value2  # does string comparisons if both values are strings
  Value1 + Value2   # does string conversion if either value is a string

Unit testing for the parser turned out to be particularly easy to implement. All that’s needed is a small utility that reads expressions and prints/verifies the evaluation results. Throwing in some additional shell code allowed a normal text file to drive unit testing. It simply contains expressions and expected results on alternating lines. Btw, libreadline can be really handy in cases like this. Using it takes a mere 5-10 lines of additional code to support a nice interactive command line interface including history for the evaluator test shell.

After some initial testing, the C++ AST node classes seemed like an awful lot of pointers, fragmentation and VTable calls for a supposedly straight forward expression evaluation. Also, adding the missing destruction semantics would have significantly increased the existing class logic. So I tried to come up with a leaner and foremost flat memory presentation. In the end, I settled with a single array that grows in 4 byte (integer) steps, embeds strings literally (padded to 4 byte alignment) and uses array offsets instead of pointers for references. A single multiplication operator is encoded with 3 integers that way: MUL_opcode factor1_index factor2_index. That’s essentially 12 bytes per binary operator, still significantly more than the parser input, but also significantly smaller than allocating an equivalent C++ class. Evaluation of the expression stored in the array doesn’t need any VTable calls, and a single straight forward evaluation function can be used, that implements the different operators as switch statement cases. Also release semantics are persuasively trivial for a single consecutive array.

What’s left was to figure a way to embed expression evaluation in XML values or text blocks. Previously, $(expression) was substituted everywhere, but with the new syntax, variables (or rather constants defined within the Rapicorn core or via the ‘<arg:ArgName default="5"/>‘ syntax supported by Rapicorn XML files) didn’t use a $-prefix anymore. So sticking with $() seemed to make little sense. As it’s implemented now, backticks are used to cause expression evaluation, with the empty expression evaluating to a single backtick:

  XML Value/Text         Parser Result
    Foo  5 + 5      ->     Foo  5 + 5
    Foo `5 + 5`     ->     Foo 10
    ``Foo``         ->     `Foo`

We will see how useful the current expression style turns out to be. I don’t consider every implementation bit outlined here solidly engraved into stone yet. So as always, I’m open to constructive feedback.

As forewarned, I have a few more words on integrating Flex and Bison with each other and into one’s own library. First, Flex and Bison turned out not to be exactly simple to configure, especially if none of the generated symbols should be exported from a library or clash with a possible second parser linked into the same library or program. Also some fiddling is required to pass on proper line count information from the lexer to the parser, getting character counts as well is non-trivial but lucky wasn’t strictly needed for Rapicorn expressions. The simplest setup I managed to come up with works as follows:

  sinfex.hh     # public API
  sinfeximpl.hh # internal structure definitions
  sinfex.cc     # evaluator implementation
  sinfex.l      # scanner rules for Flex
  sinfex.y      # parser rules for Bison
  sinfex.lgen   # generated by Flex
  sinfex.ygen   # generated by Bison

The only compiled file in this list is sinfex.cc which includes sinfex.lgen and sinfex.ygen as part of an anonymous C++ namespace. A linker script ldscript.map used when finally linking the library prevents anonymous symbols from being exported. The anonymous namespacing of everything declared in sinfex.lgen and sinfex.ygen is what prevents clashes with a possible second parser linked into the library. This isn’t as elegant as i was hoping for, but at least effective in a practical sense. There unfortunately is no way to configure Flex or Bison to generate only static functions and variables. And yes, I have also looked into variants like flex++, bison++, bisonc++, byacc, etc, but they usually show much of the same problems and also tend to make matters worse by generating more files or more complex code.

Finally getting things done

2008-06-06T13:51:00+00:00

I&aposve been meaning to blog again for a long while, and I finally managed to sit down and do it. The last few months have been very, very busy. I got inspired in some way and started studying three times as hard, which is a good thing since I finally manage to get a lot of things done there. This week I finished two more master courses, for both of which we did some interesting stuff. For the first one I have been looking at very low-level cache optimizations (esp. strip lining/loop blocking) with somebody else; learnt a great deal of new stuff and gained experience. The other course was about grid computing; for the presentation and project part I have been focussing on data storage in grids. I&aposve been looking at iRODS, which is an open source system for building data grids. It is a very interesting and promising project, but not yet ready for production deployments. I should probably put my report on this online at some point. Furthermore, my thesis is finally almost done. In the coming weeks I will be working on finishing another course which I had to leave behind for a while at the end of last year. At least the end is coming in sight, I hope to have my BSc and MSc degrees before mid next-year. Being very busy with studying is nice and all, but it means I had zero time left for spare time (GTK+) hacking. I hope this will change in the coming weeks and get my “getting things done” attitude from University work also applied to GTK+ hacking ;) I am going to look into:

Getting the column resizing with > 1 expand=TRUE columns patch updated, fixed and committed in trunk. (finally)
Design and implement a proper API for doing DnD (with multiple rows) in GtkTreeView. This should include making it possible to DnD between tree views and apps. (finally)
Look into improving the rubber banding behavior as Christian Neumair talked about in his blog. As is stated in the related tree view bugzilla bug about this, probably need to move over the cell_process_action() refactorings from my experimental branch to trunk and then this might be much easier to fix. Moving that refactoring over means writing a good automated layouting test.
Look into properly fixing the editing mess. We need a better means to distinguish between committed/cancelled editings.
Actually write about the plans for a simple tree view wrapper that I&aposve discussed with Johan and Emmanuele during the hack fest.
Continue hacking on my experimental tree view branch. More on this later.

I thought I had more for this list, but this will keep me busy for a good while anyway ;)

AsyncRunner for Ruby/GLib

2008-06-04T20:48:52+00:00

Was playing around a bit with a synchronous network library that I wanted to use from a GTK+ frontend. Obviously this wouldn’t work too well as the UI would be blocked while waiting for the library to return from it’s network calls. So I wanted to run the network operations in the background using a thread but still get the callbacks in the main thread to be able to update the UI from there.

I ended up writing a small class I called AsyncRunner which is a small proxy to call methods in a various thread and get the callback in the main thread. It’s using the GLib Mainloop so it would only be useful in the cases where you actually have one.

require 'thread-sync'
class MySyncClass
  def foo_method(arg)
  end

  def bar_method(arg1, arg2)
  end
end

sync = MySyncClass.new

# In order to get the methods of MySyncClass asynchronous it is wrapped in an AsyncRunner.
async = AsyncRunner.new(sync)

async.foo_method('test') do
  ui_update()
end

main_loop = GLib::MainLoop.new
main_loop.run

Share This