multi-monitors-add-on/multi-monitors-add-on@breizhhardware/mmpanel.js

/*
Copyright (C) 2014  spin83

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, visit https://www.gnu.org/licenses/.
*/

import St from "gi://St";
import Shell from "gi://Shell";
import Meta from "gi://Meta";
import Atk from "gi://Atk";
import Clutter from "gi://Clutter";
import GObject from "gi://GObject";

import * as Main from "resource:///org/gnome/shell/ui/main.js";
import * as Panel from "resource:///org/gnome/shell/ui/panel.js";
import * as PopupMenu from "resource:///org/gnome/shell/ui/popupMenu.js";
import * as PanelMenu from "resource:///org/gnome/shell/ui/panelMenu.js";
import * as CtrlAltTab from "resource:///org/gnome/shell/ui/ctrlAltTab.js";
import * as ExtensionSystem from "resource:///org/gnome/shell/ui/extensionSystem.js";

import * as MultiMonitors from "./extension.js";
import * as Convenience from "./convenience.js";
import * as MMCalendar from "./mmcalendar.js";

const SHOW_ACTIVITIES_ID = "show-activities";
var SHOW_APP_MENU_ID = "show-app-menu";
const SHOW_DATE_TIME_ID = "show-date-time";
const AVAILABLE_INDICATORS_ID = "available-indicators";
const TRANSFER_INDICATORS_ID = "transfer-indicators";

export var StatusIndicatorsController = class StatusIndicatorsController {
	constructor() {
		this._transfered_indicators = [];
		this._settings = Convenience.getSettings();

		this._updatedSessionId = Main.sessionMode.connect(
			"updated",
			this._updateSessionIndicators.bind(this),
		);
		this._updateSessionIndicators();
		this._extensionStateChangedId = Main.extensionManager.connect(
			"extension-state-changed",
			this._extensionStateChanged.bind(this),
		);

		this._transferIndicatorsId = this._settings.connect(
			"changed::" + TRANSFER_INDICATORS_ID,
			this.transferIndicators.bind(this),
		);
	}

	destroy() {
		this._settings.disconnect(this._transferIndicatorsId);
		Main.extensionManager.disconnect(this._extensionStateChangedId);
		Main.sessionMode.disconnect(this._updatedSessionId);
		this._settings.set_strv(AVAILABLE_INDICATORS_ID, []);
		this._transferBack(this._transfered_indicators);
	}

	transferBack(panel) {
		let transfer_back = this._transfered_indicators.filter((element) => {
			return element.monitor == panel.monitorIndex;
		});

		this._transferBack(transfer_back, panel);
	}

	transferIndicators() {
		let boxs = ["_leftBox", "_centerBox", "_rightBox"];
		let transfers = this._settings
			.get_value(TRANSFER_INDICATORS_ID)
			.deep_unpack();
		let show_app_menu = this._settings.get_value(SHOW_APP_MENU_ID);

		let transfer_back = this._transfered_indicators.filter((element) => {
			return !transfers.hasOwnProperty(element.iname);
		});

		this._transferBack(transfer_back);

		for (let iname in transfers) {
			if (transfers.hasOwnProperty(iname) && Main.panel.statusArea[iname]) {
				let monitor = transfers[iname];

				let indicator = Main.panel.statusArea[iname];
				let panel = this._findPanel(monitor);
				boxs.forEach((box) => {
					if (Main.panel[box].contains(indicator.container) && panel) {
						global.log("a " + box + " > " + iname + " : " + monitor);
						this._transfered_indicators.push({
							iname: iname,
							box: box,
							monitor: monitor,
						});
						Main.panel[box].remove_child(indicator.container);
						if (show_app_menu && box === "_leftBox")
							panel[box].insert_child_at_index(indicator.container, 1);
						else panel[box].insert_child_at_index(indicator.container, 0);
					}
				});
			}
		}
	}

	_findPanel(monitor) {
		for (let i = 0; i < Main.mmPanel.length; i++) {
			if (Main.mmPanel[i].monitorIndex == monitor) {
				return Main.mmPanel[i];
			}
		}
		return null;
	}

	_transferBack(transfer_back, panel) {
		transfer_back.forEach((element) => {
			this._transfered_indicators.splice(
				this._transfered_indicators.indexOf(element),
			);
			if (Main.panel.statusArea[element.iname]) {
				let indicator = Main.panel.statusArea[element.iname];
				if (!panel) {
					panel = this._findPanel(element.monitor);
				}
				if (panel[element.box].contains(indicator.container)) {
					global.log(
						"r " +
						element.box +
						" > " +
						element.iname +
						" : " +
						element.monitor,
					);
					panel[element.box].remove_child(indicator.container);
					if (element.box === "_leftBox")
						Main.panel[element.box].insert_child_at_index(
							indicator.container,
							1,
						);
					else
						Main.panel[element.box].insert_child_at_index(
							indicator.container,
							0,
						);
				}
			}
		});
	}

	_extensionStateChanged() {
		this._findAvailableIndicators();
		this.transferIndicators();
	}

	_updateSessionIndicators() {
		let session_indicators = [];
		session_indicators.push("MultiMonitorsAddOn");
		let sessionPanel = Main.sessionMode.panel;
		for (let sessionBox in sessionPanel) {
			sessionPanel[sessionBox].forEach((sesionIndicator) => {
				session_indicators.push(sesionIndicator);
			});
		}
		this._session_indicators = session_indicators;
		this._available_indicators = [];

		this._findAvailableIndicators();
		this.transferIndicators();
	}

	_findAvailableIndicators() {
		let available_indicators = [];
		let statusArea = Main.panel.statusArea;
		for (let indicator in statusArea) {
			if (
				statusArea.hasOwnProperty(indicator) &&
				this._session_indicators.indexOf(indicator) < 0
			) {
				available_indicators.push(indicator);
			}
		}
		if (available_indicators.length != this._available_indicators.length) {
			this._available_indicators = available_indicators;
			//			global.log(this._available_indicators);
			this._settings.set_strv(
				AVAILABLE_INDICATORS_ID,
				this._available_indicators,
			);
		}
	}
};

