Older blog entries for jamesh (starting at number 168)

Ubuntu

Ubuntu seems to have taken off very quickly since the preview release came out a few weeks ago. In general, people seem to like the small tweaks we've made to the default Gnome install. Of course, after the preview came out people found bugs in some of my Gnome patches ...

One of the things we added was the trash applet on the panel. I made a fair number of fixes that make the applet fit in with the desktop a bit better and handle error conditions a bit better.

Probably the biggest fix was adding support for multiple trash directories. Originally the applet would move files to ~/.Trash and didn't monitor any other trash directories, which meant that moving to the trash took longer than necessary on slow volumes and the applet didn't correctly reflect the trash's empty state if you used the "move to trash" context menu item in Nautilus.

One of the problems implementing this was that the trash handling in Gnome is pretty much entirely private to Nautilus. I managed to adapt the Nautilus code into a small class (about 500 lines) that could provide an item count for the trash, notification of changes to the item count, and the ability to empty the trash. A lot of the complexity in this code is to handle plugging and and unplugging of removable volumes. It'd be nice if this kind of code was available in gnome-vfs or something though.

Icon Theme APIs

While working on various Ubuntu fixes, I found an error that seems to be quite common in various bits of the desktop. It goes something like this:

1. Find the image file for an icon at size n using gnome_icon_theme_lookup_icon() or gtk_icon_theme_lookup_icon().
2. Create a GdkPixbuf from the image file using gdk_pixbuf_new_from_file().
3. Use the pixbuf as an nxn icon.

The first problem with this is that gtk_icon_theme_lookup_icon() is not guaranteed to return an image at the desired size. This is quite obvious when you consider that you can pass in an arbitrary size to the lookup function, but the icon theme will only contain a finite number of sizes. However, if you ask for a common sized icon and the icon theme contains that size image, it might appear that the function will always return an image file of the requested size. The fix is to check the size of the loaded pixbuf and scale it if it is of the wrong dimensions.

The second problem is to do with SVG image files. They can be rendered at arbitrary sizes, but gdk_pixbuf_new_from_file() doesn't tell the loader backend what size is actually wanted. This means that the SVG will be rendered at whatever size is listed in the file itself, which could be very large or very small. To avoid having to resize the SVG image after rendering it (which could be slow), you can use the gdk_pixbuf_new_from_file_at_size() routine (new in GTK 2.4) which passes the desired size to the backend so that ones like the SVG backend can render at an appropriate size. This function will return a pixbuf that fits into the bounding height/width you pass to it, and will perform scaling if the backend can't load the image at the requested size.

If this sounds complicated, there is an easier way. You can just use gtk_icon_theme_load_icon(), which will lookup the image, and load it at the desired size all in one go. I guess there aren't many people using it because there wasn't an equivalent in the older GnomeIconTheme API.

Applets vs. Notification Icons

It seems that a lot of people get confused by what things on the panel should be applets and what should be notification icons. Originally, the main difference between the two was this:

• The lifecycle of an applet is managed by the panel, which in turn is tied to the lifecycle of the session. So applets generally live for the length of the session (unless they are added/removed part way through a session).
• Notification icons are more transient. Their lifecycle is linked to whatever app they were created by. Once the app exits the notification icon goes away too.

There are some other differences though:

• Applets can be moved around on the panel while notification icons are constrained to the system tray. If you accept that notification icons are transient then it isn't that big a deal.
• KDE also implements the system tray spec, so a notification icon can be used on both desktops (plus any other desktop that implements the spec). In contrast, Gnome applets are Bonobo controls which makes them a bit difficult to use on other desktops.
• The panel can merge menu items into the context menu of applets, and supports middle click drag to move applets.
• The system tray is supposed to be able to display "message balloons" for the notification icons. This doesn't seem to work properly though. The reason for getting the system tray to show the balloons is so you don't get multiple applets popping up such notices on top of each other, and to make it easier for the user to manage such notifications.

Due to these differences there are a number of notification icons such as Novell's netapplet which more closely follow the lifecycle of an applet but are notification icons for cross desktop compatibility.

