1153 lines
40 KiB
JavaScript
1153 lines
40 KiB
JavaScript
/*
|
|
* This file is part of the Dash-To-Panel extension for Gnome 3
|
|
*
|
|
* This program is free software: you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation, either version 2 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
import GObject from 'gi://GObject';
|
|
import Clutter from 'gi://Clutter';
|
|
import GLib from 'gi://GLib';
|
|
import Graphene from 'gi://Graphene';
|
|
import * as Main from 'resource:///org/gnome/shell/ui/main.js';
|
|
import Meta from 'gi://Meta';
|
|
import * as PopupMenu from 'resource:///org/gnome/shell/ui/popupMenu.js';
|
|
import St from 'gi://St';
|
|
|
|
import * as Taskbar from './taskbar.js';
|
|
import * as Utils from './utils.js';
|
|
import {SETTINGS, DESKTOPSETTINGS} from './extension.js';
|
|
import {gettext as _} from 'resource:///org/gnome/shell/extensions/extension.js';
|
|
|
|
//timeout intervals
|
|
const ENSURE_VISIBLE_MS = 200;
|
|
|
|
//timeout names
|
|
const T1 = 'openMenuTimeout';
|
|
const T2 = 'closeMenuTimeout';
|
|
const T3 = 'peekTimeout';
|
|
const T4 = 'ensureVisibleTimeout';
|
|
|
|
const MAX_TRANSLATION = 40;
|
|
const HEADER_HEIGHT = 38;
|
|
const MAX_CLOSE_BUTTON_SIZE = 30;
|
|
const MIN_DIMENSION = 100;
|
|
const FOCUSED_COLOR_OFFSET = 24;
|
|
const HEADER_COLOR_OFFSET = -12;
|
|
const FADE_SIZE = 36;
|
|
const PEEK_INDEX_PROP = '_dtpPeekInitialIndex';
|
|
|
|
let headerHeight = 0;
|
|
let alphaBg = 0;
|
|
let isLeftButtons = false;
|
|
let isTopHeader = true;
|
|
let isManualStyling = false;
|
|
let scaleFactor = 1;
|
|
let animationTime = 0;
|
|
let aspectRatio = {};
|
|
|
|
export const PreviewMenu = GObject.registerClass({
|
|
Signals: { 'open-state-changed': {} }
|
|
}, class PreviewMenu extends St.Widget {
|
|
|
|
_init(panel) {
|
|
super._init({ layout_manager: new Clutter.BinLayout() });
|
|
|
|
let geom = panel.geom;
|
|
this.panel = panel;
|
|
this.currentAppIcon = null;
|
|
this._focusedPreview = null;
|
|
this._peekedWindow = null;
|
|
this.allowCloseWindow = true;
|
|
this.peekInitialWorkspaceIndex = -1;
|
|
this.opened = false;
|
|
this.isVertical = geom.position == St.Side.LEFT || geom.position == St.Side.RIGHT;
|
|
this._translationProp = 'translation_' + (this.isVertical ? 'x' : 'y');
|
|
this._translationDirection = (geom.position == St.Side.TOP || geom.position == St.Side.LEFT ? -1 : 1);
|
|
this._translationOffset = Math.min(panel.dtpSize, MAX_TRANSLATION) * this._translationDirection;
|
|
|
|
this.menu = new St.Widget({
|
|
name: 'preview-menu',
|
|
layout_manager: new Clutter.BinLayout(),
|
|
reactive: true,
|
|
track_hover: true,
|
|
x_expand: true,
|
|
y_expand: true,
|
|
x_align: Clutter.ActorAlign[geom.position != St.Side.RIGHT ? 'START' : 'END'],
|
|
y_align: Clutter.ActorAlign[geom.position != St.Side.BOTTOM ? 'START' : 'END']
|
|
});
|
|
this._box = new St.BoxLayout({ vertical: this.isVertical });
|
|
this._scrollView = new St.ScrollView({
|
|
name: 'dashtopanelPreviewScrollview',
|
|
hscrollbar_policy: St.PolicyType.NEVER,
|
|
vscrollbar_policy: St.PolicyType.NEVER,
|
|
enable_mouse_scrolling: true,
|
|
y_expand: !this.isVertical
|
|
});
|
|
|
|
this._scrollView.add_actor(this._box);
|
|
this.menu.add_child(this._scrollView);
|
|
this.add_child(this.menu);
|
|
}
|
|
|
|
enable() {
|
|
this._timeoutsHandler = new Utils.TimeoutsHandler();
|
|
this._signalsHandler = new Utils.GlobalSignalsHandler();
|
|
|
|
Main.layoutManager.addChrome(this, { affectsInputRegion: false });
|
|
Main.layoutManager.trackChrome(this.menu, { affectsInputRegion: true });
|
|
|
|
this._resetHiddenState();
|
|
this._refreshGlobals();
|
|
this._updateClip();
|
|
this.menu.set_position(1, 1);
|
|
|
|
this._signalsHandler.add(
|
|
[
|
|
this.menu,
|
|
'notify::hover',
|
|
() => this._onHoverChanged()
|
|
],
|
|
[
|
|
this._scrollView,
|
|
'scroll-event',
|
|
this._onScrollEvent.bind(this)
|
|
],
|
|
[
|
|
this.panel.panelBox,
|
|
'style-changed',
|
|
() => this._updateClip()
|
|
],
|
|
[
|
|
Utils.DisplayWrapper.getScreen(),
|
|
'in-fullscreen-changed',
|
|
() => {
|
|
if (global.display.focus_window && global.display.focus_window.is_fullscreen()) {
|
|
this.close(true);
|
|
}
|
|
}
|
|
],
|
|
[
|
|
SETTINGS,
|
|
[
|
|
'changed::panel-sizes',
|
|
'changed::window-preview-size',
|
|
'changed::window-preview-padding',
|
|
'changed::window-preview-show-title'
|
|
],
|
|
() => {
|
|
this._refreshGlobals();
|
|
this._updateClip();
|
|
}
|
|
]
|
|
);
|
|
}
|
|
|
|
disable() {
|
|
this._timeoutsHandler.destroy();
|
|
this._signalsHandler.destroy();
|
|
|
|
this.close(true);
|
|
|
|
Main.layoutManager.untrackChrome(this.menu);
|
|
Main.layoutManager.removeChrome(this);
|
|
}
|
|
|
|
requestOpen(appIcon) {
|
|
let timeout = SETTINGS.get_int('show-window-previews-timeout');
|
|
|
|
if (this.opened) {
|
|
timeout = Math.min(100, timeout);
|
|
}
|
|
|
|
this._endOpenCloseTimeouts();
|
|
this._timeoutsHandler.add([T1, timeout, () => this.open(appIcon)]);
|
|
}
|
|
|
|
requestClose() {
|
|
this._endOpenCloseTimeouts();
|
|
this._addCloseTimeout();
|
|
}
|
|
|
|
open(appIcon, preventCloseWindow) {
|
|
if (this.currentAppIcon != appIcon) {
|
|
this.currentAppIcon = appIcon;
|
|
this.allowCloseWindow = !preventCloseWindow;
|
|
|
|
if (!this.opened) {
|
|
this._refreshGlobals();
|
|
|
|
this.set_height(this.clipHeight);
|
|
this.menu.show();
|
|
|
|
setStyle(this.menu, 'background: ' + Utils.getrgbaColor(this.panel.dynamicTransparency.backgroundColorRgb, alphaBg));
|
|
}
|
|
|
|
this._mergeWindows(appIcon);
|
|
this._updatePosition();
|
|
this._animateOpenOrClose(true);
|
|
|
|
this._setReactive(true);
|
|
this._setOpenedState(true);
|
|
}
|
|
}
|
|
|
|
close(immediate) {
|
|
this._endOpenCloseTimeouts();
|
|
this._removeFocus();
|
|
this._endPeek();
|
|
|
|
if (immediate) {
|
|
Utils.stopAnimations(this.menu);
|
|
this._resetHiddenState();
|
|
} else {
|
|
this._animateOpenOrClose(false, () => this._resetHiddenState());
|
|
}
|
|
|
|
this._setReactive(false);
|
|
this.currentAppIcon = null;
|
|
}
|
|
|
|
update(appIcon, windows) {
|
|
if (this.currentAppIcon == appIcon) {
|
|
if (windows && !windows.length) {
|
|
this.close();
|
|
} else {
|
|
this._addAndRemoveWindows(windows);
|
|
this._updatePosition();
|
|
}
|
|
}
|
|
}
|
|
|
|
updatePosition() {
|
|
this._updatePosition();
|
|
}
|
|
|
|
focusNext() {
|
|
let previews = this._box.get_children();
|
|
let currentIndex = this._focusedPreview ? previews.indexOf(this._focusedPreview) : -1;
|
|
let nextIndex = currentIndex + 1;
|
|
|
|
nextIndex = previews[nextIndex] ? nextIndex : 0;
|
|
|
|
if (previews[nextIndex]) {
|
|
this._removeFocus();
|
|
previews[nextIndex].setFocus(true);
|
|
this._focusedPreview = previews[nextIndex];
|
|
}
|
|
|
|
return nextIndex;
|
|
}
|
|
|
|
activateFocused() {
|
|
if (this.opened && this._focusedPreview) {
|
|
this._focusedPreview.activate();
|
|
}
|
|
}
|
|
|
|
requestPeek(window) {
|
|
this._timeoutsHandler.remove(T3);
|
|
|
|
if (SETTINGS.get_boolean('peek-mode')) {
|
|
if (this.peekInitialWorkspaceIndex < 0) {
|
|
this._timeoutsHandler.add([T3, SETTINGS.get_int('enter-peek-mode-timeout'), () => this._peek(window)]);
|
|
} else {
|
|
this._peek(window);
|
|
}
|
|
}
|
|
}
|
|
|
|
endPeekHere() {
|
|
this._endPeek(true);
|
|
}
|
|
|
|
ensureVisible(preview) {
|
|
let [ , upper, pageSize] = this._getScrollAdjustmentValues();
|
|
|
|
if (upper > pageSize) {
|
|
this._timeoutsHandler.add([
|
|
T4,
|
|
ENSURE_VISIBLE_MS,
|
|
() => Utils.ensureActorVisibleInScrollView(this._scrollView, preview, MIN_DIMENSION, () => this._updateScrollFade())
|
|
]);
|
|
}
|
|
}
|
|
|
|
getCurrentAppIcon() {
|
|
return this.currentAppIcon;
|
|
}
|
|
|
|
_setReactive(reactive) {
|
|
this._box.get_children().forEach(c => c.reactive = reactive);
|
|
this.menu.reactive = reactive;
|
|
}
|
|
|
|
_setOpenedState(opened) {
|
|
this.opened = opened;
|
|
this.emit('open-state-changed');
|
|
}
|
|
|
|
_resetHiddenState() {
|
|
this.menu.hide();
|
|
this.set_height(0);
|
|
this._setOpenedState(false);
|
|
this.menu.opacity = 0;
|
|
this.menu[this._translationProp] = this._translationOffset;
|
|
this._box.get_children().forEach(c => c.destroy());
|
|
}
|
|
|
|
_removeFocus() {
|
|
if (this._focusedPreview) {
|
|
this._focusedPreview.setFocus(false);
|
|
this._focusedPreview = null;
|
|
}
|
|
}
|
|
|
|
_mergeWindows(appIcon, windows) {
|
|
windows = windows || (appIcon.window ? [appIcon.window] : appIcon.getAppIconInterestingWindows());
|
|
windows.sort(Taskbar.sortWindowsCompareFunction);
|
|
|
|
let currentPreviews = this._box.get_children();
|
|
let l = Math.max(windows.length, currentPreviews.length);
|
|
|
|
for (let i = 0; i < l; ++i) {
|
|
if (currentPreviews[i] && windows[i]) {
|
|
currentPreviews[i].assignWindow(windows[i], this.opened);
|
|
} else if (!currentPreviews[i]) {
|
|
this._addNewPreview(windows[i]);
|
|
} else if (!windows[i]) {
|
|
currentPreviews[i][!this.opened ? 'destroy' : 'animateOut']();
|
|
}
|
|
}
|
|
}
|
|
|
|
_addAndRemoveWindows(windows) {
|
|
let currentPreviews = this._box.get_children();
|
|
|
|
windows.sort(Taskbar.sortWindowsCompareFunction);
|
|
|
|
for (let i = 0, l = windows.length; i < l; ++i) {
|
|
let currentIndex = Utils.findIndex(currentPreviews, c => c.window == windows[i]);
|
|
|
|
if (currentIndex < 0) {
|
|
this._addNewPreview(windows[i]);
|
|
} else {
|
|
currentPreviews[currentIndex].assignWindow(windows[i]);
|
|
currentPreviews.splice(currentIndex, 1);
|
|
|
|
if (this._peekedWindow && this._peekedWindow == windows[i]) {
|
|
this.requestPeek(windows[i]);
|
|
}
|
|
}
|
|
}
|
|
|
|
currentPreviews.forEach(c => c.animateOut());
|
|
}
|
|
|
|
_addNewPreview(window) {
|
|
let preview = new Preview(this);
|
|
|
|
this._box.add_child(preview);
|
|
preview.adjustOnStage();
|
|
preview.assignWindow(window, this.opened);
|
|
}
|
|
|
|
_addCloseTimeout() {
|
|
this._timeoutsHandler.add([T2, SETTINGS.get_int('leave-timeout'), () => this.close()]);
|
|
}
|
|
|
|
_onHoverChanged() {
|
|
this._endOpenCloseTimeouts();
|
|
|
|
if (this.currentAppIcon && !this.menu.hover) {
|
|
this._addCloseTimeout();
|
|
this._endPeek();
|
|
}
|
|
}
|
|
|
|
_onScrollEvent(actor, event) {
|
|
if (!event.is_pointer_emulated()) {
|
|
let vOrh = this.isVertical ? 'v' : 'h';
|
|
let adjustment = this._scrollView['get_' + vOrh + 'scroll_bar']().get_adjustment();
|
|
let increment = adjustment.step_increment;
|
|
let delta = increment;
|
|
|
|
switch (event.get_scroll_direction()) {
|
|
case Clutter.ScrollDirection.UP:
|
|
delta = -increment;
|
|
break;
|
|
case Clutter.ScrollDirection.SMOOTH:
|
|
let [dx, dy] = event.get_scroll_delta();
|
|
delta = dy * increment;
|
|
delta += dx * increment;
|
|
break;
|
|
}
|
|
|
|
adjustment.set_value(adjustment.get_value() + delta);
|
|
this._updateScrollFade();
|
|
}
|
|
|
|
return Clutter.EVENT_STOP;
|
|
}
|
|
|
|
_endOpenCloseTimeouts() {
|
|
this._timeoutsHandler.remove(T1);
|
|
this._timeoutsHandler.remove(T2);
|
|
this._timeoutsHandler.remove(T4);
|
|
}
|
|
|
|
_refreshGlobals() {
|
|
isLeftButtons = Meta.prefs_get_button_layout().left_buttons.indexOf(Meta.ButtonFunction.CLOSE) >= 0;
|
|
isTopHeader = SETTINGS.get_string('window-preview-title-position') == 'TOP';
|
|
isManualStyling = SETTINGS.get_boolean('window-preview-manual-styling');
|
|
scaleFactor = Utils.getScaleFactor();
|
|
headerHeight = SETTINGS.get_boolean('window-preview-show-title') ? HEADER_HEIGHT * scaleFactor : 0;
|
|
animationTime = SETTINGS.get_int('window-preview-animation-time') * .001;
|
|
aspectRatio.x = {
|
|
size: SETTINGS.get_int('window-preview-aspect-ratio-x'),
|
|
fixed: SETTINGS.get_boolean('window-preview-fixed-x')
|
|
};
|
|
aspectRatio.y = {
|
|
size: SETTINGS.get_int('window-preview-aspect-ratio-y'),
|
|
fixed: SETTINGS.get_boolean('window-preview-fixed-y')
|
|
};
|
|
|
|
alphaBg = SETTINGS.get_boolean('preview-use-custom-opacity') ?
|
|
SETTINGS.get_int('preview-custom-opacity') * .01 :
|
|
this.panel.dynamicTransparency.alpha;
|
|
}
|
|
|
|
_updateClip() {
|
|
let x, y, w;
|
|
let geom = this.panel.getGeometry();
|
|
let panelBoxTheme = this.panel.panelBox.get_theme_node();
|
|
let previewSize = (SETTINGS.get_int('window-preview-size') +
|
|
SETTINGS.get_int('window-preview-padding') * 2) * scaleFactor;
|
|
|
|
if (this.isVertical) {
|
|
w = previewSize;
|
|
this.clipHeight = this.panel.monitor.height;
|
|
y = this.panel.monitor.y;
|
|
} else {
|
|
w = this.panel.monitor.width;
|
|
this.clipHeight = (previewSize + headerHeight);
|
|
x = this.panel.monitor.x;
|
|
}
|
|
|
|
if (geom.position == St.Side.LEFT) {
|
|
x = this.panel.monitor.x + this.panel.dtpSize + panelBoxTheme.get_padding(St.Side.LEFT);
|
|
} else if (geom.position == St.Side.RIGHT) {
|
|
x = this.panel.monitor.x + this.panel.monitor.width - (this.panel.dtpSize + previewSize) - panelBoxTheme.get_padding(St.Side.RIGHT);
|
|
} else if (geom.position == St.Side.TOP) {
|
|
y = this.panel.monitor.y + this.panel.dtpSize + panelBoxTheme.get_padding(St.Side.TOP);
|
|
} else { //St.Side.BOTTOM
|
|
y = this.panel.monitor.y + this.panel.monitor.height - (this.panel.dtpSize + panelBoxTheme.get_padding(St.Side.BOTTOM) + previewSize + headerHeight);
|
|
}
|
|
|
|
Utils.setClip(this, x, y, w, this.clipHeight);
|
|
}
|
|
|
|
_updatePosition() {
|
|
let sourceNode = this.currentAppIcon.get_theme_node();
|
|
let sourceContentBox = sourceNode.get_content_box(this.currentAppIcon.get_allocation_box());
|
|
let sourceAllocation = Utils.getTransformedAllocation(this.currentAppIcon);
|
|
let [previewsWidth, previewsHeight] = this._getPreviewsSize();
|
|
let appIconMargin = SETTINGS.get_int('appicon-margin') / scaleFactor;
|
|
let x = 0, y = 0;
|
|
|
|
previewsWidth = Math.min(previewsWidth, this.panel.monitor.width);
|
|
previewsHeight = Math.min(previewsHeight, this.panel.monitor.height);
|
|
this._updateScrollFade(previewsWidth < this.panel.monitor.width && previewsHeight < this.panel.monitor.height);
|
|
|
|
if (this.isVertical) {
|
|
y = sourceAllocation.y1 + appIconMargin - this.panel.monitor.y + (sourceContentBox.y2 - sourceContentBox.y1 - previewsHeight) * .5;
|
|
y = Math.max(y, 0);
|
|
y = Math.min(y, this.panel.monitor.height - previewsHeight);
|
|
} else {
|
|
x = sourceAllocation.x1 + appIconMargin - this.panel.monitor.x + (sourceContentBox.x2 - sourceContentBox.x1 - previewsWidth) * .5;
|
|
x = Math.max(x, 0);
|
|
x = Math.min(x, this.panel.monitor.width - previewsWidth);
|
|
}
|
|
|
|
if (!this.opened) {
|
|
this.menu.set_position(x, y);
|
|
this.menu.set_size(previewsWidth, previewsHeight);
|
|
} else {
|
|
Utils.animate(this.menu, getTweenOpts({ x: x, y: y, width: previewsWidth, height: previewsHeight }));
|
|
}
|
|
}
|
|
|
|
_updateScrollFade(remove) {
|
|
let [value, upper, pageSize] = this._getScrollAdjustmentValues();
|
|
let needsFade = Math.round(upper) > Math.round(pageSize);
|
|
let fadeWidgets = this.menu.get_children().filter(c => c != this._scrollView);
|
|
|
|
if (!remove && needsFade) {
|
|
if (!fadeWidgets.length) {
|
|
fadeWidgets.push(this._getFadeWidget());
|
|
fadeWidgets.push(this._getFadeWidget(true));
|
|
|
|
this.menu.add_child(fadeWidgets[0]);
|
|
this.menu.add_child(fadeWidgets[1]);
|
|
}
|
|
|
|
fadeWidgets[0].visible = value > 0;
|
|
fadeWidgets[1].visible = value + pageSize < upper;
|
|
} else if (remove || (!needsFade && fadeWidgets.length)) {
|
|
fadeWidgets.forEach(fw => fw.destroy());
|
|
}
|
|
}
|
|
|
|
_getScrollAdjustmentValues() {
|
|
let [value , , upper, , , pageSize] = this._scrollView[(this.isVertical ? 'v' : 'h') + 'scroll'].adjustment.get_values();
|
|
|
|
return [value, upper, pageSize];
|
|
}
|
|
|
|
_getFadeWidget(end) {
|
|
let x = 0, y = 0;
|
|
let startBg = Utils.getrgbaColor(this.panel.dynamicTransparency.backgroundColorRgb, Math.min(alphaBg + .1, 1));
|
|
let endBg = Utils.getrgbaColor(this.panel.dynamicTransparency.backgroundColorRgb, 0)
|
|
let fadeStyle = 'background-gradient-start:' + startBg +
|
|
'background-gradient-end:' + endBg +
|
|
'background-gradient-direction:' + this.panel.getOrientation();
|
|
|
|
if (this.isVertical) {
|
|
y = end ? this.panel.monitor.height - FADE_SIZE : 0;
|
|
} else {
|
|
x = end ? this.panel.monitor.width - FADE_SIZE : 0;
|
|
}
|
|
|
|
let fadeWidget = new St.Widget({
|
|
reactive: false,
|
|
pivot_point: new Graphene.Point({ x: .5, y: .5 }),
|
|
rotation_angle_z: end ? 180 : 0,
|
|
style: fadeStyle,
|
|
x: x, y: y,
|
|
width: this.isVertical ? this.width : FADE_SIZE,
|
|
height: this.isVertical ? FADE_SIZE : this.height
|
|
});
|
|
|
|
return fadeWidget;
|
|
}
|
|
|
|
_getPreviewsSize() {
|
|
let previewsWidth = 0;
|
|
let previewsHeight = 0;
|
|
|
|
this._box.get_children().forEach(c => {
|
|
if (!c.animatingOut) {
|
|
let [width, height] = c.getSize();
|
|
|
|
if (this.isVertical) {
|
|
previewsWidth = Math.max(width, previewsWidth);
|
|
previewsHeight += height;
|
|
} else {
|
|
previewsWidth += width;
|
|
previewsHeight = Math.max(height, previewsHeight);
|
|
}
|
|
}
|
|
});
|
|
|
|
return [previewsWidth, previewsHeight];
|
|
}
|
|
|
|
_animateOpenOrClose(show, onComplete) {
|
|
let isTranslationAnimation = this.menu[this._translationProp] != 0;
|
|
let tweenOpts = {
|
|
opacity: show ? 255 : 0,
|
|
transition: show ? 'easeInOutQuad' : 'easeInCubic',
|
|
onComplete: () => {
|
|
if (isTranslationAnimation) {
|
|
Main.layoutManager._queueUpdateRegions();
|
|
}
|
|
|
|
(onComplete || (() => {}))();
|
|
}
|
|
};
|
|
|
|
tweenOpts[this._translationProp] = show ? this._translationDirection : this._translationOffset;
|
|
|
|
Utils.animate(this.menu, getTweenOpts(tweenOpts));
|
|
}
|
|
|
|
_peek(window) {
|
|
let currentWorkspace = Utils.getCurrentWorkspace();
|
|
let windowWorkspace = window.get_workspace();
|
|
let focusWindow = () => this._focusMetaWindow(SETTINGS.get_int('peek-mode-opacity'), window);
|
|
|
|
this._restorePeekedWindowStack();
|
|
|
|
if (this._peekedWindow && windowWorkspace != currentWorkspace) {
|
|
currentWorkspace.list_windows().forEach(mw => this.animateWindowOpacity(mw, null, 255))
|
|
}
|
|
|
|
this._peekedWindow = window;
|
|
|
|
if (currentWorkspace != windowWorkspace) {
|
|
this._switchToWorkspaceImmediate(windowWorkspace.index());
|
|
this._timeoutsHandler.add([T3, 100, focusWindow]);
|
|
} else {
|
|
focusWindow();
|
|
}
|
|
|
|
if (this.peekInitialWorkspaceIndex < 0) {
|
|
this.peekInitialWorkspaceIndex = currentWorkspace.index();
|
|
}
|
|
}
|
|
|
|
_endPeek(stayHere) {
|
|
this._timeoutsHandler.remove(T3);
|
|
|
|
if (this._peekedWindow) {
|
|
let immediate = !stayHere && this.peekInitialWorkspaceIndex != Utils.getCurrentWorkspace().index();
|
|
|
|
this._restorePeekedWindowStack();
|
|
this._focusMetaWindow(255, this._peekedWindow, immediate, true);
|
|
this._peekedWindow = null;
|
|
|
|
if (!stayHere) {
|
|
this._switchToWorkspaceImmediate(this.peekInitialWorkspaceIndex);
|
|
}
|
|
|
|
this.peekInitialWorkspaceIndex = -1;
|
|
}
|
|
}
|
|
|
|
_switchToWorkspaceImmediate(workspaceIndex) {
|
|
let workspace = Utils.getWorkspaceByIndex(workspaceIndex);
|
|
let shouldAnimate = Main.wm._shouldAnimate;
|
|
|
|
if (!workspace || (!workspace.list_windows().length &&
|
|
workspaceIndex < Utils.getWorkspaceCount() - 1)) {
|
|
workspace = Utils.getCurrentWorkspace();
|
|
}
|
|
|
|
Main.wm._shouldAnimate = () => false;
|
|
workspace.activate(global.display.get_current_time_roundtrip());
|
|
Main.wm._shouldAnimate = shouldAnimate;
|
|
}
|
|
|
|
_focusMetaWindow(dimOpacity, window, immediate, ignoreFocus) {
|
|
window.get_workspace().list_windows().forEach(mw => {
|
|
let wa = mw.get_compositor_private();
|
|
let isFocused = !ignoreFocus && mw == window;
|
|
|
|
if (wa) {
|
|
if (isFocused) {
|
|
mw[PEEK_INDEX_PROP] = wa.get_parent().get_children().indexOf(wa);
|
|
wa.get_parent().set_child_above_sibling(wa, null);
|
|
}
|
|
|
|
if (isFocused && mw.minimized) {
|
|
wa.show();
|
|
}
|
|
|
|
this.animateWindowOpacity(mw, wa, isFocused ? 255 : dimOpacity, immediate)
|
|
}
|
|
});
|
|
}
|
|
|
|
animateWindowOpacity(metaWindow, windowActor, opacity, immediate) {
|
|
windowActor = windowActor || metaWindow.get_compositor_private();
|
|
|
|
if (windowActor && !metaWindow.minimized) {
|
|
let tweenOpts = getTweenOpts({ opacity });
|
|
|
|
if (immediate && !metaWindow.is_on_all_workspaces()) {
|
|
tweenOpts.time = 0;
|
|
}
|
|
|
|
Utils.animateWindowOpacity(windowActor, tweenOpts);
|
|
}
|
|
}
|
|
|
|
_restorePeekedWindowStack() {
|
|
let windowActor = this._peekedWindow ? this._peekedWindow.get_compositor_private() : null;
|
|
|
|
if (windowActor) {
|
|
if (this._peekedWindow.hasOwnProperty(PEEK_INDEX_PROP)) {
|
|
windowActor.get_parent().set_child_at_index(windowActor, this._peekedWindow[PEEK_INDEX_PROP]);
|
|
delete this._peekedWindow[PEEK_INDEX_PROP];
|
|
}
|
|
|
|
if (this._peekedWindow.minimized) {
|
|
windowActor.hide();
|
|
}
|
|
}
|
|
}
|
|
});
|
|
|
|
export const Preview = GObject.registerClass({
|
|
}, class Preview extends St.Widget {
|
|
|
|
_init(previewMenu) {
|
|
super._init({
|
|
style_class: 'preview-container',
|
|
reactive: true,
|
|
track_hover: true,
|
|
layout_manager: new Clutter.BinLayout()
|
|
});
|
|
|
|
this.window = null;
|
|
this._waitWindowId = 0;
|
|
this._needsCloseButton = true;
|
|
this.cloneWidth = this.cloneHeight = 0;
|
|
this._previewMenu = previewMenu;
|
|
this._padding = SETTINGS.get_int('window-preview-padding') * scaleFactor;
|
|
this._previewDimensions = this._getPreviewDimensions();
|
|
this.animatingOut = false;
|
|
|
|
let box = new St.Widget({ layout_manager: new Clutter.BoxLayout({ orientation: Clutter.Orientation.VERTICAL }), y_expand: true });
|
|
let [previewBinWidth, previewBinHeight] = this._getBinSize();
|
|
let closeButton = new St.Button({ style_class: 'window-close', accessible_name: 'Close window' });
|
|
|
|
closeButton.add_actor(new St.Icon({ icon_name: 'window-close-symbolic' }));
|
|
|
|
this._closeButtonBin = new St.Widget({
|
|
style_class: 'preview-close-btn-container',
|
|
layout_manager: new Clutter.BinLayout(),
|
|
opacity: 0,
|
|
x_expand: true, y_expand: true,
|
|
x_align: Clutter.ActorAlign[isLeftButtons ? 'START' : 'END'],
|
|
y_align: Clutter.ActorAlign[isTopHeader ? 'START' : 'END']
|
|
});
|
|
|
|
this._closeButtonBin.add_child(closeButton);
|
|
|
|
this._previewBin = new St.Widget({
|
|
layout_manager: new Clutter.BinLayout(),
|
|
x_expand: true, y_expand: true,
|
|
style: 'padding: ' + this._padding / scaleFactor + 'px;'
|
|
});
|
|
|
|
this._previewBin.set_size(previewBinWidth, previewBinHeight);
|
|
|
|
box.add_child(this._previewBin);
|
|
|
|
if (headerHeight) {
|
|
let headerBox = new St.Widget({
|
|
style_class: 'preview-header-box',
|
|
layout_manager: new Clutter.BoxLayout(),
|
|
x_expand: true,
|
|
y_align: Clutter.ActorAlign[isTopHeader ? 'START' : 'END']
|
|
});
|
|
|
|
setStyle(headerBox, this._getBackgroundColor(HEADER_COLOR_OFFSET, 1));
|
|
this._workspaceIndicator = new St.Label({ y_align: Clutter.ActorAlign.CENTER });
|
|
this._windowTitle = new St.Label({ y_align: Clutter.ActorAlign.CENTER, x_expand: true });
|
|
|
|
this._iconBin = new St.Widget({ layout_manager: new Clutter.BinLayout() });
|
|
this._iconBin.set_size(headerHeight, headerHeight);
|
|
|
|
headerBox.add_child(this._iconBin);
|
|
headerBox.insert_child_at_index(this._workspaceIndicator, isLeftButtons ? 0 : 1);
|
|
headerBox.insert_child_at_index(this._windowTitle, isLeftButtons ? 1 : 2);
|
|
|
|
box.insert_child_at_index(headerBox, isTopHeader ? 0 : 1);
|
|
}
|
|
|
|
this.add_child(box);
|
|
this.add_child(this._closeButtonBin);
|
|
|
|
closeButton.connect('clicked', () => this._onCloseBtnClick());
|
|
this.connect('notify::hover', () => this._onHoverChanged());
|
|
this.connect('button-release-event', (actor, e) => this._onButtonReleaseEvent(e));
|
|
this.connect('destroy', () => this._onDestroy());
|
|
}
|
|
|
|
adjustOnStage() {
|
|
let closeButton = this._closeButtonBin.get_first_child();
|
|
let closeButtonHeight = closeButton.height;
|
|
let maxCloseButtonSize = MAX_CLOSE_BUTTON_SIZE * scaleFactor;
|
|
let closeButtonBorderRadius = '';
|
|
|
|
if (closeButtonHeight > maxCloseButtonSize) {
|
|
closeButtonHeight = maxCloseButtonSize;
|
|
closeButton.set_size(closeButtonHeight, closeButtonHeight);
|
|
}
|
|
|
|
if (!headerHeight) {
|
|
closeButtonBorderRadius = 'border-radius: ';
|
|
|
|
if (isTopHeader) {
|
|
closeButtonBorderRadius += (isLeftButtons ? '0 0 4px 0;' : '0 0 0 4px;');
|
|
} else {
|
|
closeButtonBorderRadius += (isLeftButtons ? '0 4px 0 0;' : '4px 0 0 0;');
|
|
}
|
|
}
|
|
|
|
setStyle(
|
|
this._closeButtonBin,
|
|
'padding: ' + (headerHeight ? Math.round((headerHeight - closeButtonHeight) * .5 / scaleFactor) : 4) + 'px;' +
|
|
this._getBackgroundColor(HEADER_COLOR_OFFSET, headerHeight ? 1 : .6) +
|
|
closeButtonBorderRadius
|
|
);
|
|
}
|
|
|
|
assignWindow(window, animateSize) {
|
|
if (this.window != window) {
|
|
let _assignWindowClone = () => {
|
|
if (window.get_compositor_private()) {
|
|
let cloneBin = this._getWindowCloneBin(window);
|
|
|
|
this._resizeClone(cloneBin, window);
|
|
this._addClone(cloneBin, animateSize);
|
|
this._previewMenu.updatePosition();
|
|
} else if (!this._waitWindowId) {
|
|
this._waitWindowId = GLib.idle_add(GLib.PRIORITY_DEFAULT_IDLE, () => {
|
|
this._waitWindowId = 0;
|
|
|
|
if (this._previewMenu.opened) {
|
|
_assignWindowClone();
|
|
}
|
|
|
|
return GLib.SOURCE_REMOVE;
|
|
});
|
|
}
|
|
};
|
|
|
|
_assignWindowClone();
|
|
}
|
|
|
|
this._cancelAnimateOut();
|
|
this._removeWindowSignals();
|
|
this.window = window;
|
|
this._needsCloseButton = this._previewMenu.allowCloseWindow && window.can_close() && !Utils.checkIfWindowHasTransient(window);
|
|
this._updateHeader();
|
|
}
|
|
|
|
animateOut() {
|
|
if (!this.animatingOut) {
|
|
let tweenOpts = getTweenOpts({ opacity: 0, width: 0, height: 0, onComplete: () => this.destroy() });
|
|
|
|
this.animatingOut = true;
|
|
|
|
Utils.stopAnimations(this);
|
|
Utils.animate(this, tweenOpts);
|
|
}
|
|
}
|
|
|
|
getSize() {
|
|
let [binWidth, binHeight] = this._getBinSize();
|
|
|
|
binWidth = Math.max(binWidth, this.cloneWidth + this._padding * 2);
|
|
binHeight = Math.max(binHeight, this.cloneHeight + this._padding * 2) + headerHeight;
|
|
|
|
return [binWidth, binHeight];
|
|
}
|
|
|
|
setFocus(focused) {
|
|
this._hideOrShowCloseButton(!focused);
|
|
setStyle(this, this._getBackgroundColor(FOCUSED_COLOR_OFFSET, focused ? '-' : 0));
|
|
|
|
if (focused) {
|
|
this._previewMenu.ensureVisible(this);
|
|
this._previewMenu.requestPeek(this.window);
|
|
}
|
|
}
|
|
|
|
activate() {
|
|
this._previewMenu.endPeekHere();
|
|
this._previewMenu.close();
|
|
Main.activateWindow(this.window);
|
|
}
|
|
|
|
_onDestroy() {
|
|
if (this._waitWindowId) {
|
|
GLib.source_remove(this._waitWindowId);
|
|
this._waitWindowId = 0;
|
|
}
|
|
|
|
this._removeWindowSignals();
|
|
}
|
|
|
|
_onHoverChanged() {
|
|
this.setFocus(this.hover);
|
|
}
|
|
|
|
_onCloseBtnClick() {
|
|
this._hideOrShowCloseButton(true);
|
|
this.reactive = false;
|
|
|
|
if (!SETTINGS.get_boolean('group-apps')) {
|
|
this._previewMenu.close();
|
|
} else {
|
|
this._previewMenu.endPeekHere();
|
|
}
|
|
|
|
this.window.delete(global.get_current_time());
|
|
}
|
|
|
|
_onButtonReleaseEvent(e) {
|
|
switch (e.get_button()) {
|
|
case 1: // Left click
|
|
this.activate();
|
|
break;
|
|
case 2: // Middle click
|
|
if (SETTINGS.get_boolean('preview-middle-click-close')) {
|
|
this._onCloseBtnClick();
|
|
}
|
|
break;
|
|
case 3: // Right click
|
|
this._showContextMenu(e);
|
|
break;
|
|
}
|
|
|
|
return Clutter.EVENT_STOP;
|
|
}
|
|
|
|
_cancelAnimateOut() {
|
|
if (this.animatingOut) {
|
|
this.animatingOut = false;
|
|
|
|
Utils.stopAnimations(this);
|
|
Utils.animate(this, getTweenOpts({ opacity: 255, width: this.cloneWidth, height: this.cloneHeight }));
|
|
}
|
|
}
|
|
|
|
_showContextMenu(e) {
|
|
let coords = e.get_coords();
|
|
let currentWorkspace = this._previewMenu.peekInitialWorkspaceIndex < 0 ?
|
|
Utils.getCurrentWorkspace() :
|
|
Utils.getWorkspaceByIndex(this._previewMenu.peekInitialWorkspaceIndex);
|
|
|
|
Main.wm._showWindowMenu(null, this.window, Meta.WindowMenuType.WM, {
|
|
x: coords[0],
|
|
y: coords[1],
|
|
width: 0,
|
|
height: 0
|
|
});
|
|
|
|
let menu = Main.wm._windowMenuManager._manager._menus[0];
|
|
|
|
menu.connect('open-state-changed', () => this._previewMenu.menu.sync_hover());
|
|
this._previewMenu.menu.sync_hover();
|
|
|
|
if (this.window.get_workspace() != currentWorkspace) {
|
|
let menuItem = new PopupMenu.PopupMenuItem(_('Move to current Workspace') + ' [' + (currentWorkspace.index() + 1) + ']');
|
|
let menuItems = menu.box.get_children();
|
|
let insertIndex = Utils.findIndex(menuItems, c => c._delegate instanceof PopupMenu.PopupSeparatorMenuItem);
|
|
|
|
insertIndex = insertIndex >= 0 ? insertIndex : menuItems.length - 1;
|
|
menu.addMenuItem(menuItem, insertIndex);
|
|
menuItem.connect('activate', () => this.window.change_workspace(currentWorkspace));
|
|
}
|
|
}
|
|
|
|
_removeWindowSignals() {
|
|
if (this._titleWindowChangeId) {
|
|
this.window.disconnect(this._titleWindowChangeId);
|
|
this._titleWindowChangeId = 0;
|
|
}
|
|
}
|
|
|
|
_updateHeader() {
|
|
if (headerHeight) {
|
|
let iconTextureSize = SETTINGS.get_boolean('window-preview-use-custom-icon-size') ?
|
|
SETTINGS.get_int('window-preview-custom-icon-size') :
|
|
headerHeight / scaleFactor * .6;
|
|
let icon = this._previewMenu.getCurrentAppIcon().app.create_icon_texture(iconTextureSize);
|
|
let workspaceIndex = '';
|
|
let workspaceStyle = null;
|
|
let fontScale = DESKTOPSETTINGS.get_double('text-scaling-factor');
|
|
let commonTitleStyles = 'color: ' + SETTINGS.get_string('window-preview-title-font-color') + ';' +
|
|
'font-size: ' + SETTINGS.get_int('window-preview-title-font-size') * fontScale + 'px;' +
|
|
'font-weight: ' + SETTINGS.get_string('window-preview-title-font-weight') + ';';
|
|
|
|
this._iconBin.destroy_all_children();
|
|
this._iconBin.add_child(icon);
|
|
|
|
if (!SETTINGS.get_boolean('isolate-workspaces')) {
|
|
workspaceIndex = (this.window.get_workspace().index() + 1).toString();
|
|
workspaceStyle = 'margin: 0 4px 0 ' + (isLeftButtons ? Math.round((headerHeight - icon.width) * .5) + 'px' : '0') + '; padding: 0 4px;' +
|
|
'border: 2px solid ' + this._getRgbaColor(FOCUSED_COLOR_OFFSET, .8) + 'border-radius: 2px;' + commonTitleStyles;
|
|
}
|
|
|
|
this._workspaceIndicator.text = workspaceIndex;
|
|
setStyle(this._workspaceIndicator, workspaceStyle);
|
|
|
|
this._titleWindowChangeId = this.window.connect('notify::title', () => this._updateWindowTitle());
|
|
setStyle(this._windowTitle, 'max-width: 0px; padding-right: 4px;' + commonTitleStyles);
|
|
this._updateWindowTitle();
|
|
}
|
|
}
|
|
|
|
_updateWindowTitle() {
|
|
this._windowTitle.text = this.window.title;
|
|
}
|
|
|
|
_hideOrShowCloseButton(hide) {
|
|
if (this._needsCloseButton) {
|
|
Utils.animate(this._closeButtonBin, getTweenOpts({ opacity: hide ? 0 : 255 }));
|
|
}
|
|
}
|
|
|
|
_getBackgroundColor(offset, alpha) {
|
|
return 'background-color: ' + this._getRgbaColor(offset, alpha) +
|
|
'transition-duration:' + this._previewMenu.panel.dynamicTransparency.animationDuration;
|
|
}
|
|
|
|
_getRgbaColor(offset, alpha) {
|
|
alpha = Math.abs(alpha);
|
|
|
|
if (isNaN(alpha)) {
|
|
alpha = alphaBg;
|
|
}
|
|
|
|
return Utils.getrgbaColor(this._previewMenu.panel.dynamicTransparency.backgroundColorRgb, alpha, offset);
|
|
}
|
|
|
|
_addClone(newCloneBin, animateSize) {
|
|
let currentClones = this._previewBin.get_children();
|
|
let newCloneOpts = getTweenOpts({ opacity: 255 });
|
|
|
|
this._previewBin.add_child(newCloneBin);
|
|
|
|
if (currentClones.length) {
|
|
let currentCloneBin = currentClones.pop();
|
|
let currentCloneOpts = getTweenOpts({ opacity: 0, onComplete: () => currentCloneBin.destroy() });
|
|
|
|
if (newCloneBin.width > currentCloneBin.width) {
|
|
newCloneOpts.width = newCloneBin.width;
|
|
newCloneBin.width = currentCloneBin.width;
|
|
} else {
|
|
currentCloneOpts.width = newCloneBin.width;
|
|
}
|
|
|
|
if (newCloneBin.height > currentCloneBin.height) {
|
|
newCloneOpts.height = newCloneBin.height;
|
|
newCloneBin.height = currentCloneBin.height;
|
|
} else {
|
|
currentCloneOpts.height = newCloneBin.height;
|
|
}
|
|
|
|
currentClones.forEach(c => c.destroy());
|
|
Utils.animate(currentCloneBin, currentCloneOpts);
|
|
} else if (animateSize) {
|
|
newCloneBin.width = 0;
|
|
newCloneBin.height = 0;
|
|
newCloneOpts.width = this.cloneWidth;
|
|
newCloneOpts.height = this.cloneHeight;
|
|
}
|
|
|
|
Utils.animate(newCloneBin, newCloneOpts);
|
|
}
|
|
|
|
_getWindowCloneBin(window) {
|
|
let frameRect = window.get_frame_rect();
|
|
let bufferRect = window.get_buffer_rect();
|
|
let clone = new Clutter.Clone({ source: window.get_compositor_private() });
|
|
let cloneBin = new St.Widget({
|
|
opacity: 0,
|
|
layout_manager: frameRect.width != bufferRect.width ||
|
|
frameRect.height != bufferRect.height ?
|
|
new WindowCloneLayout(frameRect, bufferRect) :
|
|
new Clutter.BinLayout()
|
|
});
|
|
|
|
cloneBin.add_child(clone);
|
|
|
|
return cloneBin;
|
|
}
|
|
|
|
_getBinSize() {
|
|
let [fixedWidth, fixedHeight] = this._previewDimensions;
|
|
|
|
return [
|
|
aspectRatio.x.fixed ? fixedWidth + this._padding * 2 : -1,
|
|
aspectRatio.y.fixed ? fixedHeight + this._padding * 2 : -1
|
|
];
|
|
}
|
|
|
|
_resizeClone(cloneBin, window) {
|
|
let frameRect = cloneBin.layout_manager.frameRect || window.get_frame_rect();
|
|
let [fixedWidth, fixedHeight] = this._previewDimensions;
|
|
let ratio = Math.min(fixedWidth / frameRect.width, fixedHeight / frameRect.height, 1);
|
|
let cloneWidth = frameRect.width * ratio;
|
|
let cloneHeight = frameRect.height * ratio;
|
|
|
|
let clonePaddingTB = cloneHeight < MIN_DIMENSION ? MIN_DIMENSION - cloneHeight : 0;
|
|
let clonePaddingLR = cloneWidth < MIN_DIMENSION ? MIN_DIMENSION - cloneWidth : 0;
|
|
let clonePaddingTop = clonePaddingTB * .5;
|
|
let clonePaddingLeft = clonePaddingLR * .5;
|
|
|
|
this.cloneWidth = cloneWidth + clonePaddingLR * scaleFactor;
|
|
this.cloneHeight = cloneHeight + clonePaddingTB * scaleFactor;
|
|
|
|
cloneBin.set_style('padding: ' + clonePaddingTop + 'px ' + clonePaddingLeft + 'px;');
|
|
cloneBin.layout_manager.ratio = ratio;
|
|
cloneBin.layout_manager.padding = [clonePaddingLeft * scaleFactor, clonePaddingTop * scaleFactor];
|
|
|
|
cloneBin.get_first_child().set_size(cloneWidth, cloneHeight);
|
|
}
|
|
|
|
_getPreviewDimensions() {
|
|
let size = SETTINGS.get_int('window-preview-size') * scaleFactor;
|
|
let w, h;
|
|
|
|
if (this._previewMenu.isVertical) {
|
|
w = size;
|
|
h = w * aspectRatio.y.size / aspectRatio.x.size;
|
|
} else {
|
|
h = size;
|
|
w = h * aspectRatio.x.size / aspectRatio.y.size;
|
|
}
|
|
|
|
return [w, h];
|
|
}
|
|
});
|
|
|
|
export const WindowCloneLayout = GObject.registerClass({
|
|
}, class WindowCloneLayout extends Clutter.BinLayout {
|
|
|
|
_init(frameRect, bufferRect) {
|
|
super._init();
|
|
|
|
//the buffer_rect contains the transparent padding that must be removed
|
|
this.frameRect = frameRect;
|
|
this.bufferRect = bufferRect;
|
|
}
|
|
|
|
vfunc_allocate(actor, box) {
|
|
let [width, height] = box.get_size();
|
|
|
|
box.set_origin(
|
|
(this.bufferRect.x - this.frameRect.x) * this.ratio + this.padding[0],
|
|
(this.bufferRect.y - this.frameRect.y) * this.ratio + this.padding[1]
|
|
);
|
|
|
|
box.set_size(
|
|
width + (this.bufferRect.width - this.frameRect.width) * this.ratio,
|
|
height + (this.bufferRect.height - this.frameRect.height) * this.ratio
|
|
);
|
|
|
|
actor.get_first_child().allocate(box);
|
|
}
|
|
});
|
|
|
|
export function setStyle(actor, style) {
|
|
if (!isManualStyling) {
|
|
actor.set_style(style);
|
|
}
|
|
}
|
|
|
|
export function getTweenOpts(opts) {
|
|
let defaults = {
|
|
time: animationTime,
|
|
transition: 'easeInOutQuad'
|
|
};
|
|
|
|
return Utils.mergeObjects(opts || {}, defaults);
|
|
}
|