export var MultiMonitorsAppMenuButton = (() => {
	let MultiMonitorsAppMenuButton = class MultiMonitorsAppMenuButton extends PanelMenu.Button {
		_init(panel) {
			if (panel.monitorIndex == undefined)
				this._monitorIndex = Main.layoutManager.primaryIndex;
			else this._monitorIndex = panel.monitorIndex;
			this._actionOnWorkspaceGroupNotifyId = 0;
			this._targetAppGroup = null;
			this._lastFocusedWindow = null;
			Panel.AppMenuButton.prototype._init.call(this, panel);

			this._windowEnteredMonitorId = global.display.connect(
				"window-entered-monitor",
				this._windowEnteredMonitor.bind(this),
			);
			this._windowLeftMonitorId = global.display.connect(
				"window-left-monitor",
				this._windowLeftMonitor.bind(this),
			);
		}

		_windowEnteredMonitor(metaScreen, monitorIndex, metaWin) {
			if (monitorIndex == this._monitorIndex) {
				switch (metaWin.get_window_type()) {
					case Meta.WindowType.NORMAL:
					case Meta.WindowType.DIALOG:
					case Meta.WindowType.MODAL_DIALOG:
					case Meta.WindowType.SPLASHSCREEN:
						this._sync();
						break;
				}
			}
		}

		_windowLeftMonitor(metaScreen, monitorIndex, metaWin) {
			if (monitorIndex == this._monitorIndex) {
				switch (metaWin.get_window_type()) {
					case Meta.WindowType.NORMAL:
					case Meta.WindowType.DIALOG:
					case Meta.WindowType.MODAL_DIALOG:
					case Meta.WindowType.SPLASHSCREEN:
						this._sync();
						break;
				}
			}
		}

		_findTargetApp() {
			if (this._actionOnWorkspaceGroupNotifyId) {
				this._targetAppGroup.disconnect(this._actionOnWorkspaceGroupNotifyId);
				this._actionOnWorkspaceGroupNotifyId = 0;
				this._targetAppGroup = null;
			}
			let groupWindow = false;
			let groupFocus = false;

			let workspaceManager = global.workspace_manager;
			let workspace = workspaceManager.get_active_workspace();
			let tracker = Shell.WindowTracker.get_default();
			let focusedApp = tracker.focus_app;
			if (focusedApp && focusedApp.is_on_workspace(workspace)) {
				let windows = focusedApp.get_windows();
				for (let i = 0; i < windows.length; i++) {
					let win = windows[i];
					if (win.located_on_workspace(workspace)) {
						if (win.get_monitor() == this._monitorIndex) {
							if (win.has_focus()) {
								this._lastFocusedWindow = win;
								//    	        			global.log(this._monitorIndex+": focus :"+win.get_title()+" : "+win.has_focus());
								return focusedApp;
							} else groupWindow = true;
						} else {
							if (win.has_focus()) groupFocus = true;
						}
						if (groupFocus && groupWindow) {
							if (focusedApp != this._targetApp) {
								this._targetAppGroup = focusedApp;
								this._actionOnWorkspaceGroupNotifyId =
									this._targetAppGroup.connect(
										"notify::action-group",
										this._sync.bind(this),
									);
								//    				 	global.log(this._monitorIndex+": gConnect :"+win.get_title()+" : "+win.has_focus());
							}
							break;
						}
					}
				}
			}

			for (let i = 0; i < this._startingApps.length; i++)
				if (this._startingApps[i].is_on_workspace(workspace)) {
					//            	global.log(this._monitorIndex+": newAppFocus");
					return this._startingApps[i];
				}

			if (
				this._lastFocusedWindow &&
				this._lastFocusedWindow.located_on_workspace(workspace) &&
				this._lastFocusedWindow.get_monitor() == this._monitorIndex
			) {
				//			global.log(this._monitorIndex+": lastFocus :"+this._lastFocusedWindow.get_title());
				return tracker.get_window_app(this._lastFocusedWindow);
			}

			let windows = global.display.get_tab_list(
				Meta.TabList.NORMAL_ALL,
				workspace,
			);

			for (let i = 0; i < windows.length; i++) {
				if (windows[i].get_monitor() == this._monitorIndex) {
					this._lastFocusedWindow = windows[i];
					//        		global.log(this._monitorIndex+": appFind :"+windows[i].get_title());
					return tracker.get_window_app(windows[i]);
				}
			}

			return null;
		}

		_sync() {
			if (!this._switchWorkspaceNotifyId) return;
			Panel.AppMenuButton.prototype._sync.call(this);
		}

		_onDestroy() {
			if (this._actionGroupNotifyId) {
				this._targetApp.disconnect(this._actionGroupNotifyId);
				this._actionGroupNotifyId = 0;
			}

			global.display.disconnect(this._windowEnteredMonitorId);
			global.display.disconnect(this._windowLeftMonitorId);

			if (this._busyNotifyId) {
				this._targetApp.disconnect(this._busyNotifyId);
				this._busyNotifyId = 0;
			}

			if (this.menu._windowsChangedId) {
				this.menu._app.disconnect(this.menu._windowsChangedId);
				this.menu._windowsChangedId = 0;
			}
			Panel.AppMenuButton.prototype._onDestroy.call(this);
		}
	};
	MultiMonitors.copyClass(Panel.AppMenuButton, MultiMonitorsAppMenuButton);
	return GObject.registerClass(
		{ Signals: { changed: {} } },
		MultiMonitorsAppMenuButton,
	);
})();

