2011-09-28 13:16:26 +00:00
|
|
|
// -*- mode: js; js-indent-level: 4; indent-tabs-mode: nil -*-
|
2019-01-31 14:07:06 +00:00
|
|
|
/* exported Panel */
|
2008-10-31 18:09:20 +00:00
|
|
|
|
2021-08-11 17:40:52 +00:00
|
|
|
const { Atk, Clutter, GLib, GObject, Meta, Shell, St } = imports.gi;
|
2008-10-31 18:09:20 +00:00
|
|
|
|
2013-06-18 11:35:41 +00:00
|
|
|
const Animation = imports.ui.animation;
|
2021-08-11 17:40:52 +00:00
|
|
|
const { AppMenu } = imports.ui.appMenu;
|
2012-08-28 21:10:44 +00:00
|
|
|
const Config = imports.misc.config;
|
2011-02-07 16:29:34 +00:00
|
|
|
const CtrlAltTab = imports.ui.ctrlAltTab;
|
2012-02-11 10:14:43 +00:00
|
|
|
const DND = imports.ui.dnd;
|
2010-05-12 21:07:41 +00:00
|
|
|
const Overview = imports.ui.overview;
|
2010-05-20 15:18:46 +00:00
|
|
|
const PopupMenu = imports.ui.popupMenu;
|
2010-06-22 21:02:26 +00:00
|
|
|
const PanelMenu = imports.ui.panelMenu;
|
2022-07-27 02:46:42 +00:00
|
|
|
const {QuickSettingsMenu, SystemIndicator} = imports.ui.quickSettings;
|
2008-11-09 18:01:59 +00:00
|
|
|
const Main = imports.ui.main;
|
2008-10-31 23:09:46 +00:00
|
|
|
|
2017-07-18 17:47:27 +00:00
|
|
|
var PANEL_ICON_SIZE = 16;
|
|
|
|
var APP_MENU_ICON_MARGIN = 0;
|
2009-08-11 15:32:58 +00:00
|
|
|
|
2017-07-18 17:47:27 +00:00
|
|
|
var BUTTON_DND_ACTIVATION_TIMEOUT = 250;
|
2011-01-05 14:47:27 +00:00
|
|
|
|
2022-07-24 17:49:58 +00:00
|
|
|
const N_QUICK_SETTINGS_COLUMNS = 2;
|
|
|
|
|
2009-12-26 17:00:36 +00:00
|
|
|
/**
|
2010-05-05 14:03:48 +00:00
|
|
|
* AppMenuButton:
|
2009-12-26 17:00:36 +00:00
|
|
|
*
|
|
|
|
* This class manages the "application menu" component. It tracks the
|
|
|
|
* currently focused application. However, when an app is launched,
|
|
|
|
* this menu also handles startup notification for it. So when we
|
|
|
|
* have an active startup notification, we switch modes to display that.
|
|
|
|
*/
|
2017-10-31 01:23:39 +00:00
|
|
|
var AppMenuButton = GObject.registerClass({
|
2019-01-29 01:27:05 +00:00
|
|
|
Signals: { 'changed': {} },
|
2017-10-31 01:23:39 +00:00
|
|
|
}, class AppMenuButton extends PanelMenu.Button {
|
2017-10-31 00:03:21 +00:00
|
|
|
_init(panel) {
|
2017-10-31 01:23:39 +00:00
|
|
|
super._init(0.0, null, true);
|
2011-05-15 16:55:23 +00:00
|
|
|
|
2019-04-09 23:17:51 +00:00
|
|
|
this.accessible_role = Atk.Role.MENU;
|
2012-02-27 16:31:10 +00:00
|
|
|
|
2010-10-06 21:31:22 +00:00
|
|
|
this._startingApps = [];
|
2009-08-11 15:32:58 +00:00
|
|
|
|
2012-08-28 21:10:44 +00:00
|
|
|
this._menuManager = panel.menuManager;
|
2010-10-06 21:31:22 +00:00
|
|
|
this._targetApp = null;
|
2009-08-11 15:32:58 +00:00
|
|
|
|
2010-05-05 14:03:48 +00:00
|
|
|
let bin = new St.Bin({ name: 'appMenu' });
|
2019-04-09 23:17:51 +00:00
|
|
|
this.add_actor(bin);
|
2011-03-08 17:46:43 +00:00
|
|
|
|
2019-04-09 23:17:51 +00:00
|
|
|
this.bind_property("reactive", this, "can-focus", 0);
|
|
|
|
this.reactive = false;
|
2011-03-08 17:46:43 +00:00
|
|
|
|
2014-11-11 15:30:11 +00:00
|
|
|
this._container = new St.BoxLayout({ style_class: 'panel-status-menu-box' });
|
2010-05-05 14:03:48 +00:00
|
|
|
bin.set_child(this._container);
|
2010-03-12 20:57:01 +00:00
|
|
|
|
2012-10-30 17:30:21 +00:00
|
|
|
let textureCache = St.TextureCache.get_default();
|
|
|
|
textureCache.connect('icon-theme-changed',
|
2017-12-02 00:27:35 +00:00
|
|
|
this._onIconThemeChanged.bind(this));
|
2012-10-30 17:30:21 +00:00
|
|
|
|
2019-02-04 23:30:41 +00:00
|
|
|
let iconEffect = new Clutter.DesaturateEffect();
|
2020-05-07 12:25:13 +00:00
|
|
|
this._iconBox = new St.Bin({
|
|
|
|
style_class: 'app-menu-icon',
|
|
|
|
y_align: Clutter.ActorAlign.CENTER,
|
|
|
|
});
|
2019-02-04 23:30:41 +00:00
|
|
|
this._iconBox.add_effect(iconEffect);
|
2010-02-28 20:36:13 +00:00
|
|
|
this._container.add_actor(this._iconBox);
|
2013-08-12 12:36:38 +00:00
|
|
|
|
2019-02-04 23:30:41 +00:00
|
|
|
this._iconBox.connect('style-changed', () => {
|
|
|
|
let themeNode = this._iconBox.get_theme_node();
|
|
|
|
iconEffect.enabled = themeNode.get_icon_style() == St.IconStyle.SYMBOLIC;
|
|
|
|
});
|
|
|
|
|
2020-03-29 21:51:13 +00:00
|
|
|
this._label = new St.Label({
|
|
|
|
y_expand: true,
|
|
|
|
y_align: Clutter.ActorAlign.CENTER,
|
|
|
|
});
|
2015-02-18 20:39:33 +00:00
|
|
|
this._container.add_actor(this._label);
|
2011-03-29 09:49:50 +00:00
|
|
|
|
2018-10-04 14:52:34 +00:00
|
|
|
this._visible = !Main.overview.visible;
|
2010-05-12 21:30:14 +00:00
|
|
|
if (!this._visible)
|
2018-07-06 08:48:15 +00:00
|
|
|
this.hide();
|
2021-08-15 22:36:59 +00:00
|
|
|
Main.overview.connectObject(
|
|
|
|
'hiding', this._sync.bind(this),
|
|
|
|
'showing', this._sync.bind(this), this);
|
2009-08-11 15:32:58 +00:00
|
|
|
|
2019-11-18 20:18:29 +00:00
|
|
|
this._spinner = new Animation.Spinner(PANEL_ICON_SIZE, {
|
|
|
|
animate: true,
|
2019-11-18 20:25:59 +00:00
|
|
|
hideOnStop: true,
|
2019-11-18 20:18:29 +00:00
|
|
|
});
|
2019-07-16 09:24:13 +00:00
|
|
|
this._container.add_actor(this._spinner);
|
2010-06-10 12:07:33 +00:00
|
|
|
|
2018-10-04 14:52:34 +00:00
|
|
|
let menu = new AppMenu(this);
|
|
|
|
this.setMenu(menu);
|
|
|
|
this._menuManager.addMenu(menu);
|
|
|
|
|
2021-08-15 22:36:59 +00:00
|
|
|
Shell.WindowTracker.get_default().connectObject('notify::focus-app',
|
|
|
|
this._focusAppChanged.bind(this), this);
|
|
|
|
Shell.AppSystem.get_default().connectObject('app-state-changed',
|
|
|
|
this._onAppStateChanged.bind(this), this);
|
|
|
|
global.window_manager.connectObject('switch-workspace',
|
|
|
|
this._sync.bind(this), this);
|
2010-10-06 21:31:22 +00:00
|
|
|
|
2009-08-11 15:32:58 +00:00
|
|
|
this._sync();
|
2017-10-31 01:23:39 +00:00
|
|
|
}
|
2010-05-12 21:30:14 +00:00
|
|
|
|
2018-08-21 09:48:19 +00:00
|
|
|
fadeIn() {
|
2013-01-27 14:45:04 +00:00
|
|
|
if (this._visible)
|
2010-05-12 21:30:14 +00:00
|
|
|
return;
|
|
|
|
|
2011-02-16 20:17:46 +00:00
|
|
|
this._visible = true;
|
2019-04-09 23:17:51 +00:00
|
|
|
this.reactive = true;
|
2018-07-20 19:46:19 +00:00
|
|
|
this.remove_all_transitions();
|
|
|
|
this.ease({
|
|
|
|
opacity: 255,
|
|
|
|
duration: Overview.ANIMATION_TIME,
|
2019-08-20 21:43:54 +00:00
|
|
|
mode: Clutter.AnimationMode.EASE_OUT_QUAD,
|
2018-07-20 19:46:19 +00:00
|
|
|
});
|
2017-10-31 01:23:39 +00:00
|
|
|
}
|
2010-05-12 21:30:14 +00:00
|
|
|
|
2018-08-21 09:48:19 +00:00
|
|
|
fadeOut() {
|
2010-05-12 21:30:14 +00:00
|
|
|
if (!this._visible)
|
|
|
|
return;
|
|
|
|
|
2011-02-16 20:17:46 +00:00
|
|
|
this._visible = false;
|
2019-04-09 23:17:51 +00:00
|
|
|
this.reactive = false;
|
2018-07-20 19:46:19 +00:00
|
|
|
this.remove_all_transitions();
|
|
|
|
this.ease({
|
|
|
|
opacity: 0,
|
2020-04-15 09:16:32 +00:00
|
|
|
mode: Clutter.AnimationMode.EASE_OUT_QUAD,
|
2018-07-20 19:46:19 +00:00
|
|
|
duration: Overview.ANIMATION_TIME,
|
|
|
|
});
|
2017-10-31 01:23:39 +00:00
|
|
|
}
|
2009-08-11 15:32:58 +00:00
|
|
|
|
2021-03-01 09:07:27 +00:00
|
|
|
_syncIcon(app) {
|
|
|
|
const icon = app.create_icon_texture(PANEL_ICON_SIZE - APP_MENU_ICON_MARGIN);
|
2013-07-19 19:39:48 +00:00
|
|
|
this._iconBox.set_child(icon);
|
2017-10-31 01:23:39 +00:00
|
|
|
}
|
2013-07-19 19:39:48 +00:00
|
|
|
|
2017-10-31 00:03:21 +00:00
|
|
|
_onIconThemeChanged() {
|
2012-10-30 17:30:21 +00:00
|
|
|
if (this._iconBox.child == null)
|
|
|
|
return;
|
|
|
|
|
2021-03-01 09:07:27 +00:00
|
|
|
if (this._targetApp)
|
|
|
|
this._syncIcon(this._targetApp);
|
2017-10-31 01:23:39 +00:00
|
|
|
}
|
2012-10-30 17:30:21 +00:00
|
|
|
|
2017-10-31 00:03:21 +00:00
|
|
|
stopAnimation() {
|
2019-07-22 14:46:40 +00:00
|
|
|
this._spinner.stop();
|
2017-10-31 01:23:39 +00:00
|
|
|
}
|
2010-06-10 12:07:33 +00:00
|
|
|
|
2017-10-31 00:03:21 +00:00
|
|
|
startAnimation() {
|
2012-11-05 22:11:27 +00:00
|
|
|
this._spinner.play();
|
2017-10-31 01:23:39 +00:00
|
|
|
}
|
2010-06-10 12:07:33 +00:00
|
|
|
|
2017-10-31 00:03:21 +00:00
|
|
|
_onAppStateChanged(appSys, app) {
|
2010-06-10 12:07:33 +00:00
|
|
|
let state = app.state;
|
2017-10-31 00:38:18 +00:00
|
|
|
if (state != Shell.AppState.STARTING)
|
|
|
|
this._startingApps = this._startingApps.filter(a => a != app);
|
|
|
|
else if (state == Shell.AppState.STARTING)
|
2010-10-06 21:31:22 +00:00
|
|
|
this._startingApps.push(app);
|
2010-06-10 12:07:33 +00:00
|
|
|
// For now just resync on all running state changes; this is mainly to handle
|
|
|
|
// cases where the focused window's application changes without the focus
|
|
|
|
// changing. An example case is how we map OpenOffice.org based on the window
|
|
|
|
// title which is a dynamic property.
|
|
|
|
this._sync();
|
2017-10-31 01:23:39 +00:00
|
|
|
}
|
2010-06-10 12:07:33 +00:00
|
|
|
|
2017-10-31 00:03:21 +00:00
|
|
|
_focusAppChanged() {
|
2009-10-15 23:28:29 +00:00
|
|
|
let tracker = Shell.WindowTracker.get_default();
|
|
|
|
let focusedApp = tracker.focus_app;
|
2010-07-02 19:36:56 +00:00
|
|
|
if (!focusedApp) {
|
|
|
|
// If the app has just lost focus to the panel, pretend
|
|
|
|
// nothing happened; otherwise you can't keynav to the
|
|
|
|
// app menu.
|
Rework window / actor focus handling
The duality of the Clutter's key focus and mutter's window focus has long been
a problem for us in lots of case, and caused us to create large and complicated
hacks to get around the issue, including GrabHelper's focus grab model.
Instead of doing this, tie basic focus management into the core of gnome-shell,
instead of requiring complex "application-level" management to get it done
right.
Do this by making sure that only one of an actor or window can be focused at
the same time, and apply the appropriate logic to drop one or the other,
reactively.
Modals are considered a special case, as we grab all keyboard events, but at
the X level, the client window still has focus. Make sure to not do any input
synchronization when we have a modal.
At the same time, remove the FOCUSED input mode, as it's no longer necessary.
https://bugzilla.gnome.org/show_bug.cgi?id=700735
2013-05-18 04:18:13 +00:00
|
|
|
if (global.stage.key_focus != null)
|
2010-07-02 19:36:56 +00:00
|
|
|
return;
|
|
|
|
}
|
2012-03-13 18:20:37 +00:00
|
|
|
this._sync();
|
2017-10-31 01:23:39 +00:00
|
|
|
}
|
2012-03-13 18:20:37 +00:00
|
|
|
|
2017-10-31 00:03:21 +00:00
|
|
|
_findTargetApp() {
|
2018-01-03 07:55:38 +00:00
|
|
|
let workspaceManager = global.workspace_manager;
|
|
|
|
let workspace = workspaceManager.get_active_workspace();
|
2012-03-13 18:20:37 +00:00
|
|
|
let tracker = Shell.WindowTracker.get_default();
|
|
|
|
let focusedApp = tracker.focus_app;
|
2013-08-13 11:41:44 +00:00
|
|
|
if (focusedApp && focusedApp.is_on_workspace(workspace))
|
|
|
|
return focusedApp;
|
|
|
|
|
2019-08-20 00:51:42 +00:00
|
|
|
for (let i = 0; i < this._startingApps.length; i++) {
|
2012-03-13 18:20:37 +00:00
|
|
|
if (this._startingApps[i].is_on_workspace(workspace))
|
2013-08-13 11:41:44 +00:00
|
|
|
return this._startingApps[i];
|
2019-08-20 00:51:42 +00:00
|
|
|
}
|
2010-07-02 19:36:56 +00:00
|
|
|
|
2013-08-13 11:41:44 +00:00
|
|
|
return null;
|
2017-10-31 01:23:39 +00:00
|
|
|
}
|
2011-03-08 17:46:43 +00:00
|
|
|
|
2017-10-31 00:03:21 +00:00
|
|
|
_sync() {
|
2013-08-13 11:41:44 +00:00
|
|
|
let targetApp = this._findTargetApp();
|
2011-11-16 00:12:58 +00:00
|
|
|
|
2013-08-13 11:41:44 +00:00
|
|
|
if (this._targetApp != targetApp) {
|
2021-08-15 22:36:59 +00:00
|
|
|
this._targetApp?.disconnectObject(this);
|
2011-03-08 17:46:43 +00:00
|
|
|
|
2013-08-13 11:41:44 +00:00
|
|
|
this._targetApp = targetApp;
|
2011-03-08 17:46:43 +00:00
|
|
|
|
2013-08-13 11:41:44 +00:00
|
|
|
if (this._targetApp) {
|
2021-08-15 22:36:59 +00:00
|
|
|
this._targetApp.connectObject('notify::busy', this._sync.bind(this), this);
|
2015-02-18 20:39:33 +00:00
|
|
|
this._label.set_text(this._targetApp.get_name());
|
2019-04-09 23:17:51 +00:00
|
|
|
this.set_accessible_name(this._targetApp.get_name());
|
2021-03-01 09:07:27 +00:00
|
|
|
|
|
|
|
this._syncIcon(this._targetApp);
|
2011-05-15 16:55:23 +00:00
|
|
|
}
|
2011-03-08 17:46:43 +00:00
|
|
|
}
|
|
|
|
|
2019-08-19 19:38:51 +00:00
|
|
|
let visible = this._targetApp != null && !Main.overview.visibleTarget;
|
2013-08-13 11:41:44 +00:00
|
|
|
if (visible)
|
2018-08-21 09:48:19 +00:00
|
|
|
this.fadeIn();
|
2013-08-13 11:41:44 +00:00
|
|
|
else
|
2018-08-21 09:48:19 +00:00
|
|
|
this.fadeOut();
|
2010-06-10 12:07:33 +00:00
|
|
|
|
2019-08-19 19:38:51 +00:00
|
|
|
let isBusy = this._targetApp != null &&
|
2013-08-13 11:41:44 +00:00
|
|
|
(this._targetApp.get_state() == Shell.AppState.STARTING ||
|
2019-08-19 19:38:51 +00:00
|
|
|
this._targetApp.get_busy());
|
2013-08-13 11:41:44 +00:00
|
|
|
if (isBusy)
|
2011-03-08 17:46:43 +00:00
|
|
|
this.startAnimation();
|
2011-05-15 16:55:23 +00:00
|
|
|
else
|
2013-08-13 11:41:44 +00:00
|
|
|
this.stopAnimation();
|
2009-08-11 15:32:58 +00:00
|
|
|
|
2019-08-19 19:38:51 +00:00
|
|
|
this.reactive = visible && !isBusy;
|
2013-08-13 11:41:44 +00:00
|
|
|
|
2018-10-04 14:52:34 +00:00
|
|
|
this.menu.setApp(this._targetApp);
|
2009-08-11 15:32:58 +00:00
|
|
|
this.emit('changed');
|
2017-10-31 01:23:39 +00:00
|
|
|
}
|
2011-11-20 14:38:48 +00:00
|
|
|
});
|
2009-08-11 15:32:58 +00:00
|
|
|
|
2017-10-31 01:23:39 +00:00
|
|
|
var ActivitiesButton = GObject.registerClass(
|
|
|
|
class ActivitiesButton extends PanelMenu.Button {
|
2017-10-31 00:03:21 +00:00
|
|
|
_init() {
|
2017-10-31 01:23:39 +00:00
|
|
|
super._init(0.0, null, true);
|
2019-04-09 23:17:51 +00:00
|
|
|
this.accessible_role = Atk.Role.TOGGLE_BUTTON;
|
2011-07-14 12:56:14 +00:00
|
|
|
|
2019-04-09 23:17:51 +00:00
|
|
|
this.name = 'panelActivities';
|
2011-07-14 12:35:55 +00:00
|
|
|
|
2011-07-14 12:53:44 +00:00
|
|
|
/* Translators: If there is no suitable word for "Activities"
|
|
|
|
in your language, you can use the word for "Overview". */
|
2020-03-29 21:51:13 +00:00
|
|
|
this._label = new St.Label({
|
|
|
|
text: _('Activities'),
|
|
|
|
y_align: Clutter.ActorAlign.CENTER,
|
|
|
|
});
|
2019-04-09 23:17:51 +00:00
|
|
|
this.add_actor(this._label);
|
2011-07-14 12:35:55 +00:00
|
|
|
|
2019-04-09 23:17:51 +00:00
|
|
|
this.label_actor = this._label;
|
2012-02-17 17:16:53 +00:00
|
|
|
|
2017-10-31 00:38:18 +00:00
|
|
|
Main.overview.connect('showing', () => {
|
2019-04-09 23:17:51 +00:00
|
|
|
this.add_style_pseudo_class('overview');
|
2019-08-19 17:55:49 +00:00
|
|
|
this.add_accessible_state(Atk.StateType.CHECKED);
|
2017-10-31 00:38:18 +00:00
|
|
|
});
|
|
|
|
Main.overview.connect('hiding', () => {
|
2019-04-09 23:17:51 +00:00
|
|
|
this.remove_style_pseudo_class('overview');
|
2019-08-19 17:55:49 +00:00
|
|
|
this.remove_accessible_state(Atk.StateType.CHECKED);
|
2017-10-31 00:38:18 +00:00
|
|
|
});
|
2011-07-14 12:53:44 +00:00
|
|
|
|
|
|
|
this._xdndTimeOut = 0;
|
2017-10-31 01:23:39 +00:00
|
|
|
}
|
2011-07-14 12:53:44 +00:00
|
|
|
|
2019-01-31 14:08:10 +00:00
|
|
|
handleDragOver(source, _actor, _x, _y, _time) {
|
2011-07-14 12:53:44 +00:00
|
|
|
if (source != Main.xdndHandler)
|
2012-02-11 10:14:43 +00:00
|
|
|
return DND.DragMotionResult.CONTINUE;
|
2011-07-14 12:53:44 +00:00
|
|
|
|
|
|
|
if (this._xdndTimeOut != 0)
|
2019-08-19 18:50:33 +00:00
|
|
|
GLib.source_remove(this._xdndTimeOut);
|
|
|
|
this._xdndTimeOut = GLib.timeout_add(GLib.PRIORITY_DEFAULT, BUTTON_DND_ACTIVATION_TIMEOUT, () => {
|
2019-01-31 14:08:10 +00:00
|
|
|
this._xdndToggleOverview();
|
2017-12-02 00:27:35 +00:00
|
|
|
});
|
2014-04-10 17:26:52 +00:00
|
|
|
GLib.Source.set_name_by_id(this._xdndTimeOut, '[gnome-shell] this._xdndToggleOverview');
|
2012-02-11 10:14:43 +00:00
|
|
|
|
|
|
|
return DND.DragMotionResult.CONTINUE;
|
2017-10-31 01:23:39 +00:00
|
|
|
}
|
2011-07-14 12:53:44 +00:00
|
|
|
|
2019-09-10 05:42:48 +00:00
|
|
|
vfunc_event(event) {
|
2014-07-31 15:26:47 +00:00
|
|
|
if (event.type() == Clutter.EventType.TOUCH_END ||
|
2019-08-20 00:51:42 +00:00
|
|
|
event.type() == Clutter.EventType.BUTTON_RELEASE) {
|
2015-10-22 16:12:28 +00:00
|
|
|
if (Main.overview.shouldToggleByCornerOrButton())
|
|
|
|
Main.overview.toggle();
|
2019-08-20 00:51:42 +00:00
|
|
|
}
|
2014-07-31 15:26:47 +00:00
|
|
|
|
2013-11-29 18:17:34 +00:00
|
|
|
return Clutter.EVENT_PROPAGATE;
|
2017-10-31 01:23:39 +00:00
|
|
|
}
|
2011-07-14 12:56:14 +00:00
|
|
|
|
2019-09-10 05:42:48 +00:00
|
|
|
vfunc_key_release_event(keyEvent) {
|
2019-11-04 10:18:25 +00:00
|
|
|
let symbol = keyEvent.keyval;
|
|
|
|
if (symbol == Clutter.KEY_Return || symbol == Clutter.KEY_space) {
|
|
|
|
if (Main.overview.shouldToggleByCornerOrButton()) {
|
|
|
|
Main.overview.toggle();
|
|
|
|
return Clutter.EVENT_STOP;
|
2019-09-10 05:42:48 +00:00
|
|
|
}
|
2011-07-14 12:56:14 +00:00
|
|
|
}
|
2019-11-04 10:18:25 +00:00
|
|
|
|
|
|
|
return Clutter.EVENT_PROPAGATE;
|
2017-10-31 01:23:39 +00:00
|
|
|
}
|
2011-07-14 12:56:14 +00:00
|
|
|
|
2019-02-04 11:30:53 +00:00
|
|
|
_xdndToggleOverview() {
|
2019-02-01 13:41:55 +00:00
|
|
|
let [x, y] = global.get_pointer();
|
2011-07-14 12:53:44 +00:00
|
|
|
let pickedActor = global.stage.get_actor_at_pos(Clutter.PickMode.REACTIVE, x, y);
|
|
|
|
|
2019-04-09 23:17:51 +00:00
|
|
|
if (pickedActor == this && Main.overview.shouldToggleByCornerOrButton())
|
2013-03-04 22:02:02 +00:00
|
|
|
Main.overview.toggle();
|
2011-07-14 12:53:44 +00:00
|
|
|
|
2019-08-19 18:50:33 +00:00
|
|
|
GLib.source_remove(this._xdndTimeOut);
|
2011-07-14 12:53:44 +00:00
|
|
|
this._xdndTimeOut = 0;
|
2013-11-29 00:45:39 +00:00
|
|
|
return GLib.SOURCE_REMOVE;
|
2011-07-14 12:53:44 +00:00
|
|
|
}
|
2011-11-20 17:56:27 +00:00
|
|
|
});
|
2011-02-09 02:12:10 +00:00
|
|
|
|
2021-09-02 15:15:36 +00:00
|
|
|
const UnsafeModeIndicator = GObject.registerClass(
|
2022-07-27 02:46:42 +00:00
|
|
|
class UnsafeModeIndicator extends SystemIndicator {
|
2021-09-02 15:15:36 +00:00
|
|
|
_init() {
|
|
|
|
super._init();
|
|
|
|
|
|
|
|
this._indicator = this._addIndicator();
|
|
|
|
this._indicator.icon_name = 'channel-insecure-symbolic';
|
|
|
|
|
|
|
|
global.context.bind_property('unsafe-mode',
|
|
|
|
this._indicator, 'visible',
|
|
|
|
GObject.BindingFlags.SYNC_CREATE);
|
|
|
|
}
|
|
|
|
});
|
|
|
|
|
2022-07-24 17:49:58 +00:00
|
|
|
var QuickSettings = GObject.registerClass(
|
|
|
|
class QuickSettings extends PanelMenu.Button {
|
|
|
|
_init() {
|
|
|
|
super._init(0.0, C_('System menu in the top bar', 'System'), true);
|
|
|
|
|
|
|
|
this._indicators = new St.BoxLayout({
|
|
|
|
style_class: 'panel-status-indicators-box',
|
|
|
|
});
|
|
|
|
this.add_child(this._indicators);
|
|
|
|
|
|
|
|
this.setMenu(new QuickSettingsMenu(this, N_QUICK_SETTINGS_COLUMNS));
|
2022-07-27 02:46:42 +00:00
|
|
|
|
2022-08-03 04:03:40 +00:00
|
|
|
if (Config.HAVE_NETWORKMANAGER)
|
|
|
|
this._network = new imports.ui.status.network.Indicator();
|
|
|
|
else
|
|
|
|
this._network = null;
|
|
|
|
|
2022-07-26 08:45:35 +00:00
|
|
|
if (Config.HAVE_BLUETOOTH)
|
|
|
|
this._bluetooth = new imports.ui.status.bluetooth.Indicator();
|
|
|
|
else
|
|
|
|
this._bluetooth = null;
|
|
|
|
|
2022-07-30 00:17:15 +00:00
|
|
|
this._system = new imports.ui.status.system.Indicator();
|
2022-07-29 23:37:07 +00:00
|
|
|
this._volume = new imports.ui.status.volume.Indicator();
|
2022-07-29 22:41:00 +00:00
|
|
|
this._brightness = new imports.ui.status.brightness.Indicator();
|
2022-07-27 10:54:24 +00:00
|
|
|
this._remoteAccess = new imports.ui.status.remoteAccess.RemoteAccessApplet();
|
2022-07-27 02:43:39 +00:00
|
|
|
this._location = new imports.ui.status.location.Indicator();
|
2022-07-27 02:01:53 +00:00
|
|
|
this._thunderbolt = new imports.ui.status.thunderbolt.Indicator();
|
2022-07-24 18:18:55 +00:00
|
|
|
this._nightLight = new imports.ui.status.nightLight.Indicator();
|
2022-07-27 01:38:28 +00:00
|
|
|
this._darkMode = new imports.ui.status.darkMode.Indicator();
|
2022-07-29 16:50:57 +00:00
|
|
|
this._powerProfiles = new imports.ui.status.powerProfiles.Indicator();
|
2022-07-24 18:45:45 +00:00
|
|
|
this._rfkill = new imports.ui.status.rfkill.Indicator();
|
2022-07-27 01:46:43 +00:00
|
|
|
this._autoRotate = new imports.ui.status.autoRotate.Indicator();
|
2022-07-27 02:46:42 +00:00
|
|
|
this._unsafeMode = new UnsafeModeIndicator();
|
2023-02-02 18:58:43 +00:00
|
|
|
this._backgroundApps = new imports.ui.status.backgroundApps.Indicator();
|
2022-07-27 02:46:42 +00:00
|
|
|
|
2022-07-29 22:41:00 +00:00
|
|
|
this._indicators.add_child(this._brightness);
|
2022-07-27 10:54:24 +00:00
|
|
|
this._indicators.add_child(this._remoteAccess);
|
2022-07-27 02:01:53 +00:00
|
|
|
this._indicators.add_child(this._thunderbolt);
|
2022-07-27 02:43:39 +00:00
|
|
|
this._indicators.add_child(this._location);
|
2022-07-24 18:18:55 +00:00
|
|
|
this._indicators.add_child(this._nightLight);
|
2022-08-03 04:03:40 +00:00
|
|
|
if (this._network)
|
|
|
|
this._indicators.add_child(this._network);
|
2022-07-27 01:38:28 +00:00
|
|
|
this._indicators.add_child(this._darkMode);
|
2022-07-29 16:50:57 +00:00
|
|
|
this._indicators.add_child(this._powerProfiles);
|
2022-07-26 08:45:35 +00:00
|
|
|
if (this._bluetooth)
|
|
|
|
this._indicators.add_child(this._bluetooth);
|
2022-07-24 18:45:45 +00:00
|
|
|
this._indicators.add_child(this._rfkill);
|
2022-07-27 01:46:43 +00:00
|
|
|
this._indicators.add_child(this._autoRotate);
|
2022-07-29 23:37:07 +00:00
|
|
|
this._indicators.add_child(this._volume);
|
2022-07-27 02:46:42 +00:00
|
|
|
this._indicators.add_child(this._unsafeMode);
|
2022-07-30 00:17:15 +00:00
|
|
|
this._indicators.add_child(this._system);
|
2022-07-27 02:46:42 +00:00
|
|
|
|
2022-07-30 00:17:15 +00:00
|
|
|
this._addItems(this._system.quickSettingsItems, N_QUICK_SETTINGS_COLUMNS);
|
2022-07-29 23:37:07 +00:00
|
|
|
this._addItems(this._volume.quickSettingsItems, N_QUICK_SETTINGS_COLUMNS);
|
2022-07-29 22:41:00 +00:00
|
|
|
this._addItems(this._brightness.quickSettingsItems, N_QUICK_SETTINGS_COLUMNS);
|
|
|
|
|
2022-07-27 10:54:24 +00:00
|
|
|
this._addItems(this._remoteAccess.quickSettingsItems);
|
2022-07-27 02:01:53 +00:00
|
|
|
this._addItems(this._thunderbolt.quickSettingsItems);
|
2022-07-27 02:43:39 +00:00
|
|
|
this._addItems(this._location.quickSettingsItems);
|
2022-08-03 04:03:40 +00:00
|
|
|
if (this._network)
|
|
|
|
this._addItems(this._network.quickSettingsItems);
|
2022-07-26 08:45:35 +00:00
|
|
|
if (this._bluetooth)
|
|
|
|
this._addItems(this._bluetooth.quickSettingsItems);
|
2022-07-29 16:50:57 +00:00
|
|
|
this._addItems(this._powerProfiles.quickSettingsItems);
|
2022-07-24 18:18:55 +00:00
|
|
|
this._addItems(this._nightLight.quickSettingsItems);
|
2022-07-27 01:38:28 +00:00
|
|
|
this._addItems(this._darkMode.quickSettingsItems);
|
2022-07-24 18:45:45 +00:00
|
|
|
this._addItems(this._rfkill.quickSettingsItems);
|
2022-07-27 01:46:43 +00:00
|
|
|
this._addItems(this._autoRotate.quickSettingsItems);
|
2022-07-27 02:46:42 +00:00
|
|
|
this._addItems(this._unsafeMode.quickSettingsItems);
|
2023-02-02 18:58:43 +00:00
|
|
|
|
|
|
|
this._addItems(this._backgroundApps.quickSettingsItems, N_QUICK_SETTINGS_COLUMNS);
|
2022-07-24 17:49:58 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
_addItems(items, colSpan = 1) {
|
|
|
|
items.forEach(item => this.menu.addItem(item, colSpan));
|
|
|
|
}
|
|
|
|
});
|
|
|
|
|
2012-08-28 21:10:44 +00:00
|
|
|
const PANEL_ITEM_IMPLEMENTATIONS = {
|
|
|
|
'activities': ActivitiesButton,
|
|
|
|
'appMenu': AppMenuButton,
|
2022-07-24 17:49:58 +00:00
|
|
|
'quickSettings': QuickSettings,
|
2012-08-28 21:10:44 +00:00
|
|
|
'dateMenu': imports.ui.dateMenu.DateMenuButton,
|
|
|
|
'a11y': imports.ui.status.accessibility.ATIndicator,
|
|
|
|
'keyboard': imports.ui.status.keyboard.InputSourceIndicator,
|
2019-03-20 16:46:12 +00:00
|
|
|
'dwellClick': imports.ui.status.dwellClick.DwellClickIndicator,
|
2022-02-08 16:18:01 +00:00
|
|
|
'screenRecording': imports.ui.status.remoteAccess.ScreenRecordingIndicator,
|
2022-07-27 10:29:26 +00:00
|
|
|
'screenSharing': imports.ui.status.remoteAccess.ScreenSharingIndicator,
|
2012-08-28 21:10:44 +00:00
|
|
|
};
|
|
|
|
|
2017-10-31 01:23:39 +00:00
|
|
|
var Panel = GObject.registerClass(
|
|
|
|
class Panel extends St.Widget {
|
2017-10-31 00:03:21 +00:00
|
|
|
_init() {
|
2020-03-29 21:51:13 +00:00
|
|
|
super._init({
|
|
|
|
name: 'panel',
|
|
|
|
reactive: true,
|
|
|
|
});
|
2018-06-27 19:02:15 +00:00
|
|
|
|
2020-02-26 03:53:40 +00:00
|
|
|
this.set_offscreen_redirect(Clutter.OffscreenRedirect.ALWAYS);
|
2009-11-10 17:13:58 +00:00
|
|
|
|
2012-09-21 20:19:27 +00:00
|
|
|
this._sessionStyle = null;
|
|
|
|
|
2012-08-26 14:05:46 +00:00
|
|
|
this.statusArea = {};
|
2011-04-06 13:26:15 +00:00
|
|
|
|
2015-02-23 19:07:04 +00:00
|
|
|
this.menuManager = new PopupMenu.PopupMenuManager(this);
|
2010-05-20 15:18:46 +00:00
|
|
|
|
2009-11-17 22:46:20 +00:00
|
|
|
this._leftBox = new St.BoxLayout({ name: 'panelLeft' });
|
2018-06-27 19:02:15 +00:00
|
|
|
this.add_child(this._leftBox);
|
2009-11-17 22:46:20 +00:00
|
|
|
this._centerBox = new St.BoxLayout({ name: 'panelCenter' });
|
2018-06-27 19:02:15 +00:00
|
|
|
this.add_child(this._centerBox);
|
2009-11-17 22:46:20 +00:00
|
|
|
this._rightBox = new St.BoxLayout({ name: 'panelRight' });
|
2018-06-27 19:02:15 +00:00
|
|
|
this.add_child(this._rightBox);
|
2009-08-11 15:16:25 +00:00
|
|
|
|
2022-03-05 21:47:54 +00:00
|
|
|
this.connect('button-press-event', this._onButtonPress.bind(this));
|
|
|
|
this.connect('touch-event', this._onTouchEvent.bind(this));
|
|
|
|
|
2017-10-31 00:38:18 +00:00
|
|
|
Main.overview.connect('showing', () => {
|
2018-06-27 19:02:15 +00:00
|
|
|
this.add_style_pseudo_class('overview');
|
2017-10-31 00:38:18 +00:00
|
|
|
});
|
|
|
|
Main.overview.connect('hiding', () => {
|
2018-06-27 19:02:15 +00:00
|
|
|
this.remove_style_pseudo_class('overview');
|
2017-10-31 00:38:18 +00:00
|
|
|
});
|
2013-02-05 14:24:46 +00:00
|
|
|
|
2018-06-27 19:02:15 +00:00
|
|
|
Main.layoutManager.panelBox.add(this);
|
|
|
|
Main.ctrlAltTabManager.addGroup(this, _("Top Bar"), 'focus-top-bar-symbolic',
|
2011-02-07 16:29:34 +00:00
|
|
|
{ sortGroup: CtrlAltTab.SortGroup.TOP });
|
2012-09-01 12:42:53 +00:00
|
|
|
|
2017-12-02 00:27:35 +00:00
|
|
|
Main.sessionMode.connect('updated', this._updatePanel.bind(this));
|
2016-09-23 19:08:11 +00:00
|
|
|
|
2019-01-28 00:42:00 +00:00
|
|
|
global.display.connect('workareas-changed', () => this.queue_relayout());
|
2012-09-01 12:42:53 +00:00
|
|
|
this._updatePanel();
|
2017-10-31 01:23:39 +00:00
|
|
|
}
|
2008-12-01 19:51:43 +00:00
|
|
|
|
2019-01-31 14:08:10 +00:00
|
|
|
vfunc_get_preferred_width(_forHeight) {
|
2017-04-12 06:46:54 +00:00
|
|
|
let primaryMonitor = Main.layoutManager.primaryMonitor;
|
|
|
|
|
|
|
|
if (primaryMonitor)
|
2018-06-27 19:02:15 +00:00
|
|
|
return [0, primaryMonitor.width];
|
2011-07-21 14:49:04 +00:00
|
|
|
|
2018-06-27 19:02:15 +00:00
|
|
|
return [0, 0];
|
2017-10-31 01:23:39 +00:00
|
|
|
}
|
2011-07-21 14:49:04 +00:00
|
|
|
|
2020-05-09 19:30:26 +00:00
|
|
|
vfunc_allocate(box) {
|
|
|
|
this.set_allocation(box);
|
2018-06-27 19:02:15 +00:00
|
|
|
|
2011-07-21 14:49:04 +00:00
|
|
|
let allocWidth = box.x2 - box.x1;
|
|
|
|
let allocHeight = box.y2 - box.y1;
|
|
|
|
|
2019-02-01 13:41:55 +00:00
|
|
|
let [, leftNaturalWidth] = this._leftBox.get_preferred_width(-1);
|
|
|
|
let [, centerNaturalWidth] = this._centerBox.get_preferred_width(-1);
|
|
|
|
let [, rightNaturalWidth] = this._rightBox.get_preferred_width(-1);
|
2011-07-21 14:49:04 +00:00
|
|
|
|
|
|
|
let sideWidth, centerWidth;
|
|
|
|
centerWidth = centerNaturalWidth;
|
2018-01-09 08:39:06 +00:00
|
|
|
|
|
|
|
// get workspace area and center date entry relative to it
|
2018-06-27 19:02:15 +00:00
|
|
|
let monitor = Main.layoutManager.findMonitorForActor(this);
|
2018-01-09 08:39:06 +00:00
|
|
|
let centerOffset = 0;
|
|
|
|
if (monitor) {
|
|
|
|
let workArea = Main.layoutManager.getWorkAreaForMonitor(monitor.index);
|
|
|
|
centerOffset = 2 * (workArea.x - monitor.x) + workArea.width - monitor.width;
|
|
|
|
}
|
|
|
|
|
|
|
|
sideWidth = Math.max(0, (allocWidth - centerWidth + centerOffset) / 2);
|
2011-07-21 14:49:04 +00:00
|
|
|
|
|
|
|
let childBox = new Clutter.ActorBox();
|
|
|
|
|
|
|
|
childBox.y1 = 0;
|
|
|
|
childBox.y2 = allocHeight;
|
2018-06-27 19:02:15 +00:00
|
|
|
if (this.get_text_direction() == Clutter.TextDirection.RTL) {
|
2017-04-12 06:46:54 +00:00
|
|
|
childBox.x1 = Math.max(allocWidth - Math.min(Math.floor(sideWidth),
|
|
|
|
leftNaturalWidth),
|
|
|
|
0);
|
2011-07-21 14:49:04 +00:00
|
|
|
childBox.x2 = allocWidth;
|
|
|
|
} else {
|
|
|
|
childBox.x1 = 0;
|
|
|
|
childBox.x2 = Math.min(Math.floor(sideWidth),
|
|
|
|
leftNaturalWidth);
|
|
|
|
}
|
2020-05-09 19:30:26 +00:00
|
|
|
this._leftBox.allocate(childBox);
|
2011-07-21 14:49:04 +00:00
|
|
|
|
|
|
|
childBox.x1 = Math.ceil(sideWidth);
|
|
|
|
childBox.y1 = 0;
|
|
|
|
childBox.x2 = childBox.x1 + centerWidth;
|
|
|
|
childBox.y2 = allocHeight;
|
2020-05-09 19:30:26 +00:00
|
|
|
this._centerBox.allocate(childBox);
|
2011-07-21 14:49:04 +00:00
|
|
|
|
|
|
|
childBox.y1 = 0;
|
|
|
|
childBox.y2 = allocHeight;
|
2018-06-27 19:02:15 +00:00
|
|
|
if (this.get_text_direction() == Clutter.TextDirection.RTL) {
|
2011-07-21 14:49:04 +00:00
|
|
|
childBox.x1 = 0;
|
|
|
|
childBox.x2 = Math.min(Math.floor(sideWidth),
|
|
|
|
rightNaturalWidth);
|
|
|
|
} else {
|
2017-04-12 06:46:54 +00:00
|
|
|
childBox.x1 = Math.max(allocWidth - Math.min(Math.floor(sideWidth),
|
|
|
|
rightNaturalWidth),
|
|
|
|
0);
|
2011-07-21 14:49:04 +00:00
|
|
|
childBox.x2 = allocWidth;
|
|
|
|
}
|
2020-05-09 19:30:26 +00:00
|
|
|
this._rightBox.allocate(childBox);
|
2017-10-31 01:23:39 +00:00
|
|
|
}
|
2011-07-21 14:49:04 +00:00
|
|
|
|
2019-09-10 05:42:48 +00:00
|
|
|
_tryDragWindow(event) {
|
2013-02-20 01:27:11 +00:00
|
|
|
if (Main.modalCount > 0)
|
2013-11-29 18:17:34 +00:00
|
|
|
return Clutter.EVENT_PROPAGATE;
|
2013-02-20 01:27:11 +00:00
|
|
|
|
2022-03-05 21:47:54 +00:00
|
|
|
const targetActor = global.stage.get_event_actor(event);
|
|
|
|
if (targetActor !== this)
|
2013-11-29 18:17:34 +00:00
|
|
|
return Clutter.EVENT_PROPAGATE;
|
2011-10-04 15:14:29 +00:00
|
|
|
|
2022-09-29 16:53:45 +00:00
|
|
|
const [x, y_] = event.get_coords();
|
2019-09-10 05:42:48 +00:00
|
|
|
let dragWindow = this._getDraggableWindowForPosition(x);
|
2018-05-24 15:28:36 +00:00
|
|
|
|
2019-09-10 05:42:48 +00:00
|
|
|
if (!dragWindow)
|
2013-11-29 18:17:34 +00:00
|
|
|
return Clutter.EVENT_PROPAGATE;
|
2011-10-04 15:14:29 +00:00
|
|
|
|
2022-09-29 16:53:45 +00:00
|
|
|
return dragWindow.begin_grab_op(
|
2019-09-10 05:42:48 +00:00
|
|
|
Meta.GrabOp.MOVING,
|
2022-10-21 18:21:13 +00:00
|
|
|
event.get_device(),
|
|
|
|
event.get_event_sequence(),
|
2022-09-29 16:53:45 +00:00
|
|
|
event.get_time()) ? Clutter.EVENT_STOP : Clutter.EVENT_PROPAGATE;
|
2019-09-10 05:42:48 +00:00
|
|
|
}
|
2011-10-04 15:14:29 +00:00
|
|
|
|
2022-03-05 21:47:54 +00:00
|
|
|
_onButtonPress(actor, event) {
|
|
|
|
if (event.get_button() !== Clutter.BUTTON_PRIMARY)
|
2013-11-29 18:17:34 +00:00
|
|
|
return Clutter.EVENT_PROPAGATE;
|
2011-10-04 15:14:29 +00:00
|
|
|
|
2022-03-05 21:47:54 +00:00
|
|
|
return this._tryDragWindow(event);
|
2019-09-10 05:42:48 +00:00
|
|
|
}
|
|
|
|
|
2022-03-05 21:47:54 +00:00
|
|
|
_onTouchEvent(actor, event) {
|
|
|
|
if (event.type() !== Clutter.EventType.TOUCH_BEGIN)
|
2019-09-10 05:42:48 +00:00
|
|
|
return Clutter.EVENT_PROPAGATE;
|
2011-10-04 15:14:29 +00:00
|
|
|
|
2022-03-05 21:47:54 +00:00
|
|
|
return this._tryDragWindow(event);
|
2017-10-31 01:23:39 +00:00
|
|
|
}
|
2011-10-04 15:14:29 +00:00
|
|
|
|
2019-09-10 05:42:48 +00:00
|
|
|
vfunc_key_press_event(keyEvent) {
|
|
|
|
let symbol = keyEvent.keyval;
|
2017-11-01 18:43:11 +00:00
|
|
|
if (symbol == Clutter.KEY_Escape) {
|
2019-09-10 05:42:48 +00:00
|
|
|
global.display.focus_default_window(keyEvent.time);
|
2017-11-01 18:43:11 +00:00
|
|
|
return Clutter.EVENT_STOP;
|
|
|
|
}
|
|
|
|
|
2020-03-26 22:40:38 +00:00
|
|
|
return super.vfunc_key_press_event(keyEvent);
|
2017-10-31 01:23:39 +00:00
|
|
|
}
|
2017-11-01 18:43:11 +00:00
|
|
|
|
2017-10-31 00:03:21 +00:00
|
|
|
_toggleMenu(indicator) {
|
2019-12-17 00:00:40 +00:00
|
|
|
if (!indicator || !indicator.mapped)
|
2019-01-23 22:55:12 +00:00
|
|
|
return; // menu not supported by current session mode
|
2012-08-28 21:10:44 +00:00
|
|
|
|
|
|
|
let menu = indicator.menu;
|
2019-04-09 23:17:51 +00:00
|
|
|
if (!indicator.reactive)
|
2012-05-18 14:04:47 +00:00
|
|
|
return;
|
2012-03-27 13:26:20 +00:00
|
|
|
|
2013-04-26 14:14:55 +00:00
|
|
|
menu.toggle();
|
|
|
|
if (menu.isOpen)
|
2018-11-27 12:58:25 +00:00
|
|
|
menu.actor.navigate_focus(null, St.DirectionType.TAB_FORWARD, false);
|
2017-10-31 01:23:39 +00:00
|
|
|
}
|
2012-03-27 13:26:20 +00:00
|
|
|
|
2022-07-30 00:24:17 +00:00
|
|
|
_closeMenu(indicator) {
|
|
|
|
if (!indicator || !indicator.mapped)
|
|
|
|
return; // menu not supported by current session mode
|
|
|
|
|
|
|
|
if (!indicator.reactive)
|
|
|
|
return;
|
|
|
|
|
|
|
|
indicator.menu.close();
|
|
|
|
}
|
|
|
|
|
2017-10-31 00:03:21 +00:00
|
|
|
toggleCalendar() {
|
2015-02-18 01:52:07 +00:00
|
|
|
this._toggleMenu(this.statusArea.dateMenu);
|
2017-10-31 01:23:39 +00:00
|
|
|
}
|
2015-02-18 01:52:07 +00:00
|
|
|
|
2017-10-31 00:03:21 +00:00
|
|
|
closeCalendar() {
|
2022-07-30 00:24:17 +00:00
|
|
|
this._closeMenu(this.statusArea.dateMenu);
|
|
|
|
}
|
2015-02-13 09:44:13 +00:00
|
|
|
|
2022-07-30 00:24:17 +00:00
|
|
|
closeQuickSettings() {
|
|
|
|
this._closeMenu(this.statusArea.quickSettings);
|
2017-10-31 01:23:39 +00:00
|
|
|
}
|
2015-02-13 09:44:13 +00:00
|
|
|
|
2012-09-01 12:42:53 +00:00
|
|
|
set boxOpacity(value) {
|
|
|
|
let isReactive = value > 0;
|
|
|
|
|
|
|
|
this._leftBox.opacity = value;
|
|
|
|
this._leftBox.reactive = isReactive;
|
|
|
|
this._centerBox.opacity = value;
|
|
|
|
this._centerBox.reactive = isReactive;
|
|
|
|
this._rightBox.opacity = value;
|
|
|
|
this._rightBox.reactive = isReactive;
|
2017-10-31 01:23:39 +00:00
|
|
|
}
|
2012-09-01 12:42:53 +00:00
|
|
|
|
|
|
|
get boxOpacity() {
|
|
|
|
return this._leftBox.opacity;
|
2017-10-31 01:23:39 +00:00
|
|
|
}
|
2012-09-01 12:42:53 +00:00
|
|
|
|
2017-10-31 00:03:21 +00:00
|
|
|
_updatePanel() {
|
2012-08-28 21:10:44 +00:00
|
|
|
let panel = Main.sessionMode.panel;
|
2012-09-01 12:42:53 +00:00
|
|
|
this._hideIndicators();
|
|
|
|
this._updateBox(panel.left, this._leftBox);
|
|
|
|
this._updateBox(panel.center, this._centerBox);
|
|
|
|
this._updateBox(panel.right, this._rightBox);
|
2012-09-21 20:19:27 +00:00
|
|
|
|
2018-07-14 20:56:22 +00:00
|
|
|
if (panel.left.includes('dateMenu'))
|
2015-04-23 10:43:03 +00:00
|
|
|
Main.messageTray.bannerAlignment = Clutter.ActorAlign.START;
|
2018-07-14 20:56:22 +00:00
|
|
|
else if (panel.right.includes('dateMenu'))
|
2015-04-23 10:43:03 +00:00
|
|
|
Main.messageTray.bannerAlignment = Clutter.ActorAlign.END;
|
|
|
|
// Default to center if there is no dateMenu
|
|
|
|
else
|
|
|
|
Main.messageTray.bannerAlignment = Clutter.ActorAlign.CENTER;
|
|
|
|
|
2012-09-21 20:19:27 +00:00
|
|
|
if (this._sessionStyle)
|
2022-02-02 22:19:12 +00:00
|
|
|
this.remove_style_class_name(this._sessionStyle);
|
2012-09-21 20:19:27 +00:00
|
|
|
|
|
|
|
this._sessionStyle = Main.sessionMode.panelStyle;
|
|
|
|
if (this._sessionStyle)
|
2022-02-02 22:19:12 +00:00
|
|
|
this.add_style_class_name(this._sessionStyle);
|
2017-10-31 01:23:39 +00:00
|
|
|
}
|
2012-08-28 21:10:44 +00:00
|
|
|
|
2017-10-31 00:03:21 +00:00
|
|
|
_hideIndicators() {
|
2012-09-01 12:42:53 +00:00
|
|
|
for (let role in PANEL_ITEM_IMPLEMENTATIONS) {
|
|
|
|
let indicator = this.statusArea[role];
|
|
|
|
if (!indicator)
|
|
|
|
continue;
|
2012-09-04 16:27:50 +00:00
|
|
|
indicator.container.hide();
|
2012-09-01 12:42:53 +00:00
|
|
|
}
|
2017-10-31 01:23:39 +00:00
|
|
|
}
|
2012-09-01 12:42:53 +00:00
|
|
|
|
2017-10-31 00:03:21 +00:00
|
|
|
_ensureIndicator(role) {
|
2012-09-01 12:42:53 +00:00
|
|
|
let indicator = this.statusArea[role];
|
|
|
|
if (!indicator) {
|
|
|
|
let constructor = PANEL_ITEM_IMPLEMENTATIONS[role];
|
|
|
|
if (!constructor) {
|
|
|
|
// This icon is not implemented (this is a bug)
|
|
|
|
return null;
|
|
|
|
}
|
|
|
|
indicator = new constructor(this);
|
|
|
|
this.statusArea[role] = indicator;
|
|
|
|
}
|
|
|
|
return indicator;
|
2017-10-31 01:23:39 +00:00
|
|
|
}
|
2012-09-01 12:42:53 +00:00
|
|
|
|
2017-10-31 00:03:21 +00:00
|
|
|
_updateBox(elements, box) {
|
2012-09-01 12:42:53 +00:00
|
|
|
let nChildren = box.get_n_children();
|
|
|
|
|
|
|
|
for (let i = 0; i < elements.length; i++) {
|
|
|
|
let role = elements[i];
|
|
|
|
let indicator = this._ensureIndicator(role);
|
|
|
|
if (indicator == null)
|
|
|
|
continue;
|
2011-04-06 13:26:15 +00:00
|
|
|
|
2012-09-01 12:42:53 +00:00
|
|
|
this._addToPanelBox(role, indicator, i + nChildren, box);
|
2010-07-24 11:57:53 +00:00
|
|
|
}
|
2017-10-31 01:23:39 +00:00
|
|
|
}
|
2010-07-24 11:57:53 +00:00
|
|
|
|
2017-10-31 00:03:21 +00:00
|
|
|
_addToPanelBox(role, indicator, position, box) {
|
2012-09-04 16:27:50 +00:00
|
|
|
let container = indicator.container;
|
2012-09-01 12:42:53 +00:00
|
|
|
container.show();
|
|
|
|
|
|
|
|
let parent = container.get_parent();
|
2012-09-04 16:27:50 +00:00
|
|
|
if (parent)
|
2012-09-01 12:42:53 +00:00
|
|
|
parent.remove_actor(container);
|
|
|
|
|
2015-04-23 16:43:58 +00:00
|
|
|
|
2012-09-01 12:42:53 +00:00
|
|
|
box.insert_child_at_index(container, position);
|
2012-08-28 21:10:44 +00:00
|
|
|
this.statusArea[role] = indicator;
|
2017-10-31 00:38:18 +00:00
|
|
|
let destroyId = indicator.connect('destroy', emitter => {
|
2012-08-28 21:10:44 +00:00
|
|
|
delete this.statusArea[role];
|
|
|
|
emitter.disconnect(destroyId);
|
2017-10-31 00:38:18 +00:00
|
|
|
});
|
2017-12-02 00:27:35 +00:00
|
|
|
indicator.connect('menu-set', this._onMenuSet.bind(this));
|
2015-04-28 09:05:58 +00:00
|
|
|
this._onMenuSet(indicator);
|
2017-10-31 01:23:39 +00:00
|
|
|
}
|
2011-08-25 15:46:25 +00:00
|
|
|
|
2017-10-31 00:03:21 +00:00
|
|
|
addToStatusArea(role, indicator, position, box) {
|
2012-08-26 14:05:46 +00:00
|
|
|
if (this.statusArea[role])
|
2022-02-07 14:14:06 +00:00
|
|
|
throw new Error(`Extension point conflict: there is already a status indicator for role ${role}`);
|
2011-08-22 21:19:13 +00:00
|
|
|
|
|
|
|
if (!(indicator instanceof PanelMenu.Button))
|
|
|
|
throw new TypeError('Status indicator must be an instance of PanelMenu.Button');
|
|
|
|
|
2022-01-18 20:02:04 +00:00
|
|
|
position ??= 0;
|
2012-08-28 21:10:44 +00:00
|
|
|
let boxes = {
|
|
|
|
left: this._leftBox,
|
|
|
|
center: this._centerBox,
|
2019-08-20 21:43:54 +00:00
|
|
|
right: this._rightBox,
|
2012-08-28 21:10:44 +00:00
|
|
|
};
|
|
|
|
let boxContainer = boxes[box] || this._rightBox;
|
2012-09-01 12:42:53 +00:00
|
|
|
this.statusArea[role] = indicator;
|
2012-08-28 21:10:44 +00:00
|
|
|
this._addToPanelBox(role, indicator, position, boxContainer);
|
2011-08-22 21:19:13 +00:00
|
|
|
return indicator;
|
2017-10-31 01:23:39 +00:00
|
|
|
}
|
2012-09-21 20:19:27 +00:00
|
|
|
|
2017-10-31 00:03:21 +00:00
|
|
|
_onMenuSet(indicator) {
|
2019-06-29 23:04:32 +00:00
|
|
|
if (!indicator.menu || indicator.menu._openChangedId)
|
2015-04-28 09:05:58 +00:00
|
|
|
return;
|
|
|
|
|
2022-09-05 00:21:29 +00:00
|
|
|
this.menuManager.addMenu(indicator.menu);
|
|
|
|
|
2015-04-28 09:05:58 +00:00
|
|
|
indicator.menu._openChangedId = indicator.menu.connect('open-state-changed',
|
2017-10-31 00:38:18 +00:00
|
|
|
(menu, isOpen) => {
|
2015-04-28 09:05:58 +00:00
|
|
|
let boxAlignment;
|
|
|
|
if (this._leftBox.contains(indicator.container))
|
|
|
|
boxAlignment = Clutter.ActorAlign.START;
|
|
|
|
else if (this._centerBox.contains(indicator.container))
|
|
|
|
boxAlignment = Clutter.ActorAlign.CENTER;
|
|
|
|
else if (this._rightBox.contains(indicator.container))
|
|
|
|
boxAlignment = Clutter.ActorAlign.END;
|
|
|
|
|
|
|
|
if (boxAlignment == Main.messageTray.bannerAlignment)
|
|
|
|
Main.messageTray.bannerBlocked = isOpen;
|
2017-10-31 00:38:18 +00:00
|
|
|
});
|
2012-09-01 12:42:53 +00:00
|
|
|
}
|
2018-02-05 18:46:22 +00:00
|
|
|
|
|
|
|
_getDraggableWindowForPosition(stageX) {
|
|
|
|
let workspaceManager = global.workspace_manager;
|
2020-04-03 23:52:29 +00:00
|
|
|
const windows = workspaceManager.get_active_workspace().list_windows();
|
|
|
|
const allWindowsByStacking =
|
|
|
|
global.display.sort_windows_by_stacking(windows).reverse();
|
2018-02-05 18:46:22 +00:00
|
|
|
|
|
|
|
return allWindowsByStacking.find(metaWindow => {
|
|
|
|
let rect = metaWindow.get_frame_rect();
|
|
|
|
return metaWindow.is_on_primary_monitor() &&
|
|
|
|
metaWindow.showing_on_its_workspace() &&
|
|
|
|
metaWindow.get_window_type() != Meta.WindowType.DESKTOP &&
|
|
|
|
metaWindow.maximized_vertically &&
|
2019-01-29 01:18:52 +00:00
|
|
|
stageX > rect.x && stageX < rect.x + rect.width;
|
2018-02-05 18:46:22 +00:00
|
|
|
});
|
|
|
|
}
|
2011-11-20 17:56:27 +00:00
|
|
|
});
|