636 lines
24 KiB
JavaScript
636 lines
24 KiB
JavaScript
// -*- mode: js; js-indent-level: 4; indent-tabs-mode: nil -*-
|
|
|
|
const Clutter = imports.gi.Clutter;
|
|
const GLib = imports.gi.GLib;
|
|
const Gio = imports.gi.Gio;
|
|
const Lang = imports.lang;
|
|
const Meta = imports.gi.Meta;
|
|
const St = imports.gi.St;
|
|
const Shell = imports.gi.Shell;
|
|
|
|
const AltTab = imports.ui.altTab;
|
|
const WorkspaceSwitcherPopup = imports.ui.workspaceSwitcherPopup;
|
|
const Main = imports.ui.main;
|
|
const Tweener = imports.ui.tweener;
|
|
|
|
const SHELL_KEYBINDINGS_SCHEMA = 'org.gnome.shell.keybindings';
|
|
const WINDOW_ANIMATION_TIME = 0.25;
|
|
const DIM_TIME = 0.500;
|
|
const UNDIM_TIME = 0.250;
|
|
|
|
var dimShader = undefined;
|
|
|
|
function getDimShaderSource() {
|
|
if (!dimShader)
|
|
dimShader = Shell.get_file_contents_utf8_sync(global.datadir + '/shaders/dim-window.glsl');
|
|
return dimShader;
|
|
}
|
|
|
|
function getTopInvisibleBorder(metaWindow) {
|
|
let outerRect = metaWindow.get_outer_rect();
|
|
let inputRect = metaWindow.get_input_rect();
|
|
return outerRect.y - inputRect.y;
|
|
}
|
|
|
|
const WindowDimmer = new Lang.Class({
|
|
Name: 'WindowDimmer',
|
|
|
|
_init: function(actor) {
|
|
if (Clutter.feature_available(Clutter.FeatureFlags.SHADERS_GLSL)) {
|
|
this._effect = new Clutter.ShaderEffect({ shader_type: Clutter.ShaderType.FRAGMENT_SHADER });
|
|
this._effect.set_shader_source(getDimShaderSource());
|
|
} else {
|
|
this._effect = null;
|
|
}
|
|
|
|
this.actor = actor;
|
|
},
|
|
|
|
set dimFraction(fraction) {
|
|
this._dimFraction = fraction;
|
|
|
|
if (this._effect == null)
|
|
return;
|
|
|
|
if (!Meta.prefs_get_attach_modal_dialogs()) {
|
|
this._effect.enabled = false;
|
|
return;
|
|
}
|
|
|
|
if (fraction > 0.01) {
|
|
Shell.shader_effect_set_double_uniform(this._effect, 'height', this.actor.get_height());
|
|
Shell.shader_effect_set_double_uniform(this._effect, 'fraction', fraction);
|
|
|
|
if (!this._effect.actor)
|
|
this.actor.add_effect(this._effect);
|
|
} else {
|
|
if (this._effect.actor)
|
|
this.actor.remove_effect(this._effect);
|
|
}
|
|
},
|
|
|
|
get dimFraction() {
|
|
return this._dimFraction;
|
|
},
|
|
|
|
_dimFraction: 0.0
|
|
});
|
|
|
|
function getWindowDimmer(actor) {
|
|
if (!actor._windowDimmer)
|
|
actor._windowDimmer = new WindowDimmer(actor);
|
|
|
|
return actor._windowDimmer;
|
|
}
|
|
|
|
const WindowManager = new Lang.Class({
|
|
Name: 'WindowManager',
|
|
|
|
_init : function() {
|
|
this._shellwm = global.window_manager;
|
|
|
|
this._minimizing = [];
|
|
this._maximizing = [];
|
|
this._unmaximizing = [];
|
|
this._mapping = [];
|
|
this._destroying = [];
|
|
|
|
this._dimmedWindows = [];
|
|
|
|
this._animationBlockCount = 0;
|
|
|
|
this._switchData = null;
|
|
this._shellwm.connect('kill-switch-workspace', Lang.bind(this, this._switchWorkspaceDone));
|
|
this._shellwm.connect('kill-window-effects', Lang.bind(this, function (shellwm, actor) {
|
|
this._minimizeWindowDone(shellwm, actor);
|
|
this._maximizeWindowDone(shellwm, actor);
|
|
this._unmaximizeWindowDone(shellwm, actor);
|
|
this._mapWindowDone(shellwm, actor);
|
|
this._destroyWindowDone(shellwm, actor);
|
|
}));
|
|
|
|
this._shellwm.connect('switch-workspace', Lang.bind(this, this._switchWorkspace));
|
|
this._shellwm.connect('minimize', Lang.bind(this, this._minimizeWindow));
|
|
this._shellwm.connect('maximize', Lang.bind(this, this._maximizeWindow));
|
|
this._shellwm.connect('unmaximize', Lang.bind(this, this._unmaximizeWindow));
|
|
this._shellwm.connect('map', Lang.bind(this, this._mapWindow));
|
|
this._shellwm.connect('destroy', Lang.bind(this, this._destroyWindow));
|
|
|
|
this._workspaceSwitcherPopup = null;
|
|
Meta.keybindings_set_custom_handler('switch-to-workspace-left',
|
|
Lang.bind(this, this._showWorkspaceSwitcher));
|
|
Meta.keybindings_set_custom_handler('switch-to-workspace-right',
|
|
Lang.bind(this, this._showWorkspaceSwitcher));
|
|
Meta.keybindings_set_custom_handler('switch-to-workspace-up',
|
|
Lang.bind(this, this._showWorkspaceSwitcher));
|
|
Meta.keybindings_set_custom_handler('switch-to-workspace-down',
|
|
Lang.bind(this, this._showWorkspaceSwitcher));
|
|
Meta.keybindings_set_custom_handler('switch-windows',
|
|
Lang.bind(this, this._startAppSwitcher));
|
|
Meta.keybindings_set_custom_handler('switch-group',
|
|
Lang.bind(this, this._startAppSwitcher));
|
|
Meta.keybindings_set_custom_handler('switch-windows-backward',
|
|
Lang.bind(this, this._startAppSwitcher));
|
|
Meta.keybindings_set_custom_handler('switch-group-backward',
|
|
Lang.bind(this, this._startAppSwitcher));
|
|
Meta.keybindings_set_custom_handler('switch-panels',
|
|
Lang.bind(this, this._startA11ySwitcher));
|
|
global.display.add_keybinding('open-application-menu',
|
|
new Gio.Settings({ schema: SHELL_KEYBINDINGS_SCHEMA }),
|
|
Meta.KeyBindingFlags.NONE,
|
|
Lang.bind(this, this._openAppMenu));
|
|
|
|
Main.overview.connect('showing', Lang.bind(this, function() {
|
|
for (let i = 0; i < this._dimmedWindows.length; i++)
|
|
this._undimWindow(this._dimmedWindows[i], true);
|
|
}));
|
|
Main.overview.connect('hiding', Lang.bind(this, function() {
|
|
for (let i = 0; i < this._dimmedWindows.length; i++)
|
|
this._dimWindow(this._dimmedWindows[i], true);
|
|
}));
|
|
},
|
|
|
|
blockAnimations: function() {
|
|
this._animationBlockCount++;
|
|
},
|
|
|
|
unblockAnimations: function() {
|
|
this._animationBlockCount = Math.max(0, this._animationBlockCount - 1);
|
|
},
|
|
|
|
_shouldAnimate : function(actor) {
|
|
if (Main.overview.visible || this._animationBlockCount > 0)
|
|
return false;
|
|
if (actor && (actor.meta_window.get_window_type() != Meta.WindowType.NORMAL))
|
|
return false;
|
|
return true;
|
|
},
|
|
|
|
_removeEffect : function(list, actor) {
|
|
let idx = list.indexOf(actor);
|
|
if (idx != -1) {
|
|
list.splice(idx, 1);
|
|
return true;
|
|
}
|
|
return false;
|
|
},
|
|
|
|
_minimizeWindow : function(shellwm, actor) {
|
|
if (!this._shouldAnimate(actor)) {
|
|
shellwm.completed_minimize(actor);
|
|
return;
|
|
}
|
|
|
|
actor.set_scale(1.0, 1.0);
|
|
actor.move_anchor_point_from_gravity(Clutter.Gravity.CENTER);
|
|
|
|
/* scale window down to 0x0.
|
|
* maybe TODO: get icon geometry passed through and move the window towards it?
|
|
*/
|
|
this._minimizing.push(actor);
|
|
|
|
let primary = Main.layoutManager.primaryMonitor;
|
|
let xDest = primary.x;
|
|
if (Clutter.get_default_text_direction() == Clutter.TextDirection.RTL)
|
|
xDest += primary.width;
|
|
|
|
Tweener.addTween(actor,
|
|
{ scale_x: 0.0,
|
|
scale_y: 0.0,
|
|
x: xDest,
|
|
y: 0,
|
|
time: WINDOW_ANIMATION_TIME,
|
|
transition: 'easeOutQuad',
|
|
onComplete: this._minimizeWindowDone,
|
|
onCompleteScope: this,
|
|
onCompleteParams: [shellwm, actor],
|
|
onOverwrite: this._minimizeWindowOverwritten,
|
|
onOverwriteScope: this,
|
|
onOverwriteParams: [shellwm, actor]
|
|
});
|
|
},
|
|
|
|
_minimizeWindowDone : function(shellwm, actor) {
|
|
if (this._removeEffect(this._minimizing, actor)) {
|
|
Tweener.removeTweens(actor);
|
|
actor.set_scale(1.0, 1.0);
|
|
actor.move_anchor_point_from_gravity(Clutter.Gravity.NORTH_WEST);
|
|
|
|
shellwm.completed_minimize(actor);
|
|
}
|
|
},
|
|
|
|
_minimizeWindowOverwritten : function(shellwm, actor) {
|
|
if (this._removeEffect(this._minimizing, actor)) {
|
|
shellwm.completed_minimize(actor);
|
|
}
|
|
},
|
|
|
|
_maximizeWindow : function(shellwm, actor, targetX, targetY, targetWidth, targetHeight) {
|
|
shellwm.completed_maximize(actor);
|
|
},
|
|
|
|
_maximizeWindowDone : function(shellwm, actor) {
|
|
},
|
|
|
|
_maximizeWindowOverwrite : function(shellwm, actor) {
|
|
},
|
|
|
|
_unmaximizeWindow : function(shellwm, actor, targetX, targetY, targetWidth, targetHeight) {
|
|
shellwm.completed_unmaximize(actor);
|
|
},
|
|
|
|
_unmaximizeWindowDone : function(shellwm, actor) {
|
|
},
|
|
|
|
_hasAttachedDialogs: function(window, ignoreWindow) {
|
|
var count = 0;
|
|
window.foreach_transient(function(win) {
|
|
if (win != ignoreWindow && win.is_attached_dialog())
|
|
count++;
|
|
return false;
|
|
});
|
|
return count != 0;
|
|
},
|
|
|
|
_checkDimming: function(window, ignoreWindow) {
|
|
let shouldDim = this._hasAttachedDialogs(window, ignoreWindow);
|
|
|
|
if (shouldDim && !window._dimmed) {
|
|
window._dimmed = true;
|
|
this._dimmedWindows.push(window);
|
|
if (!Main.overview.visible)
|
|
this._dimWindow(window, true);
|
|
} else if (!shouldDim && window._dimmed) {
|
|
window._dimmed = false;
|
|
this._dimmedWindows = this._dimmedWindows.filter(function(win) {
|
|
return win != window;
|
|
});
|
|
if (!Main.overview.visible)
|
|
this._undimWindow(window, true);
|
|
}
|
|
},
|
|
|
|
_dimWindow: function(window, animate) {
|
|
let actor = window.get_compositor_private();
|
|
if (!actor)
|
|
return;
|
|
if (animate)
|
|
Tweener.addTween(getWindowDimmer(actor),
|
|
{ dimFraction: 1.0,
|
|
time: DIM_TIME,
|
|
transition: 'linear'
|
|
});
|
|
else
|
|
getWindowDimmer(actor).dimFraction = 1.0;
|
|
},
|
|
|
|
_undimWindow: function(window, animate) {
|
|
let actor = window.get_compositor_private();
|
|
if (!actor)
|
|
return;
|
|
if (animate)
|
|
Tweener.addTween(getWindowDimmer(actor),
|
|
{ dimFraction: 0.0,
|
|
time: UNDIM_TIME,
|
|
transition: 'linear'
|
|
});
|
|
else
|
|
getWindowDimmer(actor).dimFraction = 0.0;
|
|
},
|
|
|
|
_mapWindow : function(shellwm, actor) {
|
|
actor._windowType = actor.meta_window.get_window_type();
|
|
actor._notifyWindowTypeSignalId = actor.meta_window.connect('notify::window-type', Lang.bind(this, function () {
|
|
let type = actor.meta_window.get_window_type();
|
|
if (type == actor._windowType)
|
|
return;
|
|
if (type == Meta.WindowType.MODAL_DIALOG ||
|
|
actor._windowType == Meta.WindowType.MODAL_DIALOG) {
|
|
let parent = actor.get_meta_window().get_transient_for();
|
|
if (parent)
|
|
this._checkDimming(parent);
|
|
}
|
|
|
|
actor._windowType = type;
|
|
}));
|
|
if (actor.meta_window.is_attached_dialog()) {
|
|
this._checkDimming(actor.get_meta_window().get_transient_for());
|
|
if (this._shouldAnimate()) {
|
|
actor.set_scale(1.0, 0.0);
|
|
actor.show();
|
|
this._mapping.push(actor);
|
|
|
|
Tweener.addTween(actor,
|
|
{ scale_y: 1,
|
|
time: WINDOW_ANIMATION_TIME,
|
|
transition: "easeOutQuad",
|
|
onComplete: this._mapWindowDone,
|
|
onCompleteScope: this,
|
|
onCompleteParams: [shellwm, actor],
|
|
onOverwrite: this._mapWindowOverwrite,
|
|
onOverwriteScope: this,
|
|
onOverwriteParams: [shellwm, actor]
|
|
});
|
|
return;
|
|
}
|
|
shellwm.completed_map(actor);
|
|
return;
|
|
}
|
|
if (!this._shouldAnimate(actor)) {
|
|
shellwm.completed_map(actor);
|
|
return;
|
|
}
|
|
|
|
actor.opacity = 0;
|
|
actor.show();
|
|
|
|
/* Fade window in */
|
|
this._mapping.push(actor);
|
|
Tweener.addTween(actor,
|
|
{ opacity: 255,
|
|
time: WINDOW_ANIMATION_TIME,
|
|
transition: 'easeOutQuad',
|
|
onComplete: this._mapWindowDone,
|
|
onCompleteScope: this,
|
|
onCompleteParams: [shellwm, actor],
|
|
onOverwrite: this._mapWindowOverwrite,
|
|
onOverwriteScope: this,
|
|
onOverwriteParams: [shellwm, actor]
|
|
});
|
|
},
|
|
|
|
_mapWindowDone : function(shellwm, actor) {
|
|
if (this._removeEffect(this._mapping, actor)) {
|
|
Tweener.removeTweens(actor);
|
|
actor.opacity = 255;
|
|
shellwm.completed_map(actor);
|
|
}
|
|
},
|
|
|
|
_mapWindowOverwrite : function(shellwm, actor) {
|
|
if (this._removeEffect(this._mapping, actor)) {
|
|
shellwm.completed_map(actor);
|
|
}
|
|
},
|
|
|
|
_destroyWindow : function(shellwm, actor) {
|
|
let window = actor.meta_window;
|
|
if (actor._notifyWindowTypeSignalId) {
|
|
window.disconnect(actor._notifyWindowTypeSignalId);
|
|
actor._notifyWindowTypeSignalId = 0;
|
|
}
|
|
if (window._dimmed) {
|
|
this._dimmedWindows = this._dimmedWindows.filter(function(win) {
|
|
return win != window;
|
|
});
|
|
}
|
|
if (window.is_attached_dialog()) {
|
|
let parent = window.get_transient_for();
|
|
this._checkDimming(parent, window);
|
|
if (!this._shouldAnimate()) {
|
|
shellwm.completed_destroy(actor);
|
|
return;
|
|
}
|
|
|
|
actor.set_scale(1.0, 1.0);
|
|
actor.show();
|
|
this._destroying.push(actor);
|
|
|
|
actor._parentDestroyId = parent.connect('unmanaged', Lang.bind(this, function () {
|
|
Tweener.removeTweens(actor);
|
|
this._destroyWindowDone(shellwm, actor);
|
|
}));
|
|
|
|
Tweener.addTween(actor,
|
|
{ scale_y: 0,
|
|
time: WINDOW_ANIMATION_TIME,
|
|
transition: "easeOutQuad",
|
|
onComplete: this._destroyWindowDone,
|
|
onCompleteScope: this,
|
|
onCompleteParams: [shellwm, actor],
|
|
onOverwrite: this._destroyWindowDone,
|
|
onOverwriteScope: this,
|
|
onOverwriteParams: [shellwm, actor]
|
|
});
|
|
return;
|
|
}
|
|
shellwm.completed_destroy(actor);
|
|
},
|
|
|
|
_destroyWindowDone : function(shellwm, actor) {
|
|
if (this._removeEffect(this._destroying, actor)) {
|
|
let parent = actor.get_meta_window().get_transient_for();
|
|
if (parent && actor._parentDestroyId) {
|
|
parent.disconnect(actor._parentDestroyId);
|
|
actor._parentDestroyId = 0;
|
|
}
|
|
shellwm.completed_destroy(actor);
|
|
}
|
|
},
|
|
|
|
_switchWorkspace : function(shellwm, from, to, direction) {
|
|
if (!this._shouldAnimate()) {
|
|
shellwm.completed_switch_workspace();
|
|
return;
|
|
}
|
|
|
|
let windows = global.get_window_actors();
|
|
|
|
/* @direction is the direction that the "camera" moves, so the
|
|
* screen contents have to move one screen's worth in the
|
|
* opposite direction.
|
|
*/
|
|
let xDest = 0, yDest = 0;
|
|
|
|
if (direction == Meta.MotionDirection.UP ||
|
|
direction == Meta.MotionDirection.UP_LEFT ||
|
|
direction == Meta.MotionDirection.UP_RIGHT)
|
|
yDest = global.screen_height;
|
|
else if (direction == Meta.MotionDirection.DOWN ||
|
|
direction == Meta.MotionDirection.DOWN_LEFT ||
|
|
direction == Meta.MotionDirection.DOWN_RIGHT)
|
|
yDest = -global.screen_height;
|
|
|
|
if (direction == Meta.MotionDirection.LEFT ||
|
|
direction == Meta.MotionDirection.UP_LEFT ||
|
|
direction == Meta.MotionDirection.DOWN_LEFT)
|
|
xDest = global.screen_width;
|
|
else if (direction == Meta.MotionDirection.RIGHT ||
|
|
direction == Meta.MotionDirection.UP_RIGHT ||
|
|
direction == Meta.MotionDirection.DOWN_RIGHT)
|
|
xDest = -global.screen_width;
|
|
|
|
let switchData = {};
|
|
this._switchData = switchData;
|
|
switchData.inGroup = new Clutter.Group();
|
|
switchData.outGroup = new Clutter.Group();
|
|
switchData.windows = [];
|
|
|
|
let wgroup = global.window_group;
|
|
wgroup.add_actor(switchData.inGroup);
|
|
wgroup.add_actor(switchData.outGroup);
|
|
|
|
for (let i = 0; i < windows.length; i++) {
|
|
let window = windows[i];
|
|
|
|
if (!window.meta_window.showing_on_its_workspace())
|
|
continue;
|
|
|
|
if (window.get_workspace() == from) {
|
|
switchData.windows.push({ window: window,
|
|
parent: window.get_parent() });
|
|
window.reparent(switchData.outGroup);
|
|
} else if (window.get_workspace() == to) {
|
|
switchData.windows.push({ window: window,
|
|
parent: window.get_parent() });
|
|
window.reparent(switchData.inGroup);
|
|
window.show_all();
|
|
}
|
|
}
|
|
|
|
switchData.inGroup.set_position(-xDest, -yDest);
|
|
switchData.inGroup.raise_top();
|
|
|
|
Tweener.addTween(switchData.outGroup,
|
|
{ x: xDest,
|
|
y: yDest,
|
|
time: WINDOW_ANIMATION_TIME,
|
|
transition: 'easeOutQuad',
|
|
onComplete: this._switchWorkspaceDone,
|
|
onCompleteScope: this,
|
|
onCompleteParams: [shellwm]
|
|
});
|
|
Tweener.addTween(switchData.inGroup,
|
|
{ x: 0,
|
|
y: 0,
|
|
time: WINDOW_ANIMATION_TIME,
|
|
transition: 'easeOutQuad'
|
|
});
|
|
},
|
|
|
|
_switchWorkspaceDone : function(shellwm) {
|
|
let switchData = this._switchData;
|
|
if (!switchData)
|
|
return;
|
|
this._switchData = null;
|
|
|
|
for (let i = 0; i < switchData.windows.length; i++) {
|
|
let w = switchData.windows[i];
|
|
if (w.window.is_destroyed()) // Window gone
|
|
continue;
|
|
if (w.window.get_parent() == switchData.outGroup) {
|
|
w.window.reparent(w.parent);
|
|
w.window.hide();
|
|
} else
|
|
w.window.reparent(w.parent);
|
|
}
|
|
Tweener.removeTweens(switchData.inGroup);
|
|
Tweener.removeTweens(switchData.outGroup);
|
|
switchData.inGroup.destroy();
|
|
switchData.outGroup.destroy();
|
|
|
|
shellwm.completed_switch_workspace();
|
|
},
|
|
|
|
_startAppSwitcher : function(display, screen, window, binding) {
|
|
/* prevent a corner case where both popups show up at once */
|
|
if (this._workspaceSwitcherPopup != null)
|
|
this._workspaceSwitcherPopup.actor.hide();
|
|
|
|
let tabPopup = new AltTab.AltTabPopup();
|
|
|
|
let modifiers = binding.get_modifiers();
|
|
let backwards = modifiers & Meta.VirtualModifier.SHIFT_MASK;
|
|
if (!tabPopup.show(backwards, binding.get_name(), binding.get_mask()))
|
|
tabPopup.destroy();
|
|
},
|
|
|
|
_startA11ySwitcher : function(display, screen, window, binding) {
|
|
let modifiers = binding.get_modifiers();
|
|
let backwards = modifiers & Meta.VirtualModifier.SHIFT_MASK;
|
|
Main.ctrlAltTabManager.popup(backwards, binding.get_mask());
|
|
},
|
|
|
|
_openAppMenu : function(display, screen, window, event, binding) {
|
|
Main.panel.openAppMenu();
|
|
},
|
|
|
|
_showWorkspaceSwitcher : function(display, screen, window, binding) {
|
|
if (screen.n_workspaces == 1)
|
|
return;
|
|
|
|
if (this._workspaceSwitcherPopup == null)
|
|
this._workspaceSwitcherPopup = new WorkspaceSwitcherPopup.WorkspaceSwitcherPopup();
|
|
|
|
if (binding.get_name() == 'switch-to-workspace-up')
|
|
this.actionMoveWorkspaceUp();
|
|
else if (binding.get_name() == 'switch-to-workspace-down')
|
|
this.actionMoveWorkspaceDown();
|
|
// left/right would effectively act as synonyms for up/down if we enabled them;
|
|
// but that could be considered confusing.
|
|
// else if (binding.get_name() == 'switch-to-workspace-left')
|
|
// this.actionMoveWorkspaceLeft();
|
|
// else if (binding.get_name() == 'switch-to-workspace-right')
|
|
// this.actionMoveWorkspaceRight();
|
|
},
|
|
|
|
actionMoveWorkspaceLeft: function() {
|
|
let rtl = (Clutter.get_default_text_direction() == Clutter.TextDirection.RTL);
|
|
let activeWorkspaceIndex = global.screen.get_active_workspace_index();
|
|
let indexToActivate = activeWorkspaceIndex;
|
|
if (rtl && activeWorkspaceIndex < global.screen.n_workspaces - 1)
|
|
indexToActivate++;
|
|
else if (!rtl && activeWorkspaceIndex > 0)
|
|
indexToActivate--;
|
|
|
|
if (indexToActivate != activeWorkspaceIndex)
|
|
global.screen.get_workspace_by_index(indexToActivate).activate(global.get_current_time());
|
|
|
|
if (!Main.overview.visible)
|
|
this._workspaceSwitcherPopup.display(WorkspaceSwitcherPopup.UP, indexToActivate);
|
|
},
|
|
|
|
actionMoveWorkspaceRight: function() {
|
|
let rtl = (Clutter.get_default_text_direction() == Clutter.TextDirection.RTL);
|
|
let activeWorkspaceIndex = global.screen.get_active_workspace_index();
|
|
let indexToActivate = activeWorkspaceIndex;
|
|
if (rtl && activeWorkspaceIndex > 0)
|
|
indexToActivate--;
|
|
else if (!rtl && activeWorkspaceIndex < global.screen.n_workspaces - 1)
|
|
indexToActivate++;
|
|
|
|
if (indexToActivate != activeWorkspaceIndex)
|
|
global.screen.get_workspace_by_index(indexToActivate).activate(global.get_current_time());
|
|
|
|
if (!Main.overview.visible)
|
|
this._workspaceSwitcherPopup.display(WorkspaceSwitcherPopup.DOWN, indexToActivate);
|
|
},
|
|
|
|
actionMoveWorkspaceUp: function() {
|
|
let activeWorkspaceIndex = global.screen.get_active_workspace_index();
|
|
let indexToActivate = activeWorkspaceIndex;
|
|
if (activeWorkspaceIndex > 0)
|
|
indexToActivate--;
|
|
|
|
if (indexToActivate != activeWorkspaceIndex)
|
|
global.screen.get_workspace_by_index(indexToActivate).activate(global.get_current_time());
|
|
|
|
if (!Main.overview.visible)
|
|
this._workspaceSwitcherPopup.display(WorkspaceSwitcherPopup.UP, indexToActivate);
|
|
},
|
|
|
|
actionMoveWorkspaceDown: function() {
|
|
let activeWorkspaceIndex = global.screen.get_active_workspace_index();
|
|
let indexToActivate = activeWorkspaceIndex;
|
|
if (activeWorkspaceIndex < global.screen.n_workspaces - 1)
|
|
indexToActivate++;
|
|
|
|
if (indexToActivate != activeWorkspaceIndex)
|
|
global.screen.get_workspace_by_index(indexToActivate).activate(global.get_current_time());
|
|
|
|
if (!Main.overview.visible)
|
|
this._workspaceSwitcherPopup.display(WorkspaceSwitcherPopup.DOWN, indexToActivate);
|
|
}
|
|
});
|