var MultiMonitorsActivitiesButton = (() => {
	let MultiMonitorsActivitiesButton = class MultiMonitorsActivitiesButton extends PanelMenu.Button {
		_init() {
			super._init(0.0, null, true);
			this.accessible_role = Atk.Role.TOGGLE_BUTTON;

			this.name = "mmPanelActivities";

			/* Translators: If there is no suitable word for "Activities"
                     in your language, you can use the word for "Overview". */
			this._label = new St.Label({
				text: _("Activities"),
				y_align: Clutter.ActorAlign.CENTER,
			});
			this.add_actor(this._label);

			this.label_actor = this._label;

			this._showingId = Main.overview.connect("showing", () => {
				this.add_style_pseudo_class("overview");
				this.add_accessible_state(Atk.StateType.CHECKED);
			});
			this._hidingId = Main.overview.connect("hiding", () => {
				this.remove_style_pseudo_class("overview");
				this.remove_accessible_state(Atk.StateType.CHECKED);
			});

			this._xdndTimeOut = 0;
		}

		_onDestroy() {
			Main.overview.disconnect(this._showingId);
			Main.overview.disconnect(this._hidingId);
			super._onDestroy();
		}
	};
	MultiMonitors.copyClass(
		Panel.ActivitiesButton,
		MultiMonitorsActivitiesButton,
	);
	return GObject.registerClass(MultiMonitorsActivitiesButton);
})();

const MULTI_MONITOR_PANEL_ITEM_IMPLEMENTATIONS = {
	activities: MultiMonitorsActivitiesButton,
	appMenu: MultiMonitorsAppMenuButton,
	dateMenu: MMCalendar.MultiMonitorsDateMenuButton,
};

