I, and most programmers I believe, work in that way that I need a real and useful project when learning a new programming language. So I thought why not re-writing the Roxen Application Launcher I wrote in C#/Mono a couple of years ago in Vala – which by the way is syntactically very, very similar to C# and Java. I’d gotten tired of always having to fiddle with the C# code with every new version of Mono since something always broke when Mono was updated so a re-write wasn’t going to be totally pointless. The good thing about Vala is that the Vala compiler generates C code and that’s what you compile the program from. Fast code and hopefully more mature and stable libraries that won’t break backwards compatibility with every new release.

What about Vala

So, on I went about it and I think that Vala is a really promising language. It’s still a very young language so some library bindings isn’t behaving exactly as expected and the documentation isn’t directly redundant – although the Vala reference documentation site isn’t half bad. But since Vala pretty much is a wrapper for, or binding to, the underlying C libraries you can find answers to your questions that way. All in all I think Vala has a promising future: Way more simple than C and almost as fast and light on memory (remember the Vala compiler generates C code) and way faster than C#/Mono and free from any Microsoft associations .

What about the Roxen Application Launcher

In this new version I utilize GConf for storing application settings. I also made use of – for the first time – the GNU Build Tools for compilation which also makes it easier to distribute and for others to compile from the sources. This also means that the distributed version compiles from the C sources and not the Vala sources so there’s no need for the Vala compiler to build the program.

Other than that there’s nothing fancy about it. The Vala sources is available at my Github repository.

Roxen Appliction Launcher 0.4.2

Screenshots

The screenshots is showing the Swedish translation.

List of downloaded files

Adding support for new file type

The GNOME status icon

From what I understand Vala code is first translated into plain old C code, and then compiled with the ordinary GCC compiler. The benefit is that you don’t have to get head aches about memory management and so forth.

Vala seems pretty interesting and I downloaded it and compiled it without any difficulties. There are precompiled packages for most Linux distros – it’s available in the Ubuntu repository – but since Vala is new and still under development the distro packages is far behind in version.

There’s also a Vala IDE and plugins for GEdit, Anjuta and Eclipse.

Anyway, just to try Vala out I made a little program – using Val(a)ide – that changes the desktop wallpaper on a per interval basis. Send the program a path to a directory with images and the background will change among those images every *nth minutes.

This program needs libgee which at the moment needs to be added manually.

Compile: valac --pkg gconf-2.0 --pkg gee-1.0 --pkg gio-2.0 main.vala -o wallpaper-iterator

/* main.vala
 *
 * Copyright (C) 2009 Pontus Östlund 
 *
 * No license what so ever. Do what ever you like...
 *
 * Author:
 * 	Pontus Östlund 
 */

// GLib isn't really neccessary since it's imported automatically
using GLib, Gee, GConf;

/**
 * User defined exception types
 */
errordomain IOError {
	FILE_NOT_FOUND,
	NOT_A_DIRECTORY
}

/**
 * Main class
 */
public class Main
{
	/**
	 * Used as reference in option parser
	 */
	static int arg_delay;

	/**
	 * Application command line options
	 */
	const OptionEntry[] options = {
		{ "delay", 'd', 0, OptionArg.INT, ref arg_delay,
			"Number of minutes to wait before swapping background", null },
		{ null }
	};

	/**
	 * Main method
	 *
	 * @param args
	 *  Command line arguments
	 */
  public static int main (string[] args)
  {
		try {
			var opt = new OptionContext("\"/path/to/wallpapers\"");
			opt.set_help_enabled(true);
			opt.add_main_entries(options, null);
			opt.parse(ref args);
		}
		catch (GLib.Error e) {
			stderr.printf("Error: %s\n", e.message);
			stderr.printf("Run '%s --help' to see a full list of available "+
			              "options\n", args[0]);
			return 1;
		}

		if (args.length < 2) {
			stderr.printf("Missing argument!\n");
			stderr.printf("Run '%s --help' for usage\n", args[0]);
			return 1;
		}

		// Default time before changing background is 30 minutes
		int delay = arg_delay > 0 ? arg_delay*60 : 60*30;

		try {
			WallpaperIterator bg = new WallpaperIterator(args[1], delay);
			bg.run();
			bg.stop();
		}
		catch (IOError e) {
			stderr.printf("Error: %s\n", e.message);
			return 1;
		}
		finally {
			stderr.printf("Finally block reached!\n");
		}

    return 0;
  }
}

/**
 * Class that handles changeing of desktop wallpapers on a per interval way
 */