While talking with Mark on IRC, it became apparent that a number of the applets included with Gnome aren't strictly linked to the session's lifetime. For example, my laptop has a PCMCIA wireless adapter, so I put the wireless applet on my panel to show the signal strength. However, it doesn't really make sense to display the applet when the card is unplugged.

Similarly, if I share my home directory between a number of computers, it doesn't make sense to show the volume control applet on systems without a sound card or the battery status applet on systems without a battery. So perhaps these applets shouldn't really be tied to the panel's life cycle.

With infrastructure like NetworkManager where there is a user-level daemon used to communicate with the user when necessary, it would make sense for that daemon to provide network status as notification icons. This way the icons would only appear when the associated device was attached. Something similar could be done for the volume control and battery status applets -- query HAL to see if they need to be loaded.

However, with such long lasting notification icons you probably want some of the features of applets such as being able to move them round a bit. This indicates that it might not make so much sense to make such a big distinction between applets and notification applets.

I wonder how difficult it would be to extend the system tray/notification icon spec to handle the features applets currently have?. From a quick look, the additional features include:

1. Some way for icons to cooperate with the panel to handle moving icons around.
2. Some way to uniquely identify applets so that the panel can place them in the same location next time the icon is created.
3. Provide some standard context menu items. The standard ones that applets have merged in are "Move", "Lock" and "Remove from panel". Only the first two would need additions to handle.
4. Better size negotiation. An applet can query the width and orientation of a panel when deciding what its size should be. I don't think a notification icon can do so.
5. Figure out a good way to start notification icons on session startup.
6. If notifcation icons can be moved to anywhere on the panel, where should truely transient icons be placed the first time? Currently they are placed in the system tray, which provides a convenient place for the user to expect to see such notifications.

This should also make it easier to provide more full featured panel widgets that work cross desktop. I wonder how feasible it is?

Notification Icons

I decided to go ahead and write the code to allow Zenity to listen for commands on stdin. It was pretty easy to add, and Glynn accepted the patch so it is in the latest CVS version. The main difference between the implementation and what I described earlier is that you need to pass the --listen argument to Zenity to activate this mode (without it, it acts as a one-shot notification icon where it exits when the icon is clicked on). The easiest way to use it from a bash script is to tie Zenity to a file descriptor like this:

exec 3> >(zenity --notification --listen)

You can then feed commands to the notification icon by echoing things to that file descriptor. For example:

echo "tooltip: a new tooltip" >&3

The available commands are icon, tooltip and visible. When you've finished and want to kill off the icon, you can simply close the file descriptor:

exec 3>&-

Some things that would be good to add are message balloon support (although the Gnome system tray doesn't seem to support them right now) and support for animated images (useful to get the user's attention while message balloons don't work).

One of the reasons for adding this functionality to Zenity was for use in jhbuild. Davyd did the initial prototype for this, but the idea for the notification icon seemed fairly generic and useful outside of jhbuild. Also, by putting it in Zenity there is less to maintain in jhbuild itself :)

Foundation Elections (continued)

bolsh: as I said, many real elections make modifications to an idealised STV system to simplify vote counting. The counting for the .au senate elections sounds like it takes a random sample of votes when transfering preferences too.

Also, in my description a candidate needed to get more votes than the quota and the quota could be fractional. In contrast, the Australian senate elections say candidates must reach the Droop Quota, which is the smallest integer greater than the quota formula I used. If you are using random sampling for preference transfers so that each ballot has a weight of either 0 or 1, then this is equivalent. However, if you count fractional votes, then it does make a difference.

Since the votes are all collected electionically for the foundation elections, it shouldn't be any more difficult to count the votes exactly (which the pSTV software you pointed out trivial).

I agree that it would be interesting to get people to list preferences on the ballot even if we don't switch to STV for the election (I mentioned this in one of my foundation-list emails). The top 11 preferences could be used to perform the existing vote counting algorithm.

Work

The preview release of Ubuntu will be coming out later today. While most of the work I've been doing is in some of the backend infrastructure rather than packaging, for the past half week I've been helping out with some of the Gnome modifications. I doubt all of the changes will be accepted up stream, but I think a number of them would be welcome changes for Gnome 2.10.