export const MultiMonitorsPanel = (() => {
	let MultiMonitorsPanel = class MultiMonitorsPanel extends St.Widget {
		_init(monitorIndex, mmPanelBox) {
			super._init({ name: "panel", reactive: true });

			this.monitorIndex = monitorIndex;

			this.set_offscreen_redirect(Clutter.OffscreenRedirect.ALWAYS);

			this._sessionStyle = null;

			this.statusArea = {};

			this.menuManager = new PopupMenu.PopupMenuManager(this);

			this._leftBox = new St.BoxLayout({ name: "panelLeft" });
			this.add_child(this._leftBox);
			this._centerBox = new St.BoxLayout({ name: "panelCenter" });
			this.add_child(this._centerBox);
			this._rightBox = new St.BoxLayout({ name: "panelRight" });
			this.add_child(this._rightBox);

			this._showingId = Main.overview.connect("showing", () => {
				this.add_style_pseudo_class("overview");
			});
			this._hidingId = Main.overview.connect("hiding", () => {
				this.remove_style_pseudo_class("overview");
			});

			mmPanelBox.panelBox.add(this);
			Main.ctrlAltTabManager.addGroup(
				this,
				_("Top Bar"),
				"focus-top-bar-symbolic",
				{ sortGroup: CtrlAltTab.SortGroup.TOP },
			);

			this._updatedId = Main.sessionMode.connect(
				"updated",
				this._updatePanel.bind(this),
			);

			this._workareasChangedId = global.display.connect(
				"workareas-changed",
				() => this.queue_relayout(),
			);
			this._updatePanel();

			this._settings = Convenience.getSettings();
			this._showActivitiesId = this._settings.connect(
				"changed::" + SHOW_ACTIVITIES_ID,
				this._showActivities.bind(this),
			);
			this._showActivities();

			this._showAppMenuId = this._settings.connect(
				"changed::" + SHOW_APP_MENU_ID,
				this._showAppMenu.bind(this),
			);
			this._showAppMenu();

			this._showDateTimeId = this._settings.connect(
				"changed::" + SHOW_DATE_TIME_ID,
				this._showDateTime.bind(this),
			);
			this._showDateTime();

			this.connect("destroy", this._onDestroy.bind(this));
		}

		_onDestroy() {
			global.display.disconnect(this._workareasChangedId);
			Main.overview.disconnect(this._showingId);
			Main.overview.disconnect(this._hidingId);

			this._settings.disconnect(this._showActivitiesId);
			this._settings.disconnect(this._showAppMenuId);
			this._settings.disconnect(this._showDateTimeId);

			Main.ctrlAltTabManager.removeGroup(this);
			Main.sessionMode.disconnect(this._updatedId);
		}

		_showActivities() {
			let name = "activities";
			if (this._settings.get_boolean(SHOW_ACTIVITIES_ID)) {
				if (this.statusArea[name]) this.statusArea[name].visible = true;
			} else {
				if (this.statusArea[name]) this.statusArea[name].visible = false;
			}
		}

		_showDateTime() {
			let name = "dateMenu";
			if (this._settings.get_boolean(SHOW_DATE_TIME_ID)) {
				if (this.statusArea[name]) this.statusArea[name].visible = true;
			} else {
				if (this.statusArea[name]) this.statusArea[name].visible = false;
			}
		}

		_showAppMenu() {
			let name = "appMenu";
			if (this._settings.get_boolean(SHOW_APP_MENU_ID)) {
				if (!this.statusArea[name]) {
					let indicator = new MultiMonitorsAppMenuButton(this);
					this.statusArea[name] = indicator;
					let box = this._leftBox;
					this._addToPanelBox(name, indicator, box.get_n_children() + 1, box);
				}
			} else {
				if (this.statusArea[name]) {
					let indicator = this.statusArea[name];
					this.menuManager.removeMenu(indicator.menu);
					indicator.destroy();
					delete this.statusArea[name];
				}
			}
		}

		vfunc_get_preferred_width(forHeight) {
			if (Main.layoutManager.monitors.length > this.monitorIndex)
				return [0, Main.layoutManager.monitors[this.monitorIndex].width];

			return [0, 0];
		}

		_hideIndicators() {
			for (let role in MULTI_MONITOR_PANEL_ITEM_IMPLEMENTATIONS) {
				let indicator = this.statusArea[role];
				if (!indicator) continue;
				indicator.container.hide();
			}
		}

		_ensureIndicator(role) {
			let indicator = this.statusArea[role];
			if (indicator) {
				indicator.container.show();
				return null;
			} else {
				let constructor = MULTI_MONITOR_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;
		}

		_getDraggableWindowForPosition(stageX) {
			let workspaceManager = global.workspace_manager;
			const windows = workspaceManager.get_active_workspace().list_windows();
			const allWindowsByStacking = global.display
				.sort_windows_by_stacking(windows)
				.reverse();

			return allWindowsByStacking.find((metaWindow) => {
				let rect = metaWindow.get_frame_rect();
				return (
					metaWindow.get_monitor() == this.monitorIndex &&
					metaWindow.showing_on_its_workspace() &&
					metaWindow.get_window_type() != Meta.WindowType.DESKTOP &&
					metaWindow.maximized_vertically &&
					stageX > rect.x &&
					stageX < rect.x + rect.width
				);
			});
		}
	};

	MultiMonitors.copyClass(Panel.Panel, MultiMonitorsPanel);
	return GObject.registerClass(MultiMonitorsPanel);
})();