Merge lp:~tkk2112/ctk/partial-new-css into lp:ctk

[Thomas Kristensen]

partially implemented new css system

Unmerged revisions

115. By Thomas Kristensen on 2010-05-03

Partially implemented the new stylesheet code.

=== modified file 'configure.ac'
--- configure.ac	2009-11-13 11:52:55 +0000
+++ configure.ac	2010-05-03 20:12:42 +0000
@@ -27,23 +27,21 @@
 GLIB_REQUIRED=2.16.0
 CLUTTER_REQUIRED=1.0.0
 GEE_REQUIRED=0.5.0
-CCSS_REQUIRED=0.5.0
 
 PKG_CHECK_MODULES(GLIB, glib-2.0 >= $GLIB_REQUIRED gobject-2.0 >= $GLIB_REQUIRED)
 PKG_CHECK_MODULES(CLUTTER, clutter-1.0 >= $CLUTTER_REQUIRED)
 PKG_CHECK_MODULES(GEE, gee-1.0 >= $GEE_REQUIRED)
-PKG_CHECK_MODULES(CCSS, ccss-1 >= $CCSS_REQUIRED)
 
-CTK_PKG_DEPS="glib-2.0, gobject-2.0, clutter-1.0, gee-1.0, ccss-1"
+CTK_PKG_DEPS="glib-2.0, gobject-2.0, gio-2.0, clutter-1.0, gee-1.0"
 AC_SUBST(CTK_PKG_DEPS)
 
-CTK_VALAFLAGS="--pkg clutter-1.0 --pkg cogl-1.0 --pkg ccss-1 --pkg gee-1.0"
+CTK_VALAFLAGS="--pkg gio-2.0 --pkg clutter-1.0 --pkg cogl-1.0 --pkg gee-1.0"
 AC_SUBST(CTK_VALAFLAGS)
 
-CTK_CFLAGS="$GLIB_CFLAGS $CLUTTER_CFLAGS $GEE_CFLAGS $CCSS_CFLAGS"
+CTK_CFLAGS="$GLIB_CFLAGS $CLUTTER_CFLAGS $GEE_CFLAGS"
 AC_SUBST(CTK_CFLAGS)
 
-CTK_LIBS="$GLIB_LIBS $CLUTTER_LIBS $GEE_LIBS $CCSS_LIBS"
+CTK_LIBS="$GLIB_LIBS $CLUTTER_LIBS $GEE_LIBS"
 AC_SUBST(CTK_LIBS)
 
 AC_CONFIG_FILES([Makefile

=== modified file 'ctk/Makefile.am'
--- ctk/Makefile.am	2010-01-24 14:59:58 +0000
+++ ctk/Makefile.am	2010-05-03 20:12:42 +0000
@@ -26,6 +26,7 @@
 	scrollview.vala \
 	stylable.vala \
 	style.vala \
+	stylesheet.vala \
 	text-entry.vala \
 	texture-factory.vala \
 	types.vala \

=== modified file 'ctk/adjustment.vala'
--- ctk/adjustment.vala	2010-01-19 08:41:34 +0000
+++ ctk/adjustment.vala	2010-05-03 20:12:42 +0000
@@ -39,6 +39,7 @@
 						this.value_changed_source = Idle.add_full (Clutter.PRIORITY_REDRAW, () => {
 							this.value_changed_source = 0;
 							this.notify_property ("value");
+                            return false;
 						});
 					}
 				}
@@ -60,6 +61,7 @@
 						this.lower_changed_source = Idle.add_full (Clutter.PRIORITY_REDRAW, () => {
 							this.lower_changed_source = 0;
 							this.notify_property ("lower");
+                            return false;
 						});
 					}
 					this.clamp_page (this.lower, this.upper);
@@ -82,6 +84,7 @@
 						this.upper_changed_source = Idle.add_full (Clutter.PRIORITY_REDRAW, () => {
 							this.upper_changed_source = 0;
 							this.notify_property ("upper");
+                            return false;
 						});
 					}
 					this.clamp_page (this.lower, this.upper);
@@ -104,6 +107,7 @@
 						this.step_increment_changed_source = Idle.add_full (Clutter.PRIORITY_REDRAW, () => {
 							this.step_increment_changed_source = 0;
 							this.notify_property ("step-increment");
+                            return false;
 						});
 					}
 				}
@@ -125,6 +129,7 @@
 						this.page_increment_changed_source = Idle.add_full (Clutter.PRIORITY_REDRAW, () => {
 							this.page_increment_changed_source = 0;
 							this.notify_property ("page-increment");
+                            return false;
 						});
 					}
 				}
@@ -146,6 +151,7 @@
 						this.page_size_changed_source = Idle.add_full (Clutter.PRIORITY_REDRAW, () => {
 							this.page_size_changed_source = 0;
 							this.notify_property ("page-size");
+                            return false;
 						});
 					}
 					this.clamp_page (this.lower, this.upper);
@@ -238,6 +244,7 @@
 				this.changed_source = Idle.add_full (Clutter.PRIORITY_REDRAW, () => {
 					this.changed_source = 0;
 					this.changed ();
+                    return false;
 				});
 			}
 		}

