// -*- mode: js; js-indent-level: 4; indent-tabs-mode: nil -*- const Clutter = imports.gi.Clutter; const GdkPixbuf = imports.gi.GdkPixbuf const Gio = imports.gi.Gio; const GLib = imports.gi.GLib; const GObject = imports.gi.GObject; const Signals = imports.signals; const Meta = imports.gi.Meta; const Shell = imports.gi.Shell; const St = imports.gi.St; // Use __ () and N__() for the extension gettext domain, and reuse // the shell domain with the default _() and N_() const Gettext = imports.gettext.domain('dashtodock'); const __ = Gettext.gettext; const N__ = function(e) { return e }; const AppDisplay = imports.ui.appDisplay; const AppFavorites = imports.ui.appFavorites; const BoxPointer = imports.ui.boxpointer; const Dash = imports.ui.dash; const DND = imports.ui.dnd; const IconGrid = imports.ui.iconGrid; const Main = imports.ui.main; const ParentalControlsManager = imports.misc.parentalControlsManager; const PopupMenu = imports.ui.popupMenu; const Util = imports.misc.util; const Workspace = imports.ui.workspace; const ExtensionUtils = imports.misc.extensionUtils; const Me = ExtensionUtils.getCurrentExtension(); const Docking = Me.imports.docking; const Utils = Me.imports.utils; const WindowPreview = Me.imports.windowPreview; const AppIconIndicators = Me.imports.appIconIndicators; const DbusmenuUtils = Me.imports.dbusmenuUtils; const tracker = Shell.WindowTracker.get_default(); const clickAction = { SKIP: 0, MINIMIZE: 1, LAUNCH: 2, CYCLE_WINDOWS: 3, MINIMIZE_OR_OVERVIEW: 4, PREVIEWS: 5, MINIMIZE_OR_PREVIEWS: 6, FOCUS_OR_PREVIEWS: 7, FOCUS_MINIMIZE_OR_PREVIEWS: 8, QUIT: 9 }; const scrollAction = { DO_NOTHING: 0, CYCLE_WINDOWS: 1, SWITCH_WORKSPACE: 2 }; let recentlyClickedAppLoopId = 0; let recentlyClickedApp = null; let recentlyClickedAppWindows = null; let recentlyClickedAppIndex = 0; let recentlyClickedAppMonitor = -1; /** * Extend AppIcon * * - Apply a css class based on the number of windows of each application (#N); * - Customized indicators for running applications in place of the default "dot" style which is hidden (#N); * a class of the form "running#N" is applied to the AppWellIcon actor. * like the original .running one. * - Add a .focused style to the focused app * - Customize click actions. * - Update minimization animation target * - Update menu if open on windows change */ var DockAbstractAppIcon = GObject.registerClass({ GTypeFlags: GObject.TypeFlags.ABSTRACT, Properties: { 'focused': GObject.ParamSpec.boolean( 'focused', 'focused', 'focused', GObject.ParamFlags.READWRITE, false), 'running': GObject.ParamSpec.boolean( 'running', 'running', 'running', GObject.ParamFlags.READWRITE, false), 'urgent': GObject.ParamSpec.boolean( 'urgent', 'urgent', 'urgent', GObject.ParamFlags.READWRITE, false), 'windows-count': GObject.ParamSpec.uint( 'windows-count', 'windows-count', 'windows-count', GObject.ParamFlags.READWRITE, 0, GLib.MAXUINT32, 0), } }, class DockAbstractAppIcon extends Dash.DashIcon { // settings are required inside. _init(app, monitorIndex, iconAnimator) { super._init(app); // a prefix is required to avoid conflicting with the parent class variable this.monitorIndex = monitorIndex; this._signalsHandler = new Utils.GlobalSignalsHandler(this); this.iconAnimator = iconAnimator; this._indicator = new AppIconIndicators.AppIconIndicator(this); // Monitor windows-changes instead of app state. // Keep using the same Id and function callback (that is extended) if (this._stateChangedId > 0) { this.app.disconnect(this._stateChangedId); this._stateChangedId = 0; } this._signalsHandler.add(this.app, 'windows-changed', () => this._updateWindows()); this._signalsHandler.add(this.app, 'notify::state', () => this._updateRunningState()); this._signalsHandler.add(global.display, 'window-demands-attention', (_dpy, window) => this._onWindowDemandsAttention(window)); this._signalsHandler.add(global.display, 'window-marked-urgent', (_dpy, window) => this._onWindowDemandsAttention(window)); // In Wayland sessions, this signal is needed to track the state of windows dragged // from one monitor to another. As this is triggered quite often (whenever a new winow // of any application opened or moved to a different desktop), // we restrict this signal to the case when 'isolate-monitors' is true, // and if there are at least 2 monitors. if (Docking.DockManager.settings.get_boolean('isolate-monitors') && Main.layoutManager.monitors.length > 1) { this._signalsHandler.removeWithLabel('isolate-monitors'); this._signalsHandler.addWithLabel('isolate-monitors', global.display, 'window-entered-monitor', this._onWindowEntered.bind(this)); } this.connect('notify::running', () => { if (this.running) this.add_style_class_name('running'); else this.remove_style_class_name('running'); }); this.connect('notify::focused', () => { if (this.focused) this.add_style_class_name('focused'); else this.remove_style_class_name('focused'); }) this.connect('notify::urgent', () => { const icon = this.icon._iconBin; this._signalsHandler.removeWithLabel('urgent-windows') if (this.urgent) { icon.set_pivot_point(0.5, 0.5); this.iconAnimator.addAnimation(icon, 'dance'); if (!this._urgentWindows.size) { const urgentWindows = this.getInterestingWindows(); urgentWindows.forEach(w => (w._manualUrgency = true)); this._updateUrgentWindows(urgentWindows); } } else { this.iconAnimator.removeAnimation(icon, 'dance'); icon.rotation_angle_z = 0; this._urgentWindows.forEach(w => (delete w._manualUrgency)); this._updateUrgentWindows(); } }); this._urgentWindows = new Set(); this._progressOverlayArea = null; this._progress = 0; let keys = ['apply-custom-theme', 'running-indicator-style', ]; keys.forEach(key => { this._signalsHandler.add( Docking.DockManager.settings, 'changed::' + key, () => { this._indicator.destroy(); this._indicator = new AppIconIndicators.AppIconIndicator(this); } ); }); this._updateState(); this._numberOverlay(); this.updateIconGeometry(); this._previewMenuManager = null; this._previewMenu = null; } _onDestroy() { super._onDestroy(); // This is necessary due to an upstream bug // https://bugzilla.gnome.org/show_bug.cgi?id=757556 // It can be safely removed once it get solved upstrea. if (this._menu) this._menu.close(false); } ownsWindow(window) { return this.app === tracker.get_window_app(window); } _onWindowEntered(metaScreen, monitorIndex, metaWin) { if (this.ownsWindow(metaWin)) this._updateWindows(); } vfunc_scroll_event(scrollEvent) { let settings = Docking.DockManager.settings; let isEnabled = settings.get_enum('scroll-action') === scrollAction.CYCLE_WINDOWS; if (!isEnabled) return Clutter.EVENT_PROPAGATE; // We only activate windows of running applications, i.e. we never open new windows // We check if the app is running, and that the # of windows is > 0 in // case we use workspace isolation, if (!this.running) return Clutter.EVENT_PROPAGATE; if (this._optionalScrollCycleWindowsDeadTimeId) return Clutter.EVENT_PROPAGATE; else this._optionalScrollCycleWindowsDeadTimeId = GLib.timeout_add( GLib.PRIORITY_DEFAULT, 250, () => { this._optionalScrollCycleWindowsDeadTimeId = 0; }); let direction = null; switch (scrollEvent.direction) { case Clutter.ScrollDirection.UP: direction = Meta.MotionDirection.UP; break; case Clutter.ScrollDirection.DOWN: direction = Meta.MotionDirection.DOWN; break; case Clutter.ScrollDirection.SMOOTH: let [, dy] = Clutter.get_current_event().get_scroll_delta(); if (dy < 0) direction = Meta.MotionDirection.UP; else if (dy > 0) direction = Meta.MotionDirection.DOWN; break; } if (!Main.overview.visible) { let reversed = direction === Meta.MotionDirection.UP; if (this.focused && !this._urgentWindows.size) this._cycleThroughWindows(reversed); else { // Activate the first window let windows = this.getInterestingWindows(); if (windows.length > 0) { let w = windows[0]; Main.activateWindow(w); } } } else this.app.activate(); return Clutter.EVENT_STOP; } _updateWindows() { if (this._menu && this._menu.isOpen) this._menu.update(); this._updateState(); this.updateIconGeometry(); } _updateState() { this._urgentWindows.clear(); const interestingWindows = this.getInterestingWindows(); this.windowsCount = interestingWindows.length; this._updateRunningState(); this._updateFocusState(); this._updateUrgentWindows(interestingWindows); } _updateRunningState() { this.running = (this.app.state === Shell.AppState.RUNNING) && this.windowsCount; } _updateFocusState() { this.focused = (tracker.focus_app === this.app && this.running); } _updateUrgentWindows(interestingWindows) { this._signalsHandler.removeWithLabel('urgent-windows') this._urgentWindows.clear(); if (interestingWindows === undefined) interestingWindows = this.getInterestingWindows(); interestingWindows.forEach(win => { if (win.urgent || win.demandsAttention || win._manualUrgency) this._addUrgentWindow(win); }); this.urgent = !!this._urgentWindows.size; } _onWindowDemandsAttention(window) { if (this.ownsWindow(window)) this._addUrgentWindow(window); } _addUrgentWindow(window) { if (this._urgentWindows.has(window)) return; if (window._manualUrgency && window.has_focus()) { delete window._manualUrgency; return; } this._urgentWindows.add(window); this.urgent = true; const onDemandsAttentionChanged = () => { if (!window.demandsAttention && !window.urgent && !window._manualUrgency) this._updateUrgentWindows(); }; if (window.demandsAttention) this._signalsHandler.addWithLabel('urgent-windows', window, 'notify::demands-attention', () => onDemandsAttentionChanged()); if (window.urgent) this._signalsHandler.addWithLabel('urgent-windows', window, 'notify::urgent', () => onDemandsAttentionChanged()); if (window._manualUrgency) { this._signalsHandler.addWithLabel('urgent-windows', window, 'focus', () => { delete window._manualUrgency; onDemandsAttentionChanged() }); } } /** * Update taraget for minimization animation */ updateIconGeometry() { // If (for unknown reason) the actor is not on the stage the reported size // and position are random values, which might exceeds the integer range // resulting in an error when assigned to the a rect. This is a more like // a workaround to prevent flooding the system with errors. if (this.get_stage() == null) return; let rect = new Meta.Rectangle(); [rect.x, rect.y] = this.get_transformed_position(); [rect.width, rect.height] = this.get_transformed_size(); let windows = this.getWindows(); if (Docking.DockManager.settings.get_boolean('multi-monitor')) { let monitorIndex = this.monitorIndex; windows = windows.filter(function(w) { return w.get_monitor() == monitorIndex; }); } windows.forEach(function(w) { w.set_icon_geometry(rect); }); } _updateRunningStyle() { // The logic originally in this function has been moved to // AppIconIndicatorBase._updateDefaultDot(). However it cannot be removed as // it called by the parent constructor. } popupMenu() { this._removeMenuTimeout(); this.fake_release(); this._draggable.fakeRelease(); if (!this._menu) { this._menu = new DockAppIconMenu(this); this._menu.connect('activate-window', (menu, window) => { Main.activateWindow(window); }); this._menu.connect('open-state-changed', (menu, isPoppedUp) => { if (!isPoppedUp) this._onMenuPoppedDown(); else { // Setting the max-height is s useful if part of the menu is // scrollable so the minimum height is smaller than the natural height. let monitor_index = Main.layoutManager.findIndexForActor(this); let workArea = Main.layoutManager.getWorkAreaForMonitor(monitor_index); let position = Utils.getPosition(); this._isHorizontal = ( position == St.Side.TOP || position == St.Side.BOTTOM); // If horizontal also remove the height of the dash const { dockFixed: fixedDock } = Docking.DockManager.settings; let additional_margin = this._isHorizontal && !fixedDock ? Main.overview.dash.height : 0; let verticalMargins = this._menu.actor.margin_top + this._menu.actor.margin_bottom; // Also set a max width to the menu, so long labels (long windows title) get truncated this._menu.actor.style = ('max-height: ' + Math.round(workArea.height - additional_margin - verticalMargins) + 'px;' + 'max-width: 400px'); } }); let id = Main.overview.connect('hiding', () => { this._menu.close(); }); this._menu.actor.connect('destroy', function() { Main.overview.disconnect(id); }); this._menuManager.addMenu(this._menu); } this.emit('menu-state-changed', true); this.set_hover(true); this._menu.popup(); this._menuManager.ignoreRelease(); this.emit('sync-tooltip'); return false; } activate(button) { let event = Clutter.get_current_event(); let modifiers = event ? event.get_state() : 0; // Only consider SHIFT and CONTROL as modifiers (exclude SUPER, CAPS-LOCK, etc.) modifiers = modifiers & (Clutter.ModifierType.SHIFT_MASK | Clutter.ModifierType.CONTROL_MASK); // We don't change the CTRL-click behaviour: in such case we just chain // up the parent method and return. if (modifiers & Clutter.ModifierType.CONTROL_MASK) { // Keep default behaviour: launch new window // By calling the parent method I make it compatible // with other extensions tweaking ctrl + click super.activate(button); return; } // We check what type of click we have and if the modifier SHIFT is // being used. We then define what buttonAction should be for this // event. let buttonAction = 0; let settings = Docking.DockManager.settings; if (button && button == 2 ) { if (modifiers & Clutter.ModifierType.SHIFT_MASK) buttonAction = settings.get_enum('shift-middle-click-action'); else buttonAction = settings.get_enum('middle-click-action'); } else if (button && button == 1) { if (modifiers & Clutter.ModifierType.SHIFT_MASK) buttonAction = settings.get_enum('shift-click-action'); else buttonAction = settings.get_enum('click-action'); } // We check if the app is running, and that the # of windows is > 0 in // case we use workspace isolation. let windows = this.getInterestingWindows(); // Some action modes (e.g. MINIMIZE_OR_OVERVIEW) require overview to remain open // This variable keeps track of this let shouldHideOverview = true; // We customize the action only when the application is already running if (this.running) { const hasUrgentWindows = !!this._urgentWindows.size; const singleOrUrgentWindows = windows.length === 1 || hasUrgentWindows; switch (buttonAction) { case clickAction.MINIMIZE: // In overview just activate the app, unless the acion is explicitely // requested with a keyboard modifier if (!Main.overview.visible || modifiers){ // If we have button=2 or a modifier, allow minimization even if // the app is not focused if ((this.focused && !hasUrgentWindows) || button === 2 || modifiers & Clutter.ModifierType.SHIFT_MASK) { // minimize all windows on double click and always in the case of primary click without // additional modifiers let click_count = 0; if (Clutter.EventType.CLUTTER_BUTTON_PRESS) click_count = event.get_click_count(); let all_windows = (button == 1 && ! modifiers) || click_count > 1; this._minimizeWindow(all_windows); } else this._activateAllWindows(); } else { let w = windows[0]; Main.activateWindow(w); } break; case clickAction.MINIMIZE_OR_OVERVIEW: // When a single window is present, toggle minimization // If only one windows is present toggle minimization, but only when trigggered with the // simple click action (no modifiers, no middle click). if (singleOrUrgentWindows && !modifiers && button == 1) { let w = windows[0]; if (this.focused) { // Window is raised, minimize it this._minimizeWindow(w); } else { // Window is minimized, raise it Main.activateWindow(w); } // Launch overview when multiple windows are present // TODO: only show current app windows when gnome shell API will allow it } else { shouldHideOverview = false; Main.overview.toggle(); } break; case clickAction.CYCLE_WINDOWS: if (!Main.overview.visible) { if (this.focused && !hasUrgentWindows) this._cycleThroughWindows(); else { // Activate the first window let w = windows[0]; Main.activateWindow(w); } } else this.app.activate(); break; case clickAction.FOCUS_OR_PREVIEWS: if (this.focused && !hasUrgentWindows && (windows.length > 1 || modifiers || button != 1)) { this._windowPreviews(); } else { // Activate the first window let w = windows[0]; Main.activateWindow(w); } break; case clickAction.FOCUS_MINIMIZE_OR_PREVIEWS: if (this.focused && !hasUrgentWindows) { if (windows.length > 1 || modifiers || button != 1) this._windowPreviews(); else if (!Main.overview.visible) this._minimizeWindow(); } else { // Activate the first window let w = windows[0]; Main.activateWindow(w); } break; case clickAction.LAUNCH: this.launchNewWindow(); break; case clickAction.PREVIEWS: if (!Main.overview.visible) { // If only one windows is present just switch to it, but only when trigggered with the // simple click action (no modifiers, no middle click). if (singleOrUrgentWindows && !modifiers && button == 1) { let w = windows[0]; Main.activateWindow(w); } else this._windowPreviews(); } else { this.app.activate(); } break; case clickAction.MINIMIZE_OR_PREVIEWS: // When a single window is present, toggle minimization // If only one windows is present toggle minimization, but only when trigggered with the // simple click action (no modifiers, no middle click). if (!Main.overview.visible) { if (singleOrUrgentWindows && !modifiers && button == 1) { let w = windows[0]; if (this.focused) { // Window is raised, minimize it this._minimizeWindow(w); } else { // Window is minimized, raise it Main.activateWindow(w); } } else { // Launch previews when multiple windows are present this._windowPreviews(); } } else { this.app.activate(); } break; case clickAction.QUIT: this.closeAllWindows(); break; case clickAction.SKIP: let w = windows[0]; Main.activateWindow(w); break; } } else { this.launchNewWindow(); } // Hide overview except when action mode requires it if(shouldHideOverview) { Main.overview.hide(); } } shouldShowTooltip() { return this.hover && (!this._menu || !this._menu.isOpen) && (!this._previewMenu || !this._previewMenu.isOpen); } _windowPreviews() { if (!this._previewMenu) { this._previewMenuManager = new PopupMenu.PopupMenuManager(this); this._previewMenu = new WindowPreview.WindowPreviewMenu(this); this._previewMenuManager.addMenu(this._previewMenu); this._previewMenu.connect('open-state-changed', (menu, isPoppedUp) => { if (!isPoppedUp) this._onMenuPoppedDown(); }); let id = Main.overview.connect('hiding', () => { this._previewMenu.close(); }); this._previewMenu.actor.connect('destroy', function() { Main.overview.disconnect(id); }); } if (this._previewMenu.isOpen) this._previewMenu.close(); else this._previewMenu.popup(); return false; } // Try to do the right thing when attempting to launch a new window of an app. In // particular, if the application doens't allow to launch a new window, activate // the existing window instead. launchNewWindow(p) { let appInfo = this.app.get_app_info(); let actions = appInfo.list_actions(); if (this.app.can_open_new_window()) { this.animateLaunch(); // This is used as a workaround for a bug resulting in no new windows being opened // for certain running applications when calling open_new_window(). // // https://bugzilla.gnome.org/show_bug.cgi?id=756844 // // Similar to what done when generating the popupMenu entries, if the application provides // a "New Window" action, use it instead of directly requesting a new window with // open_new_window(), which fails for certain application, notably Nautilus. if (actions.indexOf('new-window') == -1) { this.app.open_new_window(-1); } else { let i = actions.indexOf('new-window'); if (i !== -1) this.app.launch_action(actions[i], global.get_current_time(), -1); } } else { // Try to manually activate the first window. Otherwise, when the app is activated by // switching to a different workspace, a launch spinning icon is shown and disappers only // after a timeout. let windows = this.getWindows(); if (windows.length > 0) Main.activateWindow(windows[0]) else this.app.activate(); } } _numberOverlay() { // Add label for a Hot-Key visual aid this._numberOverlayLabel = new St.Label(); this._numberOverlayBin = new St.Bin({ child: this._numberOverlayLabel, x_align: Clutter.ActorAlign.START, y_align: Clutter.ActorAlign.START, x_expand: true, y_expand: true }); this._numberOverlayLabel.add_style_class_name('number-overlay'); this._numberOverlayOrder = -1; this._numberOverlayBin.hide(); this._iconContainer.add_child(this._numberOverlayBin); } updateNumberOverlay() { // We apply an overall scale factor that might come from a HiDPI monitor. // Clutter dimensions are in physical pixels, but CSS measures are in logical // pixels, so make sure to consider the scale. let scaleFactor = St.ThemeContext.get_for_stage(global.stage).scale_factor; // Set the font size to something smaller than the whole icon so it is // still visible. The border radius is large to make the shape circular let [minWidth, natWidth] = this._iconContainer.get_preferred_width(-1); let font_size = Math.round(Math.max(12, 0.3*natWidth) / scaleFactor); let size = Math.round(font_size*1.2); this._numberOverlayLabel.set_style( 'font-size: ' + font_size + 'px;' + 'border-radius: ' + this.icon.iconSize + 'px;' + 'width: ' + size + 'px; height: ' + size +'px;' ); } setNumberOverlay(number) { this._numberOverlayOrder = number; this._numberOverlayLabel.set_text(number.toString()); } toggleNumberOverlay(activate) { if (activate && this._numberOverlayOrder > -1) { this.updateNumberOverlay(); this._numberOverlayBin.show(); } else this._numberOverlayBin.hide(); } _minimizeWindow(param) { // Param true make all app windows minimize let windows = this.getInterestingWindows(); let current_workspace = global.workspace_manager.get_active_workspace(); for (let i = 0; i < windows.length; i++) { let w = windows[i]; if (w.get_workspace() == current_workspace && w.showing_on_its_workspace()) { w.minimize(); // Just minimize one window. By specification it should be the // focused window on the current workspace. if(!param) break; } } } // By default only non minimized windows are activated. // This activates all windows in the current workspace. _activateAllWindows() { // First activate first window so workspace is switched if needed. // We don't do this if isolation is on! if (!Docking.DockManager.settings.get_boolean('isolate-workspaces') && !Docking.DockManager.settings.get_boolean('isolate-monitors')) this.app.activate(); // then activate all other app windows in the current workspace let windows = this.getInterestingWindows(); let activeWorkspace = global.workspace_manager.get_active_workspace_index(); if (windows.length <= 0) return; let activatedWindows = 0; for (let i = windows.length - 1; i >= 0; i--) { if (windows[i].get_workspace().index() == activeWorkspace) { Main.activateWindow(windows[i]); activatedWindows++; } } } //This closes all windows of the app. closeAllWindows() { let windows = this.getInterestingWindows(); const time = global.get_current_time(); windows.forEach(w => w.delete(time)); } _cycleThroughWindows(reversed) { // Store for a little amount of time last clicked app and its windows // since the order changes upon window interaction let MEMORY_TIME=3000; let app_windows = this.getInterestingWindows(); if (app_windows.length <1) return if (recentlyClickedAppLoopId > 0) GLib.source_remove(recentlyClickedAppLoopId); recentlyClickedAppLoopId = GLib.timeout_add( GLib.PRIORITY_DEFAULT, MEMORY_TIME, this._resetRecentlyClickedApp); // If there isn't already a list of windows for the current app, // or the stored list is outdated, use the current windows list. let monitorIsolation = Docking.DockManager.settings.get_boolean('isolate-monitors'); if (!recentlyClickedApp || recentlyClickedApp.get_id() != this.app.get_id() || recentlyClickedAppWindows.length != app_windows.length || (recentlyClickedAppMonitor != this.monitorIndex && monitorIsolation)) { recentlyClickedApp = this.app; recentlyClickedAppWindows = app_windows; recentlyClickedAppMonitor = this.monitorIndex; recentlyClickedAppIndex = 0; } if (reversed) { recentlyClickedAppIndex--; if (recentlyClickedAppIndex < 0) recentlyClickedAppIndex = recentlyClickedAppWindows.length - 1; } else { recentlyClickedAppIndex++; } let index = recentlyClickedAppIndex % recentlyClickedAppWindows.length; let window = recentlyClickedAppWindows[index]; Main.activateWindow(window); } _resetRecentlyClickedApp() { if (recentlyClickedAppLoopId > 0) GLib.source_remove(recentlyClickedAppLoopId); recentlyClickedAppLoopId=0; recentlyClickedApp =null; recentlyClickedAppWindows = null; recentlyClickedAppIndex = 0; recentlyClickedAppMonitor = -1; return false; } getWindows() { return this.app.get_windows(); } // Filter out unnecessary windows, for instance // nautilus desktop window. getInterestingWindows() { const interestingWindows = getInterestingWindows(this.getWindows(), this.monitorIndex); if (!this._urgentWindows.size) return interestingWindows; return [...new Set([...this._urgentWindows, ...interestingWindows])]; } }); var DockAppIcon = GObject.registerClass({ }, class DockAppIcon extends DockAbstractAppIcon { _init(app, monitorIndex, iconAnimator) { super._init(app, monitorIndex, iconAnimator); this._signalsHandler.add(tracker, 'notify::focus-app', () => this._updateFocusState()); } }); var DockLocationAppIcon = GObject.registerClass({ }, class DockLocationAppIcon extends DockAbstractAppIcon { _init(app, monitorIndex, iconAnimator) { if (!app.location) throw new Error('Provided application %s has no location'.format(app)); super._init(app, monitorIndex, iconAnimator); if (Docking.DockManager.settings.isolateLocations) { this._signalsHandler.add(tracker, 'notify::focus-app', () => this._updateFocusState()); } else { this._signalsHandler.add(global.display, 'notify::focus-window', () => this._updateFocusState()); } } get location() { return this.app.location; } _updateFocusState() { if (Docking.DockManager.settings.isolateLocations) return super._updateFocusState(); this.focused = (this.app.isFocused && this.running); } }); function makeAppIcon(app, monitorIndex, iconAnimator) { if (app.location) return new DockLocationAppIcon(app, monitorIndex, iconAnimator); return new DockAppIcon(app, monitorIndex, iconAnimator); } let discreteGpuAvailable = AppDisplay.discreteGpuAvailable; /** * DockAppIconMenu * * - set popup arrow side based on dash orientation * - Add close windows option based on quitfromdash extension * (https://github.com/deuill/shell-extension-quitfromdash) * - Add open windows thumbnails instead of list * - update menu when application windows change */ const DockAppIconMenu = class DockAppIconMenu extends PopupMenu.PopupMenu { constructor(source) { super(source, 0.5, Utils.getPosition()); this._signalsHandler = new Utils.GlobalSignalsHandler(this); // We want to keep the item hovered while the menu is up this.blockSourceEvents = true; this._source = source; this._parentalControlsManager = ParentalControlsManager.getDefault(); this.actor.add_style_class_name('app-menu'); this.actor.add_style_class_name('app-well-menu'); this.actor.add_style_class_name('dock-app-menu'); // Chain our visibility and lifecycle to that of the source this._signalsHandler.add(source, 'notify::mapped', () => { if (!source.mapped) this.close(); }); source.connect('destroy', () => this.destroy()); Main.uiGroup.add_actor(this.actor); const { remoteModel } = Docking.DockManager.getDefault(); const remoteModelApp = remoteModel?.lookupById(this._source?.app?.id); if (remoteModelApp && DbusmenuUtils.haveDBusMenu()) { const [onQuicklist, onDynamicSection] = Utils.splitHandler((sender, { quicklist }, dynamicSection) => { dynamicSection.removeAll(); if (quicklist) { quicklist.get_children().forEach(remoteItem => dynamicSection.addMenuItem(DbusmenuUtils.makePopupMenuItem(remoteItem, false))); } }); this._signalsHandler.add([ remoteModelApp, 'quicklist-changed', onQuicklist ], [ this, 'dynamic-section-changed', onDynamicSection ]); } if (discreteGpuAvailable === undefined) { const updateDiscreteGpuAvailable = () => { const switcherooProxy = global.get_switcheroo_control(); if (switcherooProxy) { const prop = switcherooProxy.get_cached_property('HasDualGpu'); discreteGpuAvailable = prop?.unpack() ?? false; } else { discreteGpuAvailable = false; } } updateDiscreteGpuAvailable(); global.connect('notify::switcheroo-control', () => updateDiscreteGpuAvailable()); } } _appendSeparator() { this.addMenuItem(new PopupMenu.PopupSeparatorMenuItem()); } _appendMenuItem(labelText) { const item = new PopupMenu.PopupMenuItem(labelText); this.addMenuItem(item); return item; } popup(_activatingButton) { this._rebuildMenu(); this.open(BoxPointer.PopupAnimation.FULL); } _rebuildMenu() { this.removeAll(); if (Docking.DockManager.settings.get_boolean('show-windows-preview')) { // Display the app windows menu items and the separator between windows // of the current desktop and other windows. this._allWindowsMenuItem = new PopupMenu.PopupSubMenuMenuItem(__('All Windows'), false); this._allWindowsMenuItem.hide(); this.addMenuItem(this._allWindowsMenuItem); } else { const windows = this._source.getInterestingWindows().filter( w => !w.skip_taskbar); if (windows.length > 0) { this.addMenuItem( /* Translators: This is the heading of a list of open windows */ new PopupMenu.PopupSeparatorMenuItem(_('Open Windows'))); } windows.forEach(window => { let title = window.title ? window.title : this._source.app.get_name(); let item = this._appendMenuItem(title); item.connect('activate', () => { this.emit('activate-window', window); }); }); } if (!this._source.app.is_window_backed()) { this._appendSeparator(); let appInfo = this._source.app.get_app_info(); let actions = appInfo.list_actions(); if (this._source.app.can_open_new_window() && actions.indexOf('new-window') == -1) { this._newWindowMenuItem = this._appendMenuItem(_('New Window')); this._newWindowMenuItem.connect('activate', () => { if (this._source.app.state == Shell.AppState.STOPPED) this._source.animateLaunch(); this._source.app.open_new_window(-1); this.emit('activate-window', null); }); this._appendSeparator(); } if (discreteGpuAvailable && this._source.app.state == Shell.AppState.STOPPED) { const appPrefersNonDefaultGPU = appInfo.get_boolean('PrefersNonDefaultGPU'); const gpuPref = appPrefersNonDefaultGPU ? Shell.AppLaunchGpu.DEFAULT : Shell.AppLaunchGpu.DISCRETE; this._onGpuMenuItem = this._appendMenuItem(appPrefersNonDefaultGPU ? _('Launch using Integrated Graphics Card') : _('Launch using Discrete Graphics Card')); this._onGpuMenuItem.connect('activate', () => { this._source.animateLaunch(); this._source.app.launch(0, -1, gpuPref); this.emit('activate-window', null); }); } for (let i = 0; i < actions.length; i++) { let action = actions[i]; let item = this._appendMenuItem(appInfo.get_action_name(action)); item.connect('activate', (emitter, event) => { this._source.app.launch_action(action, event.get_time(), -1); this.emit('activate-window', null); }); } let canFavorite = global.settings.is_writable('favorite-apps') && (this._source instanceof DockAppIcon) && this._parentalControlsManager.shouldShowApp(this._source.app.app_info); if (canFavorite) { this._appendSeparator(); let isFavorite = AppFavorites.getAppFavorites().isFavorite(this._source.app.get_id()); if (isFavorite) { let item = this._appendMenuItem(_('Remove from Favorites')); item.connect('activate', () => { let favs = AppFavorites.getAppFavorites(); favs.removeFavorite(this._source.app.get_id()); }); } else { let item = this._appendMenuItem(_('Add to Favorites')); item.connect('activate', () => { let favs = AppFavorites.getAppFavorites(); favs.addFavorite(this._source.app.get_id()); }); } } if (Shell.AppSystem.get_default().lookup_app('org.gnome.Software.desktop') && (this._source instanceof DockAppIcon)) { this._appendSeparator(); let item = this._appendMenuItem(_('Show Details')); item.connect('activate', () => { let id = this._source.app.get_id(); let args = GLib.Variant.new('(ss)', [id, '']); Gio.DBus.get(Gio.BusType.SESSION, null, function(o, res) { let bus = Gio.DBus.get_finish(res); bus.call('org.gnome.Software', '/org/gnome/Software', 'org.gtk.Actions', 'Activate', GLib.Variant.new('(sava{sv})', ['details', [args], null]), null, 0, -1, null, null); Main.overview.hide(); }); }); } } // dynamic menu const items = this._getMenuItems(); let i = items.length; if (Shell.AppSystem.get_default().lookup_app('org.gnome.Software.desktop')) { i -= 2; } if (global.settings.is_writable('favorite-apps')) { i -= 2; } if (i < 0) { i = 0; } const dynamicSection = new PopupMenu.PopupMenuSection(); this.addMenuItem(dynamicSection, i); this.emit('dynamic-section-changed', dynamicSection); // quit menu this._appendSeparator(); this._quitfromDashMenuItem = this._appendMenuItem(_('Quit')); this._quitfromDashMenuItem.connect('activate', () => { this._source.closeAllWindows(); }); this.update(); } // update menu content when application windows change. This is desirable as actions // acting on windows (closing) are performed while the menu is shown. update() { // update, show or hide the quit menu if (this._source.windowsCount > 0) { let quitFromDashMenuText = ""; if (this._source.windowsCount == 1) this._quitfromDashMenuItem.label.set_text(_('Quit')); else this._quitfromDashMenuItem.label.set_text(__('Quit %d Windows').format(this._source.windowsCount)); this._quitfromDashMenuItem.actor.show(); } else { this._quitfromDashMenuItem.actor.hide(); } if (Docking.DockManager.settings.get_boolean('show-windows-preview')){ const windows = this._source.getInterestingWindows(); // update, show, or hide the allWindows menu // Check if there are new windows not already displayed. In such case, repopulate the allWindows // menu. Windows removal is already handled by each preview being connected to the destroy signal let old_windows = this._allWindowsMenuItem.menu._getMenuItems().map(function(item){ return item._window; }); let new_windows = windows.filter(function(w) {return old_windows.indexOf(w) < 0;}); if (new_windows.length > 0) { this._populateAllWindowMenu(windows); // Try to set the width to that of the submenu. // TODO: can't get the actual size, getting a bit less. // Temporary workaround: add 15px to compensate this._allWindowsMenuItem.width = this._allWindowsMenuItem.menu.actor.width + 15; } // The menu is created hidden and never hidded after being shown. Instead, a singlal // connected to its items destroy will set is insensitive if no more windows preview are shown. if (windows.length > 0){ this._allWindowsMenuItem.show(); this._allWindowsMenuItem.setSensitive(true); } } // Update separators this._getMenuItems().forEach(item => { if ('label' in item) { this._updateSeparatorVisibility(item); } }); } _populateAllWindowMenu(windows) { this._allWindowsMenuItem.menu.removeAll(); if (windows.length > 0) { let activeWorkspace = global.workspace_manager.get_active_workspace(); let separatorShown = windows[0].get_workspace() != activeWorkspace; for (let i = 0; i < windows.length; i++) { let window = windows[i]; if (!separatorShown && window.get_workspace() != activeWorkspace) { this._allWindowsMenuItem.menu.addMenuItem(new PopupMenu.PopupSeparatorMenuItem()); separatorShown = true; } let item = new WindowPreview.WindowPreviewMenuItem(window); this._allWindowsMenuItem.menu.addMenuItem(item); item.connect('activate', () => { this.emit('activate-window', window); }); // This is to achieve a more gracefull transition when the last windows is closed. item.connect('destroy', () => { if(this._allWindowsMenuItem.menu._getMenuItems().length == 1) // It's still counting the item just going to be destroyed this._allWindowsMenuItem.setSensitive(false); }); } } } }; // Filter out unnecessary windows, for instance // nautilus desktop window. function getInterestingWindows(windows, monitorIndex) { let settings = Docking.DockManager.settings; // When using workspace isolation, we filter out windows // that are not in the current workspace if (settings.get_boolean('isolate-workspaces')) windows = windows.filter(function(w) { return w.get_workspace().index() == global.workspace_manager.get_active_workspace_index(); }); if (settings.get_boolean('isolate-monitors')) windows = windows.filter(function(w) { return w.get_monitor() == monitorIndex; }); return windows; } /** * A ShowAppsIcon improved class. * * - set label position based on dash orientation (Note, I am reusing most machinery of the appIcon class) * - implement a popupMenu based on the AppIcon code (Note, I am reusing most machinery of the appIcon class) * */ var DockShowAppsIcon = GObject.registerClass({ Signals: { 'menu-state-changed': { param_types: [GObject.TYPE_BOOLEAN] }, 'sync-tooltip': {} } } , class DockShowAppsIcon extends Dash.ShowAppsIcon { _init() { super._init(); // Re-use appIcon methods let appIconPrototype = AppDisplay.AppIcon.prototype; this.toggleButton.y_expand = false; this.toggleButton.connect('popup-menu', appIconPrototype._onKeyboardPopupMenu.bind(this)); this.toggleButton.connect('clicked', this._removeMenuTimeout.bind(this)); this.reactive = true; this.toggleButton.popupMenu = () => this.popupMenu.call(this); this.toggleButton._removeMenuTimeout = () => this._removeMenuTimeout.call(this); this._menu = null; this._menuManager = new PopupMenu.PopupMenuManager(this); this._menuTimeoutId = 0; } vfunc_leave_event(leaveEvent) { return AppDisplay.AppIcon.prototype.vfunc_leave_event.call( this.toggleButton, leaveEvent); } vfunc_button_press_event(buttonPressEvent) { return AppDisplay.AppIcon.prototype.vfunc_button_press_event.call( this.toggleButton, buttonPressEvent); } vfunc_touch_event(touchEvent) { return AppDisplay.AppIcon.prototype.vfunc_touch_event.call( this.toggleButton, touchEvent); } showLabel() { itemShowLabel.call(this); } _onMenuPoppedDown() { AppDisplay.AppIcon.prototype._onMenuPoppedDown.apply(this, arguments); } _setPopupTimeout() { AppDisplay.AppIcon.prototype._onMenuPoppedDown.apply(this, arguments); } _removeMenuTimeout() { AppDisplay.AppIcon.prototype._removeMenuTimeout.apply(this, arguments); } popupMenu() { this._removeMenuTimeout(); this.toggleButton.fake_release(); if (!this._menu) { this._menu = new DockShowAppsIconMenu(this); this._menu.connect('open-state-changed', (menu, isPoppedUp) => { if (!isPoppedUp) this._onMenuPoppedDown(); }); let id = Main.overview.connect('hiding', () => { this._menu.close(); }); this._menu.actor.connect('destroy', function() { Main.overview.disconnect(id); }); this._menuManager.addMenu(this._menu); } this.emit('menu-state-changed', true); this.toggleButton.set_hover(true); this._menu.popup(); this._menuManager.ignoreRelease(); this.emit('sync-tooltip'); return false; } }); /** * A menu for the showAppsIcon */ class DockShowAppsIconMenu extends DockAppIconMenu { _rebuildMenu() { this.removeAll(); /* Translators: %s is "Settings", which is automatically translated. You can also translate the full message if this fits better your language. */ let name = __('Dash to Dock %s').format(_('Settings')) let item = this._appendMenuItem(name); item.connect('activate', function () { ExtensionUtils.openPrefs(); }); } }; /** * This function is used for both extendShowAppsIcon and extendDashItemContainer */ function itemShowLabel() { // Check if the label is still present at all. When switching workpaces, the // item might have been destroyed in between. if (!this._labelText || this.label.get_stage() == null) return; this.label.set_text(this._labelText); this.label.opacity = 0; this.label.show(); let [stageX, stageY] = this.get_transformed_position(); let node = this.label.get_theme_node(); let itemWidth = this.allocation.x2 - this.allocation.x1; let itemHeight = this.allocation.y2 - this.allocation.y1; let labelWidth = this.label.get_width(); let labelHeight = this.label.get_height(); let x, y, xOffset, yOffset; let position = Utils.getPosition(); this._isHorizontal = ((position == St.Side.TOP) || (position == St.Side.BOTTOM)); let labelOffset = node.get_length('-x-offset'); switch (position) { case St.Side.LEFT: yOffset = Math.floor((itemHeight - labelHeight) / 2); y = stageY + yOffset; xOffset = labelOffset; x = stageX + this.get_width() + xOffset; break; case St.Side.RIGHT: yOffset = Math.floor((itemHeight - labelHeight) / 2); y = stageY + yOffset; xOffset = labelOffset; x = Math.round(stageX) - labelWidth - xOffset; break; case St.Side.TOP: y = stageY + labelOffset + itemHeight; xOffset = Math.floor((itemWidth - labelWidth) / 2); x = stageX + xOffset; break; case St.Side.BOTTOM: yOffset = labelOffset; y = stageY - labelHeight - yOffset; xOffset = Math.floor((itemWidth - labelWidth) / 2); x = stageX + xOffset; break; } // keep the label inside the screen border // Only needed fot the x coordinate. // Leave a few pixel gap let gap = 5; let monitor = Main.layoutManager.findMonitorForActor(this); if (x - monitor.x < gap) x += monitor.x - x + labelOffset; else if (x + labelWidth > monitor.x + monitor.width - gap) x -= x + labelWidth - (monitor.x + monitor.width) + gap; this.label.remove_all_transitions(); this.label.set_position(x, y); this.label.ease({ opacity: 255, duration: Dash.DASH_ITEM_LABEL_SHOW_TIME, mode: Clutter.AnimationMode.EASE_OUT_QUAD }); }