[gnome-shell/wip/rstrode/rhel-7.9: 42/86] workspacesView: Support horizontal layout

[Ray Strode <halfline src gnome org>]

commit 4ce3da82b484eec05691589ca7aa4c679fb9155d
Author: Florian Müllner <fmuellner gnome org>
Date:   Tue Jun 4 19:49:23 2019 +0000

    workspacesView: Support horizontal layout
    
    Just as we did for the workspace switcher popup, support workspaces
    being laid out in a single row in the window picker.
    
    Note that this takes care of the various workspace switch actions in
    the overview (scrolling, panning, touch(pad) gestures) as well as the
    switch animation, but not of the overview's workspace switcher component.
    
    There are currently no plans to support other layouts there, as the
    component is inherently vertical (in fact, it was the whole reason for
    switching the layout in the first place).
    
    https://gitlab.gnome.org/GNOME/gnome-shell/merge_requests/575

 js/ui/workspacesView.js | 74 ++++++++++++++++++++++++++++++++++++-------------
 1 file changed, 54 insertions(+), 20 deletions(-)
---
diff --git a/js/ui/workspacesView.js b/js/ui/workspacesView.js
index 563e43da4a..dd7bb0e2a7 100644
--- a/js/ui/workspacesView.js
+++ b/js/ui/workspacesView.js
@@ -187,26 +187,32 @@ var WorkspacesView = new Lang.Class({
 
             Tweener.removeTweens(workspace.actor);
 
-            let y = (w - active) * this._fullGeometry.height;
+            let params = {};
+            if (global.screen.layout_rows == -1)
+                params.y = (w - active) * this._fullGeometry.height;
+            else if (this.actor.text_direction == Clutter.TextDirection.RTL)
+                params.x = (active - w) * this._fullGeometry.width;
+            else
+                params.x = (w - active) * this._fullGeometry.width;
 
             if (showAnimation) {
-                let params = { y: y,
-                               time: WORKSPACE_SWITCH_TIME,
-                               transition: 'easeOutQuad'
-                             };
+                let tweenParams = Object.assign(params, {
+                    time: WORKSPACE_SWITCH_TIME,
+                    transition: 'easeOutQuad'
+                });
                 // we have to call _updateVisibility() once before the
                 // animation and once afterwards - it does not really
                 // matter which tween we use, so we pick the first one ...
                 if (w == 0) {
                     this._updateVisibility();
-                    params.onComplete = () => {
+                    tweenParams.onComplete = () => {
                         this._animating = false;
                         this._updateVisibility();
                     };
                 }
-                Tweener.addTween(workspace.actor, params);
+                Tweener.addTween(workspace.actor, tweenParams);
             } else {
-                workspace.actor.set_position(0, y);
+                Object.assign(workspace.actor, params);
                 if (w == 0)
                     this._updateVisibility();
             }
@@ -328,22 +334,39 @@ var WorkspacesView = new Lang.Class({
             metaWorkspace.activate(global.get_current_time());
         }
 
-        let last = this._workspaces.length - 1;
-        let firstWorkspaceY = this._workspaces[0].actor.y;
-        let lastWorkspaceY = this._workspaces[last].actor.y;
-        let workspacesHeight = lastWorkspaceY - firstWorkspaceY;
-
         if (adj.upper == 1)
             return;
 
-        let currentY = firstWorkspaceY;
-        let newY =  - adj.value / (adj.upper - 1) * workspacesHeight;
+        let last = this._workspaces.length - 1;
+
+        if (global.screen.layout_rows == -1) {
+            let firstWorkspaceY = this._workspaces[0].actor.y;
+            let lastWorkspaceY = this._workspaces[last].actor.y;
+            let workspacesHeight = lastWorkspaceY - firstWorkspaceY;
+
+            let currentY = firstWorkspaceY;
+            let newY = -adj.value / (adj.upper - 1) * workspacesHeight;
+
+            let dy = newY - currentY;
 
-        let dy = newY - currentY;
+            for (let i = 0; i < this._workspaces.length; i++) {
+                this._workspaces[i].actor.visible = Math.abs(i - adj.value) <= 1;
+                this._workspaces[i].actor.y += dy;
+            }
+        } else {
+            let firstWorkspaceX = this._workspaces[0].actor.x;
+            let lastWorkspaceX = this._workspaces[last].actor.x;
+            let workspacesWidth = lastWorkspaceX - firstWorkspaceX;
+
+            let currentX = firstWorkspaceX;
+            let newX = -adj.value / (adj.upper - 1) * workspacesWidth;
 
-        for (let i = 0; i < this._workspaces.length; i++) {
-            this._workspaces[i].actor.visible = Math.abs(i - adj.value) <= 1;
-            this._workspaces[i].actor.y += dy;
+            let dx = newX - currentX;
+
+            for (let i = 0; i < this._workspaces.length; i++) {
+                this._workspaces[i].actor.visible = Math.abs(i - adj.value) <= 1;
+                this._workspaces[i].actor.x += dx;
+            }
         }
     },
 });
@@ -479,7 +502,12 @@ var WorkspacesDisplay = new Lang.Class({
     _onPan(action) {
         let [dist, dx, dy] = action.get_motion_delta(0);
         let adjustment = this._scrollAdjustment;
-        adjustment.value -= (dy / this.actor.height) * adjustment.page_size;
+        if (global.screen.layout_rows == -1)
+            adjustment.value -= (dy / this.actor.height) * adjustment.page_size;
+        else if (this.actor.text_direction == Clutter.TextDirection.RTL)
+            adjustment.value += (dx / this.actor.width) * adjustment.page_size;
+        else
+            adjustment.value -= (dx / this.actor.width) * adjustment.page_size;
         return false;
     },
 
@@ -688,6 +716,12 @@ var WorkspacesDisplay = new Lang.Class({
         case Clutter.ScrollDirection.DOWN:
             ws = activeWs.get_neighbor(Meta.MotionDirection.DOWN);
             break;
+        case Clutter.ScrollDirection.LEFT:
+            ws = activeWs.get_neighbor(Meta.MotionDirection.LEFT);
+            break;
+        case Clutter.ScrollDirection.RIGHT:
+            ws = activeWs.get_neighbor(Meta.MotionDirection.RIGHT);
+            break;
         default:
             return Clutter.EVENT_PROPAGATE;
         }