Merge lp:~teemperor/switchboard-plug-keyboard/fix-layouts into lp:~elementary-pantheon/switchboard-plug-keyboard/trunk

[Raphael Isemann]

Fix the layout panel

Ok, we merge that or we get just flooded with bug-reports as the plug currently doesn't work at all.

[Corentin Noël (tintou)]

Even if it doesn't respect ANY elementary codestyle rule, I approve the bug fix

review: Approve

[ilian (9-ilian)]

I`ve tryed to disable or fully remove Ibus, changing stuff in 'desktop.ibus.general and hotkeys.
Also edited "org.gnome.desktop.input-sources.sources and xkb-options" - no effect
Same with "org.gnome.libgnomekbd.keyboard" my layouts are "['us', 'bg+phonetic']" and options to "['grp\tgrp:alt_shift_toggle']" still shortcut don't working.

review: Approve

=== modified file 'src/Pages/Layout/add_layout.vala'
--- src/Pages/Layout/add_layout.vala	2014-01-06 17:12:27 +0000
+++ src/Pages/Layout/add_layout.vala	2014-08-11 14:54:46 +0000
@@ -1,7 +1,7 @@
-namespace Pantheon.Keyboard.Layout
+namespace Pantheon.Keyboard.LayoutPage
 {
 	// pop over widget to add a new keyboard layout
-	class AddLayout : Gtk.Dialog//Granite.Widgets.PopOver
+	class AddLayout : Gtk.Dialog
 	{
 		public signal void layout_added (int language, int layout = 0);
 
 
=== modified file 'src/Pages/Layout/display.vala'
--- src/Pages/Layout/display.vala	2014-01-06 17:12:27 +0000
+++ src/Pages/Layout/display.vala	2014-08-11 14:54:46 +0000
@@ -1,226 +1,207 @@
-namespace Pantheon.Keyboard.Layout
+namespace Pantheon.Keyboard.LayoutPage
 {
-	// widget to display/add/remove/move keyboard layouts
-	// interacts with class SettingsLayout
-	class Display : Gtk.Grid
-	{
-		private signal void update_buttons ();
-
-		private SettingsLayouts settings;
-		private Gtk.TreeView tree;
-
-		public Display ()
-		{
-			settings = new SettingsLayouts ();
-			var list = make_list_store ();
-			tree     = new Gtk.TreeView.with_model (list);
-			var cell = new Gtk.CellRendererText ();
-
-			tree.insert_column_with_attributes (-1, null, cell, "text", 0);
-			tree.headers_visible = false;
-			tree.expand = true;
-
-			var scroll = new Gtk.ScrolledWindow(null, null);
-			scroll.hscrollbar_policy = Gtk.PolicyType.AUTOMATIC;
-			scroll.vscrollbar_policy = Gtk.PolicyType.AUTOMATIC;
-			scroll.shadow_type = Gtk.ShadowType.IN;
-			scroll.add(tree);
-			scroll.expand = true;
-
-			var tbar = new Gtk.Toolbar();
-			tbar.set_style(Gtk.ToolbarStyle.ICONS);
-			tbar.set_icon_size(Gtk.IconSize.SMALL_TOOLBAR);
-			tbar.set_show_arrow(false);
-			tbar.hexpand = true;
-
-			scroll.get_style_context().set_junction_sides(Gtk.JunctionSides.BOTTOM);
-			tbar.get_style_context().add_class(Gtk.STYLE_CLASS_INLINE_TOOLBAR);
-			tbar.get_style_context().set_junction_sides(Gtk.JunctionSides.TOP);
-
-			var add_button    = new Gtk.ToolButton (null, _("Add…"));
-			var remove_button = new Gtk.ToolButton (null, _("Remove"));
-			var up_button     = new Gtk.ToolButton (null, _("Move up"));
-			var down_button   = new Gtk.ToolButton (null, _("Move down"));
-
-			add_button.set_tooltip_text    (_("Add…"));
-			remove_button.set_tooltip_text (_("Remove"));
-			up_button.set_tooltip_text     (_("Move up"));
-			down_button.set_tooltip_text   (_("Move down"));
-
-			add_button.set_icon_name    ("list-add-symbolic");
-			remove_button.set_icon_name ("list-remove-symbolic");
-			up_button.set_icon_name     ("go-up-symbolic");
-			down_button.set_icon_name   ("go-down-symbolic");
-
-			remove_button.sensitive = false;
-			up_button.sensitive     = false;
-			down_button.sensitive   = false;
-
-			tbar.insert (add_button,    -1);
-			tbar.insert (remove_button, -1);
-			tbar.insert (up_button,     -1);
-			tbar.insert (down_button,   -1);
-
-			this.attach (scroll, 0, 0, 1, 1);
-			this.attach (tbar,   0, 1, 1, 1);
-
-			var pop = new AddLayout ();
-
-			add_button.clicked.connect( () => {
-				// uncomment when reverting to popover
-				//pop.move_to_widget (add_button);
-				// and remove this line
-				pop.show_all ();
-				add_item (tree, pop);
-			} );
-
-			remove_button.clicked.connect( () => {
-				remove_item (tree);
-				update_buttons ();
-			} );
-
-			up_button.clicked.connect (() => {
-				move_item (tree, 0);
-				update_buttons ();
-			} );
-
-			down_button.clicked.connect (() => {
-				move_item (tree, 1);
-				update_buttons ();
-			} );
-
-			tree.cursor_changed.connect (() => {
-				update_buttons ();
-			} );
-
-			this.update_buttons.connect (() =>
-			{
-				Gtk.TreePath path;
-
-				tree.get_cursor (out path, null);
-
-				if (path == null)
-				{
-					up_button.sensitive     = false;
-					down_button.sensitive   = false;
-					remove_button.sensitive = false;
-					return;
-				}
-
-				int index = (path.get_indices ())[0];
-				int count = settings.layouts.length - 1;
-
-				up_button.sensitive     = (index != 0);
-				down_button.sensitive   = (index != count);
-				remove_button.sensitive = (count > 0);
-			} );
-		}
-
-		private Gtk.ListStore make_list_store ()
-		{
-			Gtk.ListStore list_store = new Gtk.ListStore (3, typeof (string), typeof(uint), typeof(uint));
-			Gtk.TreeIter iter;
-
-			uint layout = 0, variant = 0;
-
-			foreach (string item in settings.layouts)
-			{
-				handler.from_code (item, out layout, out variant);
-				item = handler.get_name (layout, variant);
-
-				list_store.append (out iter);
-				list_store.set (iter, 0, item);
-				list_store.set (iter, 1, layout);
-				list_store.set (iter, 2, variant);
-			}
-
-			return list_store;
-		}
-
-		public void reset_all ()
-		{
-			settings.reset_all ();
-			tree.model = make_list_store ();
-			update_buttons ();
-		}
-
-		void add_item (Gtk.TreeView tree, Layout.AddLayout pop)
-		{
-			pop.layout_added.connect ((layout, variant) =>
-			{
-				Gtk.TreeIter iter;
-
-				var name = handler.get_name (layout, variant);
-				var code = handler.get_code (layout, variant);
-				var list = tree.model as Gtk.ListStore;
-
-				if (settings.add_layout (code))
-				{
-					list.append (out iter);
-					list.set (iter, 0, name);
-					list.set (iter, 1, layout);
-					list.set (iter, 2, variant);
-
-					tree.set_cursor (list.get_path(iter), null, false);
-					update_buttons ();
-				}
-			} );
-		}
-
-		void remove_item (Gtk.TreeView tree)
-		{
-			Gtk.TreeModel model;
-			Gtk.TreeIter  iter;
-
-			var select = tree.get_selection();
-			select.get_selected (out model, out iter);
-
-			GLib.Value layout, variant;
-			model.get_value (iter, 1, out layout);
-			model.get_value (iter, 2, out variant);
-
-			settings.remove_layout (handler.get_code ((uint)layout, (uint)variant));
-			stdout.printf ("%s\n", handler.get_code ((uint)layout, (uint)variant));
-			(model as Gtk.ListStore).remove(iter);
-		}
-
-		void move_item (Gtk.TreeView tree, int dir)
-		{
-			Gtk.TreeModel model;
-			Gtk.TreeIter  iter_current, iter_new;
-			Gtk.TreePath  path_current;
-
-			var select = tree.get_selection();
-			select.get_selected (out model, out iter_current);
-			path_current = model.get_path (iter_current);
-
-			iter_new = iter_current;
-
-			var store = model as Gtk.ListStore;
-
-			switch (dir)
-			{
-				case 1: if (model.iter_next (ref iter_new) == false)
-							return;
-						break;
-				case 0: if (model.iter_previous (ref iter_new) == false)
-							return;
-						break;
-			}
-
-			store.swap (iter_current, iter_new);
-
-			tree.set_cursor (model.get_path (iter_current), null, false);
-
-			switch (dir)
-			{
-				case 1:
-						settings.layout_down ((path_current.get_indices()) [0]);
-						break;
-				case 0:
-						settings.layout_up   ((path_current.get_indices()) [0]);
-						break;
-			}
-		}
-	}
+    // widget to display/add/remove/move keyboard layouts
+    class Display : Gtk.Grid
+    {
+
+        LayoutSettings settings;
+        Gtk.TreeView tree;
+        Gtk.ToolButton up_button;
+        Gtk.ToolButton down_button;
+        Gtk.ToolButton add_button;
+        Gtk.ToolButton remove_button;
+
+        /*
+         * Set to true when the user has just clicked on the list to prevent
+         * that settings.layouts.active_changed triggers update_cursor
+         */
+        bool cursor_changing = false;
+
+        public Display ()
+        {
+            settings = LayoutSettings.get_instance ();
+
+            tree     = new Gtk.TreeView ();
+            var cell = new Gtk.CellRendererText ();
+
+            tree.insert_column_with_attributes (-1, null, cell, "text", 0);
+            tree.headers_visible = false;
+            tree.expand = true;
+            rebuild_list ();
+
+            var scroll = new Gtk.ScrolledWindow(null, null);
+            scroll.hscrollbar_policy = Gtk.PolicyType.AUTOMATIC;
+            scroll.vscrollbar_policy = Gtk.PolicyType.AUTOMATIC;
+            scroll.shadow_type = Gtk.ShadowType.IN;
+            scroll.add (tree);
+            scroll.expand = true;
+
+            var tbar = new Gtk.Toolbar();
+            tbar.set_style(Gtk.ToolbarStyle.ICONS);
+            tbar.set_icon_size(Gtk.IconSize.SMALL_TOOLBAR);
+            tbar.set_show_arrow(false);
+            tbar.hexpand = true;
+
+            scroll.get_style_context().set_junction_sides(Gtk.JunctionSides.BOTTOM);
+            tbar.get_style_context().add_class(Gtk.STYLE_CLASS_INLINE_TOOLBAR);
+            tbar.get_style_context().set_junction_sides(Gtk.JunctionSides.TOP);
+
+            add_button    = new Gtk.ToolButton (null, _("Add…"));
+            remove_button = new Gtk.ToolButton (null, _("Remove"));
+            up_button     = new Gtk.ToolButton (null, _("Move up"));
+            down_button   = new Gtk.ToolButton (null, _("Move down"));
+
+            add_button.set_tooltip_text    (_("Add…"));
+            remove_button.set_tooltip_text (_("Remove"));
+            up_button.set_tooltip_text     (_("Move up"));
+            down_button.set_tooltip_text   (_("Move down"));
+
+            add_button.set_icon_name    ("list-add-symbolic");
+            remove_button.set_icon_name ("list-remove-symbolic");
+            up_button.set_icon_name     ("go-up-symbolic");
+            down_button.set_icon_name   ("go-down-symbolic");
+
+            remove_button.sensitive = false;
+            up_button.sensitive     = false;
+            down_button.sensitive   = false;
+
+            tbar.insert (add_button,    -1);
+            tbar.insert (remove_button, -1);
+            tbar.insert (up_button,     -1);
+            tbar.insert (down_button,   -1);
+
+            this.attach (scroll, 0, 0, 1, 1);
+            this.attach (tbar,   0, 1, 1, 1);
+
+            var pop = new AddLayout ();
+
+            add_button.clicked.connect( () => {
+                // uncomment when reverting to popover
+                //pop.move_to_widget (add_button);
+                // and remove this line
+                pop.show_all ();
+                add_item (pop);
+            });
+
+            remove_button.clicked.connect( () => {
+                remove_item ();
+            });
+
+            up_button.clicked.connect (() => {
+                settings.layouts.move_active_layout_up ();
+                rebuild_list ();
+            });
+
+            down_button.clicked.connect (() => {
+                settings.layouts.move_active_layout_down ();
+                rebuild_list ();
+            });
+
+            tree.cursor_changed.connect (() => {
+                cursor_changing = true;
+                int new_index = get_cursor_index ();
+                if (new_index != -1) {
+                    settings.layouts.active = new_index;
+                }
+                update_buttons ();
+
+                cursor_changing = false;
+            });
+
+            settings.layouts.active_changed.connect (() => {
+                if (cursor_changing)
+                    return;
+                update_cursor ();
+            });
+            update_cursor ();
+        }
+
+        public void reset_all ()
+        {
+            settings.reset_all ();
+            rebuild_list ();
+        }
+
+        void update_buttons () {
+                int index = get_cursor_index ();
+
+                // if empty list
+                if (index == -1)
+                {
+                    up_button.sensitive     = false;
+                    down_button.sensitive   = false;
+                    remove_button.sensitive = false;
+                } else {
+                    up_button.sensitive     = (index != 0);
+                    down_button.sensitive   = (index != settings.layouts.length - 1);
+                    remove_button.sensitive = (settings.layouts.length > 0);
+                }
+        }
+
+        /**
+         * Returns the index of the selected layout in the UI.
+         * In case the list contains no layouts, it returns -1.
+         */
+        int get_cursor_index () {
+                Gtk.TreePath path;
+
+                tree.get_cursor (out path, null);
+
+                if (path == null)
+                {
+                    return -1;
+                }
+
+                return (path.get_indices ())[0];
+        }
+
+        void update_cursor () {
+            Gtk.TreePath path = new Gtk.TreePath.from_indices (settings.layouts.active);
+            tree.set_cursor (path, null, false);
+        }
+
+        Gtk.ListStore build_store () {
+            Gtk.ListStore list_store = new Gtk.ListStore (3, typeof (string), typeof(uint), typeof(uint));
+            Gtk.TreeIter iter;
+
+            uint layout = 0, variant = 0;
+
+            for (uint i = 0; i < settings.layouts.length; i++) {
+                string item = settings.layouts.get_layout (i).name;
+                handler.from_code (item, out layout, out variant);
+                item = handler.get_name (layout, variant);
+
+                list_store.append (out iter);
+                list_store.set (iter, 0, item);
+                list_store.set (iter, 1, layout);
+                list_store.set (iter, 2, variant);
+            }
+            return list_store;
+        }
+
+        void rebuild_list () {
+            tree.model = build_store ();
+            update_cursor ();
+            update_buttons ();
+        }
+
+        void remove_item ()
+        {
+            settings.layouts.remove_active_layout ();
+            rebuild_list ();
+        }
+
+        void add_item (LayoutPage.AddLayout pop)
+        {
+            pop.layout_added.connect ((layout, variant) => {
+
+                var name = handler.get_name (layout, variant);
+                var code = handler.get_code (layout, variant);
+
+                // TODO variant
+                settings.layouts.add_layout (new Layout.XKB (code, ""));
+                rebuild_list ();
+            });
+        }
+    }
 }
 \ No newline at end of file
 
=== modified file 'src/Pages/Layout/handler.vala'
--- src/Pages/Layout/handler.vala	2014-01-06 17:12:27 +0000
+++ src/Pages/Layout/handler.vala	2014-08-11 14:54:46 +0000
@@ -1,85 +1,84 @@
-namespace Pantheon.Keyboard.Layout
+namespace Pantheon.Keyboard.LayoutPage
 {
 	// class that parses the layout file, provides lists of languages and
-	// variants, and converts between layout names and their gsettings codes	
+	// variants, and converts between layout names and their gsettings codes
 	class LayoutHandler : GLib.Object
 	{
-		Layout[]  layouts;
-	
+		InternalLayout[]  layouts;
+
 		private string[] names;
 		private string[] codes;
-	
+
 		public LayoutHandler ()
 		{
 			foreach (var l in parse_layouts ())
 			{
 				var parts = l.split(":", 2);
-			
+
 				names += parts[0];
 				codes += parts[1];
-			
-				layouts += new Layout (parse_variants (l));
+
+				layouts += new InternalLayout (parse_variants (l));
 			}
 		}
-		
+
 		public string[] get_layouts () {
 			return names;
 		}
-		
+
 		public string[] get_variants (uint index) {
 			return layouts[index].names;
 		}
-		
+
 		public string get_code (uint l, uint v)
 		{
 			if (v != 0)
-				return codes[l] + "\t" + layouts[l].codes[v];
+				return codes[l] + "+" + layouts[l].codes[v];
 			return codes[l];
 		}
-		
+
 		public string get_name (uint l, uint v)
 		{
 			if (v != 0)
 				return layouts[l].names[v];
 			return names[l];
 		}
-		
+
 		public bool from_code (string code, out uint l, out uint v)
 		{
-			var parts = code.split("\t", 2);
-			
+			var parts = code.split("+", 2);
+
 			l = v = 0;
-			
+
 			if (parts[0] == null) return false;
-			
+
 			while (codes[l] != parts[0])
 				if (l++ > codes.length)
 					return false;
-			
+
 			if (parts[1] == null) return true;
-			
+
 			while (layouts[l].codes[v] != parts[1])
 				if (v++ > layouts[l].codes.length)
 					return false;
-			
+
 			return true;
 		}
 
 		// private class that contains the variants of one language
-		private class Layout : GLib.Object
-		{
+		private class InternalLayout : GLib.Object {
 			public string[] names;
 			public string[] codes;
 
-			public Layout( string[] variants )
+			public InternalLayout (string[] variants )
 			{
 				names += _("Default");
 				codes += "";
-			
+
 				foreach (var v in variants)
 				{
 					var parts = v.split(":", 2);
-			
+
 					names += parts[0];
 					codes += parts[1];
 				}
@@ -90,7 +89,7 @@
 		private string[]? parse_layouts ()
 		{
 			string[] return_val = null;
-	
+
 			var file = File.new_for_path (Build.PKGDATADIR + "/layouts.txt");
 
 			if (!file.query_exists ()) {
@@ -100,23 +99,23 @@
 
 			try {
 				var dis = new DataInputStream (file.read ());
-	
+
 				string line;
-	
+
 				while ((line = dis.read_line (null)) != null)
 					if( "#" in line )
 						return_val += line.replace ("#", "");
 			} catch (Error e) {
 				error ("%s", e.message);
 			}
-	
+
 			return return_val;
 		}
 
 		private string[]? parse_variants (string language)
 		{
 			string[] return_val = null;
-	
+
 			var file = File.new_for_path (Build.PKGDATADIR + "/layouts.txt");
 
 			if (!file.query_exists ()) {
@@ -126,11 +125,11 @@
 
 			try {
 				var dis = new DataInputStream (file.read ());
-	
+
 				string line;
-	
+
 				while ((line = dis.read_line (null)) != null) {
-					if (line == "#"+language) {
+					if (line == "#" + language) {
 						while ((line = dis.read_line (null)) != null) {
 							if( "#" in line ) break;
 							return_val += line;
 
=== modified file 'src/Pages/Layout/settings.vala'
--- src/Pages/Layout/settings.vala	2014-01-06 17:12:27 +0000
+++ src/Pages/Layout/settings.vala	2014-08-11 14:54:46 +0000
@@ -1,156 +1,372 @@
-namespace Pantheon.Keyboard.Layout
+namespace Pantheon.Keyboard.LayoutPage
 {
-	// class to interact with gsettings and add/remove keyboard layouts
-	class SettingsLayouts : Granite.Services.Settings
-	{
-		public string[] layouts { get; set; }
-		
-		public void validate ()
-		{
-			string[] copy = {};
-			foreach (string str in layouts)
-			{
-				//if (handler.valid_code(str))
-					copy += str;
-			}
-			layouts = copy;
-		}
-		
-		public bool add_layout (string layout)
-		{
-			foreach (string str in layouts)
-			{
-				if (str == layout)
-					return false;
-			}
-			string[] val = layouts;
-			val += layout;
-			layouts = val;
-			return true;
-		}
-		
-		public void remove_layout (string layout)
-		{
-			string[] val = {};
-			
-			foreach (string str in layouts)
-			{
-				if (str != layout)
-					val += str;
-			}
-			layouts = val;
-		}
-		
-		public void layout_up (int i)
-		{
-			var l = layouts;
-			var tmp = l[i];
-			l[i] = l[i-1];
-			l[i-1] = tmp;
-			layouts = l;
-		}
-		
-		public void layout_down (int i)
-		{
-			var l = layouts;
-			var tmp = l[i];
-			l[i] = l[i+1];
-			l[i+1] = tmp;
-			layouts = l;
-		}
-		
-		public string[]? parse_default ()
-		{
-			string[] return_val = null;
-	
-			var file = File.new_for_path ("/etc/default/keyboard");
-
-			if (!file.query_exists ())
-			{
-				warning ("File '%s' doesn't exist.\n", file.get_path ());
-				return null;
-			}
-
-			string xkb_layout  = "";
-			string xkb_variant = "";
-
-			try
-			{
-				var dis = new DataInputStream (file.read ());
-	
-				string line;
-	
-				while ((line = dis.read_line (null)) != null)
-				{
-					if (line.contains ("XKBLAYOUT="))
-					{
-						xkb_layout = line.replace ("XKBLAYOUT=", "").replace ("\"", "");
-						
-						while ((line = dis.read_line (null)) != null) {
-							if (line.contains ("XKBVARIANT=")) {
-								xkb_variant = line.replace ("XKBVARIANT=", "").replace ("\"", "");
-							}
-						}
-						
-						break;
-					}
-				}
-			}
-
-			catch (Error e)
-			{
-				error ("%s", e.message);
-			}
-			
-			var variants = xkb_variant.split (",");
-			var layouts  = xkb_layout.split (",");
-			
-			for (int i = 0; i < layouts.length; i++)
-			{
-				if (variants[i] != null && variants[i] != "")
-					return_val += layouts[i] + "\t" + variants[i];
-				else
-					return_val += layouts[i];
-			}
-			
-			return return_val;
-		}
-		
-		public void reset_all ()
-		{
-			layouts = parse_default ();
-			validate ();
-			reverted ();
-		}
-		
-		public signal void reverted ();
-		
-		public SettingsLayouts()
-		{
-			base ("org.gnome.libgnomekbd.keyboard");
-			
-			if (layouts == null || layouts.length == 0)
-				layouts = parse_default ();
-			
-			validate ();
-		}
-	}
-	
-	// allows for multiple kayboard layouts at a time
-	class SettingsGroups : Granite.Services.Settings
-	{
-		public int  default_group    { get; set; }
-		public bool group_per_window { get; set; }
-		
-		public void reset_all ()
-		{
-			schema.reset ("default-group");
-			schema.reset ("group-per-window");	
-		}
-		
-		public SettingsGroups()
-		{
-			base ("org.gnome.libgnomekbd.desktop");
-		}
-	}
+
+    /**
+     * Type of a keyboard-layout as described in the description of
+     * "org.gnome.desktop.input-sources sources".
+     */
+    enum LayoutType { IBUS, XKB }
+
+    /**
+     * Immutable class that respresents a keyboard-layout according to
+     * "org.gnome.desktop.input-sources sources".
+     * This means that the enum parameter @layout_type equals the first string in the
+     * tupel of strings, and the @name parameter equals the second string.
+     */
+    class Layout {
+
+        public LayoutType layout_type { get; private set; }
+        public string name { get; private set; }
+
+        public Layout (LayoutType layout_type, string name) {
+            this.layout_type = layout_type;
+            this.name = name;
+        }
+
+        public Layout.XKB (string layout, string? variant) {
+            string full_name = layout;
+            if (variant != null && variant != "")
+                full_name += "+" + variant;
+            this (LayoutType.XKB, full_name);
+        }
+
+        public Layout.from_variant (GLib.Variant variant) {
+            if (variant.is_of_type (new VariantType ("(ss)"))) {
+                unowned string type;
+                unowned string name;
+
+                variant.get ("(&s&s)", out type, out name);
+
+                if (type == "xkb") {
+                    layout_type = LayoutType.XKB;
+                } else if (type == "ibus") {
+                    layout_type = LayoutType.IBUS;
+                } else {
+                    warning ("Unkown type %s", type);
+                }
+                this.name = name;
+
+            } else {
+                warning ("Variant has invalid type");
+            }
+        }
+
+        public bool equal (Layout other) {
+            return this.layout_type == other.layout_type && this.name == other.name;
+        }
+
+        /**
+         * GSettings saves values in the form of GLib.Variant and this
+         * function creates a Variant representing this object.
+         */
+        public GLib.Variant to_variant () {
+            string type_name = "";
+            switch (layout_type) {
+                case LayoutType.IBUS:
+                    type_name = "ibus";
+                    break;
+                case LayoutType.XKB:
+                    type_name = "xkb";
+                    break;
+                default:
+                    error ("You need to implemnt this for all possible values of"
+                           + "the LayoutType-enum");
+            }
+            GLib.Variant first = new GLib.Variant.string (type_name);
+            GLib.Variant second = new GLib.Variant.string (name);
+            GLib.Variant result = new GLib.Variant.tuple ({first, second});
+
+            return result;
+        }
+
+    }
+
+    /**
+     * Represents a list of layouts.
+     */
+    class LayoutList : Object {
+
+        GLib.List<Layout> layouts = new GLib.List<Layout> ();
+
+        // signals
+        public signal void layouts_changed ();
+        public signal void active_changed ();
+
+        public uint length {
+            get {
+                return layouts.length ();
+            }
+        }
+
+        uint _active;
+        public uint active {
+            get {
+                return _active;
+            }
+            set {
+                if (length == 0)
+                    return;
+
+                if (_active == value)
+                    return;
+
+                _active = value;
+                if (_active >= length)
+                    _active = length - 1;
+                active_changed ();
+            }
+
+        }
+
+        public bool contains_layout (Layout given_layout) {
+            return get_layout_index (given_layout) != -1;
+        }
+
+        public int get_layout_index (Layout given_layout) {
+            int i = 0;
+            foreach (Layout l in layouts) {
+                if (l.equal (given_layout))
+                    return i;
+                i++;
+            }
+            return -1;
+        }
+
+        private void switch_items (uint pos1, uint pos2) {
+            unowned List<Layout> container1 = layouts.nth (pos1);
+            unowned List<Layout> container2 = layouts.nth (pos2);
+            Layout tmp = container1.data;
+            container1.data = container2.data;
+            container2.data = tmp;
+
+            if (active == pos1)
+                active = pos2;
+            else if (active == pos2)
+                active = pos1;
+
+            layouts_changed ();
+        }
+
+        public void move_active_layout_up () {
+            if (length == 0)
+                return;
+
+            // check that the active item is not the first one
+            if (active > 0) {
+                switch_items (active, active - 1);
+            }
+        }
+
+        public void move_active_layout_down () {
+            if (length == 0)
+                return;
+
+            // check that the active item is not the last one
+            if (active < length - 1) {
+                switch_items (active, active + 1);
+            }
+        }
+
+        public bool add_layout (Layout new_layout) {
+            if (! contains_layout (new_layout)) {
+                layouts.append (new_layout);
+                layouts_changed ();
+                return true;
+            }
+            return false;
+        }
+
+        public void remove_active_layout () {
+            layouts.remove (get_layout (active));
+
+            if (active >= length)
+                active = length - 1;
+            layouts_changed ();
+        }
+
+        public void remove_all () {
+            layouts = new GLib.List<Layout> ();
+            layouts_changed ();
+        }
+
+        /**
+         * This method does not need call layouts_changed in any situation
+         * as a Layout-Object is immutable.
+         */
+        public Layout? get_layout (uint index) {
+            if (index >= length)
+                return null;
+
+            return layouts.nth_data (index);
+        }
+
+    }
+
+    class LayoutSettings
+    {
+
+        public LayoutList layouts { get; private set; }
+
+        GLib.Settings settings;
+
+        /**
+         * True if and only if we are currently writing to gsettings
+         * by ourselves.
+         */
+        bool currently_writing;
+
+        void write_list_to_gsettings () {
+            currently_writing = true;
+            try {
+                Variant[] elements = {};
+                for (uint i = 0; i < layouts.length; i++) {
+                    elements += layouts.get_layout (i).to_variant ();
+                }
+                GLib.Variant list = new GLib.Variant.array (new VariantType ("(ss)"), elements);
+                settings.set_value ("sources", list);
+            } finally {
+                currently_writing = false;
+            }
+        }
+
+        void write_active_to_gsettings () {
+            uint active = layouts.active;
+            settings.set_uint ("current", active);
+        }
+
+        void update_list_from_gsettings () {
+            // We currently write to gsettings, so we caused this signal
+            // and therefore don't need to read the list again from dconf
+            if (currently_writing)
+                return;
+
+            GLib.Variant sources = settings.get_value ("sources");
+            if (sources.is_of_type (VariantType.ARRAY)) {
+                for(size_t i = 0; i < sources.n_children (); i++) {
+                    GLib.Variant child = sources.get_child_value (i);
+                    layouts.add_layout (new Layout.from_variant (child));
+                }
+            } else {
+                warning ("Unkown type");
+            }
+        }
+
+        void update_active_from_gsettings () {
+            layouts.active = settings.get_uint ("current");
+        }
+
+        bool _per_window;
+        public bool per_window {
+            get {
+                return _per_window;
+            }
+            set {
+                if (value != _per_window) {
+                    settings.set_boolean ("per-window", value);
+                    _per_window = value;
+                }
+            }
+        }
+        // signal when the variable per_window is changed by gsettings
+        public signal void per_window_changed ();
+
+        public void parse_default () {
+            var file = File.new_for_path ("/etc/default/keyboard");
+
+            if (!file.query_exists ()) {
+                warning ("File '%s' doesn't exist.\n", file.get_path ());
+                return;
+            }
+
+            string xkb_layout  = "";
+            string xkb_variant = "";
+
+            try {
+                var dis = new DataInputStream (file.read ());
+
+                string line;
+
+                while ((line = dis.read_line (null)) != null)
+                {
+                    if (line.contains ("XKBLAYOUT="))
+                    {
+                        xkb_layout = line.replace ("XKBLAYOUT=", "").replace ("\"", "");
+
+                        while ((line = dis.read_line (null)) != null) {
+                            if (line.contains ("XKBVARIANT=")) {
+                                xkb_variant = line.replace ("XKBVARIANT=", "").replace ("\"", "");
+                            }
+                        }
+
+                        break;
+                    }
+                }
+            }
+            catch (Error e) {
+                warning ("%s", e.message);
+                return;
+            }
+
+            var variants = xkb_variant.split (",");
+            var xkb_layouts  = xkb_layout.split (",");
+
+            for (int i = 0; i < layouts.length; i++) {
+                if (variants[i] != null && variants[i] != "")
+                    layouts.add_layout (new Layout (LayoutType.XKB, xkb_layouts[i] + "+" + variants[i]));
+                else
+                    layouts.add_layout (new Layout (LayoutType.XKB, xkb_layouts[i]));
+            }
+        }
+
+        public void reset_all ()
+        {
+            layouts.remove_all ();
+            parse_default ();
+        }
+
+        // singleton pattern
+        static LayoutSettings? instance;
+        public static LayoutSettings get_instance () {
+            if (instance == null) {
+                instance = new LayoutSettings ();
+            }
+            return instance;
+        }
+
+        private LayoutSettings ()
+        {
+            settings = new Settings ("org.gnome.desktop.input-sources");
+            layouts = new LayoutList ();
+
+            _per_window = settings.get_boolean ("per-window");
+            settings.changed["per-window"].connect (() => {
+                _per_window = settings.get_boolean ("per-window");
+                per_window_changed ();
+            });
+
+            update_list_from_gsettings ();
+            update_active_from_gsettings ();
+
+            layouts.layouts_changed.connect (() => {
+                write_list_to_gsettings ();
+            });
+
+            layouts.active_changed.connect (() => {
+                write_active_to_gsettings ();
+            });
+
+            settings.changed["sources"].connect (() => {
+                update_list_from_gsettings ();
+            });
+
+            settings.changed["current"].connect (() => {
+                update_active_from_gsettings ();
+            });
+
+            if (layouts.length == 0)
+                parse_default ();
+
+        }
+    }
+
 }
 \ No newline at end of file
 
=== modified file 'src/Pages/layout.vala'
--- src/Pages/layout.vala	2014-01-06 17:12:27 +0000
+++ src/Pages/layout.vala	2014-08-11 14:54:46 +0000
@@ -1,12 +1,12 @@
-namespace Pantheon.Keyboard.Layout
+namespace Pantheon.Keyboard.LayoutPage
 {
 	// global handler
 	LayoutHandler handler;
 
 	class Page : Pantheon.Keyboard.AbstractPage
 	{
-		private Layout.Display display;
-		private SettingsGroups settings;
+		private LayoutPage.Display display;
+		private LayoutSettings settings;
 
 		public override void reset ()
 		{
@@ -18,18 +18,14 @@
 		public Page ()
 		{
 			handler  = new LayoutHandler ();
+			settings = LayoutSettings.get_instance ();
 
 			// first some labels
 			var label_1   = new Gtk.Label (_("Allow different layouts for individual windows:"));
-			var label_2   = new Gtk.Label (_("New windows use:"));
 
 			label_1.valign = Gtk.Align.CENTER;
 			label_1.halign = Gtk.Align.END;
-			label_2.valign = Gtk.Align.CENTER;
-			label_2.halign = Gtk.Align.END;
-
 			this.attach (label_1, 4, 0, 1, 1);
-			this.attach (label_2, 4, 1, 1, 1);
 
 			// widgets to change settings
 			var switch_main = new Gtk.Switch();
@@ -37,52 +33,20 @@
 			switch_main.halign = Gtk.Align.START;
 			switch_main.valign = Gtk.Align.CENTER;
 
-			var button1 = new Gtk.RadioButton.with_label(null, _("Default layout"));
-			var button2 = new Gtk.RadioButton.with_label_from_widget (button1, _("Previous window's layout"));
-
 			this.attach (switch_main, 5, 0, 1, 1);
-			this.attach (button1,     5, 1, 1, 1);
-			this.attach (button2,     5, 2, 1, 1);
-
-			settings = new Layout.SettingsGroups();
-
-			// connect switch signals
-			switch_main.active = settings.group_per_window;
-
-			button1.sensitive = button2.sensitive = switch_main.active;
-			label_2.sensitive = switch_main.active;
-
-			switch_main.notify["active"].connect( () => {
-				settings.group_per_window = switch_main.active;
-				button1.sensitive = button2.sensitive = switch_main.active;
-				label_2.sensitive = switch_main.active;
-			} );
-
-			settings.changed["group-per-window"].connect (() => {
-				switch_main.active = settings.group_per_window;
-				button1.sensitive = button2.sensitive = switch_main.active;
-				label_2.sensitive = switch_main.active;
-			} );
-
-			// connect radio button signals
-			if( settings.default_group >= 0 )
-				button1.active = true;
-			else
-				button2.active = true;
-
-			button1.toggled.connect (() => { settings.default_group =  0; } );
-			button2.toggled.connect (() => { settings.default_group = -1; } );
-
-			settings.changed["default-group"].connect (() =>
-			{
-				if( settings.default_group >= 0 )
-					button1.active = true;
-				else
-					button2.active = true;
-			} );
+
+            switch_main.active = settings.per_window;
+
+			switch_main.notify["active"].connect(() => {
+                settings.per_window = switch_main.active;
+			});
+            settings.per_window_changed.connect (() => {
+                switch_main.active = settings.per_window;
+            });
+
 
 			// tree view to display the current layouts
-			display = new Layout.Display ();
+			display = new LayoutPage.Display ();
 
 			this.attach (display, 0, 0, 4, 4);
 
 
=== modified file 'src/keyboard.vala'
--- src/keyboard.vala	2014-08-03 01:16:31 +0000
+++ src/keyboard.vala	2014-08-11 14:54:46 +0000
@@ -17,41 +17,31 @@
             var stack_switcher = new Gtk.StackSwitcher ();
             stack_switcher.set_stack (stack);
             stack_switcher.halign = Gtk.Align.CENTER;
-            
+
             stack.add_titled (new Keyboard.Shortcuts.Page (), "shortcuts", _("Shortcuts"));
             stack.add_titled (new Keyboard.Behaviour.Page (), "behavior", _("Behavior"));
-            stack.add_titled (new Keyboard.Layout.Page (), "layout", _("Layout"));
+            stack.add_titled (new Keyboard.LayoutPage.Page (), "layout", _("Layout"));
             stack.add_titled (new Keyboard.Options.Page (), "options", _("Options"));
 
-            // button to reset the current page
-            /*var button = new Gtk.Button.with_label (_("Reset to defaults"));
-
-            button.expand = false;
-            button.halign = Gtk.Align.END;
-
-            button.clicked.connect (() => {
-                pages[notebook.page].reset ();
-            });*/
-
             grid.attach (stack_switcher, 0, 0, 1, 1);
             grid.attach (stack, 0, 1, 1, 1);
         }
         grid.show_all ();
         return grid;
     }
-    
+
     public override void shown () {
-        
+
     }
-    
+
     public override void hidden () {
-        
+
     }
-    
+
     public override void search_callback (string location) {
-    
+
     }
-    
+
     // 'search' returns results like ("Keyboard → Behavior → Duration", "keyboard<sep>behavior")
     public override async Gee.TreeMap<string, string> search (string search) {
         return new Gee.TreeMap<string, string> (null, null);
@@ -62,4 +52,4 @@
     debug ("Activating Keyboard plug");
     var plug = new Pantheon.Keyboard.Plug ();
     return plug;
-}
+}
 \ No newline at end of file