public class WallpaperIterator : GLib.Object
{
	/**
	 * Number of seconds to wait before changeing wallpaper
	 */
	private int delay = 0;
	/**
	 * Current index in the images list
	 */
	private int index = 0;
	/**
	 * List of images to change between
	 */
	private ArrayList files = new ArrayList();
	/**
	 * List of allowed content types
	 */
	private ArrayList allow = new ArrayList();
	/**
	 * GConf client object
	 */
	private GConf.Client gclient = null;
	/**
	 * GConf registry where the background image is set
	 */
	private string gconf_key = "/desktop/gnome/background/picture_filename";
	/**
	 * Background being used when the application is started
	 */
	private string default_bg = null;

	/**
	 * Constructor
	 *
	 * @param dir
	 *  The directory to collect wallpapers in
	 * @param delay
	 *  Time to wait - in seconds - before swapping wallpaper
	 */
	public WallpaperIterator(string dir, int delay)
		throws IOError
	{
		assert(delay > 0);

		allow.add("image/jpeg");
		allow.add("image/png");

		var f = File.new_for_path(dir);

		if (!f.query_exists(null))
			throw new IOError.FILE_NOT_FOUND(" \"%s\" doesn't exits!".printf(dir));

		if (f.query_file_type(0, null) != FileType.DIRECTORY) {
			throw new IOError.NOT_A_DIRECTORY(" \"%s\" is not a directory!"
			                                  .printf(dir));
		}

		collect(f.get_path());

		if (files.size < 2) {
			warning("Not enough images found for this application to be useful!\n");
			return;
		}

		this.delay = delay;
	}

	/**
	 * Run the application. Starts a MainLoop
	 */
	public void run()
	{
		gclient = GConf.Client.get_default();
		default_bg = gclient.get_string(gconf_key);

		MainLoop loop = new MainLoop(null, false);
		var time = new TimeoutSource(delay*1000);
		time.set_callback(() => { swap(); });
		time.attach(loop.get_context());
		loop.run();
	}

	/**
	 * Stop the application. Tries to reset the background
	 */
	public void stop()
	{
		try {
			if (default_bg != null)
				gclient.set_string(gconf_key, default_bg);
		}
		catch (GLib.Error e) {
			warning("Failed to restore background!\n");
		}
	}

	/**
	 * Does the actual background swapping
	 */
	private void swap()
	{
		if (index >= files.size) {
			debug("Restart...\n");
			index = 0;
		}

		debug("Callback...%-2d (%s)\n", index, files[index]);

		try {
			gclient.set_string(gconf_key, files[index]);
		}
		catch (GLib.Error e) {
			warning("Failed to set background: %s\n", e.message);
		}
		index++;
	}

	/**
	 * Collect images
	 *
	 * @param path
	 */
	private void collect(string path)
	{
		try {
			var dir = File.new_for_path(path).enumerate_children(
				"standard::name,standard::type,standard::content-type",
				0, null
			);

			FileInfo fi;
			string fp;
			while ((fi = dir.next_file(null)) != null) {
				fp = path + "/" + fi.get_name();
				if (fi.get_file_type() == FileType.DIRECTORY)
					collect(fp);
				else {
					if (fi.get_content_type() in allow)
						files.add(fp);
					else
						warning("Skipping \"%s\" due to unallowed content type\n", fp);
				}
			}
		}
		catch (GLib.Error e) {
			warning("Error: %s\n", e.message);
		}
	}
}

I think Vala looks promising and I will try it out trying to write a more complex application when I find the time.

Font parsing

The first thing to do, and that I have done, is porting my font parser from PLib to C#. That was no major head ache. There are at least to different font classes available in C# Mono (`System.Drawing.Font` and `Pango.Font`) but they don’t give all information about the font that I want.

Worth mentioning is that I heavily used the Mono DataConverter class to unpack the binary strings in the fonts. The unpack() function in PHP is just tremendous and there doesn’t seem to be a native alike in C#. But thanks to Miguel de Icasa’s DataConverter it went quite alright.

Font preview

The next thing to do was figuring out how to create the font previews. And I figured it out First I though of using the console program gnome-thumbnail-font to create the previews but I had to throw that one into the bin since it doesn’t seem to handle multi line text. Since I’ve never used the graphics functions in C# before I came to the conclusion that I had to create the previews all by my self. It was quite easy finding good examples on the net of how to create text images with C#. A couple of hours later that problem was also solved (as you can see in the screen shot below). And man the graphics stuff in C# is fast. The preview images are generated instantly!

Next step

I have a lot left to do before this is a useful program but we’re heading there. One feature I’m planning on implementing is the ability to create your own font sets that you can activate/deactivate.

And I will probably come up with some more stuff to add, but that will be a later head ache!

Screen shot: Gnome Font Manager