Move window clone functionality into its own class

svn path=/trunk/; revision=172

js/ui/workspaces.js

@@ -47,6 +47,311 @@ const POSITIONS = {
 const GRID_SPACING = 15;
 const FRAME_SIZE = GRID_SPACING / 3;
 
+function WindowClone(realWindow) {
+    this._init(realWindow);
+}
+
+WindowClone.prototype = {
+    _init : function(realWindow) {
+        this.actor = new Clutter.CloneTexture({ parent_texture: realWindow.get_texture(),
+                                                reactive: true,
+                                                x: realWindow.x,
+                                                y: realWindow.y });
+        this.realWindow = realWindow;
+        this.origX = realWindow.x;
+        this.origY = realWindow.y;
+
+        this.actor.connect('button-press-event',
+                           Lang.bind(this, this._onButtonPress));
+        this.actor.connect('button-release-event',
+                           Lang.bind(this, this._onButtonRelease));
+        this.actor.connect('enter-event',
+                           Lang.bind(this, this._onEnter));
+        this.actor.connect('leave-event',
+                           Lang.bind(this, this._onLeave));
+        this.actor.connect('motion-event',
+                           Lang.bind(this, this._onMotion));
+
+        this._havePointer = false;
+        this._inDrag = false;
+        this._buttonDown = false;
+
+        // We track the number of animations we are doing for the clone so we can
+        // hide the floating title while animating. It seems like it should be
+        // possible to use Tweener.getTweenCount(clone), but that annoyingly only
+        // updates after onComplete is called.
+        this._animationCount = 0;
+    },
+
+    destroy: function () {
+        this.actor.destroy();
+        if (this._title)
+            this._title.destroy();
+    },
+    
+    addTween: function (params) {
+        this._animationCount++;
+        this._updateTitle();
+
+        if (params.onComplete) {
+            let oldOnComplete = params.onComplete;
+            let oldOnCompleteScope = params.onCompleteScope;
+            let oldOnCompleteParams = params.onCompleteParams;
+            let eventScope = oldOnCompleteScope ? oldOnCompleteScope : this.actor;
+
+            params.onComplete = function () {
+                oldOnComplete.apply(eventScope, oldOnCompleteParams);
+                this._onAnimationComplete();
+            };
+        } else
+            params.onComplete = this._onAnimationComplete;
+        params.onCompleteScope = this;
+
+        Tweener.addTween(this.actor, params);
+    },
+
+    _onEnter: function (actor, event) {
+        // If the user drags faster than we can follow, he'll end up
+        // leaving the window temporarily and then re-entering it
+        if (this._inDrag)
+            return;
+
+        this._havePointer = true;
+
+        actor.raise_top();
+        this._updateTitle();
+    },
+
+    _onLeave: function (actor, event) {
+        // If the user drags faster than we can follow, he'll end up
+        // leaving the window temporarily and then re-entering it
+        if (this._inDrag)
+            return;
+
+        this._havePointer = false;
+
+        if (this._animationCount)
+            return;
+
+    	actor.raise(this.stackAbove);
+        this._updateTitle();
+    },
+
+    _onButtonPress : function (actor, event) {
+        if (this._animationCount)
+            return;
+
+        actor.raise_top();
+
+        let [stageX, stageY] = event.get_coords();
+
+        this._buttonDown = true;
+        this._dragStartX = stageX;
+        this._dragStartY = stageY;
+
+        Clutter.grab_pointer(actor);
+
+        this._updateTitle();
+    },
+
+    _onMotion : function (actor, event) {
+        if (!this._buttonDown)
+            return;
+
+        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
+        let dragThreshold = Gtk.Settings.get_default().gtk_dnd_drag_threshold;
+        if (!this._inDrag &&
+            (Math.abs(stageX - this._dragStartX) > dragThreshold ||
+             Math.abs(stageY - this._dragStartY) > dragThreshold)) {
+            this._inDrag = true;
+            
+            this._dragOrigParent = actor.get_parent();
+            this._dragOrigX = actor.x;
+            this._dragOrigY = actor.y;
+            this._dragOrigScale = actor.scale_x;
+
+            let [cloneStageX, cloneStageY] = actor.get_transformed_position();
+            this._dragOffsetX = cloneStageX - this._dragStartX;
+            this._dragOffsetY = cloneStageY - this._dragStartY;
+
+            // Reparent the clone onto the stage, but keeping the same scale.
+            // (the set_position call below will take care of position.)
+            let [scaledWidth, scaledHeight] = actor.get_transformed_size();
+            actor.reparent(actor.get_stage());
+            actor.raise_top();
+            actor.set_scale(scaledWidth / actor.width,
+                            scaledHeight / actor.height);
+        }
+
+        // If we are dragging, update the position
+        if (this._inDrag) {
+            actor.set_position(stageX + this._dragOffsetX,
+                               stageY + this._dragOffsetY);
+        }
+    },
+
+    _onButtonRelease : function (actor, event) {
+        Clutter.ungrab_pointer();
+
+        let inDrag = this._inDrag;
+        this._buttonDown = false;
+        this._inDrag = false;
+
+        if (inDrag) {
+            let [stageX, stageY] = event.get_coords();
+
+            let origWorkspace = this.realWindow.get_workspace();
+            this.emit('dragged', stageX, stageY, event.get_time());
+            if (this.realWindow.get_workspace() == origWorkspace) {
+                // Didn't get moved elsewhere, restore position
+                this.addTween({ x: this._dragStartX + this._dragOffsetX,
+                                y: this._dragStartY + this._dragOffsetY,
+                                time: SNAP_BACK_ANIMATION_TIME,
+                                transition: "easeOutQuad",
+                                onComplete: this._onSnapBackComplete,
+                                onCompleteScope: this
+                              });
+                // Most likely, the clone is going to move away from the
+                // pointer now. But that won't cause a leave-event, so
+                // do this by hand. Of course, if the window only snaps
+                // back a short distance, this might be wrong, but it's
+                // better to have the label mysteriously missing than
+                // mysteriously present
+                this._havePointer = false;
+            }
+        } else
+            this.emit('selected', event.get_time());
+    },
+
+    _onSnapBackComplete : function () {
+        this.actor.reparent(this._dragOrigParent);
+        this.actor.set_scale(this._dragOrigScale, this._dragOrigScale);
+        this.actor.set_position(this._dragOrigX, this._dragOrigY);
+    },
+
+    _onAnimationComplete : function () {
+        this._animationCount--;
+        if (this._animationCount == 0) {
+            this._updateTitle();
+    	    this.actor.raise(this.stackAbove);
+        }
+    },
+
+    _createTitle : function () {
+        let window = this.realWindow;
+        
+        let box = new Big.Box({ background_color : WINDOWCLONE_BG_COLOR,
+                                y_align: Big.BoxAlignment.CENTER,
+                                corner_radius: 5,
+                                padding: 4,
+                                spacing: 4,
+                                orientation: Big.BoxOrientation.HORIZONTAL });
+        
+        let icon = window.meta_window.mini_icon;
+        let iconTexture = new Clutter.Texture({ x: this.actor.x,
+                                                y: this.actor.y + this.actor.height - 16,
+                                                width: 16,
+                                                height: 16,
+                                                keep_aspect_ratio: true });
+        Shell.clutter_texture_set_from_pixbuf(iconTexture, icon);
+        box.append(iconTexture, Big.BoxPackFlags.NONE);
+        
+        let title = new Clutter.Label({ color: WINDOWCLONE_TITLE_COLOR,
+                                        font_name: "Sans 12",
+                                        text: window.meta_window.title,
+                                        ellipsize: Pango.EllipsizeMode.END
+                                      });
+        box.append(title, Big.BoxPackFlags.EXPAND);
+        // Get and cache the expected width (just the icon), with spacing, plus title
+        box.fullWidth = box.width;
+        box.hide(); // Hidden by default, show on mouseover
+        this._title = box;        
+
+        // Make the title a sibling of the window
+        this.actor.get_parent().add_actor(box);
+    },
+
+    _adjustTitle : function () {
+        let title = this._title;
+        if (!title)
+            return;    
+
+        let [cloneScreenWidth, cloneScreenHeight] = this.actor.get_transformed_size();
+        let [titleScreenWidth, titleScreenHeight] = title.get_transformed_size();
+
+        // Titles are supposed to be "full-size", so adjust its
+        // scale to counteract the scaling of its ancestor actors.
+        title.set_scale(title.width / titleScreenWidth * title.scale_x,
+                        title.height / titleScreenHeight * title.scale_y);
+
+        title.width = Math.min(title.fullWidth, cloneScreenWidth);
+        let xoff = ((cloneScreenWidth - title.width) / 2) * title.scale_x;
+        title.set_position(this.actor.x + xoff, this.actor.y);
+    },
+
+    _showTitle : function () {
+        if (!this._title)
+            this._createTitle();
+
+        this._adjustTitle();
+        this._title.show();
+        this._title.raise(this.actor);
+    },
+
+    _hideTitle : function () {
+        if (!this._title)
+            return;
+
+        this._title.hide();
+    },
+
+    _updateTitle : function () {
+        let shouldShow = (this._havePointer &&
+                          !this._buttonDown &&
+                          this._animationCount == 0);
+
+        if (shouldShow)
+            this._showTitle();
+        else
+            this._hideTitle();
+    }
+};
+
+Signals.addSignalMethods(WindowClone.prototype);
+
+
+function DesktopClone(window) {
+    this._init(window);
+}
+
+DesktopClone.prototype = {
+    _init : function(window) {
+        if (window) {
+            this.actor = new Clutter.CloneTexture({ parent_texture: window.get_texture(),
+                                                    reactive: true });
+        } else {
+            let global = Shell.Global.get();
+            this.actor = new Clutter.Rectangle({ color: global.stage.color,
+                                                 reactive: true,
+                                                 width: global.screen_width,
+                                                 height: global.screen_height });
+        }
+
+        this.actor.connect('button-release-event',
+                           Lang.bind(this, this._onButtonRelease));
+    },
+
+    _onButtonRelease : function (actor, event) {
+        this.emit('selected', event.get_time());
+    }
+};
+
+Signals.addSignalMethods(DesktopClone.prototype);
+
+
 function Workspace(workspaceNum) {
     this._init(workspaceNum);
 }
@@ -65,21 +370,21 @@ Workspace.prototype = {
         // Find the desktop window
         for (let i = 0; i < windows.length; i++) {
             if (windows[i].get_window_type() == Meta.WindowType.DESKTOP) {
-                this._desktop = this._makeClone(windows[i]);
+                this._desktop = new DesktopClone(windows[i]);
                 break;
             }
         }
         // If there wasn't one, fake it
         if (!this._desktop)
-            this._desktop = this._makeDesktopRectangle();
+            this._desktop = new DesktopClone();
 
         let metaWorkspace = global.screen.get_workspace_by_index(workspaceNum);
-        this._desktop.connect('button-press-event',
+        this._desktop.connect('selected',
-                              function(actor, event) {
+                              function(clone, time) {
-                                  metaWorkspace.activate(event.get_time());
+                                  metaWorkspace.activate(time);
                                   Main.hide_overlay();
                               });
-        this.actor.add_actor(this._desktop);
+        this.actor.add_actor(this._desktop.actor);
 
         // Create clones for remaining windows that should be
         // visible in the overlay
@@ -168,10 +473,10 @@ Workspace.prototype = {
             // FIXME: do something cooler-looking using clutter-cairo
             this._frame = new Clutter.Rectangle({ color: FRAME_COLOR });
             this.actor.add_actor(this._frame);
-            this._frame.set_position(this._desktop.x - FRAME_SIZE / this.actor.scale_x,
+            this._frame.set_position(this._desktop.actor.x - FRAME_SIZE / this.actor.scale_x,
-                                     this._desktop.y - FRAME_SIZE / this.actor.scale_y);
+                                     this._desktop.actor.y - FRAME_SIZE / this.actor.scale_y);
-            this._frame.set_size(this._desktop.width + 2 * FRAME_SIZE / this.actor.scale_x,
+            this._frame.set_size(this._desktop.actor.width + 2 * FRAME_SIZE / this.actor.scale_x,
-                                 this._desktop.height + 2 * FRAME_SIZE / this.actor.scale_y);
+                                 this._desktop.actor.height + 2 * FRAME_SIZE / this.actor.scale_y);
             this._frame.lower_bottom();
 
             this._framePosHandler = this.actor.connect('notify::x', Lang.bind(this, this._updateFramePosition));
@@ -187,13 +492,13 @@ Workspace.prototype = {
     },
 
     _updateFramePosition : function() {
-        this._frame.set_position(this._desktop.x - FRAME_SIZE / this.actor.scale_x,
+        this._frame.set_position(this._desktop.actor.x - FRAME_SIZE / this.actor.scale_x,
-                                 this._desktop.y - FRAME_SIZE / this.actor.scale_y);
+                                 this._desktop.actor.y - FRAME_SIZE / this.actor.scale_y);
     },
 
     _updateFrameSize : function() {
-        this._frame.set_size(this._desktop.width + 2 * FRAME_SIZE / this.actor.scale_x,
+        this._frame.set_size(this._desktop.actor.width + 2 * FRAME_SIZE / this.actor.scale_x,
-                             this._desktop.height + 2 * FRAME_SIZE / this.actor.scale_y);
+                             this._desktop.actor.height + 2 * FRAME_SIZE / this.actor.scale_y);
     },
 
     // Reposition all windows in their zoomed-to-overlay position. if workspaceZooming
@@ -202,37 +507,33 @@ Workspace.prototype = {
     _positionWindows : function(workspaceZooming) {
         let global = Shell.Global.get();
 
-        this._overlappedMode = !((this._windows.length-1) in POSITIONS);
         for (let i = 1; i < this._windows.length; i++) {
             let clone = this._windows[i];
+            clone.stackAbove = this._windows[i - 1].actor;
 
             let [xCenter, yCenter, fraction] = this._computeWindowPosition(i);
             xCenter = xCenter * global.screen_width;
             yCenter = yCenter * global.screen_height;
 
-            let size = Math.max(clone.width, clone.height);
+            let size = Math.max(clone.actor.width, clone.actor.height);
             let desiredSize = global.screen_width * fraction;
             let scale = Math.min(desiredSize / size, 1.0);
 
             let tweenProperties = {
-                x: xCenter - 0.5 * scale * clone.width,
+                x: xCenter - 0.5 * scale * clone.actor.width,
-                y: yCenter - 0.5 * scale * clone.height,
+                y: yCenter - 0.5 * scale * clone.actor.height,
                 scale_x: scale,
                 scale_y: scale,
                 time: Overlay.ANIMATION_TIME,
                 opacity: WINDOW_OPACITY,
-                transition: "easeOutQuad",
+                transition: "easeOutQuad"
-                onComplete: this._onCloneAnimationComplete,
-                onCompleteScope: this,
-                onCompleteParams: [clone]
             };
 
             // workspace_relative assumes that the workspace is zooming in our out
             if (workspaceZooming)
                 tweenProperties['workspace_relative'] = this;
 
-            Tweener.addTween(clone, tweenProperties);
+            clone.addTween(tweenProperties);
-            clone._animationCount++;
         }
     },
 
@@ -254,13 +555,6 @@ Workspace.prototype = {
         let clone = this._windows[index];
         this._windows.splice(index, 1);
         clone.destroy();
-        if (clone.cloneTitle)
-            clone.cloneTitle.destroy();
-
-        // Adjust the index property for later windows
-        for (let j = index; j < this._windows.length; j++) {
-            this._windows[j].index--;
-        }
 
         this._positionWindows();
     },
@@ -272,10 +566,8 @@ Workspace.prototype = {
     // animated to the final location.
     addWindow : function(win, x, y, scale) {
         let clone = this._addWindowClone(win);
-        clone.x = x;
+        clone.actor.set_position (x, y);
-        clone.y = y;
+        clone.actor.set_scale (scale, scale);
-        clone.scale_x = scale;
-        clone.scale_y = scale;
         
         this._positionWindows();
     },
@@ -311,23 +603,16 @@ Workspace.prototype = {
                          });
 
         for (let i = 1; i < this._windows.length; i++) {
-            let window = this._windows[i];
+            let clone = this._windows[i];
-            if (window.cloneTitle)
+            clone.addTween({ x: clone.origX,
-                window.cloneTitle.hide();
+                             y: clone.origY,
-            Tweener.addTween(window,
+                             scale_x: 1.0,
-                             { x: window.origX,
+                             scale_y: 1.0,
-                               y: window.origY,
+                             workspace_relative: this,
-                               scale_x: 1.0,
+                             time: Overlay.ANIMATION_TIME,
-                               scale_y: 1.0,
+                             opacity: 255,
-                               workspace_relative: this,
+                             transition: "easeOutQuad"
-                               time: Overlay.ANIMATION_TIME,
+                           });
-                               opacity: 255,
-                               transition: "easeOutQuad",
-                               onComplete: this._onCloneAnimationComplete,
-                               onCompleteScope: this,
-                               onCompleteParams: [window]
-                             });
-            window._animationCount++;
         }
 
         this._visible = false;
@@ -411,43 +696,15 @@ Workspace.prototype = {
         return !win.is_override_redirect();
     },
 
-    // Create a clone of a window to use in the overlay.
-    _makeClone : function(window) {
-        let clone = new Clutter.CloneTexture({ parent_texture: window.get_texture(),
-                                               reactive: true,
-                                               x: window.x,
-                                               y: window.y });
-        clone.realWindow = window;
-        clone.origX = window.x;
-        clone.origY = window.y;
-        return clone;
-    },
-
     // Create a clone of a (non-desktop) window and add it to the window list
     _addWindowClone : function(win) {
-        let clone = this._makeClone(win);
+        let clone = new WindowClone(win);
-        clone.connect('button-press-event',
+        clone.connect('selected',
-                      Lang.bind(this, this._onCloneButtonPress));
+                      Lang.bind(this, this._onCloneSelected));
-        clone.connect('button-release-event',
+        clone.connect('dragged',
-                      Lang.bind(this, this._onCloneButtonRelease));
+                      Lang.bind(this, this._onCloneDragged));
-        clone.connect('enter-event',
-                      Lang.bind(this, this._onCloneEnter));
-        clone.connect('leave-event',
-                      Lang.bind(this, this._onCloneLeave));
-        clone.connect('motion-event',
-                      Lang.bind(this, this._onCloneMotion));
 
-        clone._havePointer = false;
+        this.actor.add_actor(clone.actor);
-        clone._inDrag = false;
-        clone._buttonDown = false;
-        clone.index = this._windows.length;
-        // We track the number of animations we are doing for the clone so we can
-        // hide the floating title while animating. It seems like it should be
-        // possible to use Tweener.getTweenCount(clone), but that annoyingly only
-        // updates after onComplete is called.
-        clone._animationCount = 0;
-
-        this.actor.add_actor(clone);
         this._windows.push(clone);
 
         return clone;
@@ -463,14 +720,11 @@ Workspace.prototype = {
         // height of the panel, so we should not subtract the height
         // of the panel from global.screen_height here either to have
         // them show up identically.
-        let desktop = new Clutter.Rectangle({ color: global.stage.color,
+        return new Clutter.Rectangle({ color: global.stage.color,
-                                              reactive: true,
+                                       x: 0,
-                                              x: 0,
+                                       y: 0,
-                                              y: 0,
+                                       width: global.screen_width,
-                                              width: global.screen_width,
+                                       height: global.screen_height });
-                                              height: global.screen_height });
-        desktop.origX = desktop.origY = 0;
-        return desktop;
     },
 
     _computeWindowPosition : function(index) {
@@ -496,206 +750,14 @@ Workspace.prototype = {
         return [xCenter, yCenter, fraction];
     },
 
-    _onCloneEnter: function (clone, event) {
+    _onCloneDragged : function (clone, stageX, stageY, time) {
-        clone._havePointer = true;
+        this.emit('window-dragged', clone, stageX, stageY, time);
-
-        if (this._overlappedMode && clone.index != this._windows.length - 1)
-    	    clone.raise_top();
-
-        this._updateCloneTitle(clone);
     },
 
-    _onCloneLeave: function (clone, event) {
+    _onCloneSelected : function (clone, time) {
-        clone._havePointer = false;
-
-        if (this._overlappedMode && clone.index != this._windows.length - 1)
-    	    clone.lower(this._windows[clone.index+1]);
-
-        this._updateCloneTitle(clone);
-    },
-
-    _onCloneButtonPress : function (clone, event) {
-        if (clone._animationCount)
-            return;
-
-        clone.raise_top();
-
-        let [stageX, stageY] = event.get_coords();
-
-        clone._buttonDown = true;
-        clone._dragStartX = stageX;
-        clone._dragStartY = stageY;
-
-        Clutter.grab_pointer(clone);
-
-        this._updateCloneTitle(clone);
-    },
-
-    _onCloneButtonRelease : function (clone, event) {
-        Clutter.ungrab_pointer();
-        let inDrag = clone._inDrag;
-        clone._buttonDown = false;
-        clone._inDrag = false;
-
-        if (inDrag) {
-            let [stageX, stageY] = event.get_coords();
-
-            this.emit('window-dragged', clone, stageX, stageY, event.get_time());
-            if (clone.realWindow.get_workspace() == this.workspaceNum) {
-                // Didn't get moved elsewhere, restore position
-                Tweener.addTween(clone,
-                                 { x: clone._dragStartX + clone._dragOffsetX,
-                                   y: clone._dragStartY + clone._dragOffsetY,
-                                   time: SNAP_BACK_ANIMATION_TIME,
-                                   transition: "easeOutQuad",
-                                   onComplete: this._onCloneSnapBackComplete,
-                                   onCompleteScope: this,
-                                   onCompleteParams: [clone]
-                                 });
-                // Most likely, the clone is going to move away from the
-                // pointer now. But that won't cause a leave-event, so
-                // do this by hand. Of course, if the window only snaps
-                // back a short distance, this might be wrong, but it's
-                // better to have the label mysteriously missing than
-                // mysteriously present
-                clone._havePointer = false;
-                clone._animationCount++;
-            }
-        } else {
-            this._activateWindow(clone.realWindow, event.get_time());
-        }
-    },
-
-    _onCloneSnapBackComplete : function (clone) {
-        clone.reparent(clone._dragOrigParent);
-        clone.set_scale(clone._dragOrigScale, clone._dragOrigScale);
-        clone.set_position(clone._dragOrigX, clone._dragOrigY);
-        this._onCloneAnimationComplete(clone);
-    },
-
-    _onCloneMotion : function (clone, event) {
-        if (!clone._buttonDown)
-            return;
-
-        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
-        let dragThreshold = Gtk.Settings.get_default().gtk_dnd_drag_threshold;
-        if (!clone._inDrag &&
-            (Math.abs(stageX - clone._dragStartX) > dragThreshold ||
-             Math.abs(stageY - clone._dragStartY) > dragThreshold)) {
-            clone._inDrag = true;
-            
-            clone._dragOrigParent = clone.get_parent();
-            clone._dragOrigX = clone.x;
-            clone._dragOrigY = clone.y;
-            clone._dragOrigScale = clone.scale_x;
-
-            let [cloneStageX, cloneStageY] = clone.get_transformed_position();
-            clone._dragOffsetX = cloneStageX - clone._dragStartX;
-            clone._dragOffsetY = cloneStageY - clone._dragStartY;
-
-            // Reparent the clone onto the stage, but keeping the same scale.
-            // (the set_position call below will take care of position.)
-            let [scaledWidth, scaledHeight] = clone.get_transformed_size();
-            clone.reparent(clone.get_stage());
-            clone.raise_top();
-            clone.set_scale(scaledWidth / clone.width,
-                            scaledHeight / clone.height);
-        }
-
-        // If we are dragging, update the position
-        if (clone._inDrag) {
-            clone.set_position(stageX + clone._dragOffsetX,
-                               stageY + clone._dragOffsetY);
-        }
-    },
-
-    _onCloneAnimationComplete : function (clone) {
-        clone._animationCount--;
-        if (clone._animationCount == 0)
-            this._updateCloneTitle(clone);
-    },
-
-    _createCloneTitle : function (clone) {
-        let me = this;
-        let window = clone.realWindow;
-        
-        let box = new Big.Box({background_color : WINDOWCLONE_BG_COLOR,
-                               y_align: Big.BoxAlignment.CENTER,
-                               corner_radius: 5,
-                               padding: 4,
-                               spacing: 4,
-                               orientation: Big.BoxOrientation.HORIZONTAL});
-        
-        let icon = window.meta_window.mini_icon;
-        let iconTexture = new Clutter.Texture({ x: clone.x,
-                                                y: clone.y + clone.height - 16,
-                                                width: 16, height: 16, keep_aspect_ratio: true});
-        Shell.clutter_texture_set_from_pixbuf(iconTexture, icon);
-        box.append(iconTexture, Big.BoxPackFlags.NONE);
-        
-        let title = new Clutter.Label({color: WINDOWCLONE_TITLE_COLOR,
-                                       font_name: "Sans 12",
-                                       text: window.meta_window.title,
-                                       ellipsize: Pango.EllipsizeMode.END});
-        box.append(title, Big.BoxPackFlags.EXPAND);
-        // Get and cache the expected width (just the icon), with spacing, plus title
-        box.fullWidth = box.width;
-        box.hide(); // Hidden by default, show on mouseover
-        clone.cloneTitle = box;        
-        
-        this.actor.add_actor(box);
-    },
-
-    _adjustCloneTitle : function (clone) {
-        let title = clone.cloneTitle;
-        if (!title)
-            return;    
-
-        let transformed = clone.get_transformed_size();
-        let cloneWidth = transformed[0];
-
-        // Set the title scale to the inverse of this.actor's scale;
-        // this means its scale is 1.0 with respect to the stage
-        // (and thus, in the same units as cloneWidth).
-        title.set_scale(1.0 / this.scale, 1.0 / this.scale);
-        title.width = Math.min(title.fullWidth, cloneWidth);
-        let xoff = ((cloneWidth - title.width) / 2) / this.scale;
-        title.set_position(clone.x + xoff, clone.y);
-    },
-
-    _showCloneTitle : function (clone) {
-        if (!clone.cloneTitle)
-            this._createCloneTitle(clone);
-
-        this._adjustCloneTitle(clone);
-        clone.cloneTitle.show();
-        clone.cloneTitle.raise(clone);
-    },
-
-    _hideCloneTitle : function (clone) {
-        if (!clone.cloneTitle)
-            return;
-
-        clone.cloneTitle.hide();
-    },
-
-    _updateCloneTitle : function (clone) {
-        let shouldShow = (clone._havePointer &&
-                          !clone._buttonDown &&
-                          clone._animationCount == 0);
-
-        if (shouldShow)
-            this._showCloneTitle(clone);
-        else
-            this._hideCloneTitle(clone);
-    },
-
-    _activateWindow : function(w, time) {
         let global = Shell.Global.get();
         let activeWorkspace = global.screen.get_active_workspace_index();
+        let w = clone.realWindow;
         let windowWorkspace = w.get_workspace();
 
         if (windowWorkspace != activeWorkspace) {
@@ -995,7 +1057,7 @@ Workspaces.prototype = {
 
         // Positions in stage coordinates
         let [myX, myY] = this.actor.get_transformed_position();
-        let [windowX, windowY] = clone.get_transformed_position();
+        let [windowX, windowY] = clone.actor.get_transformed_position();
 
         let targetWorkspace = null;
         let targetX, targetY, targetScale;
@@ -1022,7 +1084,7 @@ Workspaces.prototype = {
         // Window position and scale relative to the new workspace
         targetX = (windowX - myX - targetWorkspace.gridX) / targetWorkspace.scale;
         targetY = (windowY - myY - targetWorkspace.gridY) / targetWorkspace.scale;
-        targetScale = clone.scale_x / targetWorkspace.scale;
+        targetScale = clone.actor.scale_x / targetWorkspace.scale;
 
         let metaWindow = clone.realWindow.get_meta_window();
         metaWindow.change_workspace_by_index(targetWorkspace.workspaceNum,