I also now realise how bad the battstat_applet code is, and can understand why Glynn started from scratch. It seems like a good thing to improve for 2.10. Davyd mentioned on IRC that it would be nice if it could work with UPSs as well as laptop batteries. NUT can easily provide all the info that the applet gets from the APM or ACPI code, so this shouldn't be too difficult. I wonder how useful sysadmins would find such a feature?

Thunderbird

The new version of thunderbird looks quite nice. As well as the usual incremental improvements, this release can also act as an RSS reader. It converts items from the feeds into email messages and puts them in the chosen folder. You can then manage them as you would your mail. It's an interesting way of reading sites like planet gnome. If the feeds provide full content like the PG does, then you probably want to turn on the "Show the article summary instead of loading the web page" option. For feeds without much content you can leave that option off and it will load the linked web page instead.

Foundation Elections

There has been talk on the foundation list about changing the vote counting procedure to something more fair. The method being proposed is Single Transferable Vote, which is the same system used within a single electorate for the senate vote in the Australian Federal Election. As with the Australian elections, some people have some trouble understanding exactly how it works, so here is a description.

1. Each voter orders every candidate on their ballot in order of preference. Each ballot is assigned a weight of 1.
2. The ballots are grouped by the first preference.
3. If any candidate's total reaches the quota, then they get in. The quota is chosen such that if there are s seats, then at most s candidates can reach the quota. So a candidate must get more than n/(s + 1) first preference votes in order to reach the quota.
4. If any candidate gets over the quota, then the highest vote getter is elected, and their votes are redistributed at a reduced strength. If x people voted for the candidate, then the weighting of each of the votes is scaled by (x - q)/x where q is the quota (x - q is the number of votes over the quota). The winning candidate's name is removed from all ballots and we go back to step 2 and repeat to find the next winner.
5. If no candidate reaches the quota, then the candidate with the least first preference votes is removed from the election. Their name is removed from all ballots, and we go back to step 2. The votes for the removed candidate are redistributed at the same strength, since they didn't help elect a candidate.

Note that this vote counting system is identical to Instant-runoff voting when there is only a single seat. The quota calculation shows that the winning candidate needs to get more than 50% of the votes to win, as expected.

Some of the nice properties of this system include:

• If you vote for a losing candidate, your vote is transfered at the same strength, so is not wasted. This reduces the risk of voting for a candidate that is unlikely to win.
• Voting for a popular candidate doesn't waste your vote. The portion of your vote that wasn't needed to elect the candidate is redistributed to the next preference. For example, if 50% of people vote for dcamp, but the quota is 10% of the votes, then all his votes will be redistributed to second preference at 80% strength.
• If there are two similar candidates, they shouldn't split the vote in such a way that neither wins. If one candidate gets knocked out, their votes will transfer to the other.

There are some differences between what I described and what is used in the Australian elections. This seems to be to make the process more discrete and easier to count (mostly rounding the various quotas and transfer values). For the foundation election though, I can't see any reason not to use a more exact version.

Zenity Notification Icon

Yesterday Glynn posted about notification icon support in Zenity. His current implementation really only handles one-shot notifications, since the icon disappears and zenity exits when you click the icon.

I talked with him on IRC about adding support for a different mode where you send commands to zenity via stdin, similar to the jhbuild notification icon prototype Davyd did. This would allow you to write bash scripts like this:

exec 3> >(zenity --notification)
echo "icon: someicon" >&3
echo "tooltip: doing some important work" >&3
# do stuff
echo "icon: someothericon" >&3
# do some more stuff
exec 3>&-

This could be very useful for many scripts in addition to jhbuild, which is why I suggested adding it to zenity. Now it just needs implementing ...

linux.conf.au

The LCA2004 team have put together the conference CD and DVD. Apparently they will arrive in the mail in about a week.

They put the CD contents on the web first, and I was a bit disappointed that the recording of my talk was missing (it does include my slides though). However, when they put the DVD contents up I saw that it included a video recording of the talk, which is pretty cool.

There are links to the CD and DVD contents on the wiki. The video recording can be found by following one of the "Explore DVD" links, and looking at the entry second from the bottom. There is also a video of Havoc's keynote in there.

jhbuild

It sounds like Fluendo are looking at using the Subversion support I added to jhbuild. There were a few bugs in the code that jdahlin fixed, but it seems to be working pretty well. I still need to fix up the Arch support so that you don't need tla unless you actually build a module managed by Arch.