=== modified file 'ctk/box.vala'
--- ctk/box.vala	2010-01-25 09:02:47 +0000
+++ ctk/box.vala	2010-05-03 20:12:42 +0000
@@ -70,7 +70,7 @@
 				if (value != null) {
 					this._layout_manager = value;
 					this._layout_manager.set_container (this);
-					this._layout_manager.layout_changed.connect (this.queue_relayout);
+					this._layout_manager.layout_changed.connect (() => this.queue_relayout);
 				}
 				this.queue_relayout ();
 			}

=== modified file 'ctk/button.vala'
--- ctk/button.vala	2009-11-15 21:38:53 +0000
+++ ctk/button.vala	2010-05-03 20:12:42 +0000
@@ -71,11 +71,15 @@
 			this._label = new Clutter.Text();
 
 			this.notify["font-family"].connect(() => {
-				this._label.font_name = this.font_family + " " + this.font_size.to_string() + "px";
+				this._label.font_name = this.get_font_description ();
 			});
 
 			this.notify["font-size"].connect(() => {
-				this._label.font_name = this.font_family + " " + this.font_size.to_string() + "px";
+				this._label.font_name = this.get_font_description ();
+			});
+
+			this.notify["font-weight"].connect(() => {
+				this._label.font_name = this.get_font_description ();
 			});
 
 			this.notify["color"].connect(() => {

=== modified file 'ctk/layout-manager.vala'
--- ctk/layout-manager.vala	2010-01-14 18:04:20 +0000
+++ ctk/layout-manager.vala	2010-05-03 20:12:42 +0000
@@ -96,7 +96,7 @@
 		}
 
 		public virtual Clutter.Alpha begin_animation (ulong mode, uint duration) requires (duration < 1000) {
-			Clutter.Alpha alpha = (Clutter.Alpha) this.get_qdata (quark_layout_alpha);
+			Clutter.Alpha alpha = this.get_qdata<Clutter.Alpha> (quark_layout_alpha);
 			if (alpha != null) {
 				alpha.mode = mode;
 
@@ -121,7 +121,7 @@
 		}
 
 		public virtual double get_animation_progress () {
-			Clutter.Alpha alpha = (Clutter.Alpha) this.get_qdata (quark_layout_alpha);
+			Clutter.Alpha alpha = this.get_qdata<Clutter.Alpha> (quark_layout_alpha);
 			if (alpha == null)
 				return 1.0;
 
@@ -129,7 +129,7 @@
 		}
 
 		public virtual void end_animation () {
-			Clutter.Alpha alpha = (Clutter.Alpha) this.get_qdata (quark_layout_alpha);
+			Clutter.Alpha alpha = this.get_qdata<Clutter.Alpha> (quark_layout_alpha);
 			if (alpha == null)
 				return;
 
@@ -143,7 +143,7 @@
 		}
 
 		public LayoutMeta? get_child_meta (Clutter.Container container, Clutter.Actor actor) {
-			LayoutMeta meta = (LayoutMeta) actor.get_qdata(quark_layout_meta);
+			LayoutMeta meta = actor.get_qdata<LayoutMeta> (quark_layout_meta);
 			if (meta != null) {
 				var child = meta as Clutter.ChildMeta;
 				if (meta.manager == this && child.container == container && child.actor == actor)

=== modified file 'ctk/scrollbar.vala'
--- ctk/scrollbar.vala	2010-01-21 09:27:32 +0000
+++ ctk/scrollbar.vala	2010-05-03 20:12:42 +0000
@@ -35,7 +35,7 @@
 				}
 
 				this._adjustment = value;
-				this._adjustment.changed.connect (this.queue_relayout);
+				this._adjustment.changed.connect (() => this.queue_relayout);
 				this._adjustment.notify["value"].connect (this.update_handle_from_size);
 				this.queue_relayout ();
 			}

=== modified file 'ctk/stylable.vala'
--- ctk/stylable.vala	2009-11-03 12:28:33 +0000
+++ ctk/stylable.vala	2010-05-03 20:12:42 +0000
@@ -4,6 +4,7 @@
 * A Clutter UI toolkit
 *
 * Copyright (C) 2009 Ali Sabil
+* Copyright (C) 2010 Thomas Kristensen
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
@@ -18,8 +19,8 @@
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library. If not, see <http://www.gnu.org/licenses/>.
 *
-* Author:
-* Ali Sabil <[e-mail]>
+* Author: Ali Sabil <[e-mail]>
+*         Thomas Kristensen <[e-mail]>
 *
 */
 
@@ -30,15 +31,12 @@
 			set;
 		}
 
-
 		public abstract void refresh ();
 		public abstract Stylable? get_style_container ();
 		public abstract Stylable? get_style_base ();
 		public abstract string? get_style_id ();
 		public abstract string? get_style_type ();
-		[CCode (array_length = false, array_null_terminated = true)]
-		public abstract string[]? get_style_classes ();
-		[CCode (array_length = false, array_null_terminated = true)]
-		public abstract string[]? get_style_pseudo_classes ();
+		public abstract Gee.Set<string> get_style_classes ();
+		public abstract Gee.Set<string> get_style_pseudo_classes ();
 	}
 }

=== modified file 'ctk/style.vala'
--- ctk/style.vala	2010-01-24 17:06:13 +0000
+++ ctk/style.vala	2010-05-03 20:12:42 +0000
@@ -4,6 +4,7 @@
 * A Clutter UI toolkit
 *
 * Copyright (C) 2009 Ali Sabil
