diff options
Diffstat (limited to 'js/ui/workspace.js')
| -rw-r--r-- | js/ui/workspace.js | 1457 |
1 files changed, 1457 insertions, 0 deletions
diff --git a/js/ui/workspace.js b/js/ui/workspace.js new file mode 100644 index 0000000..bf631a5 --- /dev/null +++ b/js/ui/workspace.js @@ -0,0 +1,1457 @@ +// -*- mode: js; js-indent-level: 4; indent-tabs-mode: nil -*- +/* exported Workspace */ + +const {Clutter, GLib, GObject, Graphene, Meta, Shell, St} = imports.gi; + +const Background = imports.ui.background; +const DND = imports.ui.dnd; +const Main = imports.ui.main; +const OverviewControls = imports.ui.overviewControls; +const Params = imports.misc.params; +const Util = imports.misc.util; +const { WindowPreview } = imports.ui.windowPreview; + +var WINDOW_PREVIEW_MAXIMUM_SCALE = 0.95; + +var WINDOW_REPOSITIONING_DELAY = 750; + +// When calculating a layout, we calculate the scale of windows and the percent +// of the available area the new layout uses. If the values for the new layout, +// when weighted with the values as below, are worse than the previous layout's, +// we stop looking for a new layout and use the previous layout. +// Otherwise, we keep looking for a new layout. +var LAYOUT_SCALE_WEIGHT = 1; +var LAYOUT_SPACE_WEIGHT = 0.1; + +const BACKGROUND_CORNER_RADIUS_PIXELS = 30; + +// Window Thumbnail Layout Algorithm +// ================================= +// +// General overview +// ---------------- +// +// The window thumbnail layout algorithm calculates some optimal layout +// by computing layouts with some number of rows, calculating how good +// each layout is, and stopping iterating when it finds one that is worse +// than the previous layout. A layout consists of which windows are in +// which rows, row sizes and other general state tracking that would make +// calculating window positions from this information fairly easy. +// +// After a layout is computed that's considered the best layout, we +// compute the layout scale to fit it in the area, and then compute +// slots (sizes and positions) for each thumbnail. +// +// Layout generation +// ----------------- +// +// Layout generation is naive and simple: we simply add windows to a row +// until we've added too many windows to a row, and then make a new row, +// until we have our required N rows. The potential issue with this strategy +// is that we may have too many windows at the bottom in some pathological +// cases, which tends to make the thumbnails have the shape of a pile of +// sand with a peak, with one window at the top. +// +// Scaling factors +// --------------- +// +// Thumbnail position is mostly straightforward -- the main issue is +// computing an optimal scale for each window that fits the constraints, +// and doesn't make the thumbnail too small to see. There are two factors +// involved in thumbnail scale to make sure that these two goals are met: +// the window scale (calculated by _computeWindowScale) and the layout +// scale (calculated by computeSizeAndScale). +// +// The calculation logic becomes slightly more complicated because row +// and column spacing are not scaled, they're constant, so we can't +// simply generate a bunch of window positions and then scale it. In +// practice, it's not too bad -- we can simply try to fit the layout +// in the input area minus whatever spacing we have, and then add +// it back afterwards. +// +// The window scale is constant for the window's size regardless of the +// input area or the layout scale or rows or anything else, and right +// now just enlarges the window if it's too small. The fact that this +// factor is stable makes it easy to calculate, so there's no sense +// in not applying it in most calculations. +// +// The layout scale depends on the input area, the rows, etc, but is the +// same for the entire layout, rather than being per-window. After +// generating the rows of windows, we basically do some basic math to +// fit the full, unscaled layout to the input area, as described above. +// +// With these two factors combined, the final scale of each thumbnail is +// simply windowScale * layoutScale... almost. +// +// There's one additional constraint: the thumbnail scale must never be +// larger than WINDOW_PREVIEW_MAXIMUM_SCALE, which means that the inequality: +// +// windowScale * layoutScale <= WINDOW_PREVIEW_MAXIMUM_SCALE +// +// must always be true. This is for each individual window -- while we +// could adjust layoutScale to make the largest thumbnail smaller than +// WINDOW_PREVIEW_MAXIMUM_SCALE, it would shrink windows which are already +// under the inequality. To solve this, we simply cheat: we simply keep +// each window's "cell" area to be the same, but we shrink the thumbnail +// and center it horizontally, and align it to the bottom vertically. + +var LayoutStrategy = class { + constructor(params) { + params = Params.parse(params, { + monitor: null, + rowSpacing: 0, + columnSpacing: 0, + }); + + if (!params.monitor) + throw new Error(`No monitor param passed to ${this.constructor.name}`); + + this._monitor = params.monitor; + this._rowSpacing = params.rowSpacing; + this._columnSpacing = params.columnSpacing; + } + + // Compute a strategy-specific overall layout given a list of WindowPreviews + // @windows and the strategy-specific @layoutParams. + // + // Returns a strategy-specific layout object that is opaque to the user. + computeLayout(_windows, _layoutParams) { + throw new GObject.NotImplementedError(`computeLayout in ${this.constructor.name}`); + } + + // Given @layout and @area, compute the overall scale of the layout and + // space occupied by the layout. + // + // This method returns an array where the first element is the scale and + // the second element is the space. + // + // This method must be called before calling computeWindowSlots(), as it + // sets the fixed overall scale of the layout. + computeScaleAndSpace(_layout, _area) { + throw new GObject.NotImplementedError(`computeScaleAndSpace in ${this.constructor.name}`); + } + + // Returns an array with final position and size information for each + // window of the layout, given a bounding area that it will be inside of. + computeWindowSlots(_layout, _area) { + throw new GObject.NotImplementedError(`computeWindowSlots in ${this.constructor.name}`); + } +}; + +var UnalignedLayoutStrategy = class extends LayoutStrategy { + _newRow() { + // Row properties: + // + // * x, y are the position of row, relative to area + // + // * width, height are the scaled versions of fullWidth, fullHeight + // + // * width also has the spacing in between windows. It's not in + // fullWidth, as the spacing is constant, whereas fullWidth is + // meant to be scaled + // + // * neither height/fullHeight have any sort of spacing or padding + return { + x: 0, y: 0, + width: 0, height: 0, + fullWidth: 0, fullHeight: 0, + windows: [], + }; + } + + // Computes and returns an individual scaling factor for @window, + // to be applied in addition to the overall layout scale. + _computeWindowScale(window) { + // Since we align windows next to each other, the height of the + // thumbnails is much more important to preserve than the width of + // them, so two windows with equal height, but maybe differering + // widths line up. + let ratio = window.boundingBox.height / this._monitor.height; + + // The purpose of this manipulation here is to prevent windows + // from getting too small. For something like a calculator window, + // we need to bump up the size just a bit to make sure it looks + // good. We'll use a multiplier of 1.5 for this. + + // Map from [0, 1] to [1.5, 1] + return Util.lerp(1.5, 1, ratio); + } + + _computeRowSizes(layout) { + let { rows, scale } = layout; + for (let i = 0; i < rows.length; i++) { + let row = rows[i]; + row.width = row.fullWidth * scale + (row.windows.length - 1) * this._columnSpacing; + row.height = row.fullHeight * scale; + } + } + + _keepSameRow(row, window, width, idealRowWidth) { + if (row.fullWidth + width <= idealRowWidth) + return true; + + let oldRatio = row.fullWidth / idealRowWidth; + let newRatio = (row.fullWidth + width) / idealRowWidth; + + if (Math.abs(1 - newRatio) < Math.abs(1 - oldRatio)) + return true; + + return false; + } + + _sortRow(row) { + // Sort windows horizontally to minimize travel distance. + // This affects in what order the windows end up in a row. + row.windows.sort((a, b) => a.windowCenter.x - b.windowCenter.x); + } + + computeLayout(windows, layoutParams) { + layoutParams = Params.parse(layoutParams, { + numRows: 0, + }); + + if (layoutParams.numRows === 0) + throw new Error(`${this.constructor.name}: No numRows given in layout params`); + + const numRows = layoutParams.numRows; + + let rows = []; + let totalWidth = 0; + for (let i = 0; i < windows.length; i++) { + let window = windows[i]; + let s = this._computeWindowScale(window); + totalWidth += window.boundingBox.width * s; + } + + let idealRowWidth = totalWidth / numRows; + + // Sort windows vertically to minimize travel distance. + // This affects what rows the windows get placed in. + let sortedWindows = windows.slice(); + sortedWindows.sort((a, b) => a.windowCenter.y - b.windowCenter.y); + + let windowIdx = 0; + for (let i = 0; i < numRows; i++) { + let row = this._newRow(); + rows.push(row); + + for (; windowIdx < sortedWindows.length; windowIdx++) { + let window = sortedWindows[windowIdx]; + let s = this._computeWindowScale(window); + let width = window.boundingBox.width * s; + let height = window.boundingBox.height * s; + row.fullHeight = Math.max(row.fullHeight, height); + + // either new width is < idealWidth or new width is nearer from idealWidth then oldWidth + if (this._keepSameRow(row, window, width, idealRowWidth) || (i === numRows - 1)) { + row.windows.push(window); + row.fullWidth += width; + } else { + break; + } + } + } + + let gridHeight = 0; + let maxRow; + for (let i = 0; i < numRows; i++) { + let row = rows[i]; + this._sortRow(row); + + if (!maxRow || row.fullWidth > maxRow.fullWidth) + maxRow = row; + gridHeight += row.fullHeight; + } + + return { + numRows, + rows, + maxColumns: maxRow.windows.length, + gridWidth: maxRow.fullWidth, + gridHeight, + }; + } + + computeScaleAndSpace(layout, area) { + let hspacing = (layout.maxColumns - 1) * this._columnSpacing; + let vspacing = (layout.numRows - 1) * this._rowSpacing; + + let spacedWidth = area.width - hspacing; + let spacedHeight = area.height - vspacing; + + let horizontalScale = spacedWidth / layout.gridWidth; + let verticalScale = spacedHeight / layout.gridHeight; + + // Thumbnails should be less than 70% of the original size + let scale = Math.min( + horizontalScale, verticalScale, WINDOW_PREVIEW_MAXIMUM_SCALE); + + let scaledLayoutWidth = layout.gridWidth * scale + hspacing; + let scaledLayoutHeight = layout.gridHeight * scale + vspacing; + let space = (scaledLayoutWidth * scaledLayoutHeight) / (area.width * area.height); + + layout.scale = scale; + + return [scale, space]; + } + + computeWindowSlots(layout, area) { + this._computeRowSizes(layout); + + let { rows, scale } = layout; + + let slots = []; + + // Do this in three parts. + let heightWithoutSpacing = 0; + for (let i = 0; i < rows.length; i++) { + let row = rows[i]; + heightWithoutSpacing += row.height; + } + + let verticalSpacing = (rows.length - 1) * this._rowSpacing; + let additionalVerticalScale = Math.min(1, (area.height - verticalSpacing) / heightWithoutSpacing); + + // keep track how much smaller the grid becomes due to scaling + // so it can be centered again + let compensation = 0; + let y = 0; + + for (let i = 0; i < rows.length; i++) { + let row = rows[i]; + + // If this window layout row doesn't fit in the actual + // geometry, then apply an additional scale to it. + let horizontalSpacing = (row.windows.length - 1) * this._columnSpacing; + let widthWithoutSpacing = row.width - horizontalSpacing; + let additionalHorizontalScale = Math.min(1, (area.width - horizontalSpacing) / widthWithoutSpacing); + + if (additionalHorizontalScale < additionalVerticalScale) { + row.additionalScale = additionalHorizontalScale; + // Only consider the scaling in addition to the vertical scaling for centering. + compensation += (additionalVerticalScale - additionalHorizontalScale) * row.height; + } else { + row.additionalScale = additionalVerticalScale; + // No compensation when scaling vertically since centering based on a too large + // height would undo what vertical scaling is trying to achieve. + } + + row.x = area.x + (Math.max(area.width - (widthWithoutSpacing * row.additionalScale + horizontalSpacing), 0) / 2); + row.y = area.y + (Math.max(area.height - (heightWithoutSpacing + verticalSpacing), 0) / 2) + y; + y += row.height * row.additionalScale + this._rowSpacing; + } + + compensation /= 2; + + for (let i = 0; i < rows.length; i++) { + const row = rows[i]; + const rowY = row.y + compensation; + const rowHeight = row.height * row.additionalScale; + + let x = row.x; + for (let j = 0; j < row.windows.length; j++) { + let window = row.windows[j]; + + let s = scale * this._computeWindowScale(window) * row.additionalScale; + let cellWidth = window.boundingBox.width * s; + let cellHeight = window.boundingBox.height * s; + + s = Math.min(s, WINDOW_PREVIEW_MAXIMUM_SCALE); + let cloneWidth = window.boundingBox.width * s; + const cloneHeight = window.boundingBox.height * s; + + let cloneX = x + (cellWidth - cloneWidth) / 2; + let cloneY; + + // If there's only one row, align windows vertically centered inside the row + if (rows.length === 1) + cloneY = rowY + (rowHeight - cloneHeight) / 2; + // If there are multiple rows, align windows to the bottom edge of the row + else + cloneY = rowY + rowHeight - cellHeight; + + // Align with the pixel grid to prevent blurry windows at scale = 1 + cloneX = Math.floor(cloneX); + cloneY = Math.floor(cloneY); + + slots.push([cloneX, cloneY, cloneWidth, cloneHeight, window]); + x += cellWidth + this._columnSpacing; + } + } + return slots; + } +}; + +function animateAllocation(actor, box) { + actor.save_easing_state(); + actor.set_easing_mode(Clutter.AnimationMode.EASE_OUT_QUAD); + actor.set_easing_duration(200); + + actor.allocate(box); + + actor.restore_easing_state(); + + return actor.get_transition('allocation'); +} + +var WorkspaceLayout = GObject.registerClass({ + Properties: { + 'spacing': GObject.ParamSpec.double( + 'spacing', 'Spacing', 'Spacing', + GObject.ParamFlags.READWRITE, + 0, Infinity, 20), + 'layout-frozen': GObject.ParamSpec.boolean( + 'layout-frozen', 'Layout frozen', 'Layout frozen', + GObject.ParamFlags.READWRITE, + false), + }, +}, class WorkspaceLayout extends Clutter.LayoutManager { + _init(metaWorkspace, monitorIndex, overviewAdjustment) { + super._init(); + + this._spacing = 20; + this._layoutFrozen = false; + + this._metaWorkspace = metaWorkspace; + this._monitorIndex = monitorIndex; + this._overviewAdjustment = overviewAdjustment; + + this._container = null; + this._windows = new Map(); + this._sortedWindows = []; + this._lastBox = null; + this._windowSlots = []; + this._layout = null; + + this._needsLayout = true; + + this._stateAdjustment = new St.Adjustment({ + value: 0, + lower: 0, + upper: 1, + }); + + this._stateAdjustment.connect('notify::value', () => { + this._syncOpacities(); + this.syncOverlays(); + this.layout_changed(); + }); + + this._workarea = null; + this._workareasChangedId = 0; + } + + _syncOpacity(actor, metaWindow) { + if (!metaWindow.showing_on_its_workspace()) + actor.opacity = this._stateAdjustment.value * 255; + } + + _syncOpacities() { + this._windows.forEach(({ metaWindow }, actor) => { + this._syncOpacity(actor, metaWindow); + }); + } + + _isBetterScaleAndSpace(oldScale, oldSpace, scale, space) { + let spacePower = (space - oldSpace) * LAYOUT_SPACE_WEIGHT; + let scalePower = (scale - oldScale) * LAYOUT_SCALE_WEIGHT; + + if (scale > oldScale && space > oldSpace) { + // Win win -- better scale and better space + return true; + } else if (scale > oldScale && space <= oldSpace) { + // Keep new layout only if scale gain outweighs aspect space loss + return scalePower > spacePower; + } else if (scale <= oldScale && space > oldSpace) { + // Keep new layout only if aspect space gain outweighs scale loss + return spacePower > scalePower; + } else { + // Lose -- worse scale and space + return false; + } + } + + _adjustSpacingAndPadding(rowSpacing, colSpacing, containerBox) { + if (this._sortedWindows.length === 0) + return [rowSpacing, colSpacing, containerBox]; + + // All of the overlays have the same chrome sizes, + // so just pick the first one. + const window = this._sortedWindows[0]; + + const [topOversize, bottomOversize] = window.chromeHeights(); + const [leftOversize, rightOversize] = window.chromeWidths(); + + const oversize = + Math.max(topOversize, bottomOversize, leftOversize, rightOversize); + + if (rowSpacing !== null) + rowSpacing += oversize; + if (colSpacing !== null) + colSpacing += oversize; + + if (containerBox) { + const monitor = Main.layoutManager.monitors[this._monitorIndex]; + + const bottomPoint = new Graphene.Point3D({ y: containerBox.y2 }); + const transformedBottomPoint = + this._container.apply_transform_to_point(bottomPoint); + const bottomFreeSpace = + (monitor.y + monitor.height) - transformedBottomPoint.y; + + const [, bottomOverlap] = window.overlapHeights(); + + if ((bottomOverlap + oversize) > bottomFreeSpace) + containerBox.y2 -= (bottomOverlap + oversize) - bottomFreeSpace; + } + + return [rowSpacing, colSpacing, containerBox]; + } + + _createBestLayout(area) { + const [rowSpacing, columnSpacing] = + this._adjustSpacingAndPadding(this._spacing, this._spacing, null); + + // We look for the largest scale that allows us to fit the + // largest row/tallest column on the workspace. + this._layoutStrategy = new UnalignedLayoutStrategy({ + monitor: Main.layoutManager.monitors[this._monitorIndex], + rowSpacing, + columnSpacing, + }); + + let lastLayout = null; + let lastNumColumns = -1; + let lastScale = 0; + let lastSpace = 0; + + for (let numRows = 1; ; numRows++) { + const numColumns = Math.ceil(this._sortedWindows.length / numRows); + + // If adding a new row does not change column count just stop + // (for instance: 9 windows, with 3 rows -> 3 columns, 4 rows -> + // 3 columns as well => just use 3 rows then) + if (numColumns === lastNumColumns) + break; + + const layout = this._layoutStrategy.computeLayout(this._sortedWindows, { + numRows, + }); + + const [scale, space] = this._layoutStrategy.computeScaleAndSpace(layout, area); + + if (lastLayout && !this._isBetterScaleAndSpace(lastScale, lastSpace, scale, space)) + break; + + lastLayout = layout; + lastNumColumns = numColumns; + lastScale = scale; + lastSpace = space; + } + + return lastLayout; + } + + _getWindowSlots(containerBox) { + [, , containerBox] = + this._adjustSpacingAndPadding(null, null, containerBox); + + const availArea = { + x: parseInt(containerBox.x1), + y: parseInt(containerBox.y1), + width: parseInt(containerBox.get_width()), + height: parseInt(containerBox.get_height()), + }; + + return this._layoutStrategy.computeWindowSlots(this._layout, availArea); + } + + _getAdjustedWorkarea(container) { + const workarea = this._workarea.copy(); + + if (container instanceof St.Widget) { + const themeNode = container.get_theme_node(); + workarea.width -= themeNode.get_horizontal_padding(); + workarea.height -= themeNode.get_vertical_padding(); + } + + return workarea; + } + + _syncWorkareaTracking() { + if (this._container) { + if (this._workAreaChangedId) + return; + this._workarea = Main.layoutManager.getWorkAreaForMonitor(this._monitorIndex); + this._workareasChangedId = + global.display.connect('workareas-changed', () => { + this._workarea = Main.layoutManager.getWorkAreaForMonitor(this._monitorIndex); + this.layout_changed(); + }); + } else if (this._workareasChangedId) { + global.display.disconnect(this._workareasChangedId); + this._workareasChangedId = 0; + } + } + + vfunc_set_container(container) { + this._container = container; + this._syncWorkareaTracking(); + this._stateAdjustment.actor = container; + } + + vfunc_get_preferred_width(container, forHeight) { + const workarea = this._getAdjustedWorkarea(container); + if (forHeight === -1) + return [0, workarea.width]; + + const workAreaAspectRatio = workarea.width / workarea.height; + const widthPreservingAspectRatio = forHeight * workAreaAspectRatio; + + return [0, widthPreservingAspectRatio]; + } + + vfunc_get_preferred_height(container, forWidth) { + const workarea = this._getAdjustedWorkarea(container); + if (forWidth === -1) + return [0, workarea.height]; + + const workAreaAspectRatio = workarea.width / workarea.height; + const heightPreservingAspectRatio = forWidth / workAreaAspectRatio; + + return [0, heightPreservingAspectRatio]; + } + + vfunc_allocate(container, box) { + const containerBox = container.allocation; + const [containerWidth, containerHeight] = containerBox.get_size(); + const containerAllocationChanged = + this._lastBox === null || !this._lastBox.equal(containerBox); + + // If the containers size changed, we can no longer keep around + // the old windowSlots, so we must unfreeze the layout. + // + // However, if the overview animation is in progress, don't unfreeze + // the layout. This is needed to prevent windows "snapping" to their + // new positions during the overview closing animation when the + // allocation subtly expands every frame. + if (this._layoutFrozen && containerAllocationChanged && !Main.overview.animationInProgress) { + this._layoutFrozen = false; + this.notify('layout-frozen'); + } + + const { ControlsState } = OverviewControls; + const { currentState } = + this._overviewAdjustment.getStateTransitionParams(); + const inSessionTransition = currentState <= ControlsState.WINDOW_PICKER; + + const window = this._sortedWindows[0]; + + if (inSessionTransition || !window) { + container.remove_clip(); + } else { + const [, bottomOversize] = window.chromeHeights(); + const [containerX, containerY] = containerBox.get_origin(); + + const extraHeightProgress = + currentState - OverviewControls.ControlsState.WINDOW_PICKER; + + const extraClipHeight = bottomOversize * (1 - extraHeightProgress); + + container.set_clip(containerX, containerY, + containerWidth, containerHeight + extraClipHeight); + } + + let layoutChanged = false; + if (!this._layoutFrozen || !this._lastBox) { + if (this._needsLayout) { + this._layout = this._createBestLayout(this._workarea); + this._needsLayout = false; + layoutChanged = true; + } + + if (layoutChanged || containerAllocationChanged) { + this._windowSlotsBox = box.copy(); + this._windowSlots = this._getWindowSlots(this._windowSlotsBox); + } + } + + const slotsScale = box.get_width() / this._windowSlotsBox.get_width(); + const workareaX = this._workarea.x; + const workareaY = this._workarea.y; + const workareaWidth = this._workarea.width; + const stateAdjustementValue = this._stateAdjustment.value; + + const allocationScale = containerWidth / workareaWidth; + + const childBox = new Clutter.ActorBox(); + + const nSlots = this._windowSlots.length; + for (let i = 0; i < nSlots; i++) { + let [x, y, width, height, child] = this._windowSlots[i]; + if (!child.visible) + continue; + + x *= slotsScale; + y *= slotsScale; + width *= slotsScale; + height *= slotsScale; + + const windowInfo = this._windows.get(child); + + let workspaceBoxX, workspaceBoxY; + let workspaceBoxWidth, workspaceBoxHeight; + + if (windowInfo.metaWindow.showing_on_its_workspace()) { + workspaceBoxX = (child.boundingBox.x - workareaX) * allocationScale; + workspaceBoxY = (child.boundingBox.y - workareaY) * allocationScale; + workspaceBoxWidth = child.boundingBox.width * allocationScale; + workspaceBoxHeight = child.boundingBox.height * allocationScale; + } else { + workspaceBoxX = workareaX * allocationScale; + workspaceBoxY = workareaY * allocationScale; + workspaceBoxWidth = 0; + workspaceBoxHeight = 0; + } + + // Don't allow the scaled floating size to drop below + // the target layout size. + // We only want to apply this when the scaled floating size is + // actually larger than the target layout size, that is while + // animating between the session and the window picker. + if (inSessionTransition) { + workspaceBoxWidth = Math.max(workspaceBoxWidth, width); + workspaceBoxHeight = Math.max(workspaceBoxHeight, height); + } + + x = Util.lerp(workspaceBoxX, x, stateAdjustementValue); + y = Util.lerp(workspaceBoxY, y, stateAdjustementValue); + width = Util.lerp(workspaceBoxWidth, width, stateAdjustementValue); + height = Util.lerp(workspaceBoxHeight, height, stateAdjustementValue); + + childBox.set_origin(x, y); + childBox.set_size(width, height); + + if (windowInfo.currentTransition) { + windowInfo.currentTransition.get_interval().set_final(childBox); + + // The timeline of the transition might not have been updated + // before this allocation cycle, so make sure the child + // still updates needs_allocation to FALSE. + // Unfortunately, this relies on the fast paths in + // clutter_actor_allocate(), otherwise we'd start a new + // transition on the child, replacing the current one. + child.allocate(child.allocation); + continue; + } + + // We want layout changes (ie. larger changes to the layout like + // reshuffling the window order) to be animated, but small changes + // like changes to the container size to happen immediately (for + // example if the container height is being animated, we want to + // avoid animating the children allocations to make sure they + // don't "lag behind" the other animation). + if (layoutChanged && !Main.overview.animationInProgress) { + const transition = animateAllocation(child, childBox); + if (transition) { + windowInfo.currentTransition = transition; + windowInfo.currentTransition.connect('stopped', () => { + windowInfo.currentTransition = null; + }); + } + } else { + child.allocate(childBox); + } + } + + this._lastBox = containerBox.copy(); + } + + _syncOverlay(preview) { + const active = this._metaWorkspace?.active ?? true; + preview.overlayEnabled = active && this._stateAdjustment.value === 1; + } + + /** + * syncOverlays: + * + * Synchronizes the overlay state of all window previews. + */ + syncOverlays() { + [...this._windows.keys()].forEach(preview => this._syncOverlay(preview)); + } + + /** + * addWindow: + * @param {WindowPreview} window: the window to add + * @param {Meta.Window} metaWindow: the MetaWindow of the window + * + * Adds @window to the workspace, it will be shown immediately if + * the layout isn't frozen using the layout-frozen property. + * + * If @window is already part of the workspace, nothing will happen. + */ + addWindow(window, metaWindow) { + if (this._windows.has(window)) + return; + + this._windows.set(window, { + metaWindow, + sizeChangedId: metaWindow.connect('size-changed', () => { + this._needsLayout = true; + this.layout_changed(); + }), + destroyId: window.connect('destroy', () => + this.removeWindow(window)), + currentTransition: null, + }); + + this._sortedWindows.push(window); + this._sortedWindows.sort((a, b) => { + const winA = this._windows.get(a).metaWindow; + const winB = this._windows.get(b).metaWindow; + + return winA.get_stable_sequence() - winB.get_stable_sequence(); + }); + + this._syncOpacity(window, metaWindow); + this._syncOverlay(window); + this._container.add_child(window); + + this._needsLayout = true; + this.layout_changed(); + } + + /** + * removeWindow: + * @param {WindowPreview} window: the window to remove + * + * Removes @window from the workspace if @window is a part of the + * workspace. If the layout-frozen property is set to true, the + * window will still be visible until the property is set to false. + */ + removeWindow(window) { + const windowInfo = this._windows.get(window); + if (!windowInfo) + return; + + windowInfo.metaWindow.disconnect(windowInfo.sizeChangedId); + window.disconnect(windowInfo.destroyId); + if (windowInfo.currentTransition) + window.remove_transition('allocation'); + + this._windows.delete(window); + this._sortedWindows.splice(this._sortedWindows.indexOf(window), 1); + + // The layout might be frozen and we might not update the windowSlots + // on the next allocation, so remove the slot now already + const index = this._windowSlots.findIndex(s => s[4] === window); + if (index !== -1) + this._windowSlots.splice(index, 1); + + // The window might have been reparented by DND + if (window.get_parent() === this._container) + this._container.remove_child(window); + + this._needsLayout = true; + this.layout_changed(); + } + + syncStacking(stackIndices) { + const windows = [...this._windows.keys()]; + windows.sort((a, b) => { + const seqA = this._windows.get(a).metaWindow.get_stable_sequence(); + const seqB = this._windows.get(b).metaWindow.get_stable_sequence(); + + return stackIndices[seqA] - stackIndices[seqB]; + }); + + let lastWindow = null; + for (const window of windows) { + window.setStackAbove(lastWindow); + lastWindow = window; + } + + this._needsLayout = true; + this.layout_changed(); + } + + /** + * getFocusChain: + * + * Gets the focus chain of the workspace. This function will return + * an empty array if the floating window layout is used. + * + * @returns {Array} an array of {Clutter.Actor}s + */ + getFocusChain() { + if (this._stateAdjustment.value === 0) + return []; + + // The fifth element in the slot array is the WindowPreview + return this._windowSlots.map(s => s[4]); + } + + /** + * An StAdjustment for controlling and transitioning between + * the alignment of windows using the layout strategy and the + * floating window layout. + * + * A value of 0 of the adjustment completely uses the floating + * window layout while a value of 1 completely aligns windows using + * the layout strategy. + * + * @type {St.Adjustment} + */ + get stateAdjustment() { + return this._stateAdjustment; + } + + get spacing() { + return this._spacing; + } + + set spacing(s) { + if (this._spacing === s) + return; + + this._spacing = s; + + this._needsLayout = true; + this.notify('spacing'); + this.layout_changed(); + } + + get layoutFrozen() { + return this._layoutFrozen; + } + + set layoutFrozen(f) { + if (this._layoutFrozen === f) + return; + + this._layoutFrozen = f; + + this.notify('layout-frozen'); + if (!this._layoutFrozen) + this.layout_changed(); + } +}); + +var WorkspaceBackground = GObject.registerClass( +class WorkspaceBackground extends Shell.WorkspaceBackground { + _init(monitorIndex, stateAdjustment) { + super._init({ + style_class: 'workspace-background', + x_expand: true, + y_expand: true, + monitor_index: monitorIndex, + }); + + this._monitorIndex = monitorIndex; + this._workarea = Main.layoutManager.getWorkAreaForMonitor(monitorIndex); + + this._stateAdjustment = stateAdjustment; + this._stateAdjustment.connectObject('notify::value', () => { + this._updateBorderRadius(); + this.queue_relayout(); + }, this); + this._stateAdjustment.bind_property( + 'value', this, 'state-adjustment-value', + GObject.BindingFlags.SYNC_CREATE + ); + + this._bin = new Clutter.Actor({ + layout_manager: new Clutter.BinLayout(), + clip_to_allocation: true, + }); + + this._backgroundGroup = new Meta.BackgroundGroup({ + layout_manager: new Clutter.BinLayout(), + x_expand: true, + y_expand: true, + }); + this._bin.add_child(this._backgroundGroup); + this.add_child(this._bin); + + this._bgManager = new Background.BackgroundManager({ + container: this._backgroundGroup, + monitorIndex: this._monitorIndex, + controlPosition: false, + useContentSize: false, + }); + + this._bgManager.connect('changed', () => { + this._updateRoundedClipBounds(); + this._updateBorderRadius(); + }); + + global.display.connectObject('workareas-changed', () => { + this._workarea = Main.layoutManager.getWorkAreaForMonitor(monitorIndex); + this._updateRoundedClipBounds(); + this.queue_relayout(); + }, this); + this._updateRoundedClipBounds(); + + this._updateBorderRadius(); + + this.connect('destroy', this._onDestroy.bind(this)); + } + + _updateBorderRadius() { + const { scaleFactor } = St.ThemeContext.get_for_stage(global.stage); + const cornerRadius = scaleFactor * BACKGROUND_CORNER_RADIUS_PIXELS; + + const backgroundContent = this._bgManager.backgroundActor.content; + backgroundContent.rounded_clip_radius = + Util.lerp(0, cornerRadius, this._stateAdjustment.value); + } + + _updateRoundedClipBounds() { + const monitor = Main.layoutManager.monitors[this._monitorIndex]; + + const rect = new Graphene.Rect(); + rect.origin.x = this._workarea.x - monitor.x; + rect.origin.y = this._workarea.y - monitor.y; + rect.size.width = this._workarea.width; + rect.size.height = this._workarea.height; + + this._bgManager.backgroundActor.content.set_rounded_clip_bounds(rect); + } + + _onDestroy() { + if (this._bgManager) { + this._bgManager.destroy(); + this._bgManager = null; + } + } +}); + +/** + * @metaWorkspace: a #Meta.Workspace, or null + */ +var Workspace = GObject.registerClass( +class Workspace extends St.Widget { + _init(metaWorkspace, monitorIndex, overviewAdjustment) { + super._init({ + style_class: 'window-picker', + pivot_point: new Graphene.Point({ x: 0.5, y: 0.5 }), + layout_manager: new Clutter.BinLayout(), + }); + + const layoutManager = new WorkspaceLayout(metaWorkspace, monitorIndex, + overviewAdjustment); + + // Background + this._background = + new WorkspaceBackground(monitorIndex, layoutManager.stateAdjustment); + this.add_child(this._background); + + // Window previews + this._container = new Clutter.Actor({ + reactive: true, + x_expand: true, + y_expand: true, + }); + this._container.layout_manager = layoutManager; + this.add_child(this._container); + + this.metaWorkspace = metaWorkspace; + + this._overviewAdjustment = overviewAdjustment; + + this.monitorIndex = monitorIndex; + this._monitor = Main.layoutManager.monitors[this.monitorIndex]; + + if (monitorIndex != Main.layoutManager.primaryIndex) + this.add_style_class_name('external-monitor'); + + const clickAction = new Clutter.ClickAction(); + clickAction.connect('clicked', action => { + // Switch to the workspace when not the active one, leave the + // overview otherwise. + if (action.get_button() === 1 || action.get_button() === 0) { + const leaveOverview = this._shouldLeaveOverview(); + + this.metaWorkspace?.activate(global.get_current_time()); + if (leaveOverview) + Main.overview.hide(); + } + }); + this.bind_property('mapped', clickAction, 'enabled', GObject.BindingFlags.SYNC_CREATE); + this._container.add_action(clickAction); + + this.connect('style-changed', this._onStyleChanged.bind(this)); + this.connect('destroy', this._onDestroy.bind(this)); + + this._skipTaskbarSignals = new Map(); + const windows = global.get_window_actors().map(a => a.meta_window) + .filter(this._isMyWindow, this); + + // Create clones for windows that should be + // visible in the Overview + this._windows = []; + for (let i = 0; i < windows.length; i++) { + if (this._isOverviewWindow(windows[i])) + this._addWindowClone(windows[i]); + } + + // Track window changes, but let the window tracker process them first + this.metaWorkspace?.connectObject( + 'window-added', this._windowAdded.bind(this), GObject.ConnectFlags.AFTER, + 'window-removed', this._windowRemoved.bind(this), GObject.ConnectFlags.AFTER, + 'notify::active', () => layoutManager.syncOverlays(), this); + global.display.connectObject( + 'window-entered-monitor', this._windowEnteredMonitor.bind(this), GObject.ConnectFlags.AFTER, + 'window-left-monitor', this._windowLeftMonitor.bind(this), GObject.ConnectFlags.AFTER, + this); + this._layoutFrozenId = 0; + + // DND requires this to be set + this._delegate = this; + } + + _shouldLeaveOverview() { + if (!this.metaWorkspace || this.metaWorkspace.active) + return true; + + const overviewState = this._overviewAdjustment.value; + return overviewState > OverviewControls.ControlsState.WINDOW_PICKER; + } + + vfunc_get_focus_chain() { + return this._container.layout_manager.getFocusChain(); + } + + _lookupIndex(metaWindow) { + return this._windows.findIndex(w => w.metaWindow == metaWindow); + } + + containsMetaWindow(metaWindow) { + return this._lookupIndex(metaWindow) >= 0; + } + + isEmpty() { + return this._windows.length == 0; + } + + syncStacking(stackIndices) { + this._container.layout_manager.syncStacking(stackIndices); + } + + _doRemoveWindow(metaWin) { + let clone = this._removeWindowClone(metaWin); + + if (!clone) + return; + + clone.destroy(); + + // We need to reposition the windows; to avoid shuffling windows + // around while the user is interacting with the workspace, we delay + // the positioning until the pointer remains still for at least 750 ms + // or is moved outside the workspace + this._container.layout_manager.layout_frozen = true; + + if (this._layoutFrozenId > 0) { + GLib.source_remove(this._layoutFrozenId); + this._layoutFrozenId = 0; + } + + let [oldX, oldY] = global.get_pointer(); + + this._layoutFrozenId = GLib.timeout_add( + GLib.PRIORITY_DEFAULT, + WINDOW_REPOSITIONING_DELAY, + () => { + const [newX, newY] = global.get_pointer(); + const pointerHasMoved = oldX !== newX || oldY !== newY; + const actorUnderPointer = global.stage.get_actor_at_pos( + Clutter.PickMode.REACTIVE, newX, newY); + + if ((pointerHasMoved && this.contains(actorUnderPointer)) || + this._windows.some(w => w.contains(actorUnderPointer))) { + oldX = newX; + oldY = newY; + return GLib.SOURCE_CONTINUE; + } + + this._container.layout_manager.layout_frozen = false; + this._layoutFrozenId = 0; + return GLib.SOURCE_REMOVE; + }); + + GLib.Source.set_name_by_id(this._layoutFrozenId, + '[gnome-shell] this._layoutFrozenId'); + } + + _doAddWindow(metaWin) { + let win = metaWin.get_compositor_private(); + + if (!win) { + // Newly-created windows are added to a workspace before + // the compositor finds out about them... + let id = GLib.idle_add(GLib.PRIORITY_DEFAULT, () => { + if (metaWin.get_compositor_private() && + metaWin.get_workspace() == this.metaWorkspace) + this._doAddWindow(metaWin); + return GLib.SOURCE_REMOVE; + }); + GLib.Source.set_name_by_id(id, '[gnome-shell] this._doAddWindow'); + return; + } + + // We might have the window in our list already if it was on all workspaces and + // now was moved to this workspace + if (this._lookupIndex(metaWin) != -1) + return; + + if (!this._isMyWindow(metaWin)) + return; + + this._skipTaskbarSignals.set(metaWin, + metaWin.connect('notify::skip-taskbar', () => { + if (metaWin.skip_taskbar) + this._doRemoveWindow(metaWin); + else + this._doAddWindow(metaWin); + })); + + if (!this._isOverviewWindow(metaWin)) { + if (metaWin.get_transient_for() == null) + return; + + // Let the top-most ancestor handle all transients + let parent = metaWin.find_root_ancestor(); + let clone = this._windows.find(c => c.metaWindow == parent); + + // If no clone was found, the parent hasn't been created yet + // and will take care of the dialog when added + if (clone) + clone.addDialog(metaWin); + + return; + } + + const clone = this._addWindowClone(metaWin); + + clone.set_pivot_point(0.5, 0.5); + clone.scale_x = 0; + clone.scale_y = 0; + clone.ease({ + scale_x: 1, + scale_y: 1, + duration: 250, + onStopped: () => clone.set_pivot_point(0, 0), + }); + + if (this._layoutFrozenId > 0) { + // If a window was closed before, unfreeze the layout to ensure + // the new window is immediately shown + this._container.layout_manager.layout_frozen = false; + + GLib.source_remove(this._layoutFrozenId); + this._layoutFrozenId = 0; + } + } + + _windowAdded(metaWorkspace, metaWin) { + if (!Main.overview.closing) + this._doAddWindow(metaWin); + } + + _windowRemoved(metaWorkspace, metaWin) { + this._doRemoveWindow(metaWin); + } + + _windowEnteredMonitor(metaDisplay, monitorIndex, metaWin) { + if (monitorIndex === this.monitorIndex && !Main.overview.closing) + this._doAddWindow(metaWin); + } + + _windowLeftMonitor(metaDisplay, monitorIndex, metaWin) { + if (monitorIndex == this.monitorIndex) + this._doRemoveWindow(metaWin); + } + + // check for maximized windows on the workspace + hasMaximizedWindows() { + for (let i = 0; i < this._windows.length; i++) { + let metaWindow = this._windows[i].metaWindow; + if (metaWindow.showing_on_its_workspace() && + metaWindow.maximized_horizontally && + metaWindow.maximized_vertically) + return true; + } + return false; + } + + _clearSkipTaskbarSignals() { + for (const [metaWin, id] of this._skipTaskbarSignals) + metaWin.disconnect(id); + this._skipTaskbarSignals.clear(); + } + + prepareToLeaveOverview() { + this._clearSkipTaskbarSignals(); + + for (let i = 0; i < this._windows.length; i++) + this._windows[i].remove_all_transitions(); + + if (this._layoutFrozenId > 0) { + GLib.source_remove(this._layoutFrozenId); + this._layoutFrozenId = 0; + } + + this._container.layout_manager.layout_frozen = true; + Main.overview.connectObject( + 'hidden', this._doneLeavingOverview.bind(this), this); + } + + _onDestroy() { + this._clearSkipTaskbarSignals(); + + if (this._layoutFrozenId > 0) { + GLib.source_remove(this._layoutFrozenId); + this._layoutFrozenId = 0; + } + + this._windows = []; + } + + _doneLeavingOverview() { + this._container.layout_manager.layout_frozen = false; + } + + _doneShowingOverview() { + this._container.layout_manager.layout_frozen = false; + } + + _isMyWindow(window) { + const isOnWorkspace = this.metaWorkspace === null || + window.located_on_workspace(this.metaWorkspace); + const isOnMonitor = window.get_monitor() === this.monitorIndex; + + return isOnWorkspace && isOnMonitor; + } + + _isOverviewWindow(window) { + return !window.skip_taskbar; + } + + // Create a clone of a (non-desktop) window and add it to the window list + _addWindowClone(metaWindow) { + let clone = new WindowPreview(metaWindow, this, this._overviewAdjustment); + + clone.connect('selected', + this._onCloneSelected.bind(this)); + clone.connect('drag-begin', () => { + Main.overview.beginWindowDrag(metaWindow); + }); + clone.connect('drag-cancelled', () => { + Main.overview.cancelledWindowDrag(metaWindow); + }); + clone.connect('drag-end', () => { + Main.overview.endWindowDrag(metaWindow); + }); + clone.connect('show-chrome', () => { + let focus = global.stage.key_focus; + if (focus == null || this.contains(focus)) + clone.grab_key_focus(); + + this._windows.forEach(c => { + if (c !== clone) + c.hideOverlay(true); + }); + }); + clone.connect('destroy', () => { + this._doRemoveWindow(metaWindow); + }); + + this._container.layout_manager.addWindow(clone, metaWindow); + + if (this._windows.length == 0) + clone.setStackAbove(null); + else + clone.setStackAbove(this._windows[this._windows.length - 1]); + + this._windows.push(clone); + + return clone; + } + + _removeWindowClone(metaWin) { + // find the position of the window in our list + let index = this._lookupIndex(metaWin); + + if (index == -1) + return null; + + this._container.layout_manager.removeWindow(this._windows[index]); + + return this._windows.splice(index, 1).pop(); + } + + _onStyleChanged() { + const themeNode = this.get_theme_node(); + this._container.layout_manager.spacing = themeNode.get_length('spacing'); + } + + _onCloneSelected(clone, time) { + const wsIndex = this.metaWorkspace?.index(); + + if (this._shouldLeaveOverview()) + Main.activateWindow(clone.metaWindow, time, wsIndex); + else + this.metaWorkspace?.activate(time); + } + + // Draggable target interface + handleDragOver(source, _actor, _x, _y, _time) { + if (source.metaWindow && !this._isMyWindow(source.metaWindow)) + return DND.DragMotionResult.MOVE_DROP; + if (source.app && source.app.can_open_new_window()) + return DND.DragMotionResult.COPY_DROP; + if (!source.app && source.shellWorkspaceLaunch) + return DND.DragMotionResult.COPY_DROP; + + return DND.DragMotionResult.CONTINUE; + } + + acceptDrop(source, actor, x, y, time) { + let workspaceManager = global.workspace_manager; + let workspaceIndex = this.metaWorkspace + ? this.metaWorkspace.index() + : workspaceManager.get_active_workspace_index(); + + if (source.metaWindow) { + const window = source.metaWindow; + if (this._isMyWindow(window)) + return false; + + Main.moveWindowToMonitorAndWorkspace(window, + this.monitorIndex, workspaceIndex); + return true; + } else if (source.app && source.app.can_open_new_window()) { + if (source.animateLaunchAtPos) + source.animateLaunchAtPos(actor.x, actor.y); + + source.app.open_new_window(workspaceIndex); + return true; + } else if (!source.app && source.shellWorkspaceLaunch) { + // While unused in our own drag sources, shellWorkspaceLaunch allows + // extensions to define custom actions for their drag sources. + source.shellWorkspaceLaunch({ + workspace: workspaceIndex, + timestamp: time, + }); + return true; + } + + return false; + } + + get stateAdjustment() { + return this._container.layout_manager.stateAdjustment; + } +}); |