Fix srcdir != builddir build of St.gir

We need to use st_cflags which has -I$(srcdir) not ST_CFLAGS
when building St.gir.

.gitignore

@@ -38,5 +38,7 @@ src/gnomeshell-taskpanel
 src/gnome-shell
 src/test-recorder
 src/test-recorder.ogg
+src/test-theme
 stamp-h1
+tests/run-test.sh
 xmldocs.make

Makefile.am

@@ -1,13 +1,22 @@
-SUBDIRS = data js src po
+SUBDIRS = data js src tests po
 
 EXTRA_DIST =		\
 	.project	\
-	.settings
+	.settings	\
+	autogen.sh
+
+# These are files checked into Git that we don't want to distribute
+DIST_EXCLUDE =					\
+	.gitignore				\
+	gnome-shell.doap			\
+	MAINTAINERS				\
+	tools/build/*
 
 distcheck-hook:
-	@echo "Checking disted javascript against files in git"
+	@echo "Checking disted files against files in git"
 	@failed=false; \
-	for f in `cd $(srcdir) && git ls-files js` ; do \
+	exclude=`(for p in $(DIST_EXCLUDE) ; do echo --exclude=$$p ; done)`; \
+	for f in `cd $(srcdir) && git ls-files $$exclude` ; do \
 		if ! test -e $(distdir)/$$f ; then \
 			echo File missing from distribution: $$f ; \
 			failed=true ; \

configure.ac

@@ -1,4 +1,4 @@
-AC_INIT(gnome-shell, 2.27.3)
+AC_INIT(gnome-shell, 2.28.0)
 
 AC_CONFIG_AUX_DIR(config)
 
@@ -57,6 +57,7 @@ PKG_CHECK_MODULES(MUTTER_PLUGIN, gio-unix-2.0 gtk+-2.0 dbus-glib-1 mutter-plugin
                                  gnome-desktop-2.0 >= 2.26 libstartup-notification-1.0
                                  gobject-introspection-1.0 >= 0.6.5)
 PKG_CHECK_MODULES(TIDY, clutter-1.0)
+PKG_CHECK_MODULES(ST, clutter-1.0 gtk+-2.0 libcroco-0.6)
 PKG_CHECK_MODULES(BIG, clutter-1.0 gtk+-2.0 librsvg-2.0)
 PKG_CHECK_MODULES(GDMUSER, dbus-glib-1 gtk+-2.0)
 PKG_CHECK_MODULES(TRAY, gtk+-2.0)
@@ -128,5 +129,6 @@ AC_OUTPUT([
   js/misc/Makefile
   js/ui/Makefile
   src/Makefile
+  tests/Makefile
   po/Makefile.in
 ])

data/Makefile.am

@@ -12,9 +12,8 @@ gnome-shell.desktop.in: gnome-shell.desktop.in.in
 gnome-shell.desktop: gnome-shell.desktop.in
 	$(AM_V_GEN) sed s/^_// < $< > $@ || rm $@
 
-imagedir = $(pkgdatadir)/images
-
-dist_image_DATA =		\
+imagesdir = $(pkgdatadir)/images
+dist_images_DATA =				\
 	add-workspace.svg			\
 	app-well-glow.png			\
 	back.svg				\
@@ -24,6 +23,15 @@ dist_image_DATA =		\
 	magnifier.svg				\
 	remove-workspace.svg
 
+themedir = $(pkgdatadir)/theme
+dist_theme_DATA =				\
+	theme/gnome-shell.css			\
+	theme/scroll-button-down.png		\
+	theme/scroll-button-down-hover.png	\
+	theme/scroll-button-up.png		\
+	theme/scroll-button-up-hover.png	\
+	theme/scroll-vhandle.png
+
 schemadir  = @GCONF_SCHEMA_FILE_DIR@
 schema_DATA = gnome-shell.schemas
 

data/theme/gnome-shell.css

@@ -0,0 +1,176 @@
+/* Copyright 2009, Red Hat, Inc.
+ *
+ * Portions adapted from Mx's data/style/default.css
+ *   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.
+ */
+
+StScrollBar
+{
+  background-color: #354761;
+  padding: 0px;
+}
+
+StScrollView
+{
+  scrollbar-width: 16px;
+  scrollbar-height: 16px;
+}
+
+StButton#up-stepper
+{
+  border-image: url("scroll-button-up.png") 5;
+}
+
+StButton#up-stepper:hover,
+StButton#up-stepper:active
+{
+  border-image: url("scroll-button-up-hover.png") 5;
+}
+
+StButton#down-stepper
+{
+  border-image: url("scroll-button-down.png") 5;
+}
+
+StButton#down-stepper:hover,
+StButton#down-stepper:active
+{
+  border-image: url("scroll-button-down-hover.png") 5;
+}
+
+StScrollBar StButton#vhandle
+{
+  border-image: url("scroll-vhandle.png") 5;
+}
+
+StScrollBar StButton#vhandle:hover
+{
+  border-image: url("scroll-vhandle.png") 5;
+}
+
+/* Panel */
+
+.panel-button {
+    padding: 4px 12px 3px;
+    border-radius: 5px;
+    font: 16px sans-serif;
+    color: white;
+}
+
+.panel-button:active, .panel-button:checked {
+    background-color: #314a6c;
+}
+
+/* LookingGlass */
+
+#LookingGlassDialog
+{
+  background-color: rgba(0,0,0,0.85);
+  spacing: 4px;
+  padding: 4px;
+  border: 1px solid rgba(0,0,172,0.85);
+  border-radius: 4px;
+
+  color: #88ff66;
+}
+
+#LookingGlassDialog > #Toolbar
+{
+  border: 1px solid grey;
+  border-radius: 4px;
+}
+
+#LookingGlassDialog StLabel
+{
+  color: #88ff66;
+}
+
+#LookingGlassDialog StEntry
+{
+  color: #88ff66;
+}
+
+#LookingGlassDialog StBoxLayout#EvalBox
+{
+  padding: 4px;
+  spacing: 4px;
+}
+
+/* Calendar popup */
+
+#calendarPopup {
+    border-radius: 5px;
+    background: rgba(0,0,0,0.9);
+    border: 1px solid rgba(128,128,128,0.45);
+    color: white;
+}
+
+#calendarPopup .calendar {
+    padding: 10px;
+}
+
+.calendar {
+    spacing-rows: 5px;
+    spacing-columns: 3px;
+}
+
+.calendar-change-month {
+    padding: 2px;
+}
+
+.calendar-change-month:hover {
+    background: #314a6c;
+    border-radius: 5px;
+}
+
+.calendar-change-month:active {
+    background: #213050;
+    border-radius: 5px;
+}
+
+.calendar-day {
+    padding: 1px 2px;
+}
+
+.calendar-today {
+    font-weight: bold;
+    background: #ffffff;
+    color: black;
+    border-radius: 5px;
+}
+
+.calendar-other-month-day {
+    color: #cccccc;
+}
+
+/* App Switcher */
+.switcher-list {
+    background: rgba(0,0,0,0.8);
+    border: 1px solid rgba(128,128,128,0.40);
+    border-radius: 8px;
+    padding: 18px;
+}
+
+.switcher-list .item-box {
+    padding: 8px;
+    border-radius: 4px;
+}
+
+.switcher-list .selected-item-box {
+    padding: 8px;
+    border-radius: 4px;
+    background: rgba(255,255,255,0.33);
+}

js/misc/Makefile.am

@@ -1,4 +1,5 @@
 jsmiscdir = $(pkgdatadir)/js/misc
 
 dist_jsmisc_DATA =		\
-	docInfo.js
+	docInfo.js		\
+	format.js

js/misc/format.js

@@ -0,0 +1,44 @@
+/* -*- mode: js2; js2-basic-offset: 4; indent-tabs-mode: nil -*- */
+
+/*
+ * This function is intended to extend the String object and provide
+ * an String.format API for string formatting.
+ * It has to be set up using String.prototype.format = Format.format;
+ * Usage:
+ * "somestring %s %d".format('hello', 5);
+ * It supports %s, %d and %f, for %f it also support precisions like
+ * "%.2f".format(1.526)
+ */
+
+function format() {
+    let str = this;
+    let i = 0;
+    let args = arguments;
+
+    return str.replace(/%(?:\.([0-9]+))?(.)/g, function (str, precisionGroup, genericGroup) {
+
+                    if (precisionGroup != '' && genericGroup != 'f')
+                        throw new Error("Precision can only be specified for 'f'");
+
+                    switch (genericGroup) {
+                        case '%':
+                            return '%';
+                            break;
+                        case 's':
+                            return args[i++].toString();
+                            break;
+                        case 'd':
+                            return parseInt(args[i++]);
+                            break;
+                        case 'f':
+                            if (precisionGroup == '')
+                                return parseFloat(args[i++]);
+                            else
+                                return parseFloat(args[i++]).toFixed(parseInt(precisionGroup));
+                            break;
+                        default:
+                            throw new Error('Unsupported conversion character %' + genericGroup);
+                    }
+                    return ""; // Suppress warning
+                });
+}

js/ui/Makefile.am

@@ -5,11 +5,14 @@ dist_jsui_DATA =		\
 	appDisplay.js		\
 	appIcon.js		\
 	button.js		\
+	calendar.js		\
 	chrome.js		\
 	dash.js			\
 	dnd.js			\
 	docDisplay.js		\
+	environment.js		\
 	genericDisplay.js	\
+	lightbox.js		\
 	link.js			\
 	lookingGlass.js		\
 	main.js			\
@@ -17,6 +20,7 @@ dist_jsui_DATA =		\
 	panel.js		\
 	places.js		\
 	runDialog.js		\
+	shellDBus.js		\
 	sidebar.js		\
 	tweener.js		\
 	widget.js		\

js/ui/altTab.js

@@ -2,33 +2,38 @@
 
 const Big = imports.gi.Big;
 const Clutter = imports.gi.Clutter;
+const Gdk = imports.gi.Gdk;
 const Lang = imports.lang;
+const Mainloop = imports.mainloop;
 const Meta = imports.gi.Meta;
 const Pango = imports.gi.Pango;
 const Shell = imports.gi.Shell;
+const Signals = imports.signals;
+const St = imports.gi.St;
 
+const AppIcon = imports.ui.appIcon;
 const Main = imports.ui.main;
-const Tweener = imports.ui.tweener;
 
-const POPUP_BG_COLOR = new Clutter.Color();
-POPUP_BG_COLOR.from_pixel(0x00000080);
-const POPUP_INDICATOR_COLOR = new Clutter.Color();
-POPUP_INDICATOR_COLOR.from_pixel(0xf0f0f0ff);
-const POPUP_TRANSPARENT = new Clutter.Color();
-POPUP_TRANSPARENT.from_pixel(0x00000000);
+const POPUP_ARROW_COLOR = new Clutter.Color();
+POPUP_ARROW_COLOR.from_pixel(0xffffffff);
+const TRANSPARENT_COLOR = new Clutter.Color();
+TRANSPARENT_COLOR.from_pixel(0x00000000);
+const POPUP_SEPARATOR_COLOR = new Clutter.Color();
+POPUP_SEPARATOR_COLOR.from_pixel(0x80808066);
 
-const POPUP_INDICATOR_WIDTH = 4;
-const POPUP_GRID_SPACING = 8;
-const POPUP_ICON_SIZE = 48;
-const POPUP_NUM_COLUMNS = 5;
+const POPUP_APPICON_SIZE = 96;
+const POPUP_LIST_SPACING = 8;
 
-const POPUP_LABEL_MAX_WIDTH = POPUP_NUM_COLUMNS * (POPUP_ICON_SIZE + POPUP_GRID_SPACING);
+const POPUP_POINTER_SELECTION_THRESHOLD = 3;
 
-const OVERLAY_COLOR = new Clutter.Color();
-OVERLAY_COLOR.from_pixel(0x00000044);
+const THUMBNAIL_SIZE = 256;
+const THUMBNAIL_POPUP_TIME = 1000; // milliseconds
 
-const SHOW_TIME = 0.05;
-const SWITCH_TIME = 0.1;
+const HOVER_TIME = 500; // milliseconds
+
+function mod(a, b) {
+    return (a + b) % b;
+}
 
 function AltTabPopup() {
     this._init();
@@ -36,244 +41,639 @@ function AltTabPopup() {
 
 AltTabPopup.prototype = {
     _init : function() {
-        this.actor = new Big.Box({ background_color : POPUP_BG_COLOR,
-                                   corner_radius: POPUP_GRID_SPACING,
-                                   padding: POPUP_GRID_SPACING,
-                                   spacing: POPUP_GRID_SPACING,
-                                   orientation: Big.BoxOrientation.VERTICAL });
+        this.actor = new Clutter.Group({ reactive: true,
+                                         x: 0,
+                                         y: 0,
+                                         width: global.screen_width,
+                                         height: global.screen_height });
 
-        // Icon grid.  TODO: Investigate Nbtk.Grid once that lands.  Currently
-        // just implemented using a chain of Big.Box.
-        this._grid = new Big.Box({ spacing: POPUP_GRID_SPACING,
-                                   orientation: Big.BoxOrientation.VERTICAL });
-        let gcenterbox = new Big.Box({ orientation: Big.BoxOrientation.HORIZONTAL,
-                                       x_align: Big.BoxAlignment.CENTER });
-        gcenterbox.append(this._grid, Big.BoxPackFlags.NONE);
-        this.actor.append(gcenterbox, Big.BoxPackFlags.NONE);
+        this.actor.connect('destroy', Lang.bind(this, this._onDestroy));
 
-        // Selected-window label
-        this._label = new Clutter.Text({ font_name: "Sans 16px",
-                                         ellipsize: Pango.EllipsizeMode.END });
+        this._haveModal = false;
 
-        let labelbox = new Big.Box({ background_color: POPUP_INDICATOR_COLOR,
-                                     corner_radius: POPUP_GRID_SPACING / 2,
-                                     padding: POPUP_GRID_SPACING / 2 });
-        labelbox.append(this._label, Big.BoxPackFlags.NONE);
-        let lcenterbox = new Big.Box({ orientation: Big.BoxOrientation.HORIZONTAL,
-                                       x_align: Big.BoxAlignment.CENTER,
-                                       width: POPUP_LABEL_MAX_WIDTH + POPUP_GRID_SPACING });
-        lcenterbox.append(labelbox, Big.BoxPackFlags.NONE);
-        this.actor.append(lcenterbox, Big.BoxPackFlags.NONE);
-
-        // Indicator around selected icon
-        this._indicator = new Big.Rectangle({ border_width: POPUP_INDICATOR_WIDTH,
-                                              corner_radius: POPUP_INDICATOR_WIDTH / 2,
-                                              border_color: POPUP_INDICATOR_COLOR,
-                                              color: POPUP_TRANSPARENT });
-        this.actor.append(this._indicator, Big.BoxPackFlags.FIXED);
-
-        this._items = [];
-        this._toplevels = global.window_group.get_children();
+        this._currentApp = 0;
+        this._currentWindows = [];
+        this._thumbnailTimeoutId = 0;
 
         global.stage.add_actor(this.actor);
-
-        // Dark translucent window used to cover all but the
-        // currently-selected window while Alt-Tabbing. Actually
-        // contains four actors which can we rearrange to create
-        // a hole in the overlay.
-        this._overlay = new Clutter.Group({ reactive: true });
-        this._overlay_top = new Clutter.Rectangle({ color: OVERLAY_COLOR,
-                                                    border_width: 0 });
-        this._overlay_bottom = new Clutter.Rectangle({ color: OVERLAY_COLOR,
-                                                       border_width: 0 });
-        this._overlay_left = new Clutter.Rectangle({ color: OVERLAY_COLOR,
-                                                     border_width: 0 });
-        this._overlay_right = new Clutter.Rectangle({ color: OVERLAY_COLOR,
-                                                      border_width: 0 });
-        this._overlay.add_actor(this._overlay_top);
-        this._overlay.add_actor(this._overlay_bottom);
-        this._overlay.add_actor(this._overlay_left);
-        this._overlay.add_actor(this._overlay_right);
     },
 
-    addWindow : function(win) {
-        let item = { window: win,
-                     metaWindow: win.get_meta_window() };
+    show : function(backward) {
+        let appMonitor = Shell.AppMonitor.get_default();
+        let apps = appMonitor.get_running_apps ("");
 
-        let pixbuf = item.metaWindow.icon;
-        item.icon = new Clutter.Texture({ width: POPUP_ICON_SIZE,
-                                          height: POPUP_ICON_SIZE,
-                                          keep_aspect_ratio: true });
-        Shell.clutter_texture_set_from_pixbuf(item.icon, pixbuf);
+        if (!apps.length)
+            return false;
 
-        item.box = new Big.Box({ padding: POPUP_INDICATOR_WIDTH * 2 });
-        item.box.append(item.icon, Big.BoxPackFlags.NONE);
+        if (!Main.pushModal(this.actor))
+            return false;
+        this._haveModal = true;
 
-        item.above = null;
-        for (let i = 1; i < this._toplevels.length; i++) {
-            if (this._toplevels[i] == win) {
-                item.above = this._toplevels[i - 1];
-                break;
-            }
+        this._keyPressEventId = global.stage.connect('key-press-event', Lang.bind(this, this._keyPressEvent));
+        this._keyReleaseEventId = global.stage.connect('key-release-event', Lang.bind(this, this._keyReleaseEvent));
+
+        this._motionEventId = this.actor.connect('motion-event', Lang.bind(this, this._mouseMoved));
+        this._mouseActive = false;
+        this._mouseMovement = 0;
+
+        this._appSwitcher = new AppSwitcher(apps);
+        this.actor.add_actor(this._appSwitcher.actor);
+        this._appSwitcher.connect('item-activated', Lang.bind(this, this._appActivated));
+        this._appSwitcher.connect('item-hovered', Lang.bind(this, this._appHovered));
+
+        let primary = global.get_primary_monitor();
+        this._appSwitcher.actor.x = primary.x + Math.floor((primary.width - this._appSwitcher.actor.width) / 2);
+        this._appSwitcher.actor.y = primary.y + Math.floor((primary.height - this._appSwitcher.actor.height) / 2);
+
+        this._appIcons = this._appSwitcher.icons;
+
+        // _currentWindows give the index of the selected window for
+        // each app; they all start at 0.
+        this._currentWindows = this._appIcons.map(function (app) { return 0; });
+
+        // Make the initial selection
+        if (this._appIcons.length == 1) {
+            if (!backward && this._appIcons[0].windows.length > 1) {
+                // For compatibility with the multi-app case below
+                this._select(0, 1);
+            } else
+                this._select(0);
+        } else if (backward) {
+            this._select(this._appIcons.length - 1);
+        } else {
+            if (this._appIcons[0].windows.length > 1) {
+                let curAppNextWindow = this._appIcons[0].windows[1];
+                let nextAppWindow = this._appIcons[1].windows[0];
+
+                // If the next window of the current app is more-recently-used
+                // than the first window of the next app, then select it.
+                if (curAppNextWindow.get_workspace() == global.screen.get_active_workspace() &&
+                    curAppNextWindow.get_user_time() > nextAppWindow.get_user_time())
+                    this._select(0, 1);
+                else
+                    this._select(1);
+            } else
+                this._select(1);
         }
 
-        item.visible = item.metaWindow.showing_on_its_workspace();
-
-        if (!item.visible) {
-            let rect = new Meta.Rectangle();
-            if (item.metaWindow.get_icon_geometry(rect))
-                item.icon_rect = rect;
+        // There's a race condition; if the user released Alt before
+        // we got the grab, then we won't be notified. (See
+        // https://bugzilla.gnome.org/show_bug.cgi?id=596695 for
+        // details.) So we check now. (Have to do this after updating
+        // selection.)
+        let mods = global.get_modifier_keys();
+        if (!(mods & Gdk.ModifierType.MOD1_MASK)) {
+            this._finish();
+            return false;
         }
 
-        item.n = this._items.length;
-        this._items.push(item);
-
-        // Add it to the grid
-        if (!this._gridRow || this._gridRow.get_children().length == POPUP_NUM_COLUMNS) {
-            this._gridRow = new Big.Box({ spacing: POPUP_GRID_SPACING,
-                                          orientation: Big.BoxOrientation.HORIZONTAL });
-            this._grid.append(this._gridRow, Big.BoxPackFlags.NONE);
-        }
-        this._gridRow.append(item.box, Big.BoxPackFlags.NONE);
+        return true;
     },
 
-    show : function(initialSelection) {
-        global.window_group.add_actor(this._overlay);
-        this._overlay.raise_top();
-        this._overlay.show();
-        this.actor.opacity = 0;
-        Tweener.addTween(this.actor, { opacity: 255,
-                                       time: SHOW_TIME,
-                                       transition: "easeOutQuad" });
+    _nextApp : function() {
+        return mod(this._currentApp + 1, this._appIcons.length);
+    },
+    _previousApp : function() {
+        return mod(this._currentApp - 1, this._appIcons.length);
+    },
 
-        this.actor.show_all();
-        this.actor.x = Math.floor((global.screen_width - this.actor.width) / 2);
-        this.actor.y = Math.floor((global.screen_height - this.actor.height) / 2);
+    _nextWindow : function() {
+        return mod(this._currentWindows[this._currentApp] + 1,
+                   this._appIcons[this._currentApp].windows.length);
+    },
+    _previousWindow : function() {
+        return mod(this._currentWindows[this._currentApp] - 1,
+                   this._appIcons[this._currentApp].windows.length);
+    },
 
-        this.select(initialSelection);
+    _keyPressEvent : function(actor, event) {
+        let keysym = event.get_key_symbol();
+        let shift = (Shell.get_event_state(event) & Clutter.ModifierType.SHIFT_MASK);
+
+        // The WASD stuff is for debugging in Xephyr, where the arrow
+        // keys aren't mapped correctly
+
+        if (keysym == Clutter.Tab)
+            this._select(shift ? this._previousApp() : this._nextApp());
+        else if (keysym == Clutter.grave)
+            this._select(this._currentApp, shift ? this._previousWindow() : this._nextWindow());
+        else if (keysym == Clutter.Escape)
+            this.destroy();
+        else if (this._thumbnails) {
+            if (keysym == Clutter.Left || keysym == Clutter.a)
+                this._select(this._currentApp, this._previousWindow());
+            else if (keysym == Clutter.Right || keysym == Clutter.d)
+                this._select(this._currentApp, this._nextWindow());
+            else if (keysym == Clutter.Up || keysym == Clutter.w)
+                this._select(this._currentApp, null, true);
+        } else {
+            if (keysym == Clutter.Left || keysym == Clutter.a)
+                this._select(this._previousApp());
+            else if (keysym == Clutter.Right || keysym == Clutter.d)
+                this._select(this._nextApp());
+            else if (keysym == Clutter.Down || keysym == Clutter.s)
+                this._select(this._currentApp, this._currentWindows[this._currentApp]);
+        }
+
+        return true;
+    },
+
+    _keyReleaseEvent : function(actor, event) {
+        let keysym = event.get_key_symbol();
+
+        if (keysym == Clutter.Alt_L || keysym == Clutter.Alt_R)
+            this._finish();
+
+        return true;
+    },
+
+    _appActivated : function(appSwitcher, n) {
+        Main.activateWindow(this._appIcons[n].windows[this._currentWindows[n]]);
+        this.destroy();
+    },
+
+    _appHovered : function(appSwitcher, n) {
+        if (!this._mouseActive)
+            return;
+
+        this._select(n, this._currentWindows[n]);
+    },
+
+    _windowActivated : function(thumbnailList, n) {
+        Main.activateWindow(this._appIcons[this._currentApp].windows[n]);
+        this.destroy();
+    },
+
+    _windowHovered : function(thumbnailList, n) {
+        if (!this._mouseActive)
+            return;
+
+        this._select(this._currentApp, n);
+    },
+
+    _mouseMoved : function(actor, event) {
+        if (++this._mouseMovement < POPUP_POINTER_SELECTION_THRESHOLD)
+            return;
+
+        this.actor.disconnect(this._motionEventId);
+        this._mouseActive = true;
+
+        this._appSwitcher.checkHover();
+        if (this._thumbnails)
+            this._thumbnails.checkHover();
+    },
+
+    _finish : function() {
+        let app = this._appIcons[this._currentApp];
+        let window = app.windows[this._currentWindows[this._currentApp]];
+        Main.activateWindow(window);
+        this.destroy();
     },
 
     destroy : function() {
         this.actor.destroy();
-        this._overlay.destroy();
     },
 
-    select : function(n) {
-        if (this._selected) {
-            // Unselect previous
+    _onDestroy : function() {
+        if (this._haveModal)
+            Main.popModal(this.actor);
 
-            if (this._allocationChangedId) {
-                this._selected.box.disconnect(this._allocationChangedId);
-                delete this._allocationChangedId;
+        if (this._keyPressEventId)
+            global.stage.disconnect(this._keyPressEventId);
+        if (this._keyReleaseEventId)
+            global.stage.disconnect(this._keyReleaseEventId);
+
+        if (this._thumbnailTimeoutId != 0)
+            Mainloop.source_remove(this._thumbnailTimeoutId);
+    },
+
+    _select : function(app, window, noTimeout) {
+        if ((app != this._currentApp || !window) && this._thumbnails) {
+            this._thumbnails.actor.destroy();
+            this._thumbnails = null;
+            this._appSwitcher.showArrow(-1);
         }
 
-            if (this._selected.above)
-                this._selected.window.raise(this._selected.above);
-            else
-                this._selected.window.lower_bottom();
+        if (this._thumbnailTimeoutId != 0) {
+            Mainloop.source_remove(this._thumbnailTimeoutId);
+            this._thumbnailTimeoutId = 0;
         }
 
-        let item = this._items[n];
-        let changed = this._selected && item != this._selected;
-        this._selected = item;
-
-        if (this._selected) {
-            this._label.set_size(-1, -1);
-            this._label.text = this._selected.metaWindow.title;
-            if (this._label.width > POPUP_LABEL_MAX_WIDTH)
-                this._label.width = POPUP_LABEL_MAX_WIDTH;
-
-            // Figure out this._selected.box's coordinates in terms of
-            // this.actor
-            let bx = this._selected.box.x, by = this._selected.box.y;
-            let actor = this._selected.box.get_parent();
-            while (actor != this.actor) {
-                bx += actor.x;
-                by += actor.y;
-                actor = actor.get_parent();
-            }
-
-            if (changed) {
-                Tweener.addTween(this._indicator,
-                                 { x: bx,
-                                   y: by,
-                                   width: this._selected.box.width,
-                                   height: this._selected.box.height,
-                                   time: SWITCH_TIME,
-                                   transition: "easeOutQuad" });
+        this._currentApp = app;
+        if (window != null) {
+            this._appSwitcher.highlight(-1);
+            this._appSwitcher.showArrow(app);
         } else {
-                Tweener.removeTweens(this.indicator);
-                this._indicator.set_position(bx, by);
-                this._indicator.set_size(this._selected.box.width,
-                                         this._selected.box.height);
-            }
-            this._indicator.show();
-
-            if (this._overlay.visible) {
-                if (this._selected.visible)
-                    this._selected.window.raise(this._overlay);
-                this._adjust_overlay();
+            this._appSwitcher.highlight(app);
+            if (this._appIcons[this._currentApp].windows.length > 1)
+                this._appSwitcher.showArrow(app);
         }
 
-            this._allocationChangedId =
-                this._selected.box.connect('notify::allocation',
-                                           Lang.bind(this, this._allocationChanged));
-        } else {
-            this._label.text = "";
-            this._indicator.hide();
+        if (window != null) {
+            if (!this._thumbnails)
+                this._createThumbnails();
+            this._currentWindows[this._currentApp] = window;
+            this._thumbnails.highlight(window);
+        } else if (this._appIcons[this._currentApp].windows.length > 1 &&
+                   !noTimeout) {
+            this._thumbnailTimeoutId = Mainloop.timeout_add (
+                THUMBNAIL_POPUP_TIME,
+                Lang.bind(this, function () {
+                              this._select(this._currentApp,
+                                           this._currentWindows[this._currentApp]);
+                              return false;
+                          }));
         }
     },
 
-    _allocationChanged : function() {
-        if (this._selected)
-            this.select(this._selected.n);
+    _createThumbnails : function() {
+        this._thumbnails = new ThumbnailList (this._appIcons[this._currentApp].windows);
+        this._thumbnails.connect('item-activated', Lang.bind(this, this._windowActivated));
+        this._thumbnails.connect('item-hovered', Lang.bind(this, this._windowHovered));
+
+        this.actor.add_actor(this._thumbnails.actor);
+
+        let thumbnailCenter;
+        if (this._thumbnails.actor.width < this._appSwitcher.actor.width) {
+            // Center the thumbnails under the corresponding AppIcon.
+            // If this is being called when the switcher is first
+            // being brought up, then nothing will have been assigned
+            // an allocation yet, and the get_transformed_position()
+            // call will return 0,0.
+            // (http://bugzilla.openedhand.com/show_bug.cgi?id=1115).
+            // Calling clutter_actor_get_allocation_box() would force
+            // it to properly allocate itself, but we can't call that
+            // because it has an out-caller-allocates arg. So we use
+            // clutter_stage_get_actor_at_pos(), which will force a
+            // reallocation as a side effect.
+            global.stage.get_actor_at_pos(Clutter.PickMode.REACTIVE, 0, 0);
+
+            let icon = this._appIcons[this._currentApp].actor;
+            let [stageX, stageY] = icon.get_transformed_position();
+            thumbnailCenter = stageX + icon.width / 2;
+        } else {
+            // Center the thumbnails on the monitor
+            let primary = global.get_primary_monitor();
+            thumbnailCenter = primary.x + primary.width / 2;
+        }
+
+        this._thumbnails.actor.x = Math.floor(thumbnailCenter - this._thumbnails.actor.width / 2);
+        this._thumbnails.actor.y = this._appSwitcher.actor.y + this._appSwitcher.actor.height + POPUP_LIST_SPACING;
+    }
+};
+
+function SwitcherList(squareItems) {
+    this._init(squareItems);
+}
+
+SwitcherList.prototype = {
+    _init : function(squareItems) {
+        this.actor = new St.Bin({ style_class: 'switcher-list' });
+        this.actor.connect('destroy', Lang.bind(this, this._onDestroy));
+
+        // Here we use a GenericContainer so that we can force all the
+        // children except the separator to have the same width.
+        this._list = new Shell.GenericContainer();
+        this._list.spacing = POPUP_LIST_SPACING;
+
+        this._list.connect('get-preferred-width', Lang.bind(this, this._getPreferredWidth));
+        this._list.connect('get-preferred-height', Lang.bind(this, this._getPreferredHeight));
+        this._list.connect('allocate', Lang.bind(this, this._allocate));
+
+        this.actor.add_actor(this._list);
+
+        this._items = [];
+        this._highlighted = -1;
+        this._separator = null;
+        this._squareItems = squareItems;
+
+        this._hoverTimeout = 0;
     },
 
-    _adjust_overlay : function() {
-        if (this._selected && this._selected.icon_rect) {
-            // We want to highlight a specific rectangle within the
-            // task bar, so rearrange the pieces of the overlay to
-            // cover the whole screen except that rectangle
+    _onDestroy: function() {
+        if (this._hoverTimeout != 0) {
+            Mainloop.source_remove(this._hoverTimeout);
+            this._hoverTimeout = 0;
+        }
+    },
 
-            let rect = this._selected.icon_rect;
+    addItem : function(item) {
+        let box = new St.Bin({ style_class: 'item-box' });
+        let bbox;
 
-            this._overlay_top.x = 0;
-            this._overlay_top.y = 0;
-            this._overlay_top.width = global.screen_width;
-            this._overlay_top.height = rect.y;
+        if (item instanceof Shell.ButtonBox)
+            bbox = item;
+        else {
+            bbox = new Shell.ButtonBox({ reactive: true });
+            bbox.append(item, Big.BoxPackFlags.NONE);
+        }
+        box.add_actor(bbox);
+        this._list.add_actor(box);
 
-            this._overlay_left.x = 0;
-            this._overlay_left.y = rect.y;
-            this._overlay_left.width = rect.x;
-            this._overlay_left.height = rect.height;
-            this._overlay_left.show();
+        let n = this._items.length;
+        bbox.connect('activate', Lang.bind(this, function () {
+                                               this._itemActivated(n);
+                                          }));
+        bbox.connect('notify::hover', Lang.bind(this, function () {
+                                                    this._hoverChanged(bbox, n);
+                                               }));
 
-            this._overlay_right.x = rect.x + rect.width;
-            this._overlay_right.y = rect.y;
-            this._overlay_right.width = global.screen_width - rect.x - rect.width;
-            this._overlay_right.height = rect.height;
-            this._overlay_right.show();
+        this._items.push(box);
+    },
 
-            this._overlay_bottom.x = 0;
-            this._overlay_bottom.y = rect.y + rect.height;
-            this._overlay_bottom.width = global.screen_width;
-            this._overlay_bottom.height = global.screen_height - rect.y - rect.height;
-            this._overlay_bottom.show();
+    addSeparator: function () {
+        // FIXME: make this work with StWidgets and CSS
+        let box = new Big.Box({ padding_top: 2, padding_bottom: 2 });
+        box.append(new Clutter.Rectangle({ width: 1,
+                                           color: POPUP_SEPARATOR_COLOR }),
+                   Big.BoxPackFlags.EXPAND);
+        this._separator = box;
+        this._list.add_actor(box);
+    },
+    
+    highlight: function(index) {
+        if (this._highlighted != -1)
+            this._items[this._highlighted].style_class = 'item-box';
+
+        this._highlighted = index;
+
+        if (this._highlighted != -1)
+            this._items[this._highlighted].style_class = 'selected-item-box';
+    },
+
+    // Used after the mouse movement exceeds the threshold, to check
+    // if it's already hovering over an icon
+    checkHover: function() {
+        for (let i = 0; i < this._items.length; i++) {
+            if (this._items[i].get_child().hover) {
+                this._hoverChanged(this._items[i].get_child(), i);
+                return;
+            }
+        }
+    },
+
+    _itemActivated: function(n) {
+        this.emit('item-activated', n);
+    },
+    
+    _hoverChanged: function(box, n) {
+        if (this._hoverTimeout != 0) {
+            Mainloop.source_remove(this._hoverTimeout);
+            this._hoverTimeout = 0;
+        }
+
+        if (box.hover) {
+            this._hoverTimeout = Mainloop.timeout_add(
+                HOVER_TIME,
+                Lang.bind (this, function () {
+                               this._itemHovered(n);
+                           }));
+        }
+    },
+
+    _itemHovered: function(n) {
+        this.emit('item-hovered', n);
+    },
+
+    _maxChildWidth: function (forHeight) {
+        let maxChildMin = 0;
+        let maxChildNat = 0;
+
+        for (let i = 0; i < this._items.length; i++) {
+            let [childMin, childNat] = this._items[i].get_preferred_width(forHeight);
+            maxChildMin = Math.max(childMin, maxChildMin);
+            maxChildNat = Math.max(childNat, maxChildNat);
+
+            if (this._squareItems) {
+                let [childMin, childNat] = this._items[i].get_preferred_height(-1);
+                maxChildMin = Math.max(childMin, maxChildMin);
+                maxChildNat = Math.max(childNat, maxChildNat);
+            }
+        }
+
+        return [maxChildMin, maxChildNat];
+    },
+
+    _getPreferredWidth: function (actor, forHeight, alloc) {
+        let [maxChildMin, maxChildNat] = this._maxChildWidth(forHeight);
+
+        let separatorWidth = 0;
+        if (this._separator) {
+            let [sepMin, sepNat] = this._separator.get_preferred_width(forHeight);
+            separatorWidth = sepNat + this._list.spacing;
+        }
+
+        let totalSpacing = this._list.spacing * (this._items.length - 1);
+        alloc.min_size = this._items.length * maxChildMin + separatorWidth + totalSpacing;
+        alloc.nat_size = this._items.length * maxChildNat + separatorWidth + totalSpacing;
+    },
+
+    _getPreferredHeight: function (actor, forWidth, alloc) {
+        let maxChildMin = 0;
+        let maxChildNat = 0;
+
+        for (let i = 0; i < this._items.length; i++) {
+            let [childMin, childNat] = this._items[i].get_preferred_height(-1);
+            maxChildMin = Math.max(childMin, maxChildMin);
+            maxChildNat = Math.max(childNat, maxChildNat);
+        }
+
+        if (this._squareItems) {
+            let [childMin, childNat] = this._maxChildWidth(-1);
+            maxChildMin = Math.max(childMin, maxChildMin);
+            maxChildNat = Math.max(childNat, maxChildNat);
+        }
+
+        alloc.min_size = maxChildMin;
+        alloc.nat_size = maxChildNat;
+    },
+
+    _allocate: function (actor, box, flags) {
+        let childHeight = box.y2 - box.y1;
+
+        let [maxChildMin, maxChildNat] = this._maxChildWidth(childHeight);
+        let totalSpacing = this._list.spacing * (this._items.length - 1);
+
+        let separatorWidth = 0;
+        if (this._separator) {
+            let [sepMin, sepNat] = this._separator.get_preferred_width(childHeight);
+            separatorWidth = sepNat;
+            totalSpacing += this._list.spacing;
+        }
+
+        let childWidth = Math.floor(Math.max(0, box.x2 - box.x1 - totalSpacing - separatorWidth) / this._items.length);
+
+        let x = 0;
+        let children = this._list.get_children();
+        let childBox = new Clutter.ActorBox();
+        for (let i = 0; i < children.length; i++) {
+            if (this._items.indexOf(children[i]) != -1) {
+                let [childMin, childNat] = children[i].get_preferred_height(childWidth);
+                let vSpacing = (childHeight - childNat) / 2;
+                childBox.x1 = x;
+                childBox.y1 = vSpacing;
+                childBox.x2 = x + childWidth;
+                childBox.y2 = childBox.y1 + childNat;
+                children[i].allocate(childBox, flags);
+
+                x += this._list.spacing + childWidth;
+            } else if (children[i] == this._separator) {
+                // We want the separator to be more compact than the rest.
+                childBox.x1 = x;
+                childBox.y1 = 0;
+                childBox.x2 = x + separatorWidth;
+                childBox.y2 = childHeight;
+                children[i].allocate(childBox, flags);
+                x += this._list.spacing + separatorWidth;
             } else {
-            // Either there's no current selection, or the selection
-            // is a visible window. Make the overlay cover the whole
-            // screen. select() will raise the selected window over
-            // the overlay.
-
-            this._overlay_top.x = 0;
-            this._overlay_top.y = 0;
-            this._overlay_top.width = global.screen_width;
-            this._overlay_top.height = global.screen_height;
-            this._overlay_top.show();
-
-            this._overlay_left.hide();
-            this._overlay_right.hide();
-            this._overlay_bottom.hide();
+                // Something else, eg, AppSwitcher's arrows;
+                // we don't allocate it.
+            }
+        }
+    }
+};
+
+Signals.addSignalMethods(SwitcherList.prototype);
+
+function AppSwitcher(apps) {
+    this._init(apps);
+}
+
+AppSwitcher.prototype = {
+    __proto__ : SwitcherList.prototype,
+
+    _init : function(apps) {
+        SwitcherList.prototype._init.call(this, true);
+
+        // Construct the AppIcons, sort by time, add to the popup
+        let activeWorkspace = global.screen.get_active_workspace();
+        let workspaceIcons = [];
+        let otherIcons = [];
+        for (let i = 0; i < apps.length; i++) {
+            let appIcon = new AppIcon.AppIcon({ appInfo: apps[i],
+                                                size: POPUP_APPICON_SIZE });
+            if (this._hasWindowsOnWorkspace(appIcon, activeWorkspace))
+              workspaceIcons.push(appIcon);
+            else
+              otherIcons.push(appIcon);
+        }
+
+        workspaceIcons.sort(Lang.bind(this, this._sortAppIcon));
+        otherIcons.sort(Lang.bind(this, this._sortAppIcon));
+
+        this.icons = [];
+        this._arrows = [];
+        for (let i = 0; i < workspaceIcons.length; i++)
+            this._addIcon(workspaceIcons[i]);
+        if (workspaceIcons.length > 0 && otherIcons.length > 0)
+            this.addSeparator();
+        for (let i = 0; i < otherIcons.length; i++)
+            this._addIcon(otherIcons[i]);
+
+        this._shownArrow = -1;
+    },
+
+    _allocate: function (actor, box, flags) {
+        // Allocate the main list items
+        SwitcherList.prototype._allocate.call(this, actor, box, flags);
+
+        let arrowHeight = Math.floor(this.actor.get_theme_node().get_padding(St.Side.BOTTOM) / 3);
+        let arrowWidth = arrowHeight * 2;
+
+        // Now allocate each arrow underneath its item
+        let childBox = new Clutter.ActorBox();
+        for (let i = 0; i < this._items.length; i++) {
+            let itemBox = this._items[i].allocation;
+            childBox.x1 = Math.floor(itemBox.x1 + (itemBox.x2 - itemBox.x1 - arrowWidth) / 2);
+            childBox.x2 = childBox.x1 + arrowWidth;
+            childBox.y1 = itemBox.y2 + arrowHeight;
+            childBox.y2 = childBox.y1 + arrowHeight;
+            this._arrows[i].allocate(childBox, flags);
+        }
+    },
+
+    showArrow : function(n) {
+        if (this._shownArrow != -1)
+            this._arrows[this._shownArrow].hide();
+
+        this._shownArrow = n;
+
+        if (this._shownArrow != -1)
+            this._arrows[this._shownArrow].show();
+    },
+
+    _addIcon : function(appIcon) {
+        this.icons.push(appIcon);
+        this.addItem(appIcon.actor);
+
+        let arrow = new Shell.DrawingArea();
+        arrow.connect('redraw', Lang.bind(this,
+            function (area, texture) {
+                Shell.draw_box_pointer(texture, Shell.PointerDirection.DOWN,
+                                       TRANSPARENT_COLOR,
+                                       POPUP_ARROW_COLOR);
+            }));
+        this._list.add_actor(arrow);
+        this._arrows.push(arrow);
+        arrow.hide();
+    },
+
+    _hasWindowsOnWorkspace: function(appIcon, workspace) {
+        for (let i = 0; i < appIcon.windows.length; i++) {
+            if (appIcon.windows[i].get_workspace() == workspace)
+                return true;
+        }
+        return false;
+    },
+
+    _hasVisibleWindows : function(appIcon) {
+        for (let i = 0; i < appIcon.windows.length; i++) {
+            if (appIcon.windows[i].showing_on_its_workspace())
+                return true;
+        }
+        return false;
+    },
+
+    _sortAppIcon : function(appIcon1, appIcon2) {
+        let vis1 = this._hasVisibleWindows(appIcon1);
+        let vis2 = this._hasVisibleWindows(appIcon2);
+
+        if (vis1 && !vis2) {
+            return -1;
+        } else if (vis2 && !vis1) {
+            return 1;
+        } else {
+            // The app's most-recently-used window is first
+            // in its list
+            return (appIcon2.windows[0].get_user_time() -
+                    appIcon1.windows[0].get_user_time());
+        }
+    }
+};
+
+function ThumbnailList(windows) {
+    this._init(windows);
+}
+
+ThumbnailList.prototype = {
+    __proto__ : SwitcherList.prototype,
+
+    _init : function(windows) {
+        SwitcherList.prototype._init.call(this);
+
+        for (let i = 0; i < windows.length; i++) {
+            let mutterWindow = windows[i].get_compositor_private();
+            let windowTexture = mutterWindow.get_texture ();
+            let [width, height] = windowTexture.get_size();
+            let scale = Math.min(1.0, THUMBNAIL_SIZE / width, THUMBNAIL_SIZE / height);
+
+            let clone = new Clutter.Clone ({ source: windowTexture,
+                                             reactive: true,
+                                             width: width * scale,
+                                             height: height * scale });
+            let box = new Big.Box({ padding: AppIcon.APPICON_BORDER_WIDTH + AppIcon.APPICON_PADDING });
+            box.append(clone, Big.BoxPackFlags.NONE);
+            this.addItem(box);
         }
     }
 };

js/ui/appDisplay.js

@@ -23,32 +23,11 @@ const ENTERED_MENU_COLOR = new Clutter.Color();
 ENTERED_MENU_COLOR.from_pixel(0x00ff0022);
 
 const WELL_DEFAULT_COLUMNS = 4;
-const WELL_ITEM_HSPACING = 0;
+const WELL_ITEM_MIN_HSPACING = 4;
 const WELL_ITEM_VSPACING = 4;
 
-const WELL_MENU_POPUP_TIMEOUT_MS = 600;
-
-const TRANSPARENT_COLOR = new Clutter.Color();
-TRANSPARENT_COLOR.from_pixel(0x00000000);
-
-const WELL_MENU_BACKGROUND_COLOR = new Clutter.Color();
-WELL_MENU_BACKGROUND_COLOR.from_pixel(0x292929ff);
-const WELL_MENU_FONT = 'Sans 14px';
-const WELL_MENU_COLOR = new Clutter.Color();
-WELL_MENU_COLOR.from_pixel(0xffffffff);
-const WELL_MENU_SELECTED_COLOR = new Clutter.Color();
-WELL_MENU_SELECTED_COLOR.from_pixel(0x005b97ff);
-const WELL_MENU_BORDER_COLOR = new Clutter.Color();
-WELL_MENU_BORDER_COLOR.from_pixel(0x787878ff);
-const WELL_MENU_SEPARATOR_COLOR = new Clutter.Color();
-WELL_MENU_SEPARATOR_COLOR.from_pixel(0x787878ff);
-const WELL_MENU_BORDER_WIDTH = 1;
-const WELL_MENU_ARROW_SIZE = 12;
-const WELL_MENU_CORNER_RADIUS = 4;
-const WELL_MENU_PADDING = 4;
-
-const MENU_ICON_SIZE = 24;
-const MENU_SPACING = 15;
+const MENU_ARROW_SIZE = 12;
+const MENU_SPACING = 7;
 
 const MAX_ITEMS = 30;
 
@@ -81,7 +60,7 @@ AppDisplayItem.prototype = {
         let windows = Shell.AppMonitor.get_default().get_windows_for_app(this._appInfo.get_id());
         if (windows.length > 0) {
             let mostRecentWindow = windows[0];
-            Main.overview.activateWindow(mostRecentWindow, Clutter.get_current_event_time());
+            Main.overview.activateWindow(mostRecentWindow, Main.currentTime());
         } else {
             this._appInfo.launch();
         }
@@ -108,8 +87,8 @@ const MENU_UNSELECTED = 0;
 const MENU_SELECTED = 1;
 const MENU_ENTERED = 2;
 
-function MenuItem(name, id, iconName) {
-    this._init(name, id, iconName);
+function MenuItem(name, id) {
+    this._init(name, id);
 }
 
 /**
@@ -117,31 +96,19 @@ function MenuItem(name, id, iconName) {
  * Shows the list of menus in the sidebar.
  */
 MenuItem.prototype = {
-    _init: function(name, id, iconName) {
+    _init: function(name, id) {
         this.id = id;
 
         this.actor = new Big.Box({ orientation: Big.BoxOrientation.HORIZONTAL,
                                    spacing: 4,
                                    corner_radius: 4,
                                    padding_right: 4,
+                                   padding_left: 4,
                                    reactive: true });
         this.actor.connect('button-press-event', Lang.bind(this, function (a, e) {
             this.setState(MENU_SELECTED);
         }));
 
-        let iconTheme = Gtk.IconTheme.get_default();
-        let pixbuf = null;
-        this._icon = new Clutter.Texture({ width: MENU_ICON_SIZE,
-                                           height: MENU_ICON_SIZE });
-        // Wine manages not to have an icon
-        try {
-            pixbuf = iconTheme.load_icon(iconName, MENU_ICON_SIZE, 0 /* flags */);
-        } catch (e) {
-            pixbuf = iconTheme.load_icon('gtk-file', MENU_ICON_SIZE, 0);
-        }
-        if (pixbuf != null)
-            Shell.clutter_texture_set_from_pixbuf(this._icon, pixbuf);
-        this.actor.append(this._icon, Big.BoxPackFlags.NONE);
         this._text = new Clutter.Text({ color: GenericDisplay.ITEM_DISPLAY_NAME_COLOR,
                                         font_name: "Sans 14px",
                                         text: name });
@@ -149,7 +116,8 @@ MenuItem.prototype = {
         // We use individual boxes for the label and the arrow to ensure that they
         // are aligned vertically. Just setting y_align: Big.BoxAlignment.CENTER
         // on this.actor does not seem to achieve that.  
-        let labelBox = new Big.Box({ y_align: Big.BoxAlignment.CENTER });
+        let labelBox = new Big.Box({ y_align: Big.BoxAlignment.CENTER,
+                                     padding: 4 });
 
         labelBox.append(this._text, Big.BoxPackFlags.NONE);
        
@@ -157,8 +125,8 @@ MenuItem.prototype = {
 
         let arrowBox = new Big.Box({ y_align: Big.BoxAlignment.CENTER });
 
-        this._arrow = new Shell.Arrow({ surface_width: MENU_ICON_SIZE / 2,
-                                        surface_height: MENU_ICON_SIZE / 2,
+        this._arrow = new Shell.Arrow({ surface_width: MENU_ARROW_SIZE,
+                                        surface_height: MENU_ARROW_SIZE,
                                         direction: Gtk.ArrowType.RIGHT,
                                         opacity: 0 });
         arrowBox.append(this._arrow, Big.BoxPackFlags.NONE);
@@ -209,31 +177,21 @@ AppDisplay.prototype = {
 
         this._menus = [];
         this._menuDisplays = [];
-
-        // map<itemId, array of category names>
-        this._appCategories = {};
+        // map<search term, map<appId, true>>
+        // We use a map of appIds instead of an array to ensure that we don't have duplicates and for easier lookup.
+        this._menuSearchAppMatches = {};
 
         this._appMonitor = Shell.AppMonitor.get_default();
         this._appSystem = Shell.AppSystem.get_default();
         this._appsStale = true;
         this._appSystem.connect('installed-changed', Lang.bind(this, function(appSys) {
             this._appsStale = true;
-            this._redisplay(false);
-            this._redisplayMenus();
+            this._redisplay(GenericDisplay.RedisplayFlags.NONE);
         }));
         this._appSystem.connect('favorites-changed', Lang.bind(this, function(appSys) {
-            this._redisplay(false);
+            this._appsStale = true;
+            this._redisplay(GenericDisplay.RedisplayFlags.NONE);
         }));
-        this._appMonitor.connect('app-added', Lang.bind(this, function(monitor) {
-            this._redisplay(false);
-        }));
-        this._appMonitor.connect('app-removed', Lang.bind(this, function(monitor) {
-            this._redisplay(false);
-        }));
-
-        // Load the apps now so it doesn't slow down the first
-        // transition into the Overview
-        this._refreshCache();
 
         this._focusInMenus = true;
         this._activeMenuIndex = -1;
@@ -242,7 +200,6 @@ AppDisplay.prototype = {
         this._menuDisplay = new Big.Box({ orientation: Big.BoxOrientation.VERTICAL,
                                           spacing: MENU_SPACING
                                        });
-        this._redisplayMenus();
 
         this.connect('expanded', Lang.bind(this, function (self) {
             this._filterReset();
@@ -285,6 +242,39 @@ AppDisplay.prototype = {
         return true;
     },
 
+    setSearch: function(text) {
+        let lowertext = text.toLowerCase();
+        if (lowertext == this._search)
+            return;
+
+        // We prepare menu matches up-front, so that we don't
+        // need to go over all menu items for each application
+        // and then get all applications for a matching menu
+        // to see if a particular application passed to
+        // _isInfoMatching() is a match.
+        let terms = lowertext.split(/\s+/);
+        this._menuSearchAppMatches = {};
+        for (let i = 0; i < terms.length; i++) {
+            let term = terms[i];
+            this._menuSearchAppMatches[term] = {};
+            for (let j = 0; j < this._menus.length; j++) {
+                let menuItem = this._menus[j];
+                // Match only on the beginning of the words in category names,
+                // because otherwise it introduces unnecessary noise in the results.
+                if (menuItem.name.toLowerCase().indexOf(term) == 0 ||
+                    menuItem.name.toLowerCase().indexOf(" " + term) > 0) {
+                    let menuApps = this._appSystem.get_applications_for_menu(menuItem.id);
+                    for (let k = 0; k < menuApps.length; k++) {
+                        let menuApp = menuApps[k];
+                        this._menuSearchAppMatches[term][menuApp.get_id()] = true;
+                    }
+                }
+            }
+        }
+
+        GenericDisplay.GenericDisplay.prototype.setSearch.call(this, text);
+    },
+
     // Protected overrides
 
     _filterActive: function() {
@@ -316,8 +306,8 @@ AppDisplay.prototype = {
         })).filter(function (e) { return e != null });
     },
 
-    _addMenuItem: function(name, id, icon, index) {
-        let display = new MenuItem(name, id, icon);
+    _addMenuItem: function(name, id, index) {
+        let display = new MenuItem(name, id);
         this._menuDisplays.push(display);
         display.connect('state-changed', Lang.bind(this, function (display) {
             let activated = display.getState() != MENU_UNSELECTED;
@@ -335,7 +325,7 @@ AppDisplay.prototype = {
                     this._activeMenuApps = this._appSystem.get_applications_for_menu(id);
                 }
             }
-            this._redisplay(true);
+            this._redisplay(GenericDisplay.RedisplayFlags.FULL);
         }));
         this._menuDisplay.append(display.actor, 0);
     },
@@ -343,9 +333,13 @@ AppDisplay.prototype = {
     _redisplayMenus: function() {
         this._menuDisplay.remove_all();
         this._addMenuItem(_("Frequent"), null, 'gtk-select-all');
+        // Adding an empty box here results in double spacing between
+        // "Frequent" and the other items.
+        let separator_actor = new Big.Box();
+        this._menuDisplay.append(separator_actor, 0);
         for (let i = 0; i < this._menus.length; i++) {
             let menu = this._menus[i];
-            this._addMenuItem(menu.name, menu.id, menu.icon, i+1);
+            this._addMenuItem(menu.name, menu.id, i+1);
         }
     },
 
@@ -359,9 +353,8 @@ AppDisplay.prototype = {
     // Gets information about all applications by calling Gio.app_info_get_all().
     _refreshCache : function() {
         if (!this._appsStale)
-            return;
+            return true;
         this._allItems = {};
-        this._appCategories = {};
 
         if (this._showPrefs) {
             // Get the desktop file ids for settings/preferences.
@@ -389,14 +382,17 @@ AppDisplay.prototype = {
                     this._addApp(app);
                 }
             }
+            this._redisplayMenus();
         }
 
         this._appsStale = false;
+        return false;
     },
 
     // Stub this out; the app display always has a category selected
     _setDefaultList : function() {
-        this._matchedItems = [];
+        this._matchedItems = {};
+        this._matchedItemKeys = [];
     },
 
     // Compares items associated with the item ids based on the alphabetical order
@@ -409,7 +405,7 @@ AppDisplay.prototype = {
     },
 
     // Checks if the item info can be a match for the search string by checking
-    // the name, description, execution command, and categories for the application.
+    // the name, description, execution command, and category for the application.
     // Item info is expected to be Shell.AppInfo.
     // Returns a boolean flag indicating if itemInfo is a match.
     _isInfoMatching : function(itemInfo, search) {
@@ -421,10 +417,10 @@ AppDisplay.prototype = {
         if (this._activeMenu == null || search != "")
             return this._isInfoMatchingSearch(itemInfo, search);
         else
-            return this._isInfoMatchingMenu(itemInfo, search);
+            return this._isInfoMatchingMenu(itemInfo);
     },
 
-    _isInfoMatchingMenu : function(itemInfo, search) {
+    _isInfoMatchingMenu: function(itemInfo) {
         let id = itemInfo.get_id();
         for (let i = 0; i < this._activeMenuApps.length; i++) {
             let activeApp = this._activeMenuApps[i];
@@ -462,11 +458,11 @@ AppDisplay.prototype = {
                 return true;
         }
 
-        let categories = itemInfo.get_categories();
-        for (let i = 0; i < categories.length; i++) {
-            let category = fold(categories[i]);
-            if (category.indexOf(search) >= 0)
+        if (this._menuSearchAppMatches[search]) {
+            if (this._menuSearchAppMatches[search].hasOwnProperty(itemInfo.get_id()))
                 return true;
+        } else {
+            log("Missing an entry for search term " + search + " in this._menuSearchAppMatches");
         }
 
         return false;
@@ -480,264 +476,21 @@ AppDisplay.prototype = {
 
 Signals.addSignalMethods(AppDisplay.prototype);
 
-function WellMenu(source) {
-    this._init(source);
-}
-
-WellMenu.prototype = {
-    _init: function(source) {
-        this._source = source;
-
-        // Whether or not we successfully picked a window
-        this.didActivateWindow = false;
-
-        this.actor = new Shell.GenericContainer({ reactive: true });
-        this.actor.connect('get-preferred-width', Lang.bind(this, this._getPreferredWidth));
-        this.actor.connect('get-preferred-height', Lang.bind(this, this._getPreferredHeight));
-        this.actor.connect('allocate', Lang.bind(this, this._allocate));
-
-        this._windowContainer = new Shell.Menu({ orientation: Big.BoxOrientation.VERTICAL,
-                                                 border_color: WELL_MENU_BORDER_COLOR,
-                                                 border: WELL_MENU_BORDER_WIDTH,
-                                                 background_color: WELL_MENU_BACKGROUND_COLOR,
-                                                 padding: 4,
-                                                 corner_radius: WELL_MENU_CORNER_RADIUS,
-                                                 width: Main.overview._dash.actor.width * 0.75 });
-        this._windowContainer.connect('unselected', Lang.bind(this, this._onWindowUnselected));
-        this._windowContainer.connect('selected', Lang.bind(this, this._onWindowSelected));
-        this._windowContainer.connect('cancelled', Lang.bind(this, this._onWindowSelectionCancelled));
-        this._windowContainer.connect('activate', Lang.bind(this, this._onWindowActivate));
-        this.actor.add_actor(this._windowContainer);
-
-        // Stay popped up on release over application icon
-        this._windowContainer.set_persistent_source(this._source.actor);
-
-        // Intercept events while the menu has the pointer grab to do window-related effects
-        this._windowContainer.connect('enter-event', Lang.bind(this, this._onMenuEnter));
-        this._windowContainer.connect('leave-event', Lang.bind(this, this._onMenuLeave));
-        this._windowContainer.connect('button-release-event', Lang.bind(this, this._onMenuButtonRelease));
-
-        this._arrow = new Shell.DrawingArea();
-        this._arrow.connect('redraw', Lang.bind(this, function (area, texture) {
-            Shell.draw_box_pointer(texture, WELL_MENU_BORDER_COLOR, WELL_MENU_BACKGROUND_COLOR);
-        }));
-        this.actor.add_actor(this._arrow);
-
-        // Chain our visibility and lifecycle to that of the source
-        source.actor.connect('notify::mapped', Lang.bind(this, function () {
-            if (!source.actor.mapped)
-                this._windowContainer.popdown();
-        }));
-        source.actor.connect('destroy', Lang.bind(this, function () { this.actor.destroy(); }));
-
-        global.stage.add_actor(this.actor);
-    },
-
-    _getPreferredWidth: function(actor, forHeight, alloc) {
-        let [min, natural] = this._windowContainer.get_preferred_width(forHeight);
-        alloc.min_size = min + WELL_MENU_ARROW_SIZE;
-        alloc.natural_size = natural + WELL_MENU_ARROW_SIZE;
-    },
-
-    _getPreferredHeight: function(actor, forWidth, alloc) {
-        let [min, natural] = this._windowContainer.get_preferred_height(forWidth);
-        alloc.min_size = min;
-        alloc.natural_size = natural;
-    },
-
-    _allocate: function(actor, box, flags) {
-        let childBox = new Clutter.ActorBox();
-
-        let width = box.x2 - box.x1;
-        let height = box.y2 - box.y1;
-
-        childBox.x1 = 0;
-        childBox.x2 = WELL_MENU_ARROW_SIZE;
-        childBox.y1 = Math.floor((height / 2) - (WELL_MENU_ARROW_SIZE / 2));
-        childBox.y2 = childBox.y1 + WELL_MENU_ARROW_SIZE;
-        this._arrow.allocate(childBox, flags);
-
-        /* overlap by one pixel to hide the border */
-        childBox.x1 = WELL_MENU_ARROW_SIZE - 1;
-        childBox.x2 = width;
-        childBox.y1 = 0;
-        childBox.y2 = height;
-        this._windowContainer.allocate(childBox, flags);
-    },
-
-    _redisplay: function() {
-        this._windowContainer.remove_all();
-
-        this.didActivateWindow = false;
-
-        let windows = this._source.windows;
-
-        this._windowContainer.show();
-
-        let iconsDiffer = false;
-        let texCache = Shell.TextureCache.get_default();
-        let firstIcon = windows[0].mini_icon;
-        for (let i = 1; i < windows.length; i++) {
-            if (!texCache.pixbuf_equal(windows[i].mini_icon, firstIcon)) {
-                iconsDiffer = true;
-                break;
-            }
-        }
-
-        let activeWorkspace = global.screen.get_active_workspace();
-
-        let currentWorkspaceWindows = windows.filter(function (w) {
-            return w.get_workspace() == activeWorkspace;
-        });
-        let otherWorkspaceWindows = windows.filter(function (w) {
-            return w.get_workspace() != activeWorkspace;
-        });
-
-        this._appendWindows(currentWorkspaceWindows, iconsDiffer);
-        if (currentWorkspaceWindows.length > 0 && otherWorkspaceWindows.length > 0) {
-            let box = new Big.Box({ padding_top: 2, padding_bottom: 2 });
-            box.append(new Clutter.Rectangle({ height: 1,
-                                               color: WELL_MENU_SEPARATOR_COLOR }),
-                       Big.BoxPackFlags.EXPAND);
-            this._windowContainer.append_separator(box, Big.BoxPackFlags.NONE);
-        }
-        this._appendWindows(otherWorkspaceWindows, iconsDiffer);
-    },
-
-    _appendWindows: function (windows, iconsDiffer) {
-        for (let i = 0; i < windows.length; i++) {
-            let metaWindow = windows[i];
-
-            /* Use padding here rather than spacing in the box above so that
-             * we have a larger reactive area.
-             */
-            let box = new Big.Box({ orientation: Big.BoxOrientation.HORIZONTAL,
-                                    padding_top: 4,
-                                    padding_bottom: 4,
-                                    spacing: 4,
-                                    reactive: true });
-            box._window = metaWindow;
-            let vCenter;
-            if (iconsDiffer) {
-                vCenter = new Big.Box({ y_align: Big.BoxAlignment.CENTER });
-                let icon = Shell.TextureCache.get_default().bind_pixbuf_property(metaWindow, "mini-icon");
-                vCenter.append(icon, Big.BoxPackFlags.NONE);
-                box.append(vCenter, Big.BoxPackFlags.NONE);
-            }
-            vCenter = new Big.Box({ y_align: Big.BoxAlignment.CENTER });
-            let label = new Clutter.Text({ text: metaWindow.title,
-                                           font_name: WELL_MENU_FONT,
-                                           ellipsize: Pango.EllipsizeMode.END,
-                                           color: WELL_MENU_COLOR });
-            vCenter.append(label, Big.BoxPackFlags.NONE);
-            box.append(vCenter, Big.BoxPackFlags.NONE);
-            this._windowContainer.append(box, Big.BoxPackFlags.NONE);
-        }
-    },
-
-    popup: function() {
-        let [stageX, stageY] = this._source.actor.get_transformed_position();
-        let [stageWidth, stageHeight] = this._source.actor.get_transformed_size();
-
-        this._redisplay();
-
-        this._windowContainer.popup(0, Clutter.get_current_event_time());
-
-        this.emit('popup', true);
-
-        let x = Math.floor(stageX + stageWidth);
-        let y = Math.floor(stageY + (stageHeight / 2) - (this.actor.height / 2));
-        this.actor.set_position(x, y);
-        this.actor.show();
-    },
-
-    _findWindowCloneForActor: function (actor) {
-        if (actor._delegate instanceof Workspaces.WindowClone)
-            return actor._delegate;
-        return null;
-    },
-
-    // This function is called while the menu has a pointer grab; what we want
-    // to do is see if the mouse was released over a window clone actor
-    _onMenuButtonRelease: function (actor, event) {
-        let clone = this._findWindowCloneForActor(event.get_source());
-        if (clone) {
-            this.didActivateWindow = true;
-            Main.overview.activateWindow(clone.metaWindow, event.get_time());
-        }
-    },
-
-    _setHighlightWindow: function (metaWindow) {
-        let children = this._windowContainer.get_children();
-        for (let i = 0; i < children.length; i++) {
-            let child = children[i];
-            let menuMetaWindow = child._window;
-            if (metaWindow != null && menuMetaWindow == metaWindow) {
-                child.background_color = WELL_MENU_SELECTED_COLOR;
-            } else {
-                child.background_color = TRANSPARENT_COLOR;
-            }
-        }
-        this.emit('highlight-window', metaWindow);
-    },
-
-    // Called while menu has a pointer grab
-    _onMenuEnter: function (actor, event) {
-        let clone = this._findWindowCloneForActor(event.get_source());
-        if (clone) {
-            this._setHighlightWindow(clone.metaWindow);
-        }
-    },
-
-    // Called while menu has a pointer grab
-    _onMenuLeave: function (actor, event) {
-        let clone = this._findWindowCloneForActor(event.get_source());
-        if (clone) {
-            this._setHighlightWindow(null);
-        }
-    },
-
-    _onWindowUnselected: function (actor, child) {
-        this._setHighlightWindow(null);
-    },
-
-    _onWindowSelected: function (actor, child) {
-        this._setHighlightWindow(child._window);
-    },
-
-    _onWindowActivate: function (actor, child) {
-        let metaWindow = child._window;
-        this.didActivateWindow = true;
-        Main.overview.activateWindow(metaWindow, Clutter.get_current_event_time());
-        this.emit('popup', false);
-        this.actor.hide();
-    },
-
-    _onWindowSelectionCancelled: function () {
-        this.emit('highlight-window', null);
-        this.emit('popup', false);
-        this.actor.hide();
-    }
-}
-
-Signals.addSignalMethods(WellMenu.prototype);
-
-function BaseWellItem(appInfo, isFavorite) {
-    this._init(appInfo, isFavorite);
+function BaseWellItem(appInfo, isFavorite, hasMenu) {
+    this._init(appInfo, isFavorite, hasMenu);
 }
 
 BaseWellItem.prototype = {
+    __proto__: AppIcon.AppIcon.prototype,
+
     _init: function(appInfo, isFavorite) {
-        this.appInfo = appInfo;
+        AppIcon.AppIcon.prototype._init.call(this, { appInfo: appInfo,
+                                                     menuType: AppIcon.MenuType.ON_RIGHT,
+                                                     glow: true });
+
         this.isFavorite = isFavorite;
-        this.icon = new AppIcon.AppIcon(appInfo);
-        this.windows = this.icon.windows;
-        this.actor = new Shell.ButtonBox({ orientation: Big.BoxOrientation.VERTICAL,
-                                           border: WELL_MENU_BORDER_WIDTH,
-                                           corner_radius: WELL_MENU_CORNER_RADIUS,
-                                           reactive: true });
-        this.icon.actor._delegate = this;
-        this._draggable = DND.makeDraggable(this.icon.actor, true);
+
+        this._draggable = DND.makeDraggable(this.actor, true);
 
         // Do these as anonymous functions to avoid conflict with handlers in subclasses
         this.actor.connect('button-press-event', Lang.bind(this, function(actor, event) {
@@ -751,15 +504,14 @@ BaseWellItem.prototype = {
             if (!hover) {
                 if (this.actor.pressed && this._dragStartX != null) {
                     this.actor.fake_release();
-                    this._draggable.startDrag(this.icon.actor, this._dragStartX, this._dragStartY,
-                                              Clutter.get_current_event_time());
+                    this._draggable.startDrag(this._dragStartX, this._dragStartY,
+                                              Main.currentTime());
                 } else {
                     this._dragStartX = null;
                     this._dragStartY = null;
                 }
             }
         }));
-        this.actor.append(this.icon.actor, Big.BoxPackFlags.NONE);
     },
 
     shellWorkspaceLaunch : function() {
@@ -774,14 +526,14 @@ BaseWellItem.prototype = {
         this.appInfo.launch();
     },
 
-    getDragActor: function(stageX, stageY) {
-        return this.icon.getDragActor(stageX, stageY);
+    getDragActor: function() {
+        return this.createDragActor();
     },
 
     // Returns the original icon that is being used as a source for the cloned texture
     // that represents the item as it is being dragged.
     getDragActorSource: function() {
-        return this.icon.getDragActorSource();
+        return this.actor;
     }
 }
 
@@ -795,23 +547,14 @@ RunningWellItem.prototype = {
     _init: function(appInfo, isFavorite) {
         BaseWellItem.prototype._init.call(this, appInfo, isFavorite);
 
-        this._menuTimeoutId = 0;
-        this._menu = null;
         this._dragStartX = 0;
         this._dragStartY = 0;
 
-        this.actor.connect('button-press-event', Lang.bind(this, this._onButtonPress));
-        this.actor.connect('notify::hover', Lang.bind(this, this._onHoverChanged));
         this.actor.connect('activate', Lang.bind(this, this._onActivate));
     },
 
     _onActivate: function (actor, event) {
-        let modifiers = event.get_state();
-
-        if (this._menuTimeoutId > 0) {
-            Mainloop.source_remove(this._menuTimeoutId);
-            this._menuTimeoutId = 0;
-        }
+        let modifiers = Shell.get_event_state(event);
 
         if (modifiers & Clutter.ModifierType.CONTROL_MASK) {
             this.appInfo.launch();
@@ -823,56 +566,32 @@ RunningWellItem.prototype = {
     activateMostRecentWindow: function () {
         // The _get_windows_for_app sorts them for us
         let mostRecentWindow = this.windows[0];
-        Main.overview.activateWindow(mostRecentWindow, Clutter.get_current_event_time());
+        Main.overview.activateWindow(mostRecentWindow, Main.currentTime());
     },
 
-    _onHoverChanged: function() {
-        let hover = this.actor.hover;
-        if (!hover && this._menuTimeoutId > 0) {
-            Mainloop.source_remove(this._menuTimeoutId);
-            this._menuTimeoutId = 0;
-        }
-    },
-
-    _onButtonPress: function(actor, event) {
-        if (this._menuTimeoutId > 0)
-            Mainloop.source_remove(this._menuTimeoutId);
-        this._menuTimeoutId = Mainloop.timeout_add(WELL_MENU_POPUP_TIMEOUT_MS,
-                                                   Lang.bind(this, this._popupMenu));
-        return false;
-    },
-
-    _popupMenu: function() {
-        this._menuTimeoutId = 0;
-
-        this.actor.fake_release();
-
-        if (this._menu == null) {
-            this._menu = new WellMenu(this);
-            this._menu.connect('highlight-window', Lang.bind(this, function (menu, metaWindow) {
+    highlightWindow: function(metaWindow) {
         Main.overview.getWorkspacesForWindow(metaWindow).setHighlightWindow(metaWindow);
-            }));
-            this._menu.connect('popup', Lang.bind(this, function (menu, isPoppedUp) {
-                let id;
+    },
 
-                // If we successfully picked a window, don't reset the workspace
-                // state, since picking a window already did that.
-                if (!isPoppedUp && menu.didActivateWindow)
+    activateWindow: function(metaWindow) {
+        if (metaWindow) {
+            this._didActivateWindow = true;
+            Main.overview.activateWindow(metaWindow, Main.currentTime());
+        } else
+            Main.overview.hide();
+    },
+
+    menuPoppedUp: function() {
+        Main.overview.getWorkspacesForWindow(null).setApplicationWindowSelection(this.appInfo.get_id());
+    },
+
+    menuPoppedDown: function() {
+        if (this._didActivateWindow)
             return;
-                if (isPoppedUp)
-                    id = this.appInfo.get_id();
-                else
-                    id = null;
 
-                Main.overview.getWorkspacesForWindow(null).setApplicationWindowSelection(id);
-            }));
+        Main.overview.getWorkspacesForWindow(null).setApplicationWindowSelection(null);
     }
-
-        this._menu.popup();
-
-        return false;
-    }
-}
+};
 
 function InactiveWellItem(appInfo, isFavorite) {
     this._init(appInfo, isFavorite);
@@ -885,21 +604,11 @@ InactiveWellItem.prototype = {
         BaseWellItem.prototype._init.call(this, appInfo, isFavorite);
 
         this.actor.connect('notify::pressed', Lang.bind(this, this._onPressedChanged));
-        this.actor.connect('notify::hover', Lang.bind(this, this._onHoverChanged));
         this.actor.connect('activate', Lang.bind(this, this._onActivate));
     },
 
     _onPressedChanged: function() {
-        let pressed = this.actor.pressed;
-        if (pressed) {
-            this.actor.border_color = WELL_MENU_BORDER_COLOR;
-        } else {
-            this.actor.border_color = TRANSPARENT_COLOR;
-        }
-    },
-
-    _onHoverChanged: function() {
-        let hover = this.actor.hover;
+        this.setHighlight(this.actor.pressed);
     },
 
     _onActivate: function() {
@@ -909,6 +618,12 @@ InactiveWellItem.prototype = {
             return true;
         }
         return false;
+    },
+
+    menuPoppedUp: function() {
+    },
+
+    menuPoppedDown: function() {
     }
 };
 
@@ -938,9 +653,8 @@ WellGrid.prototype = {
             nColumns = children.length;
         else
             nColumns = WELL_DEFAULT_COLUMNS;
-        let spacing = Math.max(nColumns - 1, 0) * WELL_ITEM_HSPACING;
-        alloc.min_size = itemMin * nColumns + spacing;
-        alloc.natural_size = itemNatural * nColumns + spacing;
+        alloc.min_size = itemMin;
+        alloc.natural_size = itemNatural * nColumns;
     },
 
     _getPreferredHeight: function (grid, forWidth, alloc) {
@@ -977,10 +691,8 @@ WellGrid.prototype = {
             childBox.y2 = childBox.y1 + itemHeight;
             children[i].allocate(childBox, flags);
 
-            let atSeparator = (i == this._separatorIndex - 1);
-
             columnIndex++;
-            if (columnIndex == columns || atSeparator) {
+            if (columnIndex == columns) {
                 columnIndex = 0;
             }
 
@@ -988,29 +700,9 @@ WellGrid.prototype = {
                 y += itemHeight + WELL_ITEM_VSPACING;
                 x = box.x1;
             } else {
-                x += itemWidth + WELL_ITEM_HSPACING;
-            }
-
-            if (atSeparator) {
-                y += separatorNatural + WELL_ITEM_VSPACING;
+                x += itemWidth;
             }
         }
-
-        let separatorRowIndex = Math.ceil(this._separatorIndex / columns);
-
-        /* Allocate the separator */
-        let childBox = new Clutter.ActorBox();
-        childBox.x1 = box.x1;
-        childBox.y1 = (itemHeight + WELL_ITEM_VSPACING) * separatorRowIndex;
-        this._cachedSeparatorY = childBox.y1;
-        childBox.x2 = box.x2;
-        childBox.y2 = childBox.y1+separatorNatural;
-        this._separator.allocate(childBox, flags);
-    },
-
-    setSeparatorIndex: function (index) {
-        this._separatorIndex = index;
-        this.actor.queue_relayout();
     },
 
     removeAll: function () {
@@ -1018,11 +710,6 @@ WellGrid.prototype = {
         for (let i = 0; i < itemChildren.length; i++) {
             itemChildren[i].destroy();
         }
-        this._separatorIndex = 0;
-    },
-
-    isBeforeSeparator: function(x, y) {
-        return y < this._cachedSeparatorY;
     },
 
     _getItemChildren: function () {
@@ -1038,29 +725,40 @@ WellGrid.prototype = {
         let children = this._getItemChildren();
         if (children.length == 0)
             return [0, WELL_DEFAULT_COLUMNS, 0, 0];
-        let nColumns;
-        if (children.length < WELL_DEFAULT_COLUMNS)
-            nColumns = children.length;
-         else
+        let nColumns = 0;
+        let usedWidth = 0;
+        // Big.Box will allocate us at 0x0 if we are not visible; this is probably a
+        // Big.Box bug but it can't be fixed because if children are skipped in allocate()
+        // Clutter gets confused (see http://bugzilla.openedhand.com/show_bug.cgi?id=1831)
+        if (forWidth <= 0) {
             nColumns = WELL_DEFAULT_COLUMNS;
-
-        if (forWidth >= 0 && forWidth < minWidth) {
-           log("WellGrid: trying to allocate for width " + forWidth + " but min is " + minWidth);
-           /* FIXME - we should fall back to fewer than WELL_DEFAULT_COLUMNS here */
+        } else {
+            while (nColumns < WELL_DEFAULT_COLUMNS &&
+                   nColumns < children.length &&
+                   usedWidth + itemMinWidth <= forWidth) {
+               // By including WELL_ITEM_MIN_HSPACING in usedWidth, we are ensuring
+               // that the number of columns we end up with will allow the spacing
+               // between the columns to be at least that value.
+               usedWidth += itemMinWidth + WELL_ITEM_MIN_HSPACING;
+               nColumns++;
+            }
         }
 
-        let horizSpacingTotal = Math.max(nColumns - 1, 0) * WELL_ITEM_HSPACING;
-        let minWidth = itemMinWidth * nColumns + horizSpacingTotal;
+        if (nColumns == 0) {
+           log("WellGrid: couldn't fit a column in width " + forWidth);
+           /* FIXME - fall back to smaller icon size */
+        }
+
+        let minWidth = itemMinWidth * nColumns;
 
         let lastColumnIndex = nColumns - 1;
-        let separatorColumns = lastColumnIndex - ((lastColumnIndex + this._separatorIndex) % nColumns);
-        let rows = Math.ceil((children.length + separatorColumns) / nColumns);
+        let rows = Math.ceil(children.length / nColumns);
 
         let itemWidth;
-        if (forWidth < 0) {
+        if (forWidth <= 0) {
             itemWidth = itemNaturalWidth;
         } else {
-            itemWidth = Math.max(forWidth - horizSpacingTotal, 0) / nColumns;
+            itemWidth = Math.floor(forWidth / nColumns);
         }
 
         let itemNaturalHeight = 0;
@@ -1070,7 +768,7 @@ WellGrid.prototype = {
                 itemNaturalHeight = childNatural;
         }
 
-        return [rows, WELL_DEFAULT_COLUMNS, itemWidth, itemNaturalHeight];
+        return [rows, nColumns, itemWidth, itemNaturalHeight];
     },
 
     _getItemPreferredWidth: function () {
@@ -1101,6 +799,9 @@ AppWell.prototype = {
                                    x_align: Big.BoxAlignment.CENTER });
         this.actor._delegate = this;
 
+        this._pendingRedisplay = false;
+        this.actor.connect('notify::mapped', Lang.bind(this, this._onMappedNotify));
+
         this._grid = new WellGrid();
         this.actor.append(this._grid.actor, Big.BoxPackFlags.EXPAND);
 
@@ -1140,7 +841,20 @@ AppWell.prototype = {
                             values[id] = index; return values; }, {});
     },
 
+    _onMappedNotify: function() {
+        let mapped = this.actor.mapped;
+        if (mapped && this._pendingRedisplay)
+            this._redisplay();
+    },
+
     _redisplay: function () {
+        let mapped = this.actor.mapped;
+        if (!mapped) {
+            this._pendingRedisplay = true;
+            return;
+        }
+        this._pendingRedisplay = false;
+
         this._grid.removeAll();
 
         let favoriteIds = this._appSystem.get_favorites();
@@ -1156,7 +870,6 @@ AppWell.prototype = {
 
         let displays = []
         this._addApps(favorites, true);
-        this._grid.setSeparatorIndex(favorites.length);
         this._addApps(running, false);
         this._displays = displays;
     },
@@ -1179,9 +892,7 @@ AppWell.prototype = {
         let appSystem = Shell.AppSystem.get_default();
 
         let app = null;
-        if (source instanceof BaseWellItem) {
-            app = source.appInfo;
-        } else if (source instanceof AppDisplayItem) {
+        if (source instanceof AppDisplayItem) {
             app = appSystem.lookup_cached_app(source.getId());
         } else if (source instanceof Workspaces.WindowClone) {
             let appMonitor = Shell.AppMonitor.get_default();
@@ -1198,22 +909,15 @@ AppWell.prototype = {
         let favoriteIds = this._appSystem.get_favorites();
         let favoriteIdsObject = this._arrayValues(favoriteIds);
 
-        let dropIsFavorite = this._grid.isBeforeSeparator(x - this._grid.actor.x,
-                                                          y - this._grid.actor.y);
         let srcIsFavorite = (id in favoriteIdsObject);
 
-        if (srcIsFavorite && (!dropIsFavorite)) {
-            Mainloop.idle_add(function () {
-                appSystem.remove_favorite(id);
+        if (srcIsFavorite) {
             return false;
-            });
-        } else if ((!srcIsFavorite) && dropIsFavorite) {
+        } else {
             Mainloop.idle_add(function () {
                 appSystem.add_favorite(id);
                 return false;
             });
-        } else {
-            return false;
         }
 
         return true;

js/ui/appIcon.js

@@ -3,48 +3,107 @@
 const Big = imports.gi.Big;
 const Clutter = imports.gi.Clutter;
 const GLib = imports.gi.GLib;
+const Lang = imports.lang;
+const Mainloop = imports.mainloop;
 const Pango = imports.gi.Pango;
 const Shell = imports.gi.Shell;
-const Lang = imports.lang;
+const Signals = imports.signals;
+const Gettext = imports.gettext.domain('gnome-shell');
+const _ = Gettext.gettext;
 
 const GenericDisplay = imports.ui.genericDisplay;
 const Main = imports.ui.main;
+const Workspaces = imports.ui.workspaces;
 
 const GLOW_COLOR = new Clutter.Color();
 GLOW_COLOR.from_pixel(0x4f6ba4ff);
 const GLOW_PADDING_HORIZONTAL = 3;
 const GLOW_PADDING_VERTICAL = 3;
 
-const APP_ICON_SIZE = 48;
+const APPICON_DEFAULT_ICON_SIZE = 48;
 
-function AppIcon(appInfo) {
-    this._init(appInfo);
+const APPICON_PADDING = 1;
+const APPICON_BORDER_WIDTH = 1;
+const APPICON_CORNER_RADIUS = 4;
+
+const APPICON_MENU_POPUP_TIMEOUT_MS = 600;
+
+const APPICON_DEFAULT_BORDER_COLOR = new Clutter.Color();
+APPICON_DEFAULT_BORDER_COLOR.from_pixel(0x787878ff);
+const APPICON_MENU_BACKGROUND_COLOR = new Clutter.Color();
+APPICON_MENU_BACKGROUND_COLOR.from_pixel(0x292929ff);
+const APPICON_MENU_FONT = 'Sans 14px';
+const APPICON_MENU_COLOR = new Clutter.Color();
+APPICON_MENU_COLOR.from_pixel(0xffffffff);
+const APPICON_MENU_SELECTED_COLOR = new Clutter.Color();
+APPICON_MENU_SELECTED_COLOR.from_pixel(0x005b97ff);
+const APPICON_MENU_SEPARATOR_COLOR = new Clutter.Color();
+APPICON_MENU_SEPARATOR_COLOR.from_pixel(0x787878ff);
+const APPICON_MENU_BORDER_WIDTH = 1;
+const APPICON_MENU_ARROW_SIZE = 12;
+const APPICON_MENU_CORNER_RADIUS = 4;
+const APPICON_MENU_PADDING = 4;
+
+const TRANSPARENT_COLOR = new Clutter.Color();
+TRANSPARENT_COLOR.from_pixel(0x00000000);
+
+const MenuType = { NONE: 0, ON_RIGHT: 1, BELOW: 2 };
+
+function AppIcon(params) {
+    this._init(params);
 }
 
 AppIcon.prototype = {
-    _init : function(appInfo) {
-        this.appInfo = appInfo;
-        this.windows = Shell.AppMonitor.get_default().get_windows_for_app(appInfo.get_id());
+    _init : function(params) {
+        this.appInfo = params.appInfo;
+        if (!this.appInfo)
+            throw new Error('AppIcon constructor requires "appInfo" param');
+
+        this._menuType = ('menuType' in params) ? params.menuType : MenuType.NONE;
+        this._iconSize = ('size' in params) ? params.size : APPICON_DEFAULT_ICON_SIZE;
+        let showGlow = ('glow' in params) ? params.glow : false;
+
+        this.actor = new Shell.ButtonBox({ orientation: Big.BoxOrientation.VERTICAL,
+                                           border: APPICON_BORDER_WIDTH,
+                                           corner_radius: APPICON_CORNER_RADIUS,
+                                           padding: APPICON_PADDING,
+                                           reactive: true });
+        this.actor._delegate = this;
+        this.highlight_border_color = APPICON_DEFAULT_BORDER_COLOR;
+        this._signalIds = [];
+
+        // Note, we don't presently update the window list dynamically here; this actor
+        // gets destroyed and recreated by AppWell, and in alt-tab the whole thing is
+        // created each time
+        this.windows = Shell.AppMonitor.get_default().get_windows_for_app(this.appInfo.get_id());
         for (let i = 0; i < this.windows.length; i++) {
-            this.windows[i].connect('notify::user-time', Lang.bind(this, this._resortWindows));
+            let sigId = this.windows[i].connect('notify::user-time', Lang.bind(this, this._resortWindows));
+            this._signalIds.push([this.windows[i], sigId]);
         }
         this._resortWindows();
 
-        this.actor = new Big.Box({ orientation: Big.BoxOrientation.VERTICAL,
-                                   corner_radius: 2,
-                                   padding: 1,
-                                   reactive: true });
+        this.actor.connect('destroy', Lang.bind(this, this._destroy));
+        this.actor.connect('notify::mapped', Lang.bind(this, this._onMappedChanged));
+
+        if (this._menuType != MenuType.NONE) {
+            this.actor.connect('button-press-event', Lang.bind(this, this._updateMenuOnButtonPress));
+            this.actor.connect('notify::hover', Lang.bind(this, this._updateMenuOnHoverChanged));
+            this.actor.connect('activate', Lang.bind(this, this._updateMenuOnActivate));
+
+            this._menuTimeoutId = 0;
+            this._menu = null;
+        }
 
         let iconBox = new Big.Box({ orientation: Big.BoxOrientation.VERTICAL,
                                     x_align: Big.BoxAlignment.CENTER,
-                                    y_align: Big.BoxAlignment.CENTER });
-        this.icon = appInfo.create_icon_texture(APP_ICON_SIZE);
+                                    y_align: Big.BoxAlignment.CENTER,
+                                    width: this._iconSize,
+                                    height: this._iconSize });
+        this.icon = this.appInfo.create_icon_texture(this._iconSize);
         iconBox.append(this.icon, Big.BoxPackFlags.NONE);
 
         this.actor.append(iconBox, Big.BoxPackFlags.EXPAND);
 
-        this._windows = Shell.AppMonitor.get_default().get_windows_for_app(appInfo.get_id());
-
         let nameBox = new Shell.GenericContainer();
         nameBox.connect('get-preferred-width', Lang.bind(this, this._nameBoxGetPreferredWidth));
         nameBox.connect('get-preferred-height', Lang.bind(this, this._nameBoxGetPreferredHeight));
@@ -55,11 +114,12 @@ AppIcon.prototype = {
                                         font_name: "Sans 12px",
                                         line_alignment: Pango.Alignment.CENTER,
                                         ellipsize: Pango.EllipsizeMode.END,
-                                        text: appInfo.get_name() });
+                                        text: this.appInfo.get_name() });
         nameBox.add_actor(this._name);
+        if (showGlow) {
             this._glowBox = new Big.Box({ orientation: Big.BoxOrientation.HORIZONTAL });
             let glowPath = GLib.filename_to_uri(global.imagedir + 'app-well-glow.png', '');
-        for (let i = 0; i < this._windows.length && i < 3; i++) {
+            for (let i = 0; i < this.windows.length && i < 3; i++) {
                 let glow = Shell.TextureCache.get_default().load_uri_sync(Shell.TextureCachePolicy.FOREVER,
                                                                           glowPath, -1, -1);
                 glow.keep_aspect_ratio = false;
@@ -67,6 +127,10 @@ AppIcon.prototype = {
             }
             this._nameBox.add_actor(this._glowBox);
             this._glowBox.lower(this._name);
+        }
+        else
+            this._glowBox = null;
+
         this.actor.append(nameBox, Big.BoxPackFlags.NONE);
     },
 
@@ -111,23 +175,462 @@ AppIcon.prototype = {
         }
     },
 
+    _destroy: function() {
+        for (let i = 0; i < this._signalIds.length; i++) {
+            let [obj, sigId] = this._signalIds[i];
+            obj.disconnect(sigId);
+        }
+    },
+
+    _onMappedChanged: function() {
+        let mapped = this.actor.mapped;
+        if (mapped && this._windowSortStale)
+            this._resortWindows();
+    },
+
     _resortWindows: function() {
+        let mapped = this.actor.mapped;
+        if (!mapped) {
+            this._windowSortStale = true;
+            return;
+        }
+        this._windowSortStale = false;
         this.windows.sort(function (a, b) {
-            let timeA = a.get_user_time();
-            let timeB = b.get_user_time();
-            if (timeA == timeB)
-                return 0;
-            else if (timeA > timeB)
+            let activeWorkspace = global.screen.get_active_workspace();
+            let wsA = a.get_workspace() == activeWorkspace;
+            let wsB = b.get_workspace() == activeWorkspace;
+
+            if (wsA && !wsB)
                 return -1;
+            else if (wsB && !wsA)
                 return 1;
+
+            let visA = a.showing_on_its_workspace();
+            let visB = b.showing_on_its_workspace();
+
+            if (visA && !visB)
+                return -1;
+            else if (visB && !visA)
+                return 1;
+            else
+                return b.get_user_time() - a.get_user_time();
         });
     },
 
-    getDragActor: function() {
-        return this.appInfo.create_icon_texture(APP_ICON_SIZE);
+    // AppIcon itself is not a draggable, but if you want to make
+    // a subclass of it draggable, you can use this method to create
+    // a drag actor
+    createDragActor: function() {
+        return this.appInfo.create_icon_texture(this._iconSize);
     },
 
-    getDragActorSource: function() {
-        return this.icon;
+    setHighlight: function(highlight) {
+        if (highlight) {
+            this.actor.border_color = this.highlight_border_color;
+        } else {
+            this.actor.border_color = TRANSPARENT_COLOR;
+        }
+    },
+
+    _updateMenuOnActivate: function(actor, event) {
+        if (this._menuTimeoutId != 0) {
+            Mainloop.source_remove(this._menuTimeoutId);
+            this._menuTimeoutId = 0;
+        }
+        this.emit('activate');
+        return false;
+    },
+
+    _updateMenuOnHoverChanged: function() {
+        if (!this.actor.hover && this._menuTimeoutId != 0) {
+            Mainloop.source_remove(this._menuTimeoutId);
+            this._menuTimeoutId = 0;
+        }
+        return false;
+    },
+
+    _updateMenuOnButtonPress: function(actor, event) {
+        let button = event.get_button();
+        if (button == 1) {
+            if (this._menuTimeoutId != 0)
+                Mainloop.source_remove(this._menuTimeoutId);
+            this._menuTimeoutId = Mainloop.timeout_add(APPICON_MENU_POPUP_TIMEOUT_MS,
+                                                       Lang.bind(this, function () { this.popupMenu(button); }));
+        } else if (button == 3) {
+            this.popupMenu(button);
+        }
+        return false;
+    },
+
+    popupMenu: function(activatingButton) {
+        if (this._menuTimeoutId != 0) {
+            Mainloop.source_remove(this._menuTimeoutId);
+            this._menuTimeoutId = 0;
+        }
+
+        this.actor.fake_release();
+
+        if (!this._menu) {
+            this._menu = new AppIconMenu(this, this._menuType);
+            this._menu.connect('highlight-window', Lang.bind(this, function (menu, window) {
+                this.highlightWindow(window);
+            }));
+            this._menu.connect('activate-window', Lang.bind(this, function (menu, window) {
+                this.activateWindow(window);
+            }));
+            this._menu.connect('popup', Lang.bind(this, function (menu, isPoppedUp) {
+                if (isPoppedUp)
+                    this.menuPoppedUp();
+                else
+                    this.menuPoppedDown();
+            }));
+        }
+
+        this._menu.popup(activatingButton);
+
+        return false;
+    },
+
+    // Default implementations; AppDisplay.RunningWellItem overrides these
+    highlightWindow: function(window) {
+        this.emit('highlight-window', window);
+    },
+
+    activateWindow: function(window) {
+        this.emit('activate-window', window);
+    },
+
+    menuPoppedUp: function() {
+        this.emit('menu-popped-up', this._menu);
+    },
+
+    menuPoppedDown: function() {
+        this.emit('menu-popped-down', this._menu);
     }
 };
+
+Signals.addSignalMethods(AppIcon.prototype);
+
+function AppIconMenu(source, type) {
+    this._init(source, type);
+}
+
+AppIconMenu.prototype = {
+    _init: function(source, type) {
+        this._source = source;
+        this._type = type;
+
+        this.actor = new Shell.GenericContainer({ reactive: true });
+        this.actor.connect('get-preferred-width', Lang.bind(this, this._getPreferredWidth));
+        this.actor.connect('get-preferred-height', Lang.bind(this, this._getPreferredHeight));
+        this.actor.connect('allocate', Lang.bind(this, this._allocate));
+
+        this._windowContainer = new Shell.Menu({ orientation: Big.BoxOrientation.VERTICAL,
+                                                 border_color: source.highlight_border_color,
+                                                 border: APPICON_MENU_BORDER_WIDTH,
+                                                 background_color: APPICON_MENU_BACKGROUND_COLOR,
+                                                 padding: 4,
+                                                 corner_radius: APPICON_MENU_CORNER_RADIUS,
+                                                 width: Main.overview._dash.actor.width * 0.75 });
+        this._windowContainer.connect('unselected', Lang.bind(this, this._onItemUnselected));
+        this._windowContainer.connect('selected', Lang.bind(this, this._onItemSelected));
+        this._windowContainer.connect('cancelled', Lang.bind(this, this._onWindowSelectionCancelled));
+        this._windowContainer.connect('activate', Lang.bind(this, this._onItemActivate));
+        this.actor.add_actor(this._windowContainer);
+
+        // Stay popped up on release over application icon
+        this._windowContainer.set_persistent_source(this._source.actor);
+
+        // Intercept events while the menu has the pointer grab to do window-related effects
+        this._windowContainer.connect('enter-event', Lang.bind(this, this._onMenuEnter));
+        this._windowContainer.connect('leave-event', Lang.bind(this, this._onMenuLeave));
+        this._windowContainer.connect('button-release-event', Lang.bind(this, this._onMenuButtonRelease));
+
+        this._arrow = new Shell.DrawingArea();
+        this._arrow.connect('redraw', Lang.bind(this, function (area, texture) {
+            Shell.draw_box_pointer(texture,
+                                   this._type == MenuType.ON_RIGHT ? Shell.PointerDirection.LEFT : Shell.PointerDirection.UP,
+                                   source.highlight_border_color,
+                                   APPICON_MENU_BACKGROUND_COLOR);
+        }));
+        this.actor.add_actor(this._arrow);
+
+        // Chain our visibility and lifecycle to that of the source
+        source.actor.connect('notify::mapped', Lang.bind(this, function () {
+            if (!source.actor.mapped)
+                this._windowContainer.popdown();
+        }));
+        source.actor.connect('destroy', Lang.bind(this, function () { this.actor.destroy(); }));
+
+        global.stage.add_actor(this.actor);
+    },
+
+    _getPreferredWidth: function(actor, forHeight, alloc) {
+        let [min, natural] = this._windowContainer.get_preferred_width(forHeight);
+        if (this._type == MenuType.ON_RIGHT) {
+            min += APPICON_MENU_ARROW_SIZE;
+            natural += APPICON_MENU_ARROW_SIZE;
+        }
+        alloc.min_size = min;
+        alloc.natural_size = natural;
+    },
+
+    _getPreferredHeight: function(actor, forWidth, alloc) {
+        let [min, natural] = this._windowContainer.get_preferred_height(forWidth);
+        if (this._type == MenuType.BELOW) {
+            min += APPICON_MENU_ARROW_SIZE;
+            natural += APPICON_MENU_ARROW_SIZE;
+        }
+        alloc.min_size = min;
+        alloc.natural_size = natural;
+    },
+
+    _allocate: function(actor, box, flags) {
+        let childBox = new Clutter.ActorBox();
+
+        let width = box.x2 - box.x1;
+        let height = box.y2 - box.y1;
+
+        if (this._type == MenuType.ON_RIGHT) {
+            childBox.x1 = 0;
+            childBox.x2 = APPICON_MENU_ARROW_SIZE;
+            childBox.y1 = Math.floor((height / 2) - (APPICON_MENU_ARROW_SIZE / 2));
+            childBox.y2 = childBox.y1 + APPICON_MENU_ARROW_SIZE;
+            this._arrow.allocate(childBox, flags);
+
+            childBox.x1 = APPICON_MENU_ARROW_SIZE - APPICON_MENU_BORDER_WIDTH;
+            childBox.x2 = width;
+            childBox.y1 = 0;
+            childBox.y2 = height;
+            this._windowContainer.allocate(childBox, flags);
+        } else /* MenuType.BELOW */ {
+            childBox.x1 = Math.floor((width / 2) - (APPICON_MENU_ARROW_SIZE / 2));
+            childBox.x2 = childBox.x1 + APPICON_MENU_ARROW_SIZE;
+            childBox.y1 = 0;
+            childBox.y2 = APPICON_MENU_ARROW_SIZE;
+            this._arrow.allocate(childBox, flags);
+
+            childBox.x1 = 0;
+            childBox.x2 = width;
+            childBox.y1 = APPICON_MENU_ARROW_SIZE - APPICON_MENU_BORDER_WIDTH;
+            childBox.y2 = height;
+            this._windowContainer.allocate(childBox, flags);
+        }
+    },
+
+    _redisplay: function() {
+        this._windowContainer.remove_all();
+
+        let windows = this._source.windows;
+
+        this._windowContainer.show();
+
+        let iconsDiffer = false;
+        let texCache = Shell.TextureCache.get_default();
+        if (windows.length > 0) {
+            let firstIcon = windows[0].mini_icon;
+            for (let i = 1; i < windows.length; i++) {
+                if (!texCache.pixbuf_equal(windows[i].mini_icon, firstIcon)) {
+                    iconsDiffer = true;
+                    break;
+                }
+            }
+        }
+
+        // Display the app windows menu items and the separator between windows
+        // of the current desktop and other windows.
+        let activeWorkspace = global.screen.get_active_workspace();
+        let separatorShown = windows.length > 0 && windows[0].get_workspace() != activeWorkspace;
+
+        for (let i = 0; i < windows.length; i++) {
+            if (!separatorShown && windows[i].get_workspace() != activeWorkspace) {
+                this._appendSeparator();
+                separatorShown = true;
+            }
+
+            let icon = null;
+            if (iconsDiffer)
+                icon = Shell.TextureCache.get_default().bind_pixbuf_property(windows[i], "mini-icon");
+
+            let box = this._appendMenuItem(icon, windows[i].title);
+            box._window = windows[i];
+        }
+
+        if (windows.length > 0)
+            this._appendSeparator();
+
+        this._newWindowMenuItem = windows.length > 0 ? this._appendMenuItem(null, _("New Window")) : null;
+
+        let favorites = Shell.AppSystem.get_default().get_favorites();
+        let id = this._source.appInfo.get_id();
+        this._isFavorite = false;
+        for (let i = 0; i < favorites.length; i++) {
+            if (id == favorites[i]) {
+                this._isFavorite = true;
+                break;
+            }
+        }
+        if (windows.length > 0)
+            this._appendSeparator();
+        this._toggleFavoriteMenuItem = this._appendMenuItem(null, this._isFavorite ? _("Remove from favorites")
+                                                                    : _("Add to favorites"));
+
+        this._highlightedItem = null;
+    },
+
+    _appendSeparator: function () {
+        let box = new Big.Box({ padding_top: 2, padding_bottom: 2 });
+        box.append(new Clutter.Rectangle({ height: 1,
+                                           color: APPICON_MENU_SEPARATOR_COLOR }),
+                   Big.BoxPackFlags.EXPAND);
+        this._windowContainer.append_separator(box, Big.BoxPackFlags.NONE);
+    },
+
+    _appendMenuItem: function(iconTexture, labelText) {
+        /* Use padding here rather than spacing in the box above so that
+         * we have a larger reactive area.
+         */
+        let box = new Big.Box({ orientation: Big.BoxOrientation.HORIZONTAL,
+                                padding_top: 4,
+                                padding_bottom: 4,
+                                spacing: 4,
+                                reactive: true });
+        let vCenter;
+        if (iconTexture != null) {
+            vCenter = new Big.Box({ y_align: Big.BoxAlignment.CENTER });
+            vCenter.append(iconTexture, Big.BoxPackFlags.NONE);
+            box.append(vCenter, Big.BoxPackFlags.NONE);
+        }
+        vCenter = new Big.Box({ y_align: Big.BoxAlignment.CENTER });
+        let label = new Clutter.Text({ text: labelText,
+                                       font_name: APPICON_MENU_FONT,
+                                       ellipsize: Pango.EllipsizeMode.END,
+                                       color: APPICON_MENU_COLOR });
+        vCenter.append(label, Big.BoxPackFlags.NONE);
+        box.append(vCenter, Big.BoxPackFlags.NONE);
+        this._windowContainer.append(box, Big.BoxPackFlags.NONE);
+        return box;
+    },
+
+    popup: function(activatingButton) {
+        let [stageX, stageY] = this._source.actor.get_transformed_position();
+        let [stageWidth, stageHeight] = this._source.actor.get_transformed_size();
+
+        this._redisplay();
+
+        this._windowContainer.popup(activatingButton, Main.currentTime());
+
+        this.emit('popup', true);
+
+        let x, y;
+        if (this._type == MenuType.ON_RIGHT) {
+            x = Math.floor(stageX + stageWidth);
+            y = Math.floor(stageY + (stageHeight / 2) - (this.actor.height / 2));
+        } else {
+            x = Math.floor(stageX + (stageWidth / 2) - (this.actor.width / 2));
+            y = Math.floor(stageY + stageHeight);
+        }
+
+        this.actor.set_position(x, y);
+        this.actor.show();
+    },
+
+    popdown: function() {
+        this._windowContainer.popdown();
+        this.emit('popup', false);
+        this.actor.hide();
+    },
+
+    selectWindow: function(metaWindow) {
+        this._selectMenuItemForWindow(metaWindow);
+    },
+
+    _findMetaWindowForActor: function (actor) {
+        if (actor._delegate instanceof Workspaces.WindowClone)
+            return actor._delegate.metaWindow;
+        else if (actor.get_meta_window)
+            return actor.get_meta_window();
+        return null;
+    },
+
+    // This function is called while the menu has a pointer grab; what we want
+    // to do is see if the mouse was released over a window representation
+    _onMenuButtonRelease: function (actor, event) {
+        let metaWindow = this._findMetaWindowForActor(event.get_source());
+        if (metaWindow) {
+            this.emit('activate-window', metaWindow);
+        }
+    },
+
+    _updateHighlight: function (item) {
+        if (this._highlightedItem) {
+            this._highlightedItem.background_color = TRANSPARENT_COLOR;
+            this.emit('highlight-window', null);
+        }
+        this._highlightedItem = item;
+        if (this._highlightedItem) {
+            this._highlightedItem.background_color = APPICON_MENU_SELECTED_COLOR;
+            let window = this._highlightedItem._window;
+            if (window)
+                this.emit('highlight-window', window);
+        }
+    },
+
+    _selectMenuItemForWindow: function (metaWindow) {
+        let children = this._windowContainer.get_children();
+        for (let i = 0; i < children.length; i++) {
+            let child = children[i];
+            let menuMetaWindow = child._window;
+            if (menuMetaWindow == metaWindow)
+                this._updateHighlight(child);
+        }
+    },
+
+    // Called while menu has a pointer grab
+    _onMenuEnter: function (actor, event) {
+        let metaWindow = this._findMetaWindowForActor(event.get_source());
+        if (metaWindow) {
+            this._selectMenuItemForWindow(metaWindow);
+        }
+    },
+
+    // Called while menu has a pointer grab
+    _onMenuLeave: function (actor, event) {
+        let metaWindow = this._findMetaWindowForActor(event.get_source());
+        if (metaWindow) {
+            this._updateHighlight(null);
+        }
+    },
+
+    _onItemUnselected: function (actor, child) {
+        this._updateHighlight(null);
+    },
+
+    _onItemSelected: function (actor, child) {
+        this._updateHighlight(child);
+    },
+
+    _onItemActivate: function (actor, child) {
+        if (child._window) {
+            let metaWindow = child._window;
+            this.emit('activate-window', metaWindow);
+        } else if (child == this._newWindowMenuItem) {
+            this._source.appInfo.launch();
+            this.emit('activate-window', null);
+        } else if (child == this._toggleFavoriteMenuItem) {
+            let appSys = Shell.AppSystem.get_default();
+            if (this._isFavorite)
+                appSys.remove_favorite(this._source.appInfo.get_id());
+            else
+                appSys.add_favorite(this._source.appInfo.get_id());
+        }
+        this.popdown();
+    },
+
+    _onWindowSelectionCancelled: function () {
+        this.emit('highlight-window', null);
+        this.popdown();
+    }
+};
+
+Signals.addSignalMethods(AppIconMenu.prototype);

js/ui/button.js

@@ -91,11 +91,11 @@ const ANIMATION_TIME = 0.25;
  * size -- size in pixels of  both the button and the icon it contains
  * texture -- optional, must be used if the texture for the icon is already created (else, use setIconFromName)
  */
-function iconButton(parent, size, texture) {
+function IconButton(parent, size, texture) {
     this._init(parent, size, texture);
 }
 
-iconButton.prototype = {
+IconButton.prototype = {
     _init : function(parent, size, texture) {
         this._size = size;
         if (texture)
@@ -170,4 +170,3 @@ iconButton.prototype = {
                                        transition :"easeOutQuad" });
     }
 };
-

js/ui/calendar.js

@@ -0,0 +1,177 @@
+/* -*- mode: js2; js2-basic-offset: 4; indent-tabs-mode: nil -*- */
+
+const Clutter = imports.gi.Clutter;
+const Lang = imports.lang;
+const St = imports.gi.St;
+
+const Gettext_gtk20 = imports.gettext.domain('gtk20');
+
+const MSECS_IN_DAY = 24 * 60 * 60 * 1000;
+
+function _sameDay(dateA, dateB) {
+    return (dateA.getDate() == dateB.getDate() &&
+            dateA.getMonth() == dateB.getMonth() &&
+            dateA.getYear() == dateB.getYear());
+}
+
+function Calendar() {
+    this._init();
+};
+
+Calendar.prototype = {
+    _init: function() {
+        // FIXME: This is actually the fallback method for GTK+ for the week start;
+        // GTK+ by preference uses nl_langinfo (NL_TIME_FIRST_WEEKDAY). We probably
+        // should add a C function so we can do the full handling.
+        this._weekStart = NaN;
+        let weekStartString = Gettext_gtk20.gettext("calendar:week_start:0");
+        if (weekStartString.indexOf("calendar:week_start:") == 0) {
+            this._weekStart = parseInt(weekStartString.substring(20));
+        }
+
+        if (isNaN(this._weekStart) || this._weekStart < 0 || this._weekStart > 6) {
+            log("Translation of 'calendar:week_start:0' in GTK+ is not correct");
+            this.weekStart = 0;
+        }
+
+        // Find the ordering for month/year in the calendar heading
+        switch (Gettext_gtk20.gettext("calendar:MY")) {
+        case "calendar:MY":
+            this._headerFormat = "%B %Y";
+            break;
+        case "calendar:YM":
+            this._headerFormat = "%Y %B";
+            break;
+        default:
+            log("Translation of 'calendar:MY' in GTK+ is not correct");
+            this._headerFormat = "%B %Y";
+            break;
+        }
+
+        // Start off with the current date
+        this.date = new Date();
+
+        this.actor = new St.Table({ homogeneous: false,
+                                    style_class: "calendar",
+                                    reactive: true });
+
+        this.actor.connect('scroll-event',
+                           Lang.bind(this, this._onScroll));
+
+        // Top line of the calendar '<| September 2009 |>'
+        this._topBox = new St.BoxLayout();
+        this.actor.add(this._topBox,
+                       { row: 0, col: 0, col_span: 7 });
+
+        let back = new St.Button({ label: "&lt;", style_class: 'calendar-change-month'  });
+        this._topBox.add(back);
+        back.connect("clicked", Lang.bind(this, this._prevMonth));
+
+        this._dateLabel = new St.Label();
+        this._topBox.add(this._dateLabel, { expand: true, x_fill: false, x_align: St.Align.MIDDLE });
+
+        let forward = new St.Button({ label: "&gt;", style_class: 'calendar-change-month' });
+        this._topBox.add(forward);
+        forward.connect("clicked", Lang.bind(this, this._nextMonth));
+
+        // We need to figure out the abbreviated localized names for the days of the week;
+        // we do this by just getting the next 7 days starting from right now and then putting
+        // them in the right cell in the table. It doesn't matter if we add them in order
+        let iter = new Date(this.date);
+        iter.setSeconds(0); // Leap second protection. Hah!
+        iter.setHours(12);
+        for (let i = 0; i < 7; i++) {
+            this.actor.add(new St.Label({ text: iter.toLocaleFormat("%a") }),
+                           { row: 1,
+                             col: (7 + iter.getDay() - this._weekStart) % 7,
+                             x_fill: false, x_align: 1.0 });
+            iter.setTime(iter.getTime() + MSECS_IN_DAY);
+        }
+
+        // All the children after this are days, and get removed when we update the calendar
+        this._firstDayIndex = this.actor.get_children().length;
+
+        this._update();
+    },
+
+    // Sets the calendar to show a specific date
+    setDate: function(date) {
+        if (!_sameDay(date, this.date)) {
+            this.date = date;
+            this._update();
+        }
+    },
+
+    _onScroll : function(actor, event) {
+        switch (event.get_scroll_direction()) {
+        case Clutter.ScrollDirection.UP:
+        case Clutter.ScrollDirection.LEFT:
+            this._prevMonth();
+            break;
+        case Clutter.ScrollDirection.DOWN:
+        case Clutter.ScrollDirection.RIGHT:
+            this._nextMonth();
+            break;
+        }
+    },
+
+    _prevMonth: function() {
+        if (this.date.getMonth() == 0) {
+            this.date.setMonth(11);
+            this.date.setFullYear(this.date.getFullYear() - 1);
+        } else {
+            this.date.setMonth(this.date.getMonth() - 1);
+        }
+        this._update();
+   },
+
+    _nextMonth: function() {
+        if (this.date.getMonth() == 11) {
+            this.date.setMonth(0);
+            this.date.setFullYear(this.date.getFullYear() + 1);
+        } else {
+            this.date.setMonth(this.date.getMonth() + 1);
+        }
+        this._update();
+    },
+
+    _update: function() {
+        this._dateLabel.text = this.date.toLocaleFormat(this._headerFormat);
+
+        // Remove everything but the topBox and the weekday labels
+        let children = this.actor.get_children();
+        for (let i = this._firstDayIndex; i < children.length; i++)
+            children[i].destroy();
+
+        // Start at the beginning of the week before the start of the month
+        let iter = new Date(this.date);
+        iter.setDate(1);
+        iter.setSeconds(0);
+        iter.setHours(12);
+        iter.setTime(iter.getTime() - (iter.getDay() - this._weekStart) * MSECS_IN_DAY);
+
+        let now = new Date();
+
+        let row = 2;
+        while (true) {
+            let label = new St.Label({ text: iter.getDate().toString() });
+            if (_sameDay(now, iter))
+                label.style_class = "calendar-day calendar-today";
+            else if (iter.getMonth() != this.date.getMonth())
+                label.style_class = "calendar-day calendar-other-month-day";
+            else
+                label.style_class = "calendar-day";
+            this.actor.add(label,
+                           { row: row, col: (7 + iter.getDay() - this._weekStart) % 7,
+                             x_fill: false, x_align: 1.0 });
+
+            iter.setTime(iter.getTime() + MSECS_IN_DAY);
+            if (iter.getDay() == this._weekStart) {
+                // We stop on the first "first day of the week" after the month we are displaying
+                if (iter.getMonth() > this.date.getMonth() || iter.getYear() > this.date.getYear())
+                    break;
+                row++;
+            }
+        }
+    }
+};

js/ui/dash.js

@@ -397,7 +397,7 @@ MoreLink.prototype = {
 
         let text = new Clutter.Text({ font_name: "Sans 12px",
                                       color: BRIGHT_TEXT_COLOR,
-                                      text: _("Browse") });
+                                      text: _("More") });
         this.actor.append(text, Big.BoxPackFlags.NONE);
 
         this.actor.connect('button-press-event', Lang.bind(this, function (b, e) {
@@ -506,6 +506,13 @@ SectionHeader.prototype = {
             this.backLink.actor.hide();
     },
 
+    setMoreLinkVisible : function(visible) {
+        if (visible)
+            this.moreLink.actor.show();
+        else
+            this.moreLink.actor.hide();
+    },
+
     setCountText : function(countText) {
         if (countText == "") {
             this.countText.hide();
@@ -613,6 +620,7 @@ Dash.prototype = {
         /***** Search *****/
 
         this._searchActive = false;
+        this._searchPending = false;
         this._searchEntry = new SearchEntry();
         this.searchArea.append(this._searchEntry.actor, Big.BoxPackFlags.EXPAND);
 
@@ -620,7 +628,9 @@ Dash.prototype = {
         this._searchEntry.entry.connect('text-changed', Lang.bind(this, function (se, prop) {
             let text = this._searchEntry.getText();
             text = text.replace(/^\s+/g, "").replace(/\s+$/g, "")
+            let searchPreviouslyActive = this._searchActive;
             this._searchActive = text != '';
+            this._searchPending = this._searchActive && !searchPreviouslyActive;
             this._updateDashActors();
             if (!this._searchActive) {
                 if (this._searchTimeoutId > 0) {
@@ -779,8 +789,8 @@ Dash.prototype = {
 
         this._docsSection = new Section(_("RECENT DOCUMENTS"));
 
-        let docDisplay = new DocDisplay.DashDocDisplay();
-        this._docsSection.content.append(docDisplay.actor, Big.BoxPackFlags.EXPAND);
+        this._docDisplay = new DocDisplay.DashDocDisplay();
+        this._docsSection.content.append(this._docDisplay.actor, Big.BoxPackFlags.EXPAND);
 
         this._moreDocsPane = null;
         this._docsSection.header.moreLink.connect('activated', Lang.bind(this, function (link) {
@@ -792,6 +802,12 @@ Dash.prototype = {
            }
         }));
 
+        this._docDisplay.connect('changed', Lang.bind(this, function () {
+            this._docsSection.header.setMoreLinkVisible(
+                this._docDisplay.actor.get_children().length > 0);
+        }));
+        this._docDisplay.emit('changed');
+
         this.sectionArea.append(this._docsSection.actor, Big.BoxPackFlags.EXPAND);
 
         /***** Search Results *****/
@@ -871,17 +887,25 @@ Dash.prototype = {
     },
 
     _updateDashActors: function() {
-        if (!this._searchActive && this._searchResultsSection.actor.visible) {
+        if (this._searchPending) {
+            this._searchResultsSection.actor.show();
+            // We initially hide all sections when we start a search. When the search timeout
+            // first runs, the sections that have matching results are shown. As the search
+            // is refined, only the sections that have matching results will be shown.
+            for (let i = 0; i < this._searchSections.length; i++) {
+                let section = this._searchSections[i];
+                section.header.actor.hide();
+                section.resultArea.actor.hide();
+            }
+            this._appsSection.actor.hide();
+            this._placesSection.actor.hide();
+            this._docsSection.actor.hide();
+        } else if (!this._searchActive) {
             this._showAllSearchSections();
             this._searchResultsSection.actor.hide();
             this._appsSection.actor.show();
             this._placesSection.actor.show();
             this._docsSection.actor.show();
-        } else if (this._searchActive && !this._searchResultsSection.actor.visible) {
-            this._searchResultsSection.actor.show();
-            this._appsSection.actor.hide();
-            this._placesSection.actor.hide();
-            this._docsSection.actor.hide();
         }
     },
 

js/ui/dnd.js

@@ -8,6 +8,25 @@ const Tweener = imports.ui.tweener;
 
 const SNAP_BACK_ANIMATION_TIME = 0.25;
 
+let eventHandlerActor = null;
+let currentDraggable = null;
+
+function _getEventHandlerActor() {
+    if (!eventHandlerActor) {
+        eventHandlerActor = new Clutter.Rectangle();
+        eventHandlerActor.width = 0;
+        eventHandlerActor.height = 0;
+        global.stage.add_actor(eventHandlerActor);
+        // We connect to 'event' rather than 'captured-event' because the capturing phase doesn't happen
+        // when you've grabbed the pointer.
+        eventHandlerActor.connect('event',
+                                  function(actor, event) {
+                                      return currentDraggable._onEvent(actor, event);
+                                  });
+    }
+    return eventHandlerActor;
+}
+
 function _Draggable(actor, manualMode) {
     this._init(actor, manualMode);
 }
@@ -18,7 +37,11 @@ _Draggable.prototype = {
         if (!manualMode)
             this.actor.connect('button-press-event',
                                Lang.bind(this, this._onButtonPress));
-        this._haveSourceGrab = false;
+        this._onEventId = null;
+
+        this._buttonDown = false; // The mouse button has been pressed and has not yet been released.
+        this._dragInProgress = false; // The drag has been started, and has not been dropped or cancelled yet.
+        this._snapBackInProgress = false; // The drag has been cancelled and the item is in the process of snapping back.
     },
 
     _onButtonPress : function (actor, event) {
@@ -27,8 +50,8 @@ _Draggable.prototype = {
         if (Tweener.getTweenCount(actor))
             return false;
 
-        this._haveSourceGrab = true;
-        this._grabActor(actor);
+        this._buttonDown = true;
+        this._grabActor();
 
         let [stageX, stageY] = event.get_coords();
         this._dragStartX = stageX;
@@ -37,41 +60,69 @@ _Draggable.prototype = {
         return false;
     },
     
-    _grabActor : function (actor) {
-        Clutter.grab_pointer(actor);
-
-        // We intercept motion and button-release events so that when
-        // you release after dragging, the app doesn't see that and
-        // think you just clicked. We connect to 'event' rather than
-        // 'captured-event' because the capturing phase doesn't happen
-        // when you've grabbed the pointer.
-        this._onEventId = actor.connect('event',
+    _grabActor: function() {
+        Clutter.grab_pointer(this.actor);
+        this._onEventId = this.actor.connect('event',
                                              Lang.bind(this, this._onEvent));
     },
 
-    _ungrabActor : function (actor) {
+    _ungrabActor: function() {
         Clutter.ungrab_pointer();
-        actor.disconnect(this._onEventId);
+        this.actor.disconnect(this._onEventId);
+        this._onEventId = null;
     },
 
-    _onEvent : function (actor, event) {
-        if (this._dragActor) {
-            if (actor != this._dragActor )
-                return false;
-        } else if (actor != this.actor)
-            return false;
+    _grabEvents: function() {
+        Clutter.grab_pointer(_getEventHandlerActor());
+        Clutter.grab_keyboard(_getEventHandlerActor());
+    },
+
+    _ungrabEvents: function() {
+        Clutter.ungrab_pointer();
+        Clutter.ungrab_keyboard();
+    },
+
+    _onEvent: function(actor, event) {
+        // We intercept BUTTON_RELEASE event to know that the button was released in case we
+        // didn't start the drag, to drop the draggable in case the drag was in progress, and
+        // to complete the drag and ensure that whatever happens to be under the pointer does
+        // not get triggered if the drag was cancelled with Esc.
+        if (event.type() == Clutter.EventType.BUTTON_RELEASE) {
+            this._buttonDown = false;
+            if (this._dragInProgress) {
+                return this._dragActorDropped(event);
+            } else if (this._dragActor != null && !this._snapBackInProgress) {
+                // Drag must have been cancelled with Esc.
+                this._dragComplete();
+                return true;
+            } else {
+                // Drag has never started.
+                this._ungrabActor();
+                return false;
+            }
+        // We intercept MOTION event to figure out if the drag has started and to draw
+        // this._dragActor under the pointer when dragging is in progress
+        } else if (event.type() == Clutter.EventType.MOTION) {
+            if (this._dragInProgress) {
+                return this._updateDragPosition(event);
+            } else if (this._dragActor == null) {
+                return this._maybeStartDrag(event);
+            }
+        // We intercept KEY_PRESS event so that we can process Esc key press to cancel
+        // dragging and ignore all other key presses.
+        } else if (event.type() == Clutter.EventType.KEY_PRESS && this._dragInProgress) {
+            let symbol = event.get_key_symbol();
+            if (symbol == Clutter.Escape) {
+                this._cancelDrag(event.get_time());
+                return true;
+            }
+        }
 
-        if (event.type() == Clutter.EventType.BUTTON_RELEASE)
-            return this._onButtonRelease(actor, event);
-        else if (event.type() == Clutter.EventType.MOTION)
-            return this._onMotion(actor, event);
-        else
         return false;
     },
 
     /**
      * startDrag:
-     * @actor: Origin actor for drag and drop
      * @stageX: X coordinate of event
      * @stageY: Y coordinate of event
      * @time: Event timestamp
@@ -80,8 +131,14 @@ _Draggable.prototype = {
      * This function is useful to call if you've specified manualMode
      * for the draggable.
      */
-    startDrag: function (actor, stageX, stageY, time) {
+    startDrag: function (stageX, stageY, time) {
+        currentDraggable = this;
+        this._dragInProgress = true;
+
         this.emit('drag-begin', time);
+        if (this._onEventId)
+            this._ungrabActor();
+        this._grabEvents();
 
         this._dragStartX = stageX;
         this._dragStartY = stageY;
@@ -112,49 +169,49 @@ _Draggable.prototype = {
                 this._dragActorSource = this.actor;
             }
             this._dragOrigParent = undefined;
-            if (this._haveSourceGrab) {
-                this._haveSourceGrab = false;
-                this._ungrabActor(actor);
-            }
-            this._grabActor(this._dragActor);
 
             this._dragOffsetX = this._dragActor.x - this._dragStartX;
             this._dragOffsetY = this._dragActor.y - this._dragStartY;
         } else {
-            this._dragActor = actor;
+            this._dragActor = this.actor;
             this._dragActorSource = undefined;
-            this._dragOrigParent = actor.get_parent();
+            this._dragOrigParent = this.actor.get_parent();
             this._dragOrigX = this._dragActor.x;
             this._dragOrigY = this._dragActor.y;
             this._dragOrigScale = this._dragActor.scale_x;
 
-            let [actorStageX, actorStageY] = actor.get_transformed_position();
+            let [actorStageX, actorStageY] = this.actor.get_transformed_position();
             this._dragOffsetX = actorStageX - this._dragStartX;
             this._dragOffsetY = actorStageY - this._dragStartY;
 
             // Set the actor's scale such that it will keep the same
             // transformed size when it's reparented to the stage
-            let [scaledWidth, scaledHeight] = actor.get_transformed_size();
-            actor.set_scale(scaledWidth / actor.width,
-                           scaledHeight / actor.height);
+            let [scaledWidth, scaledHeight] = this.actor.get_transformed_size();
+            this.actor.set_scale(scaledWidth / this.actor.width,
+                                 scaledHeight / this.actor.height);
         }
 
-        this._dragActor.reparent(actor.get_stage());
+        this._dragActor.reparent(this.actor.get_stage());
         this._dragActor.raise_top();
     },
 
-    _onMotion : function (actor, event) {
+    _maybeStartDrag:  function(event) {
         let [stageX, stageY] = event.get_coords();
 
-        // If we haven't begun a drag, see if the user has moved the
-        // mouse enough to trigger a drag
+        // See if the user has moved the mouse enough to trigger a drag
         let threshold = Gtk.Settings.get_default().gtk_dnd_drag_threshold;
-        if (!this._dragActor &&
-            (Math.abs(stageX - this._dragStartX) > threshold ||
+        if ((Math.abs(stageX - this._dragStartX) > threshold ||
              Math.abs(stageY - this._dragStartY) > threshold)) {
-                this.startDrag(actor, stageX, stageY, event.get_time());
+                this.startDrag(stageX, stageY, event.get_time());
+                this._updateDragPosition(event);
         }
 
+        return true;
+    },
+
+    _updateDragPosition : function (event) {
+        let [stageX, stageY] = event.get_coords();
+
         // If we are dragging, update the position
         if (this._dragActor) {
             this._dragActor.set_position(stageX + this._dragOffsetX,
@@ -162,7 +219,7 @@ _Draggable.prototype = {
             // Because we want to find out what other actor is located at the current position of this._dragActor,
             // we have to temporarily hide this._dragActor.
             this._dragActor.hide();
-            let target = actor.get_stage().get_actor_at_pos(Clutter.PickMode.ALL,
+            let target = this._dragActor.get_stage().get_actor_at_pos(Clutter.PickMode.ALL,
                                                                       stageX + this._dragOffsetX,
                                                                       stageY + this._dragOffsetY);
             this._dragActor.show();
@@ -172,7 +229,7 @@ _Draggable.prototype = {
                     // We currently loop through all parents on drag-over even if one of the children has handled it.
                     // We can check the return value of the function and break the loop if it's true if we don't want
                     // to continue checking the parents.
-                    target._delegate.handleDragOver(this.actor._delegate, actor,
+                    target._delegate.handleDragOver(this.actor._delegate, this._dragActor,
                                                     (stageX + this._dragOffsetX - targX) / target.scale_x,
                                                     (stageY + this._dragOffsetY - targY) / target.scale_y,
                                                     event.get_time());
@@ -184,40 +241,42 @@ _Draggable.prototype = {
         return true;
     },
 
-    _onButtonRelease : function (actor, event) {
-        this._ungrabActor(actor);
-
-        let dragging = (actor == this._dragActor);
-        this._dragActor = undefined;
-
-        if (!dragging)
-            return false;
-
-        // Find a drop target
-        actor.hide();
+    _dragActorDropped: function(event) {
+        // Find a drop target. Because we want to find out what other actor is located at
+        // the current position of this._dragActor, we have to temporarily hide this._dragActor.
+        this._dragActor.hide();
         let [dropX, dropY] = event.get_coords();
-        let target = actor.get_stage().get_actor_at_pos(Clutter.PickMode.ALL,
+        let target = this._dragActor.get_stage().get_actor_at_pos(Clutter.PickMode.ALL,
                                                                   dropX, dropY);
-        actor.show();
+        this._dragActor.show();
         while (target) {
             if (target._delegate && target._delegate.acceptDrop) {
                 let [targX, targY] = target.get_transformed_position();
-                if (target._delegate.acceptDrop(this.actor._delegate, actor,
+                if (target._delegate.acceptDrop(this.actor._delegate, this._dragActor,
                                                 (dropX - targX) / target.scale_x,
                                                 (dropY - targY) / target.scale_y,
                                                 event.get_time())) {
                     // If it accepted the drop without taking the actor,
                     // destroy it.
-                    if (actor.get_parent() == actor.get_stage())
-                        actor.destroy();
+                    if (this._dragActor.get_parent() == this._dragActor.get_stage())
+                        this._dragActor.destroy();
 
+                    this._dragInProgress = false;
                     this.emit('drag-end', event.get_time(), true);
+                    this._dragComplete();
                     return true;
                 }
             }
             target = target.get_parent();
         }
 
+        this._cancelDrag(event.get_time());
+
+        return true;
+    },
+
+    _cancelDrag: function(eventTime) {
+        this._dragInProgress = false;
         // Snap back to the actor source if the source is still around, snap back 
         // to the original location if the actor itself was being dragged or the
         // source is no longer around.
@@ -227,17 +286,17 @@ _Draggable.prototype = {
             [snapBackX, snapBackY] = this._dragActorSource.get_transformed_position();
         }
 
+        this._snapBackInProgress = true;
         // No target, so snap back
-        Tweener.addTween(actor,
+        Tweener.addTween(this._dragActor,
                          { x: snapBackX,
                            y: snapBackY,
                            time: SNAP_BACK_ANIMATION_TIME,
                            transition: "easeOutQuad",
                            onComplete: this._onSnapBackComplete,
                            onCompleteScope: this,
-                           onCompleteParams: [actor, event.get_time()]
+                           onCompleteParams: [this._dragActor, eventTime]
                          });
-        return true;
     },
 
     _onSnapBackComplete : function (dragActor, eventTime) {
@@ -249,6 +308,16 @@ _Draggable.prototype = {
             dragActor.destroy();
         }
         this.emit('drag-end', eventTime, false);
+
+        this._snapBackInProgress = false;
+        if (!this._buttonDown)
+            this._dragComplete();
+    },
+
+    _dragComplete: function() {
+        this._dragActor = undefined;
+        currentDraggable = null;
+        this._ungrabEvents();
     }
 };
 

js/ui/docDisplay.js

@@ -136,7 +136,7 @@ DocDisplay.prototype = {
             // but redisplaying right away is cool when we use Zephyr.
             // Also, we might be displaying remote documents, like Google Docs, in the future
             // which might be edited by someone else.
-            this._redisplay(false);
+            this._redisplay(GenericDisplay.RedisplayFlags.NONE);
         }));
 
         this.connect('destroy', Lang.bind(this, function (o) {
@@ -150,9 +150,10 @@ DocDisplay.prototype = {
     // Gets the list of recent items from the recent items manager.
     _refreshCache : function() {
         if (!this._docsStale)
-            return;
+            return true;
         this._allItems = this._docManager.getItems();
         this._docsStale = false;
+        return false;
     },
 
     // Sets the list of the displayed items based on how recently they were last visited.
@@ -171,21 +172,24 @@ DocDisplay.prototype = {
         // them once when they are returned by this._recentManager.get_items() to avoid having to do 
         // this sorting each time, but the sorting seems to be very fast anyway, so there is no need
         // to introduce an additional class variable.
-        this._matchedItems = [];
+        this._matchedItems = {};
+        this._matchedItemKeys = [];
         let docIdsToRemove = [];
         for (docId in this._allItems) {
             // this._allItems[docId].exists() checks if the resource still exists
-            if (this._allItems[docId].exists()) 
-                this._matchedItems.push(docId);
-            else 
+            if (this._allItems[docId].exists()) {
+                this._matchedItems[docId] = 1;
+                this._matchedItemKeys.push(docId);
+            } else {
                 docIdsToRemove.push(docId);
             }
+        }
 
         for (docId in docIdsToRemove) {
             delete this._allItems[docId];
         }
 
-        this._matchedItems.sort(Lang.bind(this, function (a,b) { return this._compareItems(a,b); }));
+        this._matchedItemKeys.sort(Lang.bind(this, this._compareItems));
     },
 
     // Compares items associated with the item ids based on how recently the items
@@ -298,7 +302,7 @@ DashDocDisplayItem.prototype = {
     shellWorkspaceLaunch: function () {
         this._info.launch();
     }
-}
+};
 
 /**
  * Class used to display two column recent documents in the dash
@@ -432,5 +436,9 @@ DashDocDisplay.prototype = {
             let display = new DashDocDisplayItem(docInfo);
             this.actor.add_actor(display.actor);
         }
+        this.emit('changed');
     }
-}
+};
+
+Signals.addSignalMethods(DashDocDisplay.prototype);
+

js/ui/environment.js

@@ -0,0 +1,36 @@
+/* -*- mode: js2; js2-basic-offset: 4; indent-tabs-mode: nil -*- */
+
+const St = imports.gi.St;
+
+const Tweener = imports.ui.tweener;
+
+const Format = imports.misc.format;
+
+// "monkey patch" in some varargs ClutterContainer methods; we need
+// to do this per-container class since there is no representation
+// of interfaces in Javascript
+function _patchContainerClass(containerClass) {
+    // This one is a straightforward mapping of the C method
+    containerClass.prototype.child_set = function(actor, props) {
+        let meta = this.get_child_meta(actor);
+        for (prop in props)
+            meta[prop] = props[prop];
+    };
+
+    // clutter_container_add() actually is a an add-many-actors
+    // method. We conveniently, but somewhat dubiously, take the
+    // this opportunity to make it do something more useful.
+    containerClass.prototype.add = function(actor, props) {
+        this.add_actor(actor);
+        if (props)
+            this.child_set(actor, props);
+    };
+}
+
+_patchContainerClass(St.BoxLayout);
+_patchContainerClass(St.Table);
+
+function init() {
+    Tweener.init();
+    String.prototype.format = Format.format;
+}

js/ui/genericDisplay.js

@@ -17,6 +17,11 @@ const DND = imports.ui.dnd;
 const Link = imports.ui.link;
 const Main = imports.ui.main;
 
+const RedisplayFlags = { NONE: 0,
+                         RESET_CONTROLS: 1 << 0,
+                         FULL: 1 << 1,
+                         SUBSEARCH: 1 << 2 };
+
 const ITEM_DISPLAY_NAME_COLOR = new Clutter.Color();
 ITEM_DISPLAY_NAME_COLOR.from_pixel(0xffffffff);
 const ITEM_DISPLAY_DESCRIPTION_COLOR = new Clutter.Color();
@@ -93,7 +98,7 @@ GenericDisplayItem.prototype = {
                                                                       infoIconUri,
                                                                       INFORMATION_BUTTON_SIZE,
                                                                       INFORMATION_BUTTON_SIZE);
-        this._informationButton = new Button.iconButton(this.actor, INFORMATION_BUTTON_SIZE, infoIcon);
+        this._informationButton = new Button.IconButton(this.actor, INFORMATION_BUTTON_SIZE, infoIcon);
         let buttonBox = new Big.Box({ width: INFORMATION_BUTTON_SIZE + 2 * DEFAULT_PADDING,
                                       height: INFORMATION_BUTTON_SIZE,
                                       padding_left: DEFAULT_PADDING, padding_right: DEFAULT_PADDING,
@@ -121,6 +126,8 @@ GenericDisplayItem.prototype = {
         this._description = null;
         this._icon = null;
 
+        this._initialLoadComplete = false;
+
         // An array of details description actors that we create over time for the item.
         // It is used for updating the description text inside the details actor when
         // the description text for the item is updated.
@@ -337,9 +344,10 @@ GenericDisplay.prototype = {
 
         // map<itemId, Object> where Object represents the item info
         this._allItems = {};
-        // an array of itemIds of items that match the current request
-        // in the order in which the items should be displayed
-        this._matchedItems = [];
+        // set<itemId>
+        this._matchedItems = {};
+        // sorted array of items matched by search
+        this._matchedItemKeys = [];
         // map<itemId, GenericDisplayItem>
         this._displayedItems = {};
         this._openDetailIndex = -1;
@@ -357,8 +365,20 @@ GenericDisplay.prototype = {
 
     // Sets the search string and displays the matching items.
     setSearch: function(text) {
-        this._search = text.toLowerCase();
-        this._redisplay(true);
+        let lowertext = text.toLowerCase();
+        if (lowertext == this._search)
+            return;
+        let flags = RedisplayFlags.RESET_CONTROLS;
+        if (this._search != '') {
+            // Because we combine search terms with OR, we have to be sure that no new term
+            // was introduced before deciding that the new search results will be a subset of
+            // the existing search results.
+            if (lowertext.indexOf(this._search) == 0 &&
+                lowertext.split(/\s+/).length == this._search.split(/\s+/).length)
+                flags |= RedisplayFlags.SUBSEARCH;
+        }
+        this._search = lowertext;
+        this._redisplay(flags);
     },
 
     // Launches the item that is currently selected, closing the Overview
@@ -430,16 +450,16 @@ GenericDisplay.prototype = {
         // positive number when this._mathedItems.length is 0
         // This can be triggered if a search string is entered for which there are no matches.
         // log("this._mathedItems.length: " + this._matchedItems.length + " this._list.displayedCount " + this._list.displayedCount);
-        return this._matchedItems.length > 0;
+        return this._matchedItemKeys.length > 0;
     },
 
     getMatchedItemsCount: function() {
-        return this._matchedItems.length;
+        return this._matchedItemKeys.length;
     },
 
     // Load the initial state
     load: function() {
-        this._redisplay(true);
+        this._redisplay(RedisplayFlags.FULL);
     },
 
     // Should be called when the display is closed
@@ -470,52 +490,16 @@ GenericDisplay.prototype = {
 
     //// Protected methods ////
 
-    /*
-     * Displays items that match the current request and should show up on the current page.
-     * Updates the display control to reflect the matched items set and the page selected.
-     *
-     * resetDisplayControl - indicates if the display control should be re-created because 
-     *                       the results or the space allocated for them changed. If it's false,
-     *                       the existing display control is used and only the page links are
-     *                       updated to reflect the current page selection.
-     */
-    _displayMatchedItems: function(resetDisplayControl) {
-        // When generating a new list to display, we first remove all the old
-        // displayed items which will unset the selection. So we need 
-        // to keep a flag which indicates if this display had the selection.
-        let hadSelected = this.hasSelected();
-
+    _recreateDisplayItems: function() {
         this._removeAllDisplayItems();
-        for (let i = 0; i < this._matchedItems.length; i++) {
-            this._addDisplayItem(this._matchedItems[i]);
+        this._setDefaultList();
+        for (let itemId in this._allItems) {
+            this._addDisplayItem(itemId);
         }
-
-        if (hadSelected) {
-            this._selectedIndex = -1;
-            this.selectFirstItem();
-        }
-
-        // Check if the pointer is over one of the items and display the information button if it is.
-        // We want to do this between finishing our changes to the display and the point where
-        // the display is redrawn.
-        Mainloop.idle_add(Lang.bind(this,
-                                    function() {
-                                        let [child, x, y, mask] = Gdk.Screen.get_default().get_root_window().get_pointer();
-                                        let actor = global.stage.get_actor_at_pos(Clutter.PickMode.REACTIVE,
-                                                                                  x, y);
-                                        if (actor != null) {
-                                            let item = this._findDisplayedByActor(actor);
-                                            if (item != null) {
-                                                item.onDrawnUnderPointer();
-                                            }
-                                        }
-                                        return false;
-                                    }),
-                          Meta.PRIORITY_BEFORE_REDRAW);
     },
 
     // Creates a display item based on the information associated with itemId
-    // and adds it to the displayed items.
+    // and adds it to the list of displayed items, but does not yet display it.
     _addDisplayItem : function(itemId) {
         if (this._displayedItems.hasOwnProperty(itemId)) {
             log("Tried adding a display item for " + itemId + ", but an item with this item id is already among displayed items.");
@@ -546,7 +530,6 @@ GenericDisplay.prototype = {
                                               this.emit('show-details', index);
                                           }
                                       }));
-        this._list.add_actor(displayItem.actor);
         this._displayedItems[itemId] = displayItem;
     },
 
@@ -585,33 +568,139 @@ GenericDisplay.prototype = {
         this.unsetSelected();
     },
 
+    _compareSearchMatch: function(a, b) {
+        let countA = this._matchedItems[a];
+        let countB = this._matchedItems[b];
+        if (countA > countB)
+            return -1;
+        else if (countA < countB)
+            return 1;
+        else
+            return this._compareItems(a, b);
+    },
+
+    _setMatches: function(matches) {
+        this._matchedItems = matches;
+        this._matchedItemKeys = [];
+        for (let itemId in this._matchedItems) {
+            this._matchedItemKeys.push(itemId);
+        }
+        this._matchedItemKeys.sort(Lang.bind(this, this._compareSearchMatch));
+    },
+
+    /**
+     * _redisplaySubSearch:
+     * A somewhat more optimized function called when we know
+     * that we're going to be displaying a subset of the items
+     * we already had, in the same order.  In that case, we can
+     * just hide the actors that shouldn't be shown.
+     */
+    _redisplaySubSearch: function() {
+        let matches = this._getSearchMatchedItems(true);
+
+        // Just hide all from the old set,
+        // we'll show the ones we want below
+        for (let itemId in this._displayedItems) {
+            let item = this._displayedItems[itemId];
+            item.actor.hide();
+        }
+
+        this._setMatches(matches);
+
+        for (let itemId in matches) {
+            let item = this._displayedItems[itemId];
+            item.actor.show();
+        }
+        this._list.queue_relayout();
+    },
+
+    _redisplayReordering: function() {
+        if (!this._filterActive()) {
+            this._setDefaultList();
+        } else {
+            this._setMatches(this._getSearchMatchedItems(false));
+        }
+        this._list.remove_all();
+        for (let i = 0; i < this._matchedItemKeys.length; i++) {
+            let itemId = this._matchedItemKeys[i];
+            let item = this._displayedItems[itemId];
+            item.actor.show();
+            this._list.add_actor(item.actor);
+       }
+    },
+
     /*
      * Updates the displayed items, applying the search string if one exists.
-     *
-     * resetPage - indicates if the page selection should be reset when displaying the matching results.
+     * @flags: Flags controlling redisplay behavior as follows:
+     *  RESET_CONTROLS - indicates if the page selection should be reset when displaying the matching results.
      *  We reset the page selection when the change in results was initiated by the user by
      *  entering a different search criteria or by viewing the results list in a different
      *  size mode, but we keep the page selection the same if the results got updated on
      *  their own while the user was browsing through the result pages.
+     *  SUBSEARCH - Indicates that the current _search is a superstring of the previous
+     *  one, which implies we only need to re-search through previous results.
+     *  FULL - Indicates that we need refresh all displayed items.
      */
-    _redisplay: function(resetPage) {
-        this._refreshCache();
-        if (!this._filterActive())
-            this._setDefaultList();
-        else
-            this._doSearchFilter();
+    _redisplay: function(flags) {
+        let resetPage = (flags & RedisplayFlags.RESET_CONTROLS) > 0;
+        let isSubSearch = (flags & RedisplayFlags.SUBSEARCH) > 0;
+        let fullReload = (flags & RedisplayFlags.FULL) > 0;
+
+        let hadSelected = this.hasSelected();
+        this.unsetSelected();
+
+        if (!this._initialLoadComplete)
+            fullReload = true;
+
+        if (!this._refreshCache())
+            fullReload = true;
+
+        if (fullReload) {
+            this._recreateDisplayItems();
+            this._initialLoadComplete = true;
+        }
+
+        if (isSubSearch) {
+            this._redisplaySubSearch();
+        } else {
+            this._redisplayReordering();
+        }
 
         if (resetPage)
             this._list.page = 0;
 
-        this._displayMatchedItems(true);
+        if (hadSelected) {
+            this._selectedIndex = -1;
+            this.selectFirstItem();
+        }
+
+        Mainloop.idle_add(Lang.bind(this, this._checkInformationIcon),
+                          Meta.PRIORITY_BEFORE_REDRAW);
 
         this.emit('redisplayed');
     },
 
+    // Check if the pointer is over one of the items and display the information button if it is.
+    // We want to do this between finishing our changes to the display and the point where
+    // the display is redrawn.
+    _checkInformationIcon: function() {
+        let [child, x, y, mask] = Gdk.Screen.get_default().get_root_window().get_pointer();
+        let actor = global.stage.get_actor_at_pos(Clutter.PickMode.REACTIVE,
+                                                  x, y);
+        if (actor != null) {
+            let item = this._findDisplayedByActor(actor);
+            if (item != null) {
+               item.onDrawnUnderPointer();
+            }
+        }
+        return false;
+    },
+
     //// Pure virtual protected methods ////
 
     // Performs the steps needed to have the latest information about the items.
+    // Implementation should return %true if we are up to date, and %false
+    // if a full reload occurred.
     _refreshCache: function() {
         throw new Error("Not implemented");
     },
@@ -643,56 +732,40 @@ GenericDisplay.prototype = {
 
     //// Private methods ////
 
-    _getSearchMatchedItems: function() {
-        let matchedItemsForSearch = {};
+    _getItemSearchScore: function(itemId, terms) {
+        let item = this._allItems[itemId];
+        let score = 0;
+        for (let i = 0; i < terms.length; i++) {
+            let term = terms[i];
+            if (this._isInfoMatching(item, term)) {
+                score++;
+            }
+        }
+        return score;
+    },
+
+    _getSearchMatchedItems: function(isSubSearch) {
         // Break the search up into terms, and search for each
         // individual term.  Keep track of the number of terms
         // each item matched.
         let terms = this._search.split(/\s+/);
-        for (let i = 0; i < terms.length; i++) {
-            let term = terms[i];
-            for (itemId in this._allItems) {
-                let item = this._allItems[itemId];
-                if (this._isInfoMatching(item, term)) {
-                    let count = matchedItemsForSearch[itemId];
-                    if (!count)
-                        count = 0;
-                    count += 1;
-                    matchedItemsForSearch[itemId] = count;
-                }
-            }
-        }
-        return matchedItemsForSearch;
-    },
+        let matchScores = {};
 
-    // Applies the search string to the list of items to find matches,
-    // and displays the matching items.
-    _doSearchFilter: function() {
-        let matchedItemsForSearch;
-
-        if (this._filterActive()) {
-            matchedItemsForSearch = this._getSearchMatchedItems();
+        if (isSubSearch) {
+            for (let i = 0; i < this._matchedItemKeys.length; i++) {
+                let itemId = this._matchedItemKeys[i];
+                let score = this._getItemSearchScore(itemId, terms);
+                if (score > 0)
+                    matchScores[itemId] = score;
+            }
         } else {
-            matchedItemsForSearch = {};
-            for (let itemId in this._allItems) {
-                matchedItemsForSearch[itemId] = 1;
+            for (let itemId in this._displayedItems) {
+                let score = this._getItemSearchScore(itemId, terms);
+                if (score > 0)
+                    matchScores[itemId] = score;
             }
         }
-
-        this._matchedItems = [];
-        for (itemId in matchedItemsForSearch) {
-            this._matchedItems.push(itemId);
-        }
-        this._matchedItems.sort(Lang.bind(this, function (a, b) {
-            let countA = matchedItemsForSearch[a];
-            let countB = matchedItemsForSearch[b];
-            if (countA > countB)
-                return -1;
-            else if (countA < countB)
-                return 1;
-            else
-                return this._compareItems(a, b);
-        }));
+        return matchScores;
     },
 
     /*

js/ui/lightbox.js

@@ -0,0 +1,151 @@
+/* -*- mode: js2; js2-basic-offset: 4; indent-tabs-mode: nil -*- */
+
+const Clutter = imports.gi.Clutter;
+const Lang = imports.lang;
+
+const Main = imports.ui.main;
+const Tweener = imports.ui.tweener;
+
+const SHADE_COLOR = new Clutter.Color();
+SHADE_COLOR.from_pixel(0x00000044);
+
+/**
+ * Lightbox:
+ * @container: parent Clutter.Container
+ * @width: (optional) shade actor width
+ * @height: (optional) shade actor height
+ *
+ * Lightbox creates a dark translucent "shade" actor to hide the
+ * contents of @container, and allows you to specify particular actors
+ * in @container to highlight by bringing them above the shade. It
+ * tracks added and removed actors in @container while the lightboxing
+ * is active, and ensures that all actors are returned to their
+ * original stacking order when the lightboxing is removed. (However,
+ * if actors are restacked by outside code while the lightboxing is
+ * active, the lightbox may later revert them back to their original
+ * order.)
+ *
+ * By default, the shade window will have the height and width of
+ * @container and will track any changes in its size. You can override
+ * this by passing an explicit width and height
+ */
+function Lightbox(container, width, height) {
+    this._init(container, width, height);
+}
+
+Lightbox.prototype = {
+    _init : function(container, width, height) {
+        this._container = container;
+        this._children = container.get_children();
+        this.actor = new Clutter.Rectangle({ color: SHADE_COLOR,
+                                             x: 0,
+                                             y: 0,
+                                             border_width: 0,
+                                             reactive: true });
+
+        container.add_actor(this.actor);
+        this.actor.raise_top();
+
+        this._destroySignalId = this.actor.connect('destroy', Lang.bind(this, this.destroy));
+
+        if (width && height) {
+            this.actor.width = width;
+            this.actor.height = height;
+            this._allocationChangedSignalId = 0;
+        } else {
+            this.actor.width = container.width;
+            this.actor.height = container.height;
+            this._allocationChangedSignalId = container.connect('allocation-changed', Lang.bind(this, this._allocationChanged));
+        }
+
+        this._actorAddedSignalId = container.connect('actor-added', Lang.bind(this, this._actorAdded));
+        this._actorRemovedSignalId = container.connect('actor-removed', Lang.bind(this, this._actorRemoved));
+
+        this._highlighted = null;
+    },
+
+    _allocationChanged : function(container, box, flags) {
+        this.actor.width = this._container.width;
+        this.actor.height = this._container.height;
+    },
+
+    _actorAdded : function(container, newChild) {
+        let children = this._container.get_children();
+        let myIndex = children.indexOf(this.actor);
+        let newChildIndex = children.indexOf(newChild);
+
+        if (newChildIndex > myIndex) {
+            // The child was added above the shade (presumably it was
+            // made the new top-most child). Move it below the shade,
+            // and add it to this._children as the new topmost actor.
+            newChild.lower(this.actor);
+            this._children.push(newChild);
+        } else if (newChildIndex == 0) {
+            // Bottom of stack
+            this._children.unshift(newChild);
+        } else {
+            // Somewhere else; insert it into the correct spot
+            let prevChild = this._children.indexOf(children[newChildIndex - 1]);
+            if (prevChild != -1) // paranoia
+                this._children.splice(prevChild + 1, 0, newChild);
+        }
+    },
+
+    _actorRemoved : function(container, child) {
+        let index = this._children.indexOf(child);
+        if (index != -1) // paranoia
+            this._children.splice(index, 1);
+
+        if (child == this._highlighted)
+            this._highlighted = null;
+    },
+
+    /**
+     * highlight:
+     * @window: actor to highlight
+     *
+     * Highlights the indicated actor and unhighlights any other
+     * currently-highlighted actor. With no arguments or a false/null
+     * argument, all actors will be unhighlighted.
+     */
+    highlight : function(window) {
+        if (this._highlighted == window)
+            return;
+
+        // Walk this._children raising and lowering actors as needed.
+        // Things get a little tricky if the to-be-raised and
+        // to-be-lowered actors were originally adjacent, in which
+        // case we may need to indicate some *other* actor as the new
+        // sibling of the to-be-lowered one.
+
+        let below = this.actor;
+        for (let i = this._children.length - 1; i >= 0; i--) {
+            if (this._children[i] == window)
+                this._children[i].raise_top();
+            else if (this._children[i] == this._highlighted)
+                this._children[i].lower(below);
+            else
+                below = this._children[i];
+        }
+
+        this._highlighted = window;
+    },
+
+    /**
+     * destroy:
+     *
+     * Destroys the lightbox. This is called automatically if the
+     * lightbox's container is destroyed.
+     */
+    destroy : function() {
+        if (this._allocationChangedSignalId != 0)
+            this._container.disconnect(this._allocationChangedSignalId);
+        this._container.disconnect(this._actorAddedSignalId);
+        this._container.disconnect(this._actorRemovedSignalId);
+
+        this.actor.disconnect(this._destroySignalId);
+
+        this.highlight(null);
+        this.actor.destroy();
+    }
+};

js/ui/lookingGlass.js

@@ -4,6 +4,7 @@ const Big = imports.gi.Big;
 const Clutter = imports.gi.Clutter;
 const Gio = imports.gi.Gio;
 const Pango = imports.gi.Pango;
+const St = imports.gi.St;
 const Shell = imports.gi.Shell;
 const Signals = imports.signals;
 const Lang = imports.lang;
@@ -12,18 +13,7 @@ const Mainloop = imports.mainloop;
 const Tweener = imports.ui.tweener;
 const Main = imports.ui.main;
 
-const LG_BORDER_COLOR = new Clutter.Color();
-LG_BORDER_COLOR.from_pixel(0x0000aca0);
-const LG_BACKGROUND_COLOR = new Clutter.Color();
-LG_BACKGROUND_COLOR.from_pixel(0x000000d5);
-const GREY = new Clutter.Color();
-GREY.from_pixel(0xAFAFAFFF);
-const MATRIX_GREEN = new Clutter.Color();
-MATRIX_GREEN.from_pixel(0x88ff66ff);
-// FIXME pull from GConf
-const MATRIX_FONT = 'Monospace 10';
-
-                    /* Imports...feel free to add here as needed */
+/* Imports...feel free to add here as needed */
 var commandHeader = "const Clutter = imports.gi.Clutter; " +
                     "const GLib = imports.gi.GLib; " +
                     "const Gtk = imports.gi.Gtk; " +
@@ -47,7 +37,7 @@ function Notebook() {
 
 Notebook.prototype = {
     _init: function() {
-        this.actor = new Big.Box();
+        this.actor = new St.BoxLayout({ vertical: true });
 
         this.tabControls = new Big.Box({ orientation: Big.BoxOrientation.HORIZONTAL,
                                          spacing: 4, padding: 2 });
@@ -58,21 +48,24 @@ Notebook.prototype = {
 
     appendPage: function(name, child) {
         let labelOuterBox = new Big.Box({ padding: 2 });
-        let labelBox = new Big.Box({ padding: 2, border_color: MATRIX_GREEN,
-                                     reactive: true });
+        let labelBox = new St.BoxLayout({ reactive: true });
         labelOuterBox.append(labelBox, Big.BoxPackFlags.NONE);
-        let label = new Clutter.Text({ color: MATRIX_GREEN,
-                                       font_name: MATRIX_FONT,
-                                       text: name });
+        let label = new St.Label({ text: name });
         labelBox.connect('button-press-event', Lang.bind(this, function () {
             this.selectChild(child);
             return true;
         }));
-        labelBox.append(label, Big.BoxPackFlags.EXPAND);
-        this._tabs.push([child, labelBox]);
-        child.hide();
-        this.actor.append(child, Big.BoxPackFlags.EXPAND);
+        labelBox.add(label, { expand: true });
         this.tabControls.append(labelOuterBox, Big.BoxPackFlags.NONE);
+
+        let scrollview = new St.ScrollView({ x_fill: true, y_fill: true });
+        scrollview.get_hscroll_bar().hide();
+        scrollview.add_actor(child);
+
+        this._tabs.push([child, labelBox, scrollview]);
+        scrollview.hide();
+        this.actor.add(scrollview, { expand: true });
+
         if (this._selectedIndex == -1)
             this.selectIndex(0);
     },
@@ -80,10 +73,10 @@ Notebook.prototype = {
     _unselect: function() {
         if (this._selectedIndex < 0)
             return;
-        let [child, labelBox] = this._tabs[this._selectedIndex];
+        let [child, labelBox, scrollview] = this._tabs[this._selectedIndex];
         labelBox.padding = 2;
         labelBox.border = 0;
-        child.hide();
+        scrollview.hide();
         this._selectedIndex = -1;
     },
 
@@ -95,10 +88,10 @@ Notebook.prototype = {
             this.emit('selection', null);
             return;
         }
-        let [child, labelBox] = this._tabs[index];
+        let [child, labelBox, scrollview] = this._tabs[index];
         labelBox.padding = 1;
         labelBox.border = 1;
-        child.show();
+        scrollview.show();
         this._selectedIndex = index;
         this.emit('selection', child);
     },
@@ -108,7 +101,7 @@ Notebook.prototype = {
             this.selectIndex(-1);
         else {
             for (let i = 0; i < this._tabs.length; i++) {
-                let [tabChild, labelBox] = this._tabs[i];
+                let [tabChild, labelBox, scrollview] = this._tabs[i];
                 if (tabChild == child) {
                     this.selectIndex(i);
                     return;
@@ -130,20 +123,19 @@ Result.prototype = {
 
         this.actor = new Big.Box();
 
-        let cmdTxt = new Clutter.Text({ color: MATRIX_GREEN,
-                                        font_name: MATRIX_FONT,
-                                        ellipsize: Pango.EllipsizeMode.END,
-                                        text: command });
+        let cmdTxt = new St.Label({ text: command });
+        cmdTxt.ellipsize = Pango.EllipsizeMode.END;
+
         this.actor.append(cmdTxt, Big.BoxPackFlags.NONE);
-        let resultTxt = new Clutter.Text({ color: MATRIX_GREEN,
-                                           font_name: MATRIX_FONT,
-                                           ellipsize: Pango.EllipsizeMode.END,
-                                           text: "r(" + index + ") = " + o });
+        let resultTxt = new St.Label({ text: "r(" + index + ") = " + o });
+        resultTxt.ellipsize = Pango.EllipsizeMode.END;
+
         this.actor.append(resultTxt, Big.BoxPackFlags.NONE);
-        let line = new Big.Box({ border_color: GREY,
-                                 border_bottom: 1,
-                                 height: 8 });
-        this.actor.append(line, Big.BoxPackFlags.NONE);
+        let line = new Clutter.Rectangle({ name: "Separator",
+                                           height: 1 });
+        let padBin = new St.Bin({ name: "Separator", x_fill: true, y_fill: true });
+        padBin.add_actor(line);
+        this.actor.append(padBin, Big.BoxPackFlags.NONE);
     }
 }
 
@@ -158,17 +150,14 @@ ActorHierarchy.prototype = {
 
         this._parentList = [];
 
-        this.actor = new Big.Box({ spacing: 4,
-                                   border: 1,
-                                   padding: 4,
-                                   border_color: GREY });
+        this.actor = new St.BoxLayout({ name: "ActorHierarchy", vertical: true });
     },
 
     setTarget: function(actor) {
         this._previousTarget = this._target;
         this.target = actor;
 
-        this.actor.remove_all();
+        this.actor.get_children().forEach(function (child) { child.destroy(); });
 
         if (!(actor instanceof Clutter.Actor))
             return;
@@ -181,11 +170,9 @@ ActorHierarchy.prototype = {
         while ((parent = parent.get_parent()) != null) {
             this._parentList.push(parent);
 
-            let link = new Clutter.Text({ color: MATRIX_GREEN,
-                                          font_name: MATRIX_FONT,
-                                          reactive: true,
+            let link = new St.Label({ reactive: true,
                                       text: "" + parent });
-            this.actor.append(link, Big.BoxPackFlags.IF_FITS);
+            this.actor.add_actor(link);
             let parentTarget = parent;
             link.connect('button-press-event', Lang.bind(this, function () {
                 this._selectByActor(parentTarget);
@@ -214,16 +201,13 @@ PropertyInspector.prototype = {
 
         this._parentList = [];
 
-        this.actor = new Big.Box({ spacing: 4,
-                                   border: 1,
-                                   padding: 4,
-                                   border_color: GREY });
+        this.actor = new St.BoxLayout({ name: "PropertyInspector", vertical: true });
     },
 
     setTarget: function(actor) {
         this.target = actor;
 
-        this.actor.remove_all();
+        this.actor.get_children().forEach(function (child) { child.destroy(); });
 
         for (let propName in actor) {
             let valueStr;
@@ -233,11 +217,9 @@ PropertyInspector.prototype = {
                 valueStr = '<error>';
             }
             let propText = propName + ": " + valueStr;
-            let propDisplay = new Clutter.Text({ color: MATRIX_GREEN,
-                                                 font_name: MATRIX_FONT,
-                                                 reactive: true,
+            let propDisplay = new St.Label({ reactive: true,
                                              text: propText });
-            this.actor.append(propDisplay, Big.BoxPackFlags.IF_FITS);
+            this.actor.add_actor(propDisplay);
         }
     }
 }
@@ -249,20 +231,17 @@ function Inspector() {
 Inspector.prototype = {
     _init: function() {
         let width = 150;
-        let eventHandler = new Big.Box({ background_color: LG_BACKGROUND_COLOR,
-                                         border: 1,
-                                         border_color: LG_BORDER_COLOR,
-                                         corner_radius: 4,
-                                         y: global.stage.height/2,
-                                         reactive: true
-                                      });
+        let primary = global.get_primary_monitor();
+        let eventHandler = new St.BoxLayout({ name: "LookingGlassDialog",
+                                              vertical: false,
+                                              y: primary.y + Math.floor(primary.height / 2),
+                                              reactive: true });
         eventHandler.connect('notify::allocation', Lang.bind(this, function () {
-            eventHandler.x = Math.floor((global.stage.width)/2 - (eventHandler.width)/2);
+            eventHandler.x = primary.x + Math.floor((primary.width - eventHandler.width) / 2);
         }));
         global.stage.add_actor(eventHandler);
-        let displayText = new Clutter.Text({ color: MATRIX_GREEN,
-                                             font_name: MATRIX_FONT, text: '' });
-        eventHandler.append(displayText, Big.BoxPackFlags.EXPAND);
+        let displayText = new St.Label();
+        eventHandler.add(displayText, { expand: true });
 
         let borderPaintTarget = null;
         let borderPaintId = null;
@@ -321,29 +300,26 @@ LookingGlass.prototype = {
         this._offset = 0;
         this._results = [];
 
-        // TODO replace with scrolling or something better
-        this._maxItems = 10;
+        // Sort of magic, but...eh.
+        this._maxItems = 150;
+
+        this.actor = new St.BoxLayout({ name: "LookingGlassDialog",
+                                        vertical: true,
+                                        visible: false });
+
+        let gconf = Shell.GConf.get_default();
+        gconf.watch_directory("/desktop/gnome/interface");
+        gconf.connect("changed::/desktop/gnome/interface/monospace_font_name",
+                      Lang.bind(this, this._updateFont));
+        this._updateFont();
 
-        this.actor = new Big.Box({ background_color: LG_BACKGROUND_COLOR,
-                                   border: 1,
-                                   border_color: LG_BORDER_COLOR,
-                                   corner_radius: 4,
-                                   padding_top: 8,
-                                   padding_left: 4,
-                                   padding_right: 4,
-                                   padding_bottom: 4,
-                                   spacing: 4,
-                                   visible: false
-                                });
         global.stage.add_actor(this.actor);
 
-        let toolbar = new Big.Box({ orientation: Big.BoxOrientation.HORIZONTAL,
-                                    border: 1, border_color: GREY,
-                                    corner_radius: 4 });
-        this.actor.append(toolbar, Big.BoxPackFlags.NONE);
+        let toolbar = new St.BoxLayout({ name: "Toolbar" });
+        this.actor.add_actor(toolbar);
         let inspectIcon = Shell.TextureCache.get_default().load_gicon(new Gio.ThemedIcon({ name: 'gtk-color-picker' }),
                                                                       24);
-        toolbar.append(inspectIcon, Big.BoxPackFlags.NONE);
+        toolbar.add_actor(inspectIcon);
         inspectIcon.reactive = true;
         inspectIcon.connect('button-press-event', Lang.bind(this, function () {
             let inspector = new Inspector();
@@ -361,31 +337,26 @@ LookingGlass.prototype = {
         }));
 
         let notebook = new Notebook();
-        this.actor.append(notebook.actor, Big.BoxPackFlags.EXPAND);
-        toolbar.append(notebook.tabControls, Big.BoxPackFlags.END);
+        this.actor.add(notebook.actor, { expand: true });
 
-        this._evalBox = new Big.Box({ orientation: Big.BoxOrientation.VERTICAL,
-                                      spacing: 4 });
+        let emptyBox = new St.Bin();
+        toolbar.add(emptyBox, { expand: true });
+        toolbar.add_actor(notebook.tabControls);
+
+        this._evalBox = new St.BoxLayout({ name: "EvalBox", vertical: true });
         notebook.appendPage('Evaluator', this._evalBox);
 
         this._resultsArea = new Big.Box({ orientation: Big.BoxOrientation.VERTICAL,
                                           spacing: 4 });
-        this._evalBox.append(this._resultsArea, Big.BoxPackFlags.EXPAND);
+        this._evalBox.add(this._resultsArea, { expand: true });
 
         let entryArea = new Big.Box({ orientation: Big.BoxOrientation.HORIZONTAL });
-        this._evalBox.append(entryArea, Big.BoxPackFlags.NONE);
+        this._evalBox.add_actor(entryArea);
 
-        let label = new Clutter.Text({ color: MATRIX_GREEN,
-                                       font_name: MATRIX_FONT,
-                                       text: 'js>>> ' });
+        let label = new St.Label({ text: 'js>>> ' });
         entryArea.append(label, Big.BoxPackFlags.NONE);
 
-        this._entry = new Clutter.Text({ color: MATRIX_GREEN,
-                                         font_name: MATRIX_FONT,
-                                         editable: true,
-                                         activatable: true,
-                                         singleLineMode: true,
-                                         text: ''});
+        this._entry = new St.Entry();
         /* unmapping the edit box will un-focus it, undo that */
         notebook.connect('selection', Lang.bind(this, function (nb, child) {
             if (child == this._evalBox)
@@ -403,7 +374,7 @@ LookingGlass.prototype = {
             notebook.selectIndex(0);
         }));
 
-        this._entry.connect('activate', Lang.bind(this, function (o, e) {
+        this._entry.clutter_text.connect('activate', Lang.bind(this, function (o, e) {
             let text = o.get_text();
             // Ensure we don't get newlines in the command; the history file is
             // newline-separated.
@@ -416,7 +387,7 @@ LookingGlass.prototype = {
             this._historyNavIndex = -1;
             return true;
         }));
-        this._entry.connect('key-press-event', Lang.bind(this, function(o, e) {
+        this._entry.clutter_text.connect('key-press-event', Lang.bind(this, function(o, e) {
             let symbol = e.get_key_symbol();
             if (symbol == Clutter.Escape) {
                 this.close();
@@ -446,6 +417,19 @@ LookingGlass.prototype = {
         }));
     },
 
+    _updateFont: function() {
+        let gconf = Shell.GConf.get_default();
+        let fontName = gconf.get_string("/desktop/gnome/interface/monospace_font_name");
+        // This is mishandled by the scanner - should by Pango.FontDescription_from_string(fontName);
+        // https://bugzilla.gnome.org/show_bug.cgi?id=595889
+        let fontDesc = Pango.Font.description_from_string(fontName);
+        // We ignore everything but size and style; you'd be crazy to set your system-wide
+        // monospace font to be bold/oblique/etc. Could easily be added here.
+        this.actor.style =
+            'font-size: ' + fontDesc.get_size() / 1024. + (fontDesc.get_size_is_absolute() ? 'px' : 'pt') + ';'
+            + 'font-family: "' + fontDesc.get_family() + '";';
+    },
+
     _readHistory: function () {
         if (!this._historyFile.query_exists(null))
             return;
@@ -518,11 +502,11 @@ LookingGlass.prototype = {
     },
 
     _resizeTo: function(actor) {
-        let stage = global.stage;
-        let myWidth = stage.width * 0.7;
-        let myHeight = stage.height * 0.7;
+        let primary = global.get_primary_monitor();
+        let myWidth = primary.width * 0.7;
+        let myHeight = primary.height * 0.7;
         let [srcX, srcY] = actor.get_transformed_position();
-        this.actor.x = srcX + (stage.width-myWidth)/2;
+        this.actor.x = srcX + (primary.width - myWidth) / 2;
         this._hiddenY = srcY + actor.height - myHeight - 4; // -4 to hide the top corners
         this._targetY = this._hiddenY + myHeight;
         this.actor.y = this._hiddenY;
@@ -542,13 +526,15 @@ LookingGlass.prototype = {
         if (this._open)
             return;
 
+        if (!Main.pushModal(this.actor))
+            return;
+
         this.actor.show();
         this.actor.lower(Main.chrome.actor);
         this._open = true;
 
         Tweener.removeTweens(this.actor);
 
-        Main.pushModal(this.actor);
         global.stage.set_key_focus(this._entry);
 
         Tweener.addTween(this.actor, { time: 0.5,

js/ui/main.js

@@ -1,6 +1,7 @@
 /* -*- mode: js2; js2-basic-offset: 4; indent-tabs-mode: nil -*- */
 
 const Clutter = imports.gi.Clutter;
+const DBus = imports.dbus;
 const Gdk = imports.gi.Gdk;
 const Gio = imports.gi.Gio;
 const GLib = imports.gi.GLib;
@@ -9,14 +10,16 @@ const Mainloop = imports.mainloop;
 const Meta = imports.gi.Meta;
 const Shell = imports.gi.Shell;
 const Signals = imports.signals;
+const St = imports.gi.St;
 
 const Chrome = imports.ui.chrome;
+const Environment = imports.ui.environment;
 const Overview = imports.ui.overview;
 const Panel = imports.ui.panel;
 const RunDialog = imports.ui.runDialog;
 const LookingGlass = imports.ui.lookingGlass;
+const ShellDBus = imports.ui.shellDBus;
 const Sidebar = imports.ui.sidebar;
-const Tweener = imports.ui.tweener;
 const WindowManager = imports.ui.windowManager;
 
 const DEFAULT_BACKGROUND_COLOR = new Clutter.Color();
@@ -30,6 +33,7 @@ let runDialog = null;
 let lookingGlass = null;
 let wm = null;
 let recorder = null;
+let shellDBusService = null;
 let modalCount = 0;
 let modalActorFocusStack = [];
 
@@ -42,8 +46,14 @@ function start() {
     Gio.DesktopAppInfo.set_desktop_env("GNOME");
 
     global.grab_dbus_service();
+    shellDBusService = new ShellDBus.GnomeShell();
+    // Force a connection now; dbus.js will do this internally
+    // if we use its name acquisition stuff but we aren't right
+    // now; to do so we'd need to convert from its async calls
+    // back into sync ones.
+    DBus.session.flush();
 
-    Tweener.init();
+    Environment.init();
 
     // Ensure ShellAppMonitor is initialized; this will
     // also initialize ShellAppSystem first.  ShellAppSystem
@@ -66,10 +76,24 @@ function start() {
     for (let i = 0; i < children.length; i++)
         children[i].destroy();
 
+    let themeContext = St.ThemeContext.get_for_stage (global.stage);
+    let stylesheetPath = global.datadir + "/theme/gnome-shell.css";
+    let theme = new St.Theme ({ application_stylesheet: stylesheetPath });
+    themeContext.set_theme (theme);
+
     global.connect('panel-run-dialog', function(panel) {
         // Make sure not more than one run dialog is shown.
         getRunDialog().open();
     });
+    let shellwm = global.window_manager;
+    shellwm.takeover_keybinding("panel_main_menu");
+    shellwm.connect("keybinding::panel_main_menu", function () {
+        overview.toggle();
+    });
+    shellwm.takeover_keybinding("panel_run_dialog");
+    shellwm.connect("keybinding::panel_run_dialog", function () {
+       getRunDialog().open();
+    });
 
     overview = new Overview.Overview();
     chrome = new Chrome.Chrome();
@@ -103,7 +127,9 @@ function start() {
 }
 
 function _relayout() {
-    panel.actor.set_size(global.screen_width, Panel.PANEL_HEIGHT);
+    let primary = global.get_primary_monitor();
+    panel.actor.set_position(primary.x, primary.y);
+    panel.actor.set_size(primary.width, Panel.PANEL_HEIGHT);
     overview.relayout();
 }
 
@@ -175,7 +201,7 @@ function _globalKeyPressHandler(actor, event) {
                 overview.hide();
 
             return true;
-        } else if (symbol == Clutter.F2 && (event.get_state() & Clutter.ModifierType.MOD1_MASK)) {
+        } else if (symbol == Clutter.F2 && (Shell.get_event_state(event) & Clutter.ModifierType.MOD1_MASK)) {
             getRunDialog().open();
         }
     }
@@ -205,9 +231,18 @@ function _findModal(actor) {
  * Next, record the current Clutter keyboard focus on a stack.  If the modal stack
  * returns to this actor, reset the focus to the actor which was focused
  * at the time pushModal() was invoked.
+ *
+ * Returns: true iff we successfully acquired a grab or already had one
  */
 function pushModal(actor) {
-    let timestamp = global.screen.get_display().get_current_time();
+    if (modalCount == 0) {
+        if (!global.begin_modal(currentTime())) {
+            log("pushModal: invocation of begin_modal failed");
+            return false;
+        }
+    }
+
+    global.set_stage_input_mode(Shell.StageInputMode.FULLSCREEN);
 
     modalCount += 1;
     actor.connect('destroy', function() {
@@ -225,14 +260,7 @@ function pushModal(actor) {
     }
     modalActorFocusStack.push([actor, curFocus]);
 
-    if (modalCount > 1)
-        return;
-
-    if (!global.begin_modal(timestamp)) {
-        log("pushModal: invocation of begin_modal failed");
-        return;
-    }
-    global.set_stage_input_mode(Shell.StageInputMode.FULLSCREEN);
+    return true;
 }
 
 /**
@@ -244,8 +272,6 @@ function pushModal(actor) {
  * previous focus at the time when pushModal() was invoked.
  */
 function popModal(actor) {
-    let timestamp = global.screen.get_display().get_current_time();
-
     modalCount -= 1;
     let focusIndex = _findModal(actor);
     if (focusIndex >= 0) {
@@ -263,7 +289,7 @@ function popModal(actor) {
     if (modalCount > 0)
         return;
 
-    global.end_modal(timestamp);
+    global.end_modal(currentTime());
     global.set_stage_input_mode(Shell.StageInputMode.NORMAL);
 }
 
@@ -283,15 +309,62 @@ function getRunDialog() {
 }
 
 function createAppLaunchContext() {
-    let screen = global.screen;
-    let display = screen.get_display();
-
     let context = new Gdk.AppLaunchContext();
-    context.set_timestamp(display.get_current_time());
+    context.set_timestamp(currentTime());
 
     // Make sure that the app is opened on the current workspace even if
     // the user switches before it starts
-    context.set_desktop(screen.get_active_workspace_index());
+    context.set_desktop(global.screen.get_active_workspace_index());
 
     return context;
 }
+
+/**
+ * currentTime:
+ *
+ * Gets the current X server time from the current Clutter, Gdk, or X
+ * event. If called from outside an event handler, this may return
+ * %Clutter.CURRENT_TIME (aka 0), or it may return a slightly
+ * out-of-date timestamp.
+ */
+function currentTime() {
+    // meta_display_get_current_time() will return the correct time
+    // when handling an X or Gdk event, but will return CurrentTime
+    // from some Clutter event callbacks.
+    //
+    // clutter_get_current_event_time() will return the correct time
+    // from a Clutter event callback, but may return an out-of-date
+    // timestamp if called at other times.
+    //
+    // So we try meta_display_get_current_time() first, since we
+    // can recognize a "wrong" answer from that, and then fall back
+    // to clutter_get_current_event_time().
+
+    let time = global.screen.get_display().get_current_time();
+    if (time != Clutter.CURRENT_TIME)
+        return time;
+
+    return Clutter.get_current_event_time();
+}
+
+/**
+ * activateWindow:
+ * @window: the Meta.Window to activate
+ * @time: (optional) current event time
+ *
+ * Activates @window, switching to its workspace first if necessary
+ */
+function activateWindow(window, time) {
+    let activeWorkspaceNum = global.screen.get_active_workspace_index();
+    let windowWorkspaceNum = window.get_workspace().index();
+
+    if (!time)
+        time = currentTime();
+
+    if (windowWorkspaceNum != activeWorkspaceNum) {
+        let workspace = global.screen.get_workspace_by_index(windowWorkspaceNum);
+        workspace.activate_with_focus(window, time);
+    } else {
+        window.activate(time);
+    }
+}

js/ui/overview.js

@@ -39,6 +39,10 @@ const ANIMATION_TIME = 0.25;
 // will take up the remaining sections of the display.
 
 const WIDE_SCREEN_CUT_OFF_RATIO = 1.4;
+// A common netbook resolution is 1024x600, which trips the widescreen
+// ratio.  However that leaves way too few pixels for the dash.  So
+// just treat this as a regular screen.
+const WIDE_SCREEN_MINIMUM_HEIGHT = 768;
 
 const COLUMNS_REGULAR_SCREEN = 4;
 const ROWS_REGULAR_SCREEN = 8;
@@ -138,41 +142,44 @@ Overview.prototype = {
     },
 
     _recalculateGridSizes: function () {
-        wideScreen = (global.screen_width/global.screen_height > WIDE_SCREEN_CUT_OFF_RATIO);
+        let primary = global.get_primary_monitor();
+        wideScreen = (primary.width/primary.height > WIDE_SCREEN_CUT_OFF_RATIO) &&
+                     (primary.height >= WIDE_SCREEN_MINIMUM_HEIGHT);
 
         // We divide the screen into an imaginary grid which helps us determine the layout of
         // different visual components.
         if (wideScreen) {
-            displayGridColumnWidth = global.screen_width / COLUMNS_WIDE_SCREEN;
-            displayGridRowHeight = global.screen_height / ROWS_WIDE_SCREEN;
+            displayGridColumnWidth = primary.width / COLUMNS_WIDE_SCREEN;
+            displayGridRowHeight = primary.height / ROWS_WIDE_SCREEN;
         } else {
-            displayGridColumnWidth = global.screen_width / COLUMNS_REGULAR_SCREEN;
-            displayGridRowHeight = global.screen_height / ROWS_REGULAR_SCREEN;
+            displayGridColumnWidth = primary.width / COLUMNS_REGULAR_SCREEN;
+            displayGridRowHeight = primary.height / ROWS_REGULAR_SCREEN;
         }
     },
 
     relayout: function () {
-        let screenHeight = global.screen_height;
-        let screenWidth = global.screen_width;
+        let primary = global.get_primary_monitor();
+
+        this._group.set_position(primary.x, primary.y);
 
         let contentY = Panel.PANEL_HEIGHT;
-        let contentHeight = screenHeight - contentY;
+        let contentHeight = primary.height - contentY;
 
         this._coverPane.set_position(0, contentY);
-        this._coverPane.set_size(screenWidth, contentHeight);
+        this._coverPane.set_size(primary.width, contentHeight);
 
         let workspaceColumnsUsed = wideScreen ? COLUMNS_FOR_WORKSPACES_WIDE_SCREEN : COLUMNS_FOR_WORKSPACES_REGULAR_SCREEN;
         let workspaceRowsUsed = wideScreen ? ROWS_FOR_WORKSPACES_WIDE_SCREEN : ROWS_FOR_WORKSPACES_REGULAR_SCREEN;
 
         this._workspacesWidth = displayGridColumnWidth * workspaceColumnsUsed
                                   - WORKSPACE_GRID_PADDING * 2;
-        // We scale the vertical padding by (screenHeight / screenWidth)
+        // We scale the vertical padding by (primary.height / primary.width)
         // so that the workspace preserves its aspect ratio.
         this._workspacesHeight = displayGridRowHeight * workspaceRowsUsed
-                                   - WORKSPACE_GRID_PADDING * (screenHeight / screenWidth) * 2;
+                                   - WORKSPACE_GRID_PADDING * (primary.height / primary.width) * 2;
 
         this._workspacesX = displayGridColumnWidth + WORKSPACE_GRID_PADDING;
-        this._workspacesY = displayGridRowHeight + WORKSPACE_GRID_PADDING * (screenHeight / screenWidth);
+        this._workspacesY = displayGridRowHeight + WORKSPACE_GRID_PADDING * (primary.height / primary.width);
 
         this._dash.actor.set_position(0, contentY);
         this._dash.actor.set_size(displayGridColumnWidth, contentHeight);
@@ -182,10 +189,12 @@ Overview.prototype = {
         // place the 'Add Workspace' button in the bottom row of the grid
         addRemoveButtonSize = Math.floor(displayGridRowHeight * 3/5);
         this._addButtonX = this._workspacesX + this._workspacesWidth - addRemoveButtonSize;
-        this._addButtonY = screenHeight - Math.floor(displayGridRowHeight * 4/5);
+        this._addButtonY = primary.height - Math.floor(displayGridRowHeight * 4/5);
 
-        this._backOver.set_position(0, contentY);
-        this._backOver.set_size(global.screen_width, contentHeight);
+        // The parent (this._group) is positioned at the top left of the primary monitor
+        // while this._backOver occupies the entire screen.
+        this._backOver.set_position(- primary.x, - primary.y);
+        this._backOver.set_size(global.screen_width, global.screen_height);
 
         this._paneContainer.set_position(this._dash.actor.x + this._dash.actor.width + DEFAULT_PADDING,
                                          contentY);
@@ -193,7 +202,7 @@ Overview.prototype = {
         this._paneContainer.height = contentHeight;
 
         this._transparentBackground.set_position(this._paneContainer.x, this._paneContainer.y);
-        this._transparentBackground.set_size(global.screen_width - this._paneContainer.x,
+        this._transparentBackground.set_size(primary.width - this._paneContainer.x,
                                              this._paneContainer.height);
 
         if (this._activeDisplayPane != null)
@@ -277,7 +286,8 @@ Overview.prototype = {
     show : function() {
         if (this.visible)
             return;
-        Main.pushModal(this._dash.actor);
+        if (!Main.pushModal(this._dash.actor))
+            return;
 
         this.visible = true;
         this.animationInProgress = true;
@@ -316,9 +326,10 @@ Overview.prototype = {
         // The opposite transition is used in hide().
         this._group.scaleX = this._group.scaleY = this.getZoomedInScale();
         [this._group.x, this._group.y] = this.getZoomedInPosition();
+        let primary = global.get_primary_monitor();
         Tweener.addTween(this._group,
-                         { x: 0,
-                           y: 0,
+                         { x: primary.x,
+                           y: primary.y,
                            scaleX: 1,
                            scaleY: 1,
                            transition: 'easeOutQuad',
@@ -349,6 +360,10 @@ Overview.prototype = {
             this._activeDisplayPane.close();
         this._workspaces.hide();
 
+        this._addButton.actor.destroy();
+        this._addButton.actor = null;
+        this._addButton = null;
+
         // Create a zoom in effect by transforming the Overview group so that
         // the active workspace fills up the whole screen. The opposite
         // transition is used in show().
@@ -441,7 +456,7 @@ Overview.prototype = {
     },
 
     _addNewWorkspace: function() {
-        global.screen.append_new_workspace(false, global.screen.get_display().get_current_time());
+        global.screen.append_new_workspace(false, Main.currentTime());
     },
 
     _acceptNewWorkspaceDrop: function(source, dropActor, x, y, time) {

js/ui/panel.js

@@ -7,12 +7,14 @@ const Lang = imports.lang;
 const Mainloop = imports.mainloop;
 const Meta = imports.gi.Meta;
 const Shell = imports.gi.Shell;
+const St = imports.gi.St;
 const Tweener = imports.ui.tweener;
 const Signals = imports.signals;
 const Gettext = imports.gettext.domain('gnome-shell');
 const _ = Gettext.gettext;
 
 const Button = imports.ui.button;
+const Calendar = imports.ui.calendar;
 const Main = imports.ui.main;
 
 const PANEL_HEIGHT = 26;
@@ -53,12 +55,13 @@ const TRAY_SPACING_MIN = 8;
 // Used for the tray icon container with gtk pre-2.16, which doesn't
 // fully support tray icon transparency
 const TRAY_BACKGROUND_COLOR = new Clutter.Color();
-TRAY_BACKGROUND_COLOR.from_pixel(0xefefefff);
+TRAY_BACKGROUND_COLOR.from_pixel(0x0b0b0bff);
 const TRAY_BORDER_COLOR = new Clutter.Color();
 TRAY_BORDER_COLOR.from_pixel(0x00000033);
 const TRAY_CORNER_RADIUS = 5;
 const TRAY_BORDER_WIDTH = 0;
 
+const HOT_CORNER_ACTIVATION_TIMEOUT = 0.5;
 
 function AppPanelMenu() {
     this._init();
@@ -288,6 +291,8 @@ Panel.prototype = {
                                                   opacity: 0,
                                                   reactive: true });
 
+        this._hotCornerActivationTime = 0;
+
         this._hotCornerEnvirons.connect('leave-event',
                                         Lang.bind(this, this._onHotCornerEnvironsLeft));
         // Clicking on the hot corner environs should result in the same bahavior
@@ -313,10 +318,17 @@ Panel.prototype = {
 
         /* center */
 
+        let clockButton = new St.Button({ style_class: "panel-button",
+                                          toggle_mode: true });
+        this._centerBox.append(clockButton, Big.BoxPackFlags.NONE);
+        clockButton.connect('clicked', Lang.bind(this, this._toggleCalendar));
+
         this._clock = new Clutter.Text({ font_name: DEFAULT_FONT,
                                          color: PANEL_FOREGROUND_COLOR,
                                          text: "" });
-        this._centerBox.append(this._clock, Big.BoxPackFlags.NONE);
+        clockButton.add_actor(this._clock);
+
+        this._calendarPopup = null;
 
         /* right */
 
@@ -395,14 +407,14 @@ Panel.prototype = {
         // We get into the Overview mode on button-press-event as opposed to button-release-event because eventually we'll probably
         // have the Overview act like a menu that allows the user to release the mouse on the activity the user wants
         // to switch to.
-        this.button.actor.connect('button-press-event', function(b, e) {
-            if (e.get_button() == 1 && e.get_click_count() == 1) {
-                Main.overview.toggle();
+        this.button.actor.connect('button-press-event', Lang.bind(this, function(b, e) {
+            if (e.get_button() == 1 && e.get_click_count() == 1 && !Main.overview.animationInProgress) {
+                this._maybeToggleOverviewOnClick();
                 return true;
             } else {
                 return false;
             }
-        });
+        }));
         // In addition to pressing the button, the Overview can be entered and exited by other means, such as
         // pressing the System key, Alt+F1 or Esc. We want the button to be pressed in when the Overview is entered
         // and to be released when it is exited regardless of how it was triggered.
@@ -454,10 +466,21 @@ Panel.prototype = {
         return false;
     },
 
+    _toggleCalendar: function(clockButton) {
+        if (clockButton.checked) {
+            if (this._calendarPopup == null)
+                this._calendarPopup = new CalendarPopup();
+            this._calendarPopup.show();
+        } else {
+            this._calendarPopup.hide();
+        }
+    },
+
     _onHotCornerEntered : function() {
         if (!this._hotCornerEntered) {
             this._hotCornerEntered = true;
             if (!Main.overview.animationInProgress) {
+                this._hotCornerActivationTime = Date.now() / 1000;
                 Main.overview.toggle();
             }
         }
@@ -466,7 +489,7 @@ Panel.prototype = {
 
     _onHotCornerClicked : function() {
          if (!Main.overview.animationInProgress) {
-             Main.overview.toggle();
+             this._maybeToggleOverviewOnClick();
          }
          return false;
     },
@@ -483,5 +506,65 @@ Panel.prototype = {
             this._hotCornerEntered = false;
         }
         return false;
+    },
+
+    // Toggles the overview unless this is the first click on the Activities button within the HOT_CORNER_ACTIVATION_TIMEOUT time
+    // of the hot corner being triggered. This check avoids opening and closing the overview if the user both triggered the hot corner
+    // and clicked the Activities button.
+    _maybeToggleOverviewOnClick: function() {
+        if (this._hotCornerActivationTime == 0 || Date.now() / 1000 - this._hotCornerActivationTime > HOT_CORNER_ACTIVATION_TIMEOUT)
+            Main.overview.toggle();
+        this._hotCornerActivationTime = 0;
+    }
+};
+
+function CalendarPopup() {
+    this._init();
+}
+
+CalendarPopup.prototype = {
+    _init: function() {
+        let panelActor = Main.panel.actor;
+
+        this.actor = new St.BoxLayout({ name: 'calendarPopup' });
+
+        this.calendar = new Calendar.Calendar();
+        this.actor.add(this.calendar.actor);
+
+        // Directly adding the actor to Main.chrome.actor is a hack to
+        // work around the fact that there is no way to add an actor that
+        // affects the input region but not the shape.
+        // See: https://bugzilla.gnome.org/show_bug.cgi?id=597044
+        Main.chrome.actor.add_actor(this.actor);
+        Main.chrome.addInputRegionActor(this.actor);
+        this.actor.y = (panelActor.y + panelActor.height - this.actor.height);
+    },
+
+    show: function() {
+        let panelActor = Main.panel.actor;
+
+        // Reset the calendar to today's date
+        this.calendar.setDate(new Date());
+
+        this.actor.x = Math.round(panelActor.x + (panelActor.width - this.actor.width) / 2);
+        this.actor.lower(panelActor);
+        this.actor.show();
+        Tweener.addTween(this.actor,
+                         { y: panelActor.y + panelActor.height,
+                           time: 0.2,
+                           transition: "easeOutQuad"
+                         });
+    },
+
+    hide: function() {
+        let panelActor = Main.panel.actor;
+
+        Tweener.addTween(this.actor,
+                         { y: panelActor.y + panelActor.height - this.actor.height,
+                           time: 0.2,
+                           transition: "easeOutQuad",
+                           onComplete: function() { this.actor.hide(); },
+                           onCompleteScope: this
+                         });
     }
 };

js/ui/places.js

@@ -9,11 +9,16 @@ const Shell = imports.gi.Shell;
 const Lang = imports.lang;
 const Mainloop = imports.mainloop;
 const Signals = imports.signals;
+const Gettext = imports.gettext.domain('gnome-shell');
+const _ = Gettext.gettext;
 
 const DND = imports.ui.dnd;
 const Main = imports.ui.main;
 const GenericDisplay = imports.ui.genericDisplay;
 
+const NAUTILUS_PREFS_DIR = '/apps/nautilus/preferences';
+const DESKTOP_IS_HOME_KEY = NAUTILUS_PREFS_DIR + '/desktop_is_home_dir';
+
 const PLACES_VSPACING = 8;
 const PLACES_ICON_SIZE = 16;
 
@@ -75,17 +80,33 @@ function Places() {
 
 Places.prototype = {
     _init : function() {
+        // Places is divided semi-arbitrarily into left and right; a grid would
+        // look better in that there would be an even number of items left+right,
+        // but it seems like we want some sort of differentiation between actions
+        // like "Connect to server..." and regular folders
         this.actor = new Big.Box({ orientation: Big.BoxOrientation.HORIZONTAL,
                                    spacing: 4 });
-        this._menuBox = new Big.Box({ orientation: Big.BoxOrientation.VERTICAL,
-                                      spacing: PLACES_VSPACING });
-        this.actor.append(this._menuBox, Big.BoxPackFlags.EXPAND);
-        this._devBox = new Big.Box({ orientation: Big.BoxOrientation.VERTICAL,
-                                      spacing: PLACES_VSPACING });
+        this._leftBox = new Big.Box({ orientation: Big.BoxOrientation.VERTICAL });
+        this.actor.append(this._leftBox, Big.BoxPackFlags.EXPAND);
+        this._rightBox = new Big.Box({ orientation: Big.BoxOrientation.VERTICAL });
+        this.actor.append(this._rightBox, Big.BoxPackFlags.EXPAND);
 
+        // Subdivide left into actions and devices
+        this._actionsBox = new Big.Box({ orientation: Big.BoxOrientation.VERTICAL,
+                                         spacing: PLACES_VSPACING });
+        this._leftBox.append(this._actionsBox, Big.BoxPackFlags.NONE);
+        this._devBox = new Big.Box({ orientation: Big.BoxOrientation.VERTICAL,
+                                      spacing: PLACES_VSPACING,
+                                      padding_top: 6 });
+        this._leftBox.append(this._devBox, Big.BoxPackFlags.NONE);
+
+        // Right is bookmarks
         this._dirsBox = new Big.Box({ orientation: Big.BoxOrientation.VERTICAL,
                                       spacing: PLACES_VSPACING });
-        this.actor.append(this._dirsBox, Big.BoxPackFlags.EXPAND);
+        this._rightBox.append(this._dirsBox, Big.BoxPackFlags.NONE);
+
+        let gconf = Shell.GConf.get_default();
+        gconf.watch_directory(NAUTILUS_PREFS_DIR);
 
         let homeFile = Gio.file_new_for_path (GLib.get_home_dir());
         let homeUri = homeFile.get_uri();
@@ -99,13 +120,27 @@ Places.prototype = {
                 Gio.app_info_launch_default_for_uri(homeUri, Main.createAppLaunchContext());
             });
 
-        this._menuBox.append(home.actor, Big.BoxPackFlags.NONE);
+        this._actionsBox.append(home.actor, Big.BoxPackFlags.NONE);
+
+        let desktopPath = GLib.get_user_special_dir(GLib.UserDirectory.DIRECTORY_DESKTOP);
+        let desktopFile = Gio.file_new_for_path (desktopPath);
+        let desktopUri = desktopFile.get_uri();
+        let desktopLabel = Shell.util_get_label_for_uri (desktopUri);
+        let desktopIcon = Shell.util_get_icon_for_uri (desktopUri);
+        this._desktopMenu = new PlaceDisplay(desktopLabel,
+            function() {
+                return Shell.TextureCache.get_default().load_gicon(desktopIcon, PLACES_ICON_SIZE);
+            },
+            function() {
+                Gio.app_info_launch_default_for_uri(desktopUri, Main.createAppLaunchContext());
+            });
+        this._actionsBox.append(this._desktopMenu.actor, Big.BoxPackFlags.NONE);
+        this._updateDesktopMenuVisibility();
+        gconf.connect('changed::' + DESKTOP_IS_HOME_KEY, Lang.bind(this, this._updateDesktopMenuVisibility));
 
         /*
         * Show devices, code more or less ported from nautilus-places-sidebar.c
         */
-
-        this._menuBox.append(this._devBox, Big.BoxPackFlags.NONE);
         this._volumeMonitor = Gio.VolumeMonitor.get();
         this._volumeMonitor.connect('volume-added', Lang.bind(this, this._updateDevices));
         this._volumeMonitor.connect('volume-removed',Lang.bind(this, this._updateDevices));
@@ -137,17 +172,17 @@ Places.prototype = {
                 function () {
                     networkApp.launch();
                 });
-            this._menuBox.append(network.actor, Big.BoxPackFlags.NONE);
+            this._actionsBox.append(network.actor, Big.BoxPackFlags.NONE);
         }
 
-        let connect = new PlaceDisplay('Connect to...',
+        let connect = new PlaceDisplay(_("Connect to..."),
             function () {
                 return Shell.TextureCache.get_default().load_icon_name("applications-internet", PLACES_ICON_SIZE);
             },
             function () {
                 new Shell.Process({ args: ['nautilus-connect-server'] }).run();
             });
-        this._menuBox.append(connect.actor, Big.BoxPackFlags.NONE);
+        this._actionsBox.append(connect.actor, Big.BoxPackFlags.NONE);
 
         this._bookmarksPath = GLib.build_filenamev([GLib.get_home_dir(), ".gtk-bookmarks"]);
         this._bookmarksFile = Gio.file_new_for_path(this._bookmarksPath);
@@ -272,7 +307,15 @@ Places.prototype = {
                         Gio.app_info_launch_default_for_uri(mountUri, Main.createAppLaunchContext());
                });
         this._devBox.append(devItem.actor, Big.BoxPackFlags.NONE);
-    }
+    },
 
+    _updateDesktopMenuVisibility: function() {
+        let gconf = Shell.GConf.get_default();
+        let desktopIsHome = gconf.get_boolean(DESKTOP_IS_HOME_KEY);
+        if (desktopIsHome)
+            this._desktopMenu.actor.hide();
+        else
+            this._desktopMenu.actor.show();
+    }
 };
 Signals.addSignalMethods(Places.prototype);

js/ui/runDialog.js

@@ -11,11 +11,9 @@ const Signals = imports.signals;
 const Gettext = imports.gettext.domain('gnome-shell');
 const _ = Gettext.gettext;
 
+const Lightbox = imports.ui.lightbox;
 const Main = imports.ui.main;
 
-const OVERLAY_COLOR = new Clutter.Color();
-OVERLAY_COLOR.from_pixel(0x00000044);
-
 const BOX_BACKGROUND_COLOR = new Clutter.Color();
 BOX_BACKGROUND_COLOR.from_pixel(0x000000cc);
 
@@ -36,9 +34,8 @@ RunDialog.prototype = {
         this._isOpen = false;
 
         let gconf = Shell.GConf.get_default();
-        gconf.connect('changed', Lang.bind(this, function (gconf, key) {
-            if (key == 'development_tools')
-                this._enableInternalCommands = gconf.get_bool('development_tools');
+        gconf.connect('changed::development_tools', Lang.bind(this, function () {
+            this._enableInternalCommands = gconf.get_boolean('development_tools');
         }));
         this._enableInternalCommands = gconf.get_boolean('development_tools');
 
@@ -63,28 +60,26 @@ RunDialog.prototype = {
 
         // All actors are inside _group. We create it initially
         // hidden then show it in show()
-        this._group = new Clutter.Group({ visible: false });
-        global.stage.add_actor(this._group);
-
-        this._overlay = new Clutter.Rectangle({ color: OVERLAY_COLOR,
-                                                width: global.screen_width,
-                                                height: global.screen_height,
-                                                border_width: 0,
-                                                reactive: true });
-        this._group.add_actor(this._overlay);
-
-        let boxH = new Big.Box({ orientation: Big.BoxOrientation.HORIZONTAL,
-                                 x_align: Big.BoxAlignment.CENTER,
-                                 y_align: Big.BoxAlignment.CENTER,
+        this._group = new Clutter.Group({ visible: false,
+                                          x: 0,
+                                          y: 0,
                                           width: global.screen_width,
                                           height: global.screen_height });
+        global.stage.add_actor(this._group);
 
-        this._group.add_actor(boxH);
+        let lightbox = new Lightbox.Lightbox(this._group);
+
+        this._boxH = new Big.Box({ orientation: Big.BoxOrientation.HORIZONTAL,
+                                   x_align: Big.BoxAlignment.CENTER,
+                                   y_align: Big.BoxAlignment.CENTER });
+
+        this._group.add_actor(this._boxH);
+        lightbox.highlight(this._boxH);
 
         let boxV = new Big.Box({ orientation: Big.BoxOrientation.VERTICAL,
                                  y_align: Big.BoxAlignment.CENTER });
 
-        boxH.append(boxV, Big.BoxPackFlags.NONE);
+        this._boxH.append(boxV, Big.BoxPackFlags.NONE);
 
 
         let dialogBox = new Big.Box({ orientation: Big.BoxOrientation.VERTICAL,
@@ -94,7 +89,7 @@ RunDialog.prototype = {
                                       padding: DIALOG_PADDING,
                                       width: DIALOG_WIDTH });
 
-        boxH.append(dialogBox, Big.BoxPackFlags.NONE);
+        this._boxH.append(dialogBox, Big.BoxPackFlags.NONE);
 
         let label = new Clutter.Text({ color: BOX_TEXT_COLOR,
                                        font_name: '18px Sans',
@@ -153,6 +148,7 @@ RunDialog.prototype = {
     },
 
     _run : function(command) {
+        this._commandError = false;
         let f;
         if (this._enableInternalCommands)
             f = this._internalCommands[command];
@@ -162,7 +158,6 @@ RunDialog.prototype = {
             f();
         } else if (command) {
             try {
-                this._commandError = false;
                 let [ok, len, args] = GLib.shell_parse_argv(command);
                 let p = new Shell.Process({'args' : args});
                 p.run();
@@ -175,7 +170,7 @@ RunDialog.prototype = {
                  * We are only interested in the actual error, so parse that out.
                  */
                 let m = /.+\((.+)\)/.exec(e);
-                let errorStr = "Execution of '" + command + "' failed:\n" + m[1];
+                let errorStr = _("Execution of '%s' failed:").format(command) + "\n" + m[1];
                 this._errorMessage.set_text(errorStr);
                 this._errorBox.show();
             }
@@ -186,10 +181,18 @@ RunDialog.prototype = {
         if (this._isOpen) // Already shown
             return;
 
+        if (!Main.pushModal(this._group))
+            return;
+
+        // Position the dialog on the current monitor
+        let monitor = global.get_focus_monitor();
+
+        this._boxH.set_position(monitor.x, monitor.y);
+        this._boxH.set_size(monitor.width, monitor.height);
+
         this._isOpen = true;
         this._group.show();
 
-        Main.pushModal(this._group);
         global.stage.set_key_focus(this._entry);
     },
 

js/ui/shellDBus.js

@@ -0,0 +1,72 @@
+/* -*- mode: js2; js2-basic-offset: 4; indent-tabs-mode: nil -*- */
+
+const DBus = imports.dbus;
+const Lang = imports.lang;
+const Shell = imports.gi.Shell;
+const Mainloop = imports.mainloop;
+
+const Main = imports.ui.main;
+
+const GnomeShellIface = {
+    name: "org.gnome.Shell",
+    methods: [{ name: "Eval",
+                inSignature: "s",
+                outSignature: "bs"
+              }
+             ],
+    signals: [],
+    properties: [{ name: "OverviewActive",
+                   signature: "b",
+                   access: "readwrite" }]
+};
+
+function GnomeShell() {
+    this._init();
+}
+
+GnomeShell.prototype = {
+    _init: function() {
+        DBus.session.exportObject('/org/gnome/Shell', this);
+    },
+
+    /**
+     * Eval:
+     * @code: A string containing JavaScript code
+     *
+     * This function executes arbitrary code in the main
+     * loop, and returns a boolean success and
+     * JSON representation of the object as a string.
+     *
+     * If evaluation completes without throwing an exception,
+     * then the return value will be [true, JSON.stringify(result)].
+     * If evaluation fails, then the return value will be
+     * [false, JSON.stringify(exception)];
+     *
+     */
+    Eval: function(code) {
+        let returnValue;
+        let success;
+        try {
+            returnValue = JSON.stringify(eval(code));
+            success = true;
+        } catch (e) {
+            returnValue = JSON.stringify(e);
+            success = false;
+        }
+        return [success, returnValue];
+    },
+
+    get OverviewActive() {
+        return Main.overview.visible;
+    },
+
+    set OverviewActive(visible) {
+        if (visible)
+            Main.overview.show();
+        else
+            Main.overview.hide();
+    }
+};
+
+DBus.conformExport(GnomeShell.prototype, GnomeShellIface);
+

js/ui/windowManager.js

@@ -4,6 +4,7 @@ const Clutter = imports.gi.Clutter;
 const Lang = imports.lang;
 const Mainloop = imports.mainloop;
 const Meta = imports.gi.Meta;
+const Shell = imports.gi.Shell;
 
 const AltTab = imports.ui.altTab;
 const Main = imports.ui.main;
@@ -39,7 +40,8 @@ WindowManager.prototype = {
         shellwm.connect('destroy', Lang.bind(this, this._destroyWindow));
         shellwm.connect('kill-destroy', Lang.bind(this, this._destroyWindowDone));
 
-        shellwm.connect('begin-alt-tab', Lang.bind(this, this._beginAltTab));
+        shellwm.takeover_keybinding('switch_windows');
+        shellwm.connect('keybinding::switch_windows', Lang.bind(this, this._startAppSwitcher));
     },
 
     _shouldAnimate : function(actor) {
@@ -161,41 +163,10 @@ WindowManager.prototype = {
     },
 
     _destroyWindow : function(shellwm, actor) {
-        if (!this._shouldAnimate(actor)) {
         shellwm.completed_destroy(actor);
-            return;
-        }
-
-        actor.move_anchor_point_from_gravity(Clutter.Gravity.CENTER);
-        
-        /* anachronistic 'tv-like' effect - squash on y axis, leave x alone */
-        this._destroying.push(actor);
-        Tweener.addTween(actor,
-                         { scale_x: 1.0,
-                           scale_y: 0.0,
-                           time: WINDOW_ANIMATION_TIME,
-                           transition: "easeOutQuad",
-                           onComplete: this._destroyWindowDone,
-                           onCompleteScope: this,
-                           onCompleteParams: [shellwm, actor],
-                           onOverwrite: this._destroyWindowOverwrite,
-                           onOverwriteScope: this,
-                           onOverwriteParams: [shellwm, actor]
-                         });
     },
     
     _destroyWindowDone : function(shellwm, actor) {
-        if (this._removeEffect(this._destroying, actor)) {
-            shellwm.completed_destroy(actor);
-            Tweener.removeTweens(actor);
-            actor.set_scale(1.0, 1.0);
-        }
-    },
-
-    _destroyWindowOverwrite : function(shellwm, actor) {
-        if (this._removeEffect(this._destroying, actor)) {
-            shellwm.completed_destroy(actor);
-        }
     },
 
     _switchWorkspace : function(shellwm, from, to, direction) {
@@ -300,12 +271,10 @@ WindowManager.prototype = {
         shellwm.completed_switch_workspace();
     },
 
-    _beginAltTab : function(shellwm, handler) {
-        let popup = new AltTab.AltTabPopup();
+    _startAppSwitcher : function(shellwm, binding, window, backwards) {
+        let tabPopup = new AltTab.AltTabPopup();
 
-        handler.connect('window-added', function(handler, window) { popup.addWindow(window); });
-        handler.connect('show', function(handler, initialSelection) { popup.show(initialSelection); });
-        handler.connect('destroy', function() { popup.destroy(); });
-        handler.connect('notify::selected', function() { popup.select(handler.selected); });
+        if (!tabPopup.show(backwards))
+            tabPopup.destroy();
     }
 };

js/ui/workspaces.js

@@ -12,6 +12,7 @@ const Shell = imports.gi.Shell;
 const Signals = imports.signals;
 
 const DND = imports.ui.dnd;
+const Lightbox = imports.ui.lightbox;
 const Main = imports.ui.main;
 const Overview = imports.ui.overview;
 const Panel = imports.ui.panel;
@@ -25,8 +26,6 @@ const WINDOWCLONE_TITLE_COLOR = new Clutter.Color();
 WINDOWCLONE_TITLE_COLOR.from_pixel(0xffffffff);
 const FRAME_COLOR = new Clutter.Color();
 FRAME_COLOR.from_pixel(0xffffffff);
-const LIGHTBOX_COLOR = new Clutter.Color();
-LIGHTBOX_COLOR.from_pixel(0x00000044);
 
 const SCROLL_SCALE_AMOUNT = 100 / 5;
 
@@ -45,7 +44,8 @@ const POSITIONS = {
         4: [[0.25, 0.25, 0.47],   [0.75, 0.25, 0.47], [0.75, 0.75, 0.47], [0.25, 0.75, 0.47]],
         5: [[0.165, 0.25, 0.32], [0.495, 0.25, 0.32], [0.825, 0.25, 0.32], [0.25, 0.75, 0.32], [0.75, 0.75, 0.32]]
 };
-
+// Used in _orderWindowsPermutations, 5! = 120 which is probably the highest we can go
+const POSITIONING_PERMUTATIONS_MAX = 5;
 
 function _interpolate(start, end, step) {
     return start + (end - start) * step;
@@ -111,6 +111,8 @@ WindowClone.prototype = {
         this.origX = realWindow.x;
         this.origY = realWindow.y;
 
+        this._stackAbove = null;
+
         this._title = null;
 
         this.actor.connect('button-release-event',
@@ -129,6 +131,8 @@ WindowClone.prototype = {
         this._draggable.connect('drag-begin', Lang.bind(this, this._onDragBegin));
         this._draggable.connect('drag-end', Lang.bind(this, this._onDragEnd));
         this._inDrag = false;
+
+        this._zooming = false;
     },
 
     setVisibleWithChrome: function(visible) {
@@ -143,6 +147,14 @@ WindowClone.prototype = {
         }
     },
 
+    setStackAbove: function (actor) {
+        this._stackAbove = actor;
+        if (this._inDrag || this._zooming)
+            // We'll fix up the stack after the drag/zooming
+            return;
+        this.actor.raise(this._stackAbove);
+    },
+
     destroy: function () {
         this.actor.destroy();
         if (this._title)
@@ -157,7 +169,6 @@ WindowClone.prototype = {
 
         this._havePointer = true;
 
-        actor.raise_top();
         this._updateTitle();
     },
 
@@ -206,33 +217,19 @@ WindowClone.prototype = {
     },
 
     _zoomStart : function () {
-        this._zoomOverlay = new Clutter.Rectangle({ reactive: true,
-                                                    color: LIGHTBOX_COLOR,
-                                                    border_width: 0,
-                                                    x: 0,
-                                                    y: 0,
-                                                    width: global.screen_width,
-                                                    height: global.screen_height,
-                                                    opacity: 0 });
-        this._zoomOverlay.show();
-        global.stage.add_actor(this._zoomOverlay);
-        Tweener.addTween(this._zoomOverlay,
-                         { opacity: 255,
-                           time: ZOOM_OVERLAY_FADE_TIME,
-                           transition: "easeOutQuad"
-                         });
+        this._zooming = true;
+
+        this._zoomLightbox = new Lightbox.Lightbox(global.stage);
 
         this._zoomLocalOrig  = new ScaledPoint(this.actor.x, this.actor.y, this.actor.scale_x, this.actor.scale_y);
         this._zoomGlobalOrig = new ScaledPoint();
         let parent = this._origParent = this.actor.get_parent();
-        [width, height] = this.actor.get_transformed_size();
+        let [width, height] = this.actor.get_transformed_size();
         this._zoomGlobalOrig.setPosition.apply(this._zoomGlobalOrig, this.actor.get_transformed_position());
         this._zoomGlobalOrig.setScale(width / this.actor.width, height / this.actor.height);
 
-        this._zoomOverlay.raise_top();
-        this._zoomOverlay.show();
-
         this.actor.reparent(global.stage);
+        this._zoomLightbox.highlight(this.actor);
 
         [this.actor.x, this.actor.y]             = this._zoomGlobalOrig.getPosition();
         [this.actor.scale_x, this.actor.scale_y] = this._zoomGlobalOrig.getScale();
@@ -248,14 +245,17 @@ WindowClone.prototype = {
     },
 
     _zoomEnd : function () {
+        this._zooming = false;
+
         this.actor.reparent(this._origParent);
+        this.actor.raise(this._stackAbove);
 
         [this.actor.x, this.actor.y]             = this._zoomLocalOrig.getPosition();
         [this.actor.scale_x, this.actor.scale_y] = this._zoomLocalOrig.getScale();
 
         this._adjustTitle();
 
-        this._zoomOverlay.destroy();
+        this._zoomLightbox.destroy();
         Main.overview.disconnect(this._hideEventId);
 
         this._zoomLocalPosition  = undefined;
@@ -264,7 +264,7 @@ WindowClone.prototype = {
         this._zoomGlobalScale    = undefined;
         this._zoomTargetPosition = undefined;
         this._zoomStep           = undefined;
-        this._zoomOverlay    = undefined;
+        this._zoomLightbox       = undefined;
     },
 
     _onButtonRelease : function (actor, event) {
@@ -288,6 +288,12 @@ WindowClone.prototype = {
         // mysteriously present
         this._havePointer = false;
 
+        // We may not have a parent if DnD completed successfully, in
+        // which case our clone will shortly be destroyed and replaced
+        // with a new one on the target workspace.
+        if (this.actor.get_parent() != null)
+            this.actor.raise(this._stackAbove);
+
         this.emit('drag-end');
     },
 
@@ -299,7 +305,6 @@ WindowClone.prototype = {
     // Called by Tweener
     onAnimationComplete : function () {
         this._updateTitle();
-        this.actor.raise(this.stackAbove);
     },
 
     _createTitle : function () {
@@ -431,14 +436,6 @@ Workspace.prototype = {
         this.actor.height = global.screen_height;
         this.scale = 1.0;
 
-        this._lightbox = new Clutter.Rectangle({ color: LIGHTBOX_COLOR });
-        this.actor.connect('notify::allocation', Lang.bind(this, function () {
-            let [width, height] = this.actor.get_size();
-            this._lightbox.set_size(width, height);
-        }));
-        this.actor.add_actor(this._lightbox);
-        this._lightbox.hide();
-
         let windows = global.get_windows().filter(this._isMyWindow, this);
 
         // Find the desktop window
@@ -573,10 +570,10 @@ Workspace.prototype = {
      */
     setLightboxMode: function (showLightbox) {
         if (showLightbox) {
-            this.setHighlightWindow(null);
-            this._lightbox.show();
+            this._lightbox = new Lightbox.Lightbox(this.actor);
         } else {
-            this._lightbox.hide();
+            this._lightbox.destroy();
+            this._lightbox = null;
         }
     },
 
@@ -587,13 +584,12 @@ Workspace.prototype = {
      * Draw the user's attention to the given window @metaWindow.
      */
     setHighlightWindow: function (metaWindow) {
-        for (let i = 0; i < this._windows.length; i++) {
-            this._windows[i].actor.lower(this._lightbox);
-        }
+        let actor;
         if (metaWindow != null) {
             let clone = this.lookupCloneForMetaWindow(metaWindow);
-            clone.actor.raise(this._lightbox);
+            actor = clone.actor;
         }
+        this._lightbox.highlight(actor);
     },
 
     _adjustRemoveButton : function() {
@@ -643,12 +639,43 @@ Workspace.prototype = {
                              this._desktop.actor.height + 2 * FRAME_SIZE / this.actor.scale_y);
     },
 
+    _isCloneVisible: function(clone) {
+        return this._showOnlyWindows == null || (clone.metaWindow in this._showOnlyWindows);
+    },
+
+    /**
+     * _getVisibleClones:
+     *
+     * Returns a list WindowClone objects where the clone isn't filtered
+     * out by any application filter.  The clone for the desktop is excluded.
+     * The returned array will always be newly allocated; it is not in any
+     * defined order, and thus it's convenient to call .sort() with your
+     * choice of sorting function.
+     */
+    _getVisibleClones: function() {
+        let visible = [];
+
+        for (let i = 1; i < this._windows.length; i++) {
+            let clone = this._windows[i];
+
+            if (!this._isCloneVisible(clone))
+                continue;
+
+            visible.push(clone);
+        }
+        return visible;
+    },
+
+    _getVisibleWindows: function() {
+        return this._getVisibleClones().map(function (clone) { return clone.metaWindow; });
+    },
+
     _resetCloneVisibility: function () {
         for (let i = 1; i < this._windows.length; i++) {
             let clone = this._windows[i];
             let icon = this._windowIcons[i];
 
-            if (this._showOnlyWindows != null && !(clone.metaWindow in this._showOnlyWindows)) {
+            if (!this._isCloneVisible(clone)) {
                 clone.setVisibleWithChrome(false);
                 icon.hide();
             } else {
@@ -657,6 +684,220 @@ Workspace.prototype = {
         }
     },
 
+    // Only use this for n <= 20 say
+    _factorial: function(n) {
+        let result = 1;
+        for (let i = 2; i <= n; i++)
+            result *= i;
+        return result;
+    },
+
+    /**
+     * _permutation:
+     * @permutationIndex: An integer from [0, list.length!)
+     * @list: (inout): Array of objects to permute; will be modified in place
+     *
+     * Given an integer between 0 and length of array, re-order the array in-place
+     * into a permutation denoted by the index.
+     */
+    _permutation: function(permutationIndex, list) {
+        for (let j = 2; j <= list.length; j++) {
+            let firstIndex = (permutationIndex % j);
+            let secondIndex = j - 1;
+            // Swap
+            let tmp = list[firstIndex];
+            list[firstIndex] = list[secondIndex];
+            list[secondIndex] = tmp;
+            permutationIndex = Math.floor(permutationIndex / j);
+        }
+    },
+
+    /**
+     * _forEachPermutations:
+     * @list: Array
+     * @func: Function which takes a single array argument
+     *
+     * Call @func with each permutation of @list as an argument.
+     */
+    _forEachPermutations: function(list, func) {
+        let nCombinations = this._factorial(list.length);
+        for (let i = 0; i < nCombinations; i++) {
+            let listCopy = list.concat();
+            this._permutation(i, listCopy);
+            func(listCopy);
+        }
+    },
+
+    /**
+     * _computeWindowMotion:
+     * @metaWindow: A #MetaWindow
+     * @slot: An element of #POSITIONS
+     * @slotGeometry: Layout of @slot
+     *
+     * Returns a number corresponding to how much perceived motion
+     * would be involved in moving the window to the given slot.
+     * Currently this is the square of the distance between the
+     * centers.
+     */
+    _computeWindowMotion: function (metaWindow, slot, slotGeometry) {
+        let rect = new Meta.Rectangle();
+        metaWindow.get_outer_rect(rect);
+
+        let [slotX, slotY, slotWidth, slotHeight] = slotGeometry;
+        let distanceSquared;
+        let xDelta, yDelta;
+
+        xDelta = (rect.x + rect.width / 2) - (slotX + slotWidth / 2);
+        yDelta = (rect.y + rect.height / 2) - (slotY + slotHeight / 2);
+        distanceSquared = xDelta * xDelta + yDelta * yDelta;
+
+        return distanceSquared;
+    },
+
+    /**
+     * _orderWindowsPermutations:
+     *
+     * Iterate over all permutations of the windows, and determine the
+     * permutation which has the least total motion.
+     */
+    _orderWindowsPermutations: function (windows, slots, slotGeometries) {
+        let minimumMotionPermutation = null;
+        let minimumMotion = -1;
+        let permIndex = 0;
+        this._forEachPermutations(windows, Lang.bind(this, function (permutation) {
+            let motion = 0;
+            for (let i = 0; i < permutation.length; i++) {
+                let metaWindow = permutation[i];
+                let slot = slots[i];
+                let slotAbsGeometry = slotGeometries[i];
+
+                let delta = this._computeWindowMotion(metaWindow, slot, slotAbsGeometry);
+
+                motion += delta;
+            }
+
+            if (minimumMotionPermutation == null || motion < minimumMotion) {
+                minimumMotionPermutation = permutation;
+                minimumMotion = motion;
+            }
+            permIndex++;
+        }));
+        return minimumMotionPermutation;
+    },
+
+    /**
+     * _orderWindowsGreedy:
+     *
+     * Iterate over available slots in order, placing into each one the window
+     * we find with the smallest motion to that slot.
+     */
+    _orderWindowsGreedy: function(windows, slots, slotGeometries) {
+        let result = [];
+        let slotIndex = 0;
+        // Copy since we mutate below
+        let windowCopy = windows.concat();
+        for (let i = 0; i < slots.length; i++) {
+            let slot = slots[i];
+            let slotGeometry = slotGeometries[i];
+            let minimumMotionIndex = -1;
+            let minimumMotion = -1;
+            for (let j = 0; j < windowCopy.length; j++) {
+                let metaWindow = windowCopy[j];
+                let delta = this._computeWindowMotion(metaWindow, slot, slotGeometry);
+                if (minimumMotionIndex == -1 || delta < minimumMotion) {
+                    minimumMotionIndex = j;
+                    minimumMotion = delta;
+                }
+            }
+            result.push(windowCopy[minimumMotionIndex]);
+            windowCopy.splice(minimumMotionIndex, 1);
+        }
+        return result;
+    },
+
+    /**
+     * _orderWindowsByMotionAndStartup:
+     * @windows: Array of #MetaWindow
+     * @slots: Array of slots
+     *
+     * Returns a copy of @windows, ordered in such a way that they require least motion
+     * to move to the final screen coordinates of @slots.  Ties are broken in a stable
+     * fashion by the order in which the windows were created.
+     */
+    _orderWindowsByMotionAndStartup: function(windows, slots) {
+        let appMonitor = Shell.AppMonitor.get_default();
+        windows.sort(function(w1, w2) {
+            return w2.get_stable_sequence() - w1.get_stable_sequence();
+        });
+        let slotGeometries = slots.map(Lang.bind(this, this._getSlotAbsoluteGeometry));
+        if (windows.length <= POSITIONING_PERMUTATIONS_MAX)
+            return this._orderWindowsPermutations(windows, slots, slotGeometries);
+        else
+            return this._orderWindowsGreedy(windows, slots, slotGeometries);
+    },
+
+    /**
+     * _getSlotRelativeGeometry:
+     * @slot: A layout slot
+     *
+     * Returns: the workspace-relative [x, y, width, height]
+     * of a given window layout slot.
+     */
+    _getSlotRelativeGeometry: function(slot) {
+        let [xCenter, yCenter, fraction] = slot;
+
+        let width = global.screen_width * fraction;
+        let height = global.screen_height * fraction;
+
+        let x = xCenter * global.screen_width - width / 2;
+        let y = yCenter * global.screen_height - height / 2;
+
+        return [x, y, width, height];
+    },
+
+    /**
+     * _getSlotAbsoluteGeometry:
+     * @slot: A layout slot
+     *
+     * Returns: the screen coordiantes [x, y, width, height]
+     * of a given window layout slot.
+     */
+    _getSlotAbsoluteGeometry: function(slot) {
+        let [x, y, width, height] = this._getSlotRelativeGeometry(slot);
+        return [ this.gridX + x, this.gridY + y,
+                 this.scale * width, this.scale * height];
+    },
+
+    /**
+     * _computeWindowRelativeLayout:
+     * @metaWindow: A #MetaWindow
+     * @slot: A layout slot
+     *
+     * Given a window and slot to fit it in, compute its
+     * workspace-relative [x, y, scale] where scale applies
+     * to both X and Y directions.
+     */
+    _computeWindowRelativeLayout: function(metaWindow, slot) {
+        let [xCenter, yCenter, fraction] = slot;
+
+        xCenter = xCenter * global.screen_width;
+        yCenter = yCenter * global.screen_height;
+
+        let rect = new Meta.Rectangle();
+        metaWindow.get_outer_rect(rect);
+
+        let desiredWidth = global.screen_width * fraction;
+        let desiredHeight = global.screen_height * fraction;
+        let scale = Math.min(desiredWidth / rect.width,
+                             desiredHeight / rect.height,
+                             1.0 / this.scale);
+
+        let x = xCenter - 0.5 * scale * rect.width;
+        let y = yCenter - 0.5 * scale * rect.height;
+
+        return [x, y, scale];
+    },
+
     /**
      * positionWindows:
      * @workspaceZooming: If true, then the workspace is moving at the same time and we need to take that into account.
@@ -664,47 +905,25 @@ Workspace.prototype = {
     positionWindows : function(workspaceZooming) {
         let totalVisible = 0;
 
-        for (let i = 1; i < this._windows.length; i++) {
-            let clone = this._windows[i];
+        let visibleWindows = this._getVisibleWindows();
 
-            if (this._showOnlyWindows != null && !(clone.metaWindow in this._showOnlyWindows))
-                continue;
+        // Start the animations
+        let slots = this._computeAllWindowSlots(visibleWindows.length);
+        visibleWindows = this._orderWindowsByMotionAndStartup(visibleWindows, slots);
 
-            totalVisible += 1;
-        }
+        for (let i = 0; i < visibleWindows.length; i++) {
+            let slot = slots[i];
+            let metaWindow = visibleWindows[i];
+            let mainIndex = this._lookupIndex(metaWindow);
+            let clone = metaWindow._delegate;
+            let icon = this._windowIcons[mainIndex];
 
-        let previousWindow = this._windows[0];
-        let visibleIndex = 0;
-        for (let i = 1; i < this._windows.length; i++) {
-            let clone = this._windows[i];
-            let icon = this._windowIcons[i];
-
-            if (this._showOnlyWindows != null && !(clone.metaWindow in this._showOnlyWindows))
-                continue;
-
-            clone.stackAbove = previousWindow.actor;
-            previousWindow = clone;
-
-            visibleIndex += 1;
-
-            let [xCenter, yCenter, fraction] = this._computeWindowPosition(visibleIndex, totalVisible);
-            xCenter = xCenter * global.screen_width;
-            yCenter = yCenter * global.screen_height;
-
-            // clone.actor.width/height aren't reliably set at this point for
-            // a new window - they're only set when the window contents are
-            // initially updated prior to painting.
-            let cloneRect = new Meta.Rectangle();
-            clone.realWindow.meta_window.get_outer_rect(cloneRect);
-
-            let desiredWidth = global.screen_width * fraction;
-            let desiredHeight = global.screen_height * fraction;
-            let scale = Math.min(desiredWidth / cloneRect.width, desiredHeight / cloneRect.height, 1.0 / this.scale);
+            let [x, y, scale] = this._computeWindowRelativeLayout(metaWindow, slot);
 
             icon.hide();
             Tweener.addTween(clone.actor,
-                             { x: xCenter - 0.5 * scale * cloneRect.width,
-                               y: yCenter - 0.5 * scale * cloneRect.height,
+                             { x: x,
+                               y: y,
                                scale_x: scale,
                                scale_y: scale,
                                workspace_relative: workspaceZooming ? this : null,
@@ -717,6 +936,24 @@ Workspace.prototype = {
         }
     },
 
+    syncStacking: function(stackIndices) {
+        let desktopClone = this._windows[0];
+
+        let visibleClones = this._getVisibleClones();
+        visibleClones.sort(function (a, b) { return stackIndices[a.metaWindow.get_stable_sequence()] - stackIndices[b.metaWindow.get_stable_sequence()]; });
+
+        for (let i = 0; i < visibleClones.length; i++) {
+            let clone = visibleClones[i];
+            let metaWindow = clone.metaWindow;
+            if (i == 0) {
+                clone.setStackAbove(desktopClone.actor);
+            } else {
+                let previousClone = visibleClones[i - 1];
+                clone.setStackAbove(previousClone.actor);
+            }
+        }
+    },
+
     _fadeInWindowIcon: function (clone, icon) {
         icon.opacity = 0;
         icon.show();
@@ -1032,11 +1269,7 @@ Workspace.prototype = {
         return clone;
     },
 
-    _computeWindowPosition : function(index, totalWindows) {
-        // ignore this._windows[0], which is the desktop
-        let windowIndex = index - 1;
-        let numberOfWindows = totalWindows;
-
+    _computeWindowSlot : function(windowIndex, numberOfWindows) {
         if (numberOfWindows in POSITIONS)
             return POSITIONS[numberOfWindows][windowIndex];
 
@@ -1053,6 +1286,14 @@ Workspace.prototype = {
         return [xCenter, yCenter, fraction];
     },
 
+    _computeAllWindowSlots: function(totalWindows) {
+        let slots = [];
+        for (let i = 0; i < totalWindows; i++) {
+            slots.push(this._computeWindowSlot(i, totalWindows));
+        }
+        return slots;
+    },
+
     _onCloneSelected : function (clone, time) {
         Main.overview.activateWindow(clone.metaWindow, time);
     },
@@ -1137,8 +1378,10 @@ Workspaces.prototype = {
         // workspaces have been created. This cannot be done first because
         // window movement depends on the Workspaces object being accessible
         // as an Overview member.
+        this._overviewShowingId =
             Main.overview.connect('showing',
                                  Lang.bind(this, function() {
+                this._onRestacked();
                 for (let w = 0; w < this._workspaces.length; w++)
                     this._workspaces[w].zoomToOverview();
         }));
@@ -1150,6 +1393,9 @@ Workspaces.prototype = {
         this._switchWorkspaceNotifyId =
             global.window_manager.connect('switch-workspace',
                                           Lang.bind(this, this._activeWorkspaceChanged));
+        this._restackedNotifyId =
+            global.screen.connect('restacked',
+                                  Lang.bind(this, this._onRestacked));
     },
 
     _lookupWorkspaceForMetaWindow: function (metaWindow) {
@@ -1226,21 +1472,6 @@ Workspaces.prototype = {
         }
     },
 
-    _activateWindowInternal: function (metaWindow, time) {
-        let activeWorkspaceNum = global.screen.get_active_workspace_index();
-        let windowWorkspaceNum = metaWindow.get_workspace().index();
-
-        let clone = this._lookupCloneForMetaWindow (metaWindow);
-        clone.actor.raise_top();
-
-        if (windowWorkspaceNum != activeWorkspaceNum) {
-            let workspace = global.screen.get_workspace_by_index(windowWorkspaceNum);
-            workspace.activate_with_focus(metaWindow, time);
-        } else {
-            metaWindow.activate(time);
-        }
-    },
-
     /**
      * activateWindowFromOverview:
      * @metaWindow: A #MetaWindow
@@ -1253,7 +1484,8 @@ Workspaces.prototype = {
         if (this._windowSelectionAppId != null) {
             this._clearApplicationWindowSelection(false);
         }
-        this._activateWindowInternal(metaWindow, time);
+
+        Main.activateWindow(metaWindow, time);
         Main.overview.hide();
     },
 
@@ -1276,8 +1508,10 @@ Workspaces.prototype = {
         this.actor.destroy();
         this.actor = null;
 
+        Main.overview.disconnect(this._overviewShowingId);
         global.screen.disconnect(this._nWorkspacesNotifyId);
         global.window_manager.disconnect(this._switchWorkspaceNotifyId);
+        global.screen.disconnect(this._restackedNotifyId);
     },
 
     getScale : function() {
@@ -1423,6 +1657,19 @@ Workspaces.prototype = {
         this.actor.add_actor(workspace.actor);
     },
 
+    _onRestacked: function() {
+        let stack = global.get_windows();
+        let stackIndices = {};
+
+        for (let i = 0; i < stack.length; i++) {
+            // Use the stable sequence for an integer to use as a hash key
+            stackIndices[stack[i].get_meta_window().get_stable_sequence()] = i;
+        }
+
+        for (let i = 0; i < this._workspaces.length; i++)
+            this._workspaces[i].syncStacking(stackIndices);
+    },
+
     // Handles a drop onto the (+) button; assumes the new workspace
     // has already been added
     acceptNewWorkspaceDrop : function(source, dropActor, x, y, time) {

po/LINGUAS

@@ -1,3 +1,4 @@
+ar
 ca
 cs
 da
@@ -15,6 +16,7 @@ nl
 pa
 pl
 pt_BR
+sl
 sv
 tr
 zh_CN

po/ar.po

@@ -0,0 +1,204 @@
+# SOME DESCRIPTIVE TITLE.
+# Copyright (C) YEAR THE PACKAGE'S COPYRIGHT HOLDER
+# This file is distributed under the same license as the PACKAGE package.
+# Khaled Hosny <khaledhosny@eglug.org>, 2009.
+msgid ""
+msgstr ""
+"Project-Id-Version: HEAD\n"
+"Report-Msgid-Bugs-To: \n"
+"POT-Creation-Date: 2009-10-03 19:19+0200\n"
+"PO-Revision-Date: 2009-10-03 19:20+0300\n"
+"Last-Translator: Khaled Hosny <khaledhosny@eglug.org>\n"
+"Language-Team: Arabic <doc@arabeyes.org>\n"
+"Language: ar\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=UTF-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+"Plural-Forms: nplurals=6; plural=n==0 ? 0 : n==1 ? 1 : n==2 ? 2 : n%100>=3 "
+"&& n%100<=10 ? 3 : n%100>=11 && n%100<=99 ? 4 : 5;\n"
+"X-Generator: Virtaal 0.4.0\n"
+
+#: ../data/gnome-shell.desktop.in.in.h:1
+msgid "GNOME Shell"
+msgstr "صدفة جنوم"
+
+#: ../data/gnome-shell.desktop.in.in.h:2
+msgid "Window management and application launching"
+msgstr "إدارة النوافذ وإطلاق التطبيقات"
+
+#. left side
+#: ../js/ui/panel.js:271
+msgid "Activities"
+msgstr "الأنشطة"
+
+#. Translators: This is a time format.
+#: ../js/ui/panel.js:461
+msgid "%a %l:%M %p"
+msgstr "%A %Ol:%OM %p"
+
+#: ../js/ui/dash.js:283
+msgid "Find..."
+msgstr "ابحث..."
+
+#: ../js/ui/dash.js:400
+msgid "More"
+msgstr "المزيد"
+
+#: ../js/ui/dash.js:543
+msgid "(see all)"
+msgstr "(انظر الكل)"
+
+#. **** Applications ****
+#: ../js/ui/dash.js:763 ../js/ui/dash.js:825
+msgid "APPLICATIONS"
+msgstr "التطبيقات"
+
+#. **** Places ****
+#. Translators: This is in the sense of locations for documents,
+#. network locations, etc.
+#: ../js/ui/dash.js:783
+msgid "PLACES"
+msgstr "الأماكن"
+
+#. **** Documents ****
+#: ../js/ui/dash.js:790 ../js/ui/dash.js:835
+msgid "RECENT DOCUMENTS"
+msgstr "المستندات الحديثة"
+
+#. **** Search Results ****
+#: ../js/ui/dash.js:815 ../js/ui/dash.js:955
+msgid "SEARCH RESULTS"
+msgstr "نتائج البحث"
+
+#: ../js/ui/dash.js:830
+msgid "PREFERENCES"
+msgstr "التفضيلات"
+
+#: ../js/ui/runDialog.js:96
+msgid "Please enter a command:"
+msgstr "من فضلك اكتب أمرا:"
+
+#: ../src/shell-global.c:812
+msgid "Less than a minute ago"
+msgstr "منذ أقل من دقيقة"
+
+#: ../src/shell-global.c:815
+#, c-format
+msgid "%d minute ago"
+msgid_plural "%d minutes ago"
+msgstr[0] "منذ أقل من دقيقة"
+msgstr[1] "منذ دقيقة"
+msgstr[2] "منذ دقيقتين"
+msgstr[3] "منذ %d دقائق"
+msgstr[4] "منذ %d دقيقة"
+msgstr[5] "منذ %d دقيقة"
+
+#: ../src/shell-global.c:818
+#, c-format
+msgid "%d hour ago"
+msgid_plural "%d hours ago"
+msgstr[0] "منذ أقل من ساعة"
+msgstr[1] "منذ ساعة"
+msgstr[2] "منذ ساعتين"
+msgstr[3] "منذ %d ساعات"
+msgstr[4] "منذ %d ساعة"
+msgstr[5] "منذ %d ساعة"
+
+#: ../src/shell-global.c:821
+#, c-format
+msgid "%d day ago"
+msgid_plural "%d days ago"
+msgstr[0] "منذ أقل من يوم"
+msgstr[1] "منذ يوم"
+msgstr[2] "منذ يومين"
+msgstr[3] "منذ %d أيام"
+msgstr[4] "منذ %d يوما"
+msgstr[5] "منذ %d يوم"
+
+#: ../src/shell-global.c:824
+#, c-format
+msgid "%d week ago"
+msgid_plural "%d weeks ago"
+msgstr[0] "منذ أقل من أسبوع"
+msgstr[1] "منذ أسبوع"
+msgstr[2] "منذ أسبوعين"
+msgstr[3] "منذ %d أسابيع"
+msgstr[4] "منذ %d أسبوعا"
+msgstr[5] "منذ %d أسبوع"
+
+#: ../src/shell-status-menu.c:156
+msgid "Unknown"
+msgstr "مجهول"
+
+#: ../src/shell-status-menu.c:212
+#, c-format
+msgid "Can't lock screen: %s"
+msgstr "تعذّر إيصاد الشاشة: %s"
+
+#: ../src/shell-status-menu.c:227
+#, c-format
+msgid "Can't temporarily set screensaver to blank screen: %s"
+msgstr "تعذّر ضبك حافظة الشاشة مؤقتا لتكون شاشة خالية: %s"
+
+#: ../src/shell-status-menu.c:351
+#, c-format
+msgid "Can't logout: %s"
+msgstr "تعذّر الخروج: %s"
+
+#: ../src/shell-status-menu.c:492
+msgid "Account Information..."
+msgstr "معلومات الحساب..."
+
+#: ../src/shell-status-menu.c:502
+msgid "Sidebar"
+msgstr "الشريط الجانبي"
+
+#: ../src/shell-status-menu.c:510
+msgid "System Preferences..."
+msgstr "تفضيلات النظام..."
+
+#: ../src/shell-status-menu.c:525
+msgid "Lock Screen"
+msgstr "أوصد الشاشة"
+
+#: ../src/shell-status-menu.c:535
+msgid "Switch User"
+msgstr "بدّل المستخدم"
+
+#. Only show switch user if there are other users
+#. Log Out
+#: ../src/shell-status-menu.c:546
+msgid "Log Out..."
+msgstr "اخرج..."
+
+#. Shut down
+#: ../src/shell-status-menu.c:557
+msgid "Shut Down..."
+msgstr "أطفئ..."
+
+#: ../src/shell-uri-util.c:87
+msgid "Home Folder"
+msgstr "مجلد المنزل"
+
+#. Translators: this is the same string as the one found in
+#. * nautilus
+#: ../src/shell-uri-util.c:102
+msgid "File System"
+msgstr "نظام الملفات"
+
+#: ../src/shell-uri-util.c:248
+msgid "Search"
+msgstr "ابحث"
+
+#. Translators: the first string is the name of a gvfs
+#. * method, and the second string is a path. For
+#. * example, "Trash: some-directory". It means that the
+#. * directory called "some-directory" is in the trash.
+#.
+#: ../src/shell-uri-util.c:298
+#, c-format
+msgid "%1$s: %2$s"
+msgstr "‏%1$s:‏ %2$s"
+
+#~ msgid "Browse"
+#~ msgstr "استعرض"

po/ca.po

@@ -7,8 +7,8 @@ msgid ""
 msgstr ""
 "Project-Id-Version: HEAD\n"
 "Report-Msgid-Bugs-To: \n"
-"POT-Creation-Date: 2009-08-30 18:53+0200\n"
-"PO-Revision-Date: 2009-08-30 18:57+0100\n"
+"POT-Creation-Date: 2009-10-01 23:16+0200\n"
+"PO-Revision-Date: 2009-10-01 23:20+0100\n"
 "Last-Translator: Siegfried-Angel Gevatter Pujals <rainct@ubuntu.com>\n"
 "Language-Team: \n"
 "MIME-Version: 1.0\n"
@@ -30,76 +30,81 @@ msgid "Activities"
 msgstr "Activitats"
 
 #. Translators: This is a time format.
-#: ../js/ui/panel.js:454
+#: ../js/ui/panel.js:461
 msgid "%a %l:%M %p"
 msgstr "%a %H:%M"
 
-#: ../js/ui/dash.js:256
+#: ../js/ui/dash.js:283
 msgid "Find..."
 msgstr "Cerca..."
 
-#: ../js/ui/dash.js:374
-msgid "Browse"
-msgstr "Navega"
+#: ../js/ui/dash.js:400
+msgid "More"
+msgstr "Més"
 
-#: ../js/ui/dash.js:451
+#: ../js/ui/dash.js:543
 msgid "(see all)"
 msgstr "(mostra tot)"
 
 #. **** Applications ****
-#: ../js/ui/dash.js:633
-#: ../js/ui/dash.js:681
+#: ../js/ui/dash.js:763
+#: ../js/ui/dash.js:825
 msgid "APPLICATIONS"
 msgstr "APLICACIONS"
 
 #. **** Places ****
 #. Translators: This is in the sense of locations for documents,
 #. network locations, etc.
-#: ../js/ui/dash.js:653
+#: ../js/ui/dash.js:783
 msgid "PLACES"
 msgstr "LLOCS"
 
 #. **** Documents ****
-#: ../js/ui/dash.js:660
-#: ../js/ui/dash.js:692
+#: ../js/ui/dash.js:790
+#: ../js/ui/dash.js:835
 msgid "RECENT DOCUMENTS"
 msgstr "DOCUMENTS RECENTS"
 
 #. **** Search Results ****
-#: ../js/ui/dash.js:679
+#: ../js/ui/dash.js:815
+#: ../js/ui/dash.js:958
 msgid "SEARCH RESULTS"
 msgstr "RESULTATS DE LA CERCA"
 
-#: ../js/ui/runDialog.js:82
+#: ../js/ui/dash.js:830
+msgid "PREFERENCES"
+msgstr "PREFERÈNCIES"
+
+#: ../js/ui/runDialog.js:96
 msgid "Please enter a command:"
 msgstr "Introduïu una ordre:"
 
-#: ../src/shell-global.c:840
+#: ../src/shell-global.c:812
 msgid "Less than a minute ago"
 msgstr "Fa menys d'un minut"
 
-#: ../src/shell-global.c:843
+#: ../src/shell-global.c:815
 #, c-format
 msgid "%d minute ago"
 msgid_plural "%d minutes ago"
 msgstr[0] "Fa %d minut"
 msgstr[1] "Fa %d minuts"
 
-#: ../src/shell-global.c:846
+#: ../src/shell-global.c:818
 #, c-format
 msgid "%d hour ago"
 msgid_plural "%d hours ago"
 msgstr[0] "Fa %d hora"
 msgstr[1] "Fa %d hores"
 
-#: ../src/shell-global.c:849
+#: ../src/shell-global.c:821
 #, c-format
 msgid "%d day ago"
 msgid_plural "%d days ago"
 msgstr[0] "Fa %d dia"
 msgstr[1] "Fa %d dies"
 
-#: ../src/shell-global.c:852
+#: ../src/shell-global.c:824
 #, c-format
 msgid "%d week ago"
 msgid_plural "%d weeks ago"
@@ -180,10 +185,3 @@ msgstr "Cerca"
 msgid "%1$s: %2$s"
 msgstr "%1$s: %2$s"
 
-#~ msgid "Find apps or documents"
-#~ msgstr "Cerca aplicacions o documents"
-#~ msgid "Manager"
-#~ msgstr "Gestor"
-#~ msgid "The user manager object this user is controlled by."
-#~ msgstr "L'objecte gestor d'usuaris que controla a aquest usuari."
-

po/cs.po

@@ -7,9 +7,9 @@ msgid ""
 msgstr ""
 "Project-Id-Version: gnome-shell\n"
 "Report-Msgid-Bugs-To: \n"
-"POT-Creation-Date: 2009-08-30 17:37+0200\n"
-"PO-Revision-Date: 2009-08-30 17:33+0200\n"
-"Last-Translator: Petr Kovar <pknbe@volny.cz>\n"
+"POT-Creation-Date: 2009-09-22 13:36+0200\n"
+"PO-Revision-Date: 2009-09-22 13:37+0200\n"
+"Last-Translator: Andre Klapper <ak-47@gmx.net>, 2009\n"
 "Language-Team: Czech <gnome-cs-list@gnome.org>\n"
 "MIME-Version: 1.0\n"
 "Content-Type: text/plain; charset=UTF-8\n"
@@ -25,58 +25,62 @@ msgid "Window management and application launching"
 msgstr "Správa oken a spouštění aplikací"
 
 #. left side
-#: ../js/ui/panel.js:271
+#: ../js/ui/panel.js:269
 msgid "Activities"
 msgstr "Činnosti"
 
 #. Translators: This is a time format.
-#: ../js/ui/panel.js:454
+#: ../js/ui/panel.js:452
 msgid "%a %l:%M %p"
 msgstr "%a, %H:%M"
 
-#: ../js/ui/dash.js:256
+#: ../js/ui/dash.js:283
 msgid "Find..."
 msgstr "Najít..."
 
-#: ../js/ui/dash.js:374
+#: ../js/ui/dash.js:400
 msgid "Browse"
 msgstr "Procházet"
 
-#: ../js/ui/dash.js:451
+#: ../js/ui/dash.js:536
 msgid "(see all)"
 msgstr "(zobrazit vše)"
 
 #. **** Applications ****
-#: ../js/ui/dash.js:633 ../js/ui/dash.js:681
+#: ../js/ui/dash.js:753 ../js/ui/dash.js:809
 msgid "APPLICATIONS"
 msgstr "APLIKACE"
 
 #. **** Places ****
 #. Translators: This is in the sense of locations for documents,
 #. network locations, etc.
-#: ../js/ui/dash.js:653
+#: ../js/ui/dash.js:773
 msgid "PLACES"
 msgstr "MÍSTA"
 
 #. **** Documents ****
-#: ../js/ui/dash.js:660 ../js/ui/dash.js:692
+#: ../js/ui/dash.js:780 ../js/ui/dash.js:819
 msgid "RECENT DOCUMENTS"
 msgstr "NEDÁVNÉ DOKUMENTY"
 
 #. **** Search Results ****
-#: ../js/ui/dash.js:679
+#: ../js/ui/dash.js:799 ../js/ui/dash.js:931
 msgid "SEARCH RESULTS"
 msgstr "VÝSLEDKY HLEDÁNÍ"
 
-#: ../js/ui/runDialog.js:82
+#: ../js/ui/dash.js:814
+msgid "PREFERENCES"
+msgstr "NASTAVENÍ"
+
+#: ../js/ui/runDialog.js:101
 msgid "Please enter a command:"
 msgstr "Zadejte prosím příkaz:"
 
-#: ../src/shell-global.c:840
+#: ../src/shell-global.c:799
 msgid "Less than a minute ago"
 msgstr "Před méně než minutou"
 
-#: ../src/shell-global.c:843
+#: ../src/shell-global.c:802
 #, c-format
 msgid "%d minute ago"
 msgid_plural "%d minutes ago"
@@ -84,7 +88,7 @@ msgstr[0] "Před %d minutou"
 msgstr[1] "Před %d minutami"
 msgstr[2] "Před %d minutami"
 
-#: ../src/shell-global.c:846
+#: ../src/shell-global.c:805
 #, c-format
 msgid "%d hour ago"
 msgid_plural "%d hours ago"
@@ -92,7 +96,7 @@ msgstr[0] "Před %d hodinou"
 msgstr[1] "Před %d hodinami"
 msgstr[2] "Před %d hodinami"
 
-#: ../src/shell-global.c:849
+#: ../src/shell-global.c:808
 #, c-format
 msgid "%d day ago"
 msgid_plural "%d days ago"
@@ -100,7 +104,7 @@ msgstr[0] "Před %d dnem"
 msgstr[1] "Před %d dny"
 msgstr[2] "Před %d dny"
 
-#: ../src/shell-global.c:852
+#: ../src/shell-global.c:811
 #, c-format
 msgid "%d week ago"
 msgid_plural "%d weeks ago"

po/de.po

@@ -4,18 +4,20 @@
 #
 # Hendrik Brandt <heb@gnome-de.org>, 2009.
 # Hendrik Richter <hendrikr@gnome.org>, 2009.
+# Christian Kirbach <Christian.Kirbach@googlemail.com>, 2009.
 #
 msgid ""
 msgstr ""
 "Project-Id-Version: HEAD\n"
-"Report-Msgid-Bugs-To: \n"
-"POT-Creation-Date: 2009-08-20 16:47+0200\n"
-"PO-Revision-Date: 2009-08-20 16:49+0200\n"
-"Last-Translator: Hendrik Richter <hendrikr@gnome.org>\n"
-"Language-Team: Deutsch <gnome-de@gnome.org>\n"
+"Report-Msgid-Bugs-To: http://bugzilla.gnome.org/enter_bug.cgi?product=gnome-"
+"shell&component=general\n"
+"POT-Creation-Date: 2009-10-01 22:22+0000\n"
+"PO-Revision-Date: 2009-10-01 14:32+0200\n"
+"Last-Translator: Christian Kirbach <Christian.Kirbach@googlemail.com>\n"
+"Language-Team: German <gnome-de@gnome.org>\n"
 "MIME-Version: 1.0\n"
 "Content-Type: text/plain; charset=UTF-8\n"
-"Content-Transfer-Encoding: UTF-8\n"
+"Content-Transfer-Encoding: 8bit\n"
 "Plural-Forms: nplurals=2; plural=(n != 1);\n"
 
 #: ../data/gnome-shell.desktop.in.in.h:1
@@ -27,78 +29,83 @@ msgid "Window management and application launching"
 msgstr "Fenster verwalten und Anwendungen starten"
 
 #. left side
-#: ../js/ui/panel.js:266
+#: ../js/ui/panel.js:271
 msgid "Activities"
 msgstr "Aktivitäten"
 
 #. Translators: This is a time format.
-#: ../js/ui/panel.js:433
+#: ../js/ui/panel.js:461
 msgid "%a %l:%M %p"
 msgstr "%a %H:%M"
 
-#: ../js/ui/dash.js:251
-msgid "Find apps or documents"
-msgstr "Anwendungen oder Dokumente suchen"
+#: ../js/ui/dash.js:283
+msgid "Find..."
+msgstr "Suchen …"
 
-#: ../js/ui/dash.js:369
-msgid "Browse"
-msgstr "Durchsuchen"
+#: ../js/ui/dash.js:400
+msgid "More"
+msgstr "Mehr"
+
+#: ../js/ui/dash.js:543
+msgid "(see all)"
+msgstr "(alle sehen)"
 
 #. **** Applications ****
-#: ../js/ui/dash.js:505 ../js/ui/dash.js:578
+#: ../js/ui/dash.js:763 ../js/ui/dash.js:825
 msgid "APPLICATIONS"
 msgstr "ANWENDUNGEN"
 
-#. **** Documents ****
-#: ../js/ui/dash.js:510 ../js/ui/dash.js:605
-msgid "RECENT DOCUMENTS"
-msgstr "ZULETZT GEÖFFNETE DOKUMENTE"
-
 #. **** Places ****
 #. Translators: This is in the sense of locations for documents,
 #. network locations, etc.
-#: ../js/ui/dash.js:598
+#: ../js/ui/dash.js:783
 msgid "PLACES"
 msgstr "ORTE"
 
-#: ../js/ui/runDialog.js:75
+#. **** Documents ****
+#: ../js/ui/dash.js:790 ../js/ui/dash.js:835
+msgid "RECENT DOCUMENTS"
+msgstr "ZULETZT GEÖFFNETE DOKUMENTE"
+
+#. **** Search Results ****
+#: ../js/ui/dash.js:815 ../js/ui/dash.js:955
+msgid "SEARCH RESULTS"
+msgstr "SUCHERGEBNISSE"
+
+#: ../js/ui/dash.js:830
+msgid "PREFERENCES"
+msgstr "EINSTELLUNGEN"
+
+#: ../js/ui/runDialog.js:96
 msgid "Please enter a command:"
 msgstr "Bitte geben Sie einen Befehl ein:"
 
-#: ../src/gdmuser/gdm-user.c:243
-msgid "Manager"
-msgstr "Verwaltung"
-
-#: ../src/gdmuser/gdm-user.c:244
-msgid "The user manager object this user is controlled by."
-msgstr "Das Benutzerverwaltungsobjekt welches diesen Benutzer überwacht."
-
-#: ../src/shell-global.c:841
+#: ../src/shell-global.c:812
 msgid "Less than a minute ago"
 msgstr "Vor weniger als einer Minute"
 
-#: ../src/shell-global.c:844
+#: ../src/shell-global.c:815
 #, c-format
 msgid "%d minute ago"
 msgid_plural "%d minutes ago"
 msgstr[0] "Vor %d Minute"
 msgstr[1] "Vor %d Minuten"
 
-#: ../src/shell-global.c:847
+#: ../src/shell-global.c:818
 #, c-format
 msgid "%d hour ago"
 msgid_plural "%d hours ago"
 msgstr[0] "Vor %d Stunde"
 msgstr[1] "Vor %d Stunden"
 
-#: ../src/shell-global.c:850
+#: ../src/shell-global.c:821
 #, c-format
 msgid "%d day ago"
 msgid_plural "%d days ago"
 msgstr[0] "Vor %d Tag"
 msgstr[1] "Vor %d Tagen"
 
-#: ../src/shell-global.c:853
+#: ../src/shell-global.c:824
 #, c-format
 msgid "%d week ago"
 msgid_plural "%d weeks ago"
@@ -180,3 +187,15 @@ msgstr "Suchen"
 #, c-format
 msgid "%1$s: %2$s"
 msgstr "%1$s: %2$s"
+
+#~ msgid "Find apps or documents"
+#~ msgstr "Anwendungen oder Dokumente suchen"
+
+#~ msgid "Browse"
+#~ msgstr "Durchsuchen"
+
+#~ msgid "Manager"
+#~ msgstr "Verwaltung"
+
+#~ msgid "The user manager object this user is controlled by."
+#~ msgstr "Das Benutzerverwaltungsobjekt welches diesen Benutzer überwacht."

po/es.po

@@ -8,8 +8,8 @@ msgstr ""
 "Project-Id-Version: gnome-shell master\n"
 "Report-Msgid-Bugs-To: http://bugzilla.gnome.org/enter_bug.cgi?product=gnome-"
 "shell&component=general\n"
-"POT-Creation-Date: 2009-09-11 21:48+0000\n"
-"PO-Revision-Date: 2009-09-12 14:40+0200\n"
+"POT-Creation-Date: 2009-09-27 16:05+0000\n"
+"PO-Revision-Date: 2009-09-28 21:58+0200\n"
 "Last-Translator: Jorge González <jorgegonz@svn.gnome.org>\n"
 "Language-Team: Español <gnome-es-list@gnome.org>\n"
 "MIME-Version: 1.0\n"
@@ -40,40 +40,40 @@ msgid "Find..."
 msgstr "Buscar…"
 
 #: ../js/ui/dash.js:400
-msgid "Browse"
-msgstr "Examine"
+msgid "More"
+msgstr "Más"
 
-#: ../js/ui/dash.js:536
+#: ../js/ui/dash.js:543
 msgid "(see all)"
 msgstr "(ver todo)"
 
 #. **** Applications ****
-#: ../js/ui/dash.js:736 ../js/ui/dash.js:792
+#: ../js/ui/dash.js:763 ../js/ui/dash.js:825
 msgid "APPLICATIONS"
 msgstr "APLICACIONES"
 
 #. **** Places ****
 #. Translators: This is in the sense of locations for documents,
 #. network locations, etc.
-#: ../js/ui/dash.js:756
+#: ../js/ui/dash.js:783
 msgid "PLACES"
 msgstr "LUGARES"
 
 #. **** Documents ****
-#: ../js/ui/dash.js:763 ../js/ui/dash.js:802
+#: ../js/ui/dash.js:790 ../js/ui/dash.js:835
 msgid "RECENT DOCUMENTS"
 msgstr "DOCUMENTOS RECIENTES"
 
 #. **** Search Results ****
-#: ../js/ui/dash.js:782 ../js/ui/dash.js:907
+#: ../js/ui/dash.js:815 ../js/ui/dash.js:958
 msgid "SEARCH RESULTS"
 msgstr "RESULTADOS DE LA BÚSQUEDA"
 
-#: ../js/ui/dash.js:797
+#: ../js/ui/dash.js:830
 msgid "PREFERENCES"
 msgstr "PREFERENCIAS"
 
-#: ../js/ui/runDialog.js:90
+#: ../js/ui/runDialog.js:94
 msgid "Please enter a command:"
 msgstr "Introduzca un comando:"
 
@@ -185,6 +185,9 @@ msgstr "Buscar"
 msgid "%1$s: %2$s"
 msgstr "%1$s: %2$s"
 
+#~ msgid "Browse"
+#~ msgstr "Examine"
+
 #~ msgid "Find apps or documents"
 #~ msgstr "Encuentre aplicaciones o documentos"
 

po/hu.po

@@ -7,8 +7,8 @@ msgid ""
 msgstr ""
 "Project-Id-Version: gnome-shell master\n"
 "Report-Msgid-Bugs-To: \n"
-"POT-Creation-Date: 2009-08-15 11:35+0200\n"
-"PO-Revision-Date: 2009-08-15 11:35+0200\n"
+"POT-Creation-Date: 2009-09-28 13:41+0200\n"
+"PO-Revision-Date: 2009-09-28 13:42+0200\n"
 "Last-Translator: Gabor Kelemen <kelemeng at gnome dot hu>\n"
 "Language-Team: Hungarian <gnome at fsf dot hu>\n"
 "MIME-Version: 1.0\n"
@@ -17,77 +17,92 @@ msgstr ""
 "Plural-Forms:  nplurals=2; plural=(n != 1);\n"
 "X-Generator: KBabel 1.11.4\n"
 
+#: ../data/gnome-shell.desktop.in.in.h:1
+msgid "GNOME Shell"
+msgstr "GNOME Shell"
+
+#: ../data/gnome-shell.desktop.in.in.h:2
+msgid "Window management and application launching"
+msgstr "Ablakkezelés és alkalmazásindítás"
+
 #. left side
-#: ../js/ui/panel.js:266
+#: ../js/ui/panel.js:269
 msgid "Activities"
 msgstr "Tevékenységek"
 
 #. Translators: This is a time format.
-#: ../js/ui/panel.js:412
+#: ../js/ui/panel.js:452
 msgid "%a %l:%M %p"
 msgstr "%a., %k.%M"
 
-#: ../js/ui/dash.js:235
-msgid "Find apps or documents"
-msgstr "Alkalmazások vagy dokumentumok keresése"
+#: ../js/ui/dash.js:283
+msgid "Find..."
+msgstr "Keresés…"
 
-#: ../js/ui/dash.js:336
-msgid "Browse"
-msgstr "Tallózás"
+#: ../js/ui/dash.js:400
+msgid "More"
+msgstr "Több"
+
+#: ../js/ui/dash.js:543
+msgid "(see all)"
+msgstr "(összes megjelenítése)"
 
 #. **** Applications ****
-#: ../js/ui/dash.js:472 ../js/ui/dash.js:545
+#: ../js/ui/dash.js:763 ../js/ui/dash.js:825
 msgid "APPLICATIONS"
 msgstr "ALKALMAZÁSOK"
 
-#. **** Documents ****
-#: ../js/ui/dash.js:477 ../js/ui/dash.js:570
-msgid "RECENT DOCUMENTS"
-msgstr "LEGUTÓBBI DOKUMENTUMOK"
-
 #. **** Places ****
-#: ../js/ui/dash.js:563
+#. Translators: This is in the sense of locations for documents,
+#. network locations, etc.
+#: ../js/ui/dash.js:783
 msgid "PLACES"
 msgstr "HELYEK"
 
-#: ../js/ui/runDialog.js:74
+#. **** Documents ****
+#: ../js/ui/dash.js:790 ../js/ui/dash.js:835
+msgid "RECENT DOCUMENTS"
+msgstr "LEGUTÓBBI DOKUMENTUMOK"
+
+#. **** Search Results ****
+#: ../js/ui/dash.js:815 ../js/ui/dash.js:958
+msgid "SEARCH RESULTS"
+msgstr "TALÁLATOK"
+
+#: ../js/ui/dash.js:830
+msgid "PREFERENCES"
+msgstr "BEÁLLÍTÁSOK"
+
+#: ../js/ui/runDialog.js:94
 msgid "Please enter a command:"
 msgstr "Adjon meg egy parancsot:"
 
-#: ../src/gdmuser/gdm-user.c:242
-msgid "Manager"
-msgstr "Kezelő"
-
-#: ../src/gdmuser/gdm-user.c:243
-msgid "The user manager object this user is controlled by."
-msgstr "A felhasználót kezelő felhasználókezelő objektum."
-
-#: ../src/shell-global.c:841
+#: ../src/shell-global.c:799
 msgid "Less than a minute ago"
 msgstr "Kevesebb, mint egy perce"
 
-#: ../src/shell-global.c:844
+#: ../src/shell-global.c:802
 #, c-format
 msgid "%d minute ago"
 msgid_plural "%d minutes ago"
 msgstr[0] "%d perce"
 msgstr[1] "%d perce"
 
-#: ../src/shell-global.c:847
+#: ../src/shell-global.c:805
 #, c-format
 msgid "%d hour ago"
 msgid_plural "%d hours ago"
 msgstr[0] "%d órája"
 msgstr[1] "%d órája"
 
-#: ../src/shell-global.c:850
+#: ../src/shell-global.c:808
 #, c-format
 msgid "%d day ago"
 msgid_plural "%d days ago"
 msgstr[0] "%d napja"
 msgstr[1] "%d napja"
 
-#: ../src/shell-global.c:853
+#: ../src/shell-global.c:811
 #, c-format
 msgid "%d week ago"
 msgid_plural "%d weeks ago"
@@ -146,14 +161,6 @@ msgstr "Kijelentkezés…"
 msgid "Shut Down..."
 msgstr "Leállítás…"
 
-#: ../data/gnome-shell.desktop.in.in.h:1
-msgid "GNOME Shell"
-msgstr "GNOME Shell"
-
-#: ../data/gnome-shell.desktop.in.in.h:2
-msgid "Window management and application launching"
-msgstr "Ablakkezelés és alkalmazásindítás"
-
 #: ../src/shell-uri-util.c:87
 msgid "Home Folder"
 msgstr "Saját mappa"

po/nb.po

@@ -7,8 +7,8 @@ msgid ""
 msgstr ""
 "Project-Id-Version: gnome-shell 0.4\n"
 "Report-Msgid-Bugs-To: \n"
-"POT-Creation-Date: 2009-08-21 12:36+0200\n"
-"PO-Revision-Date: 2009-08-21 12:44+0200\n"
+"POT-Creation-Date: 2009-10-03 10:47+0200\n"
+"PO-Revision-Date: 2009-10-03 10:48+0200\n"
 "Last-Translator: Kjartan Maraas <kmaraas@broadpark.no>\n"
 "Language-Team: Norwegian bokmål <i18n-nb@lister.ping.uio.no>\n"
 "MIME-Version: 1.0\n"
@@ -25,70 +25,83 @@ msgid "Window management and application launching"
 msgstr "Vindushåndtering og oppstart av programmer"
 
 #. left side
-#: ../js/ui/panel.js:266
+#: ../js/ui/panel.js:271
 msgid "Activities"
 msgstr "Aktiviteter"
 
 #. Translators: This is a time format.
-#: ../js/ui/panel.js:433
+#: ../js/ui/panel.js:461
 msgid "%a %l:%M %p"
 msgstr "%a %l:%M"
 
-#: ../js/ui/dash.js:250
-msgid "Find apps or documents"
-msgstr "Finn programmer eller dokumenter"
+#: ../js/ui/dash.js:283
+msgid "Find..."
+msgstr "Finn..."
 
-#: ../js/ui/dash.js:368
-msgid "Browse"
-msgstr "Bla gjennom"
+#: ../js/ui/dash.js:400
+msgid "More"
+msgstr "Mer"
+
+#: ../js/ui/dash.js:543
+msgid "(see all)"
+msgstr "(se alle)"
 
 #. **** Applications ****
-#: ../js/ui/dash.js:504 ../js/ui/dash.js:577
+#: ../js/ui/dash.js:763 ../js/ui/dash.js:825
 msgid "APPLICATIONS"
 msgstr "PROGRAMMER"
 
-#. **** Documents ****
-#: ../js/ui/dash.js:509 ../js/ui/dash.js:604
-msgid "RECENT DOCUMENTS"
-msgstr "SISTE DOKUMENTER"
-
 #. **** Places ****
 #. Translators: This is in the sense of locations for documents,
 #. network locations, etc.
-#: ../js/ui/dash.js:597
+#: ../js/ui/dash.js:783
 msgid "PLACES"
 msgstr "STEDER"
 
-#: ../js/ui/runDialog.js:75
+#. **** Documents ****
+#: ../js/ui/dash.js:790 ../js/ui/dash.js:835
+msgid "RECENT DOCUMENTS"
+msgstr "SISTE DOKUMENTER"
+
+#. **** Search Results ****
+#: ../js/ui/dash.js:815 ../js/ui/dash.js:955
+msgid "SEARCH RESULTS"
+msgstr "SØKERESULTATER"
+
+#: ../js/ui/dash.js:830
+msgid "PREFERENCES"
+msgstr "BRUKERVALG"
+
+#: ../js/ui/runDialog.js:96
 msgid "Please enter a command:"
 msgstr "Oppgi en kommando:"
 
-#: ../src/shell-global.c:841
+#: ../src/shell-global.c:812
 msgid "Less than a minute ago"
 msgstr "Mindre enn ett minutt siden"
 
-#: ../src/shell-global.c:844
+#: ../src/shell-global.c:815
 #, c-format
 msgid "%d minute ago"
 msgid_plural "%d minutes ago"
 msgstr[0] "%d minutt siden"
 msgstr[1] "%d minutter siden"
 
-#: ../src/shell-global.c:847
+#: ../src/shell-global.c:818
 #, c-format
 msgid "%d hour ago"
 msgid_plural "%d hours ago"
 msgstr[0] "%d time siden"
 msgstr[1] "%d timer siden"
 
-#: ../src/shell-global.c:850
+#: ../src/shell-global.c:821
 #, c-format
 msgid "%d day ago"
 msgid_plural "%d days ago"
 msgstr[0] "%d dag siden"
 msgstr[1] "%d dager siden"
 
-#: ../src/shell-global.c:853
+#: ../src/shell-global.c:824
 #, c-format
 msgid "%d week ago"
 msgid_plural "%d weeks ago"

po/pt_BR.po

@@ -2,91 +2,107 @@
 # Copyright (C) 2009 THE gnome-shell'S COPYRIGHT HOLDER
 # This file is distributed under the same license as the gnome-shell package.
 # Og Maciel <ogmaciel@gnome.org>, 2009.
+# Rodrigo Flores <mail@rodrigoflores.org>, 2009.
 #
 msgid ""
 msgstr ""
 "Project-Id-Version: \n"
 "Report-Msgid-Bugs-To: \n"
-"POT-Creation-Date: 2009-08-14 17:53-0400\n"
-"PO-Revision-Date: 2009-08-14 17:53-0400\n"
-"Last-Translator: Og Maciel <ogmaciel@gnome.org>\n"
+"POT-Creation-Date: 2009-09-21 08:39-0300\n"
+"PO-Revision-Date: 2009-09-20 08:41-0300\n"
+"Last-Translator: Rodrigo Flores <mail@rodrigoflores.org>\n"
 "Language-Team: Brazilian Portuguese <gnome-pt_br-list@gnome.org>\n"
 "MIME-Version: 1.0\n"
 "Content-Type: text/plain; charset=UTF-8\n"
 "Content-Transfer-Encoding: 8bit\n"
 "Plural-Forms: nplurals=2; plural=(n > 1);\n"
 
+#: ../data/gnome-shell.desktop.in.in.h:1
+msgid "GNOME Shell"
+msgstr "GNOME Shell"
+
+#: ../data/gnome-shell.desktop.in.in.h:2
+msgid "Window management and application launching"
+msgstr "Gerenciamento de janelas e lançador de aplicações"
+
 #. left side
-#: ../js/ui/panel.js:266
+#: ../js/ui/panel.js:269
 msgid "Activities"
 msgstr "Atividades"
 
 #. Translators: This is a time format.
-#: ../js/ui/panel.js:412
+#: ../js/ui/panel.js:452
 msgid "%a %l:%M %p"
 msgstr "%a %l:%M %p"
 
-#: ../js/ui/dash.js:235
-msgid "Find apps or documents"
-msgstr "Localizar aplicativos ou documentos"
+#: ../js/ui/dash.js:283
+msgid "Find..."
+msgstr "Encontre..."
 
-#: ../js/ui/dash.js:336
+#: ../js/ui/dash.js:400
 msgid "Browse"
 msgstr "Navegar"
 
+#: ../js/ui/dash.js:536
+msgid "(see all)"
+msgstr "(veja todos)"
+
 #. **** Applications ****
-#: ../js/ui/dash.js:472 ../js/ui/dash.js:545
+#: ../js/ui/dash.js:753 ../js/ui/dash.js:809
 msgid "APPLICATIONS"
 msgstr "APLICATIVOS"
 
-#. **** Documents ****
-#: ../js/ui/dash.js:477 ../js/ui/dash.js:570
-msgid "RECENT DOCUMENTS"
-msgstr "DOCUMENTOS RECENTES"
-
 #. **** Places ****
-#: ../js/ui/dash.js:563
+#. Translators: This is in the sense of locations for documents,
+#. network locations, etc.
+#: ../js/ui/dash.js:773
 msgid "PLACES"
 msgstr "LOCAIS"
 
-#: ../js/ui/runDialog.js:74
+#. **** Documents ****
+#: ../js/ui/dash.js:780 ../js/ui/dash.js:819
+msgid "RECENT DOCUMENTS"
+msgstr "DOCUMENTOS RECENTES"
+
+#. **** Search Results ****
+#: ../js/ui/dash.js:799 ../js/ui/dash.js:931
+msgid "SEARCH RESULTS"
+msgstr "RESULTADOS DA BUSCA"
+
+#: ../js/ui/dash.js:814
+msgid "PREFERENCES"
+msgstr "PREFERÊNCIAS"
+
+#: ../js/ui/runDialog.js:101
 msgid "Please enter a command:"
 msgstr "Por favor digite um comando:"
 
-#: ../src/gdmuser/gdm-user.c:242
-msgid "Manager"
-msgstr "Gerenciador"
-
-#: ../src/gdmuser/gdm-user.c:243
-msgid "The user manager object this user is controlled by."
-msgstr "O objeto gerenciador de usuários que controla este usuário."
-
-#: ../src/shell-global.c:841
+#: ../src/shell-global.c:799
 msgid "Less than a minute ago"
 msgstr "Menos de um minuto atrás"
 
-#: ../src/shell-global.c:844
+#: ../src/shell-global.c:802
 #, c-format
 msgid "%d minute ago"
 msgid_plural "%d minutes ago"
 msgstr[0] "%d minuto atrás"
 msgstr[1] "%d minutos atrás"
 
-#: ../src/shell-global.c:847
+#: ../src/shell-global.c:805
 #, c-format
 msgid "%d hour ago"
 msgid_plural "%d hours ago"
 msgstr[0] "%d hora atrás"
 msgstr[1] "%d horas atrás"
 
-#: ../src/shell-global.c:850
+#: ../src/shell-global.c:808
 #, c-format
 msgid "%d day ago"
 msgid_plural "%d days ago"
 msgstr[0] "%d dia atrás"
 msgstr[1] "%d dias atrás"
 
-#: ../src/shell-global.c:853
+#: ../src/shell-global.c:811
 #, c-format
 msgid "%d week ago"
 msgid_plural "%d weeks ago"
@@ -142,3 +158,36 @@ msgstr "Encerrar sessão..."
 #: ../src/shell-status-menu.c:557
 msgid "Shut Down..."
 msgstr "Desligar..."
+
+#: ../src/shell-uri-util.c:87
+msgid "Home Folder"
+msgstr "Pasta home"
+
+#. Translators: this is the same string as the one found in
+#. * nautilus
+#: ../src/shell-uri-util.c:102
+msgid "File System"
+msgstr "Sistema de arquivos"
+
+#: ../src/shell-uri-util.c:248
+msgid "Search"
+msgstr "Procurar"
+
+#. Translators: the first string is the name of a gvfs
+#. * method, and the second string is a path. For
+#. * example, "Trash: some-directory". It means that the
+#. * directory called "some-directory" is in the trash.
+#.
+#: ../src/shell-uri-util.c:298
+#, c-format
+msgid "%1$s: %2$s"
+msgstr "%1$s: %2$s"
+
+#~ msgid "Find apps or documents"
+#~ msgstr "Localizar aplicativos ou documentos"
+
+#~ msgid "Manager"
+#~ msgstr "Gerenciador"
+
+#~ msgid "The user manager object this user is controlled by."
+#~ msgstr "O objeto gerenciador de usuários que controla este usuário."

po/sl.po

@@ -0,0 +1,198 @@
+# Slovenian translation for gnome-shell.
+# This file is distributed under the same license as the gnome-shell package.
+# Matej Urbančič <mateju@svn.gnome.org>, 2009.
+#
+msgid ""
+msgstr ""
+"Project-Id-Version: gnome-shell master\n"
+"Report-Msgid-Bugs-To: http://bugzilla.gnome.org/enter_bug.cgi?product=gnome-shell&component=general\n"
+"POT-Creation-Date: 2009-09-21 22:38+0000\n"
+"PO-Revision-Date: 2009-09-22 10:36+0100\n"
+"Last-Translator: Matej Urbančič <mateju@svn.gnome.org>\n"
+"Language-Team: Slovenian <gnome-si@googlegroups.com>\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=UTF-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+"Language: Slovenian\n"
+"Plural-Forms: nplurals=4; plural=(n%100==1 ? 1 : n%100==2 ? 2 : n%100==3 || n%100==4 ? 3 : 0);\n"
+"X-Poedit-Language: Slovenian\n"
+"X-Poedit-Country: SLOVENIA\n"
+"X-Poedit-SourceCharset: utf-8\n"
+
+#: ../data/gnome-shell.desktop.in.in.h:1
+msgid "GNOME Shell"
+msgstr "Gnome lupina"
+
+#: ../data/gnome-shell.desktop.in.in.h:2
+msgid "Window management and application launching"
+msgstr "Upravljanje oken in zaganjanje programov"
+
+#. left side
+#: ../js/ui/panel.js:269
+msgid "Activities"
+msgstr "Dejavnosti"
+
+#. Translators: This is a time format.
+#: ../js/ui/panel.js:452
+msgid "%a %l:%M %p"
+msgstr "%a, %H:%M"
+
+#: ../js/ui/dash.js:283
+msgid "Find..."
+msgstr "Poišči ..."
+
+#: ../js/ui/dash.js:400
+msgid "Browse"
+msgstr "Prebrskaj"
+
+#: ../js/ui/dash.js:536
+msgid "(see all)"
+msgstr "(poglej vse)"
+
+#. **** Applications ****
+#: ../js/ui/dash.js:753
+#: ../js/ui/dash.js:809
+msgid "APPLICATIONS"
+msgstr "Programi"
+
+#. **** Places ****
+#. Translators: This is in the sense of locations for documents,
+#. network locations, etc.
+#: ../js/ui/dash.js:773
+msgid "PLACES"
+msgstr "Mesta"
+
+#. **** Documents ****
+#: ../js/ui/dash.js:780
+#: ../js/ui/dash.js:819
+msgid "RECENT DOCUMENTS"
+msgstr "Nedavni dokumenti"
+
+#. **** Search Results ****
+#: ../js/ui/dash.js:799
+#: ../js/ui/dash.js:931
+msgid "SEARCH RESULTS"
+msgstr "Rezultati iskanja"
+
+#: ../js/ui/dash.js:814
+msgid "PREFERENCES"
+msgstr "Lastnosti"
+
+#: ../js/ui/runDialog.js:101
+msgid "Please enter a command:"
+msgstr "Prosim, vnesite ukaz:"
+
+#: ../src/shell-global.c:799
+msgid "Less than a minute ago"
+msgstr "Pred manj kot eno minuto"
+
+#: ../src/shell-global.c:802
+#, c-format
+msgid "%d minute ago"
+msgid_plural "%d minutes ago"
+msgstr[0] "Pred %d minutami"
+msgstr[1] "Pred %d minuto"
+msgstr[2] "Pred %d minutama"
+msgstr[3] "Pred %d minutami"
+
+#: ../src/shell-global.c:805
+#, c-format
+msgid "%d hour ago"
+msgid_plural "%d hours ago"
+msgstr[0] "Pred %d urami"
+msgstr[1] "Pred %d uro"
+msgstr[2] "Pred %d urama"
+msgstr[3] "Pred %d urami"
+
+#: ../src/shell-global.c:808
+#, c-format
+msgid "%d day ago"
+msgid_plural "%d days ago"
+msgstr[0] "Pred %d dnevi"
+msgstr[1] "Pred %d dnevom"
+msgstr[2] "Pred %d dnevoma"
+msgstr[3] "Pred %d dnevi"
+
+#: ../src/shell-global.c:811
+#, c-format
+msgid "%d week ago"
+msgid_plural "%d weeks ago"
+msgstr[0] "Pred %d tedni"
+msgstr[1] "Pred %d tednom"
+msgstr[2] "Pred %d tednoma"
+msgstr[3] "Pred %d tedni"
+
+#: ../src/shell-status-menu.c:156
+msgid "Unknown"
+msgstr "Neznano"
+
+#: ../src/shell-status-menu.c:212
+#, c-format
+msgid "Can't lock screen: %s"
+msgstr "Ni mogoče zakleniti zaslona: %s"
+
+#: ../src/shell-status-menu.c:227
+#, c-format
+msgid "Can't temporarily set screensaver to blank screen: %s"
+msgstr "Ni mogoče začasno nastaviti črnega zaslona za ohranjevalnik zaslona: %s"
+
+#: ../src/shell-status-menu.c:351
+#, c-format
+msgid "Can't logout: %s"
+msgstr "Ni se mogoče odjaviti: %s"
+
+#: ../src/shell-status-menu.c:492
+msgid "Account Information..."
+msgstr "Podrobnosti računa ..."
+
+#: ../src/shell-status-menu.c:502
+msgid "Sidebar"
+msgstr "_Stranska vrstica"
+
+#: ../src/shell-status-menu.c:510
+msgid "System Preferences..."
+msgstr "Sistemske lastnosti ..."
+
+#: ../src/shell-status-menu.c:525
+msgid "Lock Screen"
+msgstr "Zakleni zaslon"
+
+#: ../src/shell-status-menu.c:535
+msgid "Switch User"
+msgstr "Preklop uporabnika"
+
+#. Only show switch user if there are other users
+#. Log Out
+#: ../src/shell-status-menu.c:546
+msgid "Log Out..."
+msgstr "Odjava ..."
+
+#. Shut down
+#: ../src/shell-status-menu.c:557
+msgid "Shut Down..."
+msgstr "Izklop ..."
+
+#: ../src/shell-uri-util.c:87
+msgid "Home Folder"
+msgstr "Domača mapa"
+
+#. Translators: this is the same string as the one found in
+#. * nautilus
+#: ../src/shell-uri-util.c:102
+msgid "File System"
+msgstr "Datotečni sistem"
+
+#: ../src/shell-uri-util.c:248
+msgid "Search"
+msgstr "Iskanje"
+
+#. Translators: the first string is the name of a gvfs
+#. * method, and the second string is a path. For
+#. * example, "Trash: some-directory". It means that the
+#. * directory called "some-directory" is in the trash.
+#.
+#: ../src/shell-uri-util.c:298
+#, c-format
+msgid "%1$s: %2$s"
+msgstr "%1$s: %2$s"
+

po/sv.po

@@ -7,8 +7,8 @@ msgid ""
 msgstr ""
 "Project-Id-Version: gnome-shell\n"
 "Report-Msgid-Bugs-To: \n"
-"POT-Creation-Date: 2009-09-01 00:31+0200\n"
-"PO-Revision-Date: 2009-09-01 00:31+0100\n"
+"POT-Creation-Date: 2009-09-18 13:02+0200\n"
+"PO-Revision-Date: 2009-09-18 13:02+0100\n"
 "Last-Translator: Daniel Nylander <po@danielnylander.se>\n"
 "Language-Team: Swedish <tp-sv@listor.tp-sv.se>\n"
 "MIME-Version: 1.0\n"
@@ -25,81 +25,86 @@ msgid "Window management and application launching"
 msgstr "Fönsterhantering och programstarter"
 
 #. left side
-#: ../js/ui/panel.js:271
+#: ../js/ui/panel.js:269
 msgid "Activities"
 msgstr "Aktiviteter"
 
 #. Translators: This is a time format.
-#: ../js/ui/panel.js:454
+#: ../js/ui/panel.js:452
 msgid "%a %l:%M %p"
 msgstr "%a %H.%M"
 
-#: ../js/ui/dash.js:256
+#: ../js/ui/dash.js:283
 msgid "Find..."
 msgstr "Sök..."
 
-#: ../js/ui/dash.js:374
+#: ../js/ui/dash.js:400
 msgid "Browse"
 msgstr "Bläddra"
 
-#: ../js/ui/dash.js:451
+#: ../js/ui/dash.js:536
 msgid "(see all)"
 msgstr "(se alla)"
 
 #. **** Applications ****
-#: ../js/ui/dash.js:633
-#: ../js/ui/dash.js:681
+#: ../js/ui/dash.js:753
+#: ../js/ui/dash.js:809
 msgid "APPLICATIONS"
 msgstr "PROGRAM"
 
 #. **** Places ****
 #. Translators: This is in the sense of locations for documents,
 #. network locations, etc.
-#: ../js/ui/dash.js:653
+#: ../js/ui/dash.js:773
 msgid "PLACES"
 msgstr "PLATSER"
 
 #. **** Documents ****
-#: ../js/ui/dash.js:660
-#: ../js/ui/dash.js:692
+#: ../js/ui/dash.js:780
+#: ../js/ui/dash.js:819
 msgid "RECENT DOCUMENTS"
 msgstr "SENASTE DOKUMENT"
 
 #. **** Search Results ****
-#: ../js/ui/dash.js:679
+#: ../js/ui/dash.js:799
+#: ../js/ui/dash.js:931
 msgid "SEARCH RESULTS"
 msgstr "SÖKRESULTAT"
 
-#: ../js/ui/runDialog.js:82
+#: ../js/ui/dash.js:814
+msgid "PREFERENCES"
+msgstr "INSTÄLLNINGAR"
+
+#: ../js/ui/runDialog.js:101
 msgid "Please enter a command:"
 msgstr "Ange ett kommando:"
 
-#: ../src/shell-global.c:840
+#: ../src/shell-global.c:799
 msgid "Less than a minute ago"
 msgstr "Mindre än en minut sedan"
 
-#: ../src/shell-global.c:843
+#: ../src/shell-global.c:802
 #, c-format
 msgid "%d minute ago"
 msgid_plural "%d minutes ago"
 msgstr[0] "%d minut sedan"
 msgstr[1] "%d minuter sedan"
 
-#: ../src/shell-global.c:846
+#: ../src/shell-global.c:805
 #, c-format
 msgid "%d hour ago"
 msgid_plural "%d hours ago"
 msgstr[0] "%d timme sedan"
 msgstr[1] "%d timmar sedan"
 
-#: ../src/shell-global.c:849
+#: ../src/shell-global.c:808
 #, c-format
 msgid "%d day ago"
 msgid_plural "%d days ago"
 msgstr[0] "%d dag sedan"
 msgstr[1] "%d dagar sedan"
 
-#: ../src/shell-global.c:852
+#: ../src/shell-global.c:811
 #, c-format
 msgid "%d week ago"
 msgid_plural "%d weeks ago"

src/Makefile-st.am

@@ -0,0 +1,148 @@
+st_cflags =					\
+    -I$(top_srcdir)/src				\
+    -DPREFIX=\""$(prefix)"\"			\
+    -DLIBDIR=\""$(libdir)"\"			\
+    -DG_DISABLE_DEPRECATED			\
+    -DG_LOG_DOMAIN=\"St\"			\
+    -DST_COMPILATION				\
+    -DPACKAGE_DATA_DIR=\"$(pkgdatadir)\"	\
+    $(ST_CFLAGS)				\
+    $(NULL)
+
+st_built_sources =				\
+    st-enum-types.h				\
+    st-enum-types.c				\
+    st-marshal.h				\
+    st-marshal.c
+
+BUILT_SOURCES += $(st_built_sources)
+
+EXTRA_DIST +=					\
+	st/test-theme.css			\
+	st/st-marshal.list			\
+	st/st-enum-types.h.in			\
+	st/st-enum-types.c.in
+
+CLEANFILES += stamp-st-marshal.h stamp-st-enum-types.h
+
+st-marshal.h: stamp-st-marshal.h
+	@true
+stamp-st-marshal.h: Makefile st/st-marshal.list
+	$(AM_V_GEN) $(GLIB_GENMARSHAL)					\
+		--prefix=_st_marshal					\
+		--header						\
+	$(srcdir)/st/st-marshal.list > $@.tmp &&			\
+	(cmp -s $@.tmp st-marshal.h || cp -f $@.tmp st-marshal.h) &&	\
+	rm -f $@.tmp &&							\
+	echo timestamp > $(@F)
+
+st-marshal.c: Makefile st/st-marshal.list
+	$(AM_V_GEN) (echo "#include \"st-marshal.h\"" ;	\
+	 $(GLIB_GENMARSHAL)				\
+		--prefix=_st_marshal			\
+		--body					\
+	 $(srcdir)/st/st-marshal.list ) > $@.tmp &&	\
+	cp -f $@.tmp st-marshal.c &&			\
+	rm -f $@.tmp
+
+st-enum-types.h: stamp-st-enum-types.h Makefile
+	@true
+stamp-st-enum-types.h: $(source_h) st/st-enum-types.h.in
+	$(AM_V_GEN) ( cd $(srcdir) &&					\
+	  $(GLIB_MKENUMS)						\
+	    --template st/st-enum-types.h.in				\
+	  $(st_source_h) ) >> $@.tmp &&					\
+	(cmp -s $@.tmp st-enum-types.h || cp $@.tmp st-enum-types.h) &&	\
+	rm -f $@.tmp &&							\
+	echo timestamp > $(@F)
+
+st-enum-types.c: stamp-st-enum-types.h st/st-enum-types.c.in
+	$(AM_V_GEN) ( cd $(srcdir) &&		\
+	  $(GLIB_MKENUMS)			\
+	    --template st/st-enum-types.c.in	\
+	  $(st_source_h) ) >> $@.tmp &&		\
+	cp $@.tmp $@ &&				\
+	rm -f $@.tmp
+
+# please, keep this sorted alphabetically
+st_source_h =					\
+    st/st-adjustment.h				\
+    st/st-bin.h					\
+    st/st-border-image.h			\
+    st/st-box-layout.h				\
+    st/st-box-layout-child.h			\
+    st/st-button.h				\
+    st/st-clipboard.h				\
+    st/st-entry.h				\
+    st/st-im-text.h				\
+    st/st-label.h				\
+    st/st-private.h				\
+    st/st-scrollable.h				\
+    st/st-scroll-bar.h				\
+    st/st-scroll-view.h				\
+    st/st-subtexture.h				\
+    st/st-table.h				\
+    st/st-table-child.h				\
+    st/st-table-private.h			\
+    st/st-texture-cache.h			\
+    st/st-texture-frame.h			\
+    st/st-theme.h				\
+    st/st-theme-context.h			\
+    st/st-theme-node.h				\
+    st/st-theme-private.h			\
+    st/st-tooltip.h				\
+    st/st-types.h				\
+    st/st-widget.h				\
+    $(NULL)
+
+st_source_private_h =				\
+    st/st-private.h				\
+    st/st-table-private.h			\
+    st/st-theme-private.h
+
+# please, keep this sorted alphabetically
+st_source_c =					\
+    st/st-adjustment.c				\
+    st/st-bin.c					\
+    st/st-border-image.c			\
+    st/st-box-layout.c				\
+    st/st-box-layout-child.c			\
+    st/st-button.c				\
+    st/st-clipboard.c				\
+    st/st-entry.c				\
+    st/st-im-text.c				\
+    st/st-label.c				\
+    st/st-private.c				\
+    st/st-scrollable.c				\
+    st/st-scroll-bar.c				\
+    st/st-scroll-view.c				\
+    st/st-subtexture.c				\
+    st/st-table.c				\
+    st/st-table-child.c				\
+    st/st-texture-cache.c			\
+    st/st-texture-frame.c			\
+    st/st-theme.c				\
+    st/st-theme-context.c			\
+    st/st-theme-node.c				\
+    st/st-tooltip.c				\
+    st/st-widget.c				\
+    $(NULL)
+
+noinst_LTLIBRARIES += libst-1.0.la
+
+libst_1_0_la_LIBADD = $(ST_LIBS)
+libst_1_0_la_SOURCES =				\
+    $(st_source_c)				\
+    $(st_source_private_c)			\
+    $(st_source_h)				\
+    $(st_built_sources)				\
+    $(NULL)
+libst_1_0_la_CPPFLAGS = $(st_cflags)
+libst_1_0_la_LDFLAGS = $(LDADD)
+
+noinst_PROGRAMS += test-theme
+
+test_theme_CPPFLAGS = $(st_cflags)
+test_theme_LDADD = libst-1.0.la
+
+test_theme_SOURCES = st/test-theme.c

src/Makefile.am

@@ -4,6 +4,7 @@ CLEANFILES =
 EXTRA_DIST =
 libexec_PROGRAMS =
 noinst_LTLIBRARIES =
+noinst_PROGRAMS =
 
 .AUTOPARALLEL:
 
@@ -24,6 +25,7 @@ EXTRA_DIST += gnome-shell.in
 
 include Makefile-big.am
 include Makefile-gdmuser.am
+include Makefile-st.am
 include Makefile-tray.am
 
 gnome_shell_cflags =				\
@@ -52,8 +54,6 @@ CLEANFILES += $(SHELL_STAMP_FILES)
 libgnome_shell_la_SOURCES =			\
 	$(shell_built_sources)			\
 	gnome-shell-plugin.c			\
-	shell-alttab.c				\
-	shell-alttab.h				\
 	shell-app-monitor.c			\
 	shell-app-monitor.h			\
 	shell-app-system.c			\
@@ -114,7 +114,7 @@ if BUILD_RECORDER
 libgnome_shell_la_SOURCES += $(shell_recorder_sources)
 non_gir_sources += $(shell_recorder_non_gir_sources)
 
-noinst_PROGRAMS = test-recorder
+noinst_PROGRAMS += test-recorder
 
 test_recorder_CPPFLAGS = $(TEST_SHELL_RECORDER_CFLAGS)
 test_recorder_LDADD = $(TEST_SHELL_RECORDER_LIBS)
@@ -152,23 +152,25 @@ libgnome_shell_la_LIBADD =	\
 	$(MUTTER_PLUGIN_LIBS)	\
         $(LIBGNOMEUI_LIBS)      \
 	libbig-1.0.la		\
+	libst-1.0.la       	\
 	libgdmuser-1.0.la	\
 	libtray.la
 libgnome_shell_la_CPPFLAGS = $(gnome_shell_cflags)
 
 typelibdir = $(pkglibdir)
-typelib_DATA = Shell-0.1.typelib Big-1.0.typelib
+typelib_DATA = Shell-0.1.typelib Big-1.0.typelib St-1.0.typelib
 
-Shell-0.1.gir: $(mutter) $(G_IR_SCANNER) Big-1.0.gir libgnome-shell.la Makefile
+Shell-0.1.gir: $(mutter) $(G_IR_SCANNER) Big-1.0.gir St-1.0.gir libgnome-shell.la Makefile
 	$(AM_V_GEN) $(G_IR_SCANNER)			\
 		--namespace=Shell			\
 		--nsversion=0.1				\
 		--add-include-path=$(MUTTER_LIB_DIR)/mutter/ \
 		--include=Clutter-1.0			\
-		--include=Meta-2.27			\
+		--include=Meta-2.28			\
 		--libtool="$(LIBTOOL)"    \
 		--add-include-path=$(builddir)     \
 		--include=Big-1.0     \
+		--include=St-1.0     \
 		--program=mutter			\
 	        --program-arg=--mutter-plugins=$$(pwd)/libgnome-shell.la \
 		$(addprefix $(srcdir)/,$(libgnome_shell_la_gir_sources)) \
@@ -179,14 +181,14 @@ CLEANFILES += Shell-0.1.gir
 # The dependency on libgnome-shell.la here is because g-ir-compiler opens it
 # (not the fake library, since we've already done the rewriting)
 Shell-0.1.typelib: libgnome-shell.la Shell-0.1.gir Big-1.0.gir
-	$(AM_V_GEN) LD_LIBRARY_PATH=.$${LD_LIBRARY_PATH:+:$$LD_LIBRARY_PATH}	\
+	$(AM_V_GEN) \
 		$(G_IR_COMPILER)						\
 			--includedir=.						\
 			--includedir=$(MUTTER_LIB_DIR)/mutter/			\
 		Shell-0.1.gir -o $@
 CLEANFILES += Shell-0.1.typelib
 
-Big-1.0.gir: $(mutter) $(G_IR_SCANNER) libgnome-shell.la libbig-1.0.la $(srcdir)/big-enum-types.h Makefile
+Big-1.0.gir: $(mutter) $(G_IR_SCANNER) libgnome-shell.la libbig-1.0.la Makefile
 	$(AM_V_GEN) $(G_IR_SCANNER)			\
 		--namespace=Big				\
 		--nsversion=1.0				\
@@ -203,6 +205,28 @@ Big-1.0.gir: $(mutter) $(G_IR_SCANNER) libgnome-shell.la libbig-1.0.la $(srcdir)
 CLEANFILES += Big-1.0.gir
 
 Big-1.0.typelib: libbig-1.0.la Big-1.0.gir
-	$(AM_V_GEN) LD_LIBRARY_PATH=.$${LD_LIBRARY_PATH:+:$$LD_LIBRARY_PATH} \
-		$(G_IR_COMPILER) Big-1.0.gir -o $@
+	$(AM_V_GEN) $(G_IR_COMPILER) Big-1.0.gir -o $@
 CLEANFILES += Big-1.0.typelib
+
+St-1.0.gir: $(mutter) $(G_IR_SCANNER) libgnome-shell.la libst-1.0.la Makefile
+	$(AM_V_GEN) $(G_IR_SCANNER)						\
+	        --namespace=St							\
+	        --nsversion=1.0							\
+	        --include=Clutter-1.0						\
+		--add-include-path=$(builddir)     				\
+	        --libtool="$(LIBTOOL)"						\
+	        --program=mutter						\
+		--program-arg=--mutter-plugins=$$(pwd)/libgnome-shell.la	\
+	        -DST_COMPILATION						\
+	        $(addprefix $(srcdir)/,$(st_source_h))				\
+	        $(addprefix $(srcdir)/,$(st_source_c))				\
+	        $(srcdir)/st-enum-types.h					\
+	        $(st_cflags)							\
+	        -o $@
+CLEANFILES += St-1.0.gir
+
+St-1.0.typelib: St-1.0.gir
+	$(AM_V_GEN) $(G_IR_COMPILER)						\
+		$< -o $@
+
+CLEANFILES += St-1.0.typelib

src/big/rectangle.c

@@ -268,6 +268,52 @@ corner_get(guint         radius,
     return corner;
 }
 
+/* To match the CSS specification, we want the border to look like it was
+ * drawn over the background. But actually drawing the border over the
+ * background will produce slightly bad antialiasing at the edges, so
+ * compute the effective border color instead.
+ */
+#define NORM(x) (t = (x) + 127, (t + (t >> 8)) >> 8)
+#define MULT(c,a) NORM(c*a)
+
+static void
+premultiply (ClutterColor *color)
+{
+    guint t;
+    color->red = MULT (color->red, color->alpha);
+    color->green = MULT (color->green, color->alpha);
+    color->blue = MULT (color->blue, color->alpha);
+}
+
+static void
+unpremultiply (ClutterColor *color)
+{
+    if (color->alpha != 0) {
+        color->red = (color->red * 255 + 127) / color->alpha;
+        color->green = (color->green * 255 + 127) / color->alpha;
+        color->blue = (color->blue * 255 + 127) / color->alpha;
+    }
+}
+
+static void
+over (const ClutterColor *source,
+      const ClutterColor *destination,
+      ClutterColor       *result)
+{
+    guint t;
+    ClutterColor src = *source;
+    ClutterColor dst = *destination;
+    premultiply (&src);
+    premultiply (&dst);
+
+    result->alpha = src.alpha + NORM ((255 - src.alpha) * dst.alpha);
+    result->red   = src.red +   NORM ((255 - src.alpha) * dst.red);
+    result->green = src.green + NORM ((255 - src.alpha) * dst.green);
+    result->blue  = src.blue +  NORM ((255 - src.alpha) * dst.blue);
+
+    unpremultiply (result);
+}
+
 static void
 big_rectangle_update_corners(BigRectangle *rectangle)
 {
@@ -278,6 +324,7 @@ big_rectangle_update_corners(BigRectangle *rectangle)
     if (rectangle->radius != 0) {
         ClutterColor *color;
         ClutterColor *border_color;
+        ClutterColor effective_border;
         guint border_width;
 
         g_object_get(rectangle,
@@ -286,10 +333,12 @@ big_rectangle_update_corners(BigRectangle *rectangle)
                      "color", &color,
                      NULL);
 
+        over (border_color, color, &effective_border);
+
         corner = corner_get(rectangle->radius,
                             color,
                             border_width,
-                            border_color);
+                            &effective_border);
 
         clutter_color_free(border_color);
         clutter_color_free(color);
@@ -329,12 +378,10 @@ big_rectangle_paint(ClutterActor *actor)
 
     rectangle = BIG_RECTANGLE(actor);
 
-    if (rectangle->radius == 0) {
-        /* In that case we are no different than our parent class,
-         * so don't bother */
-        CLUTTER_ACTOR_CLASS(big_rectangle_parent_class)->paint(actor);
-        return;
-    }
+    /* We can't chain up, even when we the radius is 0, because of the different
+     * interpretation of the border/background relationship here than for
+     * ClutterRectangle.
+     */
 
     if (rectangle->corners_dirty)
         big_rectangle_update_corners(rectangle);
@@ -345,6 +392,9 @@ big_rectangle_paint(ClutterActor *actor)
                  "color", &color,
                  NULL);
 
+    if (border_color->alpha == 0 && color->alpha == 0)
+        goto out;
+
     actor_opacity = clutter_actor_get_paint_opacity (actor);
 
     clutter_actor_get_allocation_box(actor, &box);
@@ -358,6 +408,11 @@ big_rectangle_paint(ClutterActor *actor)
 
     radius = rectangle->radius;
 
+    /* Optimization; if the border is transparent, it just looks like part of
+     * the background */
+    if (radius == 0 && border_color->alpha == 0)
+        border_width = 0;
+
     max = MAX(border_width, radius);
 
     if (radius != 0) {
@@ -393,18 +448,22 @@ big_rectangle_paint(ClutterActor *actor)
     }
 
     if (border_width != 0) {
+        ClutterColor effective_border;
+        over (border_color, color, &effective_border);
+
         if (!rectangle->border_material)
             rectangle->border_material = cogl_material_new ();
 
         cogl_color_set_from_4ub(&tmp_color,
-                                border_color->red,
-                                border_color->green,
-                                border_color->blue,
-                                actor_opacity * border_color->alpha / 255);
+                                effective_border.red,
+                                effective_border.green,
+                                effective_border.blue,
+                                actor_opacity * effective_border.alpha / 255);
         cogl_color_premultiply (&tmp_color);
         cogl_material_set_color(rectangle->border_material, &tmp_color);
         cogl_set_source(rectangle->border_material);
 
+        if (radius > 0) { /* skip corners */
             /* NORTH */
             cogl_rectangle(max, 0,
                            width - max, border_width);
@@ -420,6 +479,23 @@ big_rectangle_paint(ClutterActor *actor)
             /* WEST */
             cogl_rectangle(0, max,
                            border_width, height - max);
+        } else { /* include corners */
+            /* NORTH */
+            cogl_rectangle(0, 0,
+                           width, border_width);
+
+            /* EAST */
+            cogl_rectangle(width - border_width, border_width,
+                           width, height - border_width);
+
+            /* SOUTH */
+            cogl_rectangle(0, height - border_width,
+                           width, height);
+
+            /* WEST */
+            cogl_rectangle(0, border_width,
+                           border_width, height - border_width);
+        }
     }
 
     if (!rectangle->background_material)
@@ -455,6 +531,7 @@ big_rectangle_paint(ClutterActor *actor)
     cogl_rectangle(border_width, max,
                    width - border_width, height - max);
 
+out:
     clutter_color_free(border_color);
     clutter_color_free(color);
 }

src/gnome-shell-plugin.c

@@ -192,13 +192,6 @@ gnome_shell_plugin_constructed (GObject *object)
   shell_plugin->gjs_context = gjs_context_new_with_search_path(search_path);
   g_strfreev(search_path);
 
-  shell_plugin->panel_action = XInternAtom (meta_display_get_xdisplay (display),
-                                            "_GNOME_PANEL_ACTION", FALSE);
-  shell_plugin->panel_action_run_dialog = XInternAtom (meta_display_get_xdisplay (display),
-                                                       "_GNOME_PANEL_ACTION_RUN_DIALOG", FALSE);
-  shell_plugin->panel_action_main_menu = XInternAtom (meta_display_get_xdisplay (display),
-                                                      "_GNOME_PANEL_ACTION_MAIN_MENU", FALSE);
-
   if (!gjs_context_eval (shell_plugin->gjs_context,
                          "const Main = imports.ui.main; Main.start();",
                          -1,
@@ -318,48 +311,10 @@ gnome_shell_plugin_kill_effect (MutterPlugin         *plugin,
                          actor, events);
 }
 
-static gboolean
-handle_panel_event (GnomeShellPlugin *shell_plugin,
-                    XEvent           *xev)
-{
-  MutterPlugin *plugin = MUTTER_PLUGIN (shell_plugin);
-  MetaScreen *screen;
-  MetaDisplay *display;
-  XClientMessageEvent *xev_client;
-  Window root;
-
-  screen = mutter_plugin_get_screen (plugin);
-  display = meta_screen_get_display (screen);
-
-  if (xev->type != ClientMessage)
-    return FALSE;
-
-  root = meta_screen_get_xroot (screen);
-
-  xev_client = (XClientMessageEvent*) xev;
-  if (!(xev_client->window == root &&
-        xev_client->message_type == shell_plugin->panel_action &&
-        xev_client->format == 32))
-    return FALSE;
-
-  if (xev_client->data.l[0] == shell_plugin->panel_action_run_dialog)
-    g_signal_emit_by_name (shell_global_get (), "panel-run-dialog",
-                           (guint32) xev_client->data.l[1]);
-  else if (xev_client->data.l[0] == shell_plugin->panel_action_main_menu)
-    g_signal_emit_by_name (shell_global_get (), "panel-main-menu",
-                           (guint32) xev_client->data.l[1]);
-
-  return TRUE;
-}
-
 static gboolean
 gnome_shell_plugin_xevent_filter (MutterPlugin *plugin,
                                   XEvent       *xev)
 {
-  GnomeShellPlugin *shell_plugin = GNOME_SHELL_PLUGIN (plugin);
-
-  if (handle_panel_event (shell_plugin, xev))
-    return TRUE;
   return clutter_x11_handle_event (xev) != CLUTTER_X11_FILTER_CONTINUE;
 }
 

src/metacity-symbols.c

@@ -1,64 +0,0 @@
-/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
-
-#include <mutter-plugin.h>
-
-ClutterActor *
-mutter_plugin_get_overlay_group (MutterPlugin *plugin)
-{
-  return NULL;
-}
-
-ClutterActor *
-mutter_plugin_get_stage (MutterPlugin *plugin)
-{
-  return NULL;
-}
-
-GList *
-mutter_plugin_get_windows (MutterPlugin *plugin)
-{
-  return NULL;
-}
-
-void
-mutter_plugin_query_screen_size (MutterPlugin *plugin,
-                                 int          *width,
-                                 int          *height)
-{
-}
-
-void
-mutter_plugin_set_stage_input_area (MutterPlugin *plugin,
-                                    gint x, gint y, gint width, gint height)
-{
-}
-
-MetaScreen *
-mutter_plugin_get_screen (MutterPlugin *plugin)
-{
-  return NULL;
-}
-
-ClutterActor *
-mutter_plugin_get_window_group (MutterPlugin *plugin)
-{
-  return NULL;
-}
-
-Display *
-meta_display_get_xdisplay (MetaDisplay *display)
-{
-  return NULL;
-}
-
-MetaDisplay *
-meta_screen_get_display (MetaScreen *display)
-{
-  return NULL;
-}
-
-Window
-meta_screen_get_xroot (MetaScreen *display)
-{
-  return None;
-}

src/shell-alttab.c

@@ -1,236 +0,0 @@
-/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
-
-#include "shell-alttab.h"
-#include "shell-global.h"
-#include "shell-wm.h"
-#include <mutter-plugin.h>
-
-/* Our MetaAltTabHandler implementation; ideally we would implement
- * this directly from JavaScript, but for now we can't. So we register
- * this glue class as our MetaAltTabHandler and then when mutter
- * creates one, we pass it on to ShellWM, which emits a signal to hand
- * it off to javascript code, which then connects to the signals on
- * this object.
- */
-
-static void shell_alt_tab_handler_interface_init (MetaAltTabHandlerInterface *handler_iface);
-
-G_DEFINE_TYPE_WITH_CODE (ShellAltTabHandler, shell_alt_tab_handler, G_TYPE_OBJECT,
-                         G_IMPLEMENT_INTERFACE (META_TYPE_ALT_TAB_HANDLER,
-                                                shell_alt_tab_handler_interface_init))
-
-/* Signals */
-enum
-{
-  WINDOW_ADDED,
-  SHOW,
-  DESTROY,
-
-  LAST_SIGNAL
-};
-static guint signals [LAST_SIGNAL] = { 0 };
-
-enum 
-{
-  PROP_SELECTED = 1,
-  PROP_SCREEN,
-  PROP_IMMEDIATE
-};
-
-static void
-shell_alt_tab_handler_init (ShellAltTabHandler *sth)
-{
-  sth->windows = g_ptr_array_new ();
-  sth->selected = -1;
-}
-
-static void
-shell_alt_tab_handler_constructed (GObject *object)
-{
-  ShellGlobal *global = shell_global_get ();
-  ShellWM *wm;
-
-  g_object_get (G_OBJECT (global), "window-manager", &wm, NULL);
-  _shell_wm_begin_alt_tab (wm, SHELL_ALT_TAB_HANDLER (object));
-  g_object_unref (wm);
-}
-
-static void
-shell_alt_tab_handler_set_property (GObject      *object,
-                                    guint         prop_id,
-                                    const GValue *value,
-                                    GParamSpec   *pspec)
-{
-  ShellAltTabHandler *sth = SHELL_ALT_TAB_HANDLER (object);
-
-  switch (prop_id)
-    {
-    case PROP_SCREEN:
-      /* We don't care */
-      break;
-    case PROP_IMMEDIATE:
-      sth->immediate_mode = g_value_get_boolean (value);
-      break;
-    default:
-      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
-      break;
-    }
-}
-
-static void
-shell_alt_tab_handler_get_property (GObject      *object,
-                                    guint         prop_id,
-                                    GValue       *value,
-                                    GParamSpec   *pspec)
-{
-  ShellAltTabHandler *sth = SHELL_ALT_TAB_HANDLER (object);
-
-  switch (prop_id)
-    {
-    case PROP_SELECTED:
-      g_value_set_int (value, sth->selected);
-      break;
-    default:
-      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
-      break;
-    }
-}
-
-static void
-shell_alt_tab_handler_finalize (GObject *object)
-{
-  ShellAltTabHandler *sth = SHELL_ALT_TAB_HANDLER (object);
-
-  g_ptr_array_free (sth->windows, FALSE);
-
-  G_OBJECT_CLASS (shell_alt_tab_handler_parent_class)->finalize (object);
-}
-
-static void
-shell_alt_tab_handler_add_window (MetaAltTabHandler *handler,
-				  MetaWindow        *window)
-{
-  ShellAltTabHandler *sth = SHELL_ALT_TAB_HANDLER (handler);
-
-  g_ptr_array_add (sth->windows, window);
-  g_signal_emit (handler, signals[WINDOW_ADDED], 0,
-                 meta_window_get_compositor_private (window));
-}
-
-static void
-shell_alt_tab_handler_show (MetaAltTabHandler *handler,
-                            MetaWindow        *initial_selection)
-{
-  ShellAltTabHandler *sth = SHELL_ALT_TAB_HANDLER (handler);
-  int i;
-
-  sth->selected = -1;
-  for (i = 0; i < sth->windows->len; i++)
-    {
-      if (sth->windows->pdata[i] == (gpointer)initial_selection)
-        {
-          sth->selected = i;
-          break;
-        }
-    }
-
-  g_signal_emit (handler, signals[SHOW], 0, sth->selected);
-}
-
-static void
-shell_alt_tab_handler_destroy (MetaAltTabHandler *handler)
-{
-  g_signal_emit (handler, signals[DESTROY], 0);
-}
-
-static void
-shell_alt_tab_handler_forward (MetaAltTabHandler *handler)
-{
-  ShellAltTabHandler *sth = SHELL_ALT_TAB_HANDLER (handler);
-
-  if (sth->selected == sth->windows->len - 1)
-    sth->selected = 0;
-  else
-    sth->selected++;
-  g_object_notify (G_OBJECT (handler), "selected");
-}
-
-static void
-shell_alt_tab_handler_backward (MetaAltTabHandler *handler)
-{
-  ShellAltTabHandler *sth = SHELL_ALT_TAB_HANDLER (handler);
-
-  if (sth->selected == 0)
-    sth->selected = sth->windows->len - 1;
-  else
-    sth->selected--;
-  g_object_notify (G_OBJECT (handler), "selected");
-}
-
-static MetaWindow *
-shell_alt_tab_handler_get_selected (MetaAltTabHandler *handler)
-{
-  ShellAltTabHandler *sth = SHELL_ALT_TAB_HANDLER (handler);
-
-  if (sth->selected > -1)
-    return sth->windows->pdata[sth->selected];
-  else
-    return NULL;
-}
-
-static void
-shell_alt_tab_handler_class_init (ShellAltTabHandlerClass *klass)
-{
-  GObjectClass *object_class = G_OBJECT_CLASS (klass);
-
-  object_class->constructed  = shell_alt_tab_handler_constructed;
-  object_class->set_property = shell_alt_tab_handler_set_property;
-  object_class->get_property = shell_alt_tab_handler_get_property;
-  object_class->finalize     = shell_alt_tab_handler_finalize;
-
-  g_object_class_override_property (object_class, PROP_SCREEN, "screen");
-  g_object_class_override_property (object_class, PROP_IMMEDIATE, "immediate");
-  g_object_class_install_property (object_class,
-                                   PROP_SELECTED,
-                                   g_param_spec_int ("selected",
-                                                     "Selected",
-                                                     "Selected window",
-                                                     -1, G_MAXINT, -1,
-                                                     G_PARAM_READABLE));
-
-
-  signals[WINDOW_ADDED] = g_signal_new ("window-added",
-                                        G_TYPE_FROM_CLASS (klass),
-                                        G_SIGNAL_RUN_LAST,
-                                        0,
-                                        NULL, NULL,
-                                        g_cclosure_marshal_VOID__OBJECT,
-                                        G_TYPE_NONE, 1,
-                                        MUTTER_TYPE_COMP_WINDOW);
-  signals[SHOW] = g_signal_new ("show",
-                                G_TYPE_FROM_CLASS (klass),
-                                G_SIGNAL_RUN_LAST,
-                                0,
-                                NULL, NULL,
-                                g_cclosure_marshal_VOID__INT,
-                                G_TYPE_NONE, 1,
-                                G_TYPE_INT);
-  signals[DESTROY] = g_signal_new ("destroy",
-                                   G_TYPE_FROM_CLASS (klass),
-                                   G_SIGNAL_RUN_LAST,
-                                   0,
-                                   NULL, NULL,
-                                   g_cclosure_marshal_VOID__VOID,
-                                   G_TYPE_NONE, 0);
-}
-
-static void
-shell_alt_tab_handler_interface_init (MetaAltTabHandlerInterface *handler_iface)
-{
-  handler_iface->add_window   = shell_alt_tab_handler_add_window;
-  handler_iface->show         = shell_alt_tab_handler_show;
-  handler_iface->destroy      = shell_alt_tab_handler_destroy;
-  handler_iface->forward      = shell_alt_tab_handler_forward;
-  handler_iface->backward     = shell_alt_tab_handler_backward;
-  handler_iface->get_selected = shell_alt_tab_handler_get_selected;
-}

src/shell-alttab.h

@@ -1,34 +0,0 @@
-/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
-
-#ifndef SHELL_ALT_TAB_HANDLER_H
-#define SHELL_ALT_TAB_HANDLER_H
-
-#include <alttabhandler.h>
-
-#define SHELL_TYPE_ALT_TAB_HANDLER            (shell_alt_tab_handler_get_type ())
-#define SHELL_ALT_TAB_HANDLER(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), SHELL_TYPE_ALT_TAB_HANDLER, ShellAltTabHandler))
-#define SHELL_ALT_TAB_HANDLER_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass),  SHELL_TYPE_ALT_TAB_HANDLER, ShellAltTabHandlerClass))
-#define SHELL_IS_ALT_TAB_HANDLER(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), SHELL_ALT_TAB_HANDLER_TYPE))
-#define SHELL_IS_ALT_TAB_HANDLER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass),  SHELL_TYPE_ALT_TAB_HANDLER))
-#define SHELL_ALT_TAB_HANDLER_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj),  SHELL_TYPE_ALT_TAB_HANDLER, ShellAltTabHandlerClass))
-
-typedef struct _ShellAltTabHandler      ShellAltTabHandler;
-typedef struct _ShellAltTabHandlerClass ShellAltTabHandlerClass;
-
-struct _ShellAltTabHandler {
-  GObject parent_instance;
-
-  GPtrArray *windows;
-  int selected;
-  gboolean immediate_mode;
-};
-
-struct _ShellAltTabHandlerClass {
-  GObjectClass parent_class;
-
-};
-
-GType              shell_alt_tab_handler_get_type     (void);
-
-#endif
-

src/shell-app-monitor.c

@@ -1039,6 +1039,7 @@ shell_app_monitor_init (ShellAppMonitor *self)
   path = g_build_filename (shell_config_dir, DATA_FILENAME, NULL);
   g_free (shell_config_dir);
   self->configfile = g_file_new_for_path (path);
+  g_free (path);
   restore_from_file (self);
 
   load_initial_windows (self);

src/shell-app-system.c

@@ -45,6 +45,7 @@ struct _ShellAppSystemPrivate {
 
   GHashTable *app_id_to_app;
 
+  GHashTable *cached_menu_contents;  /* <char *id, GSList<ShellAppInfo*>> */
   GSList *cached_app_menus; /* ShellAppMenuEntry */
 
   GSList *cached_settings; /* ShellAppInfo */
@@ -56,6 +57,7 @@ struct _ShellAppSystemPrivate {
   guint app_change_timeout_id;
 };
 
+static void free_appinfo_gslist (gpointer list);
 static void shell_app_system_finalize (GObject *object);
 static gboolean on_tree_changed (gpointer user_data);
 static void on_tree_changed_cb (GMenuTree *tree, gpointer user_data);
@@ -229,6 +231,9 @@ shell_app_system_init (ShellAppSystem *self)
   priv->app_id_to_app = g_hash_table_new_full (g_str_hash, g_str_equal,
                                                NULL, (GDestroyNotify) shell_app_info_unref);
 
+  priv->cached_menu_contents = g_hash_table_new_full (g_str_hash, g_str_equal,
+                                                      g_free, free_appinfo_gslist);
+
   /* For now, we want to pick up Evince, Nautilus, etc.  We'll
    * handle NODISPLAY semantics at a higher level or investigate them
    * case by case.
@@ -262,6 +267,8 @@ shell_app_system_finalize (GObject *object)
   gmenu_tree_unref (priv->apps_tree);
   gmenu_tree_unref (priv->settings_tree);
 
+  g_hash_table_destroy (priv->cached_menu_contents);
+
   g_hash_table_destroy (priv->app_id_to_app);
 
   g_slist_foreach (priv->cached_app_menus, (GFunc)shell_app_menu_entry_free, NULL);
@@ -279,6 +286,14 @@ shell_app_system_finalize (GObject *object)
   G_OBJECT_CLASS (shell_app_system_parent_class)->finalize(object);
 }
 
+static void
+free_appinfo_gslist (gpointer listp)
+{
+  GSList *list = listp;
+  g_slist_foreach (list, (GFunc) shell_app_info_unref, NULL);
+  g_slist_free (list);
+}
+
 static void
 reread_directories (ShellAppSystem *self, GSList **cache, GMenuTree *tree)
 {
@@ -419,8 +434,12 @@ static gboolean
 on_tree_changed (gpointer user_data)
 {
   ShellAppSystem *self = SHELL_APP_SYSTEM (user_data);
-  g_signal_emit (self, signals[INSTALLED_CHANGED], 0);
+
   reread_menus (self);
+  g_hash_table_remove_all (self->priv->cached_menu_contents);
+
+  g_signal_emit (self, signals[INSTALLED_CHANGED], 0);
+
   self->priv->app_change_timeout_id = 0;
   return FALSE;
 }
@@ -537,26 +556,32 @@ shell_app_menu_entry_get_type (void)
  * shell_app_system_get_applications_for_menu:
  *
  * Traverses a toplevel menu, and returns all items under it.  Nested items
- * are flattened.
+ * are flattened.  This value is computed on initial call and cached thereafter
+ * until the set of installed applications changes.
  *
- * Return value: (transfer container) (element-type ShellAppInfo): List of applications
+ * Return value: (transfer none) (element-type ShellAppInfo): List of applications
  */
 GSList *
-shell_app_system_get_applications_for_menu (ShellAppSystem *monitor,
+shell_app_system_get_applications_for_menu (ShellAppSystem *self,
                                             const char *menu)
 {
-  char *path;
-  GMenuTreeDirectory *menu_entry;
   GSList *apps;
 
+  apps = g_hash_table_lookup (self->priv->cached_menu_contents, menu);
+  if (!apps)
+    {
+      char *path;
+      GMenuTreeDirectory *menu_entry;
       path = g_strdup_printf ("/%s", menu);
-  menu_entry = gmenu_tree_get_directory_from_path (monitor->priv->apps_tree, path);
+      menu_entry = gmenu_tree_get_directory_from_path (self->priv->apps_tree, path);
       g_free (path);
       g_assert (menu_entry != NULL);
 
-  apps = gather_entries_recurse (monitor, NULL, menu_entry);
+      apps = gather_entries_recurse (self, NULL, menu_entry);
+      g_hash_table_insert (self->priv->cached_menu_contents, g_strdup (menu), apps);
 
       gmenu_tree_item_unref (menu_entry);
+    }
 
   return apps;
 }
@@ -984,14 +1009,18 @@ shell_app_info_create_icon_texture (ShellAppInfo *info, float size)
     }
 
   icon = shell_app_info_get_icon (info);
-  if (!icon)
+  if (icon == NULL)
     {
       ret = clutter_texture_new ();
       g_object_set (ret, "opacity", 0, "width", size, "height", size, NULL);
-      return ret;
+    }
+  else
+    {
+      ret = shell_texture_cache_load_gicon (shell_texture_cache_get_default (), icon, (int)size);
+      g_object_unref (icon);
     }
 
-  return shell_texture_cache_load_gicon (shell_texture_cache_get_default (), icon, (int)size);
+  return ret;
 }
 
 /**

src/shell-drawing.c

@@ -148,6 +148,7 @@ shell_draw_clock (ClutterCairoTexture *texture,
 
 void
 shell_draw_box_pointer (ClutterCairoTexture   *texture,
+                        ShellPointerDirection  direction,
                         ClutterColor          *border_color,
                         ClutterColor          *background_color)
 {
@@ -163,9 +164,35 @@ shell_draw_box_pointer (ClutterCairoTexture *texture,
 
   clutter_cairo_set_source_color (cr, border_color);
 
-  cairo_move_to (cr, width, 0);
-  cairo_line_to (cr, 0, floor (height * 0.5));
+  switch (direction)
+    {
+    case SHELL_POINTER_UP:
+      cairo_move_to (cr, 0, height);
+      cairo_line_to (cr, floor (width * 0.5), 0);
       cairo_line_to (cr, width, height);
+      break;
+
+    case SHELL_POINTER_DOWN:
+      cairo_move_to (cr, width, 0);
+      cairo_line_to (cr, floor (width * 0.5), height);
+      cairo_line_to (cr, 0, 0);
+      break;
+
+    case SHELL_POINTER_LEFT:
+      cairo_move_to (cr, width, height);
+      cairo_line_to (cr, 0, floor (height * 0.5));
+      cairo_line_to (cr, width, 0);
+      break;
+
+    case SHELL_POINTER_RIGHT:
+      cairo_move_to (cr, 0, 0);
+      cairo_line_to (cr, width, floor (height * 0.5));
+      cairo_line_to (cr, 0, height);
+      break;
+
+    default:
+      g_assert_not_reached();
+    }
 
   cairo_stroke_preserve (cr);
 
@@ -183,25 +210,20 @@ hook_paint_red_border (ClutterActor  *actor,
   CoglColor color;
   ClutterGeometry geom;
   float width = 2;
-  float x2;
-  float y2;
 
   cogl_color_set_from_4ub (&color, 0xff, 0, 0, 0xc4);
   cogl_set_source_color (&color);
 
   clutter_actor_get_allocation_geometry (actor, &geom);
-  x2 = geom.x + geom.width;
-  y2 = geom.y + geom.height;
 
   /** clockwise order **/
-  cogl_rectangle (geom.x, geom.y,
-                  x2, geom.y + width);
-  cogl_rectangle (x2 - width, geom.y + width,
-                  x2, y2);
-  cogl_rectangle (x2 - width, y2,
-                  geom.x, y2 - width);
-  cogl_rectangle (geom.x + width, y2 - width,
-                  geom.x, geom.y + width);
+  cogl_rectangle (0, 0, geom.width, width);
+  cogl_rectangle (geom.width - width, width,
+                  geom.width, geom.height);
+  cogl_rectangle (0, geom.height,
+                  geom.width - width, geom.height - width);
+  cogl_rectangle (0, geom.height - width,
+                  width, width);
 }
 
 guint

src/shell-drawing.h

@@ -13,7 +13,15 @@ ClutterCairoTexture *shell_create_vertical_gradient (ClutterColor *top,
 ClutterCairoTexture *shell_create_horizontal_gradient (ClutterColor *left,
                                                        ClutterColor *right);
 
+typedef enum {
+  SHELL_POINTER_UP,
+  SHELL_POINTER_DOWN,
+  SHELL_POINTER_LEFT,
+  SHELL_POINTER_RIGHT
+} ShellPointerDirection;
+
 void shell_draw_box_pointer (ClutterCairoTexture   *texture,
+                             ShellPointerDirection  direction,
                              ClutterColor          *border_color,
                              ClutterColor          *background_color);
 

src/shell-global.c

@@ -40,6 +40,7 @@ struct _ShellGlobal {
   
   MutterPlugin *plugin;
   ShellWM *wm;
+  const char *datadir;
   const char *imagedir;
   const char *configdir;
 
@@ -57,6 +58,7 @@ enum {
   PROP_STAGE,
   PROP_WINDOW_GROUP,
   PROP_WINDOW_MANAGER,
+  PROP_DATADIR,
   PROP_IMAGEDIR,
   PROP_CONFIGDIR,
 };
@@ -128,6 +130,9 @@ shell_global_get_property(GObject         *object,
     case PROP_WINDOW_MANAGER:
       g_value_set_object (value, global->wm);
       break;
+    case PROP_DATADIR:
+      g_value_set_string (value, global->datadir);
+      break;
     case PROP_IMAGEDIR:
       g_value_set_string (value, global->imagedir);
       break;
@@ -149,6 +154,7 @@ shell_global_init (ShellGlobal *global)
 
   if (!datadir)
     datadir = GNOME_SHELL_DATADIR;
+  global->datadir = datadir;
 
   /* We make sure imagedir ends with a '/', since the JS won't have
    * access to g_build_filename() and so will end up just
@@ -254,6 +260,13 @@ shell_global_class_init (ShellGlobalClass *klass)
                                                         "Window management interface",
                                                         SHELL_TYPE_WM,
                                                         G_PARAM_READABLE));
+  g_object_class_install_property (gobject_class,
+                                   PROP_DATADIR,
+                                   g_param_spec_string ("datadir",
+                                                        "Data directory",
+                                                        "Directory containing gnome-shell data files",
+                                                        NULL,
+                                                        G_PARAM_READABLE));
   g_object_class_install_property (gobject_class,
                                    PROP_IMAGEDIR,
                                    g_param_spec_string ("imagedir",
@@ -869,3 +882,138 @@ shell_global_create_root_pixmap_actor (ShellGlobal *global)
 
   return clutter_clone_new (global->root_pixmap);
 }
+
+/**
+ * shell_global_get_monitors:
+ * @global: the #ShellGlobal
+ *
+ * Gets a list of the bounding boxes of the active screen's monitors.
+ *
+ * Return value: (transfer full) (element-type GdkRectangle): a list
+ * of monitor bounding boxes.
+ */
+GSList *
+shell_global_get_monitors (ShellGlobal *global)
+{
+  MetaScreen *screen = shell_global_get_screen (global);
+  GSList *monitors = NULL;
+  MetaRectangle rect;
+  int i;
+
+  g_assert (sizeof (MetaRectangle) == sizeof (GdkRectangle) &&
+            G_STRUCT_OFFSET (MetaRectangle, x) == G_STRUCT_OFFSET (GdkRectangle, x) &&
+            G_STRUCT_OFFSET (MetaRectangle, y) == G_STRUCT_OFFSET (GdkRectangle, y) &&
+            G_STRUCT_OFFSET (MetaRectangle, width) == G_STRUCT_OFFSET (GdkRectangle, width) &&
+            G_STRUCT_OFFSET (MetaRectangle, height) == G_STRUCT_OFFSET (GdkRectangle, height));
+
+  for (i = meta_screen_get_n_monitors (screen) - 1; i >= 0; i--)
+    {
+      meta_screen_get_monitor_geometry (screen, i, &rect);
+      monitors = g_slist_prepend (monitors,
+                                  g_boxed_copy (GDK_TYPE_RECTANGLE, &rect));
+    }
+  return monitors;
+}
+
+/**
+ * shell_global_get_primary_monitor:
+ * @global: the #ShellGlobal
+ *
+ * Gets the bounding box of the primary monitor (the one that the
+ * panel is on).
+ *
+ * Return value: the bounding box of the primary monitor
+ */
+GdkRectangle *
+shell_global_get_primary_monitor (ShellGlobal  *global)
+{
+  MetaScreen *screen = shell_global_get_screen (global);
+  MetaRectangle rect;
+
+  g_assert (sizeof (MetaRectangle) == sizeof (GdkRectangle) &&
+            G_STRUCT_OFFSET (MetaRectangle, x) == G_STRUCT_OFFSET (GdkRectangle, x) &&
+            G_STRUCT_OFFSET (MetaRectangle, y) == G_STRUCT_OFFSET (GdkRectangle, y) &&
+            G_STRUCT_OFFSET (MetaRectangle, width) == G_STRUCT_OFFSET (GdkRectangle, width) &&
+            G_STRUCT_OFFSET (MetaRectangle, height) == G_STRUCT_OFFSET (GdkRectangle, height));
+
+  meta_screen_get_monitor_geometry (screen, 0, &rect);
+  return g_boxed_copy (GDK_TYPE_RECTANGLE, &rect);
+}
+
+/**
+ * shell_global_get_focus_monitor:
+ * @global: the #ShellGlobal
+ *
+ * Gets the bounding box of the monitor containing the window that
+ * currently contains the keyboard focus.
+ *
+ * Return value: the bounding box of the focus monitor
+ */
+GdkRectangle *
+shell_global_get_focus_monitor (ShellGlobal  *global)
+{
+  MetaScreen *screen = shell_global_get_screen (global);
+  MetaDisplay *display = meta_screen_get_display (screen);
+  MetaWindow *focus = meta_display_get_focus_window (display);
+  MetaRectangle rect, wrect;
+  int nmonitors, i;
+
+  if (focus)
+    {
+      meta_window_get_outer_rect (focus, &wrect);
+      nmonitors = meta_screen_get_n_monitors (screen);
+
+      /* Find the monitor that the top-left corner of @focus is on. */
+      for (i = 0; i < nmonitors; i++)
+        {
+          meta_screen_get_monitor_geometry (screen, i, &rect);
+
+          if (rect.x < wrect.x && rect.y < wrect.y &&
+              rect.x + rect.width > wrect.x &&
+              rect.y + rect.height > wrect.y)
+            return g_boxed_copy (GDK_TYPE_RECTANGLE, &rect);
+        }
+    }
+
+  meta_screen_get_monitor_geometry (screen, 0, &rect);
+  return g_boxed_copy (GDK_TYPE_RECTANGLE, &rect);
+}
+
+/**
+ * shell_global_get_modifier_keys:
+ * @global: the #ShellGlobal
+ *
+ * Gets the current set of modifier keys that are pressed down;
+ * this is a wrapper around gdk_display_get_pointer() that strips
+ * out any un-declared modifier flags, to make gjs happy; see
+ * https://bugzilla.gnome.org/show_bug.cgi?id=597292.
+ *
+ * Return value: the current modifiers
+ */
+GdkModifierType
+shell_global_get_modifier_keys (ShellGlobal *global)
+{
+  GdkModifierType mods;
+
+  gdk_display_get_pointer (gdk_display_get_default (), NULL, NULL, NULL, &mods);
+  return mods & GDK_MODIFIER_MASK;
+}
+
+/**
+ * shell_get_event_state:
+ * @event: a #ClutterEvent
+ *
+ * Gets the current state of the event (the set of modifier keys that
+ * are pressed down). Thhis is a wrapper around
+ * clutter_event_get_state() that strips out any un-declared modifier
+ * flags, to make gjs happy; see
+ * https://bugzilla.gnome.org/show_bug.cgi?id=597292.
+ *
+ * Return value: the state from the event
+ */
+ClutterModifierType
+shell_get_event_state (ClutterEvent *event)
+{
+  ClutterModifierType state = clutter_event_get_state (event);
+  return state & CLUTTER_MODIFIER_MASK;
+}

src/shell-global.h

@@ -73,6 +73,14 @@ void shell_global_format_time_relative_pretty (ShellGlobal *global, guint delta,
 
 ClutterActor *shell_global_create_root_pixmap_actor (ShellGlobal *global);
 
+GSList       *shell_global_get_monitors        (ShellGlobal  *global);
+GdkRectangle *shell_global_get_primary_monitor (ShellGlobal  *global);
+GdkRectangle *shell_global_get_focus_monitor   (ShellGlobal  *global);
+
+GdkModifierType shell_global_get_modifier_keys (ShellGlobal *global);
+
+ClutterModifierType shell_get_event_state (ClutterEvent *event);
+
 G_END_DECLS
 
 #endif /* __SHELL_GLOBAL_H__ */

src/shell-marshal.list

@@ -2,3 +2,4 @@ VOID:INT,INT,INT
 VOID:OBJECT,INT,INT,INT,INT
 VOID:BOXED
 VOID:BOXED,OBJECT
+VOID:STRING,OBJECT,BOOLEAN

src/shell-menu.c

@@ -15,6 +15,7 @@ G_DEFINE_TYPE(ShellMenu, shell_menu, BIG_TYPE_BOX);
 struct _ShellMenuPrivate {
   gboolean popped_up;
   gboolean have_grab;
+  guint activating_button;
 
   gboolean released_on_source;
   ClutterActor *source_actor;
@@ -117,9 +118,15 @@ shell_menu_button_release_event (ClutterActor       *actor,
 {
   ShellMenu *box = SHELL_MENU (actor);
 
-  if (event->button != 1)
+  /* Until the user releases the button that brought up the menu, we just
+   * ignore other button press/releass.
+   * See https://bugzilla.gnome.org/show_bug.cgi?id=596371
+   */
+  if (box->priv->activating_button > 0 && box->priv->activating_button != event->button)
     return FALSE;
 
+  box->priv->activating_button = 0;
+
   if (box->priv->source_actor && !box->priv->released_on_source)
     {
       if (box->priv->source_actor == event->source ||
@@ -134,13 +141,8 @@ shell_menu_button_release_event (ClutterActor       *actor,
 
   shell_menu_popdown_nosignal (box);
 
-  if (!container_contains (CLUTTER_CONTAINER (box), event->source))
-    {
-      g_signal_emit (G_OBJECT (box), shell_menu_signals[CANCELLED], 0);
-      return FALSE;
-    }
-
-  if (box->priv->selected == NULL)
+  if (!container_contains (CLUTTER_CONTAINER (box), event->source) ||
+      box->priv->selected == NULL)
     {
       g_signal_emit (G_OBJECT (box), shell_menu_signals[CANCELLED], 0);
       return FALSE;
@@ -158,6 +160,7 @@ shell_menu_popup (ShellMenu         *box,
 {
   if (box->priv->popped_up)
     return;
+  box->priv->activating_button = button;
   box->priv->popped_up = TRUE;
   box->priv->have_grab = TRUE;
   box->priv->released_on_source = FALSE;

src/shell-overflow-list.c

@@ -24,6 +24,23 @@ struct _ShellOverflowListPrivate {
   guint displayed_count;
 };
 
+static GList *
+get_visible_children (ShellOverflowList *self)
+{
+  GList *children, *iter, *next;
+
+  children = clutter_container_get_children (CLUTTER_CONTAINER (self));
+  for (iter = children; iter; iter = next)
+    {
+      ClutterActor *actor = iter->data;
+      next = iter->next;
+
+      if (!CLUTTER_ACTOR_IS_VISIBLE (actor))
+        children = g_list_delete_link (children, iter);
+    }
+  return children;
+}
+
 static void
 recalc_displayed_count (ShellOverflowList *self)
 {
@@ -32,7 +49,7 @@ recalc_displayed_count (ShellOverflowList *self)
   int displayed_count;
   int page, n_pages;
 
-  children = clutter_container_get_children (CLUTTER_CONTAINER (self));
+  children = get_visible_children (self);
   n_children = g_list_length (children);
   g_list_free (children);
 
@@ -136,7 +153,7 @@ shell_overflow_list_allocate (ClutterActor           *actor,
   curheight = 0;
   avail_height = box->y2 - box->y1;
 
-  children = clutter_container_get_children (CLUTTER_CONTAINER (self));
+  children = get_visible_children (self);
   n_children = g_list_length (children);
 
   n_fits = 0;
@@ -189,7 +206,7 @@ shell_overflow_list_paint (ClutterActor *actor)
   GList *children, *iter;
   int i;
 
-  children = clutter_container_get_children (CLUTTER_CONTAINER (self));
+  children = get_visible_children (self);
 
   if (children == NULL)
     return;
@@ -232,7 +249,7 @@ shell_overflow_list_get_preferred_height (ClutterActor *actor,
   if (natural_height_p)
     {
       int n_children;
-      children = clutter_container_get_children (CLUTTER_CONTAINER (self));
+      children = get_visible_children (self);
       n_children = g_list_length (children);
       if (n_children == 0)
         *natural_height_p = 0;
@@ -254,7 +271,7 @@ shell_overflow_list_get_preferred_width (ClutterActor *actor,
   GList *iter;
   GList *children;
 
-  children = clutter_container_get_children (CLUTTER_CONTAINER (self));
+  children = get_visible_children (self);
 
   for (iter = children; iter; iter = iter->next)
     {
@@ -374,7 +391,7 @@ shell_overflow_list_get_displayed_actor (ShellOverflowList *self,
 {
   GList *children, *iter;
 
-  children = clutter_container_get_children (CLUTTER_CONTAINER (self));
+  children = get_visible_children (self);
 
   if (children == NULL)
     return NULL;
@@ -405,7 +422,7 @@ shell_overflow_list_get_actor_index (ShellOverflowList *self,
   int i;
   int result;
 
-  children = clutter_container_get_children (CLUTTER_CONTAINER (self));
+  children = get_visible_children (self);
 
   if (children == NULL)
     return -1;

src/shell-panel-window.c

@@ -1,240 +0,0 @@
-#include "shell-panel-window.h"
-
-#include <gdk/gdkx.h>
-#include <X11/Xlib.h>
-
-#define PANEL_HEIGHT 25
-
-enum {
-   PROP_0,
-
-};
-
-static void shell_panel_window_finalize (GObject *object);
-static void shell_panel_window_size_request (GtkWidget *self, GtkRequisition *req);
-static void shell_panel_window_size_allocate (GtkWidget *self, GtkAllocation *allocation);
-static void shell_panel_window_realize (GtkWidget *self);
-static void shell_panel_window_show (GtkWidget *self);
-static void set_strut (ShellPanelWindow *self);
-static void on_workarea_changed (ShellPanelWindow *self);
-static void handle_new_workarea (ShellPanelWindow *self);
-static GdkFilterReturn filter_func (GdkXEvent *xevent,
-				    GdkEvent *event,
-				    gpointer data);
-
-G_DEFINE_TYPE(ShellPanelWindow, shell_panel_window, GTK_TYPE_WINDOW);
-
-struct ShellPanelWindowPrivate {
-  GtkAllocation workarea;
-  guint width;
-  guint height;
-  Atom workarea_atom;
-};
-
-static void
-shell_panel_window_class_init(ShellPanelWindowClass *klass)
-{
-    GObjectClass *gobject_class = (GObjectClass *)klass;
-    GtkWidgetClass *widget_class = (GtkWidgetClass *)klass;
-
-    gobject_class->finalize = shell_panel_window_finalize;
-    
-    widget_class->realize = shell_panel_window_realize;
-    widget_class->size_request = shell_panel_window_size_request;    
-    widget_class->size_allocate = shell_panel_window_size_allocate;
-    widget_class->show = shell_panel_window_show;
-}
-
-static void shell_panel_window_init (ShellPanelWindow *self)
-{
-  self->priv = g_new0 (ShellPanelWindowPrivate, 1);
-
-  self->priv->workarea_atom = gdk_x11_get_xatom_by_name_for_display (gdk_display_get_default (), "_NET_WORKAREA");
-  
-  gtk_window_set_type_hint (GTK_WINDOW (self), GDK_WINDOW_TYPE_HINT_DOCK);
-  gtk_window_set_focus_on_map (GTK_WINDOW (self), FALSE);
-  gdk_window_add_filter (NULL, filter_func, self);
-}
-
-static void shell_panel_window_finalize (GObject *object)
-{
-    ShellPanelWindow *self = (ShellPanelWindow*)object;
-
-    g_free (self->priv);
-    g_signal_handlers_destroy(object);
-    G_OBJECT_CLASS (shell_panel_window_parent_class)->finalize(object);
-}
-
-ShellPanelWindow* shell_panel_window_new(void) {
-    return (ShellPanelWindow*) g_object_new(SHELL_TYPE_PANEL_WINDOW, 
-        "type", GTK_WINDOW_TOPLEVEL, NULL);
-}
-
-static void
-set_strut (ShellPanelWindow *self)
-{
-  long *buf;
-  int strut_size;
-
-  strut_size = GTK_WIDGET (self)->allocation.height;
-
-  buf = g_new0 (long, 4);
-  buf[0] = 0; /* left */
-  buf[1] = 0; /* right */
-  buf[2] = 0; /* top */
-  buf[3] = strut_size; /* bottom */
-  gdk_property_change (GTK_WIDGET (self)->window, gdk_atom_intern_static_string ("_NET_WM_STRUT"),
-		       gdk_atom_intern_static_string ("CARDINAL"), 32,
-		       GDK_PROP_MODE_REPLACE,
-		       (guchar*) buf, 4);
-  g_free (buf);
-}
-
-static void
-shell_panel_window_size_request (GtkWidget *widget, GtkRequisition *requisition)
-{
-  ShellPanelWindow *self = SHELL_PANEL_WINDOW (widget);  
-  GTK_WIDGET_CLASS (shell_panel_window_parent_class)->size_request(widget, requisition);  
-  requisition->width = self->priv->width;
-  requisition->height = PANEL_HEIGHT; 
-}
-
-static void
-shell_panel_window_size_allocate (GtkWidget *widget, GtkAllocation *allocation)
-{
-  ShellPanelWindow *self = SHELL_PANEL_WINDOW (widget);
-  GTK_WIDGET_CLASS (shell_panel_window_parent_class)->size_allocate(widget, allocation);
-  if (GTK_WIDGET_REALIZED (self))
-    set_strut (self);
-}
-
-static void
-shell_panel_window_realize (GtkWidget *widget)
-{
-  ShellPanelWindow *self = SHELL_PANEL_WINDOW (widget);
-  GTK_WIDGET_CLASS (shell_panel_window_parent_class)->realize(widget);
-  set_strut (self);
-}
-
-static void
-shell_panel_window_show (GtkWidget *widget)
-{
-  ShellPanelWindow *self = SHELL_PANEL_WINDOW (widget);
-  on_workarea_changed (self);
-  GTK_WIDGET_CLASS (shell_panel_window_parent_class)->show(widget);
-}
-
-static void
-handle_new_workarea (ShellPanelWindow *self)
-{
-  GtkRequisition requisition;
-  int x, y;
-  int width;
-  int height;
-  int x_target, y_target;
-
-  gtk_widget_size_request (GTK_WIDGET (self), &requisition);
-
-  /* If we don't have a workarea, just use monitor */
-  if (self->priv->workarea.width == 0) 
-    {
-      int monitor;
-      GdkRectangle monitor_geometry;      
-      
-      monitor = gdk_screen_get_monitor_at_point (gdk_screen_get_default (),
-                                                 0, 0);
-      gdk_screen_get_monitor_geometry (gdk_screen_get_default (),
-                                       monitor, &monitor_geometry);      
-      x = monitor_geometry.x;
-      y = monitor_geometry.y;
-      width = monitor_geometry.width;
-      height = monitor_geometry.height;
-    }
-  else
-    {
-      x = self->priv->workarea.x;
-      y = self->priv->workarea.y;
-      width = self->priv->workarea.width;
-      height = self->priv->workarea.height;
-    }
-  
-  x_target = x;
-  y_target = y + height - requisition.height;
-
-  self->priv->width = width;
-  self->priv->height = height;
-  gtk_widget_set_size_request (GTK_WIDGET (self), width - x_target, PANEL_HEIGHT);
-  gtk_window_move (GTK_WINDOW (self), x_target, y_target);
-}
-
-static void
-on_workarea_changed (ShellPanelWindow *self)
-{
-  gulong bytes_after, nitems;
-  Atom type;
-  gint format;
-  guchar *data;
-  long *data32;
-  Atom workarea = gdk_x11_get_xatom_by_name_for_display (gdk_display_get_default (), "_NET_WORKAREA");
-
-  XGetWindowProperty (GDK_DISPLAY(), GDK_ROOT_WINDOW(),
-		      workarea,
-		      0, 4, FALSE, workarea,
-		      &type, &format, &nitems, &bytes_after, &data);
-  if ((format == 32) && (nitems == 4) && (bytes_after == 0))
-    {
-      int x, y, width, height;
-      data32 = (long*) data;
-      x = data32[0];
-      y = data32[1];
-      width = data32[2];
-      height = data32[3];
-      if (x == self->priv->workarea.x && y == self->priv->workarea.y 
-          && width == self->priv->workarea.width 
-          && height == self->priv->workarea.height)
-        return;
-
-      self->priv->workarea.x = x;
-      self->priv->workarea.y = y;
-      self->priv->workarea.width = width;
-      self->priv->workarea.height = height;
-
-      handle_new_workarea (self);
-    }
-  else if (nitems == 0)
-    {
-      /* We have no workarea set; assume there are no other panels at this time */
-      self->priv->workarea.x = self->priv->workarea.y = 0;
-      self->priv->workarea.width = self->priv->workarea.height = 0;
-      handle_new_workarea (self);
-    }
-  else
-    {
-      g_printerr ("unexpected return from XGetWindowProperty: %d %ld %ld\n",
-          format, nitems, bytes_after);
-    }
-}
-
-static GdkFilterReturn
-filter_func (GdkXEvent *gdk_xevent,
-	     GdkEvent *event,
-	     gpointer data)
-{
-  ShellPanelWindow *self = SHELL_PANEL_WINDOW (data);
-  GdkFilterReturn ret = GDK_FILTER_CONTINUE;
-  XEvent *xevent = (XEvent *) event;
-
-  switch (xevent->type) 
-  {
-  case PropertyNotify:
-    {
-      if (xevent->xproperty.atom != self->priv->workarea_atom)
-	break;
-      on_workarea_changed (self);
-    }
-    break;
-  default:
-    break;
-  }
-  return ret;
-}

src/shell-panel-window.h

@@ -1,35 +0,0 @@
-#ifndef __SHELL_PANEL_WINDOW_H__
-#define __SHELL_PANEL_WINDOW_H__
-
-#include <gtk/gtk.h>
-
-#define SHELL_TYPE_PANEL_WINDOW                 (shell_panel_window_get_type ())
-#define SHELL_PANEL_WINDOW(obj)                 (G_TYPE_CHECK_INSTANCE_CAST ((obj), SHELL_TYPE_PANEL_WINDOW, ShellPanelWindow))
-#define SHELL_PANEL_WINDOW_CLASS(klass)         (G_TYPE_CHECK_CLASS_CAST ((klass), SHELL_TYPE_PANEL_WINDOW, ShellPanelWindowClass))
-#define SHELL_IS_PANEL_WINDOW(obj)              (G_TYPE_CHECK_INSTANCE_TYPE ((obj), SHELL_TYPE_PANEL_WINDOW))
-#define SHELL_IS_PANEL_WINDOW_CLASS(klass)      (G_TYPE_CHECK_CLASS_TYPE ((klass), SHELL_TYPE_PANEL_WINDOW))
-#define SHELL_PANEL_WINDOW_GET_CLASS(obj)       (G_TYPE_INSTANCE_GET_CLASS ((obj), SHELL_TYPE_PANEL_WINDOW, ShellPanelWindowClass))
-
-typedef struct _ShellPanelWindow ShellPanelWindow;
-typedef struct _ShellPanelWindowClass ShellPanelWindowClass;
-
-typedef struct ShellPanelWindowPrivate ShellPanelWindowPrivate;
-
-struct _ShellPanelWindow
-{
-    GtkWindow parent;
-
-    ShellPanelWindowPrivate *priv;
-};
-
-struct _ShellPanelWindowClass
-{
-    GtkWindowClass parent_class;
-
-};
-
-GType shell_panel_window_get_type (void) G_GNUC_CONST;
-ShellPanelWindow* shell_panel_window_new(void);
-
-
-#endif /* __SHELL_PANEL_WINDOW_H__ */

src/shell-texture-cache.c

@@ -20,7 +20,13 @@ typedef struct
 
 struct _ShellTextureCachePrivate
 {
+  /* Things that were loaded with a cache policy != NONE */
   GHashTable *keyed_cache; /* CacheKey -> CoglTexture* */
+  /* Presently this is used to de-duplicate requests for GIcons,
+   * it could in theory be extended to async URL loading and other
+   * cases too.
+   */
+  GHashTable *outstanding_requests; /* CacheKey -> AsyncTextureLoadData * */
   GnomeDesktopThumbnailFactory *thumbnails;
 };
 
@@ -130,6 +136,8 @@ shell_texture_cache_init (ShellTextureCache *self)
   self->priv = g_new0 (ShellTextureCachePrivate, 1);
   self->priv->keyed_cache = g_hash_table_new_full (cache_key_hash, cache_key_equal,
                                                    cache_key_destroy, cogl_handle_unref);
+  self->priv->outstanding_requests = g_hash_table_new_full (cache_key_hash, cache_key_equal,
+                                                            cache_key_destroy, NULL);
   self->priv->thumbnails = gnome_desktop_thumbnail_factory_new (GNOME_DESKTOP_THUMBNAIL_SIZE_NORMAL);
 }
 
@@ -427,7 +435,10 @@ impl_load_thumbnail (ShellTextureCache *cache,
   existing_thumbnail = gnome_desktop_thumbnail_factory_lookup (thumbnail_factory, uri, mtime);
 
   if (existing_thumbnail != NULL)
+    {
       pixbuf = gdk_pixbuf_new_from_file_at_size (existing_thumbnail, size, size, error);
+      g_free (existing_thumbnail);
+    }
   else if (gnome_desktop_thumbnail_factory_has_valid_failed_thumbnail (thumbnail_factory, uri, mtime))
     g_set_error (error, G_IO_ERROR, G_IO_ERROR_FAILED, "Has failed thumbnail");
   else if (gnome_desktop_thumbnail_factory_can_thumbnail (thumbnail_factory, uri, mime_type, mtime))
@@ -644,7 +655,7 @@ typedef struct {
   GtkIconInfo *icon_info;
   guint width;
   guint height;
-  ClutterTexture *texture;
+  GSList *textures;
 } AsyncTextureLoadData;
 
 static CoglHandle
@@ -703,15 +714,31 @@ on_pixbuf_loaded (GObject      *source,
                   GAsyncResult *result,
                   gpointer      user_data)
 {
+  GSList *iter;
   ShellTextureCache *cache;
   AsyncTextureLoadData *data;
   GdkPixbuf *pixbuf;
   GError *error = NULL;
-  CoglHandle texdata;
-  CacheKey *key;
+  CoglHandle texdata = NULL;
+  CacheKey key;
 
   data = user_data;
   cache = SHELL_TEXTURE_CACHE (source);
+
+  memset (&key, 0, sizeof(key));
+  key.policy = data->policy;
+  if (data->icon)
+    key.icon = data->icon;
+  else if (data->recent_info && data->thumbnail)
+    key.thumbnail_uri = (char*)gtk_recent_info_get_uri (data->recent_info);
+  else if (data->thumbnail)
+    key.thumbnail_uri = (char*)data->uri;
+  else if (data->uri)
+    key.uri = data->uri;
+  key.size = data->width;
+
+  g_hash_table_remove (cache->priv->outstanding_requests, &key);
+
   pixbuf = load_pixbuf_async_finish (cache, result, &error);
   if (pixbuf == NULL)
     pixbuf = load_pixbuf_fallback(data);
@@ -726,29 +753,24 @@ on_pixbuf_loaded (GObject      *source,
     {
       gpointer orig_key, value;
 
-      key = g_new0 (CacheKey, 1);
-      key->policy = data->policy;
-      if (data->icon)
-        key->icon = g_object_ref (data->icon);
-      else if (data->recent_info && data->thumbnail)
-        key->thumbnail_uri = g_strdup (gtk_recent_info_get_uri (data->recent_info));
-      else if (data->thumbnail)
-        key->thumbnail_uri = g_strdup (data->uri);
-      else if (data->uri)
-        key->uri = g_strdup (data->uri);
-      key->size = data->width;
-
-      if (!g_hash_table_lookup_extended (cache->priv->keyed_cache, key,
+      if (!g_hash_table_lookup_extended (cache->priv->keyed_cache, &key,
                                          &orig_key, &value))
-        g_hash_table_insert (cache->priv->keyed_cache, key,
+        {
+          cogl_handle_ref (texdata);
+          g_hash_table_insert (cache->priv->keyed_cache, cache_key_dup (&key),
                                texdata);
-      else
-        cache_key_destroy (key);
+        }
     }
 
-  set_texture_cogl_texture (data->texture, texdata);
+  for (iter = data->textures; iter; iter = iter->next)
+    {
+      ClutterTexture *texture = iter->data;
+      set_texture_cogl_texture (texture, texdata);
+    }
 
 out:
+  if (texdata)
+    cogl_handle_unref (texdata);
   if (data->icon)
     {
       gtk_icon_info_free (data->icon_info);
@@ -764,7 +786,11 @@ out:
 
   /* Alternatively we could weakref and just do nothing if the texture
      is destroyed */
-  g_object_unref (data->texture);
+  for (iter = data->textures; iter; iter = iter->next)
+    {
+      ClutterTexture *texture = iter->data;
+      g_object_unref (texture);
+    }
 
   g_clear_error (&error);
   g_free (data);
@@ -872,6 +898,59 @@ shell_texture_cache_bind_pixbuf_property (ShellTextureCache *cache,
   return CLUTTER_ACTOR(texture);
 }
 
+/**
+ * create_texture_and_ensure_request:
+ * @cache:
+ * @key: A filled in #CacheKey
+ * @request: (out): If no request is outstanding, one will be created and returned here
+ * @texture: (out): A new texture, also added to the request
+ *
+ * Check for any outstanding load for the data represented by @key.  If there
+ * is already a request pending, append it to that request to avoid loading
+ * the data multiple times.
+ *
+ * Returns: %TRUE iff there is already a request pending
+ */
+static gboolean
+create_texture_and_ensure_request (ShellTextureCache     *cache,
+                                   CacheKey              *key,
+                                   AsyncTextureLoadData **request,
+                                   ClutterActor         **texture)
+{
+  CoglHandle texdata;
+  AsyncTextureLoadData *pending;
+  gboolean had_pending;
+
+  *texture = (ClutterActor *) create_default_texture (cache);
+  clutter_actor_set_size (*texture, key->size, key->size);
+
+  texdata = g_hash_table_lookup (cache->priv->keyed_cache, key);
+
+  if (texdata != NULL)
+    {
+      /* We had this cached already, just set the texture and we're done. */
+      set_texture_cogl_texture (CLUTTER_TEXTURE (*texture), texdata);
+      return TRUE;
+    }
+
+  pending = g_hash_table_lookup (cache->priv->outstanding_requests, key);
+  had_pending = pending != NULL;
+
+  if (pending == NULL)
+    {
+      /* Not cached and no pending request, create it */
+      *request = g_new0 (AsyncTextureLoadData, 1);
+      g_hash_table_insert (cache->priv->outstanding_requests, cache_key_dup (key), *request);
+    }
+  else
+   *request = pending;
+
+  /* Regardless of whether there was a pending request, prepend our texture here. */
+  (*request)->textures = g_slist_prepend ((*request)->textures, g_object_ref (*texture));
+
+  return had_pending;
+}
+
 /**
  * shell_texture_cache_load_gicon:
  *
@@ -885,22 +964,18 @@ shell_texture_cache_load_gicon (ShellTextureCache *cache,
                                 GIcon             *icon,
                                 gint               size)
 {
-  ClutterTexture *texture;
-  CoglHandle texdata;
+  AsyncTextureLoadData *request;
+  ClutterActor *texture;
   CacheKey key;
-
-  texture = create_default_texture (cache);
-  clutter_actor_set_size (CLUTTER_ACTOR (texture), size, size);
+  GtkIconTheme *theme;
+  GtkIconInfo *info;
 
   memset (&key, 0, sizeof(key));
   key.icon = icon;
   key.size = size;
-  texdata = g_hash_table_lookup (cache->priv->keyed_cache, &key);
 
-  if (texdata == NULL)
-    {
-      GtkIconTheme *theme;
-      GtkIconInfo *info;
+  if (create_texture_and_ensure_request (cache, &key, &request, &texture))
+    return texture;
 
   /* Do theme lookups in the main thread to avoid thread-unsafety */
   theme = gtk_icon_theme_get_default ();
@@ -908,21 +983,24 @@ shell_texture_cache_load_gicon (ShellTextureCache *cache,
   info = gtk_icon_theme_lookup_by_gicon (theme, icon, size, GTK_ICON_LOOKUP_USE_BUILTIN);
   if (info != NULL)
     {
-          AsyncTextureLoadData *data;
-          data = g_new0 (AsyncTextureLoadData, 1);
       /* hardcoded here for now; we should actually blow this away on
        * icon theme changes probably */
-          data->policy = SHELL_TEXTURE_CACHE_POLICY_FOREVER;
-          data->icon = g_object_ref (icon);
-          data->icon_info = info;
-          data->texture = g_object_ref (texture);
-          data->width = data->height = size;
-          load_icon_pixbuf_async (cache, icon, info, size, NULL, on_pixbuf_loaded, data);
-        }
+      request->policy = SHELL_TEXTURE_CACHE_POLICY_FOREVER;
+      request->icon = g_object_ref (icon);
+      request->icon_info = info;
+      request->width = request->height = size;
+
+      load_icon_pixbuf_async (cache, icon, info, size, NULL, on_pixbuf_loaded, request);
     }
   else
     {
-      set_texture_cogl_texture (texture, texdata);
+      /* Blah; we failed to find the icon, but we've added our texture to the outstanding
+       * requests.  In that case, just undo what create_texture_lookup_status did.
+       */
+       g_slist_foreach (request->textures, (GFunc) g_object_unref, NULL);
+       g_slist_free (request->textures);
+       g_free (request);
+       g_hash_table_remove (cache->priv->outstanding_requests, &key);
     }
 
   return CLUTTER_ACTOR (texture);
@@ -983,7 +1061,7 @@ shell_texture_cache_load_uri_async (ShellTextureCache *cache,
   data->uri = g_strdup (uri);
   data->width = available_width;
   data->height = available_height;
-  data->texture = g_object_ref (texture);
+  data->textures = g_slist_prepend (data->textures, g_object_ref (texture));
   load_uri_pixbuf_async (cache, uri, available_width, available_height, NULL, on_pixbuf_loaded, data);
 
   return CLUTTER_ACTOR (texture);
@@ -1106,7 +1184,7 @@ shell_texture_cache_load_thumbnail (ShellTextureCache *cache,
       data->thumbnail = TRUE;
       data->width = size;
       data->height = size;
-      data->texture = g_object_ref (texture);
+      data->textures = g_slist_prepend (data->textures, g_object_ref (texture));
       load_thumbnail_async (cache, uri, mimetype, size, NULL, on_pixbuf_loaded, data);
     }
   else
@@ -1182,7 +1260,7 @@ shell_texture_cache_load_recent_thumbnail (ShellTextureCache *cache,
       data->recent_info = gtk_recent_info_ref (info);
       data->width = size;
       data->height = size;
-      data->texture = g_object_ref (texture);
+      data->textures = g_slist_prepend (data->textures, g_object_ref (texture));
       load_recent_thumbnail_async (cache, info, size, NULL, on_pixbuf_loaded, data);
     }
   else

src/shell-wm.c

@@ -1,9 +1,13 @@
 /* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
 
+#include <string.h>
+
 #include "shell-wm.h"
 #include "shell-global.h"
 #include "shell-marshal.h"
 
+#include <keybindings.h>
+
 struct _ShellWM {
   GObject parent;
 
@@ -27,7 +31,7 @@ enum
   SWITCH_WORKSPACE,
   KILL_SWITCH_WORKSPACE,
 
-  BEGIN_ALT_TAB,
+  KEYBINDING,
 
   LAST_SIGNAL
 };
@@ -42,7 +46,6 @@ static guint shell_wm_signals [LAST_SIGNAL] = { 0 };
 static void
 shell_wm_init (ShellWM *wm)
 {
-  meta_alt_tab_handler_register (SHELL_TYPE_ALT_TAB_HANDLER);
 }
 
 static void
@@ -169,15 +172,32 @@ shell_wm_class_init (ShellWMClass *klass)
 		  NULL, NULL,
 		  g_cclosure_marshal_VOID__VOID,
 		  G_TYPE_NONE, 0);
-  shell_wm_signals[BEGIN_ALT_TAB] =
-    g_signal_new ("begin-alt-tab",
+
+  /**
+   * ShellWM::keybinding:
+   * @shellwm: the #ShellWM
+   * @binding: the keybinding name
+   * @window: for window keybindings, the #MetaWindow
+   * @backwards: for "reversible" keybindings, whether or not
+   * the backwards (Shifted) variant was invoked
+   *
+   * Emitted when a keybinding captured via
+   * shell_wm_takeover_keybinding() is invoked. The keybinding name
+   * (which has underscores, not hyphens) is also included as the
+   * detail of the signal name, so you can connect just specific
+   * keybindings.
+   */
+  shell_wm_signals[KEYBINDING] =
+    g_signal_new ("keybinding",
 		  G_TYPE_FROM_CLASS (klass),
-		  G_SIGNAL_RUN_LAST,
+		  G_SIGNAL_RUN_LAST | G_SIGNAL_DETAILED,
 		  0,
 		  NULL, NULL,
-		  g_cclosure_marshal_VOID__OBJECT,
-		  G_TYPE_NONE, 1,
-                  META_TYPE_ALT_TAB_HANDLER);
+		  _shell_marshal_VOID__STRING_OBJECT_BOOLEAN,
+		  G_TYPE_NONE, 3,
+                  G_TYPE_STRING,
+                  META_TYPE_WINDOW,
+                  G_TYPE_BOOLEAN);
 }
 
 void
@@ -391,14 +411,6 @@ _shell_wm_destroy (ShellWM      *wm,
   g_signal_emit (wm, shell_wm_signals[DESTROY], 0, actor);
 }
 
-/* Called from shell-alttab.c */
-void
-_shell_wm_begin_alt_tab (ShellWM              *wm,
-                         ShellAltTabHandler   *handler)
-{
-  g_signal_emit (wm, shell_wm_signals[BEGIN_ALT_TAB], 0, handler);
-}
-
 /**
  * shell_wm_new:
  * @plugin: the #MutterPlugin
@@ -417,3 +429,37 @@ shell_wm_new (MutterPlugin *plugin)
 
   return wm;
 }
+
+static void
+shell_wm_key_handler (MetaDisplay    *display,
+                      MetaScreen     *screen,
+                      MetaWindow     *window,
+                      XEvent         *event,
+                      MetaKeyBinding *binding,
+                      gpointer        data)
+{
+  ShellWM *wm = data;
+  gboolean backwards = (event->xkey.state & ShiftMask);
+
+  g_signal_emit (wm, shell_wm_signals[KEYBINDING],
+                 g_quark_from_string (binding->name),
+                 binding->name, window, backwards);
+}
+
+/**
+ * shell_wm_takeover_keybinding:
+ * @wm: the #ShellWM
+ * @binding_name: a mutter keybinding name
+ *
+ * Tells mutter to forward keypresses for @binding_name to the shell
+ * rather than processing them internally. This will cause a
+ * #ShellWM::keybinding signal to be emitted when that key is pressed.
+ */
+void
+shell_wm_takeover_keybinding (ShellWM      *wm,
+                              const char   *binding_name)
+{
+  meta_keybindings_set_custom_handler (binding_name,
+                                       shell_wm_key_handler,
+                                       wm, NULL);
+}

src/shell-wm.h

@@ -4,8 +4,6 @@
 #include <glib-object.h>
 #include <mutter-plugin.h>
 
-#include "shell-alttab.h"
-
 G_BEGIN_DECLS
 
 typedef struct _ShellWM      ShellWM;
@@ -73,10 +71,9 @@ void _shell_wm_kill_effect      (ShellWM              *wm,
 				 MutterWindow         *actor,
 				 gulong                events);
 
-/* Called by ShellAltTabHandler */
-
-void _shell_wm_begin_alt_tab    (ShellWM              *wm,
-				 ShellAltTabHandler   *handler);
+/* Keybinding stuff */
+void shell_wm_takeover_keybinding (ShellWM    *wm,
+				   const char *binding_name);
 
 G_END_DECLS
 

src/st/st-adjustment.c

@@ -0,0 +1,777 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+/*
+ * st-adjustment.c: Adjustment object
+ *
+ * Copyright (C) 2008 OpenedHand
+ * Copyright (c) 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.
+ *
+ * Written by: Chris Lord <chris@openedhand.com>, inspired by GtkAdjustment
+ * Port to St by: Robert Staudinger <robsta@openedhand.com>
+ *
+ */
+
+/**
+ * SECTION:st-adjustment
+ * @short_description: A GObject representing an adjustable bounded value
+ *
+ * The #StAdjustment object represents a range of values bounded between a
+ * minimum and maximum, together with step and page increments and a page size.
+ */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include <glib-object.h>
+#include <clutter/clutter.h>
+
+#include "st-adjustment.h"
+#include "st-marshal.h"
+#include "st-private.h"
+
+G_DEFINE_TYPE (StAdjustment, st_adjustment, G_TYPE_OBJECT)
+
+#define ADJUSTMENT_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), ST_TYPE_ADJUSTMENT, StAdjustmentPrivate))
+
+struct _StAdjustmentPrivate
+{
+  /* Do not sanity-check values while constructing,
+   * not all properties may be set yet. */
+  gboolean is_constructing : 1;
+
+  gdouble  lower;
+  gdouble  upper;
+  gdouble  value;
+  gdouble  step_increment;
+  gdouble  page_increment;
+  gdouble  page_size;
+
+  /* For interpolation */
+  ClutterTimeline *interpolation;
+  gdouble          old_position;
+  gdouble          new_position;
+
+  /* For elasticity */
+  gboolean      elastic;
+  guint         bounce_source;
+  ClutterAlpha *bounce_alpha;
+};
+
+enum
+{
+  PROP_0,
+
+  PROP_LOWER,
+  PROP_UPPER,
+  PROP_VALUE,
+  PROP_STEP_INC,
+  PROP_PAGE_INC,
+  PROP_PAGE_SIZE,
+
+  PROP_ELASTIC,
+};
+
+enum
+{
+  CHANGED,
+
+  LAST_SIGNAL
+};
+
+static guint signals[LAST_SIGNAL] = { 0, };
+
+static gboolean st_adjustment_set_lower          (StAdjustment *adjustment,
+                                                  gdouble       lower);
+static gboolean st_adjustment_set_upper          (StAdjustment *adjustment,
+                                                  gdouble       upper);
+static gboolean st_adjustment_set_step_increment (StAdjustment *adjustment,
+                                                  gdouble       step);
+static gboolean st_adjustment_set_page_increment (StAdjustment *adjustment,
+                                                  gdouble       page);
+static gboolean st_adjustment_set_page_size      (StAdjustment *adjustment,
+                                                  gdouble       size);
+
+static void
+st_adjustment_constructed (GObject *object)
+{
+  GObjectClass *g_class;
+  StAdjustment *self = ST_ADJUSTMENT (object);
+
+  g_class = G_OBJECT_CLASS (st_adjustment_parent_class);
+  /* The docs say we're suppose to chain up, but would crash without
+   * some extra care. */
+  if (g_class && g_class->constructed &&
+      g_class->constructed != st_adjustment_constructed)
+    {
+      g_class->constructed (object);
+    }
+
+  ST_ADJUSTMENT (self)->priv->is_constructing = FALSE;
+  st_adjustment_clamp_page (self, self->priv->lower, self->priv->upper);
+}
+
+static void
+st_adjustment_get_property (GObject    *gobject,
+                            guint       prop_id,
+                            GValue     *value,
+                            GParamSpec *pspec)
+{
+  StAdjustmentPrivate *priv = ST_ADJUSTMENT (gobject)->priv;
+
+  switch (prop_id)
+    {
+    case PROP_LOWER:
+      g_value_set_double (value, priv->lower);
+      break;
+
+    case PROP_UPPER:
+      g_value_set_double (value, priv->upper);
+      break;
+
+    case PROP_VALUE:
+      g_value_set_double (value, priv->value);
+      break;
+
+    case PROP_STEP_INC:
+      g_value_set_double (value, priv->step_increment);
+      break;
+
+    case PROP_PAGE_INC:
+      g_value_set_double (value, priv->page_increment);
+      break;
+
+    case PROP_PAGE_SIZE:
+      g_value_set_double (value, priv->page_size);
+      break;
+
+    case PROP_ELASTIC:
+      g_value_set_boolean (value, priv->elastic);
+      break;
+
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (gobject, prop_id, pspec);
+      break;
+    }
+}
+
+static void
+st_adjustment_set_property (GObject      *gobject,
+                            guint         prop_id,
+                            const GValue *value,
+                            GParamSpec   *pspec)
+{
+  StAdjustment *adj = ST_ADJUSTMENT (gobject);
+
+  switch (prop_id)
+    {
+    case PROP_LOWER:
+      st_adjustment_set_lower (adj, g_value_get_double (value));
+      break;
+
+    case PROP_UPPER:
+      st_adjustment_set_upper (adj, g_value_get_double (value));
+      break;
+
+    case PROP_VALUE:
+      st_adjustment_set_value (adj, g_value_get_double (value));
+      break;
+
+    case PROP_STEP_INC:
+      st_adjustment_set_step_increment (adj, g_value_get_double (value));
+      break;
+
+    case PROP_PAGE_INC:
+      st_adjustment_set_page_increment (adj, g_value_get_double (value));
+      break;
+
+    case PROP_PAGE_SIZE:
+      st_adjustment_set_page_size (adj, g_value_get_double (value));
+      break;
+
+    case PROP_ELASTIC:
+      st_adjustment_set_elastic (adj, g_value_get_boolean (value));
+      break;
+
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (gobject, prop_id, pspec);
+      break;
+    }
+}
+
+static void
+stop_interpolation (StAdjustment *adjustment)
+{
+  StAdjustmentPrivate *priv = adjustment->priv;
+
+  if (priv->interpolation)
+    {
+      clutter_timeline_stop (priv->interpolation);
+      g_object_unref (priv->interpolation);
+      priv->interpolation = NULL;
+
+      if (priv->bounce_alpha)
+        {
+          g_object_unref (priv->bounce_alpha);
+          priv->bounce_alpha = NULL;
+        }
+    }
+
+  if (priv->bounce_source)
+    {
+      g_source_remove (priv->bounce_source);
+      priv->bounce_source = 0;
+    }
+}
+
+static void
+st_adjustment_dispose (GObject *object)
+{
+  stop_interpolation (ST_ADJUSTMENT (object));
+
+  G_OBJECT_CLASS (st_adjustment_parent_class)->dispose (object);
+}
+
+static void
+st_adjustment_class_init (StAdjustmentClass *klass)
+{
+  GObjectClass *object_class = G_OBJECT_CLASS (klass);
+
+  g_type_class_add_private (klass, sizeof (StAdjustmentPrivate));
+
+  object_class->constructed = st_adjustment_constructed;
+  object_class->get_property = st_adjustment_get_property;
+  object_class->set_property = st_adjustment_set_property;
+  object_class->dispose = st_adjustment_dispose;
+
+  g_object_class_install_property (object_class,
+                                   PROP_LOWER,
+                                   g_param_spec_double ("lower",
+                                                        "Lower",
+                                                        "Lower bound",
+                                                        -G_MAXDOUBLE,
+                                                        G_MAXDOUBLE,
+                                                        0.0,
+                                                        ST_PARAM_READWRITE |
+                                                        G_PARAM_CONSTRUCT));
+  g_object_class_install_property (object_class,
+                                   PROP_UPPER,
+                                   g_param_spec_double ("upper",
+                                                        "Upper",
+                                                        "Upper bound",
+                                                        -G_MAXDOUBLE,
+                                                        G_MAXDOUBLE,
+                                                        0.0,
+                                                        ST_PARAM_READWRITE |
+                                                        G_PARAM_CONSTRUCT));
+  g_object_class_install_property (object_class,
+                                   PROP_VALUE,
+                                   g_param_spec_double ("value",
+                                                        "Value",
+                                                        "Current value",
+                                                        -G_MAXDOUBLE,
+                                                        G_MAXDOUBLE,
+                                                        0.0,
+                                                        ST_PARAM_READWRITE |
+                                                        G_PARAM_CONSTRUCT));
+  g_object_class_install_property (object_class,
+                                   PROP_STEP_INC,
+                                   g_param_spec_double ("step-increment",
+                                                        "Step Increment",
+                                                        "Step increment",
+                                                        0.0,
+                                                        G_MAXDOUBLE,
+                                                        0.0,
+                                                        ST_PARAM_READWRITE |
+                                                        G_PARAM_CONSTRUCT));
+  g_object_class_install_property (object_class,
+                                   PROP_PAGE_INC,
+                                   g_param_spec_double ("page-increment",
+                                                        "Page Increment",
+                                                        "Page increment",
+                                                        0.0,
+                                                        G_MAXDOUBLE,
+                                                        0.0,
+                                                        ST_PARAM_READWRITE |
+                                                        G_PARAM_CONSTRUCT));
+  g_object_class_install_property (object_class,
+                                   PROP_PAGE_SIZE,
+                                   g_param_spec_double ("page-size",
+                                                        "Page Size",
+                                                        "Page size",
+                                                        0.0,
+                                                        G_MAXDOUBLE,
+                                                        0.0,
+                                                        ST_PARAM_READWRITE |
+                                                        G_PARAM_CONSTRUCT));
+  g_object_class_install_property (object_class,
+                                   PROP_ELASTIC,
+                                   g_param_spec_boolean ("elastic",
+                                                         "Elastic",
+                                                         "Make interpolation "
+                                                         "behave in an "
+                                                         "'elastic' way and "
+                                                         "stop clamping value.",
+                                                         FALSE,
+                                                         ST_PARAM_READWRITE |
+                                                         G_PARAM_CONSTRUCT));
+
+  /**
+   * StAdjustment::changed:
+   *
+   * Emitted when any of the adjustment values have changed
+   */
+  signals[CHANGED] =
+    g_signal_new ("changed",
+                  G_TYPE_FROM_CLASS (klass),
+                  G_SIGNAL_RUN_LAST,
+                  G_STRUCT_OFFSET (StAdjustmentClass, changed),
+                  NULL, NULL,
+                  _st_marshal_VOID__VOID,
+                  G_TYPE_NONE, 0);
+}
+
+static void
+st_adjustment_init (StAdjustment *self)
+{
+  self->priv = ADJUSTMENT_PRIVATE (self);
+
+  self->priv->is_constructing = TRUE;
+}
+
+StAdjustment *
+st_adjustment_new (gdouble value,
+                   gdouble lower,
+                   gdouble upper,
+                   gdouble step_increment,
+                   gdouble page_increment,
+                   gdouble page_size)
+{
+  return g_object_new (ST_TYPE_ADJUSTMENT,
+                       "value", value,
+                       "lower", lower,
+                       "upper", upper,
+                       "step-increment", step_increment,
+                       "page-increment", page_increment,
+                       "page-size", page_size,
+                       NULL);
+}
+
+gdouble
+st_adjustment_get_value (StAdjustment *adjustment)
+{
+  StAdjustmentPrivate *priv;
+
+  g_return_val_if_fail (ST_IS_ADJUSTMENT (adjustment), 0);
+
+  priv = adjustment->priv;
+
+  if (priv->interpolation)
+    {
+      return MAX (priv->lower,
+                  MIN (priv->upper - priv->page_size,
+                       priv->new_position));
+    }
+  else
+    return priv->value;
+}
+
+void
+st_adjustment_set_value (StAdjustment *adjustment,
+                         gdouble       value)
+{
+  StAdjustmentPrivate *priv;
+
+  g_return_if_fail (ST_IS_ADJUSTMENT (adjustment));
+
+  priv = adjustment->priv;
+
+  stop_interpolation (adjustment);
+
+  /* Defer clamp until after construction. */
+  if (!priv->is_constructing)
+    {
+      if (!priv->elastic)
+        value = CLAMP (value,
+                       priv->lower,
+                       MAX (priv->lower, priv->upper - priv->page_size));
+    }
+
+  if (priv->value != value)
+    {
+      priv->value = value;
+
+      g_object_notify (G_OBJECT (adjustment), "value");
+    }
+}
+
+void
+st_adjustment_clamp_page (StAdjustment *adjustment,
+                          gdouble       lower,
+                          gdouble       upper)
+{
+  StAdjustmentPrivate *priv;
+  gboolean changed;
+
+  g_return_if_fail (ST_IS_ADJUSTMENT (adjustment));
+
+  priv = adjustment->priv;
+
+  stop_interpolation (adjustment);
+
+  lower = CLAMP (lower, priv->lower, priv->upper - priv->page_size);
+  upper = CLAMP (upper, priv->lower + priv->page_size, priv->upper);
+
+  changed = FALSE;
+
+  if (priv->value + priv->page_size > upper)
+    {
+      priv->value = upper - priv->page_size;
+      changed = TRUE;
+    }
+
+  if (priv->value < lower)
+    {
+      priv->value = lower;
+      changed = TRUE;
+    }
+
+  if (changed)
+    g_object_notify (G_OBJECT (adjustment), "value");
+}
+
+static gboolean
+st_adjustment_set_lower (StAdjustment *adjustment,
+                         gdouble       lower)
+{
+  StAdjustmentPrivate *priv = adjustment->priv;
+
+  if (priv->lower != lower)
+    {
+      priv->lower = lower;
+
+      g_signal_emit (adjustment, signals[CHANGED], 0);
+
+      g_object_notify (G_OBJECT (adjustment), "lower");
+
+      /* Defer clamp until after construction. */
+      if (!priv->is_constructing)
+        st_adjustment_clamp_page (adjustment, priv->lower, priv->upper);
+
+      return TRUE;
+    }
+
+  return FALSE;
+}
+
+static gboolean
+st_adjustment_set_upper (StAdjustment *adjustment,
+                         gdouble       upper)
+{
+  StAdjustmentPrivate *priv = adjustment->priv;
+
+  if (priv->upper != upper)
+    {
+      priv->upper = upper;
+
+      g_signal_emit (adjustment, signals[CHANGED], 0);
+
+      g_object_notify (G_OBJECT (adjustment), "upper");
+
+      /* Defer clamp until after construction. */
+      if (!priv->is_constructing)
+        st_adjustment_clamp_page (adjustment, priv->lower, priv->upper);
+
+      return TRUE;
+    }
+
+  return FALSE;
+}
+
+static gboolean
+st_adjustment_set_step_increment (StAdjustment *adjustment,
+                                  gdouble       step)
+{
+  StAdjustmentPrivate *priv = adjustment->priv;
+
+  if (priv->step_increment != step)
+    {
+      priv->step_increment = step;
+
+      g_signal_emit (adjustment, signals[CHANGED], 0);
+
+      g_object_notify (G_OBJECT (adjustment), "step-increment");
+
+      return TRUE;
+    }
+
+  return FALSE;
+}
+
+static gboolean
+st_adjustment_set_page_increment (StAdjustment *adjustment,
+                                  gdouble       page)
+{
+  StAdjustmentPrivate *priv = adjustment->priv;
+
+  if (priv->page_increment != page)
+    {
+      priv->page_increment = page;
+
+      g_signal_emit (adjustment, signals[CHANGED], 0);
+
+      g_object_notify (G_OBJECT (adjustment), "page-increment");
+
+      return TRUE;
+    }
+
+  return FALSE;
+}
+
+static gboolean
+st_adjustment_set_page_size (StAdjustment *adjustment,
+                             gdouble       size)
+{
+  StAdjustmentPrivate *priv = adjustment->priv;
+
+  if (priv->page_size != size)
+    {
+      priv->page_size = size;
+
+      g_signal_emit (adjustment, signals[CHANGED], 0);
+
+      g_object_notify (G_OBJECT (adjustment), "page_size");
+
+      /* Well explicitely clamp after construction. */
+      if (!priv->is_constructing)
+        st_adjustment_clamp_page (adjustment, priv->lower, priv->upper);
+
+      return TRUE;
+    }
+
+  return FALSE;
+}
+
+void
+st_adjustment_set_values (StAdjustment *adjustment,
+                          gdouble       value,
+                          gdouble       lower,
+                          gdouble       upper,
+                          gdouble       step_increment,
+                          gdouble       page_increment,
+                          gdouble       page_size)
+{
+  StAdjustmentPrivate *priv;
+  gboolean emit_changed = FALSE;
+
+  g_return_if_fail (ST_IS_ADJUSTMENT (adjustment));
+  g_return_if_fail (page_size >= 0 && page_size <= G_MAXDOUBLE);
+  g_return_if_fail (step_increment >= 0 && step_increment <= G_MAXDOUBLE);
+  g_return_if_fail (page_increment >= 0 && page_increment <= G_MAXDOUBLE);
+
+  priv = adjustment->priv;
+
+  stop_interpolation (adjustment);
+
+  emit_changed = FALSE;
+
+  g_object_freeze_notify (G_OBJECT (adjustment));
+
+  emit_changed |= st_adjustment_set_lower (adjustment, lower);
+  emit_changed |= st_adjustment_set_upper (adjustment, upper);
+  emit_changed |= st_adjustment_set_step_increment (adjustment, step_increment);
+  emit_changed |= st_adjustment_set_page_increment (adjustment, page_increment);
+  emit_changed |= st_adjustment_set_page_size (adjustment, page_size);
+
+  if (value != priv->value)
+    {
+      st_adjustment_set_value (adjustment, value);
+      emit_changed = TRUE;
+    }
+
+  if (emit_changed)
+    g_signal_emit (G_OBJECT (adjustment), signals[CHANGED], 0);
+
+  g_object_thaw_notify (G_OBJECT (adjustment));
+}
+
+void
+st_adjustment_get_values (StAdjustment *adjustment,
+                          gdouble      *value,
+                          gdouble      *lower,
+                          gdouble      *upper,
+                          gdouble      *step_increment,
+                          gdouble      *page_increment,
+                          gdouble      *page_size)
+{
+  StAdjustmentPrivate *priv;
+
+  g_return_if_fail (ST_IS_ADJUSTMENT (adjustment));
+
+  priv = adjustment->priv;
+
+  if (lower)
+    *lower = priv->lower;
+
+  if (upper)
+    *upper = priv->upper;
+
+  if (value)
+    *value = st_adjustment_get_value (adjustment);
+
+  if (step_increment)
+    *step_increment = priv->step_increment;
+
+  if (page_increment)
+    *page_increment = priv->page_increment;
+
+  if (page_size)
+    *page_size = priv->page_size;
+}
+
+static void
+interpolation_new_frame_cb (ClutterTimeline *timeline,
+                            guint            msecs,
+                            StAdjustment    *adjustment)
+{
+  StAdjustmentPrivate *priv = adjustment->priv;
+
+  priv->interpolation = NULL;
+
+  if (priv->elastic)
+    {
+      gdouble progress = clutter_alpha_get_alpha (priv->bounce_alpha) / 1.0;
+      gdouble dx = priv->old_position
+                   + (priv->new_position - priv->old_position)
+                   * progress;
+
+      st_adjustment_set_value (adjustment, dx);
+    }
+  else
+    st_adjustment_set_value (adjustment,
+                             priv->old_position +
+                             (priv->new_position - priv->old_position) *
+                             clutter_timeline_get_progress (timeline));
+
+  priv->interpolation = timeline;
+}
+
+static void
+interpolation_completed_cb (ClutterTimeline *timeline,
+                            StAdjustment    *adjustment)
+{
+  StAdjustmentPrivate *priv = adjustment->priv;
+
+  stop_interpolation (adjustment);
+  st_adjustment_set_value (adjustment, priv->new_position);
+}
+
+/* Note, there's super-optimal code that does a similar thing in
+ * clutter-alpha.c
+ *
+ * Tried this instead of CLUTTER_ALPHA_SINE_INC, but I think SINE_INC looks
+ * better. Leaving code here in case this is revisited.
+ */
+/*
+   static guint32
+   bounce_alpha_func (ClutterAlpha *alpha,
+                   gpointer      user_data)
+   {
+   ClutterFixed progress, angle;
+   ClutterTimeline *timeline = clutter_alpha_get_timeline (alpha);
+
+   progress = clutter_timeline_get_progressx (timeline);
+   angle = clutter_qmulx (CFX_PI_2 + CFX_PI_4/2, progress);
+
+   return clutter_sinx (angle) +
+    (CFX_ONE - clutter_sinx (CFX_PI_2 + CFX_PI_4/2));
+   }
+ */
+
+void
+st_adjustment_interpolate (StAdjustment *adjustment,
+                           gdouble       value,
+                           guint         duration)
+{
+  StAdjustmentPrivate *priv = adjustment->priv;
+
+  stop_interpolation (adjustment);
+
+  if (duration <= 1)
+    {
+      st_adjustment_set_value (adjustment, value);
+      return;
+    }
+
+  priv->old_position = priv->value;
+  priv->new_position = value;
+
+  priv->interpolation = clutter_timeline_new (duration);
+
+  if (priv->elastic)
+    priv->bounce_alpha = clutter_alpha_new_full (priv->interpolation,
+                                                 CLUTTER_LINEAR);
+
+  g_signal_connect (priv->interpolation,
+                    "new-frame",
+                    G_CALLBACK (interpolation_new_frame_cb),
+                    adjustment);
+  g_signal_connect (priv->interpolation,
+                    "completed",
+                    G_CALLBACK (interpolation_completed_cb),
+                    adjustment);
+
+  clutter_timeline_start (priv->interpolation);
+}
+
+gboolean
+st_adjustment_get_elastic (StAdjustment *adjustment)
+{
+  return adjustment->priv->elastic;
+}
+
+void
+st_adjustment_set_elastic (StAdjustment *adjustment,
+                           gboolean      elastic)
+{
+  adjustment->priv->elastic = elastic;
+}
+
+gboolean
+st_adjustment_clamp (StAdjustment *adjustment,
+                     gboolean      interpolate,
+                     guint         duration)
+{
+  StAdjustmentPrivate *priv = adjustment->priv;
+  gdouble dest = priv->value;
+
+  if (priv->value < priv->lower)
+    dest = priv->lower;
+
+  if (priv->value > priv->upper - priv->page_size)
+    dest = priv->upper - priv->page_size;
+
+  if (dest != priv->value)
+    {
+      if (interpolate)
+        st_adjustment_interpolate (adjustment, dest, duration);
+      else
+        st_adjustment_set_value (adjustment, dest);
+
+      return TRUE;
+    }
+
+  return FALSE;
+}

src/st/st-adjustment.h

@@ -0,0 +1,122 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+/*
+ * st-adjustment.h: Adjustment object
+ *
+ * Copyright 2008 OpenedHand
+ * 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.
+ *
+ * Written by: Chris Lord <chris@openedhand.com>, inspired by GtkAdjustment
+ * Port to St by: Robert Staudinger <robsta@openedhand.com>
+ *
+ */
+
+#if !defined(ST_H_INSIDE) && !defined(ST_COMPILATION)
+#error "Only <st/st.h> can be included directly.h"
+#endif
+
+#ifndef __ST_ADJUSTMENT_H__
+#define __ST_ADJUSTMENT_H__
+
+#include <glib-object.h>
+#include <clutter/clutter.h>
+
+G_BEGIN_DECLS
+
+#define ST_TYPE_ADJUSTMENT            (st_adjustment_get_type())
+#define ST_ADJUSTMENT(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), ST_TYPE_ADJUSTMENT, StAdjustment))
+#define ST_IS_ADJUSTMENT(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), ST_TYPE_ADJUSTMENT))
+#define ST_ADJUSTMENT_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), ST_TYPE_ADJUSTMENT, StAdjustmentClass))
+#define ST_IS_ADJUSTMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), ST_TYPE_ADJUSTMENT))
+#define ST_ADJUSTMENT_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), ST_TYPE_ADJUSTMENT, StAdjustmentClass))
+
+typedef struct _StAdjustment          StAdjustment;
+typedef struct _StAdjustmentPrivate   StAdjustmentPrivate;
+typedef struct _StAdjustmentClass     StAdjustmentClass;
+
+/**
+ * StAdjustment:
+ *
+ * Class for handling an interval between to values. The contents of
+ * the #StAdjustment are private and should be accessed using the
+ * public API.
+ */
+struct _StAdjustment
+{
+  /*< private >*/
+  GObject parent_instance;
+
+  StAdjustmentPrivate *priv;
+};
+
+/**
+ * StAdjustmentClass
+ * @changed: Class handler for the ::changed signal.
+ *
+ * Base class for #StAdjustment.
+ */
+struct _StAdjustmentClass
+{
+  /*< private >*/
+  GObjectClass parent_class;
+
+  /*< public >*/
+  void (* changed) (StAdjustment *adjustment);
+};
+
+GType st_adjustment_get_type (void) G_GNUC_CONST;
+
+StAdjustment *st_adjustment_new         (gdouble       value,
+                                         gdouble       lower,
+                                         gdouble       upper,
+                                         gdouble       step_increment,
+                                         gdouble       page_increment,
+                                         gdouble       page_size);
+gdouble       st_adjustment_get_value   (StAdjustment *adjustment);
+void          st_adjustment_set_value   (StAdjustment *adjustment,
+                                         gdouble       value);
+void          st_adjustment_clamp_page  (StAdjustment *adjustment,
+                                         gdouble       lower,
+                                         gdouble       upper);
+void          st_adjustment_set_values  (StAdjustment *adjustment,
+                                         gdouble       value,
+                                         gdouble       lower,
+                                         gdouble       upper,
+                                         gdouble       step_increment,
+                                         gdouble       page_increment,
+                                         gdouble       page_size);
+void          st_adjustment_get_values  (StAdjustment *adjustment,
+                                         gdouble      *value,
+                                         gdouble      *lower,
+                                         gdouble      *upper,
+                                         gdouble      *step_increment,
+                                         gdouble      *page_increment,
+                                         gdouble      *page_size);
+
+void          st_adjustment_interpolate (StAdjustment *adjustment,
+                                         gdouble       value,
+                                         guint         duration);
+
+gboolean      st_adjustment_get_elastic (StAdjustment *adjustment);
+void          st_adjustment_set_elastic (StAdjustment *adjustment,
+                                         gboolean      elastic);
+
+gboolean      st_adjustment_clamp       (StAdjustment *adjustment,
+                                         gboolean      interpolate,
+                                         guint         duration);
+
+G_END_DECLS
+
+#endif /* __ST_ADJUSTMENT_H__ */

src/st/st-bin.c

@@ -0,0 +1,748 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+/*
+ * st-bin.c: Basic container actor
+ *
+ * Copyright (c) 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.
+ *
+ * Written by: Emmanuele Bassi <ebassi@linux.intel.com>
+ *
+ */
+
+/**
+ * SECTION:st-bin
+ * @short_description: a simple container with one actor
+ *
+ * #StBin is a simple container capable of having only one
+ * #ClutterActor as a child.
+ *
+ * #StBin inherits from #StWidget, so it is fully themable.
+ */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include <clutter/clutter.h>
+
+#include "st-bin.h"
+#include "st-enum-types.h"
+#include "st-private.h"
+
+#define ST_BIN_GET_PRIVATE(obj)       (G_TYPE_INSTANCE_GET_PRIVATE ((obj), ST_TYPE_BIN, StBinPrivate))
+
+struct _StBinPrivate
+{
+  ClutterActor *child;
+
+  StAlign       x_align;
+  StAlign       y_align;
+
+  guint         x_fill : 1;
+  guint         y_fill : 1;
+};
+
+enum
+{
+  PROP_0,
+
+  PROP_CHILD,
+  PROP_X_ALIGN,
+  PROP_Y_ALIGN,
+  PROP_X_FILL,
+  PROP_Y_FILL
+};
+
+static void clutter_container_iface_init (ClutterContainerIface *iface);
+
+G_DEFINE_TYPE_WITH_CODE (StBin, st_bin, ST_TYPE_WIDGET,
+                         G_IMPLEMENT_INTERFACE (CLUTTER_TYPE_CONTAINER,
+                                                clutter_container_iface_init));
+
+void
+_st_bin_get_align_factors (StBin   *bin,
+                           gdouble *x_align,
+                           gdouble *y_align)
+{
+  StBinPrivate *priv = bin->priv;
+  gdouble factor;
+
+  switch (priv->x_align)
+    {
+    case ST_ALIGN_START:
+      factor = 0.0;
+      break;
+
+    case ST_ALIGN_MIDDLE:
+      factor = 0.5;
+      break;
+
+    case ST_ALIGN_END:
+      factor = 1.0;
+      break;
+
+    default:
+      factor = 0.0;
+      break;
+    }
+
+  if (x_align)
+    *x_align = factor;
+
+  switch (priv->y_align)
+    {
+    case ST_ALIGN_START:
+      factor = 0.0;
+      break;
+
+    case ST_ALIGN_MIDDLE:
+      factor = 0.5;
+      break;
+
+    case ST_ALIGN_END:
+      factor = 1.0;
+      break;
+
+    default:
+      factor = 0.0;
+      break;
+    }
+
+  if (y_align)
+    *y_align = factor;
+}
+
+static void
+st_bin_add (ClutterContainer *container,
+            ClutterActor     *actor)
+{
+  st_bin_set_child (ST_BIN (container), actor);
+}
+
+static void
+st_bin_remove (ClutterContainer *container,
+               ClutterActor     *actor)
+{
+  StBinPrivate *priv = ST_BIN (container)->priv;
+
+  if (priv->child == actor)
+    st_bin_set_child (ST_BIN (container), NULL);
+}
+
+static void
+st_bin_foreach (ClutterContainer *container,
+                ClutterCallback   callback,
+                gpointer          user_data)
+{
+  StBinPrivate *priv = ST_BIN (container)->priv;
+
+  if (priv->child)
+    callback (priv->child, user_data);
+}
+
+static void
+clutter_container_iface_init (ClutterContainerIface *iface)
+{
+  iface->add = st_bin_add;
+  iface->remove = st_bin_remove;
+  iface->foreach = st_bin_foreach;
+}
+
+static void
+st_bin_paint (ClutterActor *self)
+{
+  StBinPrivate *priv = ST_BIN (self)->priv;
+
+  /* allow StWidget to paint the background */
+  CLUTTER_ACTOR_CLASS (st_bin_parent_class)->paint (self);
+
+  /* the pain our child */
+  if (priv->child)
+    clutter_actor_paint (priv->child);
+}
+
+static void
+st_bin_pick (ClutterActor       *self,
+             const ClutterColor *pick_color)
+{
+  StBinPrivate *priv = ST_BIN (self)->priv;
+
+  /* get the default pick implementation */
+  CLUTTER_ACTOR_CLASS (st_bin_parent_class)->pick (self, pick_color);
+
+  if (priv->child)
+    clutter_actor_paint (priv->child);
+}
+
+static void
+st_bin_allocate (ClutterActor          *self,
+                 const ClutterActorBox *box,
+                 ClutterAllocationFlags flags)
+{
+  StBinPrivate *priv = ST_BIN (self)->priv;
+
+  CLUTTER_ACTOR_CLASS (st_bin_parent_class)->allocate (self, box,
+                                                       flags);
+
+  if (priv->child)
+    {
+      StThemeNode *theme_node = st_widget_get_theme_node (ST_WIDGET (self));
+      gfloat natural_width, natural_height;
+      gfloat min_width, min_height;
+      gfloat child_width, child_height;
+      gfloat available_width, available_height;
+      ClutterRequestMode request;
+      ClutterActorBox content_box;
+      ClutterActorBox allocation = { 0, };
+      gdouble x_align, y_align;
+
+      st_theme_node_get_content_box (theme_node, box, &content_box);
+
+      _st_bin_get_align_factors (ST_BIN (self), &x_align, &y_align);
+
+      available_width  = content_box.x2 - content_box.x1;
+      available_height = content_box.y2 - content_box.y1;
+
+      if (available_width < 0)
+        available_width = 0;
+
+      if (available_height < 0)
+        available_height = 0;
+
+      if (priv->x_fill)
+        {
+          allocation.x1 = (int) content_box.x1;
+          allocation.x2 = (int) content_box.x2;
+        }
+
+      if (priv->y_fill)
+        {
+          allocation.y1 = (int) content_box.y1;
+          allocation.y2 = (int) content_box.y2;
+        }
+
+      /* if we are filling horizontally and vertically then we're done */
+      if (priv->x_fill && priv->y_fill)
+        {
+          clutter_actor_allocate (priv->child, &allocation, flags);
+          return;
+        }
+
+      request = CLUTTER_REQUEST_HEIGHT_FOR_WIDTH;
+      g_object_get (G_OBJECT (priv->child), "request-mode", &request, NULL);
+
+      if (request == CLUTTER_REQUEST_HEIGHT_FOR_WIDTH)
+        {
+          clutter_actor_get_preferred_width (priv->child, available_height,
+                                             &min_width,
+                                             &natural_width);
+
+          child_width = CLAMP (natural_width, min_width, available_width);
+
+          clutter_actor_get_preferred_height (priv->child, child_width,
+                                              &min_height,
+                                              &natural_height);
+
+          child_height = CLAMP (natural_height, min_height, available_height);
+        }
+      else
+        {
+          clutter_actor_get_preferred_height (priv->child, available_width,
+                                              &min_height,
+                                              &natural_height);
+
+          child_height = CLAMP (natural_height, min_height, available_height);
+
+          clutter_actor_get_preferred_width (priv->child, child_height,
+                                             &min_width,
+                                             &natural_width);
+
+          child_width = CLAMP (natural_width, min_width, available_width);
+        }
+
+      if (!priv->x_fill)
+        {
+          allocation.x1 = content_box.x1 + (int) ((available_width - child_width) * x_align);
+          allocation.x2 = allocation.x1 + child_width;
+        }
+
+      if (!priv->y_fill)
+        {
+          allocation.y1 = content_box.y1 + (int) ((available_height - child_height) * y_align);
+          allocation.y2 = allocation.y1 + child_height;
+        }
+
+      clutter_actor_allocate (priv->child, &allocation, flags);
+    }
+}
+
+static void
+st_bin_get_preferred_width (ClutterActor *self,
+                            gfloat        for_height,
+                            gfloat       *min_width_p,
+                            gfloat       *natural_width_p)
+{
+  StBinPrivate *priv = ST_BIN (self)->priv;
+  StThemeNode *theme_node = st_widget_get_theme_node (ST_WIDGET (self));
+
+  st_theme_node_adjust_for_height (theme_node, &for_height);
+
+  if (priv->child == NULL)
+    {
+      if (min_width_p)
+        *min_width_p = 0;
+
+      if (natural_width_p)
+        *natural_width_p = 0;
+    }
+  else
+    {
+      clutter_actor_get_preferred_width (priv->child, for_height,
+                                         min_width_p,
+                                         natural_width_p);
+    }
+
+  st_theme_node_adjust_preferred_width (theme_node, min_width_p, natural_width_p);
+}
+
+static void
+st_bin_get_preferred_height (ClutterActor *self,
+                             gfloat        for_width,
+                             gfloat       *min_height_p,
+                             gfloat       *natural_height_p)
+{
+  StBinPrivate *priv = ST_BIN (self)->priv;
+  StThemeNode *theme_node = st_widget_get_theme_node (ST_WIDGET (self));
+
+  st_theme_node_adjust_for_width (theme_node, &for_width);
+
+  if (priv->child == NULL)
+    {
+      if (min_height_p)
+        *min_height_p = 0;
+
+      if (natural_height_p)
+        *natural_height_p = 0;
+    }
+  else
+    {
+      clutter_actor_get_preferred_height (priv->child, for_width,
+                                          min_height_p,
+                                          natural_height_p);
+    }
+
+  st_theme_node_adjust_preferred_height (theme_node, min_height_p, natural_height_p);
+}
+
+static void
+st_bin_dispose (GObject *gobject)
+{
+  StBinPrivate *priv = ST_BIN (gobject)->priv;
+
+  if (priv->child)
+    {
+      clutter_actor_unparent (priv->child);
+      priv->child = NULL;
+    }
+
+  G_OBJECT_CLASS (st_bin_parent_class)->dispose (gobject);
+}
+
+static void
+st_bin_set_property (GObject      *gobject,
+                     guint         prop_id,
+                     const GValue *value,
+                     GParamSpec   *pspec)
+{
+  StBin *bin = ST_BIN (gobject);
+
+  switch (prop_id)
+    {
+    case PROP_CHILD:
+      st_bin_set_child (bin, g_value_get_object (value));
+      break;
+
+    case PROP_X_ALIGN:
+      st_bin_set_alignment (bin,
+                            g_value_get_enum (value),
+                            bin->priv->y_align);
+      break;
+
+    case PROP_Y_ALIGN:
+      st_bin_set_alignment (bin,
+                            bin->priv->x_align,
+                            g_value_get_enum (value));
+      break;
+
+    case PROP_X_FILL:
+      st_bin_set_fill (bin,
+                       g_value_get_boolean (value),
+                       bin->priv->y_fill);
+      break;
+
+    case PROP_Y_FILL:
+      st_bin_set_fill (bin,
+                       bin->priv->y_fill,
+                       g_value_get_boolean (value));
+      break;
+
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (gobject, prop_id, pspec);
+    }
+}
+
+static void
+st_bin_get_property (GObject    *gobject,
+                     guint       prop_id,
+                     GValue     *value,
+                     GParamSpec *pspec)
+{
+  StBinPrivate *priv = ST_BIN (gobject)->priv;
+
+  switch (prop_id)
+    {
+    case PROP_CHILD:
+      g_value_set_object (value, priv->child);
+      break;
+
+    case PROP_X_FILL:
+      g_value_set_boolean (value, priv->x_fill);
+      break;
+
+    case PROP_Y_FILL:
+      g_value_set_boolean (value, priv->y_fill);
+      break;
+
+    case PROP_X_ALIGN:
+      g_value_set_enum (value, priv->x_align);
+      break;
+
+    case PROP_Y_ALIGN:
+      g_value_set_enum (value, priv->y_align);
+      break;
+
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (gobject, prop_id, pspec);
+    }
+}
+
+static void
+st_bin_class_init (StBinClass *klass)
+{
+  GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
+  ClutterActorClass *actor_class = CLUTTER_ACTOR_CLASS (klass);
+  GParamSpec *pspec;
+
+  g_type_class_add_private (klass, sizeof (StBinPrivate));
+
+  gobject_class->set_property = st_bin_set_property;
+  gobject_class->get_property = st_bin_get_property;
+  gobject_class->dispose = st_bin_dispose;
+
+  actor_class->get_preferred_width = st_bin_get_preferred_width;
+  actor_class->get_preferred_height = st_bin_get_preferred_height;
+  actor_class->allocate = st_bin_allocate;
+  actor_class->paint = st_bin_paint;
+  actor_class->pick = st_bin_pick;
+
+  /**
+   * StBin:child:
+   *
+   * The child #ClutterActor of the #StBin container.
+   */
+  pspec = g_param_spec_object ("child",
+                               "Child",
+                               "The child of the Bin",
+                               CLUTTER_TYPE_ACTOR,
+                               ST_PARAM_READWRITE);
+  g_object_class_install_property (gobject_class, PROP_CHILD, pspec);
+
+  /**
+   * StBin:x-align:
+   *
+   * The horizontal alignment of the #StBin child.
+   */
+  pspec = g_param_spec_enum ("x-align",
+                             "X Align",
+                             "The horizontal alignment",
+                             ST_TYPE_ALIGN,
+                             ST_ALIGN_MIDDLE,
+                             ST_PARAM_READWRITE);
+  g_object_class_install_property (gobject_class, PROP_X_ALIGN, pspec);
+
+  /**
+   * StBin:y-align:
+   *
+   * The vertical alignment of the #StBin child.
+   */
+  pspec = g_param_spec_enum ("y-align",
+                             "Y Align",
+                             "The vertical alignment",
+                             ST_TYPE_ALIGN,
+                             ST_ALIGN_MIDDLE,
+                             ST_PARAM_READWRITE);
+  g_object_class_install_property (gobject_class, PROP_Y_ALIGN, pspec);
+
+  /**
+   * StBin:x-fill:
+   *
+   * Whether the child should fill the horizontal allocation
+   */
+  pspec = g_param_spec_boolean ("x-fill",
+                                "X Fill",
+                                "Whether the child should fill the "
+                                "horizontal allocation",
+                                FALSE,
+                                ST_PARAM_READWRITE);
+  g_object_class_install_property (gobject_class, PROP_X_FILL, pspec);
+
+  /**
+   * StBin:y-fill:
+   *
+   * Whether the child should fill the vertical allocation
+   */
+  pspec = g_param_spec_boolean ("y-fill",
+                                "Y Fill",
+                                "Whether the child should fill the "
+                                "vertical allocation",
+                                FALSE,
+                                ST_PARAM_READWRITE);
+  g_object_class_install_property (gobject_class, PROP_Y_FILL, pspec);
+}
+
+static void
+st_bin_init (StBin *bin)
+{
+  bin->priv = ST_BIN_GET_PRIVATE (bin);
+
+  bin->priv->x_align = ST_ALIGN_MIDDLE;
+  bin->priv->y_align = ST_ALIGN_MIDDLE;
+}
+
+/**
+ * st_bin_new:
+ *
+ * Creates a new #StBin, a simple container for one child.
+ *
+ * Return value: the newly created #StBin actor
+ */
+StWidget *
+st_bin_new (void)
+{
+  return g_object_new (ST_TYPE_BIN, NULL);
+}
+
+/**
+ * st_bin_set_child:
+ * @bin: a #StBin
+ * @child: a #ClutterActor, or %NULL
+ *
+ * Sets @child as the child of @bin.
+ *
+ * If @bin already has a child, the previous child is removed.
+ */
+void
+st_bin_set_child (StBin        *bin,
+                  ClutterActor *child)
+{
+  StBinPrivate *priv;
+
+  g_return_if_fail (ST_IS_BIN (bin));
+  g_return_if_fail (child == NULL || CLUTTER_IS_ACTOR (child));
+
+  priv = bin->priv;
+
+  if (priv->child == child)
+    return;
+
+  if (priv->child)
+    {
+      ClutterActor *old_child = priv->child;
+
+      g_object_ref (old_child);
+
+      priv->child = NULL;
+      clutter_actor_unparent (old_child);
+
+      g_signal_emit_by_name (bin, "actor-removed", old_child);
+
+      g_object_unref (old_child);
+    }
+
+  if (child)
+    {
+      priv->child = child;
+      clutter_actor_set_parent (child, CLUTTER_ACTOR (bin));
+
+      g_signal_emit_by_name (bin, "actor-added", priv->child);
+    }
+
+  clutter_actor_queue_relayout (CLUTTER_ACTOR (bin));
+
+  g_object_notify (G_OBJECT (bin), "child");
+}
+
+/**
+ * st_bin_get_child:
+ * @bin: a #StBin
+ *
+ * Retrieves a pointer to the child of @bin.
+ *
+ * Return value: (transfer none): a #ClutterActor, or %NULL
+ */
+ClutterActor *
+st_bin_get_child (StBin *bin)
+{
+  g_return_val_if_fail (ST_IS_BIN (bin), NULL);
+
+  return bin->priv->child;
+}
+
+/**
+ * st_bin_set_alignment:
+ * @bin: a #StBin
+ * @x_align: horizontal alignment
+ * @y_align: vertical alignment
+ *
+ * Sets the horizontal and vertical alignment of the child
+ * inside a #StBin.
+ */
+void
+st_bin_set_alignment (StBin  *bin,
+                      StAlign x_align,
+                      StAlign y_align)
+{
+  StBinPrivate *priv;
+  gboolean changed = FALSE;
+
+  g_return_if_fail (ST_IS_BIN (bin));
+
+  priv = bin->priv;
+
+  g_object_freeze_notify (G_OBJECT (bin));
+
+  if (priv->x_align != x_align)
+    {
+      priv->x_align = x_align;
+      g_object_notify (G_OBJECT (bin), "x-align");
+      changed = TRUE;
+    }
+
+  if (priv->y_align != y_align)
+    {
+      priv->y_align = y_align;
+      g_object_notify (G_OBJECT (bin), "y-align");
+      changed = TRUE;
+    }
+
+  if (changed)
+    clutter_actor_queue_relayout (CLUTTER_ACTOR (bin));
+
+  g_object_thaw_notify (G_OBJECT (bin));
+}
+
+/**
+ * st_bin_get_alignment:
+ * @bin: a #StBin
+ * @x_align: return location for the horizontal alignment, or %NULL
+ * @y_align: return location for the vertical alignment, or %NULL
+ *
+ * Retrieves the horizontal and vertical alignment of the child
+ * inside a #StBin, as set by st_bin_set_alignment().
+ */
+void
+st_bin_get_alignment (StBin   *bin,
+                      StAlign *x_align,
+                      StAlign *y_align)
+{
+  StBinPrivate *priv;
+
+  g_return_if_fail (ST_IS_BIN (bin));
+
+  priv = bin->priv;
+
+  if (x_align)
+    *x_align = priv->x_align;
+
+  if (y_align)
+    *y_align = priv->y_align;
+}
+
+/**
+ * st_bin_set_fill:
+ * @bin: a #StBin
+ * @x_fill: %TRUE if the child should fill horizontally the @bin
+ * @y_fill: %TRUE if the child should fill vertically the @bin
+ *
+ * Sets whether the child of @bin should fill out the horizontal
+ * and/or vertical allocation of the parent
+ */
+void
+st_bin_set_fill (StBin   *bin,
+                 gboolean x_fill,
+                 gboolean y_fill)
+{
+  StBinPrivate *priv;
+  gboolean changed = FALSE;
+
+  g_return_if_fail (ST_IS_BIN (bin));
+
+  priv = bin->priv;
+
+  g_object_freeze_notify (G_OBJECT (bin));
+
+  if (priv->x_fill != x_fill)
+    {
+      priv->x_fill = x_fill;
+      changed = TRUE;
+
+      g_object_notify (G_OBJECT (bin), "x-fill");
+    }
+
+  if (priv->y_fill != y_fill)
+    {
+      priv->y_fill = y_fill;
+      changed = TRUE;
+
+      g_object_notify (G_OBJECT (bin), "y-fill");
+    }
+
+  if (changed)
+    clutter_actor_queue_relayout (CLUTTER_ACTOR (bin));
+
+  g_object_thaw_notify (G_OBJECT (bin));
+}
+
+/**
+ * st_bin_get_fill:
+ * @bin: a #StBin
+ * @x_fill: (out): return location for the horizontal fill, or %NULL
+ * @y_fill: (out): return location for the vertical fill, or %NULL
+ *
+ * Retrieves the horizontal and vertical fill settings
+ */
+void
+st_bin_get_fill (StBin    *bin,
+                 gboolean *x_fill,
+                 gboolean *y_fill)
+{
+  g_return_if_fail (ST_IS_BIN (bin));
+
+  if (x_fill)
+    *x_fill = bin->priv->x_fill;
+
+  if (y_fill)
+    *y_fill = bin->priv->y_fill;
+}

src/st/st-bin.h

@@ -0,0 +1,93 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+/*
+ * st-bin.h: Basic container actor
+ *
+ * Copyright 2009, 2008 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.
+ * Boston, MA 02111-1307, USA.
+ *
+ * Written by: Emmanuele Bassi <ebassi@linux.intel.com>
+ *
+ */
+
+#if !defined(ST_H_INSIDE) && !defined(ST_COMPILATION)
+#error "Only <st/st.h> can be included directly.h"
+#endif
+
+#ifndef __ST_BIN_H__
+#define __ST_BIN_H__
+
+#include <st/st-types.h>
+#include <st/st-widget.h>
+
+G_BEGIN_DECLS
+
+#define ST_TYPE_BIN                   (st_bin_get_type ())
+#define ST_BIN(obj)                   (G_TYPE_CHECK_INSTANCE_CAST ((obj), ST_TYPE_BIN, StBin))
+#define ST_IS_BIN(obj)                (G_TYPE_CHECK_INSTANCE_TYPE ((obj), ST_TYPE_BIN))
+#define ST_BIN_CLASS(klass)           (G_TYPE_CHECK_CLASS_CAST ((klass), ST_TYPE_BIN, StBinClass))
+#define ST_IS_BIN_CLASS(klass)        (G_TYPE_CHECK_CLASS_TYPE ((klass), ST_TYPE_BIN))
+#define ST_BIN_GET_CLASS(obj)         (G_TYPE_INSTANCE_GET_CLASS ((obj), ST_TYPE_BIN, StBinClass))
+
+typedef struct _StBin                 StBin;
+typedef struct _StBinPrivate          StBinPrivate;
+typedef struct _StBinClass            StBinClass;
+
+/**
+ * StBin:
+ *
+ * The #StBin struct contains only private data
+ */
+struct _StBin
+{
+  /*< private >*/
+  StWidget parent_instance;
+
+  StBinPrivate *priv;
+};
+
+/**
+ * StBinClass:
+ *
+ * The #StBinClass struct contains only private data
+ */
+struct _StBinClass
+{
+  /*< private >*/
+  StWidgetClass parent_class;
+};
+
+GType st_bin_get_type (void) G_GNUC_CONST;
+
+StWidget   *  st_bin_new           (void);
+void          st_bin_set_child     (StBin        *bin,
+                                    ClutterActor *child);
+ClutterActor *st_bin_get_child     (StBin        *bin);
+void          st_bin_set_alignment (StBin        *bin,
+                                    StAlign       x_align,
+                                    StAlign       y_align);
+void          st_bin_get_alignment (StBin        *bin,
+                                    StAlign      *x_align,
+                                    StAlign      *y_align);
+void          st_bin_set_fill      (StBin        *bin,
+                                    gboolean      x_fill,
+                                    gboolean      y_fill);
+void          st_bin_get_fill      (StBin        *bin,
+                                    gboolean     *x_fill,
+                                    gboolean     *y_fill);
+
+G_END_DECLS
+
+#endif /* __ST_BIN_H__ */

src/st/st-border-image.c

@@ -0,0 +1,92 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+
+#include <config.h>
+
+#include "st-border-image.h"
+
+struct _StBorderImage {
+  GObject parent;
+
+  char *filename;
+  int border_top;
+  int border_right;
+  int border_bottom;
+  int border_left;
+};
+
+struct _StBorderImageClass {
+  GObjectClass parent_class;
+
+};
+
+G_DEFINE_TYPE (StBorderImage, st_border_image, G_TYPE_OBJECT)
+
+static void
+st_border_image_finalize (GObject *object)
+{
+  StBorderImage *image = ST_BORDER_IMAGE (object);
+
+  g_free (image->filename);
+
+  G_OBJECT_CLASS (st_border_image_parent_class)->finalize (object);
+}
+
+static void
+st_border_image_class_init (StBorderImageClass *klass)
+{
+  GObjectClass *object_class = G_OBJECT_CLASS (klass);
+
+  object_class->finalize = st_border_image_finalize;
+}
+
+static void
+st_border_image_init (StBorderImage *image)
+{
+}
+
+StBorderImage *
+st_border_image_new (const char *filename,
+                       int         border_top,
+                       int         border_right,
+                       int         border_bottom,
+                       int         border_left)
+{
+  StBorderImage *image;
+
+  image = g_object_new (ST_TYPE_BORDER_IMAGE, NULL);
+
+  image->filename = g_strdup (filename);
+  image->border_top = border_top;
+  image->border_right = border_right;
+  image->border_bottom = border_bottom;
+  image->border_left = border_left;
+
+  return image;
+}
+
+const char *
+st_border_image_get_filename (StBorderImage *image)
+{
+  g_return_val_if_fail (ST_IS_BORDER_IMAGE (image), NULL);
+
+  return image->filename;
+}
+
+void
+st_border_image_get_borders (StBorderImage *image,
+                             int           *border_top,
+                             int           *border_right,
+                             int           *border_bottom,
+                             int           *border_left)
+{
+  g_return_if_fail (ST_IS_BORDER_IMAGE (image));
+
+  if (border_top)
+    *border_top = image->border_top;
+  if (border_right)
+    *border_right = image->border_right;
+  if (border_bottom)
+    *border_bottom = image->border_bottom;
+  if (border_left)
+    *border_left = image->border_left;
+}

src/st/st-border-image.h

@@ -0,0 +1,38 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+#ifndef __ST_BORDER_IMAGE_H__
+#define __ST_BORDER_IMAGE_H__
+
+#include <glib-object.h>
+
+G_BEGIN_DECLS
+
+/* A StBorderImage encapsulates an image with specified unscaled borders on each edge.
+ */
+typedef struct _StBorderImage      StBorderImage;
+typedef struct _StBorderImageClass StBorderImageClass;
+
+#define ST_TYPE_BORDER_IMAGE             (st_border_image_get_type ())
+#define ST_BORDER_IMAGE(object)          (G_TYPE_CHECK_INSTANCE_CAST ((object), ST_TYPE_BORDER_IMAGE, StBorderImage))
+#define ST_BORDER_IMAGE_CLASS(klass)     (G_TYPE_CHECK_CLASS_CAST ((klass), ST_TYPE_BORDER_IMAGE, StBorderImageClass))
+#define ST_IS_BORDER_IMAGE(object)       (G_TYPE_CHECK_INSTANCE_TYPE ((object), ST_TYPE_BORDER_IMAGE))
+#define ST_IS_BORDER_IMAGE_CLASS(klass)  (G_TYPE_CHECK_CLASS_TYPE ((klass), ST_TYPE_BORDER_IMAGE))
+#define ST_BORDER_IMAGE_GET_CLASS(obj)   (G_TYPE_INSTANCE_GET_CLASS ((obj), ST_TYPE_BORDER_IMAGE, StBorderImageClass))
+
+GType             st_border_image_get_type          (void) G_GNUC_CONST;
+
+StBorderImage *st_border_image_new (const char *filename,
+                                    int         border_top,
+                                    int         border_right,
+                                    int         border_bottom,
+                                    int         border_left);
+
+const char *st_border_image_get_filename (StBorderImage *image);
+void        st_border_image_get_borders  (StBorderImage *image,
+                                          int           *border_top,
+                                          int           *border_right,
+                                          int           *border_bottom,
+                                          int           *border_left);
+
+G_END_DECLS
+
+#endif /* __ST_BORDER_IMAGE_H__ */

src/st/st-box-layout-child.c

@@ -0,0 +1,190 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+/*
+ * st-box-layout-child.c: box layout child actor
+ *
+ * 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.
+ *
+ * Written by: Thomas Wood <thomas.wood@intel.com>
+ */
+
+/**
+ * SECTION:st-box-layout-child
+ * @short_description: meta data associated with a #StBoxLayout child.
+ *
+ * #StBoxLayoutChild is a #ClutterChildMeta implementation that stores the
+ * child properties for children inside a #StBoxLayout.
+ */
+
+#include "st-box-layout-child.h"
+#include "st-private.h"
+
+G_DEFINE_TYPE (StBoxLayoutChild, st_box_layout_child, CLUTTER_TYPE_CHILD_META)
+
+#define BOX_LAYOUT_CHILD_PRIVATE(o) \
+  (G_TYPE_INSTANCE_GET_PRIVATE ((o), ST_TYPE_BOX_LAYOUT_CHILD, StBoxLayoutChildPrivate))
+
+
+enum
+{
+  PROP_0,
+
+  PROP_EXPAND,
+  PROP_X_FILL,
+  PROP_Y_FILL,
+  PROP_X_ALIGN,
+  PROP_Y_ALIGN
+};
+
+static void
+st_box_layout_child_get_property (GObject    *object,
+                                  guint       property_id,
+                                  GValue     *value,
+                                  GParamSpec *pspec)
+{
+  StBoxLayoutChild *child = ST_BOX_LAYOUT_CHILD (object);
+
+  switch (property_id)
+    {
+    case PROP_EXPAND:
+      g_value_set_boolean (value, child->expand);
+      break;
+    case PROP_X_FILL:
+      g_value_set_boolean (value, child->x_fill);
+      break;
+    case PROP_Y_FILL:
+      g_value_set_boolean (value, child->y_fill);
+      break;
+    case PROP_X_ALIGN:
+      g_value_set_enum (value, child->x_align);
+      break;
+    case PROP_Y_ALIGN:
+      g_value_set_enum (value, child->y_align);
+      break;
+
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
+    }
+}
+
+static void
+st_box_layout_child_set_property (GObject      *object,
+                                  guint         property_id,
+                                  const GValue *value,
+                                  GParamSpec   *pspec)
+{
+  StBoxLayoutChild *child = ST_BOX_LAYOUT_CHILD (object);
+  StBoxLayout *box = ST_BOX_LAYOUT (CLUTTER_CHILD_META (object)->container);
+
+  switch (property_id)
+    {
+    case PROP_EXPAND:
+      child->expand = g_value_get_boolean (value);
+      break;
+    case PROP_X_FILL:
+      child->x_fill = g_value_get_boolean (value);
+      break;
+    case PROP_Y_FILL:
+      child->y_fill = g_value_get_boolean (value);
+      break;
+    case PROP_X_ALIGN:
+      child->x_align = g_value_get_enum (value);
+      break;
+    case PROP_Y_ALIGN:
+      child->y_align = g_value_get_enum (value);
+      break;
+
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
+    }
+
+  clutter_actor_queue_relayout ((ClutterActor*) box);
+}
+
+static void
+st_box_layout_child_dispose (GObject *object)
+{
+  G_OBJECT_CLASS (st_box_layout_child_parent_class)->dispose (object);
+}
+
+static void
+st_box_layout_child_finalize (GObject *object)
+{
+  G_OBJECT_CLASS (st_box_layout_child_parent_class)->finalize (object);
+}
+
+static void
+st_box_layout_child_class_init (StBoxLayoutChildClass *klass)
+{
+  GObjectClass *object_class = G_OBJECT_CLASS (klass);
+  GParamSpec *pspec;
+
+  object_class->get_property = st_box_layout_child_get_property;
+  object_class->set_property = st_box_layout_child_set_property;
+  object_class->dispose = st_box_layout_child_dispose;
+  object_class->finalize = st_box_layout_child_finalize;
+
+
+  pspec = g_param_spec_boolean ("expand", "Expand",
+                                "Allocate the child extra space",
+                                FALSE,
+                                ST_PARAM_READWRITE);
+  g_object_class_install_property (object_class, PROP_EXPAND, pspec);
+
+  pspec = g_param_spec_boolean ("x-fill", "x-fill",
+                                "Whether the child should receive priority "
+                                "when the container is allocating spare space "
+                                "on the horizontal axis",
+                                TRUE,
+                                ST_PARAM_READWRITE);
+  g_object_class_install_property (object_class, PROP_X_FILL, pspec);
+
+  pspec = g_param_spec_boolean ("y-fill", "y-fill",
+                                "Whether the child should receive priority "
+                                "when the container is allocating spare space "
+                                "on the vertical axis",
+                                TRUE,
+                                ST_PARAM_READWRITE);
+  g_object_class_install_property (object_class, PROP_Y_FILL, pspec);
+
+  pspec = g_param_spec_enum ("x-align",
+                             "X Alignment",
+                             "X alignment of the widget within the cell",
+                             ST_TYPE_ALIGN,
+                             ST_ALIGN_MIDDLE,
+                             ST_PARAM_READWRITE);
+  g_object_class_install_property (object_class, PROP_X_ALIGN, pspec);
+
+  pspec = g_param_spec_enum ("y-align",
+                             "Y Alignment",
+                             "Y alignment of the widget within the cell",
+                             ST_TYPE_ALIGN,
+                             ST_ALIGN_MIDDLE,
+                             ST_PARAM_READWRITE);
+  g_object_class_install_property (object_class, PROP_Y_ALIGN, pspec);
+}
+
+static void
+st_box_layout_child_init (StBoxLayoutChild *self)
+{
+  self->expand = FALSE;
+
+  self->x_fill = TRUE;
+  self->y_fill = TRUE;
+
+  self->x_align = ST_ALIGN_MIDDLE;
+  self->y_align = ST_ALIGN_MIDDLE;
+}
+

src/st/st-box-layout-child.h

@@ -0,0 +1,85 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+/*
+ * st-box-layout-child.h: box layout child actor
+ *
+ * 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.
+ *
+ * Written by: Thomas Wood <thomas.wood@intel.com>
+ */
+
+#ifndef _ST_BOX_LAYOUT_CHILD_H
+#define _ST_BOX_LAYOUT_CHILD_H
+
+#include <clutter/clutter.h>
+#include "st-enum-types.h"
+#include "st-box-layout.h"
+
+G_BEGIN_DECLS
+
+#define ST_TYPE_BOX_LAYOUT_CHILD st_box_layout_child_get_type()
+
+#define ST_BOX_LAYOUT_CHILD(obj) \
+  (G_TYPE_CHECK_INSTANCE_CAST ((obj), \
+  ST_TYPE_BOX_LAYOUT_CHILD, StBoxLayoutChild))
+
+#define ST_BOX_LAYOUT_CHILD_CLASS(klass) \
+  (G_TYPE_CHECK_CLASS_CAST ((klass), \
+  ST_TYPE_BOX_LAYOUT_CHILD, StBoxLayoutChildClass))
+
+#define ST_IS_BOX_LAYOUT_CHILD(obj) \
+  (G_TYPE_CHECK_INSTANCE_TYPE ((obj), \
+  ST_TYPE_BOX_LAYOUT_CHILD))
+
+#define ST_IS_BOX_LAYOUT_CHILD_CLASS(klass) \
+  (G_TYPE_CHECK_CLASS_TYPE ((klass), \
+  ST_TYPE_BOX_LAYOUT_CHILD))
+
+#define ST_BOX_LAYOUT_CHILD_GET_CLASS(obj) \
+  (G_TYPE_INSTANCE_GET_CLASS ((obj), \
+  ST_TYPE_BOX_LAYOUT_CHILD, StBoxLayoutChildClass))
+
+typedef struct _StBoxLayoutChild StBoxLayoutChild;
+typedef struct _StBoxLayoutChildClass StBoxLayoutChildClass;
+typedef struct _StBoxLayoutChildPrivate StBoxLayoutChildPrivate;
+
+/**
+ * StBoxLayoutChild:
+ *
+ * The contents of this structure are private and should only be accessed
+ * through the public API.
+ */
+struct _StBoxLayoutChild
+{
+  /*< private >*/
+  ClutterChildMeta parent;
+
+  gboolean expand;
+  gboolean x_fill : 1;
+  gboolean y_fill : 1;
+  StAlign x_align;
+  StAlign y_align;
+};
+
+struct _StBoxLayoutChildClass
+{
+  ClutterChildMetaClass parent_class;
+};
+
+GType st_box_layout_child_get_type (void);
+
+G_END_DECLS
+
+#endif /* _ST_BOX_LAYOUT_CHILD_H */

src/st/st-box-layout.h

@@ -0,0 +1,94 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+/*
+ * st-box-layout.h: box layout actor
+ *
+ * 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.
+ *
+ * Written by: Thomas Wood <thomas.wood@intel.com>
+ *
+ */
+
+#if !defined(ST_H_INSIDE) && !defined(ST_COMPILATION)
+#error "Only <st/st.h> can be included directly.h"
+#endif
+
+#ifndef _ST_BOX_LAYOUT_H
+#define _ST_BOX_LAYOUT_H
+
+#include <st/st-widget.h>
+
+G_BEGIN_DECLS
+
+#define ST_TYPE_BOX_LAYOUT st_box_layout_get_type()
+
+#define ST_BOX_LAYOUT(obj) \
+  (G_TYPE_CHECK_INSTANCE_CAST ((obj), \
+  ST_TYPE_BOX_LAYOUT, StBoxLayout))
+
+#define ST_BOX_LAYOUT_CLASS(klass) \
+  (G_TYPE_CHECK_CLASS_CAST ((klass), \
+  ST_TYPE_BOX_LAYOUT, StBoxLayoutClass))
+
+#define ST_IS_BOX_LAYOUT(obj) \
+  (G_TYPE_CHECK_INSTANCE_TYPE ((obj), \
+  ST_TYPE_BOX_LAYOUT))
+
+#define ST_IS_BOX_LAYOUT_CLASS(klass) \
+  (G_TYPE_CHECK_CLASS_TYPE ((klass), \
+  ST_TYPE_BOX_LAYOUT))
+
+#define ST_BOX_LAYOUT_GET_CLASS(obj) \
+  (G_TYPE_INSTANCE_GET_CLASS ((obj), \
+  ST_TYPE_BOX_LAYOUT, StBoxLayoutClass))
+
+typedef struct _StBoxLayout StBoxLayout;
+typedef struct _StBoxLayoutClass StBoxLayoutClass;
+typedef struct _StBoxLayoutPrivate StBoxLayoutPrivate;
+
+/**
+ * StBoxLayout:
+ *
+ * The contents of this structure are private and should only be accessed
+ * through the public API.
+ */
+struct _StBoxLayout
+{
+  /*< private >*/
+  StWidget parent;
+
+  StBoxLayoutPrivate *priv;
+};
+
+struct _StBoxLayoutClass
+{
+  StWidgetClass parent_class;
+};
+
+GType st_box_layout_get_type (void);
+
+StWidget *st_box_layout_new (void);
+
+void     st_box_layout_set_vertical   (StBoxLayout *box,
+                                       gboolean     vertical);
+gboolean st_box_layout_get_vertical   (StBoxLayout *box);
+
+void     st_box_layout_set_pack_start (StBoxLayout *box,
+                                       gboolean     pack_start);
+gboolean st_box_layout_get_pack_start (StBoxLayout *box);
+
+G_END_DECLS
+
+#endif /* _ST_BOX_LAYOUT_H */

src/st/st-button.c

@@ -0,0 +1,692 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+/*
+ * st-button.c: Plain button actor
+ *
+ * Copyright 2007 OpenedHand
+ * Copyright 2008, 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.
+ *
+ * Written by: Emmanuele Bassi <ebassi@openedhand.com>
+ *             Thomas Wood <thomas@linux.intel.com>
+ *
+ */
+
+/**
+ * SECTION:st-button
+ * @short_description: Button widget
+ *
+ * A button widget with support for either a text label or icon, toggle mode
+ * and transitions effects between states.
+ */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include <stdlib.h>
+#include <string.h>
+
+#include <glib.h>
+
+#include <clutter/clutter.h>
+
+#include "st-button.h"
+
+#include "st-marshal.h"
+#include "st-texture-frame.h"
+#include "st-texture-cache.h"
+#include "st-private.h"
+
+enum
+{
+  PROP_0,
+
+  PROP_LABEL,
+  PROP_TOGGLE_MODE,
+  PROP_CHECKED,
+  PROP_TRANSITION_DURATION
+};
+
+enum
+{
+  CLICKED,
+
+  LAST_SIGNAL
+};
+
+#define ST_BUTTON_GET_PRIVATE(obj)    \
+  (G_TYPE_INSTANCE_GET_PRIVATE ((obj), ST_TYPE_BUTTON, StButtonPrivate))
+
+struct _StButtonPrivate
+{
+  gchar            *text;
+
+  ClutterActor     *old_bg;
+  gboolean          old_bg_parented; /* TRUE if we have adopted old_bg */
+
+  guint8            old_opacity;
+
+  guint             is_pressed : 1;
+  guint             is_hover : 1;
+  guint             is_checked : 1;
+  guint             is_toggle : 1;
+
+  gint              transition_duration;
+
+  ClutterAnimation *animation;
+
+  gint              spacing;
+};
+
+static guint button_signals[LAST_SIGNAL] = { 0, };
+
+G_DEFINE_TYPE (StButton, st_button, ST_TYPE_BIN);
+
+static void
+st_button_update_label_style (StButton *button)
+{
+  ClutterActor *label;
+  StThemeNode *theme_node;
+  ClutterColor color;
+  const PangoFontDescription *font;
+  gchar *font_string = NULL;
+
+  label = st_bin_get_child ((StBin*) button);
+
+  /* check the child is really a label */
+  if (!CLUTTER_IS_TEXT (label))
+    return;
+
+  theme_node = st_widget_get_theme_node (ST_WIDGET (button));
+
+  st_theme_node_get_foreground_color (theme_node, &color);
+  clutter_text_set_color (CLUTTER_TEXT (label), &color);
+
+  font = st_theme_node_get_font (theme_node);
+  font_string = pango_font_description_to_string (font);
+  clutter_text_set_font_name (CLUTTER_TEXT (label), font_string);
+  g_free (font_string);
+}
+
+static void
+st_button_dispose_old_bg (StButton *button)
+{
+  StButtonPrivate *priv = button->priv;
+
+  if (priv->old_bg)
+    {
+      if (priv->old_bg_parented)
+        {
+          clutter_actor_unparent (priv->old_bg);
+          priv->old_bg_parented = FALSE;
+        }
+      g_object_unref (priv->old_bg);
+      priv->old_bg = NULL;
+    }
+}
+
+static void
+st_animation_completed (ClutterAnimation *animation,
+                        StButton         *button)
+{
+  st_button_dispose_old_bg (button);
+}
+
+static void
+st_button_style_changed (StWidget *widget)
+{
+  StButton *button = ST_BUTTON (widget);
+  StButtonPrivate *priv = button->priv;
+  StButtonClass *button_class = ST_BUTTON_GET_CLASS (button);
+  StThemeNode *theme_node = st_widget_get_theme_node (ST_WIDGET (button));
+  ClutterActor *bg_image;
+  double spacing;
+
+  st_button_dispose_old_bg (button);
+
+  bg_image = st_widget_get_border_image ((StWidget*) button);
+  if (bg_image)
+    button->priv->old_bg = g_object_ref (bg_image);
+
+  ST_WIDGET_CLASS (st_button_parent_class)->style_changed (widget);
+
+  spacing = 6;
+  st_theme_node_get_length (theme_node, "border-spacing", FALSE, &spacing);
+  priv->spacing = (int)(0.5 + spacing);
+
+  /* update the label styling */
+  st_button_update_label_style (button);
+
+  /* run a transition if applicable */
+  if (button_class->transition)
+    {
+      button_class->transition (button, priv->old_bg);
+    }
+  else
+    {
+      if (priv->old_bg &&
+          (!st_widget_get_style_pseudo_class (widget)))
+        {
+          ClutterAnimation *animation;
+          if (!clutter_actor_get_parent (priv->old_bg))
+            {
+              clutter_actor_set_parent (priv->old_bg, (ClutterActor*) widget);
+              priv->old_bg_parented = TRUE;
+            }
+          if (priv->transition_duration > 0)
+            {
+              animation = clutter_actor_animate (priv->old_bg,
+                                                 CLUTTER_LINEAR,
+                                                 priv->transition_duration,
+                                                 "opacity", 0,
+                                                 NULL);
+              g_signal_connect (animation, "completed",
+                                G_CALLBACK (st_animation_completed), button);
+            }
+          else
+            {
+              st_button_dispose_old_bg (button);
+            }
+
+        }
+    }
+}
+
+static void
+st_button_real_pressed (StButton *button)
+{
+  st_widget_set_style_pseudo_class ((StWidget*) button, "active");
+}
+
+static void
+st_button_real_released (StButton *button)
+{
+  StButtonPrivate *priv = button->priv;
+
+  if (priv->is_checked)
+    st_widget_set_style_pseudo_class ((StWidget*) button, "checked");
+  else if (!priv->is_hover)
+    st_widget_set_style_pseudo_class ((StWidget*) button, NULL);
+  else
+    st_widget_set_style_pseudo_class ((StWidget*) button, "hover");
+
+}
+
+static gboolean
+st_button_button_press (ClutterActor       *actor,
+                        ClutterButtonEvent *event)
+{
+  st_widget_hide_tooltip (ST_WIDGET (actor));
+
+  if (event->button == 1)
+    {
+      StButton *button = ST_BUTTON (actor);
+      StButtonClass *klass = ST_BUTTON_GET_CLASS (button);
+
+      button->priv->is_pressed = TRUE;
+
+      clutter_grab_pointer (actor);
+
+      if (klass->pressed)
+        klass->pressed (button);
+
+      return TRUE;
+    }
+
+  return FALSE;
+}
+
+static gboolean
+st_button_button_release (ClutterActor       *actor,
+                          ClutterButtonEvent *event)
+{
+  if (event->button == 1)
+    {
+      StButton *button = ST_BUTTON (actor);
+      StButtonClass *klass = ST_BUTTON_GET_CLASS (button);
+
+      if (!button->priv->is_pressed)
+        return FALSE;
+
+      clutter_ungrab_pointer ();
+
+      if (button->priv->is_toggle)
+        {
+          st_button_set_checked (button, !button->priv->is_checked);
+        }
+
+      button->priv->is_pressed = FALSE;
+
+      if (klass->released)
+        klass->released (button);
+
+      g_signal_emit (button, button_signals[CLICKED], 0);
+
+      return TRUE;
+    }
+
+  return FALSE;
+}
+
+static gboolean
+st_button_enter (ClutterActor         *actor,
+                 ClutterCrossingEvent *event)
+{
+  StButton *button = ST_BUTTON (actor);
+
+  if (!button->priv->is_checked)
+    st_widget_set_style_pseudo_class ((StWidget*) button, "hover");
+
+  button->priv->is_hover = 1;
+
+  return CLUTTER_ACTOR_CLASS (st_button_parent_class)->enter_event (actor, event);
+}
+
+static gboolean
+st_button_leave (ClutterActor         *actor,
+                 ClutterCrossingEvent *event)
+{
+  StButton *button = ST_BUTTON (actor);
+
+  button->priv->is_hover = 0;
+
+  if (button->priv->is_pressed)
+    {
+      StButtonClass *klass = ST_BUTTON_GET_CLASS (button);
+
+      clutter_ungrab_pointer ();
+
+      button->priv->is_pressed = FALSE;
+
+      if (klass->released)
+        klass->released (button);
+    }
+
+  if (button->priv->is_checked)
+    st_widget_set_style_pseudo_class ((StWidget*) button, "checked");
+  else
+    st_widget_set_style_pseudo_class ((StWidget*) button, NULL);
+
+  return CLUTTER_ACTOR_CLASS (st_button_parent_class)->leave_event (actor, event);
+}
+
+static void
+st_button_set_property (GObject      *gobject,
+                        guint         prop_id,
+                        const GValue *value,
+                        GParamSpec   *pspec)
+{
+  StButton *button = ST_BUTTON (gobject);
+  StButtonPrivate *priv = ST_BUTTON (gobject)->priv;
+
+  switch (prop_id)
+    {
+    case PROP_LABEL:
+      st_button_set_label (button, g_value_get_string (value));
+      break;
+    case PROP_TOGGLE_MODE:
+      st_button_set_toggle_mode (button, g_value_get_boolean (value));
+      break;
+    case PROP_CHECKED:
+      st_button_set_checked (button, g_value_get_boolean (value));
+      break;
+    case PROP_TRANSITION_DURATION:
+      priv->transition_duration = g_value_get_int (value);
+      break;
+
+
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (gobject, prop_id, pspec);
+      break;
+    }
+}
+
+static void
+st_button_get_property (GObject    *gobject,
+                        guint       prop_id,
+                        GValue     *value,
+                        GParamSpec *pspec)
+{
+  StButtonPrivate *priv = ST_BUTTON (gobject)->priv;
+
+  switch (prop_id)
+    {
+    case PROP_LABEL:
+      g_value_set_string (value, priv->text);
+      break;
+    case PROP_TOGGLE_MODE:
+      g_value_set_boolean (value, priv->is_toggle);
+      break;
+    case PROP_CHECKED:
+      g_value_set_boolean (value, priv->is_checked);
+      break;
+    case PROP_TRANSITION_DURATION:
+      g_value_set_int (value, priv->transition_duration);
+      break;
+
+
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (gobject, prop_id, pspec);
+      break;
+    }
+}
+
+static void
+st_button_finalize (GObject *gobject)
+{
+  StButtonPrivate *priv = ST_BUTTON (gobject)->priv;
+
+  g_free (priv->text);
+
+  G_OBJECT_CLASS (st_button_parent_class)->finalize (gobject);
+}
+
+static void
+st_button_dispose (GObject *gobject)
+{
+  st_button_dispose_old_bg (ST_BUTTON (gobject));
+
+  G_OBJECT_CLASS (st_button_parent_class)->dispose (gobject);
+}
+
+static void
+st_button_map (ClutterActor *self)
+{
+  StButtonPrivate *priv = ST_BUTTON (self)->priv;
+
+  CLUTTER_ACTOR_CLASS (st_button_parent_class)->map (self);
+
+  if (priv->old_bg && priv->old_bg_parented)
+    clutter_actor_map (priv->old_bg);
+}
+
+static void
+st_button_unmap (ClutterActor *self)
+{
+  StButtonPrivate *priv = ST_BUTTON (self)->priv;
+
+  CLUTTER_ACTOR_CLASS (st_button_parent_class)->unmap (self);
+
+  if (priv->old_bg && priv->old_bg_parented)
+    clutter_actor_unmap (priv->old_bg);
+}
+
+static void
+st_button_draw_background (StWidget         *widget)
+{
+  StButtonPrivate *priv;
+
+  ST_WIDGET_CLASS (st_button_parent_class)->draw_background (widget);
+
+  priv = ST_BUTTON (widget)->priv;
+
+  if (priv->old_bg && priv->old_bg_parented)
+    clutter_actor_paint (priv->old_bg);
+}
+
+static void
+st_button_class_init (StButtonClass *klass)
+{
+  GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
+  ClutterActorClass *actor_class = CLUTTER_ACTOR_CLASS (klass);
+  StWidgetClass *widget_class = ST_WIDGET_CLASS (klass);
+  GParamSpec *pspec;
+
+  g_type_class_add_private (klass, sizeof (StButtonPrivate));
+
+  klass->pressed = st_button_real_pressed;
+  klass->released = st_button_real_released;
+
+  gobject_class->set_property = st_button_set_property;
+  gobject_class->get_property = st_button_get_property;
+  gobject_class->dispose = st_button_dispose;
+  gobject_class->finalize = st_button_finalize;
+
+  actor_class->button_press_event = st_button_button_press;
+  actor_class->button_release_event = st_button_button_release;
+  actor_class->enter_event = st_button_enter;
+  actor_class->leave_event = st_button_leave;
+
+  actor_class->map = st_button_map;
+  actor_class->unmap = st_button_unmap;
+
+  widget_class->draw_background = st_button_draw_background;
+  widget_class->style_changed = st_button_style_changed;
+
+  pspec = g_param_spec_string ("label",
+                               "Label",
+                               "Label of the button",
+                               NULL, G_PARAM_READWRITE);
+  g_object_class_install_property (gobject_class, PROP_LABEL, pspec);
+
+  pspec = g_param_spec_boolean ("toggle-mode",
+                                "Toggle Mode",
+                                "Enable or disable toggling",
+                                FALSE, G_PARAM_READWRITE);
+  g_object_class_install_property (gobject_class, PROP_TOGGLE_MODE, pspec);
+
+  pspec = g_param_spec_boolean ("checked",
+                                "Checked",
+                                "Indicates if a toggle button is \"on\""
+                                " or \"off\"",
+                                FALSE, G_PARAM_READWRITE);
+  g_object_class_install_property (gobject_class, PROP_CHECKED, pspec);
+
+  pspec = g_param_spec_int ("transition-duration",
+                            "Transition Duration",
+                            "Duration of the state transition effect",
+                            0, G_MAXINT, 120, G_PARAM_READWRITE);
+  g_object_class_install_property (gobject_class, PROP_TRANSITION_DURATION, pspec);
+
+
+  /**
+   * StButton::clicked:
+   * @button: the object that received the signal
+   *
+   * Emitted when the user activates the button, either with a mouse press and
+   * release or with the keyboard.
+   */
+
+  button_signals[CLICKED] =
+    g_signal_new ("clicked",
+                  G_TYPE_FROM_CLASS (klass),
+                  G_SIGNAL_RUN_LAST,
+                  G_STRUCT_OFFSET (StButtonClass, clicked),
+                  NULL, NULL,
+                  _st_marshal_VOID__VOID,
+                  G_TYPE_NONE, 0);
+}
+
+static void
+st_button_init (StButton *button)
+{
+  button->priv = ST_BUTTON_GET_PRIVATE (button);
+  button->priv->transition_duration = 120;
+  button->priv->spacing = 6;
+
+  clutter_actor_set_reactive ((ClutterActor *) button, TRUE);
+}
+
+/**
+ * st_button_new:
+ *
+ * Create a new button
+ *
+ * Returns: a new #StButton
+ */
+StWidget *
+st_button_new (void)
+{
+  return g_object_new (ST_TYPE_BUTTON, NULL);
+}
+
+/**
+ * st_button_new_with_label:
+ * @text: text to set the label to
+ *
+ * Create a new #StButton with the specified label
+ *
+ * Returns: a new #StButton
+ */
+StWidget *
+st_button_new_with_label (const gchar *text)
+{
+  return g_object_new (ST_TYPE_BUTTON, "label", text, NULL);
+}
+
+/**
+ * st_button_get_label:
+ * @button: a #StButton
+ *
+ * Get the text displayed on the button
+ *
+ * Returns: the text for the button. This must not be freed by the application
+ */
+G_CONST_RETURN gchar *
+st_button_get_label (StButton *button)
+{
+  g_return_val_if_fail (ST_IS_BUTTON (button), NULL);
+
+  return button->priv->text;
+}
+
+/**
+ * st_button_set_label:
+ * @button: a #Stbutton
+ * @text: text to set the label to
+ *
+ * Sets the text displayed on the button
+ */
+void
+st_button_set_label (StButton    *button,
+                     const gchar *text)
+{
+  StButtonPrivate *priv;
+  ClutterActor *label;
+
+  g_return_if_fail (ST_IS_BUTTON (button));
+
+  priv = button->priv;
+
+  g_free (priv->text);
+
+  if (text)
+    priv->text = g_strdup (text);
+  else
+    priv->text = g_strdup ("");
+
+  label = st_bin_get_child ((StBin*) button);
+
+  if (label && CLUTTER_IS_TEXT (label))
+    {
+      clutter_text_set_text (CLUTTER_TEXT (label), priv->text);
+    }
+  else
+    {
+      label = g_object_new (CLUTTER_TYPE_TEXT,
+                            "text", priv->text,
+                            "line-alignment", PANGO_ALIGN_CENTER,
+                            "ellipsize", PANGO_ELLIPSIZE_END,
+                            "use-markup", TRUE,
+                            NULL);
+      st_bin_set_child ((StBin*) button, label);
+    }
+
+  /* Fake a style change so that we reset the style properties on the label */
+  st_widget_style_changed (ST_WIDGET (button));
+
+  g_object_notify (G_OBJECT (button), "label");
+}
+
+/**
+ * st_button_get_toggle_mode:
+ * @button: a #StButton
+ *
+ * Get the toggle mode status of the button.
+ *
+ * Returns: #TRUE if toggle mode is set, otherwise #FALSE
+ */
+gboolean
+st_button_get_toggle_mode (StButton *button)
+{
+  g_return_val_if_fail (ST_IS_BUTTON (button), FALSE);
+
+  return button->priv->is_toggle;
+}
+
+/**
+ * st_button_set_toggle_mode:
+ * @button: a #Stbutton
+ * @toggle: #TRUE or #FALSE
+ *
+ * Enables or disables toggle mode for the button. In toggle mode, the active
+ * state will be "toggled" when the user clicks the button.
+ */
+void
+st_button_set_toggle_mode (StButton *button,
+                           gboolean  toggle)
+{
+  g_return_if_fail (ST_IS_BUTTON (button));
+
+  button->priv->is_toggle = toggle;
+
+  g_object_notify (G_OBJECT (button), "toggle-mode");
+}
+
+/**
+ * st_button_get_checked:
+ * @button: a #StButton
+ *
+ * Get the state of the button that is in toggle mode.
+ *
+ * Returns: #TRUE if the button is checked, or #FALSE if not
+ */
+gboolean
+st_button_get_checked (StButton *button)
+{
+  g_return_val_if_fail (ST_IS_BUTTON (button), FALSE);
+
+  return button->priv->is_checked;
+}
+
+/**
+ * st_button_set_checked:
+ * @button: a #Stbutton
+ * @checked: #TRUE or #FALSE
+ *
+ * Sets the pressed state of the button. This is only really useful if the
+ * button has #toggle-mode mode set to #TRUE.
+ */
+void
+st_button_set_checked (StButton *button,
+                       gboolean  checked)
+{
+  g_return_if_fail (ST_IS_BUTTON (button));
+
+  if (button->priv->is_checked != checked)
+    {
+      button->priv->is_checked = checked;
+
+      if (checked)
+        st_widget_set_style_pseudo_class ((StWidget*) button, "checked");
+      else
+      if (button->priv->is_hover)
+        st_widget_set_style_pseudo_class ((StWidget*) button, "hover");
+      else
+        st_widget_set_style_pseudo_class ((StWidget*) button, NULL);
+    }
+
+  g_object_notify (G_OBJECT (button), "checked");
+}

src/st/st-button.h

@@ -0,0 +1,94 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+/*
+ * st-button.h: Plain button actor
+ *
+ * Copyright 2007 OpenedHand
+ * Copyright 2008, 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.
+ * Boston, MA 02111-1307, USA.
+ *
+ * Written by: Emmanuele Bassi <ebassi@openedhand.com>
+ *             Thomas Wood <thomas@linux.intel.com>
+ *
+ */
+
+#if !defined(ST_H_INSIDE) && !defined(ST_COMPILATION)
+#error "Only <st/st.h> can be included directly.h"
+#endif
+
+#ifndef __ST_BUTTON_H__
+#define __ST_BUTTON_H__
+
+G_BEGIN_DECLS
+
+#include <st/st-bin.h>
+
+#define ST_TYPE_BUTTON                (st_button_get_type ())
+#define ST_BUTTON(obj)                (G_TYPE_CHECK_INSTANCE_CAST ((obj), ST_TYPE_BUTTON, StButton))
+#define ST_IS_BUTTON(obj)             (G_TYPE_CHECK_INSTANCE_TYPE ((obj), ST_TYPE_BUTTON))
+#define ST_BUTTON_CLASS(klass)        (G_TYPE_CHECK_CLASS_CAST ((klass), ST_TYPE_BUTTON, StButtonClass))
+#define ST_IS_BUTTON_CLASS(klass)     (G_TYPE_CHECK_CLASS_TYPE ((klass), ST_TYPE_BUTTON))
+#define ST_BUTTON_GET_CLASS(obj)      (G_TYPE_INSTANCE_GET_CLASS ((obj), ST_TYPE_BUTTON, StButtonClass))
+
+typedef struct _StButton              StButton;
+typedef struct _StButtonPrivate       StButtonPrivate;
+typedef struct _StButtonClass         StButtonClass;
+
+/**
+ * StButton:
+ *
+ * The contents of this structure is private and should only be accessed using
+ * the provided API.
+ */
+
+struct _StButton
+{
+  /*< private >*/
+  StBin parent_instance;
+
+  StButtonPrivate *priv;
+};
+
+struct _StButtonClass
+{
+  StBinClass parent_class;
+
+  /* vfuncs, not signals */
+  void (* pressed)    (StButton     *button);
+  void (* released)   (StButton     *button);
+  void (* transition) (StButton     *button,
+                       ClutterActor *old_bg);
+
+  /* signals */
+  void (* clicked) (StButton *button);
+};
+
+GType st_button_get_type (void) G_GNUC_CONST;
+
+StWidget *            st_button_new             (void);
+StWidget *            st_button_new_with_label  (const gchar *text);
+G_CONST_RETURN gchar *st_button_get_label       (StButton    *button);
+void                  st_button_set_label       (StButton    *button,
+                                                 const gchar *text);
+void                  st_button_set_toggle_mode (StButton    *button,
+                                                 gboolean     toggle);
+gboolean              st_button_get_toggle_mode (StButton    *button);
+void                  st_button_set_checked     (StButton    *button,
+                                                 gboolean     checked);
+gboolean              st_button_get_checked     (StButton    *button);
+
+G_END_DECLS
+
+#endif /* __ST_BUTTON_H__ */

src/st/st-clipboard.c

@@ -0,0 +1,381 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+/*
+ * st-clipboard.c: clipboard object
+ *
+ * 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.
+ *
+ * Written by: Thomas Wood <thomas.wood@intel.com>
+ *
+ */
+
+/**
+ * SECTION:st-clipboard
+ * @short_description: a simple representation of the X clipboard
+ *
+ * #StCliboard is a very simple object representation of the clipboard
+ * available to applications. Text is always assumed to be UTF-8 and non-text
+ * items are not handled.
+ */
+
+
+#include "st-clipboard.h"
+#include <X11/Xlib.h>
+#include <X11/Xatom.h>
+#include <clutter/x11/clutter-x11.h>
+#include <string.h>
+
+G_DEFINE_TYPE (StClipboard, st_clipboard, G_TYPE_OBJECT)
+
+#define CLIPBOARD_PRIVATE(o) \
+  (G_TYPE_INSTANCE_GET_PRIVATE ((o), ST_TYPE_CLIPBOARD, StClipboardPrivate))
+
+struct _StClipboardPrivate
+{
+  Window clipboard_window;
+  gchar *clipboard_text;
+
+  Atom  *supported_targets;
+  gint   n_targets;
+};
+
+typedef struct _EventFilterData EventFilterData;
+struct _EventFilterData
+{
+  StClipboard            *clipboard;
+  StClipboardCallbackFunc callback;
+  gpointer                user_data;
+};
+
+static Atom __atom_clip = None;
+static Atom __utf8_string = None;
+static Atom __atom_targets = None;
+
+static void
+st_clipboard_get_property (GObject    *object,
+                           guint       property_id,
+                           GValue     *value,
+                           GParamSpec *pspec)
+{
+  switch (property_id)
+    {
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
+    }
+}
+
+static void
+st_clipboard_set_property (GObject      *object,
+                           guint         property_id,
+                           const GValue *value,
+                           GParamSpec   *pspec)
+{
+  switch (property_id)
+    {
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
+    }
+}
+
+static void
+st_clipboard_dispose (GObject *object)
+{
+  G_OBJECT_CLASS (st_clipboard_parent_class)->dispose (object);
+}
+
+static void
+st_clipboard_finalize (GObject *object)
+{
+  StClipboardPrivate *priv = ((StClipboard *) object)->priv;
+
+  g_free (priv->clipboard_text);
+  priv->clipboard_text = NULL;
+
+  g_free (priv->supported_targets);
+  priv->supported_targets = NULL;
+  priv->n_targets = 0;
+
+  G_OBJECT_CLASS (st_clipboard_parent_class)->finalize (object);
+}
+
+static ClutterX11FilterReturn
+st_clipboard_provider (XEvent       *xev,
+                       ClutterEvent *cev,
+                       StClipboard  *clipboard)
+{
+  XSelectionEvent notify_event;
+  XSelectionRequestEvent *req_event;
+
+  if (xev->type != SelectionRequest)
+    return CLUTTER_X11_FILTER_CONTINUE;
+
+  req_event = &xev->xselectionrequest;
+
+  clutter_x11_trap_x_errors ();
+
+  if (req_event->target == __atom_targets)
+    {
+      XChangeProperty (req_event->display,
+                       req_event->requestor,
+                       req_event->property,
+                       XA_ATOM,
+                       32,
+                       PropModeReplace,
+                       (guchar*) clipboard->priv->supported_targets,
+                       clipboard->priv->n_targets);
+    }
+  else
+    {
+      XChangeProperty (req_event->display,
+                       req_event->requestor,
+                       req_event->property,
+                       req_event->target,
+                       8,
+                       PropModeReplace,
+                       (guchar*) clipboard->priv->clipboard_text,
+                       strlen (clipboard->priv->clipboard_text));
+    }
+
+  notify_event.type = SelectionNotify;
+  notify_event.display = req_event->display;
+  notify_event.requestor = req_event->requestor;
+  notify_event.selection = req_event->selection;
+  notify_event.target = req_event->target;
+  notify_event.time = req_event->time;
+
+  if (req_event->property == None)
+    notify_event.property = req_event->target;
+  else
+    notify_event.property = req_event->property;
+
+  /* notify the requestor that they have a copy of the selection */
+  XSendEvent (req_event->display, req_event->requestor, False, 0,
+              (XEvent *) &notify_event);
+  /* Make it happen non async */
+  XSync (clutter_x11_get_default_display(), FALSE);
+
+  clutter_x11_untrap_x_errors (); /* FIXME: Warn here on fail ? */
+
+  return CLUTTER_X11_FILTER_REMOVE;
+}
+
+
+static void
+st_clipboard_class_init (StClipboardClass *klass)
+{
+  GObjectClass *object_class = G_OBJECT_CLASS (klass);
+
+  g_type_class_add_private (klass, sizeof (StClipboardPrivate));
+
+  object_class->get_property = st_clipboard_get_property;
+  object_class->set_property = st_clipboard_set_property;
+  object_class->dispose = st_clipboard_dispose;
+  object_class->finalize = st_clipboard_finalize;
+}
+
+static void
+st_clipboard_init (StClipboard *self)
+{
+  Display *dpy;
+  StClipboardPrivate *priv;
+
+  priv = self->priv = CLIPBOARD_PRIVATE (self);
+
+  priv->clipboard_window =
+    XCreateSimpleWindow (clutter_x11_get_default_display (),
+                         clutter_x11_get_root_window (),
+                         -1, -1, 1, 1, 0, 0, 0);
+
+  dpy = clutter_x11_get_default_display ();
+
+  /* Only create once */
+  if (__atom_clip == None)
+    __atom_clip = XInternAtom (dpy, "CLIPBOARD", 0);
+
+  if (__utf8_string == None)
+    __utf8_string = XInternAtom (dpy, "UTF8_STRING", 0);
+
+  if (__atom_targets == None)
+    __atom_targets = XInternAtom (dpy, "TARGETS", 0);
+
+  priv->n_targets = 2;
+  priv->supported_targets = g_new (Atom, priv->n_targets);
+
+  priv->supported_targets[0] = __utf8_string;
+  priv->supported_targets[1] = __atom_targets;
+
+  clutter_x11_add_filter ((ClutterX11FilterFunc) st_clipboard_provider,
+                          self);
+}
+
+static ClutterX11FilterReturn
+st_clipboard_x11_event_filter (XEvent          *xev,
+                               ClutterEvent    *cev,
+                               EventFilterData *filter_data)
+{
+  Atom actual_type;
+  int actual_format, result;
+  unsigned long nitems, bytes_after;
+  unsigned char *data = NULL;
+
+  if(xev->type != SelectionNotify)
+    return CLUTTER_X11_FILTER_CONTINUE;
+
+  if (xev->xselection.property == None)
+    {
+      /* clipboard empty */
+      filter_data->callback (filter_data->clipboard,
+                             NULL,
+                             filter_data->user_data);
+
+      clutter_x11_remove_filter ((ClutterX11FilterFunc) st_clipboard_x11_event_filter,
+                                 filter_data);
+      g_free (filter_data);
+      return CLUTTER_X11_FILTER_REMOVE;
+    }
+
+  clutter_x11_trap_x_errors ();
+
+  result = XGetWindowProperty (xev->xselection.display,
+                               xev->xselection.requestor,
+                               xev->xselection.property,
+                               0L, G_MAXINT,
+                               True,
+                               AnyPropertyType,
+                               &actual_type,
+                               &actual_format,
+                               &nitems,
+                               &bytes_after,
+                               &data);
+
+  if (clutter_x11_untrap_x_errors () || result != Success)
+    {
+      /* FIXME: handle failure better */
+      g_warning ("Clipboard: prop retrival failed");
+    }
+
+  filter_data->callback (filter_data->clipboard, (char*) data,
+                         filter_data->user_data);
+
+  clutter_x11_remove_filter
+                          ((ClutterX11FilterFunc) st_clipboard_x11_event_filter,
+                          filter_data);
+
+  g_free (filter_data);
+
+  if (data)
+    XFree (data);
+
+  return CLUTTER_X11_FILTER_REMOVE;
+}
+
+/**
+ * st_clipboard_get_default:
+ *
+ * Get the global #StClipboard object that represents the clipboard.
+ *
+ * Returns: (transfer none): a #StClipboard owned by St and must not be
+ * unrefferenced or freed.
+ */
+StClipboard*
+st_clipboard_get_default (void)
+{
+  static StClipboard *default_clipboard = NULL;
+
+  if (!default_clipboard)
+    {
+      default_clipboard = g_object_new (ST_TYPE_CLIPBOARD, NULL);
+    }
+
+  return default_clipboard;
+}
+
+/**
+ * st_clipboard_get_text:
+ * @clipboard: A #StCliboard
+ * @callback: function to be called when the text is retreived
+ * @user_data: data to be passed to the callback
+ *
+ * Request the data from the clipboard in text form. @callback is executed
+ * when the data is retreived.
+ *
+ */
+void
+st_clipboard_get_text (StClipboard            *clipboard,
+                       StClipboardCallbackFunc callback,
+                       gpointer                user_data)
+{
+  EventFilterData *data;
+
+  Display *dpy;
+
+  g_return_if_fail (ST_IS_CLIPBOARD (clipboard));
+  g_return_if_fail (callback != NULL);
+
+  data = g_new0 (EventFilterData, 1);
+  data->clipboard = clipboard;
+  data->callback = callback;
+  data->user_data = user_data;
+
+  clutter_x11_add_filter ((ClutterX11FilterFunc) st_clipboard_x11_event_filter,
+                          data);
+
+  dpy = clutter_x11_get_default_display ();
+
+  clutter_x11_trap_x_errors (); /* safety on */
+
+  XConvertSelection (dpy,
+                     __atom_clip,
+                     __utf8_string, __utf8_string,
+                     clipboard->priv->clipboard_window,
+                     CurrentTime);
+
+  clutter_x11_untrap_x_errors ();
+}
+
+/**
+ * st_clipboard_set_text:
+ * @clipboard: A #StClipboard
+ * @text: text to copy to the clipboard
+ *
+ * Sets text as the current contents of the clipboard.
+ *
+ */
+void
+st_clipboard_set_text (StClipboard *clipboard,
+                       const gchar *text)
+{
+  StClipboardPrivate *priv;
+  Display *dpy;
+
+  g_return_if_fail (ST_IS_CLIPBOARD (clipboard));
+  g_return_if_fail (text != NULL);
+
+  priv = clipboard->priv;
+
+  /* make a copy of the text */
+  g_free (priv->clipboard_text);
+  priv->clipboard_text = g_strdup (text);
+
+  /* tell X we own the clipboard selection */
+  dpy = clutter_x11_get_default_display ();
+
+  clutter_x11_trap_x_errors ();
+
+  XSetSelectionOwner (dpy, __atom_clip, priv->clipboard_window, CurrentTime);
+  XSync (dpy, FALSE);
+
+  clutter_x11_untrap_x_errors ();
+}

src/st/st-clipboard.h

@@ -0,0 +1,103 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+/*
+ * st-clipboard.h: clipboard object
+ *
+ * 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.
+ *
+ * Written by: Thomas Wood <thomas.wood@intel.com>
+ *
+ */
+
+#if !defined(ST_H_INSIDE) && !defined(ST_COMPILATION)
+#error "Only <st/st.h> can be included directly.h"
+#endif
+
+#ifndef _ST_CLIPBOARD_H
+#define _ST_CLIPBOARD_H
+
+#include <glib-object.h>
+
+G_BEGIN_DECLS
+
+#define ST_TYPE_CLIPBOARD st_clipboard_get_type()
+
+#define ST_CLIPBOARD(obj) \
+  (G_TYPE_CHECK_INSTANCE_CAST ((obj), \
+  ST_TYPE_CLIPBOARD, StClipboard))
+
+#define ST_CLIPBOARD_CLASS(klass) \
+  (G_TYPE_CHECK_CLASS_CAST ((klass), \
+  ST_TYPE_CLIPBOARD, StClipboardClass))
+
+#define ST_IS_CLIPBOARD(obj) \
+  (G_TYPE_CHECK_INSTANCE_TYPE ((obj), \
+  ST_TYPE_CLIPBOARD))
+
+#define ST_IS_CLIPBOARD_CLASS(klass) \
+  (G_TYPE_CHECK_CLASS_TYPE ((klass), \
+  ST_TYPE_CLIPBOARD))
+
+#define ST_CLIPBOARD_GET_CLASS(obj) \
+  (G_TYPE_INSTANCE_GET_CLASS ((obj), \
+  ST_TYPE_CLIPBOARD, StClipboardClass))
+
+typedef struct _StClipboard StClipboard;
+typedef struct _StClipboardClass StClipboardClass;
+typedef struct _StClipboardPrivate StClipboardPrivate;
+
+/**
+ * StClipboard:
+ *
+ * The contents of this structure is private and should only be accessed using
+ * the provided API.
+ */
+struct _StClipboard
+{
+  /*< private >*/
+  GObject parent;
+  StClipboardPrivate *priv;
+};
+
+struct _StClipboardClass
+{
+  GObjectClass parent_class;
+};
+
+/**
+ * StClipboardCallbackFunc:
+ * @clipboard: A #StClipboard
+ * @text: text from the clipboard
+ * @user_data: user data
+ *
+ * Callback function called when text is retrieved from the clipboard.
+ */
+typedef void (*StClipboardCallbackFunc) (StClipboard *clipboard,
+                                         const gchar *text,
+                                         gpointer     user_data);
+
+GType st_clipboard_get_type (void);
+
+StClipboard* st_clipboard_get_default (void);
+
+void st_clipboard_get_text (StClipboard             *clipboard,
+                            StClipboardCallbackFunc  callback,
+                            gpointer                 user_data);
+void st_clipboard_set_text (StClipboard             *clipboard,
+                            const gchar             *text);
+
+G_END_DECLS
+
+#endif /* _ST_CLIPBOARD_H */

src/st/st-entry.c

@@ -0,0 +1,899 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+/*
+ * st-entry.c: Plain entry actor
+ *
+ * Copyright 2008, 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.
+ *
+ * Written by: Thomas Wood <thomas.wood@intel.com>
+ *
+ */
+
+/**
+ * SECTION:st-entry
+ * @short_description: Widget for displaying text
+ *
+ * #StEntry is a simple widget for displaying text. It derives from
+ * #StWidget to add extra style and placement functionality over
+ * #ClutterText. The internal #ClutterText is publicly accessibly to allow
+ * applications to set further properties.
+ *
+ * #StEntry supports the following pseudo style states:
+ * <itemizedlist>
+ *  <listitem>
+ *   <para>focus: the widget has focus</para>
+ *  </listitem>
+ *  <listitem>
+ *   <para>indeterminate: the widget is showing the hint text</para>
+ *  </listitem>
+ * </itemizedlist>
+ */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include <math.h>
+
+#include <stdlib.h>
+#include <string.h>
+
+#include <glib.h>
+
+#include <clutter/clutter.h>
+
+#include "st-entry.h"
+
+#include "st-im-text.h"
+#include "st-widget.h"
+#include "st-texture-cache.h"
+#include "st-marshal.h"
+#include "st-clipboard.h"
+
+#define HAS_FOCUS(actor) (clutter_actor_get_stage (actor) && clutter_stage_get_key_focus ((ClutterStage *) clutter_actor_get_stage (actor)) == actor)
+
+
+/* properties */
+enum
+{
+  PROP_0,
+
+  PROP_CLUTTER_TEXT,
+  PROP_HINT_TEXT,
+  PROP_TEXT,
+};
+
+/* signals */
+enum
+{
+  PRIMARY_ICON_CLICKED,
+  SECONDARY_ICON_CLICKED,
+
+  LAST_SIGNAL
+};
+
+#define ST_ENTRY_GET_PRIVATE(obj)     (G_TYPE_INSTANCE_GET_PRIVATE ((obj), ST_TYPE_ENTRY, StEntryPrivate))
+#define ST_ENTRY_PRIV(x) ((StEntry *) x)->priv
+
+
+struct _StEntryPrivate
+{
+  ClutterActor *entry;
+  gchar        *hint;
+
+  ClutterActor *primary_icon;
+  ClutterActor *secondary_icon;
+
+  gfloat        spacing;
+};
+
+static guint entry_signals[LAST_SIGNAL] = { 0, };
+
+G_DEFINE_TYPE (StEntry, st_entry, ST_TYPE_WIDGET);
+
+static void
+st_entry_set_property (GObject      *gobject,
+                       guint         prop_id,
+                       const GValue *value,
+                       GParamSpec   *pspec)
+{
+  StEntry *entry = ST_ENTRY (gobject);
+
+  switch (prop_id)
+    {
+    case PROP_HINT_TEXT:
+      st_entry_set_hint_text (entry, g_value_get_string (value));
+      break;
+
+    case PROP_TEXT:
+      st_entry_set_text (entry, g_value_get_string (value));
+      break;
+
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (gobject, prop_id, pspec);
+      break;
+    }
+}
+
+static void
+st_entry_get_property (GObject    *gobject,
+                       guint       prop_id,
+                       GValue     *value,
+                       GParamSpec *pspec)
+{
+  StEntryPrivate *priv = ST_ENTRY_PRIV (gobject);
+
+  switch (prop_id)
+    {
+    case PROP_CLUTTER_TEXT:
+      g_value_set_object (value, priv->entry);
+      break;
+
+    case PROP_HINT_TEXT:
+      g_value_set_string (value, priv->hint);
+      break;
+
+    case PROP_TEXT:
+      g_value_set_string (value, clutter_text_get_text (CLUTTER_TEXT (priv->entry)));
+      break;
+
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (gobject, prop_id, pspec);
+      break;
+    }
+}
+
+static void
+st_entry_dispose (GObject *object)
+{
+  StEntryPrivate *priv = ST_ENTRY_PRIV (object);
+
+  if (priv->entry)
+    {
+      clutter_actor_unparent (priv->entry);
+      priv->entry = NULL;
+    }
+}
+
+static void
+st_entry_finalize (GObject *object)
+{
+  StEntryPrivate *priv = ST_ENTRY_PRIV (object);
+
+  g_free (priv->hint);
+  priv->hint = NULL;
+}
+
+static void
+st_entry_style_changed (StWidget *self)
+{
+  StEntryPrivate *priv = ST_ENTRY_PRIV (self);
+  StThemeNode *theme_node;
+  ClutterColor color;
+  const PangoFontDescription *font;
+  gchar *font_string;
+
+  theme_node = st_widget_get_theme_node (self);
+ 
+  st_theme_node_get_foreground_color (theme_node, &color);
+  clutter_text_set_color (CLUTTER_TEXT (priv->entry), &color);
+
+  if (st_theme_node_get_color (theme_node, "caret-color", FALSE, &color))
+    clutter_text_set_cursor_color (CLUTTER_TEXT (priv->entry), &color);
+
+  if (st_theme_node_get_color (theme_node, "selection-background-color", FALSE, &color))
+    clutter_text_set_selection_color (CLUTTER_TEXT (priv->entry), &color);
+
+  font = st_theme_node_get_font (theme_node);
+  font_string = pango_font_description_to_string (font);
+  clutter_text_set_font_name (CLUTTER_TEXT (priv->entry), font_string);
+  g_free (font_string);
+
+  ST_WIDGET_CLASS (st_entry_parent_class)->style_changed (self);
+}
+
+static void
+st_entry_get_preferred_width (ClutterActor *actor,
+                              gfloat        for_height,
+                              gfloat       *min_width_p,
+                              gfloat       *natural_width_p)
+{
+  StEntryPrivate *priv = ST_ENTRY_PRIV (actor);
+  StThemeNode *theme_node = st_widget_get_theme_node (ST_WIDGET (actor));
+  gfloat icon_w;
+
+  st_theme_node_adjust_for_height (theme_node, &for_height);
+
+  clutter_actor_get_preferred_width (priv->entry, for_height,
+                                     min_width_p,
+                                     natural_width_p);
+
+  if (priv->primary_icon)
+    {
+      clutter_actor_get_preferred_width (priv->primary_icon, -1, NULL, &icon_w);
+
+      if (min_width_p)
+        *min_width_p += icon_w + priv->spacing;
+
+      if (natural_width_p)
+        *natural_width_p += icon_w + priv->spacing;
+    }
+
+  if (priv->secondary_icon)
+    {
+      clutter_actor_get_preferred_width (priv->secondary_icon,
+                                         -1, NULL, &icon_w);
+
+      if (min_width_p)
+        *min_width_p += icon_w + priv->spacing;
+
+      if (natural_width_p)
+        *natural_width_p += icon_w + priv->spacing;
+    }
+
+  st_theme_node_adjust_preferred_width (theme_node, min_width_p, natural_width_p);
+}
+
+static void
+st_entry_get_preferred_height (ClutterActor *actor,
+                               gfloat        for_width,
+                               gfloat       *min_height_p,
+                               gfloat       *natural_height_p)
+{
+  StEntryPrivate *priv = ST_ENTRY_PRIV (actor);
+  StThemeNode *theme_node = st_widget_get_theme_node (ST_WIDGET (actor));
+  gfloat icon_h;
+
+  st_theme_node_adjust_for_width (theme_node, &for_width);
+
+  clutter_actor_get_preferred_height (priv->entry, for_width,
+                                      min_height_p,
+                                      natural_height_p);
+
+  if (priv->primary_icon)
+    {
+      clutter_actor_get_preferred_height (priv->primary_icon,
+                                          -1, NULL, &icon_h);
+
+      if (min_height_p && icon_h > *min_height_p)
+        *min_height_p = icon_h;
+
+      if (natural_height_p && icon_h > *natural_height_p)
+        *natural_height_p = icon_h;
+    }
+
+  if (priv->secondary_icon)
+    {
+      clutter_actor_get_preferred_height (priv->secondary_icon,
+                                          -1, NULL, &icon_h);
+
+      if (min_height_p && icon_h > *min_height_p)
+        *min_height_p = icon_h;
+
+      if (natural_height_p && icon_h > *natural_height_p)
+        *natural_height_p = icon_h;
+    }
+
+  st_theme_node_adjust_preferred_height (theme_node, min_height_p, natural_height_p);
+}
+
+static void
+st_entry_allocate (ClutterActor          *actor,
+                   const ClutterActorBox *box,
+                   ClutterAllocationFlags flags)
+{
+  StEntryPrivate *priv = ST_ENTRY_PRIV (actor);
+  StThemeNode *theme_node = st_widget_get_theme_node (ST_WIDGET (actor));
+  ClutterActorClass *parent_class;
+  ClutterActorBox content_box, child_box, icon_box;
+  gfloat icon_w, icon_h;
+  gfloat entry_h, min_h, pref_h, avail_h;
+
+  parent_class = CLUTTER_ACTOR_CLASS (st_entry_parent_class);
+  parent_class->allocate (actor, box, flags);
+
+  st_theme_node_get_content_box (theme_node, box, &content_box);
+
+  avail_h = content_box.y2 - content_box.y1;
+
+  child_box.x1 = content_box.x1;
+  child_box.x2 = content_box.x2;
+
+  if (priv->primary_icon)
+    {
+      clutter_actor_get_preferred_width (priv->primary_icon,
+                                         -1, NULL, &icon_w);
+      clutter_actor_get_preferred_height (priv->primary_icon,
+                                          -1, NULL, &icon_h);
+
+      icon_box.x1 = content_box.x1;
+      icon_box.x2 = icon_box.x1 + icon_w;
+
+      icon_box.y1 = (int) (content_box.y1 + avail_h / 2 - icon_h / 2);
+      icon_box.y2 = icon_box.y1 + icon_h;
+
+      clutter_actor_allocate (priv->primary_icon,
+                              &icon_box,
+                              flags);
+
+      /* reduce the size for the entry */
+      child_box.x1 += icon_w + priv->spacing;
+    }
+
+  if (priv->secondary_icon)
+    {
+      clutter_actor_get_preferred_width (priv->secondary_icon,
+                                         -1, NULL, &icon_w);
+      clutter_actor_get_preferred_height (priv->secondary_icon,
+                                          -1, NULL, &icon_h);
+
+      icon_box.x2 = content_box.x2;
+      icon_box.x1 = icon_box.x2 - icon_w;
+
+      icon_box.y1 = (int) (content_box.y1 + avail_h / 2 - icon_h / 2);
+      icon_box.y2 = icon_box.y1 + icon_h;
+
+      clutter_actor_allocate (priv->secondary_icon,
+                              &icon_box,
+                              flags);
+
+      /* reduce the size for the entry */
+      child_box.x2 -= icon_w - priv->spacing;
+    }
+
+  clutter_actor_get_preferred_height (priv->entry, child_box.x2 - child_box.x1,
+                                      &min_h, &pref_h);
+
+  entry_h = CLAMP (pref_h, min_h, avail_h);
+
+  child_box.y1 = (int) (content_box.y1 + avail_h / 2 - entry_h / 2);
+  child_box.y2 = child_box.y1 + entry_h;
+
+  clutter_actor_allocate (priv->entry, &child_box, flags);
+}
+
+static void
+clutter_text_focus_in_cb (ClutterText  *text,
+                          ClutterActor *actor)
+{
+  StEntryPrivate *priv = ST_ENTRY_PRIV (actor);
+
+  /* remove the hint if visible */
+  if (priv->hint
+      && !strcmp (clutter_text_get_text (text), priv->hint))
+    {
+      clutter_text_set_text (text, "");
+    }
+  st_widget_set_style_pseudo_class (ST_WIDGET (actor), "focus");
+  clutter_text_set_cursor_visible (text, TRUE);
+}
+
+static void
+clutter_text_focus_out_cb (ClutterText  *text,
+                           ClutterActor *actor)
+{
+  StEntryPrivate *priv = ST_ENTRY_PRIV (actor);
+
+  /* add a hint if the entry is empty */
+  if (priv->hint && !strcmp (clutter_text_get_text (text), ""))
+    {
+      clutter_text_set_text (text, priv->hint);
+      st_widget_set_style_pseudo_class (ST_WIDGET (actor), "indeterminate");
+    }
+  else
+    {
+      st_widget_set_style_pseudo_class (ST_WIDGET (actor), NULL);
+    }
+  clutter_text_set_cursor_visible (text, FALSE);
+}
+
+static void
+st_entry_paint (ClutterActor *actor)
+{
+  StEntryPrivate *priv = ST_ENTRY_PRIV (actor);
+  ClutterActorClass *parent_class;
+
+  parent_class = CLUTTER_ACTOR_CLASS (st_entry_parent_class);
+  parent_class->paint (actor);
+
+  clutter_actor_paint (priv->entry);
+
+  if (priv->primary_icon)
+    clutter_actor_paint (priv->primary_icon);
+
+  if (priv->secondary_icon)
+    clutter_actor_paint (priv->secondary_icon);
+}
+
+static void
+st_entry_pick (ClutterActor       *actor,
+               const ClutterColor *c)
+{
+  StEntryPrivate *priv = ST_ENTRY_PRIV (actor);
+
+  CLUTTER_ACTOR_CLASS (st_entry_parent_class)->pick (actor, c);
+
+  clutter_actor_paint (priv->entry);
+
+  if (priv->primary_icon)
+    clutter_actor_paint (priv->primary_icon);
+
+  if (priv->secondary_icon)
+    clutter_actor_paint (priv->secondary_icon);
+}
+
+static void
+st_entry_map (ClutterActor *actor)
+{
+  StEntryPrivate *priv = ST_ENTRY (actor)->priv;
+
+  CLUTTER_ACTOR_CLASS (st_entry_parent_class)->map (actor);
+
+  clutter_actor_map (priv->entry);
+
+  if (priv->primary_icon)
+    clutter_actor_map (priv->primary_icon);
+
+  if (priv->secondary_icon)
+    clutter_actor_map (priv->secondary_icon);
+}
+
+static void
+st_entry_unmap (ClutterActor *actor)
+{
+  StEntryPrivate *priv = ST_ENTRY (actor)->priv;
+
+  CLUTTER_ACTOR_CLASS (st_entry_parent_class)->unmap (actor);
+
+  clutter_actor_unmap (priv->entry);
+
+  if (priv->primary_icon)
+    clutter_actor_unmap (priv->primary_icon);
+
+  if (priv->secondary_icon)
+    clutter_actor_unmap (priv->secondary_icon);
+}
+
+static void
+st_entry_clipboard_callback (StClipboard *clipboard,
+                             const gchar *text,
+                             gpointer     data)
+{
+  ClutterText *ctext = (ClutterText*)((StEntry *) data)->priv->entry;
+  gint cursor_pos;
+
+  if (!text)
+    return;
+
+  /* delete the current selection before pasting */
+  clutter_text_delete_selection (ctext);
+
+  /* "paste" the clipboard text into the entry */
+  cursor_pos = clutter_text_get_cursor_position (ctext);
+  clutter_text_insert_text (ctext, text, cursor_pos);
+}
+
+static gboolean
+st_entry_key_press_event (ClutterActor    *actor,
+                          ClutterKeyEvent *event)
+{
+  StEntryPrivate *priv = ST_ENTRY_PRIV (actor);
+
+  /* This is expected to handle events that were emitted for the inner
+     ClutterText. They only reach this function if the ClutterText
+     didn't handle them */
+
+  /* paste */
+  if ((event->modifier_state & CLUTTER_CONTROL_MASK)
+      && event->keyval == CLUTTER_v)
+    {
+      StClipboard *clipboard;
+
+      clipboard = st_clipboard_get_default ();
+
+      st_clipboard_get_text (clipboard, st_entry_clipboard_callback, actor);
+
+      return TRUE;
+    }
+
+  /* copy */
+  if ((event->modifier_state & CLUTTER_CONTROL_MASK)
+      && event->keyval == CLUTTER_c)
+    {
+      StClipboard *clipboard;
+      gchar *text;
+
+      clipboard = st_clipboard_get_default ();
+
+      text = clutter_text_get_selection ((ClutterText*) priv->entry);
+
+      if (text && strlen (text))
+        st_clipboard_set_text (clipboard, text);
+
+      return TRUE;
+    }
+
+
+  /* cut */
+  if ((event->modifier_state & CLUTTER_CONTROL_MASK)
+      && event->keyval == CLUTTER_x)
+    {
+      StClipboard *clipboard;
+      gchar *text;
+
+      clipboard = st_clipboard_get_default ();
+
+      text = clutter_text_get_selection ((ClutterText*) priv->entry);
+
+      if (text && strlen (text))
+        {
+          st_clipboard_set_text (clipboard, text);
+
+          /* now delete the text */
+          clutter_text_delete_selection ((ClutterText *) priv->entry);
+        }
+
+      return TRUE;
+    }
+
+  return FALSE;
+}
+
+static void
+st_entry_key_focus_in (ClutterActor *actor)
+{
+  StEntryPrivate *priv = ST_ENTRY_PRIV (actor);
+
+  /* We never want key focus. The ClutterText should be given first
+     pass for all key events */
+  clutter_actor_grab_key_focus (priv->entry);
+}
+
+static void
+st_entry_class_init (StEntryClass *klass)
+{
+  GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
+  ClutterActorClass *actor_class = CLUTTER_ACTOR_CLASS (klass);
+  StWidgetClass *widget_class = ST_WIDGET_CLASS (klass);
+  GParamSpec *pspec;
+
+  g_type_class_add_private (klass, sizeof (StEntryPrivate));
+
+  gobject_class->set_property = st_entry_set_property;
+  gobject_class->get_property = st_entry_get_property;
+  gobject_class->finalize = st_entry_finalize;
+  gobject_class->dispose = st_entry_dispose;
+
+  actor_class->get_preferred_width = st_entry_get_preferred_width;
+  actor_class->get_preferred_height = st_entry_get_preferred_height;
+  actor_class->allocate = st_entry_allocate;
+  actor_class->paint = st_entry_paint;
+  actor_class->pick = st_entry_pick;
+  actor_class->map = st_entry_map;
+  actor_class->unmap = st_entry_unmap;
+
+  actor_class->key_press_event = st_entry_key_press_event;
+  actor_class->key_focus_in = st_entry_key_focus_in;
+
+  widget_class->style_changed = st_entry_style_changed;
+
+  pspec = g_param_spec_object ("clutter-text",
+			       "Clutter Text",
+			       "Internal ClutterText actor",
+			       CLUTTER_TYPE_TEXT,
+			       G_PARAM_READABLE);
+  g_object_class_install_property (gobject_class, PROP_CLUTTER_TEXT, pspec);
+
+  pspec = g_param_spec_string ("hint-text",
+                               "Hint Text",
+                               "Text to display when the entry is not focused "
+                               "and the text property is empty",
+                               NULL, G_PARAM_READWRITE);
+  g_object_class_install_property (gobject_class, PROP_HINT_TEXT, pspec);
+
+  pspec = g_param_spec_string ("text",
+                               "Text",
+                               "Text of the entry",
+                               NULL, G_PARAM_READWRITE);
+  g_object_class_install_property (gobject_class, PROP_TEXT, pspec);
+
+  /* signals */
+  /**
+   * StEntry::primary-icon-clicked:
+   *
+   * Emitted when the primary icon is clicked
+   */
+  entry_signals[PRIMARY_ICON_CLICKED] =
+    g_signal_new ("primary-icon-clicked",
+                  G_TYPE_FROM_CLASS (klass),
+                  G_SIGNAL_RUN_LAST,
+                  G_STRUCT_OFFSET (StEntryClass, primary_icon_clicked),
+                  NULL, NULL,
+                  _st_marshal_VOID__VOID,
+                  G_TYPE_NONE, 0);
+  /**
+   * StEntry::secondary-icon-clicked:
+   *
+   * Emitted when the secondary icon is clicked
+   */
+  entry_signals[SECONDARY_ICON_CLICKED] =
+    g_signal_new ("secondary-icon-clicked",
+                  G_TYPE_FROM_CLASS (klass),
+                  G_SIGNAL_RUN_LAST,
+                  G_STRUCT_OFFSET (StEntryClass, secondary_icon_clicked),
+                  NULL, NULL,
+                  _st_marshal_VOID__VOID,
+                  G_TYPE_NONE, 0);
+}
+
+static void
+st_entry_init (StEntry *entry)
+{
+  StEntryPrivate *priv;
+
+  priv = entry->priv = ST_ENTRY_GET_PRIVATE (entry);
+
+  priv->entry = g_object_new (ST_TYPE_IM_TEXT,
+                              "line-alignment", PANGO_ALIGN_LEFT,
+                              "editable", TRUE,
+                              "reactive", TRUE,
+                              "single-line-mode", TRUE,
+                              NULL);
+
+  g_signal_connect (priv->entry, "key-focus-in",
+                    G_CALLBACK (clutter_text_focus_in_cb), entry);
+
+  g_signal_connect (priv->entry, "key-focus-out",
+                    G_CALLBACK (clutter_text_focus_out_cb), entry);
+
+  priv->spacing = 6.0f;
+
+  clutter_actor_set_parent (priv->entry, CLUTTER_ACTOR (entry));
+  clutter_actor_set_reactive ((ClutterActor *) entry, TRUE);
+
+  /* set cursor hidden until we receive focus */
+  clutter_text_set_cursor_visible ((ClutterText *) priv->entry, FALSE);
+}
+
+/**
+ * st_entry_new:
+ * @text: text to set the entry to
+ *
+ * Create a new #StEntry with the specified entry
+ *
+ * Returns: a new #StEntry
+ */
+StWidget *
+st_entry_new (const gchar *text)
+{
+  StWidget *entry;
+
+  /* add the entry to the stage, but don't allow it to be visible */
+  entry = g_object_new (ST_TYPE_ENTRY,
+                        "text", text,
+                        NULL);
+
+  return entry;
+}
+
+/**
+ * st_entry_get_text:
+ * @entry: a #StEntry
+ *
+ * Get the text displayed on the entry
+ *
+ * Returns: the text for the entry. This must not be freed by the application
+ */
+G_CONST_RETURN gchar *
+st_entry_get_text (StEntry *entry)
+{
+  g_return_val_if_fail (ST_IS_ENTRY (entry), NULL);
+
+  return clutter_text_get_text (CLUTTER_TEXT (entry->priv->entry));
+}
+
+/**
+ * st_entry_set_text:
+ * @entry: a #StEntry
+ * @text: text to set the entry to
+ *
+ * Sets the text displayed on the entry
+ */
+void
+st_entry_set_text (StEntry     *entry,
+                   const gchar *text)
+{
+  StEntryPrivate *priv;
+
+  g_return_if_fail (ST_IS_ENTRY (entry));
+
+  priv = entry->priv;
+
+  /* set a hint if we are blanking the entry */
+  if (priv->hint
+      && text && !strcmp ("", text)
+      && !HAS_FOCUS (priv->entry))
+    {
+      text = priv->hint;
+      st_widget_set_style_pseudo_class (ST_WIDGET (entry), "indeterminate");
+    }
+  else
+    {
+      if (HAS_FOCUS (priv->entry))
+        st_widget_set_style_pseudo_class (ST_WIDGET (entry), "focus");
+      else
+        st_widget_set_style_pseudo_class (ST_WIDGET (entry), NULL);
+    }
+
+  clutter_text_set_text (CLUTTER_TEXT (priv->entry), text);
+
+  g_object_notify (G_OBJECT (entry), "text");
+}
+
+/**
+ * st_entry_get_clutter_text:
+ * @entry: a #StEntry
+ *
+ * Retrieve the internal #ClutterText so that extra parameters can be set
+ *
+ * Returns: (transfer none): the #ClutterText used by #StEntry. The entry is
+ * owned by the #StEntry and should not be unref'ed by the application.
+ */
+ClutterActor*
+st_entry_get_clutter_text (StEntry *entry)
+{
+  g_return_val_if_fail (ST_ENTRY (entry), NULL);
+
+  return entry->priv->entry;
+}
+
+/**
+ * st_entry_set_hint_text:
+ * @entry: a #StEntry
+ * @text: text to set as the entry hint
+ *
+ * Sets the text to display when the entry is empty and unfocused. When the
+ * entry is displaying the hint, it has a pseudo class of "indeterminate".
+ * A value of NULL unsets the hint.
+ */
+void
+st_entry_set_hint_text (StEntry     *entry,
+                        const gchar *text)
+{
+  StEntryPrivate *priv;
+
+  g_return_if_fail (ST_IS_ENTRY (entry));
+
+  priv = entry->priv;
+
+  g_free (priv->hint);
+
+  priv->hint = g_strdup (text);
+
+  if (!strcmp (clutter_text_get_text (CLUTTER_TEXT (priv->entry)), ""))
+    {
+      clutter_text_set_text (CLUTTER_TEXT (priv->entry), priv->hint);
+      st_widget_set_style_pseudo_class (ST_WIDGET (entry), "indeterminate");
+    }
+}
+
+/**
+ * st_entry_get_hint_text:
+ * @entry: a #StEntry
+ *
+ * Gets the text that is displayed when the entry is empty and unfocused
+ *
+ * Returns: the current value of the hint property. This string is owned by the
+ * #StEntry and should not be freed or modified.
+ */
+G_CONST_RETURN
+gchar *
+st_entry_get_hint_text (StEntry *entry)
+{
+  g_return_val_if_fail (ST_IS_ENTRY (entry), NULL);
+
+  return entry->priv->hint;
+}
+
+static gboolean
+_st_entry_icon_press_cb (ClutterActor       *actor,
+                         ClutterButtonEvent *event,
+                         StEntry            *entry)
+{
+  StEntryPrivate *priv = entry->priv;
+
+  if (actor == priv->primary_icon)
+    g_signal_emit (entry, entry_signals[PRIMARY_ICON_CLICKED], 0);
+  else
+    g_signal_emit (entry, entry_signals[SECONDARY_ICON_CLICKED], 0);
+
+  return FALSE;
+}
+
+static void
+_st_entry_set_icon_from_file (StEntry       *entry,
+                              ClutterActor **icon,
+                              const gchar   *filename)
+{
+  if (*icon)
+    {
+      g_signal_handlers_disconnect_by_func (*icon,
+                                            _st_entry_icon_press_cb,
+                                            entry);
+      clutter_actor_unparent (*icon);
+      *icon = NULL;
+    }
+
+  if (filename)
+    {
+      StTextureCache *cache;
+
+      cache = st_texture_cache_get_default ();
+
+
+
+      *icon = (ClutterActor*) st_texture_cache_get_texture (cache, filename);
+
+      clutter_actor_set_reactive (*icon, TRUE);
+      clutter_actor_set_parent (*icon, CLUTTER_ACTOR (entry));
+      g_signal_connect (*icon, "button-release-event",
+                        G_CALLBACK (_st_entry_icon_press_cb), entry);
+    }
+
+  clutter_actor_queue_relayout (CLUTTER_ACTOR (entry));
+}
+
+/**
+ * st_entry_set_primary_icon_from_file:
+ * @entry: a #StEntry
+ * @filename: filename of an icon
+ *
+ * Set the primary icon of the entry to the given filename
+ */
+void
+st_entry_set_primary_icon_from_file (StEntry     *entry,
+                                     const gchar *filename)
+{
+  StEntryPrivate *priv;
+
+  g_return_if_fail (ST_IS_ENTRY (entry));
+
+  priv = entry->priv;
+
+  _st_entry_set_icon_from_file (entry, &priv->primary_icon, filename);
+
+}
+
+/**
+ * st_entry_set_secondary_icon_from_file:
+ * @entry: a #StEntry
+ * @filename: filename of an icon
+ *
+ * Set the primary icon of the entry to the given filename
+ */
+void
+st_entry_set_secondary_icon_from_file (StEntry     *entry,
+                                       const gchar *filename)
+{
+  StEntryPrivate *priv;
+
+  g_return_if_fail (ST_IS_ENTRY (entry));
+
+  priv = entry->priv;
+
+  _st_entry_set_icon_from_file (entry, &priv->secondary_icon, filename);
+
+}
+

src/st/st-entry.h

@@ -0,0 +1,89 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+/*
+ * st-entry.h: Plain entry actor
+ *
+ * Copyright 2008, 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.
+ * Boston, MA 02111-1307, USA.
+ *
+ * Written by: Thomas Wood <thomas@linux.intel.com>
+ *
+ */
+
+#if !defined(ST_H_INSIDE) && !defined(ST_COMPILATION)
+#error "Only <st/st.h> can be included directly.h"
+#endif
+
+#ifndef __ST_ENTRY_H__
+#define __ST_ENTRY_H__
+
+G_BEGIN_DECLS
+
+#include <st/st-widget.h>
+
+#define ST_TYPE_ENTRY                (st_entry_get_type ())
+#define ST_ENTRY(obj)                (G_TYPE_CHECK_INSTANCE_CAST ((obj), ST_TYPE_ENTRY, StEntry))
+#define ST_IS_ENTRY(obj)             (G_TYPE_CHECK_INSTANCE_TYPE ((obj), ST_TYPE_ENTRY))
+#define ST_ENTRY_CLASS(klass)        (G_TYPE_CHECK_CLASS_CAST ((klass), ST_TYPE_ENTRY, StEntryClass))
+#define ST_IS_ENTRY_CLASS(klass)     (G_TYPE_CHECK_CLASS_TYPE ((klass), ST_TYPE_ENTRY))
+#define ST_ENTRY_GET_CLASS(obj)      (G_TYPE_INSTANCE_GET_CLASS ((obj), ST_TYPE_ENTRY, StEntryClass))
+
+typedef struct _StEntry              StEntry;
+typedef struct _StEntryPrivate       StEntryPrivate;
+typedef struct _StEntryClass         StEntryClass;
+
+/**
+ * StEntry:
+ *
+ * The contents of this structure is private and should only be accessed using
+ * the provided API.
+ */
+struct _StEntry
+{
+  /*< private >*/
+  StWidget parent_instance;
+
+  StEntryPrivate *priv;
+};
+
+struct _StEntryClass
+{
+  StWidgetClass parent_class;
+
+  /* signals */
+  void (*primary_icon_clicked)   (StEntry *entry);
+  void (*secondary_icon_clicked) (StEntry *entry);
+};
+
+GType st_entry_get_type (void) G_GNUC_CONST;
+
+StWidget *            st_entry_new              (const gchar *text);
+G_CONST_RETURN gchar *st_entry_get_text         (StEntry     *entry);
+void                  st_entry_set_text         (StEntry     *entry,
+                                                 const gchar *text);
+ClutterActor*         st_entry_get_clutter_text (StEntry     *entry);
+
+void                  st_entry_set_hint_text    (StEntry     *entry,
+                                                 const gchar *text);
+G_CONST_RETURN gchar *st_entry_get_hint_text    (StEntry     *entry);
+
+void st_entry_set_primary_icon_from_file   (StEntry     *entry,
+                                            const gchar *filename);
+void st_entry_set_secondary_icon_from_file (StEntry     *entry,
+                                            const gchar *filename);
+
+G_END_DECLS
+
+#endif /* __ST_ENTRY_H__ */

src/st/st-enum-types.c.in

@@ -0,0 +1,30 @@
+/*** BEGIN file-header ***/
+#include "st-enum-types.h"
+/*** END file-header ***/
+
+/*** BEGIN file-production ***/
+/* enumerations from "@filename@" */
+#include "@filename@"
+/*** END file-production ***/
+
+/*** BEGIN value-header ***/
+GType
+@enum_name@_get_type(void) {
+  static GType enum_type_id = 0;
+  if (G_UNLIKELY (!enum_type_id))
+    {
+      static const G@Type@Value values[] = {
+/*** END value-header ***/
+
+/*** BEGIN value-production ***/
+        { @VALUENAME@, "@VALUENAME@", "@valuenick@" },
+/*** END value-production ***/
+
+/*** BEGIN value-tail ***/
+        { 0, NULL, NULL }
+      };
+      enum_type_id = g_@type@_register_static (g_intern_static_string ("@EnumName@"), values);
+    }
+  return enum_type_id;
+}
+/*** END value-tail ***/

src/st/st-enum-types.h.in

@@ -0,0 +1,29 @@
+/*** BEGIN file-header ***/
+#if !defined(ST_H_INSIDE) && !defined(ST_COMPILATION)
+#error "Only <st/st.h> can be included directly.h"
+#endif
+
+#ifndef __ST_ENUM_TYPES_H__
+#define __ST_ENUM_TYPES_H__
+
+#include <glib-object.h>
+
+G_BEGIN_DECLS
+
+/*** END file-header ***/
+
+/*** BEGIN file-production ***/
+/* enumerations from "@filename@" */
+/*** END file-production ***/
+
+/*** BEGIN file-tail ***/
+G_END_DECLS
+
+#endif /* !__ST_ENUM_TYPES_H__ */
+/*** END file-tail ***/
+
+/*** BEGIN value-header ***/
+GType @enum_name@_get_type (void) G_GNUC_CONST;
+#define ST_TYPE_@ENUMSHORT@ (@enum_name@_get_type())
+
+/*** END value-header ***/

src/st/st-im-text.c

@@ -0,0 +1,477 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+/*
+ * st-im-text.c
+ *
+ * This started as a copy of ClutterIMText converted to use
+ * GtkIMContext rather than ClutterIMContext. Original code:
+ *
+ * Author: raymond liu <raymond.liu@intel.com>
+ *
+ * Copyright (C) 2009, Intel Corporation.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public License
+ * version 2.1 as published by the Free Software Foundation.
+ *
+ * This library is distributed in the hope that 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 library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA
+ */
+
+/**
+ * SECTION:StIMText
+ * @short_description: Text widget with input method support
+ * @stability: Unstable
+ * @see_also: #ClutterText
+ * @include: st-imtext/st-imtext.h
+ *
+ * #StIMText derives from ClutterText and hooks up better text input
+ * via #GtkIMContext. It is meant to be a drop-in replacement for
+ * ClutterIMText but using GtkIMContext rather than ClutterIMContext.
+ */
+
+/* Places where this actor doesn't support all of GtkIMContext:
+ *
+ *  A) It doesn't support preedit. This makes it fairly useless for
+ *     most complicated input methods. Fixing this requires support
+ *     directly in ClutterText, since there is no way to wedge a
+ *     preedit string in externally.
+ *  B) It doesn't support surrounding context via the
+ *     :retrieve-surrounding and :delete-surrounding signals. This could
+ *     be added here, but  only affects a small number of input methods
+ *     and really doesn't make a lot of sense without A)
+ *
+ * Another problem that will show up with usage in GNOME Shell's overview
+ * is that the user may have trouble seeing and interacting with ancilliary
+ * windows shown by the IM.
+ */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include <clutter/clutter.h>
+#include <clutter/x11/clutter-x11.h>
+#include <glib.h>
+#include <gtk/gtk.h>
+#include <gdk/gdkkeysyms.h>
+#include <X11/extensions/XKB.h>
+
+#include "st-im-text.h"
+
+#define ST_IM_TEXT_GET_PRIVATE(obj)    \
+        (G_TYPE_INSTANCE_GET_PRIVATE ((obj), ST_TYPE_IM_TEXT, StIMTextPrivate))
+
+struct _StIMTextPrivate
+{
+  GtkIMContext *im_context;
+  GdkWindow *window;
+
+  guint need_im_reset : 1;
+};
+
+static void st_im_text_commit_cb (GtkIMContext *context,
+                                  const gchar  *str,
+                                  StIMText     *imtext);
+
+G_DEFINE_TYPE (StIMText, st_im_text, CLUTTER_TYPE_TEXT)
+
+static void
+st_im_text_dispose (GObject *object)
+{
+  StIMTextPrivate *priv = ST_IM_TEXT (object)->priv;
+
+  g_signal_handlers_disconnect_by_func (priv->im_context,
+                                        (void *) st_im_text_commit_cb,
+                                        object);
+
+  g_object_unref (priv->im_context);
+  priv->im_context = NULL;
+}
+
+static void
+update_im_cursor_location (StIMText *self)
+{
+  StIMTextPrivate *priv = self->priv;
+  ClutterText *clutter_text = CLUTTER_TEXT (self);
+  ClutterActor *parent;
+  gint position;
+  gfloat cursor_x, cursor_y, cursor_height;
+  gfloat actor_x, actor_y;
+  GdkRectangle area;
+
+  position = clutter_text_get_cursor_position (clutter_text);
+  clutter_text_position_to_coords (clutter_text, position,
+                                   &cursor_x, &cursor_y, &cursor_height);
+
+  /* This is a workaround for a bug in Clutter where
+   * clutter_actor_get_transformed_position doesn't work during
+   * clutter_actor_paint() because the actor has already set up
+   * a model-view matrix.
+   *
+   * http://bugzilla.openedhand.com/show_bug.cgi?id=1115
+   */
+  actor_x = actor_y = 0.;
+  parent = CLUTTER_ACTOR (self);
+  while (parent)
+    {
+      gfloat x, y;
+
+      clutter_actor_get_position (parent, &x, &y);
+      actor_x += x;
+      actor_y += y;
+
+      parent = clutter_actor_get_parent (parent);
+    }
+
+  area.x = (int)(0.5 + cursor_x + actor_x);
+  area.y = (int)(0.5 + cursor_y + actor_y);
+  area.width = 0;
+  area.height = (int)(0.5 + cursor_height);
+
+  gtk_im_context_set_cursor_location (priv->im_context, &area);
+}
+
+static void
+st_im_text_commit_cb (GtkIMContext *context,
+                      const gchar  *str,
+                      StIMText     *imtext)
+{
+  ClutterText *clutter_text = CLUTTER_TEXT (imtext);
+
+  if (clutter_text_get_editable (clutter_text))
+    {
+      clutter_text_delete_selection (clutter_text);
+      clutter_text_insert_text (clutter_text, str,
+                                clutter_text_get_cursor_position (clutter_text));
+    }
+}
+
+static void
+reset_im_context (StIMText *self)
+{
+  StIMTextPrivate *priv = self->priv;
+
+  if (priv->need_im_reset)
+    {
+      gtk_im_context_reset (priv->im_context);
+      priv->need_im_reset = FALSE;
+    }
+}
+
+static void
+st_im_text_paint (ClutterActor *actor)
+{
+  StIMText *self = ST_IM_TEXT (actor);
+  ClutterText *clutter_text = CLUTTER_TEXT (actor);
+
+  /* This updates the cursor position as a side-effect */
+  if (CLUTTER_ACTOR_CLASS (st_im_text_parent_class)->paint)
+    CLUTTER_ACTOR_CLASS (st_im_text_parent_class)->paint (actor);
+
+  if (clutter_text_get_editable (clutter_text))
+    update_im_cursor_location (self);
+}
+
+/* Returns a new reference to window */
+static GdkWindow *
+window_for_actor (ClutterActor *actor)
+{
+  GdkDisplay *display = gdk_display_get_default ();
+  ClutterActor *stage;
+  Window xwindow;
+  GdkWindow *window;
+
+  stage = clutter_actor_get_stage (actor);
+  xwindow = clutter_x11_get_stage_window ((ClutterStage *)stage);
+
+  window = gdk_window_lookup_for_display (display, xwindow);
+  if (window)
+    g_object_ref (window);
+  else
+    window = gdk_window_foreign_new_for_display (display, xwindow);
+
+  return window;
+}
+
+static void
+st_im_text_realize (ClutterActor *actor)
+{
+  StIMTextPrivate *priv = ST_IM_TEXT (actor)->priv;
+
+  priv->window = window_for_actor (actor);
+  gtk_im_context_set_client_window (priv->im_context, priv->window);
+}
+
+static void
+st_im_text_unrealize (ClutterActor *actor)
+{
+  StIMText *self = ST_IM_TEXT (actor);
+  StIMTextPrivate *priv = self->priv;
+
+  reset_im_context (self);
+  gtk_im_context_set_client_window (priv->im_context, NULL);
+  g_object_unref (priv->window);
+  priv->window = NULL;
+}
+
+static gboolean
+key_is_modifier (guint16 keyval)
+{
+  /* See gdkkeys-x11.c:_gdk_keymap_key_is_modifier() for how this
+   * really should be implemented */
+
+  switch (keyval)
+    {
+    case GDK_Shift_L:
+    case GDK_Shift_R:
+    case GDK_Control_L:
+    case GDK_Control_R:
+    case GDK_Caps_Lock:
+    case GDK_Shift_Lock:
+    case GDK_Meta_L:
+    case GDK_Meta_R:
+    case GDK_Alt_L:
+    case GDK_Alt_R:
+    case GDK_Super_L:
+    case GDK_Super_R:
+    case GDK_Hyper_L:
+    case GDK_Hyper_R:
+    case GDK_ISO_Lock:
+    case GDK_ISO_Level2_Latch:
+    case GDK_ISO_Level3_Shift:
+    case GDK_ISO_Level3_Latch:
+    case GDK_ISO_Level3_Lock:
+    case GDK_ISO_Level5_Shift:
+    case GDK_ISO_Level5_Latch:
+    case GDK_ISO_Level5_Lock:
+    case GDK_ISO_Group_Shift:
+    case GDK_ISO_Group_Latch:
+    case GDK_ISO_Group_Lock:
+      return TRUE;
+    default:
+      return FALSE;
+    }
+}
+
+static GdkEventKey *
+key_event_to_gdk (ClutterKeyEvent *event_clutter)
+{
+  GdkDisplay *display = gdk_display_get_default ();
+  GdkKeymap *keymap = gdk_keymap_get_for_display (display);
+  GdkEventKey *event_gdk;
+  event_gdk = (GdkEventKey *)gdk_event_new ((event_clutter->type == CLUTTER_KEY_PRESS) ?
+                                            GDK_KEY_PRESS : GDK_KEY_RELEASE);
+
+  event_gdk->window = window_for_actor ((ClutterActor *)event_clutter->stage);
+  event_gdk->send_event = FALSE;
+  event_gdk->time = event_clutter->time;
+  /* This depends on ClutterModifierType and GdkModifierType being
+   * identical, which they are currently. (They both match the X
+   * modifier state in the low 16-bits and have the same extensions.) */
+  event_gdk->state = event_clutter->modifier_state;
+  event_gdk->keyval = event_clutter->keyval;
+  event_gdk->hardware_keycode = event_clutter->hardware_keycode;
+  /* For non-proper non-XKB support, we'd need a huge cut-and-paste
+   * from gdkkeys-x11.c; this is a macro that just shifts a few bits
+   * out of state, so won't make the situation worse if the server
+   * doesn't support XKB; we'll just end up with group == 0 */
+  event_gdk->group = XkbGroupForCoreState (event_gdk->state);
+
+  gdk_keymap_translate_keyboard_state (keymap, event_gdk->hardware_keycode,
+                                       event_gdk->state, event_gdk->group,
+                                       &event_gdk->keyval, NULL, NULL, NULL);
+
+  if (event_clutter->unicode_value)
+    {
+      /* This is not particularly close to what GDK does - event_gdk->string
+       * is supposed to be in the locale encoding, and have control keys
+       * as control characters, etc. See gdkevents-x11.c:translate_key_event().
+       * Hopefully no input method is using event.string.
+       */
+      char buf[6];
+
+      event_gdk->length = g_unichar_to_utf8 (event_clutter->unicode_value, buf);
+      event_gdk->string = g_strndup (buf, event_gdk->length);
+    }
+
+  event_gdk->is_modifier = key_is_modifier (event_gdk->keyval);
+
+  return event_gdk;
+}
+
+static gboolean
+st_im_text_button_press_event (ClutterActor       *actor,
+                               ClutterButtonEvent *event)
+{
+  /* The button press indicates the user moving the cursor, or selecting
+   * etc, so we should abort any current preedit operation. ClutterText
+   * treats all buttons identically, so so do we.
+   */
+  reset_im_context (ST_IM_TEXT (actor));
+
+  if (CLUTTER_ACTOR_CLASS (st_im_text_parent_class)->button_press_event)
+    return CLUTTER_ACTOR_CLASS (st_im_text_parent_class)->button_press_event (actor, event);
+  else
+    return FALSE;
+}
+
+static gboolean
+st_im_text_key_press_event (ClutterActor    *actor,
+                            ClutterKeyEvent *event)
+{
+  StIMText *self = ST_IM_TEXT (actor);
+  StIMTextPrivate *priv = self->priv;
+  ClutterText *clutter_text = CLUTTER_TEXT (actor);
+  gboolean result = FALSE;
+  int old_position;
+
+  if (clutter_text_get_editable (clutter_text))
+    {
+      GdkEventKey *event_gdk = key_event_to_gdk (event);
+
+      if (gtk_im_context_filter_keypress (priv->im_context, event_gdk))
+        {
+          priv->need_im_reset = TRUE;
+          result = TRUE;
+        }
+
+      gdk_event_free ((GdkEvent *)event_gdk);
+    }
+
+  /* ClutterText:position isn't properly notified, so we have to
+   * check before/after to catch a keypress (like an arrow key)
+   * moving the cursor position, which should reset the IM context.
+   * (Resetting on notify::position would require a sentinel when
+   * committing text)
+   *
+   * http://bugzilla.openedhand.com/show_bug.cgi?id=1830
+   */
+  old_position = clutter_text_get_cursor_position (clutter_text);
+
+  if (!result &&
+      CLUTTER_ACTOR_CLASS (st_im_text_parent_class)->key_press_event)
+    result = CLUTTER_ACTOR_CLASS (st_im_text_parent_class)->key_press_event (actor, event);
+
+  if (clutter_text_get_cursor_position (clutter_text) != old_position)
+    reset_im_context (self);
+
+  return result;
+}
+
+static gboolean
+st_im_text_key_release_event (ClutterActor    *actor,
+                              ClutterKeyEvent *event)
+{
+  StIMText *self = ST_IM_TEXT (actor);
+  StIMTextPrivate *priv = self->priv;
+  ClutterText *clutter_text = CLUTTER_TEXT (actor);
+  GdkEventKey *event_gdk;
+  gboolean result = FALSE;
+
+  if (clutter_text_get_editable (clutter_text))
+    {
+      event_gdk = key_event_to_gdk (event);
+
+      if (gtk_im_context_filter_keypress (priv->im_context, event_gdk))
+        {
+          priv->need_im_reset = TRUE;
+          result = TRUE;
+        }
+
+      gdk_event_free ((GdkEvent *)event_gdk);
+    }
+
+  if (!result &&
+      CLUTTER_ACTOR_CLASS (st_im_text_parent_class)->key_release_event)
+    result = CLUTTER_ACTOR_CLASS (st_im_text_parent_class)->key_release_event (actor, event);
+
+  return result;
+}
+
+static void
+st_im_text_key_focus_in (ClutterActor *actor)
+{
+  StIMTextPrivate *priv = ST_IM_TEXT (actor)->priv;
+  ClutterText *clutter_text = CLUTTER_TEXT (actor);
+
+  if (clutter_text_get_editable (clutter_text))
+    {
+      priv->need_im_reset = TRUE;
+      gtk_im_context_focus_in (priv->im_context);
+    }
+
+  if (CLUTTER_ACTOR_CLASS (st_im_text_parent_class)->key_focus_in)
+    CLUTTER_ACTOR_CLASS (st_im_text_parent_class)->key_focus_in (actor);
+}
+
+static void
+st_im_text_key_focus_out (ClutterActor *actor)
+{
+  StIMTextPrivate *priv = ST_IM_TEXT (actor)->priv;
+  ClutterText *clutter_text = CLUTTER_TEXT (actor);
+
+  if (clutter_text_get_editable (clutter_text))
+    {
+      priv->need_im_reset = TRUE;
+      gtk_im_context_focus_out (priv->im_context);
+    }
+
+  if (CLUTTER_ACTOR_CLASS (st_im_text_parent_class)->key_focus_out)
+    CLUTTER_ACTOR_CLASS (st_im_text_parent_class)->key_focus_out (actor);
+}
+
+static void
+st_im_text_class_init (StIMTextClass *klass)
+{
+  GObjectClass *object_class = G_OBJECT_CLASS (klass);
+  ClutterActorClass *actor_class = CLUTTER_ACTOR_CLASS (klass);
+
+  g_type_class_add_private (klass, sizeof (StIMTextPrivate));
+
+  object_class->dispose = st_im_text_dispose;
+
+  actor_class->paint = st_im_text_paint;
+  actor_class->realize = st_im_text_realize;
+  actor_class->unrealize = st_im_text_unrealize;
+
+  actor_class->button_press_event = st_im_text_button_press_event;
+  actor_class->key_press_event = st_im_text_key_press_event;
+  actor_class->key_release_event = st_im_text_key_release_event;
+  actor_class->key_focus_in = st_im_text_key_focus_in;
+  actor_class->key_focus_out = st_im_text_key_focus_out;
+}
+
+static void
+st_im_text_init (StIMText *self)
+{
+  StIMTextPrivate *priv;
+
+  self->priv = priv = ST_IM_TEXT_GET_PRIVATE (self);
+
+  priv->im_context = gtk_im_multicontext_new ();
+  g_signal_connect (priv->im_context, "commit",
+                    G_CALLBACK (st_im_text_commit_cb), self);
+}
+
+/**
+ * st_im_text_new:
+ * @text: text to set  to
+ *
+ * Create a new #StIMText with the specified text
+ *
+ * Returns: a new #ClutterActor
+ */
+ClutterActor *
+st_im_text_new (const gchar *text)
+{
+  return g_object_new (ST_TYPE_IM_TEXT,
+                       "text", text,
+                       NULL);
+}

src/st/st-im-text.h

@@ -0,0 +1,69 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+/*
+ * st-imtext.h
+ *
+ * This is a copy of ClutterIMText converted to use GtkIMContext rather
+ * than ClutterIMContext. Original code:
+ *
+ * Author: raymond liu <raymond.liu@intel.com>
+ *
+ * Copyright (C) 2009, Intel Corporation.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public License
+ * version 2.1 as published by the Free Software Foundation.
+ *
+ * This library is distributed in the hope that 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 library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA
+ */
+
+#if !defined(ST_H_INSIDE) && !defined(ST_COMPILATION)
+#error "Only <st/st.h> can be included directly.h"
+#endif
+
+#ifndef __ST_IM_TEXT_H__
+#define __ST_IM_TEXT_H__
+
+G_BEGIN_DECLS
+
+#include <clutter/clutter.h>
+
+#define ST_TYPE_IM_TEXT               (st_im_text_get_type ())
+#define ST_IM_TEXT(obj)               (G_TYPE_CHECK_INSTANCE_CAST ((obj), ST_TYPE_IM_TEXT, StIMText))
+#define ST_IS_IM_TEXT(obj)            (G_TYPE_CHECK_INSTANCE_TYPE ((obj), ST_TYPE_IM_TEXT))
+#define ST_IM_TEXT_CLASS(klass)       (G_TYPE_CHECK_CLASS_CAST ((klass), ST_TYPE_IM_TEXT, StIMTextClass))
+#define ST_IS_IM_TEXT_CLASS(klass)    (G_TYPE_CHECK_CLASS_TYPE ((klass), ST_TYPE_IM_TEXT))
+#define ST_IM_TEXT_GET_CLASS(obj)     (G_TYPE_INSTANCE_GET_CLASS ((obj), ST_TYPE_IM_TEXT, StIMTextClass))
+
+typedef struct _StIMText              StIMText;
+typedef struct _StIMTextPrivate       StIMTextPrivate;
+typedef struct _StIMTextClass         StIMTextClass;
+
+struct _StIMText
+{
+  ClutterText parent_instance;
+
+  StIMTextPrivate *priv;
+};
+
+struct _StIMTextClass
+{
+  ClutterTextClass parent_class;
+};
+
+GType st_im_text_get_type (void) G_GNUC_CONST;
+
+ClutterActor *st_im_text_new             (const gchar *text);
+void          st_im_text_set_autoshow_im (StIMText    *self,
+                                          gboolean     autoshow);
+
+G_END_DECLS
+
+#endif /* __ST_IM_TEXT_H__ */

src/st/st-label.c

@@ -0,0 +1,342 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+/*
+ * st-label.c: Plain label actor
+ *
+ * Copyright 2008,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.
+ *
+ * Written by: Thomas Wood <thomas@linux.intel.com>
+ *
+ */
+
+/**
+ * SECTION:st-label
+ * @short_description: Widget for displaying text
+ *
+ * #StLabel is a simple widget for displaying text. It derives from
+ * #StWidget to add extra style and placement functionality over
+ * #ClutterText. The internal #ClutterText is publicly accessibly to allow
+ * applications to set further properties.
+ */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include <stdlib.h>
+#include <string.h>
+
+#include <glib.h>
+
+#include <clutter/clutter.h>
+
+#include "st-label.h"
+
+#include "st-widget.h"
+
+enum
+{
+  PROP_0,
+
+  PROP_CLUTTER_TEXT,
+  PROP_TEXT
+};
+
+#define ST_LABEL_GET_PRIVATE(obj)     (G_TYPE_INSTANCE_GET_PRIVATE ((obj), ST_TYPE_LABEL, StLabelPrivate))
+
+struct _StLabelPrivate
+{
+  ClutterActor *label;
+};
+
+G_DEFINE_TYPE (StLabel, st_label, ST_TYPE_WIDGET);
+
+static void
+st_label_set_property (GObject      *gobject,
+                       guint         prop_id,
+                       const GValue *value,
+                       GParamSpec   *pspec)
+{
+  StLabel *label = ST_LABEL (gobject);
+
+  switch (prop_id)
+    {
+    case PROP_TEXT:
+      st_label_set_text (label, g_value_get_string (value));
+      break;
+
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (gobject, prop_id, pspec);
+      break;
+    }
+}
+
+static void
+st_label_get_property (GObject    *gobject,
+                       guint       prop_id,
+                       GValue     *value,
+                       GParamSpec *pspec)
+{
+  StLabelPrivate *priv = ST_LABEL (gobject)->priv;
+
+  switch (prop_id)
+    {
+    case PROP_CLUTTER_TEXT:
+      g_value_set_object (value, priv->label);
+      break;
+
+    case PROP_TEXT:
+      g_value_set_string (value, clutter_text_get_text (CLUTTER_TEXT (priv->label)));
+      break;
+
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (gobject, prop_id, pspec);
+      break;
+    }
+}
+
+static void
+st_label_style_changed (StWidget *self)
+{
+  StLabelPrivate *priv;
+  StThemeNode *theme_node;
+  ClutterColor color;
+  const PangoFontDescription *font;
+  gchar *font_string;
+
+  priv = ST_LABEL (self)->priv;
+  theme_node = st_widget_get_theme_node (self);
+  st_theme_node_get_foreground_color (theme_node, &color);
+  clutter_text_set_color (CLUTTER_TEXT (priv->label), &color);
+
+  font = st_theme_node_get_font (theme_node);
+  font_string = pango_font_description_to_string (font);
+  clutter_text_set_font_name (CLUTTER_TEXT (priv->label), font_string);
+  g_free (font_string);
+
+  ST_WIDGET_CLASS (st_label_parent_class)->style_changed (self);
+}
+
+static void
+st_label_get_preferred_width (ClutterActor *actor,
+                              gfloat        for_height,
+                              gfloat       *min_width_p,
+                              gfloat       *natural_width_p)
+{
+  StLabelPrivate *priv = ST_LABEL (actor)->priv;
+  StThemeNode *theme_node = st_widget_get_theme_node (ST_WIDGET (actor));
+
+  st_theme_node_adjust_for_height (theme_node, &for_height);
+
+  clutter_actor_get_preferred_width (priv->label, for_height,
+                                     min_width_p,
+                                     natural_width_p);
+
+  st_theme_node_adjust_preferred_width (theme_node, min_width_p, natural_width_p);
+}
+
+static void
+st_label_get_preferred_height (ClutterActor *actor,
+                               gfloat        for_width,
+                               gfloat       *min_height_p,
+                               gfloat       *natural_height_p)
+{
+  StLabelPrivate *priv = ST_LABEL (actor)->priv;
+  StThemeNode *theme_node = st_widget_get_theme_node (ST_WIDGET (actor));
+
+  st_theme_node_adjust_for_width (theme_node, &for_width);
+
+  clutter_actor_get_preferred_height (priv->label, for_width,
+                                      min_height_p,
+                                      natural_height_p);
+
+  st_theme_node_adjust_preferred_height (theme_node, min_height_p, natural_height_p);
+}
+
+static void
+st_label_allocate (ClutterActor          *actor,
+                   const ClutterActorBox *box,
+                   ClutterAllocationFlags flags)
+{
+  StLabelPrivate *priv = ST_LABEL (actor)->priv;
+  StThemeNode *theme_node = st_widget_get_theme_node (ST_WIDGET (actor));
+  ClutterActorClass *parent_class;
+  ClutterActorBox content_box;
+
+  st_theme_node_get_content_box (theme_node, box, &content_box);
+
+  parent_class = CLUTTER_ACTOR_CLASS (st_label_parent_class);
+  parent_class->allocate (actor, box, flags);
+
+  clutter_actor_allocate (priv->label, &content_box, flags);
+}
+
+static void
+st_label_paint (ClutterActor *actor)
+{
+  StLabelPrivate *priv = ST_LABEL (actor)->priv;
+  ClutterActorClass *parent_class;
+
+  parent_class = CLUTTER_ACTOR_CLASS (st_label_parent_class);
+  parent_class->paint (actor);
+
+  clutter_actor_paint (priv->label);
+}
+
+static void
+st_label_map (ClutterActor *actor)
+{
+  StLabelPrivate *priv = ST_LABEL (actor)->priv;
+
+  CLUTTER_ACTOR_CLASS (st_label_parent_class)->map (actor);
+
+  clutter_actor_map (priv->label);
+}
+
+static void
+st_label_unmap (ClutterActor *actor)
+{
+  StLabelPrivate *priv = ST_LABEL (actor)->priv;
+
+  CLUTTER_ACTOR_CLASS (st_label_parent_class)->unmap (actor);
+
+  clutter_actor_unmap (priv->label);
+}
+
+static void
+st_label_class_init (StLabelClass *klass)
+{
+  GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
+  ClutterActorClass *actor_class = CLUTTER_ACTOR_CLASS (klass);
+  StWidgetClass *widget_class = ST_WIDGET_CLASS (klass);
+  GParamSpec *pspec;
+
+  g_type_class_add_private (klass, sizeof (StLabelPrivate));
+
+  gobject_class->set_property = st_label_set_property;
+  gobject_class->get_property = st_label_get_property;
+
+  actor_class->paint = st_label_paint;
+  actor_class->allocate = st_label_allocate;
+  actor_class->get_preferred_width = st_label_get_preferred_width;
+  actor_class->get_preferred_height = st_label_get_preferred_height;
+  actor_class->map = st_label_map;
+  actor_class->unmap = st_label_unmap;
+
+  widget_class->style_changed = st_label_style_changed;
+
+  pspec = g_param_spec_object ("clutter-text",
+			       "Clutter Text",
+			       "Internal ClutterText actor",
+			       CLUTTER_TYPE_TEXT,
+			       G_PARAM_READABLE);
+  g_object_class_install_property (gobject_class, PROP_CLUTTER_TEXT, pspec);
+
+  pspec = g_param_spec_string ("text",
+                               "Text",
+                               "Text of the label",
+                               NULL, G_PARAM_READWRITE);
+  g_object_class_install_property (gobject_class, PROP_TEXT, pspec);
+
+}
+
+static void
+st_label_init (StLabel *label)
+{
+  StLabelPrivate *priv;
+
+  label->priv = priv = ST_LABEL_GET_PRIVATE (label);
+
+  label->priv->label = g_object_new (CLUTTER_TYPE_TEXT,
+                                     "ellipsize", PANGO_ELLIPSIZE_END,
+                                     NULL);
+
+  clutter_actor_set_parent (priv->label, CLUTTER_ACTOR (label));
+}
+
+/**
+ * st_label_new:
+ * @text: text to set the label to
+ *
+ * Create a new #StLabel with the specified label
+ *
+ * Returns: a new #StLabel
+ */
+StWidget *
+st_label_new (const gchar *text)
+{
+  if (text == NULL || *text == '\0')
+    return g_object_new (ST_TYPE_LABEL, NULL);
+  else
+    return g_object_new (ST_TYPE_LABEL,
+                         "text", text,
+                         NULL);
+}
+
+/**
+ * st_label_get_text:
+ * @label: a #StLabel
+ *
+ * Get the text displayed on the label
+ *
+ * Returns: the text for the label. This must not be freed by the application
+ */
+G_CONST_RETURN gchar *
+st_label_get_text (StLabel *label)
+{
+  g_return_val_if_fail (ST_IS_LABEL (label), NULL);
+
+  return clutter_text_get_text (CLUTTER_TEXT (label->priv->label));
+}
+
+/**
+ * st_label_set_text:
+ * @label: a #StLabel
+ * @text: text to set the label to
+ *
+ * Sets the text displayed on the label
+ */
+void
+st_label_set_text (StLabel     *label,
+                   const gchar *text)
+{
+  StLabelPrivate *priv;
+
+  g_return_if_fail (ST_IS_LABEL (label));
+  g_return_if_fail (text != NULL);
+
+  priv = label->priv;
+
+  clutter_text_set_text (CLUTTER_TEXT (priv->label), text);
+
+  g_object_notify (G_OBJECT (label), "text");
+}
+
+/**
+ * st_label_get_clutter_text:
+ * @label: a #StLabel
+ *
+ * Retrieve the internal #ClutterText so that extra parameters can be set
+ *
+ * Returns: (transfer none): ethe #ClutterText used by #StLabel. The label
+ * is owned by the #StLabel and should not be unref'ed by the application.
+ */
+ClutterActor*
+st_label_get_clutter_text (StLabel *label)
+{
+  g_return_val_if_fail (ST_LABEL (label), NULL);
+
+  return label->priv->label;
+}

src/st/st-label.h

@@ -0,0 +1,76 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+/*
+ * st-label.h: Plain label actor
+ *
+ * Copyright 2008, 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.
+ * Boston, MA 02111-1307, USA.
+ *
+ * Written by: Thomas Wood <thomas@linux.intel.com>
+ *
+ */
+
+#if !defined(ST_H_INSIDE) && !defined(ST_COMPILATION)
+#error "Only <st/st.h> can be included directly.h"
+#endif
+
+#ifndef __ST_LABEL_H__
+#define __ST_LABEL_H__
+
+G_BEGIN_DECLS
+
+#include <st/st-widget.h>
+
+#define ST_TYPE_LABEL                (st_label_get_type ())
+#define ST_LABEL(obj)                (G_TYPE_CHECK_INSTANCE_CAST ((obj), ST_TYPE_LABEL, StLabel))
+#define ST_IS_LABEL(obj)             (G_TYPE_CHECK_INSTANCE_TYPE ((obj), ST_TYPE_LABEL))
+#define ST_LABEL_CLASS(klass)        (G_TYPE_CHECK_CLASS_CAST ((klass), ST_TYPE_LABEL, StLabelClass))
+#define ST_IS_LABEL_CLASS(klass)     (G_TYPE_CHECK_CLASS_TYPE ((klass), ST_TYPE_LABEL))
+#define ST_LABEL_GET_CLASS(obj)      (G_TYPE_INSTANCE_GET_CLASS ((obj), ST_TYPE_LABEL, StLabelClass))
+
+typedef struct _StLabel              StLabel;
+typedef struct _StLabelPrivate       StLabelPrivate;
+typedef struct _StLabelClass         StLabelClass;
+
+/**
+ * StLabel:
+ *
+ * The contents of this structure is private and should only be accessed using
+ * the provided API.
+ */
+struct _StLabel
+{
+  /*< private >*/
+  StWidget parent_instance;
+
+  StLabelPrivate *priv;
+};
+
+struct _StLabelClass
+{
+  StWidgetClass parent_class;
+};
+
+GType st_label_get_type (void) G_GNUC_CONST;
+
+StWidget *            st_label_new              (const gchar *text);
+G_CONST_RETURN gchar *st_label_get_text         (StLabel     *label);
+void                  st_label_set_text         (StLabel     *label,
+                                                 const gchar *text);
+ClutterActor *        st_label_get_clutter_text (StLabel     *label);
+
+G_END_DECLS
+
+#endif /* __ST_LABEL_H__ */

src/st/st-marshal.list

@@ -0,0 +1,12 @@
+VOID:OBJECT
+VOID:VOID
+VOID:PARAM
+VOID:POINTER
+VOID:UINT
+VOID:UINT,UINT
+VOID:OBJECT,OBJECT
+VOID:STRING,OBJECT
+VOID:OBJECT,OBJECT,INT,INT
+VOID:OBJECT,FLOAT,FLOAT,INT,ENUM
+VOID:FLOAT,FLOAT,INT,ENUM
+VOID:FLOAT,FLOAT

src/st/st-private.c

@@ -0,0 +1,112 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+#include "st-private.h"
+
+/* Utility function to modify a child allocation box with respect to the
+ * x/y-fill child properties. Expects childbox to contain the available
+ * allocation space.
+ */
+void
+_st_allocate_fill (ClutterActor    *child,
+                   ClutterActorBox *childbox,
+                   StAlign          x_alignment,
+                   StAlign          y_alignment,
+                   gboolean         x_fill,
+                   gboolean         y_fill)
+{
+  gfloat natural_width, natural_height;
+  gfloat min_width, min_height;
+  gfloat child_width, child_height;
+  gfloat available_width, available_height;
+  ClutterRequestMode request;
+  ClutterActorBox allocation = { 0, };
+  gdouble x_align, y_align;
+
+  if (x_alignment == ST_ALIGN_START)
+    x_align = 0.0;
+  else if (x_alignment == ST_ALIGN_MIDDLE)
+    x_align = 0.5;
+  else
+    x_align = 1.0;
+
+  if (y_alignment == ST_ALIGN_START)
+    y_align = 0.0;
+  else if (y_alignment == ST_ALIGN_MIDDLE)
+    y_align = 0.5;
+  else
+    y_align = 1.0;
+
+  available_width  = childbox->x2 - childbox->x1;
+  available_height = childbox->y2 - childbox->y1;
+
+  if (available_width < 0)
+    available_width = 0;
+
+  if (available_height < 0)
+    available_height = 0;
+
+  if (x_fill)
+    {
+      allocation.x1 = childbox->x1;
+      allocation.x2 = (int)(allocation.x1 + available_width);
+    }
+
+  if (y_fill)
+    {
+      allocation.y1 = childbox->y1;
+      allocation.y2 = (int)(allocation.y1 + available_height);
+    }
+
+  /* if we are filling horizontally and vertically then we're done */
+  if (x_fill && y_fill)
+    {
+      *childbox = allocation;
+      return;
+    }
+
+  request = CLUTTER_REQUEST_HEIGHT_FOR_WIDTH;
+  g_object_get (G_OBJECT (child), "request-mode", &request, NULL);
+
+  if (request == CLUTTER_REQUEST_HEIGHT_FOR_WIDTH)
+    {
+      clutter_actor_get_preferred_width (child, available_height,
+                                         &min_width,
+                                         &natural_width);
+
+      child_width = CLAMP (natural_width, min_width, available_width);
+
+      clutter_actor_get_preferred_height (child, child_width,
+                                          &min_height,
+                                          &natural_height);
+
+      child_height = CLAMP (natural_height, min_height, available_height);
+    }
+  else
+    {
+      clutter_actor_get_preferred_height (child, available_width,
+                                          &min_height,
+                                          &natural_height);
+
+      child_height = CLAMP (natural_height, min_height, available_height);
+
+      clutter_actor_get_preferred_width (child, child_height,
+                                         &min_width,
+                                         &natural_width);
+
+      child_width = CLAMP (natural_width, min_width, available_width);
+    }
+
+  if (!x_fill)
+    {
+      allocation.x1 = childbox->x1 + (int)((available_width - child_width) * x_align);
+      allocation.x2 = allocation.x1 + (int) child_width;
+    }
+
+  if (!y_fill)
+    {
+      allocation.y1 = childbox->y1 + (int)((available_height - child_height) * y_align);
+      allocation.y2 = allocation.y1 + (int) child_height;
+    }
+
+  *childbox = allocation;
+
+}

src/st/st-private.h

@@ -0,0 +1,58 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+/*
+ * st-private.h: Private declarations
+ *
+ * Copyright 2007 OpenedHand
+ * 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.
+ * Boston, MA 02111-1307, USA.
+ *
+ */
+
+#ifndef __ST_PRIVATE_H__
+#define __ST_PRIVATE_H__
+
+#include <glib.h>
+#include "st-widget.h"
+#include "st-bin.h"
+
+G_BEGIN_DECLS
+
+#define I_(str)         (g_intern_static_string ((str)))
+
+#define ST_PARAM_READABLE     \
+        (G_PARAM_READABLE |     \
+         G_PARAM_STATIC_NICK | G_PARAM_STATIC_NAME | G_PARAM_STATIC_BLURB)
+
+#define ST_PARAM_READWRITE    \
+        (G_PARAM_READABLE | G_PARAM_WRITABLE | \
+         G_PARAM_STATIC_NICK | G_PARAM_STATIC_NAME | G_PARAM_STATIC_BLURB)
+
+G_END_DECLS
+
+ClutterActor *_st_widget_get_dnd_clone (StWidget *widget);
+
+void _st_bin_get_align_factors (StBin   *bin,
+                                gdouble *x_align,
+                                gdouble *y_align);
+
+void _st_allocate_fill (ClutterActor    *child,
+                        ClutterActorBox *childbox,
+                        StAlign          x_align,
+                        StAlign          y_align,
+                        gboolean         x_fill,
+                        gboolean         y_fill);
+
+#endif /* __ST_PRIVATE_H__ */

src/st/st-scroll-bar.h

@@ -0,0 +1,83 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+/*
+ * st-scroll-bar.h: Scroll bar actor
+ *
+ * Copyright 2008 OpenedHand
+ * 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.
+ * Boston, MA 02111-1307, USA.
+ *
+ * Written by: Chris Lord <chris@openedhand.com>
+ * Port to St by: Robert Staudinger <robsta@openedhand.com>
+ *
+ */
+
+#if !defined(ST_H_INSIDE) && !defined(ST_COMPILATION)
+#error "Only <st/st.h> can be included directly.h"
+#endif
+
+#ifndef __ST_SCROLL_BAR_H__
+#define __ST_SCROLL_BAR_H__
+
+#include <st/st-adjustment.h>
+#include <st/st-bin.h>
+
+G_BEGIN_DECLS
+
+#define ST_TYPE_SCROLL_BAR            (st_scroll_bar_get_type())
+#define ST_SCROLL_BAR(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), ST_TYPE_SCROLL_BAR, StScrollBar))
+#define ST_IS_SCROLL_BAR(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), ST_TYPE_SCROLL_BAR))
+#define ST_SCROLL_BAR_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), ST_TYPE_SCROLL_BAR, StScrollBarClass))
+#define ST_IS_SCROLL_BAR_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), ST_TYPE_SCROLL_BAR))
+#define ST_SCROLL_BAR_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), ST_TYPE_SCROLL_BAR, StScrollBarClass))
+
+typedef struct _StScrollBar          StScrollBar;
+typedef struct _StScrollBarPrivate   StScrollBarPrivate;
+typedef struct _StScrollBarClass     StScrollBarClass;
+
+/**
+ * StScrollBar:
+ *
+ * The contents of this structure are private and should only be accessed
+ * through the public API.
+ */
+struct _StScrollBar
+{
+  /*< private >*/
+  StBin parent_instance;
+
+  StScrollBarPrivate *priv;
+};
+
+struct _StScrollBarClass
+{
+  StBinClass parent_class;
+
+  /* signals */
+  void (*scroll_start) (StScrollBar *bar);
+  void (*scroll_stop)  (StScrollBar *bar);
+};
+
+GType st_scroll_bar_get_type (void) G_GNUC_CONST;
+
+StWidget *st_scroll_bar_new (StAdjustment *adjustment);
+
+void          st_scroll_bar_set_adjustment (StScrollBar  *bar,
+                                            StAdjustment *adjustment);
+StAdjustment *st_scroll_bar_get_adjustment (StScrollBar  *bar);
+
+G_END_DECLS
+
+#endif /* __ST_SCROLL_BAR_H__ */

src/st/st-scroll-view.c

@@ -0,0 +1,844 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+/*
+ * st-scroll-view.h: Container with scroll-bars
+ *
+ * Copyright 2008 OpenedHand
+ * 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.
+ *
+ * Written by: Chris Lord <chris@openedhand.com>
+ * Port to St by: Robert Staudinger <robsta@openedhand.com>
+ *
+ */
+
+/**
+ * SECTION:st-scroll-view
+ * @short_description: a container for scrollable children
+ *
+ * #StScrollView is a single child container for actors that implement
+ * #StScrollable. It provides scrollbars around the edge of the child to
+ * allow the user to move around the scrollable area.
+ */
+
+#include "st-scroll-view.h"
+#include "st-marshal.h"
+#include "st-scroll-bar.h"
+#include "st-scrollable.h"
+#include <clutter/clutter.h>
+
+static void clutter_container_iface_init (ClutterContainerIface *iface);
+
+static ClutterContainerIface *st_scroll_view_parent_iface = NULL;
+
+G_DEFINE_TYPE_WITH_CODE (StScrollView, st_scroll_view, ST_TYPE_BIN,
+                         G_IMPLEMENT_INTERFACE (CLUTTER_TYPE_CONTAINER,
+                                                clutter_container_iface_init))
+
+#define SCROLL_VIEW_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), \
+                                                             ST_TYPE_SCROLL_VIEW, \
+                                                             StScrollViewPrivate))
+
+/* Default width (or height - the narrow dimension) for the scrollbars*/
+#define DEFAULT_SCROLLBAR_WIDTH 24
+
+struct _StScrollViewPrivate
+{
+  /* a pointer to the child; this is actually stored
+   * inside StBin:child, but we keep it to avoid
+   * calling st_bin_get_child() every time we need it
+   */
+  ClutterActor *child;
+
+  ClutterActor *hscroll;
+  ClutterActor *vscroll;
+
+  gfloat        row_size;
+  gfloat        column_size;
+
+  gboolean      row_size_set : 1;
+  gboolean      column_size_set : 1;
+  guint         mouse_scroll : 1;
+};
+
+enum {
+  PROP_0,
+
+  PROP_HSCROLL,
+  PROP_VSCROLL,
+  PROP_MOUSE_SCROLL
+};
+
+static void
+st_scroll_view_get_property (GObject    *object,
+                             guint       property_id,
+                             GValue     *value,
+                             GParamSpec *pspec)
+{
+  StScrollViewPrivate *priv = ((StScrollView *) object)->priv;
+
+  switch (property_id)
+    {
+    case PROP_HSCROLL:
+      g_value_set_object (value, priv->hscroll);
+      break;
+    case PROP_VSCROLL:
+      g_value_set_object (value, priv->vscroll);
+      break;
+    case PROP_MOUSE_SCROLL:
+      g_value_set_boolean (value, priv->mouse_scroll);
+      break;
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
+    }
+}
+
+static void
+st_scroll_view_set_property (GObject      *object,
+                             guint         property_id,
+                             const GValue *value,
+                             GParamSpec   *pspec)
+{
+  switch (property_id)
+    {
+    case PROP_MOUSE_SCROLL:
+      st_scroll_view_set_mouse_scrolling ((StScrollView *) object,
+                                          g_value_get_boolean (value));
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
+    }
+}
+
+static void
+st_scroll_view_dispose (GObject *object)
+{
+  StScrollViewPrivate *priv = ST_SCROLL_VIEW (object)->priv;
+
+  priv->child = NULL;
+
+  if (priv->vscroll)
+    {
+      clutter_actor_unparent (priv->vscroll);
+      priv->vscroll = NULL;
+    }
+
+  if (priv->hscroll)
+    {
+      clutter_actor_unparent (priv->hscroll);
+      priv->hscroll = NULL;
+    }
+
+  G_OBJECT_CLASS (st_scroll_view_parent_class)->dispose (object);
+}
+
+static void
+st_scroll_view_finalize (GObject *object)
+{
+  G_OBJECT_CLASS (st_scroll_view_parent_class)->finalize (object);
+}
+
+static void
+st_scroll_view_paint (ClutterActor *actor)
+{
+  StScrollViewPrivate *priv = ST_SCROLL_VIEW (actor)->priv;
+
+  /* StBin will paint the child */
+  CLUTTER_ACTOR_CLASS (st_scroll_view_parent_class)->paint (actor);
+
+  /* paint our custom children */
+  if (CLUTTER_ACTOR_IS_VISIBLE (priv->hscroll))
+    clutter_actor_paint (priv->hscroll);
+  if (CLUTTER_ACTOR_IS_VISIBLE (priv->vscroll))
+    clutter_actor_paint (priv->vscroll);
+}
+
+static void
+st_scroll_view_pick (ClutterActor       *actor,
+                     const ClutterColor *color)
+{
+  StScrollViewPrivate *priv = ST_SCROLL_VIEW (actor)->priv;
+
+  /* Chain up so we get a bounding box pained (if we are reactive) */
+  CLUTTER_ACTOR_CLASS (st_scroll_view_parent_class)->pick (actor, color);
+
+  /* paint our custom children */
+  if (CLUTTER_ACTOR_IS_VISIBLE (priv->hscroll))
+    clutter_actor_paint (priv->hscroll);
+  if (CLUTTER_ACTOR_IS_VISIBLE (priv->vscroll))
+    clutter_actor_paint (priv->vscroll);
+}
+
+static double
+get_scrollbar_width (StScrollView *scroll_view)
+{
+  StThemeNode *theme_node = st_widget_get_theme_node (ST_WIDGET (scroll_view));
+  double result = DEFAULT_SCROLLBAR_WIDTH;
+
+  st_theme_node_get_length (theme_node, "scrollbar-width", FALSE, &result);
+
+  return result;
+}
+
+static double
+get_scrollbar_height (StScrollView *scroll_view)
+{
+  StThemeNode *theme_node = st_widget_get_theme_node (ST_WIDGET (scroll_view));
+  double result = DEFAULT_SCROLLBAR_WIDTH;
+
+  st_theme_node_get_length (theme_node, "scrollbar-height", FALSE, &result);
+
+  return result;
+}
+
+static void
+st_scroll_view_get_preferred_width (ClutterActor *actor,
+                                    gfloat        for_height,
+                                    gfloat       *min_width_p,
+                                    gfloat       *natural_width_p)
+{
+  StScrollViewPrivate *priv = ST_SCROLL_VIEW (actor)->priv;
+  StThemeNode *theme_node = st_widget_get_theme_node (ST_WIDGET (actor));
+
+  if (!priv->child)
+    return;
+
+  st_theme_node_adjust_for_height (theme_node, &for_height);
+
+  /* Our natural width is the natural width of the child */
+  clutter_actor_get_preferred_width (priv->child,
+                                     for_height,
+                                     NULL,
+                                     natural_width_p);
+
+  /* Add space for the scroll-bar if we can determine it will be necessary */
+  if ((for_height >= 0) && natural_width_p)
+    {
+      gfloat natural_height;
+
+      clutter_actor_get_preferred_height (priv->child, -1.0,
+                                          NULL,
+                                          &natural_height);
+      if (for_height < natural_height)
+        *natural_width_p += get_scrollbar_width (ST_SCROLL_VIEW (actor));
+    }
+
+  if (min_width_p)
+    *min_width_p = 0;
+
+  st_theme_node_adjust_preferred_width (theme_node, min_width_p, natural_width_p);
+}
+
+static void
+st_scroll_view_get_preferred_height (ClutterActor *actor,
+                                     gfloat        for_width,
+                                     gfloat       *min_height_p,
+                                     gfloat       *natural_height_p)
+{
+  StScrollViewPrivate *priv = ST_SCROLL_VIEW (actor)->priv;
+  StThemeNode *theme_node = st_widget_get_theme_node (ST_WIDGET (actor));
+
+  if (!priv->child)
+    return;
+
+  st_theme_node_adjust_for_width (theme_node, &for_width);
+
+  /* Our natural height is the natural height of the child */
+  clutter_actor_get_preferred_height (priv->child,
+                                      for_width,
+                                      NULL,
+                                      natural_height_p);
+
+  /* Add space for the scroll-bar if we can determine it will be necessary */
+  if ((for_width >= 0) && natural_height_p)
+    {
+      gfloat natural_width;
+
+      clutter_actor_get_preferred_width (priv->child, -1.0,
+                                         NULL,
+                                         &natural_width);
+      if (for_width < natural_width)
+        *natural_height_p += get_scrollbar_height (ST_SCROLL_VIEW (actor));
+    }
+
+  if (min_height_p)
+    *min_height_p = 0;
+
+  st_theme_node_adjust_preferred_height (theme_node, min_height_p, natural_height_p);
+}
+
+static void
+st_scroll_view_allocate (ClutterActor          *actor,
+                         const ClutterActorBox *box,
+                         ClutterAllocationFlags flags)
+{
+  ClutterActorBox content_box, child_box;
+  ClutterActorClass *parent_parent_class;
+  gfloat avail_width, avail_height, sb_width, sb_height;
+
+  StScrollViewPrivate *priv = ST_SCROLL_VIEW (actor)->priv;
+  StThemeNode *theme_node = st_widget_get_theme_node (ST_WIDGET (actor));
+
+  /* Chain up to the parent's parent class
+   *
+   * We do this because we do not want StBin to allocate the child, as we
+   * give it a different allocation later, depending on whether the scrollbars
+   * are visible
+   */
+  parent_parent_class
+    = g_type_class_peek_parent (st_scroll_view_parent_class);
+
+  CLUTTER_ACTOR_CLASS (parent_parent_class)->
+  allocate (actor, box, flags);
+
+
+  st_theme_node_get_content_box (theme_node, box, &content_box);
+
+  avail_width = content_box.x2 - content_box.x1;
+  avail_height = content_box.y2 - content_box.y1;
+
+  sb_width = get_scrollbar_width (ST_SCROLL_VIEW (actor));
+  sb_height = get_scrollbar_width (ST_SCROLL_VIEW (actor));
+
+  if (!CLUTTER_ACTOR_IS_VISIBLE (priv->vscroll))
+    sb_width = 0;
+
+  if (!CLUTTER_ACTOR_IS_VISIBLE (priv->hscroll))
+    sb_height = 0;
+
+  /* Vertical scrollbar */
+  if (CLUTTER_ACTOR_IS_VISIBLE (priv->vscroll))
+    {
+      child_box.x1 = content_box.x2 - sb_width;
+      child_box.y1 = content_box.y1;
+      child_box.x2 = content_box.x2;
+      child_box.y2 = content_box.y2 - sb_height;
+
+      clutter_actor_allocate (priv->vscroll, &child_box, flags);
+    }
+
+  /* Horizontal scrollbar */
+  if (CLUTTER_ACTOR_IS_VISIBLE (priv->hscroll))
+    {
+      child_box.x1 = content_box.x1;
+      child_box.y1 = content_box.y2 - sb_height;
+      child_box.x2 = content_box.x2 - sb_width;
+      child_box.y2 = content_box.y2;
+
+      clutter_actor_allocate (priv->hscroll, &child_box, flags);
+    }
+
+
+  /* Child */
+  child_box.x1 = content_box.x1;
+  child_box.y1 = content_box.y1;
+  child_box.x2 = content_box.x2 - sb_width;
+  child_box.y2 = content_box.y2 - sb_height;
+
+  if (priv->child)
+    clutter_actor_allocate (priv->child, &child_box, flags);
+}
+
+static void
+st_scroll_view_style_changed (StWidget *widget)
+{
+  StScrollViewPrivate *priv = ST_SCROLL_VIEW (widget)->priv;
+
+  st_widget_style_changed (ST_WIDGET (priv->hscroll));
+  st_widget_style_changed (ST_WIDGET (priv->vscroll));
+
+  ST_WIDGET_CLASS (st_scroll_view_parent_class)->style_changed (widget);
+}
+
+static gboolean
+st_scroll_view_scroll_event (ClutterActor       *self,
+                             ClutterScrollEvent *event)
+{
+  StScrollViewPrivate *priv = ST_SCROLL_VIEW (self)->priv;
+  gdouble lower, value, upper, step;
+  StAdjustment *vadjustment, *hadjustment;
+
+  /* don't handle scroll events if requested not to */
+  if (!priv->mouse_scroll)
+    return FALSE;
+
+  hadjustment = st_scroll_bar_get_adjustment (ST_SCROLL_BAR(priv->hscroll));
+  vadjustment = st_scroll_bar_get_adjustment (ST_SCROLL_BAR(priv->vscroll));
+
+  switch (event->direction)
+    {
+    case CLUTTER_SCROLL_UP:
+    case CLUTTER_SCROLL_DOWN:
+      if (vadjustment)
+        g_object_get (vadjustment,
+                      "lower", &lower,
+                      "step-increment", &step,
+                      "value", &value,
+                      "upper", &upper,
+                      NULL);
+      else
+        return FALSE;
+      break;
+    case CLUTTER_SCROLL_LEFT:
+    case CLUTTER_SCROLL_RIGHT:
+      if (vadjustment)
+        g_object_get (hadjustment,
+                      "lower", &lower,
+                      "step-increment", &step,
+                      "value", &value,
+                      "upper", &upper,
+                      NULL);
+      else
+        return FALSE;
+      break;
+    }
+
+  switch (event->direction)
+    {
+    case CLUTTER_SCROLL_UP:
+      if (value == lower)
+        return FALSE;
+      else
+        st_adjustment_set_value (vadjustment, value - step);
+      break;
+    case CLUTTER_SCROLL_DOWN:
+      if (value == upper)
+        return FALSE;
+      else
+        st_adjustment_set_value (vadjustment, value + step);
+      break;
+    case CLUTTER_SCROLL_LEFT:
+      if (value == lower)
+        return FALSE;
+      else
+        st_adjustment_set_value (hadjustment, value - step);
+      break;
+    case CLUTTER_SCROLL_RIGHT:
+      if (value == upper)
+        return FALSE;
+      else
+        st_adjustment_set_value (hadjustment, value + step);
+      break;
+    }
+
+  return TRUE;
+}
+
+static void
+st_scroll_view_class_init (StScrollViewClass *klass)
+{
+  GParamSpec *pspec;
+  GObjectClass *object_class = G_OBJECT_CLASS (klass);
+  ClutterActorClass *actor_class = CLUTTER_ACTOR_CLASS (klass);
+  StWidgetClass *widget_class = ST_WIDGET_CLASS (klass);
+
+  g_type_class_add_private (klass, sizeof (StScrollViewPrivate));
+
+  object_class->get_property = st_scroll_view_get_property;
+  object_class->set_property = st_scroll_view_set_property;
+  object_class->dispose= st_scroll_view_dispose;
+  object_class->finalize = st_scroll_view_finalize;
+
+  actor_class->paint = st_scroll_view_paint;
+  actor_class->pick = st_scroll_view_pick;
+  actor_class->get_preferred_width = st_scroll_view_get_preferred_width;
+  actor_class->get_preferred_height = st_scroll_view_get_preferred_height;
+  actor_class->allocate = st_scroll_view_allocate;
+  actor_class->scroll_event = st_scroll_view_scroll_event;
+
+  widget_class->style_changed = st_scroll_view_style_changed;
+
+  g_object_class_install_property (object_class,
+                                   PROP_HSCROLL,
+                                   g_param_spec_object ("hscroll",
+                                                        "StScrollBar",
+                                                        "Horizontal scroll indicator",
+                                                        ST_TYPE_SCROLL_BAR,
+                                                        G_PARAM_READABLE));
+
+  g_object_class_install_property (object_class,
+                                   PROP_VSCROLL,
+                                   g_param_spec_object ("vscroll",
+                                                        "StScrollBar",
+                                                        "Vertical scroll indicator",
+                                                        ST_TYPE_SCROLL_BAR,
+                                                        G_PARAM_READABLE));
+
+  pspec = g_param_spec_boolean ("enable-mouse-scrolling",
+                                "Enable Mouse Scrolling",
+                                "Enable automatic mouse wheel scrolling",
+                                TRUE,
+                                G_PARAM_READWRITE);
+  g_object_class_install_property (object_class,
+                                   PROP_MOUSE_SCROLL,
+                                   pspec);
+
+}
+
+static void
+child_adjustment_changed_cb (StAdjustment *adjustment,
+                             ClutterActor *bar)
+{
+  StScrollView *scroll;
+  gdouble lower, upper, page_size;
+
+  scroll = ST_SCROLL_VIEW (clutter_actor_get_parent (bar));
+
+  /* Determine if this scroll-bar should be visible */
+  st_adjustment_get_values (adjustment, NULL,
+                            &lower, &upper,
+                            NULL, NULL,
+                            &page_size);
+
+  if ((upper - lower) > page_size)
+    clutter_actor_show (bar);
+  else
+    clutter_actor_hide (bar);
+
+  /* Request a resize */
+  clutter_actor_queue_relayout (CLUTTER_ACTOR (scroll));
+}
+
+static void
+child_hadjustment_notify_cb (GObject    *gobject,
+                             GParamSpec *arg1,
+                             gpointer    user_data)
+{
+  StAdjustment *hadjust;
+
+  ClutterActor *actor = CLUTTER_ACTOR (gobject);
+  StScrollViewPrivate *priv = ST_SCROLL_VIEW (user_data)->priv;
+
+  hadjust = st_scroll_bar_get_adjustment (ST_SCROLL_BAR(priv->hscroll));
+  if (hadjust)
+    g_signal_handlers_disconnect_by_func (hadjust,
+                                          child_adjustment_changed_cb,
+                                          priv->hscroll);
+
+  st_scrollable_get_adjustments (ST_SCROLLABLE (actor), &hadjust, NULL);
+  if (hadjust)
+    {
+      /* Force scroll step if neede. */
+      if (priv->column_size_set)
+        {
+          g_object_set (hadjust,
+                        "step-increment", priv->column_size,
+                        NULL);
+        }
+
+      st_scroll_bar_set_adjustment (ST_SCROLL_BAR(priv->hscroll), hadjust);
+      g_signal_connect (hadjust, "changed", G_CALLBACK (
+                          child_adjustment_changed_cb), priv->hscroll);
+      child_adjustment_changed_cb (hadjust, priv->hscroll);
+    }
+}
+
+static void
+child_vadjustment_notify_cb (GObject    *gobject,
+                             GParamSpec *arg1,
+                             gpointer    user_data)
+{
+  StAdjustment *vadjust;
+
+  ClutterActor *actor = CLUTTER_ACTOR (gobject);
+  StScrollViewPrivate *priv = ST_SCROLL_VIEW (user_data)->priv;
+
+  vadjust = st_scroll_bar_get_adjustment (ST_SCROLL_BAR(priv->vscroll));
+  if (vadjust)
+    g_signal_handlers_disconnect_by_func (vadjust,
+                                          child_adjustment_changed_cb,
+                                          priv->vscroll);
+
+  st_scrollable_get_adjustments (ST_SCROLLABLE(actor), NULL, &vadjust);
+  if (vadjust)
+    {
+      /* Force scroll step if neede. */
+      if (priv->row_size_set)
+        {
+          g_object_set (vadjust,
+                        "step-increment", priv->row_size,
+                        NULL);
+        }
+
+      st_scroll_bar_set_adjustment (ST_SCROLL_BAR(priv->vscroll), vadjust);
+      g_signal_connect (vadjust, "changed", G_CALLBACK (
+                          child_adjustment_changed_cb), priv->vscroll);
+      child_adjustment_changed_cb (vadjust, priv->vscroll);
+    }
+}
+
+static void
+st_scroll_view_init (StScrollView *self)
+{
+  StScrollViewPrivate *priv = self->priv = SCROLL_VIEW_PRIVATE (self);
+
+  priv->hscroll = CLUTTER_ACTOR (st_scroll_bar_new (NULL));
+  priv->vscroll = g_object_new (ST_TYPE_SCROLL_BAR, "vertical", TRUE, NULL);
+
+  clutter_actor_set_parent (priv->hscroll, CLUTTER_ACTOR (self));
+  clutter_actor_set_parent (priv->vscroll, CLUTTER_ACTOR (self));
+
+  /* mouse scroll is enabled by default, so we also need to be reactive */
+  priv->mouse_scroll = TRUE;
+  g_object_set (G_OBJECT (self), "reactive", TRUE, NULL);
+}
+
+static void
+st_scroll_view_add (ClutterContainer *container,
+                    ClutterActor     *actor)
+{
+  StScrollView *self = ST_SCROLL_VIEW (container);
+  StScrollViewPrivate *priv = self->priv;
+
+  if (ST_IS_SCROLLABLE (actor))
+    {
+      priv->child = actor;
+
+      /* chain up to StBin::add() */
+      st_scroll_view_parent_iface->add (container, actor);
+
+      /* Get adjustments for scroll-bars */
+      g_signal_connect (actor, "notify::hadjustment",
+                        G_CALLBACK (child_hadjustment_notify_cb),
+                        container);
+      g_signal_connect (actor, "notify::vadjustment",
+                        G_CALLBACK (child_vadjustment_notify_cb),
+                        container);
+      child_hadjustment_notify_cb (G_OBJECT (actor), NULL, container);
+      child_vadjustment_notify_cb (G_OBJECT (actor), NULL, container);
+    }
+  else
+    {
+      g_warning ("Attempting to add an actor of type %s to "
+                 "a StScrollView, but the actor does "
+                 "not implement StScrollable.",
+                 g_type_name (G_OBJECT_TYPE (actor)));
+    }
+}
+
+static void
+st_scroll_view_remove (ClutterContainer *container,
+                       ClutterActor     *actor)
+{
+  StScrollViewPrivate *priv = ST_SCROLL_VIEW (container)->priv;
+
+  if (actor == priv->child)
+    {
+      g_object_ref (priv->child);
+
+      /* chain up to StBin::remove() */
+      st_scroll_view_parent_iface->remove (container, actor);
+
+      g_signal_handlers_disconnect_by_func (priv->child,
+                                            child_hadjustment_notify_cb,
+                                            container);
+      g_signal_handlers_disconnect_by_func (priv->child,
+                                            child_vadjustment_notify_cb,
+                                            container);
+      st_scrollable_set_adjustments ((StScrollable*) priv->child, NULL, NULL);
+
+      g_object_unref (priv->child);
+      priv->child = NULL;
+    }
+}
+
+static void
+st_scroll_view_foreach_with_internals (ClutterContainer *container,
+                                       ClutterCallback   callback,
+                                       gpointer          user_data)
+{
+  StScrollViewPrivate *priv = ST_SCROLL_VIEW (container)->priv;
+
+  if (priv->child != NULL)
+    callback (priv->child, user_data);
+
+  if (priv->hscroll != NULL)
+    callback (priv->hscroll, user_data);
+
+  if (priv->vscroll != NULL)
+    callback (priv->vscroll, user_data);
+}
+
+static void
+clutter_container_iface_init (ClutterContainerIface *iface)
+{
+  /* store a pointer to the StBin implementation of
+   * ClutterContainer so that we can chain up when
+   * overriding the methods
+   */
+  st_scroll_view_parent_iface = g_type_interface_peek_parent (iface);
+
+  iface->add = st_scroll_view_add;
+  iface->remove = st_scroll_view_remove;
+  iface->foreach_with_internals = st_scroll_view_foreach_with_internals;
+}
+
+StWidget *
+st_scroll_view_new (void)
+{
+  return g_object_new (ST_TYPE_SCROLL_VIEW, NULL);
+}
+
+/**
+ * st_scroll_view_get_hscroll_bar:
+ * @scroll: a #StScrollView
+ *
+ * Gets the horizontal scrollbar of the scrollbiew
+ *
+ * Return value: (transfer none): the horizontal #StScrollbar
+ */
+ClutterActor *
+st_scroll_view_get_hscroll_bar (StScrollView *scroll)
+{
+  g_return_val_if_fail (ST_IS_SCROLL_VIEW (scroll), NULL);
+
+  return scroll->priv->hscroll;
+}
+
+/**
+ * st_scroll_view_get_vscroll_bar:
+ * @scroll: a #StScrollView
+ *
+ * Gets the vertical scrollbar of the scrollbiew
+ *
+ * Return value: (transfer none): the vertical #StScrollbar
+ */
+ClutterActor *
+st_scroll_view_get_vscroll_bar (StScrollView *scroll)
+{
+  g_return_val_if_fail (ST_IS_SCROLL_VIEW (scroll), NULL);
+
+  return scroll->priv->vscroll;
+}
+
+gfloat
+st_scroll_view_get_column_size (StScrollView *scroll)
+{
+  StAdjustment *adjustment;
+  gdouble column_size;
+
+  g_return_val_if_fail (scroll, 0);
+
+  adjustment = st_scroll_bar_get_adjustment (
+    ST_SCROLL_BAR (scroll->priv->hscroll));
+  g_object_get (adjustment,
+                "step-increment", &column_size,
+                NULL);
+
+  return column_size;
+}
+
+void
+st_scroll_view_set_column_size (StScrollView *scroll,
+                                gfloat        column_size)
+{
+  StAdjustment *adjustment;
+
+  g_return_if_fail (scroll);
+
+  if (column_size < 0)
+    {
+      scroll->priv->column_size_set = FALSE;
+      scroll->priv->column_size = -1;
+    }
+  else
+    {
+      scroll->priv->column_size_set = TRUE;
+      scroll->priv->column_size = column_size;
+
+      adjustment = st_scroll_bar_get_adjustment (
+        ST_SCROLL_BAR (scroll->priv->hscroll));
+
+      if (adjustment)
+        g_object_set (adjustment,
+                      "step-increment", (gdouble) scroll->priv->column_size,
+                      NULL);
+    }
+}
+
+gfloat
+st_scroll_view_get_row_size (StScrollView *scroll)
+{
+  StAdjustment *adjustment;
+  gdouble row_size;
+
+  g_return_val_if_fail (scroll, 0);
+
+  adjustment = st_scroll_bar_get_adjustment (
+    ST_SCROLL_BAR (scroll->priv->vscroll));
+  g_object_get (adjustment,
+                "step-increment", &row_size,
+                NULL);
+
+  return row_size;
+}
+
+void
+st_scroll_view_set_row_size (StScrollView *scroll,
+                             gfloat        row_size)
+{
+  StAdjustment *adjustment;
+
+  g_return_if_fail (scroll);
+
+  if (row_size < 0)
+    {
+      scroll->priv->row_size_set = FALSE;
+      scroll->priv->row_size = -1;
+    }
+  else
+    {
+      scroll->priv->row_size_set = TRUE;
+      scroll->priv->row_size = row_size;
+
+      adjustment = st_scroll_bar_get_adjustment (
+        ST_SCROLL_BAR (scroll->priv->vscroll));
+
+      if (adjustment)
+        g_object_set (adjustment,
+                      "step-increment", (gdouble) scroll->priv->row_size,
+                      NULL);
+    }
+}
+
+void
+st_scroll_view_set_mouse_scrolling (StScrollView *scroll,
+                                    gboolean      enabled)
+{
+  StScrollViewPrivate *priv;
+
+  g_return_if_fail (ST_IS_SCROLL_VIEW (scroll));
+
+  priv = ST_SCROLL_VIEW (scroll)->priv;
+
+  if (priv->mouse_scroll != enabled)
+    {
+      priv->mouse_scroll = enabled;
+
+      /* make sure we can receive mouse wheel events */
+      if (enabled)
+        clutter_actor_set_reactive ((ClutterActor *) scroll, TRUE);
+    }
+}
+
+gboolean
+st_scroll_view_get_mouse_scrolling (StScrollView *scroll)
+{
+  StScrollViewPrivate *priv;
+
+  g_return_val_if_fail (ST_IS_SCROLL_VIEW (scroll), FALSE);
+
+  priv = ST_SCROLL_VIEW (scroll)->priv;
+
+  return priv->mouse_scroll;
+}

src/st/st-scroll-view.h

@@ -0,0 +1,89 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+/*
+ * st-scroll-view.h: Container with scroll-bars
+ *
+ * Copyright 2008 OpenedHand
+ * 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.
+ * Boston, MA 02111-1307, USA.
+ *
+ * Written by: Chris Lord <chris@openedhand.com>
+ * Port to St by: Robert Staudinger <robsta@openedhand.com>
+ *
+ */
+
+#if !defined(ST_H_INSIDE) && !defined(ST_COMPILATION)
+#error "Only <st/st.h> can be included directly.h"
+#endif
+
+#ifndef __ST_SCROLL_VIEW_H__
+#define __ST_SCROLL_VIEW_H__
+
+#include <st/st-bin.h>
+
+G_BEGIN_DECLS
+
+#define ST_TYPE_SCROLL_VIEW            (st_scroll_view_get_type())
+#define ST_SCROLL_VIEW(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), ST_TYPE_SCROLL_VIEW, StScrollView))
+#define ST_IS_SCROLL_VIEW(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), ST_TYPE_SCROLL_VIEW))
+#define ST_SCROLL_VIEW_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), ST_TYPE_SCROLL_VIEW, StScrollViewClass))
+#define ST_IS_SCROLL_VIEW_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), ST_TYPE_SCROLL_VIEW))
+#define ST_SCROLL_VIEW_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), ST_TYPE_SCROLL_VIEW, StScrollViewClass))
+
+typedef struct _StScrollView          StScrollView;
+typedef struct _StScrollViewPrivate   StScrollViewPrivate;
+typedef struct _StScrollViewClass     StScrollViewClass;
+
+/**
+ * StScrollView:
+ *
+ * The contents of this structure are private and should only be accessed
+ * through the public API.
+ */
+struct _StScrollView
+{
+  /*< private >*/
+  StBin parent_instance;
+
+  StScrollViewPrivate *priv;
+};
+
+struct _StScrollViewClass
+{
+  StBinClass parent_class;
+};
+
+GType st_scroll_view_get_type (void) G_GNUC_CONST;
+
+StWidget *st_scroll_view_new (void);
+
+ClutterActor *st_scroll_view_get_hscroll_bar     (StScrollView *scroll);
+ClutterActor *st_scroll_view_get_vscroll_bar     (StScrollView *scroll);
+
+gfloat        st_scroll_view_get_column_size     (StScrollView *scroll);
+void          st_scroll_view_set_column_size     (StScrollView *scroll,
+                                                  gfloat        column_size);
+
+gfloat        st_scroll_view_get_row_size        (StScrollView *scroll);
+void          st_scroll_view_set_row_size        (StScrollView *scroll,
+                                                  gfloat        row_size);
+
+void          st_scroll_view_set_mouse_scrolling (StScrollView *scroll,
+                                                  gboolean      enabled);
+gboolean      st_scroll_view_get_mouse_scrolling (StScrollView *scroll);
+
+G_END_DECLS
+
+#endif /* __ST_SCROLL_VIEW_H__ */

src/st/st-scrollable.c

@@ -0,0 +1,97 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+/*
+ * st-scrollable.c: Scrollable interface
+ *
+ * Copyright 2008 OpenedHand
+ * 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.
+ *
+ * Written by: Chris Lord <chris@openedhand.com>
+ * Port to St by: Robert Staudinger <robsta@openedhand.com>
+ *
+ */
+
+#include "st-scrollable.h"
+
+static void
+st_scrollable_base_init (gpointer g_iface)
+{
+  static gboolean initialized = FALSE;
+
+  if (!initialized)
+    {
+      g_object_interface_install_property (g_iface,
+                                           g_param_spec_object ("hadjustment",
+                                                                "StAdjustment",
+                                                                "Horizontal adjustment",
+                                                                ST_TYPE_ADJUSTMENT,
+                                                                G_PARAM_READWRITE));
+
+      g_object_interface_install_property (g_iface,
+                                           g_param_spec_object ("vadjustment",
+                                                                "StAdjustment",
+                                                                "Vertical adjustment",
+                                                                ST_TYPE_ADJUSTMENT,
+                                                                G_PARAM_READWRITE));
+
+      initialized = TRUE;
+    }
+}
+
+GType
+st_scrollable_get_type (void)
+{
+  static GType type = 0;
+  if (type == 0)
+    {
+      static const GTypeInfo info =
+      {
+        sizeof (StScrollableInterface),
+        st_scrollable_base_init,          /* base_init */
+        NULL,
+      };
+      type = g_type_register_static (G_TYPE_INTERFACE,
+                                     "StScrollable", &info, 0);
+    }
+  return type;
+}
+
+void
+st_scrollable_set_adjustments (StScrollable *scrollable,
+                               StAdjustment *hadjustment,
+                               StAdjustment *vadjustment)
+{
+  ST_SCROLLABLE_GET_INTERFACE (scrollable)->set_adjustments (scrollable,
+                                                             hadjustment,
+                                                             vadjustment);
+}
+
+/**
+ * st_scroll_bar_get_adjustments:
+ * @hadjustment: (transfer none) (out) (allow-none): location to store the horizontal adjustment, or %NULL
+ * @vadjustment: (transfer none) (out) (allow-none): location to store the vertical adjustment, or %NULL
+ *
+ * Gets the adjustment objects that store the offsets of the scrollable widget
+ * into its possible scrolling area.
+ */
+void
+st_scrollable_get_adjustments (StScrollable  *scrollable,
+                               StAdjustment **hadjustment,
+                               StAdjustment **vadjustment)
+{
+  ST_SCROLLABLE_GET_INTERFACE (scrollable)->get_adjustments (scrollable,
+                                                             hadjustment,
+                                                             vadjustment);
+}

src/st/st-scrollable.h

@@ -0,0 +1,70 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+/*
+ * st-scrollable.h: Scrollable interface
+ *
+ * Copyright 2008 OpenedHand
+ * 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.
+ * Boston, MA 02111-1307, USA.
+ *
+ * Written by: Chris Lord <chris@openedhand.com>
+ * Port to St by: Robert Staudinger <robsta@openedhand.com>
+ *
+ */
+
+#if !defined(ST_H_INSIDE) && !defined(ST_COMPILATION)
+#error "Only <st/st.h> can be included directly.h"
+#endif
+
+#ifndef __ST_SCROLLABLE_H__
+#define __ST_SCROLLABLE_H__
+
+#include <glib-object.h>
+#include <st/st-adjustment.h>
+
+G_BEGIN_DECLS
+
+#define ST_TYPE_SCROLLABLE                (st_scrollable_get_type ())
+#define ST_SCROLLABLE(obj)                (G_TYPE_CHECK_INSTANCE_CAST ((obj), ST_TYPE_SCROLLABLE, StScrollable))
+#define ST_IS_SCROLLABLE(obj)             (G_TYPE_CHECK_INSTANCE_TYPE ((obj), ST_TYPE_SCROLLABLE))
+#define ST_SCROLLABLE_GET_INTERFACE(inst) (G_TYPE_INSTANCE_GET_INTERFACE ((inst), ST_TYPE_SCROLLABLE, StScrollableInterface))
+
+typedef struct _StScrollable StScrollable; /* Dummy object */
+typedef struct _StScrollableInterface StScrollableInterface;
+
+struct _StScrollableInterface
+{
+  GTypeInterface parent;
+
+  void (* set_adjustments) (StScrollable  *scrollable,
+                            StAdjustment  *hadjustment,
+                            StAdjustment  *vadjustment);
+  void (* get_adjustments) (StScrollable  *scrollable,
+                            StAdjustment **hadjustment,
+                            StAdjustment **vadjustment);
+};
+
+GType st_scrollable_get_type (void) G_GNUC_CONST;
+
+void st_scrollable_set_adjustments (StScrollable  *scrollable,
+                                    StAdjustment  *hadjustment,
+                                    StAdjustment  *vadjustment);
+void st_scrollable_get_adjustments (StScrollable  *scrollable,
+                                    StAdjustment **hadjustment,
+                                    StAdjustment **vadjustment);
+
+G_END_DECLS
+
+#endif /* __ST_SCROLLABLE_H__ */

src/st/st-subtexture.c

@@ -0,0 +1,576 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+/*
+ * st-subtexture.h: Class to wrap a texture and "subframe" it.
+ * based on
+ * st-texture-frame.c: Expandible texture actor
+ *
+ * Copyright 2007 OpenedHand
+ * 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.
+ * Boston, MA 02111-1307, USA.
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include <cogl/cogl.h>
+#include <clutter/clutter.h>
+
+#include "st-subtexture.h"
+
+enum
+{
+  PROP_0,
+
+  PROP_PARENT_TEXTURE,
+
+  PROP_TOP,
+  PROP_LEFT,
+  PROP_WIDTH,
+  PROP_HEIGHT
+};
+
+G_DEFINE_TYPE (StSubtexture, st_subtexture, CLUTTER_TYPE_ACTOR);
+
+#define ST_SUBTEXTURE_GET_PRIVATE(obj)     (G_TYPE_INSTANCE_GET_PRIVATE ((obj), ST_TYPE_SUBTEXTURE, StSubtexturePrivate))
+
+struct _StSubtexturePrivate
+{
+  ClutterTexture *parent_texture;
+
+  int             left;
+  int             top;
+  int             width;
+  int             height;
+
+  CoglHandle      material;
+};
+
+static void
+st_subtexture_get_preferred_width (ClutterActor *self,
+                                   gfloat        for_height,
+                                   gfloat       *min_width_p,
+                                   gfloat       *natural_width_p)
+{
+  StSubtexturePrivate *priv = ST_SUBTEXTURE (self)->priv;
+
+  if (G_UNLIKELY (priv->parent_texture == NULL))
+    {
+      if (min_width_p)
+        *min_width_p = 0;
+
+      if (natural_width_p)
+        *natural_width_p = 0;
+    }
+  else
+    {
+      if (min_width_p)
+        *min_width_p = priv->width;
+      if (natural_width_p)
+        *natural_width_p = priv->width;
+    }
+}
+
+static void
+st_subtexture_get_preferred_height (ClutterActor *self,
+                                    gfloat        for_width,
+                                    gfloat       *min_height_p,
+                                    gfloat       *natural_height_p)
+{
+  StSubtexturePrivate *priv = ST_SUBTEXTURE (self)->priv;
+
+  if (G_UNLIKELY (priv->parent_texture == NULL))
+    {
+      if (min_height_p)
+        *min_height_p = 0;
+
+      if (natural_height_p)
+        *natural_height_p = 0;
+    }
+  else
+    {
+      if (min_height_p)
+        *min_height_p = priv->height;
+      if (natural_height_p)
+        *natural_height_p = priv->height;
+    }
+}
+
+static void
+st_subtexture_realize (ClutterActor *self)
+{
+  StSubtexturePrivate *priv = ST_SUBTEXTURE (self)->priv;
+
+  if (priv->material != COGL_INVALID_HANDLE)
+    return;
+
+  priv->material = cogl_material_new ();
+
+  CLUTTER_ACTOR_SET_FLAGS (self, CLUTTER_ACTOR_REALIZED);
+}
+
+static void
+st_subtexture_unrealize (ClutterActor *self)
+{
+  StSubtexturePrivate *priv = ST_SUBTEXTURE (self)->priv;
+
+  if (priv->material == COGL_INVALID_HANDLE)
+    return;
+
+  cogl_material_unref (priv->material);
+  priv->material = COGL_INVALID_HANDLE;
+
+  CLUTTER_ACTOR_UNSET_FLAGS (self, CLUTTER_ACTOR_REALIZED);
+}
+
+static void
+st_subtexture_paint (ClutterActor *self)
+{
+  StSubtexturePrivate *priv = ST_SUBTEXTURE (self)->priv;
+  CoglHandle cogl_texture = COGL_INVALID_HANDLE;
+  ClutterActorBox box = { 0, 0, 0, 0 };
+  gfloat tx1, ty1, tx2, ty2, tex_width, tex_height, width, height;
+  guint8 opacity;
+
+  /* no need to paint stuff if we don't have a texture */
+  if (G_UNLIKELY (priv->parent_texture == NULL))
+    return;
+
+  /* parent texture may have been hidden, so need to make sure it gets
+   * realized
+   */
+  if (!CLUTTER_ACTOR_IS_REALIZED (priv->parent_texture))
+    clutter_actor_realize (CLUTTER_ACTOR (priv->parent_texture));
+
+  cogl_texture = clutter_texture_get_cogl_texture (priv->parent_texture);
+  if (cogl_texture == COGL_INVALID_HANDLE)
+    return;
+
+  tex_width  = cogl_texture_get_width (cogl_texture);
+  tex_height = cogl_texture_get_height (cogl_texture);
+
+  clutter_actor_get_allocation_box (self, &box);
+
+  width = box.x2 - box.x1;
+  height = box.y2 - box.y1;
+
+  tx1 = 1.0 *  priv->left / tex_width;
+  ty1 = 1.0 * priv->top / tex_height;
+
+  tx2 = 1.0 * (priv->left + priv->width) / tex_width;
+  ty2 = 1.0 * (priv->top + priv->height) / tex_height;
+
+
+  opacity = clutter_actor_get_paint_opacity (self);
+
+  g_assert (priv->material != COGL_INVALID_HANDLE);
+
+  /* set the source material using the parent texture's COGL handle */
+  cogl_material_set_color4ub (priv->material, 255, 255, 255, opacity);
+  cogl_material_set_layer (priv->material, 0, cogl_texture);
+  cogl_set_source (priv->material);
+
+  cogl_rectangle_with_texture_coords (0,0, (float) width, (float) height,
+                                      tx1, ty1, tx2, ty2);
+}
+
+static inline void
+st_subtexture_set_frame_internal (StSubtexture *frame,
+                                  int           left,
+                                  int           top,
+                                  int           width,
+                                  int           height)
+{
+  StSubtexturePrivate *priv = frame->priv;
+  GObject *gobject = G_OBJECT (frame);
+  gboolean changed = FALSE;
+
+  g_object_freeze_notify (gobject);
+
+  if (priv->top != top)
+    {
+      priv->top = top;
+      g_object_notify (gobject, "top");
+      changed = TRUE;
+    }
+
+  if (priv->left != left)
+    {
+      priv->left = left;
+      g_object_notify (gobject, "left");
+      changed = TRUE;
+    }
+
+  if (priv->width != width)
+    {
+      priv->width = width;
+      g_object_notify (gobject, "width");
+      changed = TRUE;
+    }
+
+  if (priv->height != height)
+    {
+      priv->height = height;
+      g_object_notify (gobject, "height");
+      changed = TRUE;
+    }
+
+  if (changed && CLUTTER_ACTOR_IS_VISIBLE (frame))
+    clutter_actor_queue_redraw (CLUTTER_ACTOR (frame));
+
+  g_object_thaw_notify (gobject);
+}
+
+static void
+st_subtexture_set_property (GObject      *gobject,
+                            guint         prop_id,
+                            const GValue *value,
+                            GParamSpec   *pspec)
+{
+  StSubtexture *frame = ST_SUBTEXTURE (gobject);
+  StSubtexturePrivate *priv = frame->priv;
+
+  switch (prop_id)
+    {
+    case PROP_PARENT_TEXTURE:
+      st_subtexture_set_parent_texture (frame,
+                                        g_value_get_object (value));
+      break;
+
+    case PROP_TOP:
+      st_subtexture_set_frame_internal (frame,
+                                        priv->left,
+                                        g_value_get_int (value),
+                                        priv->width,
+                                        priv->height);
+      break;
+
+    case PROP_LEFT:
+      st_subtexture_set_frame_internal (frame,
+                                        g_value_get_int (value),
+                                        priv->top,
+                                        priv->width,
+                                        priv->height);
+      break;
+
+    case PROP_WIDTH:
+      st_subtexture_set_frame_internal (frame,
+                                        priv->left,
+                                        priv->top,
+                                        g_value_get_int (value),
+                                        priv->height);
+      break;
+
+    case PROP_HEIGHT:
+      st_subtexture_set_frame_internal (frame,
+                                        priv->left,
+                                        priv->top,
+                                        priv->width,
+                                        g_value_get_int (value));
+      break;
+
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (gobject, prop_id, pspec);
+      break;
+    }
+}
+
+static void
+st_subtexture_get_property (GObject    *gobject,
+                            guint       prop_id,
+                            GValue     *value,
+                            GParamSpec *pspec)
+{
+  StSubtexturePrivate *priv = ST_SUBTEXTURE (gobject)->priv;
+
+  switch (prop_id)
+    {
+    case PROP_PARENT_TEXTURE:
+      g_value_set_object (value, priv->parent_texture);
+      break;
+
+    case PROP_LEFT:
+      g_value_set_int (value, priv->left);
+      break;
+
+    case PROP_TOP:
+      g_value_set_int (value, priv->top);
+      break;
+
+    case PROP_WIDTH:
+      g_value_set_int (value, priv->width);
+      break;
+
+    case PROP_HEIGHT:
+      g_value_set_int (value, priv->height);
+      break;
+
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (gobject, prop_id, pspec);
+      break;
+    }
+}
+
+static void
+st_subtexture_dispose (GObject *gobject)
+{
+  StSubtexturePrivate *priv = ST_SUBTEXTURE (gobject)->priv;
+
+  if (priv->parent_texture)
+    {
+      g_object_unref (priv->parent_texture);
+      priv->parent_texture = NULL;
+    }
+
+  if (priv->material)
+    {
+      cogl_material_unref (priv->material);
+      priv->material = COGL_INVALID_HANDLE;
+    }
+
+  G_OBJECT_CLASS (st_subtexture_parent_class)->dispose (gobject);
+}
+
+static void
+st_subtexture_class_init (StSubtextureClass *klass)
+{
+  GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
+  ClutterActorClass *actor_class = CLUTTER_ACTOR_CLASS (klass);
+  GParamSpec *pspec;
+
+  g_type_class_add_private (gobject_class, sizeof (StSubtexturePrivate));
+
+  actor_class->get_preferred_width =
+    st_subtexture_get_preferred_width;
+  actor_class->get_preferred_height =
+    st_subtexture_get_preferred_height;
+  actor_class->realize = st_subtexture_realize;
+  actor_class->unrealize = st_subtexture_unrealize;
+  actor_class->paint = st_subtexture_paint;
+
+  gobject_class->set_property = st_subtexture_set_property;
+  gobject_class->get_property = st_subtexture_get_property;
+  gobject_class->dispose = st_subtexture_dispose;
+
+  pspec = g_param_spec_object ("parent-texture",
+                               "Parent Texture",
+                               "The parent ClutterTexture",
+                               CLUTTER_TYPE_TEXTURE,
+                               G_PARAM_READWRITE |
+                               G_PARAM_CONSTRUCT);
+  g_object_class_install_property (gobject_class, PROP_PARENT_TEXTURE, pspec);
+
+  pspec = g_param_spec_int ("left",
+                            "Left",
+                            "Left offset",
+                            0, G_MAXINT,
+                            0,
+                            G_PARAM_READWRITE);
+  g_object_class_install_property (gobject_class, PROP_LEFT, pspec);
+
+  pspec = g_param_spec_int ("top",
+                            "Top",
+                            "Top offset",
+                            0, G_MAXINT,
+                            0,
+                            G_PARAM_READWRITE);
+  g_object_class_install_property (gobject_class, PROP_TOP, pspec);
+
+  pspec = g_param_spec_int ("width",
+                            "Width",
+                            "Width",
+                            0, G_MAXINT,
+                            0,
+                            G_PARAM_READWRITE);
+  g_object_class_install_property (gobject_class, PROP_WIDTH, pspec);
+
+  pspec = g_param_spec_int ("height",
+                            "Height",
+                            "Height",
+                            0, G_MAXINT,
+                            0,
+                            G_PARAM_READWRITE);
+  g_object_class_install_property (gobject_class, PROP_HEIGHT, pspec);
+}
+
+static void
+st_subtexture_init (StSubtexture *self)
+{
+  StSubtexturePrivate *priv;
+
+  self->priv = priv = ST_SUBTEXTURE_GET_PRIVATE (self);
+
+  priv->material = COGL_INVALID_HANDLE;
+}
+
+/**
+ * st_subtexture_new:
+ * @texture: a #ClutterTexture or %NULL
+ * @left: left
+ * @top: top
+ * @width: width
+ * @height: height
+ *
+ * A #StSubtexture is a specialized texture that efficiently clones
+ * an area of the given @texture while keeping preserving portions of the
+ * same texture.
+ *
+ * A #StSubtexture can be used to make a rectangular texture fit a
+ * given size without stretching its borders.
+ *
+ * Return value: the newly created #StSubtexture
+ */
+ClutterActor*
+st_subtexture_new (ClutterTexture *texture,
+                   gint            left,
+                   gint            top,
+                   gint            width,
+                   gint            height)
+{
+  g_return_val_if_fail (texture == NULL || CLUTTER_IS_TEXTURE (texture), NULL);
+
+  return g_object_new (ST_TYPE_SUBTEXTURE,
+                       "parent-texture", texture,
+                       "top", top,
+                       "left", left,
+                       "width", width,
+                       "height", height,
+                       NULL);
+}
+
+/**
+ * st_subtexture_get_parent_texture:
+ * @frame: A #StSubtexture
+ *
+ * Return the texture used by the #StSubtexture
+ *
+ * Returns: (transfer none): a #ClutterTexture owned by the #StSubtexture
+ */
+ClutterTexture *
+st_subtexture_get_parent_texture (StSubtexture *frame)
+{
+  g_return_val_if_fail (ST_IS_SUBTEXTURE (frame), NULL);
+
+  return frame->priv->parent_texture;
+}
+
+/**
+ * st_subtexture_set_parent_texture:
+ * @frame: A #StSubtexture
+ * @texture: A #ClutterTexture
+ *
+ * Set the #ClutterTexture used by this #StSubtexture
+ *
+ */
+void
+st_subtexture_set_parent_texture (StSubtexture   *frame,
+                                  ClutterTexture *texture)
+{
+  StSubtexturePrivate *priv;
+  gboolean was_visible;
+
+  g_return_if_fail (ST_IS_SUBTEXTURE (frame));
+  g_return_if_fail (texture == NULL || CLUTTER_IS_TEXTURE (texture));
+
+  priv = frame->priv;
+
+  was_visible = CLUTTER_ACTOR_IS_VISIBLE (frame);
+
+  if (priv->parent_texture == texture)
+    return;
+
+  if (priv->parent_texture)
+    {
+      g_object_unref (priv->parent_texture);
+      priv->parent_texture = NULL;
+
+      if (was_visible)
+        clutter_actor_hide (CLUTTER_ACTOR (frame));
+    }
+
+  if (texture)
+    {
+      priv->parent_texture = g_object_ref (texture);
+
+      if (was_visible && CLUTTER_ACTOR_IS_VISIBLE (priv->parent_texture))
+        clutter_actor_show (CLUTTER_ACTOR (frame));
+    }
+
+  clutter_actor_queue_relayout (CLUTTER_ACTOR (frame));
+
+  g_object_notify (G_OBJECT (frame), "parent-texture");
+}
+
+/**
+ * st_subtexture_set_frame:
+ * @frame: A #StSubtexture
+ * @left: left
+ * @top: top
+ * @width: width
+ * @height: height
+ *
+ * Set the frame of the subtexture
+ *
+ */
+void
+st_subtexture_set_frame (StSubtexture *frame,
+                         gint          left,
+                         gint          top,
+                         gint          width,
+                         gint          height)
+{
+  g_return_if_fail (ST_IS_SUBTEXTURE (frame));
+
+  st_subtexture_set_frame_internal (frame, left, top, width, height);
+}
+
+/**
+ * st_subtexture_get_frame:
+ * @frame: A #StSubtexture
+ * @left: left
+ * @top: top
+ * @width: width
+ * @height: height
+ *
+ * Retrieve the current frame.
+ *
+ */
+void
+st_subtexture_get_frame (StSubtexture *frame,
+                         gint         *left,
+                         gint         *top,
+                         gint         *width,
+                         gint         *height)
+{
+  StSubtexturePrivate *priv;
+
+  g_return_if_fail (ST_IS_SUBTEXTURE (frame));
+
+  priv = frame->priv;
+
+  if (top)
+    *top = priv->top;
+
+  if (left)
+    *left = priv->left;
+
+  if (width)
+    *width = priv->width;
+
+  if (height)
+    *height = priv->height;
+}

src/st/st-subtexture.h

@@ -0,0 +1,97 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+/*
+ * st-subtexture.h: Class to wrap a texture and "subframe" it.
+ *
+ * Based on
+ * st-texture-frame.h: Expandible texture actor
+ *
+ * Copyright 2007, 2008 OpenedHand Ltd
+ * 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.
+ * Boston, MA 02111-1307, USA.
+ *
+ */
+
+#if !defined(ST_H_INSIDE) && !defined(ST_COMPILATION)
+#error "Only <st/st.h> can be included directly.h"
+#endif
+
+#ifndef __ST_SUBTEXTURE_H__
+#define __ST_SUBTEXTURE_H__
+
+#include <clutter/clutter.h>
+
+G_BEGIN_DECLS
+
+#define ST_TYPE_SUBTEXTURE                 (st_subtexture_get_type ())
+#define ST_SUBTEXTURE(obj)                 (G_TYPE_CHECK_INSTANCE_CAST ((obj), ST_TYPE_SUBTEXTURE, StSubtexture))
+#define ST_SUBTEXTURE_CLASS(klass)         (G_TYPE_CHECK_CLASS_CAST ((klass), ST_TYPE_SUBTEXTURE, StSubtextureClass))
+#define ST_IS_SUBTEXTURE(obj)              (G_TYPE_CHECK_INSTANCE_TYPE ((obj), ST_TYPE_SUBTEXTURE))
+#define ST_IS_SUBTEXTURE_CLASS(klass)      (G_TYPE_CHECK_CLASS_TYPE ((klass), ST_TYPE_SUBTEXTURE))
+#define ST_SUBTEXTURE_GET_CLASS(obj)       (G_TYPE_INSTANCE_GET_CLASS ((obj), ST_TYPE_SUBTEXTURE, StSubtextureClass))
+
+typedef struct _StSubtexture                StSubtexture;
+typedef struct _StSubtexturePrivate         StSubtexturePrivate;
+typedef struct _StSubtextureClass           StSubtextureClass;
+
+/**
+ * StSubtexture:
+ *
+ * The contents of this structure are private and should only be accessed
+ * through the public API.
+ */
+struct _StSubtexture
+{
+  /*< private >*/
+  ClutterActor parent_instance;
+  
+  StSubtexturePrivate    *priv;
+};
+
+struct _StSubtextureClass 
+{
+  ClutterActorClass parent_class;
+
+  /* padding for future expansion */
+  void (*_st_box_1) (void);
+  void (*_st_box_2) (void);
+  void (*_st_box_3) (void);
+  void (*_st_box_4) (void);
+}; 
+
+GType st_subtexture_get_type (void) G_GNUC_CONST;
+
+ClutterActor *  st_subtexture_new                (ClutterTexture *texture,
+                                                  gint            top,
+                                                  gint            left,
+                                                  gint            width,
+                                                  gint            height);
+void            st_subtexture_set_parent_texture (StSubtexture   *frame,
+                                                  ClutterTexture *texture);
+ClutterTexture *st_subtexture_get_parent_texture (StSubtexture   *frame);
+void            st_subtexture_set_frame          (StSubtexture   *frame,
+                                                  gint            top,
+                                                  gint            left,
+                                                  gint            width,
+                                                  gint            height);
+void            st_subtexture_get_frame          (StSubtexture   *frame,
+                                                  gint           *top,
+                                                  gint           *left,
+                                                  gint           *width,
+                                                  gint           *height);
+
+G_END_DECLS
+
+#endif /* __ST_SUBTEXTURE_H__ */

src/st/st-table-child.c

@@ -0,0 +1,805 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+/*
+ * st-table-child.h: Table child implementation
+ *
+ * Copyright 2008, 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.
+ * Boston, MA 02111-1307, USA.
+ *
+ * Written by: Thomas Wood  <thomas.wood@intel.com>
+ *
+ */
+
+#include "st-private.h"
+#include "st-table-child.h"
+#include "st-table-private.h"
+#include <st/st-widget.h>
+#include <st/st-table.h>
+
+/*
+ * ClutterChildMeta Implementation
+ */
+
+/**
+ * SECTION:st-table-child
+ * @short_description: The child property store for #StTable
+ *
+ * The #ClutterChildMeta implementation for the #StTable container widget.
+ *
+ */
+
+enum {
+  CHILD_PROP_0,
+
+  CHILD_PROP_COL,
+  CHILD_PROP_ROW,
+  CHILD_PROP_COL_SPAN,
+  CHILD_PROP_ROW_SPAN,
+  CHILD_PROP_X_EXPAND,
+  CHILD_PROP_Y_EXPAND,
+  CHILD_PROP_X_ALIGN,
+  CHILD_PROP_Y_ALIGN,
+  CHILD_PROP_X_FILL,
+  CHILD_PROP_Y_FILL,
+  CHILD_PROP_ALLOCATE_HIDDEN,
+};
+
+G_DEFINE_TYPE (StTableChild, st_table_child, CLUTTER_TYPE_CHILD_META);
+
+static void
+table_child_set_property (GObject      *gobject,
+                          guint         prop_id,
+                          const GValue *value,
+                          GParamSpec   *pspec)
+{
+  StTableChild *child = ST_TABLE_CHILD (gobject);
+  StTable *table = ST_TABLE (CLUTTER_CHILD_META(gobject)->container);
+
+  switch (prop_id)
+    {
+    case CHILD_PROP_COL:
+      child->col = g_value_get_int (value);
+      _st_table_update_row_col (table, -1, child->col);
+      clutter_actor_queue_relayout (CLUTTER_ACTOR (table));
+      break;
+    case CHILD_PROP_ROW:
+      child->row = g_value_get_int (value);
+      _st_table_update_row_col (table, child->row, -1);
+      clutter_actor_queue_relayout (CLUTTER_ACTOR (table));
+      break;
+    case CHILD_PROP_COL_SPAN:
+      child->col_span = g_value_get_int (value);
+      clutter_actor_queue_relayout (CLUTTER_ACTOR (table));
+      break;
+    case CHILD_PROP_ROW_SPAN:
+      child->row_span = g_value_get_int (value);
+      clutter_actor_queue_relayout (CLUTTER_ACTOR (table));
+      break;
+    case CHILD_PROP_X_EXPAND:
+      child->x_expand = g_value_get_boolean (value);
+      clutter_actor_queue_relayout (CLUTTER_ACTOR (table));
+      break;
+    case CHILD_PROP_Y_EXPAND:
+      child->y_expand = g_value_get_boolean (value);
+      clutter_actor_queue_relayout (CLUTTER_ACTOR (table));
+      break;
+    case CHILD_PROP_X_ALIGN:
+      child->x_align = g_value_get_double (value);
+      clutter_actor_queue_relayout (CLUTTER_ACTOR (table));
+      break;
+    case CHILD_PROP_Y_ALIGN:
+      child->y_align = g_value_get_double (value);
+      clutter_actor_queue_relayout (CLUTTER_ACTOR (table));
+      break;
+    case CHILD_PROP_X_FILL:
+      child->x_fill = g_value_get_boolean (value);
+      clutter_actor_queue_relayout (CLUTTER_ACTOR (table));
+      break;
+    case CHILD_PROP_Y_FILL:
+      child->y_fill = g_value_get_boolean (value);
+      clutter_actor_queue_relayout (CLUTTER_ACTOR (table));
+      break;
+    case CHILD_PROP_ALLOCATE_HIDDEN:
+      child->allocate_hidden = g_value_get_boolean (value);
+      clutter_actor_queue_relayout (CLUTTER_ACTOR (table));
+      break;
+
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (gobject, prop_id, pspec);
+      break;
+    }
+}
+
+static void
+table_child_get_property (GObject    *gobject,
+                          guint       prop_id,
+                          GValue     *value,
+                          GParamSpec *pspec)
+{
+  StTableChild *child = ST_TABLE_CHILD (gobject);
+
+  switch (prop_id)
+    {
+    case CHILD_PROP_COL:
+      g_value_set_int (value, child->col);
+      break;
+    case CHILD_PROP_ROW:
+      g_value_set_int (value, child->row);
+      break;
+    case CHILD_PROP_COL_SPAN:
+      g_value_set_int (value, child->col_span);
+      break;
+    case CHILD_PROP_ROW_SPAN:
+      g_value_set_int (value, child->row_span);
+      break;
+    case CHILD_PROP_X_EXPAND:
+      g_value_set_boolean (value, child->x_expand);
+      break;
+    case CHILD_PROP_Y_EXPAND:
+      g_value_set_boolean (value, child->y_expand);
+      break;
+    case CHILD_PROP_X_ALIGN:
+      g_value_set_double (value, child->x_align);
+      break;
+    case CHILD_PROP_Y_ALIGN:
+      g_value_set_double (value, child->y_align);
+      break;
+    case CHILD_PROP_X_FILL:
+      g_value_set_boolean (value, child->x_fill);
+      break;
+    case CHILD_PROP_Y_FILL:
+      g_value_set_boolean (value, child->y_fill);
+      break;
+    case CHILD_PROP_ALLOCATE_HIDDEN:
+      g_value_set_boolean (value, child->allocate_hidden);
+      break;
+
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (gobject, prop_id, pspec);
+      break;
+    }
+}
+
+static void
+st_table_child_class_init (StTableChildClass *klass)
+{
+  GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
+  GParamSpec *pspec;
+
+  gobject_class->set_property = table_child_set_property;
+  gobject_class->get_property = table_child_get_property;
+
+  pspec = g_param_spec_int ("col",
+                            "Column Number",
+                            "The column the widget resides in",
+                            0, G_MAXINT,
+                            0,
+                            ST_PARAM_READWRITE);
+
+  g_object_class_install_property (gobject_class, CHILD_PROP_COL, pspec);
+
+  pspec = g_param_spec_int ("row",
+                            "Row Number",
+                            "The row the widget resides in",
+                            0, G_MAXINT,
+                            0,
+                            ST_PARAM_READWRITE);
+
+  g_object_class_install_property (gobject_class, CHILD_PROP_ROW, pspec);
+
+  pspec = g_param_spec_int ("row-span",
+                            "Row Span",
+                            "The number of rows the widget should span",
+                            1, G_MAXINT,
+                            1,
+                            ST_PARAM_READWRITE);
+
+  g_object_class_install_property (gobject_class, CHILD_PROP_ROW_SPAN, pspec);
+
+  pspec = g_param_spec_int ("col-span",
+                            "Column Span",
+                            "The number of columns the widget should span",
+                            1, G_MAXINT,
+                            1,
+                            ST_PARAM_READWRITE);
+
+  g_object_class_install_property (gobject_class, CHILD_PROP_COL_SPAN, pspec);
+
+  pspec = g_param_spec_boolean ("x-expand",
+                                "X Expand",
+                                "Whether the child should receive priority "
+                                "when the container is allocating spare space "
+                                "on the horizontal axis",
+                                TRUE,
+                                ST_PARAM_READWRITE);
+
+  g_object_class_install_property (gobject_class, CHILD_PROP_X_EXPAND, pspec);
+
+  pspec = g_param_spec_boolean ("y-expand",
+                                "Y Expand",
+                                "Whether the child should receive priority "
+                                "when the container is allocating spare space "
+                                "on the vertical axis",
+                                TRUE,
+                                ST_PARAM_READWRITE);
+
+  g_object_class_install_property (gobject_class, CHILD_PROP_Y_EXPAND, pspec);
+
+  pspec = g_param_spec_double ("x-align",
+                               "X Alignment",
+                               "X alignment of the widget within the cell",
+                               0, 1,
+                               0.5,
+                               ST_PARAM_READWRITE);
+
+  g_object_class_install_property (gobject_class, CHILD_PROP_X_ALIGN, pspec);
+
+  pspec = g_param_spec_double ("y-align",
+                               "Y Alignment",
+                               "Y alignment of the widget within the cell",
+                               0, 1,
+                               0.5,
+                               ST_PARAM_READWRITE);
+
+  g_object_class_install_property (gobject_class, CHILD_PROP_Y_ALIGN, pspec);
+
+  pspec = g_param_spec_boolean ("x-fill",
+                                "X Fill",
+                                "Whether the child should be allocated its "
+                                "entire available space, or whether it should "
+                                "be squashed and aligned.",
+                                TRUE,
+                                ST_PARAM_READWRITE);
+
+  g_object_class_install_property (gobject_class, CHILD_PROP_X_FILL, pspec);
+
+  pspec = g_param_spec_boolean ("y-fill",
+                                "Y Fill",
+                                "Whether the child should be allocated its "
+                                "entire available space, or whether it should "
+                                "be squashed and aligned.",
+                                TRUE,
+                                ST_PARAM_READWRITE);
+
+  g_object_class_install_property (gobject_class, CHILD_PROP_Y_FILL, pspec);
+
+  pspec = g_param_spec_boolean ("allocate-hidden",
+                                "Allocate Hidden",
+                                "Whether the child should be allocate even "
+                                "if it is hidden",
+                                TRUE,
+                                ST_PARAM_READWRITE);
+
+  g_object_class_install_property (gobject_class, CHILD_PROP_ALLOCATE_HIDDEN, pspec);
+}
+
+static void
+st_table_child_init (StTableChild *self)
+{
+  self->col_span = 1;
+  self->row_span = 1;
+
+  self->x_align = 0.5;
+  self->y_align = 0.5;
+
+  self->x_expand = TRUE;
+  self->y_expand = TRUE;
+
+  self->x_fill = TRUE;
+  self->y_fill = TRUE;
+
+  self->allocate_hidden = TRUE;
+}
+
+static StTableChild*
+get_child_meta (StTable      *table,
+                ClutterActor *child)
+{
+  StTableChild *meta;
+
+  meta = (StTableChild*) clutter_container_get_child_meta (CLUTTER_CONTAINER (table), child);
+
+  return meta;
+}
+
+/**
+ * st_table_child_get_col_span:
+ * @table: an #StTable
+ * @child: a #ClutterActor
+ *
+ * Get the column span of the child. Defaults to 1.
+ *
+ * Returns: the column span of the child
+ */
+gint
+st_table_child_get_col_span (StTable      *table,
+                             ClutterActor *child)
+{
+  StTableChild *meta;
+
+  g_return_val_if_fail (ST_IS_TABLE (table), 0);
+  g_return_val_if_fail (CLUTTER_IS_ACTOR (child), 0);
+
+  meta = get_child_meta (table, child);
+
+  return meta->col_span;
+}
+
+/**
+ * st_table_child_set_col_span:
+ * @table: An #StTable
+ * @child: An #ClutterActor
+ * @span: The number of columns to span
+ *
+ * Set the column span of the child.
+ *
+ */
+void
+st_table_child_set_col_span (StTable      *table,
+                             ClutterActor *child,
+                             gint          span)
+{
+  StTableChild *meta;
+
+  g_return_if_fail (ST_IS_TABLE (table));
+  g_return_if_fail (CLUTTER_IS_ACTOR (child));
+  g_return_if_fail (span > 1);
+
+  meta = get_child_meta (table, child);
+
+  meta->col_span = span;
+
+  clutter_actor_queue_relayout (child);
+}
+
+/**
+ * st_table_child_get_row_span:
+ * @table: A #StTable
+ * @child: A #ClutterActor
+ *
+ * Get the row span of the child. Defaults to 1.
+ *
+ * Returns: the row span of the child
+ */
+gint
+st_table_child_get_row_span (StTable      *table,
+                             ClutterActor *child)
+{
+  StTableChild *meta;
+
+  g_return_val_if_fail (ST_IS_TABLE (table), 0);
+  g_return_val_if_fail (CLUTTER_IS_ACTOR (child), 0);
+
+  meta = get_child_meta (table, child);
+
+  return meta->row_span;
+}
+
+/**
+ * st_table_child_set_row_span:
+ * @table: A #StTable
+ * @child: A #ClutterActor
+ * @span: the number of rows to span
+ *
+ * Set the row span of the child.
+ *
+ */
+void
+st_table_child_set_row_span (StTable      *table,
+                             ClutterActor *child,
+                             gint          span)
+{
+  StTableChild *meta;
+
+  g_return_if_fail (ST_IS_TABLE (table));
+  g_return_if_fail (CLUTTER_IS_ACTOR (child));
+  g_return_if_fail (span > 1);
+
+  meta = get_child_meta (table, child);
+
+  meta->row_span = span;
+
+  clutter_actor_queue_relayout (child);
+}
+
+/**
+ * st_table_child_get_x_fill:
+ * @table: A #StTable
+ * @child: A #ClutterActor
+ *
+ * Get the x-fill state of the child
+ *
+ * Returns: #TRUE if the child is set to x-fill
+ */
+gboolean
+st_table_child_get_x_fill (StTable      *table,
+                           ClutterActor *child)
+{
+  StTableChild *meta;
+
+  g_return_val_if_fail (ST_IS_TABLE (table), 0);
+  g_return_val_if_fail (CLUTTER_IS_ACTOR (child), 0);
+
+  meta = get_child_meta (table, child);
+
+  return meta->x_fill;
+}
+
+/**
+ * st_table_child_set_x_fill:
+ * @table: A #StTable
+ * @child: A #ClutterActor
+ * @fill: the fill state
+ *
+ * Set the fill state of the child on the x-axis. This will cause the child to
+ * be allocated the maximum available space.
+ *
+ */
+void
+st_table_child_set_x_fill (StTable      *table,
+                           ClutterActor *child,
+                           gboolean      fill)
+{
+  StTableChild *meta;
+
+  g_return_if_fail (ST_IS_TABLE (table));
+  g_return_if_fail (CLUTTER_IS_ACTOR (child));
+
+  meta = get_child_meta (table, child);
+
+  meta->x_fill = fill;
+
+  clutter_actor_queue_relayout (child);
+}
+
+
+/**
+ * st_table_child_get_y_fill:
+ * @table: A #StTable
+ * @child: A #ClutterActor
+ *
+ * Get the y-fill state of the child
+ *
+ * Returns: #TRUE if the child is set to y-fill
+ */
+gboolean
+st_table_child_get_y_fill (StTable      *table,
+                           ClutterActor *child)
+{
+  StTableChild *meta;
+
+  g_return_val_if_fail (ST_IS_TABLE (table), 0);
+  g_return_val_if_fail (CLUTTER_IS_ACTOR (child), 0);
+
+  meta = get_child_meta (table, child);
+
+  return meta->y_fill;
+}
+
+/**
+ * st_table_child_set_y_fill:
+ * @table: A #StTable
+ * @child: A #ClutterActor
+ * @fill: the fill state
+ *
+ * Set the fill state of the child on the y-axis. This will cause the child to
+ * be allocated the maximum available space.
+ *
+ */
+void
+st_table_child_set_y_fill (StTable      *table,
+                           ClutterActor *child,
+                           gboolean      fill)
+{
+  StTableChild *meta;
+
+  g_return_if_fail (ST_IS_TABLE (table));
+  g_return_if_fail (CLUTTER_IS_ACTOR (child));
+
+  meta = get_child_meta (table, child);
+
+  meta->y_fill = fill;
+
+  clutter_actor_queue_relayout (child);
+}
+
+/**
+ * st_table_child_get_x_expand:
+ * @table: A #StTable
+ * @child: A #ClutterActor
+ *
+ * Get the x-expand property of the child
+ *
+ * Returns: #TRUE if the child is set to x-expand
+ */
+gboolean
+st_table_child_get_x_expand (StTable      *table,
+                             ClutterActor *child)
+{
+  StTableChild *meta;
+
+  g_return_val_if_fail (ST_IS_TABLE (table), 0);
+  g_return_val_if_fail (CLUTTER_IS_ACTOR (child), 0);
+
+  meta = get_child_meta (table, child);
+
+  return meta->x_expand;
+}
+
+/**
+ * st_table_child_set_x_expand:
+ * @table: A #StTable
+ * @child: A #ClutterActor
+ * @expand: the new value of the x expand child property
+ *
+ * Set x-expand on the child. This causes the column which the child
+ * resides in to be allocated any extra space if the allocation of the table is
+ * larger than the preferred size.
+ *
+ */
+void
+st_table_child_set_x_expand (StTable      *table,
+                             ClutterActor *child,
+                             gboolean      expand)
+{
+  StTableChild *meta;
+
+  g_return_if_fail (ST_IS_TABLE (table));
+  g_return_if_fail (CLUTTER_IS_ACTOR (child));
+
+  meta = get_child_meta (table, child);
+
+  meta->x_expand = expand;
+
+  clutter_actor_queue_relayout (child);
+}
+
+/**
+ * st_table_child_set_y_expand:
+ * @table: A #StTable
+ * @child: A #ClutterActor
+ * @expand: the new value of the y-expand child property
+ *
+ * Set y-expand on the child. This causes the row which the child
+ * resides in to be allocated any extra space if the allocation of the table is
+ * larger than the preferred size.
+ *
+ */
+void
+st_table_child_set_y_expand (StTable      *table,
+                             ClutterActor *child,
+                             gboolean      expand)
+{
+  StTableChild *meta;
+
+  g_return_if_fail (ST_IS_TABLE (table));
+  g_return_if_fail (CLUTTER_IS_ACTOR (child));
+
+  meta = get_child_meta (table, child);
+
+  meta->y_expand = expand;
+
+  clutter_actor_queue_relayout (child);
+}
+
+/**
+ * st_table_child_get_y_expand:
+ * @table: A #StTable
+ * @child: A #ClutterActor
+ *
+ * Get the y-expand property of the child.
+ *
+ * Returns: #TRUE if the child is set to y-expand
+ */
+gboolean
+st_table_child_get_y_expand (StTable      *table,
+                             ClutterActor *child)
+{
+  StTableChild *meta;
+
+  g_return_val_if_fail (ST_IS_TABLE (table), 0);
+  g_return_val_if_fail (CLUTTER_IS_ACTOR (child), 0);
+
+  meta = get_child_meta (table, child);
+
+  return meta->y_expand;
+}
+
+/**
+ * st_table_child_get_x_align:
+ * @table: A #StTable
+ * @child: A #ClutterActor
+ *
+ * Get the x-align value of the child
+ *
+ * Returns: An #StAlign value
+ */
+StAlign
+st_table_child_get_x_align (StTable      *table,
+                            ClutterActor *child)
+{
+  StTableChild *meta;
+
+  g_return_val_if_fail (ST_IS_TABLE (table), 0);
+  g_return_val_if_fail (CLUTTER_IS_ACTOR (child), 0);
+
+  meta = get_child_meta (table, child);
+
+  if (meta->x_align == 0.0)
+    return ST_ALIGN_START;
+  else if (meta->x_align == 1.0)
+    return ST_ALIGN_END;
+  else
+    return ST_ALIGN_MIDDLE;
+
+}
+
+/**
+ * st_table_child_set_x_align:
+ * @table: A #StTable
+ * @child: A #ClutterActor
+ * @align: A #StAlign value
+ *
+ * Set the alignment of the child within its cell. This will only have an effect
+ * if the the x-fill property is FALSE.
+ *
+ */
+void
+st_table_child_set_x_align (StTable      *table,
+                            ClutterActor *child,
+                            StAlign       align)
+{
+  StTableChild *meta;
+
+  g_return_if_fail (ST_IS_TABLE (table));
+  g_return_if_fail (CLUTTER_IS_ACTOR (child));
+
+  meta = get_child_meta (table, child);
+
+  switch (align)
+    {
+    case ST_ALIGN_START:
+      meta->x_align = 0.0;
+      break;
+    case ST_ALIGN_MIDDLE:
+      meta->x_align = 0.5;
+      break;
+    case ST_ALIGN_END:
+      meta->x_align = 1.0;
+      break;
+    }
+
+  clutter_actor_queue_relayout (child);
+}
+
+/**
+ * st_table_child_get_y_align:
+ * @table: A #StTable
+ * @child: A #ClutterActor
+ *
+ * Get the y-align value of the child
+ *
+ * Returns: An #StAlign value
+ */
+StAlign
+st_table_child_get_y_align (StTable      *table,
+                            ClutterActor *child)
+{
+  StTableChild *meta;
+
+  g_return_val_if_fail (ST_IS_TABLE (table), 0);
+  g_return_val_if_fail (CLUTTER_IS_ACTOR (child), 0);
+
+  meta = get_child_meta (table, child);
+
+  if (meta->y_align == 0.0)
+    return ST_ALIGN_START;
+  else if (meta->y_align == 1.0)
+    return ST_ALIGN_END;
+  else
+    return ST_ALIGN_MIDDLE;
+
+}
+
+/**
+ * st_table_child_set_y_align:
+ * @table: A #StTable
+ * @child: A #ClutterActor
+ * @align: A #StAlign value
+ *
+ * Set the value of the y-align property. This will only have an effect if
+ * y-fill value is set to FALSE.
+ *
+ */
+void
+st_table_child_set_y_align (StTable      *table,
+                            ClutterActor *child,
+                            StAlign       align)
+{
+  StTableChild *meta;
+
+  g_return_if_fail (ST_IS_TABLE (table));
+  g_return_if_fail (CLUTTER_IS_ACTOR (child));
+
+  meta = get_child_meta (table, child);
+
+  switch (align)
+    {
+    case ST_ALIGN_START:
+      meta->y_align = 0.0;
+      break;
+    case ST_ALIGN_MIDDLE:
+      meta->y_align = 0.5;
+      break;
+    case ST_ALIGN_END:
+      meta->y_align = 1.0;
+      break;
+    }
+
+  clutter_actor_queue_relayout (child);
+}
+
+/**
+ * st_table_child_set_allocate_hidden:
+ * @table: A #StTable
+ * @child: A #ClutterActor
+ * @value: #TRUE if the actor should be allocated when hidden
+ *
+ * Set whether the child should be allocate even if it is hidden
+ */
+void
+st_table_child_set_allocate_hidden (StTable      *table,
+                                    ClutterActor *child,
+                                    gboolean      value)
+{
+  StTableChild *meta;
+
+  g_return_if_fail (ST_IS_TABLE (table));
+  g_return_if_fail (CLUTTER_IS_ACTOR (child));
+
+  meta = get_child_meta (table, child);
+
+  if (meta->allocate_hidden != value)
+    {
+      meta->allocate_hidden = value;
+
+      clutter_actor_queue_relayout (child);
+
+      g_object_notify (G_OBJECT (meta), "allocate-hidden");
+    }
+}
+
+/**
+ * st_table_child_get_allocate_hidden:
+ * @table: A #StTable
+ * @child: A #ClutterActor
+ *
+ * Determine if the child is allocated even if it is hidden
+ *
+ * Returns: #TRUE if the actor is allocated when hidden
+ */
+gboolean
+st_table_child_get_allocate_hidden (StTable      *table,
+                                    ClutterActor *child)
+{
+  StTableChild *meta;
+
+  g_return_val_if_fail (ST_IS_TABLE (table), TRUE);
+  g_return_val_if_fail (CLUTTER_IS_ACTOR (child), TRUE);
+
+  meta = get_child_meta (table, child);
+
+  return meta->allocate_hidden;
+}

src/st/st-table-child.h

@@ -0,0 +1,129 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+/*
+ * st-table-child.h: Table child implementation
+ *
+ * Copyright 2008, 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.
+ * Boston, MA 02111-1307, USA.
+ *
+ * Written by: Thomas Wood  <thomas@linux.intel.com>
+ *
+ */
+
+#if !defined(ST_H_INSIDE) && !defined(ST_COMPILATION)
+#error "Only <st/st.h> can be included directly.h"
+#endif
+
+#ifndef __ST_TABLE_CHILD_H__
+#define __ST_TABLE_CHILD_H__
+
+#include <st/st-types.h>
+#include <st/st-widget.h>
+#include <st/st-table.h>
+#include <clutter/clutter.h>
+
+G_BEGIN_DECLS
+
+#define ST_TYPE_TABLE_CHILD          (st_table_child_get_type ())
+#define ST_TABLE_CHILD(obj)          (G_TYPE_CHECK_INSTANCE_CAST ((obj), ST_TYPE_TABLE_CHILD, StTableChild))
+#define ST_IS_TABLE_CHILD(obj)       (G_TYPE_CHECK_INSTANCE_TYPE ((obj), ST_TYPE_TABLE_CHILD))
+#define ST_TABLE_CHILD_CLASS(klass)        (G_TYPE_CHECK_CLASS_CAST ((klass), ST_TYPE_TABLE_CHILD, StTableChildClass))
+#define ST_IS_TABLE_CHILD_CLASS(klass)     (G_TYPE_CHECK_CLASS_TYPE ((klass), ST_TYPE_TABLE_CHILD))
+#define ST_TABLE_CHILD_GET_CLASS(obj)      (G_TYPE_INSTANCE_GET_CLASS ((obj), ST_TYPE_TABLE_CHILD, StTableChildClass))
+
+typedef struct _StTableChild         StTableChild;
+typedef struct _StTableChildClass    StTableChildClass;
+
+/**
+ * StTableChild:
+ *
+ * The contents of the this structure are private and should only be accessed
+ * through the public API.
+ */
+struct _StTableChild
+{
+  /*< private >*/
+  ClutterChildMeta parent_instance;
+
+  gint col;
+  gint row;
+  gint col_span;
+  gint row_span;
+  gdouble x_align;
+  gdouble y_align;
+  guint allocate_hidden : 1;
+  guint x_expand : 1;
+  guint y_expand : 1;
+  guint x_fill : 1;
+  guint y_fill : 1;
+};
+
+
+struct _StTableChildClass
+{
+  ClutterChildMetaClass parent_class;
+};
+
+GType st_table_child_get_type (void) G_GNUC_CONST;
+
+gint     st_table_child_get_col_span        (StTable      *table,
+                                             ClutterActor *child);
+void     st_table_child_set_col_span        (StTable      *table,
+                                             ClutterActor *child,
+                                             gint          span);
+gint     st_table_child_get_row_span        (StTable      *table,
+                                             ClutterActor *child);
+void     st_table_child_set_row_span        (StTable      *table,
+                                             ClutterActor *child,
+                                             gint          span);
+gboolean st_table_child_get_x_fill          (StTable      *table,
+                                             ClutterActor *child);
+void     st_table_child_set_x_fill          (StTable      *table,
+                                             ClutterActor *child,
+                                             gboolean      fill);
+gboolean st_table_child_get_y_fill          (StTable      *table,
+                                             ClutterActor *child);
+void     st_table_child_set_y_fill          (StTable      *table,
+                                             ClutterActor *child,
+                                             gboolean      fill);
+gboolean st_table_child_get_x_expand        (StTable      *table,
+                                             ClutterActor *child);
+void     st_table_child_set_x_expand        (StTable      *table,
+                                             ClutterActor *child,
+                                             gboolean      expand);
+gboolean st_table_child_get_y_expand        (StTable      *table,
+                                             ClutterActor *child);
+void     st_table_child_set_y_expand        (StTable      *table,
+                                             ClutterActor *child,
+                                             gboolean      expand);
+StAlign  st_table_child_get_x_align         (StTable      *table,
+                                             ClutterActor *child);
+void     st_table_child_set_x_align         (StTable      *table,
+                                             ClutterActor *child,
+                                             StAlign       align);
+StAlign  st_table_child_get_y_align         (StTable      *table,
+                                             ClutterActor *child);
+void     st_table_child_set_y_align         (StTable      *table,
+                                             ClutterActor *child,
+                                             StAlign       align);
+void     st_table_child_set_allocate_hidden (StTable      *table,
+                                             ClutterActor *child,
+                                             gboolean      value);
+gboolean st_table_child_get_allocate_hidden (StTable      *table,
+                                             ClutterActor *child);
+
+G_END_DECLS
+
+#endif /* __ST_TABLE_H__ */