+* Copyright (C) 2010 Thomas Kristensen
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
@@ -18,16 +19,23 @@
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library. If not, see <http://www.gnu.org/licenses/>.
 *
-* Author:
-* Ali Sabil <[e-mail]>
+* Author: Ali Sabil <[e-mail]>
+*         Thomas Kristensen <[e-mail]>
 *
 */
 
 namespace Ctk {
-	public class Style: Object {
+
+    public enum FontWeight {
+        NORMAL,
+        BOLD,
+        LIGHTER,
+        BOLDER
+    }
+    
+    public class Style: Object {
 		private static Style default_style;
-		private CCss.Grammar grammar;
-		private CCss.Stylesheet stylesheet;
+		private Css.Stylesheet stylesheet;
 
 		public signal void changed ();
 
@@ -36,7 +44,7 @@
 			if (rc_file == null) {
 				rc_file = Path.build_filename (Config.PACKAGE_DATADIR, "ctk", "style", "default.css");
 			}
-			this.load_stylesheet (rc_file, CCss.Stylesheet.Precedence.USER_AGENT);
+			this.load_stylesheet (rc_file, Css.Stylesheet.Precedence.USER_AGENT);
 		}
 
 		public static unowned Style get_default () {
@@ -46,11 +54,99 @@
 		}
 
 		public bool load_from_file (string filename) {
-			return this.load_stylesheet (filename, CCss.Stylesheet.Precedence.AUTHOR);
+			return this.load_stylesheet (filename, Css.Stylesheet.Precedence.AUTHOR);
 		}
 
 		public new bool get_property (Stylable target, ParamSpec pspec, out Value value) {
-			value.init (pspec.value_type);
+            value.init (pspec.value_type);
+
+            var properties = this.stylesheet.get_properties (target);
+            
+            stdout.printf("target=%s typeof(%s)\n", target.get_style_id (), target.get_style_type ());
+            stdout.printf("prop size=%d\n", properties.size);
+
+            
+            foreach (var p in properties) {
+                stdout.printf("%s\n", p.key);
+            }
+            var css_value = properties[pspec.name];
+
+            
+
+            if (css_value.source != null)
+                stdout.printf("name=%s\n", css_value.source);
+            if (css_value.value != null)
+                stdout.printf("string=%s\n", css_value.value);
+            if (pspec.name != null)
+                stdout.printf("pname=%s\n", pspec.name);
+
+            if (pspec.value_type == typeof (int)) {
+                if (css_value.value != null)
+                    value.set_int (css_value.value.to_int ());
+                else
+                    value.set_int (0);
+                return true;
+            } else if (pspec.value_type == typeof (uint)) {
+                if (css_value.value != null)
+                    value.set_uint (css_value.value.to_int ());
+                else
+                    value.set_uint (0);
+                return true;
+            }
+            return false;
+            /* else if (pspec.value_type == typeof (BorderImage)) {
+                    
+					unowned Css.Property property;
+
+					if (style.get_property ("border-image", out property)) {
+						unowned Css.BorderImage border_image = (Css.BorderImage) property;
+
+						BorderImage result = BorderImage (border_image.uri);
+
+						if (result.uri != null) {
+							int width, height;
+							result.texture.get_base_size (out width, out height);
+
+							result.top = (float) border_image.top.get_size (height);
+							result.right = (float) border_image.right.get_size (width);
+							result.bottom = (float) border_image.bottom.get_size (height);
+							result.left = (float) border_image.left.get_size (width);
+						}
+
+						value.set_boxed (&result);
+						return true;
+					}
+            } else if (pspec->value_type == MX_TYPE_FONT_WEIGHT)
+            {
+              g_value_init (value, pspec->value_type);
+
+              mx_font_weight_set_from_string (value, css_value->string);
+            }
+            else
+            {
+              GValue strval = { 0, };
+
+              g_value_init (value, pspec->value_type);
+
+              g_value_init (&strval, G_TYPE_STRING);
+              g_value_set_string (&strval, css_value->string);
+
+              if (!g_value_transform (&strval, value))
+                {
+                  g_warning ("Error setting property \"%s\" on \"%s\", could"
+                             " not transform \"%s\" from string to type %s",
+                             pspec->name,
+                             G_OBJECT_CLASS_NAME(G_OBJECT_GET_CLASS (stylable)),
+                             css_value->string,
+                             g_type_name (pspec->value_type));
+                }
+              g_value_unset (&strval);
+            }*/
+        }
+
+
+
+/*			value.init (pspec.value_type);
 
 			if (this.stylesheet != null) {
 				double number = 0.0;
@@ -96,10 +192,10 @@
 						value.set_boxed (&padding);
 					return result;
 				} else if (pspec.value_type == typeof (BorderImage)) {
-					unowned CCss.Property property;
+					unowned Css.Property property;
 
 					if (style.get_property ("border-image", out property)) {
-						unowned CCss.BorderImage border_image = (CCss.BorderImage) property;
+						unowned Css.BorderImage border_image = (Css.BorderImage) property;
 
 						BorderImage result = BorderImage (border_image.uri);
 
@@ -117,10 +213,10 @@
 						return true;
 					}
 				} else if (pspec.value_type == typeof (Clutter.Texture)) {
-					unowned CCss.Property property;
+					unowned Css.Property property;
 
 					if (style.get_property ("background-image", out property)) {
-						unowned CCss.BackgroundImage background_image = (CCss.BackgroundImage) property;
+						unowned Css.BackgroundImage background_image = (Css.BackgroundImage) property;
 
 						if (background_image.uri != null) {
 							var result = TextureFactory.get_default ().get_texture (background_image.uri, true);
@@ -141,136 +237,22 @@
 						}
 					}
 				}
-			}
-			return false;
-		}
-
-		private CCss.Style get_style (Stylable stylable) {
-			var node = new Node (stylable);
-			var style = this.stylesheet.query (node.get_internal_node ());
-			return style;
-		}
-
-		private bool load_stylesheet (string filename, CCss.Stylesheet.Precedence precedence) {
-			if (!FileUtils.test (filename, FileTest.IS_REGULAR)) {
+			}*/
+
+		private bool load_stylesheet (string filename, Css.Stylesheet.Precedence precedence) {
+			if (!FileUtils.test (filename, FileTest.IS_REGULAR))
 				return false;
-			}
 
-			string path = Path.get_dirname (filename);
+            var success = false;
 			if (this.stylesheet == null) {
-				this.grammar = new CCss.Grammar.css ();
-
-				var url_function = new CCss.Function ("url", url_handler);
-				grammar.add_function (url_function);
-
-				// FIXME: memory leak in path
-				this.stylesheet = grammar.create_stylesheet_from_file (filename, (owned) path);
+				this.stylesheet = new Css.Stylesheet ();
+				success = this.stylesheet.add_from_file (filename, precedence);
 			} else {
-				var url_function = new CCss.Function ("url", url_handler);
-				this.grammar.add_function (url_function);
-				this.stylesheet.add_from_file (filename, precedence, (owned) path);
-			}
-			this.changed ();
-			return true;
-		}
-
-		private static string? url_handler (SList<string> args, void* user_data) {
-			string? url = args.data;
-
-			if (url == null || !url.has_prefix ("file://"))
-				return null;
-
-			url = url.substring (7);
-			if (url[0] != '/' && user_data != null) {
-				url = Path.build_filename ((string) user_data, url);
-			}
-
-			if (!FileUtils.test (url, FileTest.IS_REGULAR)) {
-				url = null;
-			}
-			return url;
-		}
-
-		private class Node {
-			private Stylable stylable;
-			private static CCss.NodeClass node_class;
-			private CCss.Node node;
-
-			public Node (Stylable stylable) {
-				this.stylable = stylable;
-
-				this.node_class.get_container = Node.get_style_container;
-				this.node_class.get_id = Node.get_style_id;
-				this.node_class.get_type = Node.get_style_type;
-				this.node_class.get_classes = Node.get_style_classes;
-				this.node_class.get_pseudo_classes = Node.get_style_pseudo_classes;
-				this.node_class.release = Node.style_release;
-
-				this.node = new CCss.Node (this.node_class, 12, this);
-			}
-
-			public unowned CCss.Node get_internal_node () {
-				return this.node;
-			}
-
-			private static CCss.Node? get_style_container (CCss.Node ccss_node) {
-				Node node = ccss_node.get_user_data () as Node;
-
-				if (node != null) {
-					Stylable stylable = node.stylable;
-
-					Clutter.Actor parent = (stylable as Clutter.Actor).get_parent ();
-					if (parent != null) {
-						return new CCss.Node (Node.node_class, 12, parent);
-					}
-				}
-
-				return null;
-			}
-
-			private static string? get_style_id (CCss.Node ccss_node) {
-				Node node = ccss_node.get_user_data () as Node;
-				Stylable stylable = node.stylable;
-				return stylable.get_style_id ();
-			}
-
-			private static string? get_style_type (CCss.Node ccss_node) {
-				Node node = ccss_node.get_user_data () as Node;
-
-				if (node != null) {
-					Stylable stylable = node.stylable;
-					return stylable.get_style_type ();
-				}
-
-				return null;
-			}
-
-			[CCode (array_length = false, array_null_terminated = true)]
-			private static string[]? get_style_classes (CCss.Node ccss_node) {
-				Node node = ccss_node.get_user_data () as Node;
-
-				if (node != null) {
-					Stylable stylable = node.stylable;
-					return stylable.get_style_classes ();
-				}
-
-				return null;
-			}
-
-			[CCode (array_length = false, array_null_terminated = true)]
-			private static string[]? get_style_pseudo_classes (CCss.Node ccss_node) {
-				Node node = ccss_node.get_user_data () as Node;
-
-				if (node != null) {
-					Stylable stylable = node.stylable;
-					return stylable.get_style_pseudo_classes ();
-				}
-
-				return null;
-			}
-
-			private static void style_release (CCss.Node ccss_node) {
-			}
+				success = this.stylesheet.add_from_file (filename, precedence);
+			}
+			if (success)
+                this.changed ();
+			return success;
 		}
 	}
 }

