751189253a
Switch to the new WorkspaceLayout layout manager to allocate the window clones of the overview properly using Clutters layouting mechanisms. Since we now no longer make use of the fullGeometry, we can remove the setFullGeometry() function from the Workspace class. Also we can stop setting the actualGeometry on the Workspaces and WorkspaceViews and instead just set the fixed position and size of the views to their full or actual geometry. This also has the benefit that we no longer have to set a custom clip, but can simply enable clip_to_allocation. The geometry needs to be set inside a BEFORE_REDRAW later because _updateWorkspacesActualGeometry() is called from a notify::allocation handler. This isn't doing any animations when showing/hiding the overview yet, we'll add that in the next commit. https://gitlab.gnome.org/GNOME/gnome-shell/-/merge_requests/1305
833 lines
28 KiB
JavaScript
833 lines
28 KiB
JavaScript
// -*- mode: js; js-indent-level: 4; indent-tabs-mode: nil -*-
|
|
/* exported WorkspacesView, WorkspacesDisplay */
|
|
|
|
const { Clutter, Gio, GLib, GObject, Meta, Shell, St } = imports.gi;
|
|
|
|
const Main = imports.ui.main;
|
|
const SwipeTracker = imports.ui.swipeTracker;
|
|
const Workspace = imports.ui.workspace;
|
|
|
|
var WORKSPACE_SWITCH_TIME = 250;
|
|
var SCROLL_TIMEOUT_TIME = 150;
|
|
|
|
var AnimationType = {
|
|
ZOOM: 0,
|
|
FADE: 1,
|
|
};
|
|
|
|
const MUTTER_SCHEMA = 'org.gnome.mutter';
|
|
|
|
var WorkspacesViewBase = GObject.registerClass({
|
|
GTypeFlags: GObject.TypeFlags.ABSTRACT,
|
|
}, class WorkspacesViewBase extends St.Widget {
|
|
_init(monitorIndex) {
|
|
super._init({ style_class: 'workspaces-view' });
|
|
this.connect('destroy', this._onDestroy.bind(this));
|
|
global.focus_manager.add_group(this);
|
|
|
|
this._monitorIndex = monitorIndex;
|
|
|
|
this._fullGeometry = null;
|
|
|
|
this._inDrag = false;
|
|
this._windowDragBeginId = Main.overview.connect('window-drag-begin', this._dragBegin.bind(this));
|
|
this._windowDragEndId = Main.overview.connect('window-drag-end', this._dragEnd.bind(this));
|
|
}
|
|
|
|
_onDestroy() {
|
|
this._dragEnd();
|
|
|
|
if (this._windowDragBeginId > 0) {
|
|
Main.overview.disconnect(this._windowDragBeginId);
|
|
this._windowDragBeginId = 0;
|
|
}
|
|
if (this._windowDragEndId > 0) {
|
|
Main.overview.disconnect(this._windowDragEndId);
|
|
this._windowDragEndId = 0;
|
|
}
|
|
}
|
|
|
|
_dragBegin(overview, window) {
|
|
this._inDrag = true;
|
|
this._setReservedSlot(window);
|
|
}
|
|
|
|
_dragEnd() {
|
|
this._inDrag = false;
|
|
this._setReservedSlot(null);
|
|
}
|
|
|
|
setFullGeometry(geom) {
|
|
this._fullGeometry = geom;
|
|
}
|
|
|
|
vfunc_allocate(box) {
|
|
this.set_allocation(box);
|
|
|
|
for (const child of this)
|
|
child.allocate_available_size(0, 0, box.get_width(), box.get_height());
|
|
}
|
|
});
|
|
|
|
var WorkspacesView = GObject.registerClass(
|
|
class WorkspacesView extends WorkspacesViewBase {
|
|
_init(monitorIndex, scrollAdjustment) {
|
|
let workspaceManager = global.workspace_manager;
|
|
|
|
super._init(monitorIndex);
|
|
|
|
this._animating = false; // tweening
|
|
this._gestureActive = false; // touch(pad) gestures
|
|
|
|
this._scrollAdjustment = scrollAdjustment;
|
|
this._onScrollId =
|
|
this._scrollAdjustment.connect('notify::value',
|
|
this._onScroll.bind(this));
|
|
|
|
this._workspaces = [];
|
|
this._updateWorkspaces();
|
|
this._updateWorkspacesId =
|
|
workspaceManager.connect('notify::n-workspaces',
|
|
this._updateWorkspaces.bind(this));
|
|
this._reorderWorkspacesId =
|
|
workspaceManager.connect('workspaces-reordered', () => {
|
|
this._workspaces.sort((a, b) => {
|
|
return a.metaWorkspace.index() - b.metaWorkspace.index();
|
|
});
|
|
this._updateWorkspaceActors(false);
|
|
});
|
|
|
|
this._overviewShownId = Main.overview.connect('shown', () => {
|
|
this.clip_to_allocation = true;
|
|
});
|
|
|
|
this._switchWorkspaceNotifyId =
|
|
global.window_manager.connect('switch-workspace',
|
|
this._activeWorkspaceChanged.bind(this));
|
|
}
|
|
|
|
_setReservedSlot(window) {
|
|
for (let i = 0; i < this._workspaces.length; i++)
|
|
this._workspaces[i].setReservedSlot(window);
|
|
}
|
|
|
|
getActiveWorkspace() {
|
|
let workspaceManager = global.workspace_manager;
|
|
let active = workspaceManager.get_active_workspace_index();
|
|
return this._workspaces[active];
|
|
}
|
|
|
|
animateToOverview(animationType) {
|
|
for (let w = 0; w < this._workspaces.length; w++) {
|
|
if (animationType == AnimationType.ZOOM)
|
|
this._workspaces[w].zoomToOverview();
|
|
else
|
|
this._workspaces[w].fadeToOverview();
|
|
}
|
|
this._updateWorkspaceActors(false);
|
|
}
|
|
|
|
animateFromOverview(animationType) {
|
|
this.clip_to_allocation = false;
|
|
|
|
for (let w = 0; w < this._workspaces.length; w++) {
|
|
if (animationType == AnimationType.ZOOM)
|
|
this._workspaces[w].zoomFromOverview();
|
|
else
|
|
this._workspaces[w].fadeFromOverview();
|
|
}
|
|
}
|
|
|
|
syncStacking(stackIndices) {
|
|
for (let i = 0; i < this._workspaces.length; i++)
|
|
this._workspaces[i].syncStacking(stackIndices);
|
|
}
|
|
|
|
// Update workspace actors parameters
|
|
// @showAnimation: iff %true, transition between states
|
|
_updateWorkspaceActors(showAnimation) {
|
|
let workspaceManager = global.workspace_manager;
|
|
let active = workspaceManager.get_active_workspace_index();
|
|
|
|
this._animating = showAnimation;
|
|
|
|
for (let w = 0; w < this._workspaces.length; w++) {
|
|
let workspace = this._workspaces[w];
|
|
|
|
workspace.remove_all_transitions();
|
|
|
|
let params = {};
|
|
if (workspaceManager.layout_rows == -1)
|
|
params.translation_y = (w - active) * this._fullGeometry.height;
|
|
else if (this.text_direction == Clutter.TextDirection.RTL)
|
|
params.translation_x = (active - w) * this._fullGeometry.width;
|
|
else
|
|
params.translation_x = (w - active) * this._fullGeometry.width;
|
|
|
|
if (showAnimation) {
|
|
let easeParams = Object.assign(params, {
|
|
duration: WORKSPACE_SWITCH_TIME,
|
|
mode: Clutter.AnimationMode.EASE_OUT_CUBIC,
|
|
});
|
|
// 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();
|
|
easeParams.onComplete = () => {
|
|
this._animating = false;
|
|
this._updateVisibility();
|
|
};
|
|
}
|
|
workspace.ease(easeParams);
|
|
} else {
|
|
workspace.set(params);
|
|
if (w == 0)
|
|
this._updateVisibility();
|
|
}
|
|
}
|
|
}
|
|
|
|
_updateVisibility() {
|
|
let workspaceManager = global.workspace_manager;
|
|
let active = workspaceManager.get_active_workspace_index();
|
|
|
|
for (let w = 0; w < this._workspaces.length; w++) {
|
|
let workspace = this._workspaces[w];
|
|
|
|
if (this._animating || this._gestureActive)
|
|
workspace.show();
|
|
else if (this._inDrag)
|
|
workspace.visible = Math.abs(w - active) <= 1;
|
|
else
|
|
workspace.visible = w == active;
|
|
}
|
|
}
|
|
|
|
_updateWorkspaces() {
|
|
let workspaceManager = global.workspace_manager;
|
|
let newNumWorkspaces = workspaceManager.n_workspaces;
|
|
|
|
for (let j = 0; j < newNumWorkspaces; j++) {
|
|
let metaWorkspace = workspaceManager.get_workspace_by_index(j);
|
|
let workspace;
|
|
|
|
if (j >= this._workspaces.length) { /* added */
|
|
workspace = new Workspace.Workspace(metaWorkspace, this._monitorIndex);
|
|
this.add_actor(workspace);
|
|
this._workspaces[j] = workspace;
|
|
} else {
|
|
workspace = this._workspaces[j];
|
|
|
|
if (workspace.metaWorkspace != metaWorkspace) { /* removed */
|
|
workspace.destroy();
|
|
this._workspaces.splice(j, 1);
|
|
} /* else kept */
|
|
}
|
|
}
|
|
|
|
if (this._fullGeometry)
|
|
this._updateWorkspaceActors(false);
|
|
}
|
|
|
|
_activeWorkspaceChanged(_wm, _from, _to, _direction) {
|
|
if (this._scrolling)
|
|
return;
|
|
|
|
this._updateWorkspaceActors(true);
|
|
}
|
|
|
|
_onDestroy() {
|
|
super._onDestroy();
|
|
|
|
this._scrollAdjustment.disconnect(this._onScrollId);
|
|
Main.overview.disconnect(this._overviewShownId);
|
|
global.window_manager.disconnect(this._switchWorkspaceNotifyId);
|
|
let workspaceManager = global.workspace_manager;
|
|
workspaceManager.disconnect(this._updateWorkspacesId);
|
|
workspaceManager.disconnect(this._reorderWorkspacesId);
|
|
}
|
|
|
|
startTouchGesture() {
|
|
this._gestureActive = true;
|
|
}
|
|
|
|
endTouchGesture() {
|
|
this._gestureActive = false;
|
|
|
|
// Make sure title captions etc are shown as necessary
|
|
this._updateWorkspaceActors(true);
|
|
this._updateVisibility();
|
|
}
|
|
|
|
// sync the workspaces' positions to the value of the scroll adjustment
|
|
// and change the active workspace if appropriate
|
|
_onScroll(adj) {
|
|
if (adj.get_transition('value') !== null && !this._gestureActive)
|
|
return;
|
|
|
|
let workspaceManager = global.workspace_manager;
|
|
let active = workspaceManager.get_active_workspace_index();
|
|
let current = Math.round(adj.value);
|
|
|
|
if (active != current && !this._gestureActive) {
|
|
if (!this._workspaces[current]) {
|
|
// The current workspace was destroyed. This could happen
|
|
// when you are on the last empty workspace, and consolidate
|
|
// windows using the thumbnail bar.
|
|
// In that case, the intended behavior is to stay on the empty
|
|
// workspace, which is the last one, so pick it.
|
|
current = this._workspaces.length - 1;
|
|
}
|
|
|
|
let metaWorkspace = this._workspaces[current].metaWorkspace;
|
|
metaWorkspace.activate(global.get_current_time());
|
|
}
|
|
|
|
if (adj.upper == 1)
|
|
return;
|
|
|
|
let last = this._workspaces.length - 1;
|
|
|
|
if (workspaceManager.layout_rows == -1) {
|
|
let firstWorkspaceY = this._workspaces[0].translation_y;
|
|
let lastWorkspaceY = this._workspaces[last].translation_y;
|
|
let workspacesHeight = lastWorkspaceY - firstWorkspaceY;
|
|
|
|
let currentY = firstWorkspaceY;
|
|
let newY = -Math.round(adj.value / (adj.upper - 1) * workspacesHeight);
|
|
|
|
let dy = newY - currentY;
|
|
|
|
for (let i = 0; i < this._workspaces.length; i++) {
|
|
this._workspaces[i].visible = Math.abs(i - adj.value) <= 1;
|
|
this._workspaces[i].translation_y += dy;
|
|
}
|
|
} else {
|
|
let firstWorkspaceX = this._workspaces[0].translation_x;
|
|
let lastWorkspaceX = this._workspaces[last].translation_x;
|
|
let workspacesWidth = lastWorkspaceX - firstWorkspaceX;
|
|
|
|
let currentX = firstWorkspaceX;
|
|
let newX = -Math.round(adj.value / (adj.upper - 1) * workspacesWidth);
|
|
|
|
let dx = newX - currentX;
|
|
|
|
for (let i = 0; i < this._workspaces.length; i++) {
|
|
this._workspaces[i].visible = Math.abs(i - adj.value) <= 1;
|
|
this._workspaces[i].translation_x += dx;
|
|
}
|
|
}
|
|
}
|
|
});
|
|
|
|
var ExtraWorkspaceView = GObject.registerClass(
|
|
class ExtraWorkspaceView extends WorkspacesViewBase {
|
|
_init(monitorIndex) {
|
|
super._init(monitorIndex);
|
|
this._workspace = new Workspace.Workspace(null, monitorIndex);
|
|
this.add_actor(this._workspace);
|
|
}
|
|
|
|
_setReservedSlot(window) {
|
|
this._workspace.setReservedSlot(window);
|
|
}
|
|
|
|
getActiveWorkspace() {
|
|
return this._workspace;
|
|
}
|
|
|
|
animateToOverview(animationType) {
|
|
if (animationType == AnimationType.ZOOM)
|
|
this._workspace.zoomToOverview();
|
|
else
|
|
this._workspace.fadeToOverview();
|
|
}
|
|
|
|
animateFromOverview(animationType) {
|
|
if (animationType == AnimationType.ZOOM)
|
|
this._workspace.zoomFromOverview();
|
|
else
|
|
this._workspace.fadeFromOverview();
|
|
}
|
|
|
|
syncStacking(stackIndices) {
|
|
this._workspace.syncStacking(stackIndices);
|
|
}
|
|
|
|
startTouchGesture() {
|
|
}
|
|
|
|
endTouchGesture() {
|
|
}
|
|
});
|
|
|
|
var WorkspacesDisplay = GObject.registerClass(
|
|
class WorkspacesDisplay extends St.Widget {
|
|
_init(scrollAdjustment) {
|
|
super._init({
|
|
visible: false,
|
|
clip_to_allocation: true,
|
|
});
|
|
this.connect('notify::allocation', this._updateWorkspacesActualGeometry.bind(this));
|
|
|
|
let workspaceManager = global.workspace_manager;
|
|
this._scrollAdjustment = scrollAdjustment;
|
|
|
|
this._switchWorkspaceId =
|
|
global.window_manager.connect('switch-workspace',
|
|
this._activeWorkspaceChanged.bind(this));
|
|
|
|
this._reorderWorkspacesdId =
|
|
workspaceManager.connect('workspaces-reordered',
|
|
this._workspacesReordered.bind(this));
|
|
|
|
let clickAction = new Clutter.ClickAction();
|
|
clickAction.connect('clicked', action => {
|
|
// Only switch to the workspace when there's no application
|
|
// windows open. The problem is that it's too easy to miss
|
|
// an app window and get the wrong one focused.
|
|
let event = Clutter.get_current_event();
|
|
let index = this._getMonitorIndexForEvent(event);
|
|
if ((action.get_button() == 1 || action.get_button() == 0) &&
|
|
this._workspacesViews[index].getActiveWorkspace().isEmpty())
|
|
Main.overview.hide();
|
|
});
|
|
Main.overview.addAction(clickAction);
|
|
this.bind_property('mapped', clickAction, 'enabled', GObject.BindingFlags.SYNC_CREATE);
|
|
this._clickAction = clickAction;
|
|
|
|
this._swipeTracker = new SwipeTracker.SwipeTracker(
|
|
Main.layoutManager.overviewGroup, Shell.ActionMode.OVERVIEW);
|
|
this._swipeTracker.connect('begin', this._switchWorkspaceBegin.bind(this));
|
|
this._swipeTracker.connect('update', this._switchWorkspaceUpdate.bind(this));
|
|
this._swipeTracker.connect('end', this._switchWorkspaceEnd.bind(this));
|
|
this.connect('notify::mapped', this._updateSwipeTracker.bind(this));
|
|
|
|
this._windowDragBeginId =
|
|
Main.overview.connect('window-drag-begin',
|
|
this._windowDragBegin.bind(this));
|
|
this._windowDragEndId =
|
|
Main.overview.connect('window-drag-begin',
|
|
this._windowDragEnd.bind(this));
|
|
|
|
this._primaryIndex = Main.layoutManager.primaryIndex;
|
|
this._workspacesViews = [];
|
|
|
|
this._settings = new Gio.Settings({ schema_id: MUTTER_SCHEMA });
|
|
this._settings.connect('changed::workspaces-only-on-primary',
|
|
this._workspacesOnlyOnPrimaryChanged.bind(this));
|
|
this._workspacesOnlyOnPrimaryChanged();
|
|
|
|
this._notifyOpacityId = 0;
|
|
this._restackedNotifyId = 0;
|
|
this._scrollEventId = 0;
|
|
this._keyPressEventId = 0;
|
|
this._scrollTimeoutId = 0;
|
|
this._syncActualGeometryLater = 0;
|
|
|
|
this._actualGeometry = null;
|
|
this._fullGeometry = null;
|
|
this._inWindowDrag = false;
|
|
|
|
this._gestureActive = false; // touch(pad) gestures
|
|
this._canScroll = true; // limiting scrolling speed
|
|
|
|
this.connect('destroy', this._onDestroy.bind(this));
|
|
}
|
|
|
|
_onDestroy() {
|
|
if (this._notifyOpacityId) {
|
|
let parent = this.get_parent();
|
|
if (parent)
|
|
parent.disconnect(this._notifyOpacityId);
|
|
this._notifyOpacityId = 0;
|
|
}
|
|
|
|
if (this._parentSetLater) {
|
|
Meta.later_remove(this._parentSetLater);
|
|
this._parentSetLater = 0;
|
|
}
|
|
|
|
if (this._syncActualGeometryLater) {
|
|
Meta.later_remove(this._syncActualGeometryLater);
|
|
this._syncActualGeometryLater = 0;
|
|
}
|
|
|
|
if (this._scrollTimeoutId !== 0) {
|
|
GLib.source_remove(this._scrollTimeoutId);
|
|
this._scrollTimeoutId = 0;
|
|
}
|
|
|
|
global.window_manager.disconnect(this._switchWorkspaceId);
|
|
global.workspace_manager.disconnect(this._reorderWorkspacesdId);
|
|
Main.overview.disconnect(this._windowDragBeginId);
|
|
Main.overview.disconnect(this._windowDragEndId);
|
|
}
|
|
|
|
_windowDragBegin() {
|
|
this._inWindowDrag = true;
|
|
this._updateSwipeTracker();
|
|
}
|
|
|
|
_windowDragEnd() {
|
|
this._inWindowDrag = false;
|
|
this._updateSwipeTracker();
|
|
}
|
|
|
|
_updateSwipeTracker() {
|
|
this._swipeTracker.enabled = this.mapped && !this._inWindowDrag;
|
|
}
|
|
|
|
_workspacesReordered() {
|
|
let workspaceManager = global.workspace_manager;
|
|
|
|
this._scrollAdjustment.value =
|
|
workspaceManager.get_active_workspace_index();
|
|
}
|
|
|
|
_activeWorkspaceChanged(_wm, _from, to, _direction) {
|
|
if (this._gestureActive)
|
|
return;
|
|
|
|
this._scrollAdjustment.ease(to, {
|
|
mode: Clutter.AnimationMode.EASE_OUT_CUBIC,
|
|
duration: WORKSPACE_SWITCH_TIME,
|
|
});
|
|
}
|
|
|
|
_directionForProgress(progress) {
|
|
if (global.workspace_manager.layout_rows === -1) {
|
|
return progress > 0
|
|
? Meta.MotionDirection.DOWN
|
|
: Meta.MotionDirection.UP;
|
|
} else if (this.text_direction === Clutter.TextDirection.RTL) {
|
|
return progress > 0
|
|
? Meta.MotionDirection.LEFT
|
|
: Meta.MotionDirection.RIGHT;
|
|
} else {
|
|
return progress > 0
|
|
? Meta.MotionDirection.RIGHT
|
|
: Meta.MotionDirection.LEFT;
|
|
}
|
|
}
|
|
|
|
_switchWorkspaceBegin(tracker, monitor) {
|
|
if (this._workspacesOnlyOnPrimary && monitor !== this._primaryIndex)
|
|
return;
|
|
|
|
let workspaceManager = global.workspace_manager;
|
|
let adjustment = this._scrollAdjustment;
|
|
if (this._gestureActive)
|
|
adjustment.remove_transition('value');
|
|
|
|
tracker.orientation = workspaceManager.layout_rows !== -1
|
|
? Clutter.Orientation.HORIZONTAL
|
|
: Clutter.Orientation.VERTICAL;
|
|
|
|
for (let i = 0; i < this._workspacesViews.length; i++)
|
|
this._workspacesViews[i].startTouchGesture();
|
|
|
|
let monitors = Main.layoutManager.monitors;
|
|
let geometry = monitor === this._primaryIndex
|
|
? this._fullGeometry : monitors[monitor];
|
|
let distance = global.workspace_manager.layout_rows === -1
|
|
? geometry.height : geometry.width;
|
|
|
|
let progress = adjustment.value / adjustment.page_size;
|
|
let points = Array.from(
|
|
{ length: workspaceManager.n_workspaces }, (v, i) => i);
|
|
|
|
tracker.confirmSwipe(distance, points, progress, Math.round(progress));
|
|
|
|
this._gestureActive = true;
|
|
}
|
|
|
|
_switchWorkspaceUpdate(tracker, progress) {
|
|
let adjustment = this._scrollAdjustment;
|
|
adjustment.value = progress * adjustment.page_size;
|
|
}
|
|
|
|
_switchWorkspaceEnd(tracker, duration, endProgress) {
|
|
this._clickAction.release();
|
|
|
|
let workspaceManager = global.workspace_manager;
|
|
let newWs = workspaceManager.get_workspace_by_index(endProgress);
|
|
|
|
this._scrollAdjustment.ease(endProgress, {
|
|
mode: Clutter.AnimationMode.EASE_OUT_CUBIC,
|
|
duration,
|
|
onComplete: () => {
|
|
if (!newWs.active)
|
|
newWs.activate(global.get_current_time());
|
|
this._endTouchGesture();
|
|
},
|
|
});
|
|
}
|
|
|
|
_endTouchGesture() {
|
|
for (let i = 0; i < this._workspacesViews.length; i++)
|
|
this._workspacesViews[i].endTouchGesture();
|
|
this._gestureActive = false;
|
|
}
|
|
|
|
vfunc_navigate_focus(from, direction) {
|
|
return this._getPrimaryView().navigate_focus(from, direction, false);
|
|
}
|
|
|
|
animateToOverview(fadeOnPrimary) {
|
|
this.show();
|
|
this._updateWorkspacesViews();
|
|
|
|
if (this._actualGeometry && this._fullGeometry) {
|
|
for (let i = 0; i < this._workspacesViews.length; i++) {
|
|
let animationType;
|
|
if (fadeOnPrimary && i == this._primaryIndex)
|
|
animationType = AnimationType.FADE;
|
|
else
|
|
animationType = AnimationType.ZOOM;
|
|
this._workspacesViews[i].animateToOverview(animationType);
|
|
}
|
|
}
|
|
|
|
this._restackedNotifyId =
|
|
Main.overview.connect('windows-restacked',
|
|
this._onRestacked.bind(this));
|
|
if (this._scrollEventId == 0)
|
|
this._scrollEventId = Main.overview.connect('scroll-event', this._onScrollEvent.bind(this));
|
|
|
|
if (this._keyPressEventId == 0)
|
|
this._keyPressEventId = global.stage.connect('key-press-event', this._onKeyPressEvent.bind(this));
|
|
}
|
|
|
|
animateFromOverview(fadeOnPrimary) {
|
|
for (let i = 0; i < this._workspacesViews.length; i++) {
|
|
let animationType;
|
|
if (fadeOnPrimary && i == this._primaryIndex)
|
|
animationType = AnimationType.FADE;
|
|
else
|
|
animationType = AnimationType.ZOOM;
|
|
this._workspacesViews[i].animateFromOverview(animationType);
|
|
}
|
|
}
|
|
|
|
vfunc_hide() {
|
|
if (this._restackedNotifyId > 0) {
|
|
Main.overview.disconnect(this._restackedNotifyId);
|
|
this._restackedNotifyId = 0;
|
|
}
|
|
if (this._scrollEventId > 0) {
|
|
Main.overview.disconnect(this._scrollEventId);
|
|
this._scrollEventId = 0;
|
|
}
|
|
if (this._keyPressEventId > 0) {
|
|
global.stage.disconnect(this._keyPressEventId);
|
|
this._keyPressEventId = 0;
|
|
}
|
|
for (let i = 0; i < this._workspacesViews.length; i++)
|
|
this._workspacesViews[i].destroy();
|
|
this._workspacesViews = [];
|
|
|
|
super.vfunc_hide();
|
|
}
|
|
|
|
_workspacesOnlyOnPrimaryChanged() {
|
|
this._workspacesOnlyOnPrimary = this._settings.get_boolean('workspaces-only-on-primary');
|
|
|
|
if (!Main.overview.visible)
|
|
return;
|
|
|
|
this._updateWorkspacesViews();
|
|
}
|
|
|
|
_updateWorkspacesViews() {
|
|
for (let i = 0; i < this._workspacesViews.length; i++)
|
|
this._workspacesViews[i].destroy();
|
|
|
|
this._primaryIndex = Main.layoutManager.primaryIndex;
|
|
this._workspacesViews = [];
|
|
let monitors = Main.layoutManager.monitors;
|
|
for (let i = 0; i < monitors.length; i++) {
|
|
let view;
|
|
if (this._workspacesOnlyOnPrimary && i != this._primaryIndex)
|
|
view = new ExtraWorkspaceView(i);
|
|
else
|
|
view = new WorkspacesView(i, this._scrollAdjustment);
|
|
|
|
this._workspacesViews.push(view);
|
|
Main.layoutManager.overviewGroup.add_actor(view);
|
|
}
|
|
|
|
if (this._fullGeometry)
|
|
this._syncWorkspacesFullGeometry();
|
|
if (this._actualGeometry)
|
|
this._syncWorkspacesActualGeometry();
|
|
}
|
|
|
|
_getMonitorIndexForEvent(event) {
|
|
let [x, y] = event.get_coords();
|
|
let rect = new Meta.Rectangle({ x, y, width: 1, height: 1 });
|
|
return global.display.get_monitor_index_for_rect(rect);
|
|
}
|
|
|
|
_getPrimaryView() {
|
|
if (!this._workspacesViews.length)
|
|
return null;
|
|
return this._workspacesViews[this._primaryIndex];
|
|
}
|
|
|
|
activeWorkspaceHasMaximizedWindows() {
|
|
return this._getPrimaryView().getActiveWorkspace().hasMaximizedWindows();
|
|
}
|
|
|
|
vfunc_parent_set(oldParent) {
|
|
if (oldParent && this._notifyOpacityId)
|
|
oldParent.disconnect(this._notifyOpacityId);
|
|
this._notifyOpacityId = 0;
|
|
|
|
if (this._parentSetLater)
|
|
return;
|
|
|
|
this._parentSetLater = Meta.later_add(Meta.LaterType.BEFORE_REDRAW, () => {
|
|
this._parentSetLater = 0;
|
|
let newParent = this.get_parent();
|
|
if (!newParent)
|
|
return;
|
|
|
|
// This is kinda hackish - we want the primary view to
|
|
// appear as parent of this, though in reality it
|
|
// is added directly to Main.layoutManager.overviewGroup
|
|
this._notifyOpacityId = newParent.connect('notify::opacity', () => {
|
|
let opacity = this.get_parent().opacity;
|
|
let primaryView = this._getPrimaryView();
|
|
if (!primaryView)
|
|
return;
|
|
primaryView.opacity = opacity;
|
|
primaryView.visible = opacity != 0;
|
|
});
|
|
});
|
|
}
|
|
|
|
// This geometry should always be the fullest geometry
|
|
// the workspaces switcher can ever be allocated, as if
|
|
// the sliding controls were never slid in at all.
|
|
setWorkspacesFullGeometry(geom) {
|
|
this._fullGeometry = geom;
|
|
this._syncWorkspacesFullGeometry();
|
|
}
|
|
|
|
_syncWorkspacesFullGeometry() {
|
|
if (!this._workspacesViews.length)
|
|
return;
|
|
|
|
let monitors = Main.layoutManager.monitors;
|
|
for (let i = 0; i < monitors.length; i++) {
|
|
let geometry = i == this._primaryIndex ? this._fullGeometry : monitors[i];
|
|
this._workspacesViews[i].setFullGeometry(geometry);
|
|
}
|
|
}
|
|
|
|
_updateWorkspacesActualGeometry() {
|
|
const [x, y] = this.get_transformed_position();
|
|
const width = this.allocation.get_width();
|
|
const height = this.allocation.get_height();
|
|
|
|
this._actualGeometry = { x, y, width, height };
|
|
|
|
if (this._syncActualGeometryLater > 0)
|
|
return;
|
|
|
|
this._syncActualGeometryLater =
|
|
Meta.later_add(Meta.LaterType.BEFORE_REDRAW, () => {
|
|
this._syncWorkspacesActualGeometry();
|
|
|
|
this._syncActualGeometryLater = 0;
|
|
return GLib.SOURCE_REMOVE;
|
|
});
|
|
}
|
|
|
|
_syncWorkspacesActualGeometry() {
|
|
if (!this._workspacesViews.length)
|
|
return;
|
|
|
|
let monitors = Main.layoutManager.monitors;
|
|
for (let i = 0; i < monitors.length; i++) {
|
|
let geometry = i === this._primaryIndex ? this._actualGeometry : monitors[i];
|
|
const { x, y, width, height } = geometry;
|
|
|
|
this._workspacesViews[i].set({ x, y, width, height });
|
|
}
|
|
}
|
|
|
|
_onRestacked(overview, stackIndices) {
|
|
for (let i = 0; i < this._workspacesViews.length; i++)
|
|
this._workspacesViews[i].syncStacking(stackIndices);
|
|
}
|
|
|
|
_onScrollEvent(actor, event) {
|
|
if (this._swipeTracker.canHandleScrollEvent(event))
|
|
return Clutter.EVENT_PROPAGATE;
|
|
|
|
if (!this.mapped)
|
|
return Clutter.EVENT_PROPAGATE;
|
|
|
|
if (this._workspacesOnlyOnPrimary &&
|
|
this._getMonitorIndexForEvent(event) != this._primaryIndex)
|
|
return Clutter.EVENT_PROPAGATE;
|
|
|
|
if (!this._canScroll)
|
|
return Clutter.EVENT_PROPAGATE;
|
|
|
|
let workspaceManager = global.workspace_manager;
|
|
let activeWs = workspaceManager.get_active_workspace();
|
|
let ws;
|
|
switch (event.get_scroll_direction()) {
|
|
case Clutter.ScrollDirection.UP:
|
|
ws = activeWs.get_neighbor(Meta.MotionDirection.UP);
|
|
break;
|
|
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;
|
|
}
|
|
Main.wm.actionMoveWorkspace(ws);
|
|
|
|
this._canScroll = false;
|
|
this._scrollTimeoutId = GLib.timeout_add(GLib.PRIORITY_DEFAULT,
|
|
SCROLL_TIMEOUT_TIME, () => {
|
|
this._canScroll = true;
|
|
this._scrollTimeoutId = 0;
|
|
return GLib.SOURCE_REMOVE;
|
|
});
|
|
|
|
return Clutter.EVENT_STOP;
|
|
}
|
|
|
|
_onKeyPressEvent(actor, event) {
|
|
if (!this.mapped)
|
|
return Clutter.EVENT_PROPAGATE;
|
|
let workspaceManager = global.workspace_manager;
|
|
let activeWs = workspaceManager.get_active_workspace();
|
|
let ws;
|
|
switch (event.get_key_symbol()) {
|
|
case Clutter.KEY_Page_Up:
|
|
ws = activeWs.get_neighbor(Meta.MotionDirection.UP);
|
|
break;
|
|
case Clutter.KEY_Page_Down:
|
|
ws = activeWs.get_neighbor(Meta.MotionDirection.DOWN);
|
|
break;
|
|
default:
|
|
return Clutter.EVENT_PROPAGATE;
|
|
}
|
|
Main.wm.actionMoveWorkspace(ws);
|
|
return Clutter.EVENT_STOP;
|
|
}
|
|
});
|