I've also dropped one of the old versions of Automake (1.6) from the bootstrap moduleset and sanity checks. Maybe after Gnome 2.8 is out we can clean up the last few modules still requiring Automake 1.4, which should drop the number of Automake versions I need to deal with even further.

Elections

Today is the last day people can enrol to vote in the federal election. Last week we had John Howard defending one of his part members, Trish Worth, for comparing refugees to animals at a forum organised by the group Justice for Refugees.

There is also a Liberal (Peter King) who lost preselection, but is still running as an independent. He has been accused of splitting the conservative vote, which is a bit strange. I'd assume that conservatives who vote for him would give their second preference to the Liberal candidate, and vice versa. What might happen is that Labor voters might pick the independent candidate over the Liberal candidate (this happened in my electorate when a similar thing happened a few years back).

Meanwhile, the National party leader is going round telling people that the Greens are really communists: "They are watermelons. many of them - green on the outside and very, very, very red on the inside."

One other weird thing was the postal vote applications sent out by the current MP. The weird thing was that they came with reply paid envelopes to send the application back to the MP instead of the AEC. She explained why in response to a letter in the local paper, but it still seems a bit weird for the applications to pass through the office of the currently elected member.

Federal Election

So the Federal election has been announced for 9th October. If you are an Australian living overseas, now would be a good time to apply for a postal vote. It'd be great if this gets rid of John Howard. Of course, even if he does win he will probably retire soon after the election ...

Last week, it also turned out that John Howard is a spammer. He paid his son's company to send out unsolicited email to members of his electorate. Apparently our anti-spam laws include exceptions for political parties, so it might not be illegal. However, the Labor party are chasing it up whether it was legal for a third party to send out the spam (since they don't have the protection of the exemption). On the brighter side, it might encourage the politicians to rethink whether the exemptions in the Spam Act are a good idea or not.

Python Unicode Weirdness

While discussing unicode on IRC with owen, we ran into a peculiarity in Python's unicode handling. It can be tested with the following code:

>>> s = u'\U00010001\U00010002'
>>> len(s)
>>> s[0]

Python can be compiled to use either 16-bit or 32-bit widths for characters in its unicode strings (16-bit being the default). When compiled in 32-bit mode, the results of the last two statements are 2 and u'\U00010001' respectively. When compiled in 16-bit mode, the results are 4 and u'\ud800'.

So rather than just being an implementation detail, the unicode string width chosen at compile time can alter the result of Python programs that manipulate characters outside of the basic multilingual plane. It would be nice if Python programs didn't have to care about this sort of detail ...

Oxford

I've been in Oxford for the past week at the Canonical conference. There are lots of great people here, working on a lot of cool projects. Jordi's blog has a lot more info about it.

Bushisms

I found this one quite good.

Compulsory Voting

tberman: I agree that voters should have the right not to vote for anyone, but don't feel that simply not turning up to vote is a good way to do so. In a non-compulsory election, the non-voter count is going to be comprised of those who are abstaining from voting, and those who are simply two lazy to turn up. With compulsory voting, those who don't wish to vote for any particular candidate can simply leave their ballot blank, which is known as an informal vote.

Given the difference in turnout between U.S. and Australian elections, I'd guess that a fair number of the people who don't vote in the U.S. would vote if they had to turn up to a polling place on the day.

I also think it is important for as many people as possible to vote. The people who get elected are supposed to represent the electorate. When there is a clear majority it doesn't matter much, but in a marginal seat, those missing votes could easily swing the result. In this case, people can claim that the winner does not have the support of the majority of the electorate.

As far as the U.S. gravitating towards a two party system, I'd suggest that this is caused more by the vote counting procedure than the culture. When you have a system where where voting for someone who won't get a high first preference count is equivalent to not voting, people are going to gravitate towards the parties where their votes actually make a difference (or not vote at all).

With a preferential system, you can vote for a minor party as your first preference, then number off the major parties with your other preferences. This also fixes the problem where two similar candidates might split the vote causing both to lose -- one will get knocked out, and their votes will be transfered to the next preference (which would likely be the other similar candidate). This generally leads to the least unpopular candidate winning, rather than the most popular one.