=== added file 'ctk/stylesheet.vala'
--- ctk/stylesheet.vala	1970-01-01 00:00:00 +0000
+++ ctk/stylesheet.vala	2010-05-03 20:12:42 +0000
@@ -0,0 +1,584 @@
+/*
+ * Ctk
+ *
+ * A Clutter UI toolkit
+ *
+ * Copyright (C) 2009 Ali Sabil
+ * Copyright (C) 2010 Thomas Kristensen
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU Lesser General Public License,
+ * version 2.1, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+ * FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Author: Thomas Kristensen <[e-mail]>
+ *
+ * The most of the code was translated from C to Vala, the original code 
+ * had the following Copyright notice:
+ */
+
+/*
+ * Copyright 2009 Intel Corporation.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU Lesser General Public License,
+ * version 2.1, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+ * FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Author: Thomas Wood <[e-mail]>
+ *
+ */
+
+namespace Ctk {
+    namespace Css {
+
+        public struct StyleSheetValue {
+            string value;
+            string source;
+        }
+
+        public class Stylesheet: Object {
+            public enum Precedence {
+                USER_AGENT,
+                USER,
+                AUTHOR
+            }
+
+            private Gee.ArrayList<Gee.HashMap?> styles;
+            private Gee.ArrayList<Selector?> selectors;
+            private Gee.ArrayList<string>? filenames;
+            private Scanner scanner;
+            private weak string filename;
+            private int precedence;
+
+            private struct Selector {
+                string type;
+                string id;
+                string class;
+                string pseudo_class;
+                Selector? parent;
+                Selector? ancestor;
+                Gee.HashMap<string, string> style;
+                string filename;
+                int precedence;
+            }
+
+            private struct SelectorMatch {
+                int id;
+                int precedence;
+                int score;
+            }
+
+            public Stylesheet () {
+                this.styles = new Gee.ArrayList<Gee.HashMap?> ();
+                this.selectors = new Gee.ArrayList<Selector?> ();
+                this.filenames = new Gee.ArrayList<string> ();
+            }
+
+            public bool add_from_file (string filename, Precedence precedence) {
+                if (!FileUtils.test (filename, FileTest.IS_REGULAR))
+                    return false;
+
+                if (this.filenames.contains (filename))
+                    return false;
+
+                this.filename = filename;
+                this.precedence = (int) precedence;
+
+                var result = parse_file (filename);
+
+                if (result)
+                    this.filenames.add (filename);
+
+                return result;
+            }
+
+            private int sort_selector_matches (SelectorMatch a, SelectorMatch b) {
+                int precedence = a.precedence - b.precedence;
+                if (precedence > 0)
+                    return precedence;
+                return a.score - b.score;
+            }
+
+
+            public Gee.HashMap<string, StyleSheetValue?> get_properties (Stylable stylable) {
+                stdout.printf("this.selectors size=%d\n", this.selectors.size);
+
+                var matching_selectors = new Gee.ArrayList<SelectorMatch?> ();
+
+
+                /* find matching selectors */
+                for (var i = 0; i < this.selectors.size; ++i) {
+                    Selector selector = this.selectors[i];
+
+                    var score = node_matches_selector (selector, stylable);
+
+                    stdout.printf("Selector=%s, %s, %s, %s - score=%d", selector.id, selector.type, selector.class, selector.pseudo_class, score);
+
+                    if (score >= 0) {
+                        var selector_match = SelectorMatch ();
+                        selector_match.id = i;
+                        selector_match.precedence = selector.precedence;
+                        selector_match.score = score;
+                        matching_selectors.add (selector_match);
+                    }
+                }
+
+                /* score the selectors by their score */
+                matching_selectors.sort ((CompareFunc) sort_selector_matches);
+
+                /* get properties from selector's styles */
+                var result = new Gee.HashMap<string, StyleSheetValue?> (str_hash, str_equal);
+
+                foreach (var l in matching_selectors) {
+                    Selector selector = this.selectors[l.id];
+
+                    foreach (var element in selector.style) {
+                        var style_sheet_value = StyleSheetValue ();
+                        style_sheet_value.source = selector.filename;
+                        style_sheet_value.value = element.value;
+
+                        result[element.key] = style_sheet_value;
+                    }
+
+                }
+                return result;
+            }
+
+            private int node_matches_selector (Selector selector, Stylable stylable) {
+                var a = 0;
+                var b = 0;
+                var c = 0;
+
+                /* get properties for this stylable */
+                var id = stylable.get_style_id ();
+                var classes = stylable.get_style_classes ();
+                var pseudo_classes = stylable.get_style_pseudo_classes ();
+                var parent = stylable.get_style_container ();
+
+                stdout.printf("target=%s (%s), selector=%s (%s)", id, stylable.get_style_type(), selector.id, selector.type);
+
+                /* check type */
+                if (selector.type == null || selector.type[0] == '*') {
+                    /* null or universal selector match, but are ignored for score */
+                } else {
+                    var type = stylable.get_type ();
+                    var type_name = type.name ();
+                    var matched = 0;
+                    var depth = 10;
+
+                    while (type_name.len () > 0) {
+                        if (selector.type != type_name) {
+                            matched = depth;
+                            break;
+                        } else {
+                            type = type.parent ();
+                            type_name = type.name ();
+                            if (depth > 1)
+                                depth--;
+                        }
+                    }
+
+                    if (matched > 0)
+                        return -1;
+                    else
+                        c += depth;
+                }
+
+                /* check id */
+                if (id == null || selector.id != id)
+                    return -1;
+                else
+                    a += 10;
+
+                /* check psuedo_class */
+                if (pseudo_classes == null|| !(selector.pseudo_class in pseudo_classes))
+                    return -1;
+                else
+                    b += 10;
+
+                /* check class */
+                if (classes == null || !(selector.class in classes))
+                    return -1;
+                else
+                    b += 10;
+
+                /* check parent */
+                if (selector.parent != null) {
+                    if (parent == null)
+                        return -1;
+
+                    var parent_matches = node_matches_selector (selector.parent, parent);
+                    if (parent_matches < 0)
+                        return -1;
+
+                    /* increase the 'c' score, since the parent matched */
+                    c += parent_matches;
+                }
+
+                /* check ancestor */
+                if (selector.ancestor != null) {
+                    if (parent == null)
+                        return -1;
+
+                    var ancestor = parent;
+                    while (ancestor != null) {
+                        var pparent = ancestor.get_style_container ();
+
+                        var ancestor_matches = node_matches_selector (selector.ancestor, ancestor);
+
+                        /* if one of the ancestors match, stop search and increase 'c' score */
+                        if (ancestor_matches >= 0) {
+                            c += ancestor_matches;
+                            break;
+                        }
+
+                        ancestor = pparent;
+                        if (ancestor == null)
+                            return -1;
+                    }
+                }
+                return a * 10000 + b * 100 + c;
+            }
+
+            private bool parse_file (string filename) {
+                var file = File.new_for_path (filename);
+
+                if (!file.query_exists (null)) {
+                    stderr.printf ("File '%s' doesn't exist.\n", file.get_path ());
+                    return false;
+                }
+
+                try {
+                    var in_stream = new DataInputStream (file.read (null));
+                    var data = new StringBuilder ();
+
+                    string line;
+
+                    // Read lines until end of file (null) is reached
+                    while ((line = in_stream.read_line (null, null)) != null) {
+                        data.append (line);
+                    }
+
+                   return parse (data.str); 
+
+                } catch (Error e) {
+                    error ("%s", e.message);
+                }
+                return false;
+            }
+
+
+            private bool parse (string data) {
+
+                this.scanner = new Scanner (null);
+                this.scanner.config.cpair_comment_single = "\x01\n";
+                this.scanner.config.cset_identifier_nth = CharacterSet.a_2_z + "-_0123456789" + CharacterSet.A_2_Z + CharacterSet.LATINS + CharacterSet.LATINC;
+                this.scanner.config.scan_float = false; /* allows scanning '.' */
+                this.scanner.config.scan_hex = false;
+                this.scanner.config.scan_string_sq = false;
+                this.scanner.config.scan_string_dq = false;
+
+                this.scanner.input_text (data, (uint) data.len ());
+
+                var token = this.scanner.peek_next_token ();
+                while (token != TokenType.EOF) {
+                    token = parse_block ();
+
+                    if (token != TokenType.NONE)
+                        break;
+
+                    token = this.scanner.peek_next_token ();
+                }
+
+                if (token == TokenType.EOF)
+                    return true;
+                else
+                    this.scanner.unexp_token (token, null, null, null, "Error", true);
+
+                return false;
+            }
+
+            private TokenType parse_block () {
+                Gee.ArrayList<Selector?> list;
+                var token = parse_ruleset (out list);
+
+                if (token != TokenType.NONE)
+                    return token;
+
+                /* create a hash table for the properties */
+                var table = new Gee.HashMap<string, string> (str_hash, direct_equal);
+                token = parse_style (ref table);
+
+                /* assign all the selectors to this style */
+                foreach (var l in list)
+                    l.style = table;
+
+
+                this.styles.add (table);
+                this.selectors.add_all (list);
+
+                return token;
+            }
+
+            private TokenType parse_ruleset (out Gee.ArrayList<Selector?> selector_list) {
+                selector_list = new Gee.ArrayList<Selector?> ();
+
+                /* parse the first selector, then keep going until we find left curly */
+                var token = this.scanner.peek_next_token ();
+
+                Selector? parent = null;
+                Selector? selector = null;
+
+                while (token != TokenType.LEFT_CURLY) {
+                    stdout.printf("token=%d\n", (int)token);
+                    switch ((int)token) {
+                        case TokenType.IDENTIFIER:
+                        case 42: // '*'
+                        case 35: // '#'
+                        case 46: // '.'
+                        case 58: // ':'
+                            if (selector != null)
+                                parent = selector;
+                            else
+                                parent = null;
+
+                            /* check if there was a previous selector and if so, the new one
+                             * should use the previous selector to match an ancestor */
+
+                            selector = Selector ();
+                            selector.filename = this.filename.dup ();
+                            selector.precedence = this.precedence;
+                            selector_list.add (selector);
+
+                            if (parent != null) {
+                              selector_list.remove (parent);
+                              selector.ancestor = parent;
+                            }
+
+                            token = parse_simple_selector (ref selector);
+                            if (token != TokenType.NONE)
+                                return token;
+
+                            break;
+
+                        case 62: // '>'
+                            this.scanner.get_next_token ();
+                            if (selector == null)
+                                warning ("null parent when parsing '>'");
+
+                            parent = selector;
+
+                            selector = Selector ();
+                            selector.filename = this.filename;
+                            selector_list.add (selector);
+
+                            /* remove parent from list of selectors and link it to the new selector */
+                            selector.parent = parent;
+                            selector_list.remove (parent);
+
+                            token = parse_simple_selector (ref selector);
+                            if (token != TokenType.NONE)
+                                return token;
+
+                            break;
+
+                        case 44: // ','
+                            this.scanner.get_next_token ();
+
+                            selector = Selector ();
+                            selector.filename = this.filename;
+                            selector_list.add (selector);
+
+                            token = parse_simple_selector (ref selector);
+                            if (token != TokenType.NONE)
+                                return token;
+
+                            break;
+
+                        default:
+                            this.scanner.get_next_token ();
+                            this.scanner.unexp_token (TokenType.ERROR, null, null, null, "Unhandled selector", true);
+                            return TokenType.LEFT_CURLY;
+                    }
+                    token = this.scanner.peek_next_token ();
+                }
+
+                return TokenType.NONE;
+            }
+
+            private TokenType parse_simple_selector (ref Selector selector) {
+                /* parse optional type (either '*' or an identifier) */
+                var token = this.scanner.peek_next_token ();
+                switch ((int) token) {
+                    case 42: // '*'
+                        token = this.scanner.get_next_token ();
+                        selector.type = "*";
+                        break;
+                    case TokenType.IDENTIFIER:
+                        token = this.scanner.get_next_token ();
+                        selector.type = this.scanner.value.identifier;
+                        break;
+                    default:
+                        break;
+                }
+
+                /* Here we look for '#', '.' or ':' and return if we find anything else */
+                token = this.scanner.peek_next_token ();
+                while (token != TokenType.NONE) {
+                    switch ((int) token) {
+                        /* id */
+                        case 35: // '#'
+                            token = this.scanner.get_next_token ();
+                            token = this.scanner.get_next_token ();
+                            if (token != TokenType.IDENTIFIER)
+                                return TokenType.IDENTIFIER;
+                            selector.id = this.scanner.value.identifier;
+                            break;
+                        /* class */
+                        case 46: // '.'
+                            token = this.scanner.get_next_token ();
+                            token = this.scanner.get_next_token ();
+                            if (token != TokenType.IDENTIFIER)
+                                return TokenType.IDENTIFIER;
+                            selector.id = this.scanner.value.identifier;
+                            break;
+                        /* pseudo-class */
+                        case 58: // ':'
+                            token = this.scanner.get_next_token ();
+                            token = this.scanner.get_next_token ();
+                            if (token != TokenType.IDENTIFIER)
+                                return TokenType.IDENTIFIER;
+                            selector.id = this.scanner.value.identifier;
+                            break;
+
+                        /* unhandled */
+                        default:
+                            return TokenType.NONE;
+                    }
+                    token = this.scanner.peek_next_token ();
+                }
+                return TokenType.NONE;
+            }
+
+            private TokenType parse_style (ref Gee.HashMap<string, string>  table) {
+                /* { */
+                var token = this.scanner.get_next_token ();
+                if (token != TokenType.LEFT_CURLY)
+                    return TokenType.LEFT_CURLY;
+
+                /* keep going until we find '}' */
+                token = this.scanner.peek_next_token ();
+                while (token != TokenType.RIGHT_CURLY) {
+                    string? key = null;
+                    string? value = null;
+
+                    token = parse_key_value (out key, out value);
+                    if (token != TokenType.NONE)
+                        return token;
+
+                    table[key] = value;
+
+                    token = this.scanner.peek_next_token ();
+                }
+
+                /* } */
+                token = this.scanner.get_next_token ();
+                if (token != TokenType.RIGHT_CURLY)
+                    return TokenType.RIGHT_CURLY;
+
+                return TokenType.NONE;
+            }
+
+            private TokenType  parse_key_value (out string? key, out string? value) {
+                bool start_with_dash = false;
+                string id_first = this.scanner.config.cset_identifier_first;
+                string id_nth = this.scanner.config.cset_identifier_nth;
+                bool scan_identifier_1char = this.scanner.config.scan_identifier_1char;
+
+                /* parse property name */
+                var token = this.scanner.get_next_token ();
+
+                /* allow property names to start with '-' */
+                if ((char) token == '-') {
+                    /* FIXME: this will now ignore whitepsace and comments, but this should
+                    * not be allowed in the middle of a property name! */
+                    token = this.scanner.get_next_token ();
+                    start_with_dash = true;
+                }
+
+                if (token != TokenType.IDENTIFIER)
+                    return TokenType.IDENTIFIER;
+
+                if (start_with_dash)
+                    key = "-".concat (this.scanner.value.identifier);
+                else
+                    key = this.scanner.value.identifier;
+
+                token = this.scanner.get_next_token ();
+                if (token != ':')
+                    return (TokenType) ':';
+
+                /* value parsing options */
+                this.scanner.config.cset_identifier_first = CharacterSet.a_2_z + "#_-0123456789" + CharacterSet.A_2_Z + CharacterSet.LATINS + CharacterSet.LATINC;
+                this.scanner.config.cset_identifier_nth = this.scanner.config.cset_identifier_first;
+                this.scanner.config.scan_identifier_1char = true;
+                this.scanner.config.char_2_token = false;
+                this.scanner.config.cset_skip_characters = "\n";
+
+                /* parse value */
+                while (this.scanner.next_value.char != ';') {
+                    token = this.scanner.get_next_token ();
+                    switch (token) {
+                        case TokenType.IDENTIFIER:
+                            value = value + this.scanner.value.identifier;
+                            break;
+                        case TokenType.CHAR:
+                            var string_builder = new StringBuilder(value);
+                            string_builder.append_c ((char) this.scanner.value.char);
+                            value = string_builder.str;
+                            break;
+
+                        default:
+                            return (TokenType) ';';
+                    }
+
+                    token = this.scanner.peek_next_token ();
+                }
+
+                /* semi colon */
+                token = this.scanner.get_next_token ();
+                if (this.scanner.value.char != ';')
+                    return (TokenType) ';';
+
+                /* we've come to the end of the value, so reset the options */
+                this.scanner.config.cset_identifier_nth = id_nth;
+                this.scanner.config.cset_identifier_first = id_first;
+                this.scanner.config.scan_identifier_1char = scan_identifier_1char;
+                this.scanner.config.char_2_token = true;
+                this.scanner.config.cset_skip_characters = " \t\n";
+
+                /* strip the leading and trailing whitespace */
+                value.strip ();
+
+                return TokenType.NONE;
+            }
+        }
+    }
+}

