October 25, 2009 Linux, Programming , , , No comments
Useful 404 page
A change of times

Vala – the new programming language for Gnome

This Friday when I read the last issue (in Sweden) of Linux Format there was an article on a new programming language named Vala. The goal for Vala is to provide a modern programming language for, primarily, developing Gnome applications. There is of course Mono, but Vala doesn’t run in a virtual machine but is complied to machine code. But Vala resembles C# syntactically and has borrowed a lot of concepts from C#.

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

239 lines of Vala
  1. /* main.vala
  2. *
  3. * Copyright (C) 2009 Pontus Östlund <spam@poppa.se>
  4. *
  5. * No license what so ever. Do what ever you like...
  6. *
  7. * Author:
  8. * Pontus Östlund <spam@poppa.se>
  9. */
  11. // GLib isn't really neccessary since it's imported automatically
  12. using GLib, Gee, GConf;
  14. /**
  15. * User defined exception types
  16. */
  17. errordomain IOError {
  18. FILE_NOT_FOUND,
  19. NOT_A_DIRECTORY
  20. }
  22. /**
  23. * Main class
  24. */
  25. public class Main
  26. {
  27. /**
  28. * Used as reference in option parser
  29. */
  30. static int arg_delay;
  32. /**
  33. * Application command line options
  34. */
  35. const OptionEntry[] options = {
  36. { "delay", 'd', 0, OptionArg.INT, ref arg_delay,
  37. "Number of minutes to wait before swapping background", null },
  38. { null }
  39. };
  41. /**
  42. * Main method
  43. *
  44. * @param args
  45. * Command line arguments
  46. */
  47. public static int main (string[] args)
  48. {
  49. try {
  50. var opt = new OptionContext("\"/path/to/wallpapers\"");
  51. opt.set_help_enabled(true);
  52. opt.add_main_entries(options, null);
  53. opt.parse(ref args);
  54. }
  55. catch (GLib.Error e) {
  56. stderr.printf("Error: %s\n", e.message);
  57. stderr.printf("Run '%s --help' to see a full list of available "+
  58. "options\n", args[0]);
  59. return 1;
  60. }
  62. if (args.length < 2) {
  63. stderr.printf("Missing argument!\n");
  64. stderr.printf("Run '%s --help' for usage\n", args[0]);
  65. return 1;
  66. }
  68. // Default time before changing background is 30 minutes
  69. int delay = arg_delay > 0 ? arg_delay*60 : 60*30;
  71. try {
  72. WallpaperIterator bg = new WallpaperIterator(args[1], delay);
  73. bg.run();
  74. bg.stop();
  75. }
  76. catch (IOError e) {
  77. stderr.printf("Error: %s\n", e.message);
  78. return 1;
  79. }
  80. finally {
  81. stderr.printf("Finally block reached!\n");
  82. }
  84. return 0;
  85. }
  86. }
  88. /**
  89. * Class that handles changeing of desktop wallpapers on a per interval way
  90. */
  91. public class WallpaperIterator : GLib.Object
  92. {
  93. /**
  94. * Number of seconds to wait before changeing wallpaper
  95. */
  96. private int delay = 0;
  97. /**
  98. * Current index in the images list
  99. */
  100. private int index = 0;
  101. /**
  102. * List of images to change between
  103. */
  104. private ArrayList<string> files = new ArrayList<string>();
  105. /**
  106. * List of allowed content types
  107. */
  108. private ArrayList<string> allow = new ArrayList<string>();
  109. /**
  110. * GConf client object
  111. */
  112. private GConf.Client gclient = null;
  113. /**
  114. * GConf registry where the background image is set
  115. */
  116. private string gconf_key = "/desktop/gnome/background/picture_filename";
  117. /**
  118. * Background being used when the application is started
  119. */
  120. private string default_bg = null;
  122. /**
  123. * Constructor
  124. *
  125. * @param dir
  126. * The directory to collect wallpapers in
  127. * @param delay
  128. * Time to wait - in seconds - before swapping wallpaper
  129. */
  130. public WallpaperIterator(string dir, int delay)
  131. throws IOError
  132. {
  133. assert(delay > 0);
  135. allow.add("image/jpeg");
  136. allow.add("image/png");
  138. var f = File.new_for_path(dir);
  140. if (!f.query_exists(null))
  141. throw new IOError.FILE_NOT_FOUND(" \"%s\" doesn't exits!".printf(dir));
  143. if (f.query_file_type(0, null) != FileType.DIRECTORY) {
  144. throw new IOError.NOT_A_DIRECTORY(" \"%s\" is not a directory!"
  145. .printf(dir));
  146. }
  148. collect(f.get_path());
  150. if (files.size < 2) {
  151. warning("Not enough images found for this application to be useful!\n");
  152. return;
  153. }
  155. this.delay = delay;
  156. }
  158. /**
  159. * Run the application. Starts a MainLoop
  160. */
  161. public void run()
  162. {
  163. gclient = GConf.Client.get_default();
  164. default_bg = gclient.get_string(gconf_key);
  166. MainLoop loop = new MainLoop(null, false);
  167. var time = new TimeoutSource(delay*1000);
  168. time.set_callback(() => { swap(); });
  169. time.attach(loop.get_context());
  170. loop.run();
  171. }
  173. /**
  174. * Stop the application. Tries to reset the background
  175. */
  176. public void stop()
  177. {
  178. try {
  179. if (default_bg != null)
  180. gclient.set_string(gconf_key, default_bg);
  181. }
  182. catch (GLib.Error e) {
  183. warning("Failed to restore background!\n");
  184. }
  185. }
  187. /**
  188. * Does the actual background swapping
  189. */
  190. private void swap()
  191. {
  192. if (index >= files.size) {
  193. debug("Restart...\n");
  194. index = 0;
  195. }
  197. debug("Callback...%-2d (%s)\n", index, files[index]);
  199. try {
  200. gclient.set_string(gconf_key, files[index]);
  201. }
  202. catch (GLib.Error e) {
  203. warning("Failed to set background: %s\n", e.message);
  204. }
  205. index++;
  206. }
  208. /**
  209. * Collect images
  210. *
  211. * @param path
  212. */
  213. private void collect(string path)
  214. {
  215. try {
  216. var dir = File.new_for_path(path).enumerate_children(
  217. "standard::name,standard::type,standard::content-type",
  218. 0, null
  219. );
  221. FileInfo fi;
  222. string fp;
  223. while ((fi = dir.next_file(null)) != null) {
  224. fp = path + "/" + fi.get_name();
  225. if (fi.get_file_type() == FileType.DIRECTORY)
  226. collect(fp);
  227. else {
  228. if (fi.get_content_type() in allow)
  229. files.add(fp);
  230. else
  231. warning("Skipping \"%s\" due to unallowed content type\n", fp);
  232. }
  233. }
  234. }
  235. catch (GLib.Error e) {
  236. warning("Error: %s\n", e.message);
  237. }
  238. }
  239. }

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

Drop a comment