gnome-shell/js/ui/workspacesView.js

1196 lines
39 KiB
JavaScript
Raw Normal View History

// -*- mode: js; js-indent-level: 4; indent-tabs-mode: nil -*-
/* exported WorkspacesView, WorkspacesDisplay */
const { Clutter, Gio, GObject, Meta, Shell, St } = imports.gi;
const Layout = imports.ui.layout;
const Main = imports.ui.main;
const OverviewControls = imports.ui.overviewControls;
const SwipeTracker = imports.ui.swipeTracker;
const Util = imports.misc.util;
const Workspace = imports.ui.workspace;
const { ThumbnailsBox, MAX_THUMBNAIL_SCALE } = imports.ui.workspaceThumbnail;
var WORKSPACE_SWITCH_TIME = 250;
const MUTTER_SCHEMA = 'org.gnome.mutter';
const WORKSPACE_MIN_SPACING = 24;
const WORKSPACE_MAX_SPACING = 80;
const WORKSPACE_INACTIVE_SCALE = 0.94;
const SECONDARY_WORKSPACE_SCALE = 0.80;
var WorkspacesViewBase = GObject.registerClass({
GTypeFlags: GObject.TypeFlags.ABSTRACT,
}, class WorkspacesViewBase extends St.Widget {
_init(monitorIndex, overviewAdjustment) {
super._init({
style_class: 'workspaces-view',
x_expand: true,
y_expand: true,
});
this.connect('destroy', this._onDestroy.bind(this));
global.focus_manager.add_group(this);
this._monitorIndex = monitorIndex;
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));
this._overviewAdjustment = overviewAdjustment;
this._overviewId = overviewAdjustment.connect('notify::value', () => {
this._updateWorkspaceMode();
});
}
_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;
}
if (this._overviewId > 0) {
this._overviewAdjustment.disconnect(this._overviewId);
delete this._overviewId;
}
}
_dragBegin() {
this._inDrag = true;
}
_dragEnd() {
this._inDrag = false;
}
_updateWorkspaceMode() {
}
vfunc_allocate(box) {
this.set_allocation(box);
for (const child of this)
child.allocate_available_size(0, 0, box.get_width(), box.get_height());
}
vfunc_get_preferred_width() {
return [0, 0];
}
vfunc_get_preferred_height() {
return [0, 0];
}
});
var FitMode = {
SINGLE: 0,
ALL: 1,
};
var WorkspacesView = GObject.registerClass(
class WorkspacesView extends WorkspacesViewBase {
workspacesView: Interpolate against relative workspace boxes The overview transition consists of getting the initial and final states of the overview adjustment, derivating various other internal states from them (such as the fit mode, opacities, translations, etc), and finally interpolating the allocation boxes. When interpolating between the fit mode, WorkspacesView uses the current allocation box to derivate the SINGLE and ALL fit mode boxes. However, that creates a curved path during overview transitions. What we really want to do here is calculate the fit mode box relative to the corresponding overview state. For example: +----------------+----------+------------------------+ | Overview State | Fit Mode | Workspaces geometry | +----------------+----------+------------------------+ | HIDDEN | SINGLE | Cover entire screen | | WINDOW PICKER | SINGLE | Between minimap & Dash | | APP GRID | ALL | 15% screen height | +----------------+----------+------------------------+ Using the table above as the reference, when the overview transitions between WINDOW PICKER and APP GRID, we must interpolate between (SINGLE fit mode @ between minimap & Dash) and (ALL fit mode @ 15% screen height). That way, we always interpolate the final boxes, which corrects the odd path that workspaces follow during this transition. Make the WorkspacesView of the primary monitor use these cached boxes when the overview is in the middle of a transition, and the fit modes of the initial and final state differ, to calculate the workspaces positions. Part-of: <https://gitlab.gnome.org/GNOME/gnome-shell/-/merge_requests/1624>
2021-02-02 14:34:59 -05:00
_init(monitorIndex, controls, scrollAdjustment, fitModeAdjustment, overviewAdjustment) {
let workspaceManager = global.workspace_manager;
super._init(monitorIndex, overviewAdjustment);
workspacesView: Interpolate against relative workspace boxes The overview transition consists of getting the initial and final states of the overview adjustment, derivating various other internal states from them (such as the fit mode, opacities, translations, etc), and finally interpolating the allocation boxes. When interpolating between the fit mode, WorkspacesView uses the current allocation box to derivate the SINGLE and ALL fit mode boxes. However, that creates a curved path during overview transitions. What we really want to do here is calculate the fit mode box relative to the corresponding overview state. For example: +----------------+----------+------------------------+ | Overview State | Fit Mode | Workspaces geometry | +----------------+----------+------------------------+ | HIDDEN | SINGLE | Cover entire screen | | WINDOW PICKER | SINGLE | Between minimap & Dash | | APP GRID | ALL | 15% screen height | +----------------+----------+------------------------+ Using the table above as the reference, when the overview transitions between WINDOW PICKER and APP GRID, we must interpolate between (SINGLE fit mode @ between minimap & Dash) and (ALL fit mode @ 15% screen height). That way, we always interpolate the final boxes, which corrects the odd path that workspaces follow during this transition. Make the WorkspacesView of the primary monitor use these cached boxes when the overview is in the middle of a transition, and the fit modes of the initial and final state differ, to calculate the workspaces positions. Part-of: <https://gitlab.gnome.org/GNOME/gnome-shell/-/merge_requests/1624>
2021-02-02 14:34:59 -05:00
this._controls = controls;
this._fitModeAdjustment = fitModeAdjustment;
this._fitModeNotifyId = this._fitModeAdjustment.connect('notify::value', () => {
this._updateVisibility();
this._updateWorkspacesState();
this.queue_relayout();
});
this._animating = false; // tweening
this._gestureActive = false; // touch(pad) gestures
this._scrollAdjustment = scrollAdjustment;
this._onScrollId = this._scrollAdjustment.connect('notify::value',
this._onScrollAdjustmentChanged.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._workspaces.forEach(
(ws, i) => this.set_child_at_index(ws, i));
});
this._switchWorkspaceNotifyId =
global.window_manager.connect('switch-workspace',
this._activeWorkspaceChanged.bind(this));
this._updateVisibility();
}
workspacesView: Interpolate against relative workspace boxes The overview transition consists of getting the initial and final states of the overview adjustment, derivating various other internal states from them (such as the fit mode, opacities, translations, etc), and finally interpolating the allocation boxes. When interpolating between the fit mode, WorkspacesView uses the current allocation box to derivate the SINGLE and ALL fit mode boxes. However, that creates a curved path during overview transitions. What we really want to do here is calculate the fit mode box relative to the corresponding overview state. For example: +----------------+----------+------------------------+ | Overview State | Fit Mode | Workspaces geometry | +----------------+----------+------------------------+ | HIDDEN | SINGLE | Cover entire screen | | WINDOW PICKER | SINGLE | Between minimap & Dash | | APP GRID | ALL | 15% screen height | +----------------+----------+------------------------+ Using the table above as the reference, when the overview transitions between WINDOW PICKER and APP GRID, we must interpolate between (SINGLE fit mode @ between minimap & Dash) and (ALL fit mode @ 15% screen height). That way, we always interpolate the final boxes, which corrects the odd path that workspaces follow during this transition. Make the WorkspacesView of the primary monitor use these cached boxes when the overview is in the middle of a transition, and the fit modes of the initial and final state differ, to calculate the workspaces positions. Part-of: <https://gitlab.gnome.org/GNOME/gnome-shell/-/merge_requests/1624>
2021-02-02 14:34:59 -05:00
_getFirstFitAllWorkspaceBox(box, spacing, vertical) {
const { nWorkspaces } = global.workspaceManager;
const [width, height] = box.get_size();
const [workspace] = this._workspaces;
const fitAllBox = new Clutter.ActorBox();
workspacesView: Interpolate against relative workspace boxes The overview transition consists of getting the initial and final states of the overview adjustment, derivating various other internal states from them (such as the fit mode, opacities, translations, etc), and finally interpolating the allocation boxes. When interpolating between the fit mode, WorkspacesView uses the current allocation box to derivate the SINGLE and ALL fit mode boxes. However, that creates a curved path during overview transitions. What we really want to do here is calculate the fit mode box relative to the corresponding overview state. For example: +----------------+----------+------------------------+ | Overview State | Fit Mode | Workspaces geometry | +----------------+----------+------------------------+ | HIDDEN | SINGLE | Cover entire screen | | WINDOW PICKER | SINGLE | Between minimap & Dash | | APP GRID | ALL | 15% screen height | +----------------+----------+------------------------+ Using the table above as the reference, when the overview transitions between WINDOW PICKER and APP GRID, we must interpolate between (SINGLE fit mode @ between minimap & Dash) and (ALL fit mode @ 15% screen height). That way, we always interpolate the final boxes, which corrects the odd path that workspaces follow during this transition. Make the WorkspacesView of the primary monitor use these cached boxes when the overview is in the middle of a transition, and the fit modes of the initial and final state differ, to calculate the workspaces positions. Part-of: <https://gitlab.gnome.org/GNOME/gnome-shell/-/merge_requests/1624>
2021-02-02 14:34:59 -05:00
let [x1, y1] = box.get_origin();
// Spacing here is not only the space between workspaces, but also the
// space before the first workspace, and after the last one. This prevents
// workspaces from touching the edges of the allocation box.
if (vertical) {
const availableHeight = height - spacing * (nWorkspaces + 1);
let workspaceHeight = availableHeight / nWorkspaces;
let [, workspaceWidth] =
workspace.get_preferred_width(workspaceHeight);
y1 = spacing;
if (workspaceWidth > width) {
[, workspaceHeight] = workspace.get_preferred_height(width);
y1 += Math.max((availableHeight - workspaceHeight * nWorkspaces) / 2, 0);
}
fitAllBox.set_size(width, workspaceHeight);
} else {
const availableWidth = width - spacing * (nWorkspaces + 1);
let workspaceWidth = availableWidth / nWorkspaces;
let [, workspaceHeight] =
workspace.get_preferred_height(workspaceWidth);
x1 = spacing;
if (workspaceHeight > height) {
[, workspaceWidth] = workspace.get_preferred_width(height);
x1 += Math.max((availableWidth - workspaceWidth * nWorkspaces) / 2, 0);
}
fitAllBox.set_size(workspaceWidth, height);
}
fitAllBox.set_origin(x1, y1);
return fitAllBox;
}
workspacesView: Interpolate against relative workspace boxes The overview transition consists of getting the initial and final states of the overview adjustment, derivating various other internal states from them (such as the fit mode, opacities, translations, etc), and finally interpolating the allocation boxes. When interpolating between the fit mode, WorkspacesView uses the current allocation box to derivate the SINGLE and ALL fit mode boxes. However, that creates a curved path during overview transitions. What we really want to do here is calculate the fit mode box relative to the corresponding overview state. For example: +----------------+----------+------------------------+ | Overview State | Fit Mode | Workspaces geometry | +----------------+----------+------------------------+ | HIDDEN | SINGLE | Cover entire screen | | WINDOW PICKER | SINGLE | Between minimap & Dash | | APP GRID | ALL | 15% screen height | +----------------+----------+------------------------+ Using the table above as the reference, when the overview transitions between WINDOW PICKER and APP GRID, we must interpolate between (SINGLE fit mode @ between minimap & Dash) and (ALL fit mode @ 15% screen height). That way, we always interpolate the final boxes, which corrects the odd path that workspaces follow during this transition. Make the WorkspacesView of the primary monitor use these cached boxes when the overview is in the middle of a transition, and the fit modes of the initial and final state differ, to calculate the workspaces positions. Part-of: <https://gitlab.gnome.org/GNOME/gnome-shell/-/merge_requests/1624>
2021-02-02 14:34:59 -05:00
_getFirstFitSingleWorkspaceBox(box, spacing, vertical) {
const [width, height] = box.get_size();
const [workspace] = this._workspaces;
const rtl = this.text_direction === Clutter.TextDirection.RTL;
const adj = this._scrollAdjustment;
const currentWorkspace = vertical || !rtl
? adj.value : adj.upper - adj.value - 1;
// Single fit mode implies centered too
workspacesView: Interpolate against relative workspace boxes The overview transition consists of getting the initial and final states of the overview adjustment, derivating various other internal states from them (such as the fit mode, opacities, translations, etc), and finally interpolating the allocation boxes. When interpolating between the fit mode, WorkspacesView uses the current allocation box to derivate the SINGLE and ALL fit mode boxes. However, that creates a curved path during overview transitions. What we really want to do here is calculate the fit mode box relative to the corresponding overview state. For example: +----------------+----------+------------------------+ | Overview State | Fit Mode | Workspaces geometry | +----------------+----------+------------------------+ | HIDDEN | SINGLE | Cover entire screen | | WINDOW PICKER | SINGLE | Between minimap & Dash | | APP GRID | ALL | 15% screen height | +----------------+----------+------------------------+ Using the table above as the reference, when the overview transitions between WINDOW PICKER and APP GRID, we must interpolate between (SINGLE fit mode @ between minimap & Dash) and (ALL fit mode @ 15% screen height). That way, we always interpolate the final boxes, which corrects the odd path that workspaces follow during this transition. Make the WorkspacesView of the primary monitor use these cached boxes when the overview is in the middle of a transition, and the fit modes of the initial and final state differ, to calculate the workspaces positions. Part-of: <https://gitlab.gnome.org/GNOME/gnome-shell/-/merge_requests/1624>
2021-02-02 14:34:59 -05:00
let [x1, y1] = box.get_origin();
if (vertical) {
const [, workspaceHeight] = workspace.get_preferred_height(width);
y1 += (height - workspaceHeight) / 2;
y1 -= currentWorkspace * (workspaceHeight + spacing);
} else {
const [, workspaceWidth] = workspace.get_preferred_width(height);
x1 += (width - workspaceWidth) / 2;
x1 -= currentWorkspace * (workspaceWidth + spacing);
}
const fitSingleBox = new Clutter.ActorBox({ x1, y1 });
if (vertical) {
const [, workspaceHeight] = workspace.get_preferred_height(width);
fitSingleBox.set_size(width, workspaceHeight);
} else {
const [, workspaceWidth] = workspace.get_preferred_width(height);
fitSingleBox.set_size(workspaceWidth, height);
}
return fitSingleBox;
}
_getSpacing(box, fitMode, vertical) {
const [width, height] = box.get_size();
const [workspace] = this._workspaces;
let availableSpace;
let workspaceSize;
if (vertical) {
[, workspaceSize] = workspace.get_preferred_height(width);
availableSpace = (height - workspaceSize) / 2;
} else {
[, workspaceSize] = workspace.get_preferred_width(height);
availableSpace = (width - workspaceSize) / 2;
}
const spacing = (availableSpace - workspaceSize * 0.4) * (1 - fitMode);
const { scaleFactor } = St.ThemeContext.get_for_stage(global.stage);
return Math.clamp(spacing, WORKSPACE_MIN_SPACING * scaleFactor,
WORKSPACE_MAX_SPACING * scaleFactor);
}
_getWorkspaceModeForOverviewState(state) {
const { ControlsState } = OverviewControls;
switch (state) {
case ControlsState.HIDDEN:
return 0;
case ControlsState.WINDOW_PICKER:
return 1;
case ControlsState.APP_GRID:
return 0;
}
return 0;
}
_updateWorkspacesState() {
const adj = this._scrollAdjustment;
const fitMode = this._fitModeAdjustment.value;
const { initialState, finalState, progress } =
this._overviewAdjustment.getStateTransitionParams();
const workspaceMode = (1 - fitMode) * Util.lerp(
this._getWorkspaceModeForOverviewState(initialState),
this._getWorkspaceModeForOverviewState(finalState),
progress);
// Fade and scale inactive workspaces
this._workspaces.forEach((w, index) => {
w.stateAdjustment.value = workspaceMode;
const distanceToCurrentWorkspace = Math.abs(adj.value - index);
const scaleProgress = 1 - Math.clamp(distanceToCurrentWorkspace, 0, 1);
const scale = Util.lerp(WORKSPACE_INACTIVE_SCALE, 1, scaleProgress);
w.set_scale(scale, scale);
});
}
workspacesView: Interpolate against relative workspace boxes The overview transition consists of getting the initial and final states of the overview adjustment, derivating various other internal states from them (such as the fit mode, opacities, translations, etc), and finally interpolating the allocation boxes. When interpolating between the fit mode, WorkspacesView uses the current allocation box to derivate the SINGLE and ALL fit mode boxes. However, that creates a curved path during overview transitions. What we really want to do here is calculate the fit mode box relative to the corresponding overview state. For example: +----------------+----------+------------------------+ | Overview State | Fit Mode | Workspaces geometry | +----------------+----------+------------------------+ | HIDDEN | SINGLE | Cover entire screen | | WINDOW PICKER | SINGLE | Between minimap & Dash | | APP GRID | ALL | 15% screen height | +----------------+----------+------------------------+ Using the table above as the reference, when the overview transitions between WINDOW PICKER and APP GRID, we must interpolate between (SINGLE fit mode @ between minimap & Dash) and (ALL fit mode @ 15% screen height). That way, we always interpolate the final boxes, which corrects the odd path that workspaces follow during this transition. Make the WorkspacesView of the primary monitor use these cached boxes when the overview is in the middle of a transition, and the fit modes of the initial and final state differ, to calculate the workspaces positions. Part-of: <https://gitlab.gnome.org/GNOME/gnome-shell/-/merge_requests/1624>
2021-02-02 14:34:59 -05:00
_getFitModeForState(state) {
const { ControlsState } = OverviewControls;
switch (state) {
case ControlsState.HIDDEN:
case ControlsState.WINDOW_PICKER:
return FitMode.SINGLE;
case ControlsState.APP_GRID:
return FitMode.ALL;
default:
return FitMode.SINGLE;
}
}
_getInitialBoxes(box) {
const offsetBox = new Clutter.ActorBox();
offsetBox.set_size(...box.get_size());
let fitSingleBox = offsetBox;
let fitAllBox = offsetBox;
const { transitioning, initialState, finalState } =
this._overviewAdjustment.getStateTransitionParams();
const isPrimary = Main.layoutManager.primaryIndex === this._monitorIndex;
if (isPrimary && transitioning) {
const initialFitMode = this._getFitModeForState(initialState);
const finalFitMode = this._getFitModeForState(finalState);
// Only use the relative boxes when the overview is in a state
// transition, and the corresponding fit modes are different.
if (initialFitMode !== finalFitMode) {
const initialBox =
this._controls.getWorkspacesBoxForState(initialState).copy();
const finalBox =
this._controls.getWorkspacesBoxForState(finalState).copy();
// Boxes are relative to ControlsManager, transform them;
// this.apply_relative_transform_to_point(controls,
// new Graphene.Point3D());
// would be more correct, but also more expensive
const [parentOffsetX, parentOffsetY] =
this.get_parent().allocation.get_origin();
[initialBox, finalBox].forEach(b => {
b.set_origin(b.x1 - parentOffsetX, b.y1 - parentOffsetY);
});
if (initialFitMode === FitMode.SINGLE)
[fitSingleBox, fitAllBox] = [initialBox, finalBox];
else
[fitAllBox, fitSingleBox] = [initialBox, finalBox];
}
}
return [fitSingleBox, fitAllBox];
}
_updateWorkspaceMode() {
this._updateWorkspacesState();
}
vfunc_allocate(box) {
this.set_allocation(box);
if (this.get_n_children() === 0)
return;
const vertical = global.workspaceManager.layout_rows === -1;
const rtl = this.text_direction === Clutter.TextDirection.RTL;
const fitMode = this._fitModeAdjustment.value;
workspacesView: Interpolate against relative workspace boxes The overview transition consists of getting the initial and final states of the overview adjustment, derivating various other internal states from them (such as the fit mode, opacities, translations, etc), and finally interpolating the allocation boxes. When interpolating between the fit mode, WorkspacesView uses the current allocation box to derivate the SINGLE and ALL fit mode boxes. However, that creates a curved path during overview transitions. What we really want to do here is calculate the fit mode box relative to the corresponding overview state. For example: +----------------+----------+------------------------+ | Overview State | Fit Mode | Workspaces geometry | +----------------+----------+------------------------+ | HIDDEN | SINGLE | Cover entire screen | | WINDOW PICKER | SINGLE | Between minimap & Dash | | APP GRID | ALL | 15% screen height | +----------------+----------+------------------------+ Using the table above as the reference, when the overview transitions between WINDOW PICKER and APP GRID, we must interpolate between (SINGLE fit mode @ between minimap & Dash) and (ALL fit mode @ 15% screen height). That way, we always interpolate the final boxes, which corrects the odd path that workspaces follow during this transition. Make the WorkspacesView of the primary monitor use these cached boxes when the overview is in the middle of a transition, and the fit modes of the initial and final state differ, to calculate the workspaces positions. Part-of: <https://gitlab.gnome.org/GNOME/gnome-shell/-/merge_requests/1624>
2021-02-02 14:34:59 -05:00
let [fitSingleBox, fitAllBox] = this._getInitialBoxes(box);
const fitSingleSpacing =
workspacesView: Interpolate against relative workspace boxes The overview transition consists of getting the initial and final states of the overview adjustment, derivating various other internal states from them (such as the fit mode, opacities, translations, etc), and finally interpolating the allocation boxes. When interpolating between the fit mode, WorkspacesView uses the current allocation box to derivate the SINGLE and ALL fit mode boxes. However, that creates a curved path during overview transitions. What we really want to do here is calculate the fit mode box relative to the corresponding overview state. For example: +----------------+----------+------------------------+ | Overview State | Fit Mode | Workspaces geometry | +----------------+----------+------------------------+ | HIDDEN | SINGLE | Cover entire screen | | WINDOW PICKER | SINGLE | Between minimap & Dash | | APP GRID | ALL | 15% screen height | +----------------+----------+------------------------+ Using the table above as the reference, when the overview transitions between WINDOW PICKER and APP GRID, we must interpolate between (SINGLE fit mode @ between minimap & Dash) and (ALL fit mode @ 15% screen height). That way, we always interpolate the final boxes, which corrects the odd path that workspaces follow during this transition. Make the WorkspacesView of the primary monitor use these cached boxes when the overview is in the middle of a transition, and the fit modes of the initial and final state differ, to calculate the workspaces positions. Part-of: <https://gitlab.gnome.org/GNOME/gnome-shell/-/merge_requests/1624>
2021-02-02 14:34:59 -05:00
this._getSpacing(fitSingleBox, FitMode.SINGLE, vertical);
fitSingleBox =
this._getFirstFitSingleWorkspaceBox(fitSingleBox, fitSingleSpacing, vertical);
const fitAllSpacing =
workspacesView: Interpolate against relative workspace boxes The overview transition consists of getting the initial and final states of the overview adjustment, derivating various other internal states from them (such as the fit mode, opacities, translations, etc), and finally interpolating the allocation boxes. When interpolating between the fit mode, WorkspacesView uses the current allocation box to derivate the SINGLE and ALL fit mode boxes. However, that creates a curved path during overview transitions. What we really want to do here is calculate the fit mode box relative to the corresponding overview state. For example: +----------------+----------+------------------------+ | Overview State | Fit Mode | Workspaces geometry | +----------------+----------+------------------------+ | HIDDEN | SINGLE | Cover entire screen | | WINDOW PICKER | SINGLE | Between minimap & Dash | | APP GRID | ALL | 15% screen height | +----------------+----------+------------------------+ Using the table above as the reference, when the overview transitions between WINDOW PICKER and APP GRID, we must interpolate between (SINGLE fit mode @ between minimap & Dash) and (ALL fit mode @ 15% screen height). That way, we always interpolate the final boxes, which corrects the odd path that workspaces follow during this transition. Make the WorkspacesView of the primary monitor use these cached boxes when the overview is in the middle of a transition, and the fit modes of the initial and final state differ, to calculate the workspaces positions. Part-of: <https://gitlab.gnome.org/GNOME/gnome-shell/-/merge_requests/1624>
2021-02-02 14:34:59 -05:00
this._getSpacing(fitAllBox, FitMode.ALL, vertical);
fitAllBox =
this._getFirstFitAllWorkspaceBox(fitAllBox, fitAllSpacing, vertical);
// Account for RTL locales by reversing the list
const workspaces = this._workspaces.slice();
if (rtl)
workspaces.reverse();
const [fitSingleX1, fitSingleY1] = fitSingleBox.get_origin();
const [fitSingleWidth, fitSingleHeight] = fitSingleBox.get_size();
const [fitAllX1, fitAllY1] = fitAllBox.get_origin();
const [fitAllWidth, fitAllHeight] = fitAllBox.get_size();
workspaces.forEach(child => {
if (fitMode === FitMode.SINGLE)
box = fitSingleBox;
else if (fitMode === FitMode.ALL)
box = fitAllBox;
else
box = fitSingleBox.interpolate(fitAllBox, fitMode);
child.allocate_align_fill(box, 0.5, 0.5, false, false);
if (vertical) {
fitSingleBox.set_origin(
fitSingleX1,
fitSingleBox.y1 + fitSingleHeight + fitSingleSpacing);
fitAllBox.set_origin(
fitAllX1,
fitAllBox.y1 + fitAllHeight + fitAllSpacing);
} else {
fitSingleBox.set_origin(
fitSingleBox.x1 + fitSingleWidth + fitSingleSpacing,
fitSingleY1);
fitAllBox.set_origin(
fitAllBox.x1 + fitAllWidth + fitAllSpacing,
fitAllY1);
}
});
}
getActiveWorkspace() {
let workspaceManager = global.workspace_manager;
let active = workspaceManager.get_active_workspace_index();
return this._workspaces[active];
}
prepareToLeaveOverview() {
for (let w = 0; w < this._workspaces.length; w++)
this._workspaces[w].prepareToLeaveOverview();
}
syncStacking(stackIndices) {
for (let i = 0; i < this._workspaces.length; i++)
this._workspaces[i].syncStacking(stackIndices);
}
_scrollToActive() {
const { workspaceManager } = global;
const active = workspaceManager.get_active_workspace_index();
this._animating = true;
this._updateVisibility();
this._scrollAdjustment.remove_transition('value');
this._scrollAdjustment.ease(active, {
duration: WORKSPACE_SWITCH_TIME,
mode: Clutter.AnimationMode.EASE_OUT_CUBIC,
onComplete: () => {
this._animating = false;
this._updateVisibility();
},
});
}
_updateVisibility() {
let workspaceManager = global.workspace_manager;
let active = workspaceManager.get_active_workspace_index();
const fitMode = this._fitModeAdjustment.value;
const singleFitMode = fitMode === FitMode.SINGLE;
for (let w = 0; w < this._workspaces.length; w++) {
let workspace = this._workspaces[w];
if (this._animating || this._gestureActive || !singleFitMode)
workspace.show();
else
workspace.visible = Math.abs(w - active) <= 1;
}
}
_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._overviewAdjustment);
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 */
}
}
for (let j = this._workspaces.length - 1; j >= newNumWorkspaces; j--) {
this._workspaces[j].destroy();
this._workspaces.splice(j, 1);
}
this._updateWorkspacesState();
}
_activeWorkspaceChanged(_wm, _from, _to, _direction) {
if (this._scrolling)
return;
this._scrollToActive();
}
_onDestroy() {
super._onDestroy();
this._workspaces = [];
this._scrollAdjustment.disconnect(this._onScrollId);
this._fitModeAdjustment.disconnect(this._fitModeNotifyId);
global.window_manager.disconnect(this._switchWorkspaceNotifyId);
let workspaceManager = global.workspace_manager;
workspaceManager.disconnect(this._updateWorkspacesId);
workspaceManager.disconnect(this._reorderWorkspacesId);
}
startTouchGesture() {
this._gestureActive = true;
this._updateVisibility();
}
endTouchGesture() {
this._gestureActive = false;
// Make sure title captions etc are shown as necessary
this._scrollToActive();
this._updateVisibility();
}
// sync the workspaces' positions to the value of the scroll adjustment
// and change the active workspace if appropriate
_onScrollAdjustmentChanged() {
if (!this.has_allocation())
return;
const adj = this._scrollAdjustment;
const allowSwitch =
adj.get_transition('value') === null && !this._gestureActive;
let workspaceManager = global.workspace_manager;
let active = workspaceManager.get_active_workspace_index();
let current = Math.round(adj.value);
if (allowSwitch && active !== current) {
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());
}
this._updateWorkspacesState();
this.queue_relayout();
}
});
var ExtraWorkspaceView = GObject.registerClass(
class ExtraWorkspaceView extends WorkspacesViewBase {
_init(monitorIndex, overviewAdjustment) {
super._init(monitorIndex, overviewAdjustment);
this._workspace =
new Workspace.Workspace(null, monitorIndex, overviewAdjustment);
this.add_actor(this._workspace);
}
_updateWorkspaceMode() {
const overviewState = this._overviewAdjustment.value;
const progress = Math.clamp(overviewState,
OverviewControls.ControlsState.HIDDEN,
OverviewControls.ControlsState.WINDOW_PICKER);
this._workspace.stateAdjustment.value = progress;
}
vfunc_allocate(box) {
this.set_allocation(box);
const [width, height] = box.get_size();
const [, childWidth] = this._workspace.get_preferred_width(height);
const childBox = new Clutter.ActorBox();
childBox.set_origin(Math.round((width - childWidth) / 2), 0);
childBox.set_size(childWidth, height);
this._workspace.allocate(childBox);
}
getActiveWorkspace() {
return this._workspace;
}
prepareToLeaveOverview() {
this._workspace.prepareToLeaveOverview();
}
syncStacking(stackIndices) {
this._workspace.syncStacking(stackIndices);
}
startTouchGesture() {
}
endTouchGesture() {
}
});
const SecondaryMonitorDisplay = GObject.registerClass(
class SecondaryMonitorDisplay extends St.Widget {
_init(monitorIndex, controls, scrollAdjustment, fitModeAdjustment, overviewAdjustment) {
this._monitorIndex = monitorIndex;
this._controls = controls;
this._scrollAdjustment = scrollAdjustment;
this._fitModeAdjustment = fitModeAdjustment;
this._overviewAdjustment = overviewAdjustment;
super._init({
style_class: 'secondary-monitor-workspaces',
constraints: new Layout.MonitorConstraint({
index: this._monitorIndex,
work_area: true,
}),
clip_to_allocation: true,
});
this.connect('destroy', () => this._onDestroy());
this._thumbnails = new ThumbnailsBox(
this._scrollAdjustment, monitorIndex);
this.add_child(this._thumbnails);
this._thumbnails.connect('notify::should-show',
() => this._updateThumbnailVisibility());
this._stateChangedId = this._overviewAdjustment.connect('notify::value',
() => {
this._updateThumbnailParams();
this.queue_relayout();
});
this._settings = new Gio.Settings({ schema_id: MUTTER_SCHEMA });
this._settings.connect('changed::workspaces-only-on-primary',
() => this._workspacesOnPrimaryChanged());
this._workspacesOnPrimaryChanged();
}
_getThumbnailParamsForState(state) {
const { ControlsState } = OverviewControls;
let opacity, scale;
switch (state) {
case ControlsState.HIDDEN:
case ControlsState.WINDOW_PICKER:
opacity = 255;
scale = 1;
break;
case ControlsState.APP_GRID:
opacity = 0;
scale = 0.5;
break;
default:
opacity = 255;
scale = 1;
break;
}
return { opacity, scale };
}
_getThumbnailsHeight(box) {
if (!this._thumbnails.visible)
return 0;
const [width, height] = box.get_size();
const { expandFraction } = this._thumbnails;
const [thumbnailsHeight] = this._thumbnails.get_preferred_height(width);
return Math.min(
thumbnailsHeight * expandFraction,
height * MAX_THUMBNAIL_SCALE);
}
_getWorkspacesBoxForState(state, box, padding, thumbnailsHeight, spacing) {
const { ControlsState } = OverviewControls;
const workspaceBox = box.copy();
const [width, height] = workspaceBox.get_size();
switch (state) {
case ControlsState.HIDDEN:
break;
case ControlsState.WINDOW_PICKER:
workspaceBox.set_origin(0, padding + thumbnailsHeight + spacing);
workspaceBox.set_size(
width,
height - 2 * padding - thumbnailsHeight - spacing);
break;
case ControlsState.APP_GRID:
workspaceBox.set_origin(0, padding);
workspaceBox.set_size(
width,
height - 2 * padding);
break;
}
return workspaceBox;
}
vfunc_allocate(box) {
this.set_allocation(box);
const themeNode = this.get_theme_node();
const contentBox = themeNode.get_content_box(box);
const [width, height] = contentBox.get_size();
const { expandFraction } = this._thumbnails;
const spacing = themeNode.get_length('spacing') * expandFraction;
const padding =
Math.round((1 - SECONDARY_WORKSPACE_SCALE) * height / 2);
const thumbnailsHeight = this._getThumbnailsHeight(contentBox);
if (this._thumbnails.visible) {
const childBox = new Clutter.ActorBox();
childBox.set_origin(0, padding);
childBox.set_size(width, thumbnailsHeight);
this._thumbnails.allocate(childBox);
}
const {
currentState, initialState, finalState, transitioning, progress,
} = this._overviewAdjustment.getStateTransitionParams();
let workspacesBox;
const workspaceParams = [contentBox, padding, thumbnailsHeight, spacing];
if (!transitioning) {
workspacesBox =
this._getWorkspacesBoxForState(currentState, ...workspaceParams);
} else {
const initialBox =
this._getWorkspacesBoxForState(initialState, ...workspaceParams);
const finalBox =
this._getWorkspacesBoxForState(finalState, ...workspaceParams);
workspacesBox = initialBox.interpolate(finalBox, progress);
}
this._workspacesView.allocate(workspacesBox);
}
_onDestroy() {
if (this._settings)
this._settings.run_dispose();
this._settings = null;
if (this._stateChangedId)
this._overviewAdjustment.disconnect(this._stateChangedId);
this._stateChangedId = 0;
}
_workspacesOnPrimaryChanged() {
this._updateWorkspacesView();
this._updateThumbnailVisibility();
}
_updateWorkspacesView() {
if (this._workspacesView)
this._workspacesView.destroy();
if (this._settings.get_boolean('workspaces-only-on-primary')) {
this._workspacesView = new ExtraWorkspaceView(
this._monitorIndex,
this._overviewAdjustment);
} else {
this._workspacesView = new WorkspacesView(
this._monitorIndex,
this._controls,
this._scrollAdjustment,
this._fitModeAdjustment,
this._overviewAdjustment);
}
this.add_child(this._workspacesView);
}
_updateThumbnailVisibility() {
const visible =
this._thumbnails.should_show &&
!this._settings.get_boolean('workspaces-only-on-primary');
if (this._thumbnails.visible === visible)
return;
this._thumbnails.show();
this._updateThumbnailParams();
this._thumbnails.ease_property('expand-fraction', visible ? 1 : 0, {
duration: OverviewControls.SIDE_CONTROLS_ANIMATION_TIME,
mode: Clutter.AnimationMode.EASE_OUT_QUAD,
onComplete: () => (this._thumbnails.visible = visible),
});
}
_updateThumbnailParams() {
if (!this._thumbnails.visible)
return;
const { initialState, finalState, progress } =
this._overviewAdjustment.getStateTransitionParams();
const initialParams = this._getThumbnailParamsForState(initialState);
const finalParams = this._getThumbnailParamsForState(finalState);
const opacity =
Util.lerp(initialParams.opacity, finalParams.opacity, progress);
const scale =
Util.lerp(initialParams.scale, finalParams.scale, progress);
this._thumbnails.set({
opacity,
scale_x: scale,
scale_y: scale,
});
}
getActiveWorkspace() {
return this._workspacesView.getActiveWorkspace();
}
prepareToLeaveOverview() {
this._workspacesView.prepareToLeaveOverview();
}
syncStacking(stackIndices) {
this._workspacesView.syncStacking(stackIndices);
}
startTouchGesture() {
this._workspacesView.startTouchGesture();
}
endTouchGesture() {
this._workspacesView.endTouchGesture();
}
});
var WorkspacesDisplay = GObject.registerClass(
class WorkspacesDisplay extends St.Widget {
workspacesView: Interpolate against relative workspace boxes The overview transition consists of getting the initial and final states of the overview adjustment, derivating various other internal states from them (such as the fit mode, opacities, translations, etc), and finally interpolating the allocation boxes. When interpolating between the fit mode, WorkspacesView uses the current allocation box to derivate the SINGLE and ALL fit mode boxes. However, that creates a curved path during overview transitions. What we really want to do here is calculate the fit mode box relative to the corresponding overview state. For example: +----------------+----------+------------------------+ | Overview State | Fit Mode | Workspaces geometry | +----------------+----------+------------------------+ | HIDDEN | SINGLE | Cover entire screen | | WINDOW PICKER | SINGLE | Between minimap & Dash | | APP GRID | ALL | 15% screen height | +----------------+----------+------------------------+ Using the table above as the reference, when the overview transitions between WINDOW PICKER and APP GRID, we must interpolate between (SINGLE fit mode @ between minimap & Dash) and (ALL fit mode @ 15% screen height). That way, we always interpolate the final boxes, which corrects the odd path that workspaces follow during this transition. Make the WorkspacesView of the primary monitor use these cached boxes when the overview is in the middle of a transition, and the fit modes of the initial and final state differ, to calculate the workspaces positions. Part-of: <https://gitlab.gnome.org/GNOME/gnome-shell/-/merge_requests/1624>
2021-02-02 14:34:59 -05:00
_init(controls, scrollAdjustment, overviewAdjustment) {
super._init({
layout_manager: new Clutter.BinLayout(),
});
workspacesView: Interpolate against relative workspace boxes The overview transition consists of getting the initial and final states of the overview adjustment, derivating various other internal states from them (such as the fit mode, opacities, translations, etc), and finally interpolating the allocation boxes. When interpolating between the fit mode, WorkspacesView uses the current allocation box to derivate the SINGLE and ALL fit mode boxes. However, that creates a curved path during overview transitions. What we really want to do here is calculate the fit mode box relative to the corresponding overview state. For example: +----------------+----------+------------------------+ | Overview State | Fit Mode | Workspaces geometry | +----------------+----------+------------------------+ | HIDDEN | SINGLE | Cover entire screen | | WINDOW PICKER | SINGLE | Between minimap & Dash | | APP GRID | ALL | 15% screen height | +----------------+----------+------------------------+ Using the table above as the reference, when the overview transitions between WINDOW PICKER and APP GRID, we must interpolate between (SINGLE fit mode @ between minimap & Dash) and (ALL fit mode @ 15% screen height). That way, we always interpolate the final boxes, which corrects the odd path that workspaces follow during this transition. Make the WorkspacesView of the primary monitor use these cached boxes when the overview is in the middle of a transition, and the fit modes of the initial and final state differ, to calculate the workspaces positions. Part-of: <https://gitlab.gnome.org/GNOME/gnome-shell/-/merge_requests/1624>
2021-02-02 14:34:59 -05:00
this._controls = controls;
this._overviewAdjustment = overviewAdjustment;
this._fitModeAdjustment = new St.Adjustment({
actor: this,
value: FitMode.SINGLE,
lower: FitMode.SINGLE,
upper: FitMode.ALL,
});
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));
this._swipeTracker = new SwipeTracker.SwipeTracker(
Main.layoutManager.overviewGroup,
Clutter.Orientation.HORIZONTAL,
Shell.ActionMode.OVERVIEW,
{ allowDrag: false });
this._swipeTracker.allowLongSwipes = true;
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._layoutRowsNotifyId = workspaceManager.connect(
'notify::layout-rows', this._updateTrackerOrientation.bind(this));
this._updateTrackerOrientation();
this._windowDragBeginId =
Main.overview.connect('window-drag-begin',
this._windowDragBegin.bind(this));
this._windowDragEndId =
Main.overview.connect('window-drag-end',
this._windowDragEnd.bind(this));
this._primaryVisible = true;
this._primaryIndex = Main.layoutManager.primaryIndex;
this._workspacesViews = [];
this._settings = new Gio.Settings({ schema_id: MUTTER_SCHEMA });
this._restackedNotifyId = 0;
this._scrollEventId = 0;
this._keyPressEventId = 0;
this._inWindowDrag = false;
this._leavingOverview = false;
this._gestureActive = false; // touch(pad) gestures
this.connect('destroy', this._onDestroy.bind(this));
}
_onDestroy() {
if (this._parentSetLater) {
Meta.later_remove(this._parentSetLater);
this._parentSetLater = 0;
}
global.window_manager.disconnect(this._switchWorkspaceId);
global.workspace_manager.disconnect(this._reorderWorkspacesdId);
global.workspace_manager.disconnect(this._layoutRowsNotifyId);
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 &&
!this._leavingOverview;
}
_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,
});
}
_updateTrackerOrientation() {
const { layoutRows } = global.workspace_manager;
this._swipeTracker.orientation = layoutRows !== -1
? Clutter.Orientation.HORIZONTAL
: Clutter.Orientation.VERTICAL;
}
_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');
const distance = global.workspace_manager.layout_rows === -1
? this.height : this.width;
for (let i = 0; i < this._workspacesViews.length; i++)
this._workspacesViews[i].startTouchGesture();
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) {
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);
}
setPrimaryWorkspaceVisible(visible) {
if (this._primaryVisible === visible)
return;
this._primaryVisible = visible;
const primaryIndex = Main.layoutManager.primaryIndex;
const primaryWorkspace = this._workspacesViews[primaryIndex];
if (primaryWorkspace)
primaryWorkspace.visible = visible;
}
prepareToEnterOverview() {
this.show();
this._updateWorkspacesViews();
workspacesView: Only animate on show() when geometries are already set Animating the window clones of the overview requires the fullGeometry and the actualGeometry to be set, which they won't be when showing the overview for the first time. So don't even try to animate the window clones in that case because the geometries will still be null and accessing them in workspace.js will throw errors. The workspace views will still get the correct layout as soon as the allocations happen because syncing the geometries will trigger updating the window positions. Since animations are disabled for position changes when syncing the geometry though, we won't get an animation and the clones will jump into place. That's not a regression though since before this change we also didn't animate in that case because the geometries used were simply wrong (the actualGeometry was 0-sized as explained in the last commit). If we wanted to fix the initial animation of the overview, we'd have to always enable animations of the window clones when syncing geometries, but that would break the animation of the workspace when hovering the workspaceThumbnail slider, because right now those animations are "glued together" using the actualGeometry, so they would get out of sync. The reason there are no errors happening in workspace.js with the existing code is that due to a bug in Clutter the fullGeometry of WorkspacesDisplay gets set very early while mapping the WorkspacesViews (because the overviews ControlsManager gets an allocation during the resource scale calculation of a ClutterClone, see https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1181), so it won't be set to null anymore when calling WorkspacesView.animateToOverview(). https://gitlab.gnome.org/GNOME/gnome-shell/-/merge_requests/1119
2020-05-20 07:39:11 -04:00
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));
}
prepareToLeaveOverview() {
for (let i = 0; i < this._workspacesViews.length; i++)
this._workspacesViews[i].prepareToLeaveOverview();
this._leavingOverview = true;
this._updateSwipeTracker();
}
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 = [];
this._leavingOverview = false;
super.vfunc_hide();
}
_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 (i === this._primaryIndex) {
workspacesView: Interpolate against relative workspace boxes The overview transition consists of getting the initial and final states of the overview adjustment, derivating various other internal states from them (such as the fit mode, opacities, translations, etc), and finally interpolating the allocation boxes. When interpolating between the fit mode, WorkspacesView uses the current allocation box to derivate the SINGLE and ALL fit mode boxes. However, that creates a curved path during overview transitions. What we really want to do here is calculate the fit mode box relative to the corresponding overview state. For example: +----------------+----------+------------------------+ | Overview State | Fit Mode | Workspaces geometry | +----------------+----------+------------------------+ | HIDDEN | SINGLE | Cover entire screen | | WINDOW PICKER | SINGLE | Between minimap & Dash | | APP GRID | ALL | 15% screen height | +----------------+----------+------------------------+ Using the table above as the reference, when the overview transitions between WINDOW PICKER and APP GRID, we must interpolate between (SINGLE fit mode @ between minimap & Dash) and (ALL fit mode @ 15% screen height). That way, we always interpolate the final boxes, which corrects the odd path that workspaces follow during this transition. Make the WorkspacesView of the primary monitor use these cached boxes when the overview is in the middle of a transition, and the fit modes of the initial and final state differ, to calculate the workspaces positions. Part-of: <https://gitlab.gnome.org/GNOME/gnome-shell/-/merge_requests/1624>
2021-02-02 14:34:59 -05:00
view = new WorkspacesView(i,
this._controls,
this._scrollAdjustment,
this._fitModeAdjustment,
this._overviewAdjustment);
view.visible = this._primaryVisible;
this.bind_property('opacity', view, 'opacity', GObject.BindingFlags.SYNC_CREATE);
this.add_child(view);
} else {
view = new SecondaryMonitorDisplay(i,
this._controls,
this._scrollAdjustment,
this._fitModeAdjustment,
this._overviewAdjustment);
Main.layoutManager.overviewGroup.add_actor(view);
}
this._workspacesViews.push(view);
}
}
_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() {
const primaryView = this._getPrimaryView();
return primaryView
? primaryView.getActiveWorkspace().hasMaximizedWindows()
: false;
}
_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;
return Main.wm.handleWorkspaceScroll(event);
}
_onKeyPressEvent(actor, event) {
const { ControlsState } = OverviewControls;
if (this._overviewAdjustment.value !== ControlsState.WINDOW_PICKER)
return Clutter.EVENT_PROPAGATE;
const { workspaceManager } = global;
const vertical = workspaceManager.layout_rows === -1;
const rtl = this.get_text_direction() === Clutter.TextDirection.RTL;
let dir;
switch (event.get_key_symbol()) {
case Clutter.KEY_Page_Up:
if (vertical)
dir = Meta.MotionDirection.UP;
else if (rtl)
dir = Meta.MotionDirection.RIGHT;
else
dir = Meta.MotionDirection.LEFT;
break;
case Clutter.KEY_Page_Down:
if (vertical)
dir = Meta.MotionDirection.DOWN;
else if (rtl)
dir = Meta.MotionDirection.LEFT;
else
dir = Meta.MotionDirection.RIGHT;
break;
default:
return Clutter.EVENT_PROPAGATE;
}
const ws = workspaceManager.get_active_workspace().get_neighbor(dir);
if (ws)
Main.wm.actionMoveWorkspace(ws);
return Clutter.EVENT_STOP;
}
get _workspacesOnlyOnPrimary() {
return this._settings.get_boolean('workspaces-only-on-primary');
}
get fitModeAdjustment() {
return this._fitModeAdjustment;
}
});