=== modified file 'ctk/text-entry.vala'
--- ctk/text-entry.vala	2010-01-14 13:48:18 +0000
+++ ctk/text-entry.vala	2010-05-03 20:12:42 +0000
@@ -126,11 +126,15 @@
 			});
 
 			this.notify["font-family"].connect(() => {
-				this._text_actor.font_name = this.font_family + " " + this.font_size.to_string() + "px";
+				this._text_actor.font_name = this.get_font_description ();
 			});
 
 			this.notify["font-size"].connect(() => {
-				this._text_actor.font_name = this.font_family + " " + this.font_size.to_string() + "px";
+				this._text_actor.font_name = this.get_font_description ();
+			});
+
+			this.notify["font-weight"].connect(() => {
+				this._text_actor.font_name = this.get_font_description ();
 			});
 
 			this.notify["color"].connect(() => {

=== modified file 'ctk/widget.vala'
--- ctk/widget.vala	2010-01-23 19:34:51 +0000
+++ ctk/widget.vala	2010-05-03 20:12:42 +0000
@@ -4,6 +4,7 @@
 * A Clutter UI toolkit
 *
 * Copyright (C) 2009 Ali Sabil
+* Copyright (C) 2010 Thomas Kristensen
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
@@ -18,8 +19,8 @@
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library. If not, see <http://www.gnu.org/licenses/>.
 *
-* Author:
-* Ali Sabil <[e-mail]>
+* Author: Ali Sabil <[e-mail]>
+*         Thomas Kristensen <[e-mail]>
 *
 */
 
@@ -108,6 +109,21 @@
 		private uint _font_size = 12;
 
 		[CCode(notify = false)]
+		public FontWeight font_weight {
+			get {
+				return this._font_weight;
+			}
+			set {
+				if (this._font_weight != value) {
+					this._font_weight = value;
+					this.pending_relayout = true;
+					this.notify_property ("font-weight");
+				}
+			}
+		}
+		private FontWeight _font_weight = FontWeight.NORMAL;
+
+		[CCode(notify = false)]
 		public Padding padding {
 			get {
 				return this.children_container.padding;
@@ -338,6 +354,7 @@
 			this.get_property_from_style ("color");
 			this.get_property_from_style ("font-family");
 			this.get_property_from_style ("font-size");
+			this.get_property_from_style ("font-weight");
 			this.get_property_from_style ("opacity");
 			this.get_property_from_style ("padding");
 			this.get_property_from_style ("border-image");
@@ -388,14 +405,43 @@
 			return ((Object) this).get_type().name();
 		}
 
-		[CCode (array_length = false, array_null_terminated = true)]
-		public string[]? get_style_classes () {
-			return (string[]) this.style_classes.to_array ();
-		}
-
-		[CCode (array_length = false, array_null_terminated = true)]
-		public string[]? get_style_pseudo_classes () {
-			return (string[]) this.style_pseudo_classes.to_array ();
-		}
+		public Gee.Set<string> get_style_classes () {
+			return this.style_classes.read_only_view;
+		}
+
+		public Gee.Set<string> get_style_pseudo_classes () {
+			return this.style_pseudo_classes.read_only_view;
+		}
+
+        /* Utilities */
+
+        public string get_font_description () {
+            var font_description = new Pango.FontDescription ();
+            
+            font_description.set_family (this.font_family);
+            font_description.set_absolute_size (this.font_size * 1024 /* PANGO_SCALE */);    
+
+            var weight = Pango.Weight.NORMAL;
+            switch (this.font_weight) {
+                case FontWeight.BOLD:
+                    weight = Pango.Weight.BOLD;
+                    break;
+                case FontWeight.LIGHTER:
+                    weight = Pango.Weight.LIGHT;
+                    break;
+                case FontWeight.BOLDER:
+                    weight = Pango.Weight.HEAVY;
+                    break;
+                default:
+                    weight = Pango.Weight.NORMAL;
+                    break;
+            }
+            
+            font_description.set_weight (weight);
+
+            var description_string = font_description.to_string ();
+            return description_string;
+        }
+
 	}
 }