e4db68a1da
We now found the underlying bug: The ControlsManager (which causes the
bad call to `_updateWorkspacesFullGeometry()`) is getting (re-)allocated
while we add the view to the overviewGroup actor because the
overviewGroup is already visible and the view is immediately getting
mapped by `clutter_actor_add_child_internal()`. That causes a
resource-scale calculation and that indirectly causes a call to
`_clutter_stage_maybe_relayout()` (explained more detailed in the last
commit).
So now that we got rid of the immediate relayout happening when mapping
the view, we can revert this fix.
This reverts commit 6cc19ee6f0.
https://gitlab.gnome.org/GNOME/gnome-shell/-/merge_requests/1315
858 lines
29 KiB
JavaScript
858 lines
29 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', reactive: true });
|
|
this.connect('destroy', this._onDestroy.bind(this));
|
|
global.focus_manager.add_group(this);
|
|
|
|
// The actor itself isn't a drop target, so we don't want to pick on its area
|
|
this.set_size(0, 0);
|
|
|
|
this._monitorIndex = monitorIndex;
|
|
|
|
this._fullGeometry = null;
|
|
this._actualGeometry = 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;
|
|
this._syncFullGeometry();
|
|
}
|
|
|
|
setActualGeometry(geom) {
|
|
this._actualGeometry = geom;
|
|
this._syncActualGeometry();
|
|
}
|
|
});
|
|
|
|
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.set_clip(this._fullGeometry.x, this._fullGeometry.y,
|
|
this._fullGeometry.width, this._fullGeometry.height);
|
|
});
|
|
|
|
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);
|
|
}
|
|
|
|
_syncFullGeometry() {
|
|
for (let i = 0; i < this._workspaces.length; i++)
|
|
this._workspaces[i].setFullGeometry(this._fullGeometry);
|
|
}
|
|
|
|
_syncActualGeometry() {
|
|
for (let i = 0; i < this._workspaces.length; i++)
|
|
this._workspaces[i].setActualGeometry(this._actualGeometry);
|
|
}
|
|
|
|
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.remove_clip();
|
|
|
|
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.y = (w - active) * this._fullGeometry.height;
|
|
else if (this.text_direction == Clutter.TextDirection.RTL)
|
|
params.x = (active - w) * this._fullGeometry.width;
|
|
else
|
|
params.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);
|
|
this._syncFullGeometry();
|
|
}
|
|
if (this._actualGeometry)
|
|
this._syncActualGeometry();
|
|
}
|
|
|
|
_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].y;
|
|
let lastWorkspaceY = this._workspaces[last].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].y += dy;
|
|
}
|
|
} else {
|
|
let firstWorkspaceX = this._workspaces[0].x;
|
|
let lastWorkspaceX = this._workspaces[last].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].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);
|
|
}
|
|
|
|
_syncFullGeometry() {
|
|
this._workspace.setFullGeometry(this._fullGeometry);
|
|
}
|
|
|
|
_syncActualGeometry() {
|
|
this._workspace.setActualGeometry(this._actualGeometry);
|
|
}
|
|
|
|
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._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._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._scrollToActive();
|
|
}
|
|
|
|
_scrollToActive() {
|
|
let workspaceManager = global.workspace_manager;
|
|
let active = workspaceManager.get_active_workspace_index();
|
|
|
|
this._updateScrollAdjustment(active);
|
|
}
|
|
|
|
_updateScrollAdjustment(index) {
|
|
if (this._gestureActive)
|
|
return;
|
|
|
|
this._scrollAdjustment.ease(index, {
|
|
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 activeWorkspace = workspaceManager.get_active_workspace();
|
|
let newWs = workspaceManager.get_workspace_by_index(endProgress);
|
|
|
|
this._scrollAdjustment.ease(endProgress, {
|
|
mode: Clutter.AnimationMode.EASE_OUT_CUBIC,
|
|
duration,
|
|
onComplete: () => {
|
|
if (newWs !== activeWorkspace)
|
|
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 };
|
|
this._syncWorkspacesActualGeometry();
|
|
}
|
|
|
|
_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];
|
|
this._workspacesViews[i].setActualGeometry(geometry);
|
|
}
|
|
}
|
|
|
|
_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;
|
|
}
|
|
});
|