mirror of
https://github.com/zen-browser/components.git
synced 2025-07-08 06:50:00 +02:00
821 lines
30 KiB
TypeScript
821 lines
30 KiB
TypeScript
|
|
var ZenWorkspaces = {
|
|
/**
|
|
* Stores workspace IDs and their last selected tabs.
|
|
*/
|
|
_lastSelectedWorkspaceTabs: {},
|
|
|
|
init() {
|
|
if (!this.shouldHaveWorkspaces) {
|
|
console.warn('ZenWorkspaces: !!! ZenWorkspaces is disabled in hidden windows !!!');
|
|
return; // We are in a hidden window, don't initialize ZenWorkspaces
|
|
}
|
|
console.info('ZenWorkspaces: Initializing ZenWorkspaces...');
|
|
window.SessionStore.promiseInitialized.then(async () => {
|
|
await this.initializeWorkspaces();
|
|
console.info('ZenWorkspaces: ZenWorkspaces initialized');
|
|
});
|
|
},
|
|
|
|
get shouldShowIconStrip() {
|
|
delete this.shouldShowIconStrip;
|
|
this.shouldShowIconStrip = Services.prefs.getBoolPref('zen.workspaces.show-icon-strip', true);
|
|
return this.shouldShowIconStrip;
|
|
},
|
|
|
|
get shouldHaveWorkspaces() {
|
|
delete this.shouldHaveWorkspaces;
|
|
let docElement = document.documentElement;
|
|
this.shouldHaveWorkspaces = !(docElement.hasAttribute('privatebrowsingmode')
|
|
|| docElement.getAttribute('chromehidden').includes('toolbar')
|
|
|| docElement.getAttribute('chromehidden').includes('menubar'));
|
|
return this.shouldHaveWorkspaces;
|
|
},
|
|
|
|
get workspaceEnabled() {
|
|
delete this.workspaceEnabled;
|
|
this.workspaceEnabled = Services.prefs.getBoolPref('zen.workspaces.enabled', false) && this.shouldHaveWorkspaces;
|
|
return this.workspaceEnabled;
|
|
},
|
|
|
|
getActiveWorkspaceFromCache() {
|
|
return this._workspaceCache.workspaces.find((workspace) => workspace.used);
|
|
},
|
|
|
|
// Wrorkspaces saving/loading
|
|
get _storeFile() {
|
|
return PathUtils.join(PathUtils.profileDir, 'zen-workspaces', 'Workspaces.json');
|
|
},
|
|
|
|
async _workspaces() {
|
|
if (!this._workspaceCache) {
|
|
this._workspaceCache = await IOUtils.readJSON(this._storeFile);
|
|
if (!this._workspaceCache.workspaces) {
|
|
this._workspaceCache.workspaces = [];
|
|
}
|
|
}
|
|
return this._workspaceCache;
|
|
},
|
|
|
|
async onWorkspacesEnabledChanged() {
|
|
if (this.workspaceEnabled) {
|
|
throw Error("Shoud've had reloaded the window");
|
|
} else {
|
|
this._workspaceCache = null;
|
|
document.getElementById('zen-workspaces-button')?.remove();
|
|
for (let tab of gBrowser.tabs) {
|
|
gBrowser.showTab(tab);
|
|
}
|
|
}
|
|
},
|
|
|
|
async onWorkspacesIconStripChanged() {
|
|
this.shouldShowIconStrip = Services.prefs.getBoolPref('zen.workspaces.show-icon-strip', true);
|
|
await this._expandWorkspacesStrip();
|
|
},
|
|
|
|
async initializeWorkspaces() {
|
|
Services.prefs.addObserver('zen.workspaces.enabled', this.onWorkspacesEnabledChanged.bind(this));
|
|
Services.prefs.addObserver('zen.workspaces.show-icon-strip', this.onWorkspacesIconStripChanged.bind(this));
|
|
await this.initializeWorkspacesButton();
|
|
let file = new FileUtils.File(this._storeFile);
|
|
if (!file.exists()) {
|
|
await IOUtils.writeJSON(this._storeFile, {});
|
|
}
|
|
if (this.workspaceEnabled) {
|
|
this._initializeWorkspaceCreationIcons();
|
|
this._initializeWorkspaceEditIcons();
|
|
this._initializeWorkspaceTabContextMenus();
|
|
window.addEventListener('TabClose', this.handleTabClose.bind(this));
|
|
window.addEventListener('TabBrowserInserted', this.onTabBrowserInserted.bind(this));
|
|
let workspaces = await this._workspaces();
|
|
if (workspaces.workspaces.length === 0) {
|
|
await this.createAndSaveWorkspace('Default Workspace', true);
|
|
} else {
|
|
let activeWorkspace = workspaces.workspaces.find((workspace) => workspace.used);
|
|
if (!activeWorkspace) {
|
|
activeWorkspace = workspaces.workspaces.find((workspace) => workspace.default);
|
|
activeWorkspace.used = true;
|
|
await this.saveWorkspaces();
|
|
}
|
|
if (!activeWorkspace) {
|
|
activeWorkspace = workspaces.workspaces[0];
|
|
activeWorkspace.used = true;
|
|
await this.saveWorkspaces();
|
|
}
|
|
this.changeWorkspace(activeWorkspace, true);
|
|
}
|
|
}
|
|
},
|
|
|
|
handleTabClose(event) {
|
|
if (this.__contextIsDelete) {
|
|
return; // Bug when closing tabs from the context menu
|
|
}
|
|
let tab = event.target;
|
|
let workspaceID = tab.getAttribute('zen-workspace-id');
|
|
// If the tab is the last one in the workspace, create a new tab
|
|
if (workspaceID) {
|
|
let tabs = gBrowser.tabs.filter((tab) => tab.getAttribute('zen-workspace-id') === workspaceID);
|
|
if (tabs.length === 1) {
|
|
this._createNewTabForWorkspace({ uuid: workspaceID });
|
|
// We still need to close other tabs in the workspace
|
|
this.changeWorkspace({ uuid: workspaceID }, true);
|
|
}
|
|
}
|
|
},
|
|
|
|
_kIcons: JSON.parse(Services.prefs.getStringPref("zen.workspaces.icons")).map((icon) => icon),
|
|
|
|
_initializeWorkspaceCreationIcons() {
|
|
let container = document.getElementById('PanelUI-zen-workspaces-create-icons-container');
|
|
for (let icon of this._kIcons) {
|
|
let button = document.createXULElement('toolbarbutton');
|
|
button.className = 'toolbarbutton-1';
|
|
button.setAttribute('label', icon);
|
|
button.onclick = ((event) => {
|
|
let wasSelected = button.hasAttribute('selected');
|
|
for (let button of container.children) {
|
|
button.removeAttribute('selected');
|
|
}
|
|
if (!wasSelected) {
|
|
button.setAttribute('selected', 'true');
|
|
}
|
|
}).bind(this, button);
|
|
container.appendChild(button);
|
|
}
|
|
},
|
|
|
|
_initializeWorkspaceEditIcons() {
|
|
let container = this._workspaceEditIconsContainer;
|
|
for (let icon of this._kIcons) {
|
|
let button = document.createXULElement('toolbarbutton');
|
|
button.className = 'toolbarbutton-1';
|
|
button.setAttribute('label', icon);
|
|
button.onclick = ((event) => {
|
|
let wasSelected = button.hasAttribute('selected');
|
|
for (let button of container.children) {
|
|
button.removeAttribute('selected');
|
|
}
|
|
if (!wasSelected) {
|
|
button.setAttribute('selected', 'true');
|
|
}
|
|
this.onWorkspaceEditChange();
|
|
}).bind(this, button);
|
|
container.appendChild(button);
|
|
}
|
|
},
|
|
|
|
async saveWorkspace(workspaceData) {
|
|
let json = await IOUtils.readJSON(this._storeFile);
|
|
if (typeof json.workspaces === 'undefined') {
|
|
json.workspaces = [];
|
|
}
|
|
let existing = json.workspaces.findIndex((workspace) => workspace.uuid === workspaceData.uuid);
|
|
if (existing >= 0) {
|
|
json.workspaces[existing] = workspaceData;
|
|
} else {
|
|
json.workspaces.push(workspaceData);
|
|
}
|
|
console.info('ZenWorkspaces: Saving workspace', workspaceData);
|
|
await IOUtils.writeJSON(this._storeFile, json);
|
|
this._workspaceCache = null;
|
|
|
|
await this._updateWorkspacesChangeContextMenu();
|
|
},
|
|
|
|
async removeWorkspace(windowID) {
|
|
let json = await this._workspaces();
|
|
console.info('ZenWorkspaces: Removing workspace', windowID);
|
|
await this.changeWorkspace(json.workspaces.find((workspace) => workspace.uuid !== windowID));
|
|
this._deleteAllTabsInWorkspace(windowID);
|
|
delete this._lastSelectedWorkspaceTabs[windowID];
|
|
json.workspaces = json.workspaces.filter((workspace) => workspace.uuid !== windowID);
|
|
await this.unsafeSaveWorkspaces(json);
|
|
await this._propagateWorkspaceData();
|
|
await this._updateWorkspacesChangeContextMenu();
|
|
},
|
|
|
|
async saveWorkspaces() {
|
|
await IOUtils.writeJSON(this._storeFile, await this._workspaces());
|
|
this._workspaceCache = null;
|
|
},
|
|
|
|
async unsafeSaveWorkspaces(workspaces) {
|
|
await IOUtils.writeJSON(this._storeFile, workspaces);
|
|
this._workspaceCache = workspaces;
|
|
},
|
|
|
|
// Workspaces dialog UI management
|
|
|
|
openSaveDialog() {
|
|
let parentPanel = document.getElementById('PanelUI-zen-workspaces-multiview');
|
|
PanelUI.showSubView('PanelUI-zen-workspaces-create', parentPanel);
|
|
},
|
|
|
|
async openEditDialog(workspaceUuid) {
|
|
this._workspaceEditDialog.setAttribute('data-workspace-uuid', workspaceUuid);
|
|
document.getElementById('PanelUI-zen-workspaces-edit-save').setAttribute('disabled', 'true');
|
|
let workspaces = (await this._workspaces()).workspaces;
|
|
let workspaceData = workspaces.find((workspace) => workspace.uuid === workspaceUuid);
|
|
this._workspaceEditInput.textContent = workspaceData.name;
|
|
this._workspaceEditInput.value = workspaceData.name;
|
|
this._workspaceEditInput.setAttribute('data-initial-value', workspaceData.name);
|
|
this._workspaceEditIconsContainer.setAttribute('data-initial-value', workspaceData.icon);
|
|
document.querySelectorAll('#PanelUI-zen-workspaces-edit-icons-container toolbarbutton').forEach((button) => {
|
|
if (button.label === workspaceData.icon) {
|
|
button.setAttribute('selected', 'true');
|
|
} else {
|
|
button.removeAttribute('selected');
|
|
}
|
|
});
|
|
let parentPanel = document.getElementById('PanelUI-zen-workspaces-multiview');
|
|
PanelUI.showSubView('PanelUI-zen-workspaces-edit', parentPanel);
|
|
},
|
|
|
|
closeWorkspacesSubView() {
|
|
let parentPanel = document.getElementById('PanelUI-zen-workspaces-multiview');
|
|
parentPanel.goBack();
|
|
},
|
|
|
|
workspaceHasIcon(workspace) {
|
|
return typeof workspace.icon !== 'undefined' && workspace.icon !== '';
|
|
},
|
|
|
|
getWorkspaceIcon(workspace) {
|
|
if (this.workspaceHasIcon(workspace)) {
|
|
return workspace.icon;
|
|
}
|
|
return workspace.name[0].toUpperCase();
|
|
},
|
|
|
|
async _propagateWorkspaceData({
|
|
ignoreStrip = false
|
|
} = {}) {
|
|
let currentContainer = document.getElementById('PanelUI-zen-workspaces-current-info');
|
|
let workspaceList = document.getElementById('PanelUI-zen-workspaces-list');
|
|
if (!ignoreStrip) {
|
|
await this._expandWorkspacesStrip();
|
|
}
|
|
const createWorkspaceElement = (workspace) => {
|
|
let element = document.createXULElement('toolbarbutton');
|
|
element.className = 'subviewbutton';
|
|
element.setAttribute('tooltiptext', workspace.name);
|
|
element.setAttribute('zen-workspace-id', workspace.uuid);
|
|
if (workspace.used) {
|
|
element.setAttribute('active', 'true');
|
|
}
|
|
if (workspace.default) {
|
|
element.setAttribute('default', 'true');
|
|
}
|
|
const containerGroup = ContextualIdentityService.getPublicIdentities().find(
|
|
(container) => container.userContextId === workspace.containerTabId
|
|
);
|
|
if (containerGroup) {
|
|
element.classList.add('identity-color-' + containerGroup.color);
|
|
element.setAttribute('data-usercontextid', containerGroup.userContextId);
|
|
}
|
|
let childs = window.MozXULElement.parseXULToFragment(`
|
|
<div class="zen-workspace-icon">
|
|
</div>
|
|
<vbox>
|
|
<div class="zen-workspace-name">
|
|
</div>
|
|
<div class="zen-workspace-container" ${containerGroup ? '' : 'hidden="true"'}>
|
|
</div>
|
|
</vbox>
|
|
<toolbarbutton closemenu="none" class="toolbarbutton-1 zen-workspace-actions">
|
|
<image class="toolbarbutton-icon" id="zen-workspace-actions-menu-icon"></image>
|
|
</toolbarbutton>
|
|
`);
|
|
|
|
// use text content instead of innerHTML to avoid XSS
|
|
childs.querySelector('.zen-workspace-icon').textContent = this.getWorkspaceIcon(workspace);
|
|
childs.querySelector('.zen-workspace-name').textContent = workspace.name;
|
|
if (containerGroup) {
|
|
childs.querySelector('.zen-workspace-container').textContent = ContextualIdentityService.getUserContextLabel(
|
|
containerGroup.userContextId
|
|
);
|
|
}
|
|
|
|
childs.querySelector('.zen-workspace-actions').addEventListener('command', (event) => {
|
|
let button = event.target;
|
|
this._contextMenuId = button.closest('toolbarbutton[zen-workspace-id]').getAttribute('zen-workspace-id');
|
|
const popup = button.ownerDocument.getElementById('zenWorkspaceActionsMenu');
|
|
popup.openPopup(button, 'after_end');
|
|
});
|
|
element.appendChild(childs);
|
|
element.onclick = (async () => {
|
|
if (event.target.closest('.zen-workspace-actions')) {
|
|
return; // Ignore clicks on the actions button
|
|
}
|
|
await this.changeWorkspace(workspace);
|
|
let panel = document.getElementById('PanelUI-zen-workspaces');
|
|
PanelMultiView.hidePopup(panel);
|
|
document.getElementById('zen-workspaces-button').removeAttribute('open');
|
|
}).bind(this, workspace);
|
|
return element;
|
|
};
|
|
let workspaces = await this._workspaces();
|
|
let activeWorkspace = workspaces.workspaces.find((workspace) => workspace.used);
|
|
currentContainer.innerHTML = '';
|
|
workspaceList.innerHTML = '';
|
|
workspaceList.parentNode.style.display = 'flex';
|
|
if (workspaces.workspaces.length - 1 <= 0) {
|
|
workspaceList.innerHTML = 'No workspaces available';
|
|
workspaceList.setAttribute('empty', 'true');
|
|
} else {
|
|
workspaceList.removeAttribute('empty');
|
|
}
|
|
if (activeWorkspace) {
|
|
let currentWorkspace = createWorkspaceElement(activeWorkspace);
|
|
currentContainer.appendChild(currentWorkspace);
|
|
}
|
|
for (let workspace of workspaces.workspaces) {
|
|
if (workspace.used) {
|
|
continue;
|
|
}
|
|
let workspaceElement = createWorkspaceElement(workspace);
|
|
workspaceList.appendChild(workspaceElement);
|
|
}
|
|
},
|
|
|
|
async openWorkspacesDialog(event) {
|
|
if (!this.workspaceEnabled) {
|
|
return;
|
|
}
|
|
let target = event.target;
|
|
let panel = document.getElementById('PanelUI-zen-workspaces');
|
|
await this._propagateWorkspaceData({
|
|
ignoreStrip: true
|
|
});
|
|
PanelMultiView.openPopup(panel, target, {
|
|
position: 'bottomright topright',
|
|
triggerEvent: event,
|
|
}).catch(console.error);
|
|
},
|
|
|
|
async initializeWorkspacesButton() {
|
|
if (!this.workspaceEnabled) {
|
|
return;
|
|
} else if (document.getElementById('zen-workspaces-button')) {
|
|
let button = document.getElementById('zen-workspaces-button');
|
|
button.removeAttribute('hidden');
|
|
return;
|
|
}
|
|
const nextSibling = document.getElementById('zen-sidepanel-button');
|
|
const wrapper = document.createXULElement('toolbarbutton');
|
|
wrapper.id = 'zen-workspaces-button';
|
|
nextSibling.after(wrapper);
|
|
await this._expandWorkspacesStrip();
|
|
},
|
|
|
|
async _expandWorkspacesStrip() {
|
|
let workspaces = await this._workspaces();
|
|
let workspaceList = document.getElementById('zen-workspaces-button');
|
|
const newWorkspacesButton = document.createXULElement(this.shouldShowIconStrip ? 'hbox' : 'toolbarbutton');
|
|
newWorkspacesButton.id = 'zen-workspaces-button';
|
|
newWorkspacesButton.setAttribute('removable', 'false');
|
|
newWorkspacesButton.setAttribute('showInPrivateBrowsing', 'false');
|
|
newWorkspacesButton.setAttribute('tooltiptext', 'Workspaces');
|
|
|
|
if (this.shouldShowIconStrip) {
|
|
for (let workspace of workspaces.workspaces) {
|
|
let button = document.createXULElement('toolbarbutton');
|
|
button.className = 'subviewbutton';
|
|
button.setAttribute('tooltiptext', workspace.name);
|
|
button.setAttribute('zen-workspace-id', workspace.uuid);
|
|
if (workspace.used) {
|
|
button.setAttribute('active', 'true');
|
|
}
|
|
if (workspace.default) {
|
|
button.setAttribute('default', 'true');
|
|
}
|
|
button.onclick = (async () => {
|
|
await this.changeWorkspace(workspace);
|
|
}).bind(this, workspace);
|
|
let icon = document.createXULElement('div');
|
|
icon.className = 'zen-workspace-icon';
|
|
icon.textContent = this.getWorkspaceIcon(workspace);
|
|
button.appendChild(icon);
|
|
newWorkspacesButton.appendChild(button);
|
|
}
|
|
}
|
|
|
|
workspaceList.after(newWorkspacesButton);
|
|
workspaceList.remove();
|
|
|
|
if (!this.shouldShowIconStrip) {
|
|
await this._updateWorkspacesButton();
|
|
}
|
|
},
|
|
|
|
async _updateWorkspacesButton() {
|
|
let button = document.getElementById('zen-workspaces-button');
|
|
if (!button) {
|
|
return;
|
|
}
|
|
let activeWorkspace = (await this._workspaces()).workspaces.find((workspace) => workspace.used);
|
|
if (activeWorkspace) {
|
|
button.setAttribute('as-button', 'true');
|
|
button.classList.add('toolbarbutton-1', 'zen-sidebar-action-button');
|
|
|
|
button.addEventListener('click', this.openWorkspacesDialog.bind(this));
|
|
|
|
const wrapper = document.createXULElement('hbox');
|
|
wrapper.className = 'zen-workspace-sidebar-wrapper';
|
|
|
|
const icon = document.createElement('div');
|
|
icon.className = 'zen-workspace-sidebar-icon';
|
|
icon.textContent = this.getWorkspaceIcon(activeWorkspace);
|
|
|
|
|
|
// use text content instead of innerHTML to avoid XSS
|
|
const name = document.createElement('div');
|
|
name.className = 'zen-workspace-sidebar-name';
|
|
name.textContent = activeWorkspace.name;
|
|
|
|
if (!this.workspaceHasIcon(activeWorkspace)) {
|
|
icon.setAttribute('no-icon', 'true');
|
|
}
|
|
|
|
wrapper.appendChild(icon);
|
|
wrapper.appendChild(name);
|
|
|
|
button.innerHTML = '';
|
|
button.appendChild(wrapper);
|
|
}
|
|
},
|
|
|
|
// Workspaces management
|
|
|
|
get _workspaceCreateInput() {
|
|
return document.getElementById('PanelUI-zen-workspaces-create-input');
|
|
},
|
|
|
|
get _workspaceEditDialog() {
|
|
return document.getElementById('PanelUI-zen-workspaces-edit');
|
|
},
|
|
|
|
get _workspaceEditInput() {
|
|
return document.getElementById('PanelUI-zen-workspaces-edit-input');
|
|
},
|
|
|
|
get _workspaceEditIconsContainer() {
|
|
return document.getElementById('PanelUI-zen-workspaces-edit-icons-container');
|
|
},
|
|
|
|
_deleteAllTabsInWorkspace(workspaceID) {
|
|
for (let tab of gBrowser.tabs) {
|
|
if (tab.getAttribute('zen-workspace-id') === workspaceID) {
|
|
gBrowser.removeTab(tab, {
|
|
animate: true,
|
|
skipSessionStore: true,
|
|
closeWindowWithLastTab: false,
|
|
});
|
|
}
|
|
}
|
|
},
|
|
|
|
_prepareNewWorkspace(window) {
|
|
document.documentElement.setAttribute('zen-workspace-id', window.uuid);
|
|
let tabCount = 0;
|
|
for (let tab of gBrowser.tabs) {
|
|
if (!tab.hasAttribute('zen-workspace-id')) {
|
|
tab.setAttribute('zen-workspace-id', window.uuid);
|
|
tabCount++;
|
|
}
|
|
}
|
|
if (tabCount === 0) {
|
|
this._createNewTabForWorkspace(window);
|
|
}
|
|
},
|
|
|
|
_createNewTabForWorkspace(window) {
|
|
let tab = gZenUIManager.openAndChangeToTab(Services.prefs.getStringPref('browser.startup.homepage'));
|
|
tab.setAttribute('zen-workspace-id', window.uuid);
|
|
},
|
|
|
|
async saveWorkspaceFromCreate() {
|
|
let workspaceName = this._workspaceCreateInput.value;
|
|
if (!workspaceName) {
|
|
return;
|
|
}
|
|
this._workspaceCreateInput.value = '';
|
|
let icon = document.querySelector('#PanelUI-zen-workspaces-create-icons-container [selected]');
|
|
icon?.removeAttribute('selected');
|
|
await this.createAndSaveWorkspace(workspaceName, false, icon?.label);
|
|
document.getElementById('PanelUI-zen-workspaces').hidePopup(true);
|
|
},
|
|
|
|
async saveWorkspaceFromEdit() {
|
|
let workspaceUuid = this._workspaceEditDialog.getAttribute('data-workspace-uuid');
|
|
let workspaceName = this._workspaceEditInput.value;
|
|
if (!workspaceName) {
|
|
return;
|
|
}
|
|
this._workspaceEditInput.value = '';
|
|
let icon = document.querySelector('#PanelUI-zen-workspaces-edit-icons-container [selected]');
|
|
icon?.removeAttribute('selected');
|
|
let workspaces = (await this._workspaces()).workspaces;
|
|
let workspaceData = workspaces.find((workspace) => workspace.uuid === workspaceUuid);
|
|
workspaceData.name = workspaceName;
|
|
workspaceData.icon = icon?.label;
|
|
await this.saveWorkspace(workspaceData);
|
|
await this._updateWorkspacesButton();
|
|
await this._propagateWorkspaceData();
|
|
this.closeWorkspacesSubView();
|
|
},
|
|
|
|
onWorkspaceCreationNameChange(event) {
|
|
let button = document.getElementById('PanelUI-zen-workspaces-create-save');
|
|
if (this._workspaceCreateInput.value === '') {
|
|
button.setAttribute('disabled', 'true');
|
|
return;
|
|
}
|
|
button.removeAttribute('disabled');
|
|
},
|
|
|
|
onWorkspaceEditChange() {
|
|
let button = document.getElementById('PanelUI-zen-workspaces-edit-save');
|
|
let name = this._workspaceEditInput.value;
|
|
let icon = document.querySelector('#PanelUI-zen-workspaces-edit-icons-container [selected]')?.label;
|
|
if (
|
|
name === this._workspaceEditInput.getAttribute('data-initial-value') &&
|
|
icon === this._workspaceEditIconsContainer.getAttribute('data-initial-value')
|
|
) {
|
|
button.setAttribute('disabled', 'true');
|
|
return;
|
|
}
|
|
button.removeAttribute('disabled');
|
|
},
|
|
|
|
get _shouldAllowPinTab() {
|
|
return Services.prefs.getBoolPref('zen.workspaces.individual-pinned-tabs');
|
|
},
|
|
|
|
get tabContainer() {
|
|
delete this.tabContainer;
|
|
return (this.tabContainer = document.getElementById("tabbrowser-tabs"));
|
|
},
|
|
|
|
async changeWorkspace(window, onInit = false) {
|
|
if (!this.workspaceEnabled) {
|
|
return;
|
|
}
|
|
this.tabContainer._invalidateCachedTabs();
|
|
const shouldAllowPinnedTabs = this._shouldAllowPinTab;
|
|
let firstTab = undefined;
|
|
let workspaces = await this._workspaces();
|
|
for (let workspace of workspaces.workspaces) {
|
|
workspace.used = workspace.uuid === window.uuid;
|
|
}
|
|
await this.unsafeSaveWorkspaces(workspaces);
|
|
console.info('ZenWorkspaces: Changing workspace to', window.uuid);
|
|
for (let tab of gBrowser.tabs) {
|
|
if ((tab.getAttribute('zen-workspace-id') === window.uuid && !(tab.pinned && !shouldAllowPinnedTabs)) || !tab.hasAttribute('zen-workspace-id')) {
|
|
if (!firstTab) {
|
|
firstTab = tab;
|
|
} else if (gBrowser.selectedTab === tab) {
|
|
// If the selected tab is already in the workspace, we don't want to change it
|
|
firstTab = null; // note: Do not add "undefined" here, a new tab would be created
|
|
}
|
|
gBrowser.showTab(tab);
|
|
if (!tab.hasAttribute('zen-workspace-id')) {
|
|
// We add the id to those tabs that got inserted before we initialize the workspaces
|
|
// example use case: opening a link from an external app
|
|
tab.setAttribute('zen-workspace-id', window.uuid);
|
|
}
|
|
}
|
|
}
|
|
if (firstTab) {
|
|
gBrowser.selectedTab = this._lastSelectedWorkspaceTabs[window.uuid] ?? firstTab;
|
|
}
|
|
if (typeof firstTab === 'undefined' && !onInit) {
|
|
this._createNewTabForWorkspace(window);
|
|
}
|
|
for (let tab of gBrowser.tabs) {
|
|
if (tab.getAttribute('zen-workspace-id') !== window.uuid) {
|
|
// FOR UNLOADING TABS:
|
|
// gBrowser.discardBrowser(tab, true);
|
|
gBrowser.hideTab(tab, undefined, shouldAllowPinnedTabs);
|
|
}
|
|
}
|
|
this.tabContainer._invalidateCachedTabs();
|
|
document.documentElement.setAttribute('zen-workspace-id', window.uuid);
|
|
await this.saveWorkspaces();
|
|
await this._updateWorkspacesButton();
|
|
await this._propagateWorkspaceData();
|
|
await this._updateWorkspacesChangeContextMenu();
|
|
|
|
document.getElementById('tabbrowser-tabs')._positionPinnedTabs();
|
|
},
|
|
|
|
async _updateWorkspacesChangeContextMenu() {
|
|
const workspaces = await this._workspaces();
|
|
|
|
const menuPopup = document.getElementById('context-zen-change-workspace-tab-menu-popup');
|
|
|
|
menuPopup.innerHTML = '';
|
|
|
|
const activeWorkspace = workspaces.workspaces.find((workspace) => workspace.used);
|
|
|
|
for (let workspace of workspaces.workspaces) {
|
|
const menuItem = document.createXULElement('menuitem');
|
|
menuItem.setAttribute('label', workspace.name);
|
|
menuItem.setAttribute('zen-workspace-id', workspace.uuid);
|
|
|
|
if (workspace.uuid === activeWorkspace.uuid) {
|
|
menuItem.setAttribute('disabled', 'true');
|
|
}
|
|
|
|
menuPopup.appendChild(menuItem);
|
|
}
|
|
},
|
|
|
|
_createWorkspaceData(name, isDefault, icon) {
|
|
let window = {
|
|
uuid: gZenUIManager.generateUuidv4(),
|
|
default: isDefault,
|
|
used: true,
|
|
icon: icon,
|
|
name: name,
|
|
};
|
|
this._prepareNewWorkspace(window);
|
|
return window;
|
|
},
|
|
|
|
async createAndSaveWorkspace(name = 'New Workspace', isDefault = false, icon = undefined) {
|
|
if (!this.workspaceEnabled) {
|
|
return;
|
|
}
|
|
let workspaceData = this._createWorkspaceData(name, isDefault, icon);
|
|
await this.saveWorkspace(workspaceData);
|
|
await this.changeWorkspace(workspaceData);
|
|
},
|
|
|
|
async onTabBrowserInserted(event) {
|
|
let tab = event.originalTarget;
|
|
if (tab.getAttribute('zen-workspace-id') || !this.workspaceEnabled) {
|
|
return;
|
|
}
|
|
let workspaces = await this._workspaces();
|
|
let activeWorkspace = workspaces.workspaces.find((workspace) => workspace.used);
|
|
if (!activeWorkspace) {
|
|
return;
|
|
}
|
|
tab.setAttribute('zen-workspace-id', activeWorkspace.uuid);
|
|
},
|
|
|
|
async onLocationChange(browser) {
|
|
let tab = gBrowser.getTabForBrowser(browser);
|
|
let workspaceID = tab.getAttribute('zen-workspace-id');
|
|
if (!workspaceID) {
|
|
let workspaces = await this._workspaces();
|
|
let activeWorkspace = workspaces.workspaces.find((workspace) => workspace.used);
|
|
if (!activeWorkspace || tab.hasAttribute('hidden')) {
|
|
return;
|
|
}
|
|
tab.setAttribute('zen-workspace-id', activeWorkspace.uuid);
|
|
workspaceID = activeWorkspace.uuid;
|
|
}
|
|
this._lastSelectedWorkspaceTabs[workspaceID] = tab;
|
|
},
|
|
|
|
// Context menu management
|
|
|
|
_contextMenuId: null,
|
|
async updateContextMenu(_) {
|
|
console.assert(this._contextMenuId, 'No context menu ID set');
|
|
document
|
|
.querySelector(`#PanelUI-zen-workspaces [zen-workspace-id="${this._contextMenuId}"] .zen-workspace-actions`)
|
|
.setAttribute('active', 'true');
|
|
const workspaces = await this._workspaces();
|
|
let deleteMenuItem = document.getElementById('context_zenDeleteWorkspace');
|
|
if (
|
|
workspaces.workspaces.length <= 1 ||
|
|
workspaces.workspaces.find((workspace) => workspace.uuid === this._contextMenuId).default
|
|
) {
|
|
deleteMenuItem.setAttribute('disabled', 'true');
|
|
} else {
|
|
deleteMenuItem.removeAttribute('disabled');
|
|
}
|
|
let defaultMenuItem = document.getElementById('context_zenSetAsDefaultWorkspace');
|
|
if (workspaces.workspaces.find((workspace) => workspace.uuid === this._contextMenuId).default) {
|
|
defaultMenuItem.setAttribute('disabled', 'true');
|
|
} else {
|
|
defaultMenuItem.removeAttribute('disabled');
|
|
}
|
|
let openMenuItem = document.getElementById('context_zenOpenWorkspace');
|
|
if (workspaces.workspaces.find((workspace) => workspace.uuid === this._contextMenuId).used) {
|
|
openMenuItem.setAttribute('disabled', 'true');
|
|
} else {
|
|
openMenuItem.removeAttribute('disabled');
|
|
}
|
|
},
|
|
|
|
async contextChangeContainerTab(event) {
|
|
let workspaces = await this._workspaces();
|
|
let workspace = workspaces.workspaces.find((workspace) => workspace.uuid === this._contextMenuId);
|
|
let userContextId = parseInt(event.target.getAttribute('data-usercontextid'));
|
|
workspace.containerTabId = userContextId;
|
|
await this.saveWorkspace(workspace);
|
|
await this._propagateWorkspaceData();
|
|
},
|
|
|
|
onContextMenuClose() {
|
|
let target = document.querySelector(
|
|
`#PanelUI-zen-workspaces [zen-workspace-id="${this._contextMenuId}"] .zen-workspace-actions`
|
|
);
|
|
if (target) {
|
|
target.removeAttribute('active');
|
|
}
|
|
this._contextMenuId = null;
|
|
},
|
|
|
|
async setDefaultWorkspace() {
|
|
let workspaces = await this._workspaces();
|
|
for (let workspace of workspaces.workspaces) {
|
|
workspace.default = workspace.uuid === this._contextMenuId;
|
|
}
|
|
await this.unsafeSaveWorkspaces(workspaces);
|
|
await this._propagateWorkspaceData();
|
|
},
|
|
|
|
async openWorkspace() {
|
|
let workspaces = await this._workspaces();
|
|
let workspace = workspaces.workspaces.find((workspace) => workspace.uuid === this._contextMenuId);
|
|
await this.changeWorkspace(workspace);
|
|
},
|
|
|
|
async contextDelete(event) {
|
|
this.__contextIsDelete = true;
|
|
event.stopPropagation();
|
|
await this.removeWorkspace(this._contextMenuId);
|
|
this.__contextIsDelete = false;
|
|
},
|
|
|
|
async contextEdit(event) {
|
|
event.stopPropagation();
|
|
await this.openEditDialog(this._contextMenuId);
|
|
},
|
|
|
|
async changeWorkspaceShortcut() {
|
|
// Cycle through workspaces
|
|
let workspaces = await this._workspaces();
|
|
let activeWorkspace = workspaces.workspaces.find((workspace) => workspace.used);
|
|
let workspaceIndex = workspaces.workspaces.indexOf(activeWorkspace);
|
|
let nextWorkspace = workspaces.workspaces[workspaceIndex + 1] || workspaces.workspaces[0];
|
|
this.changeWorkspace(nextWorkspace);
|
|
},
|
|
|
|
_initializeWorkspaceTabContextMenus() {
|
|
const menu = document.createXULElement('menu');
|
|
menu.setAttribute('id', 'context-zen-change-workspace-tab');
|
|
menu.setAttribute('data-l10n-id', 'context-zen-change-workspace-tab');
|
|
|
|
const menuPopup = document.createXULElement('menupopup');
|
|
menuPopup.setAttribute('id', 'context-zen-change-workspace-tab-menu-popup');
|
|
menuPopup.setAttribute('oncommand', "ZenWorkspaces.changeTabWorkspace(event.target.getAttribute('zen-workspace-id'))");
|
|
|
|
menu.appendChild(menuPopup);
|
|
|
|
document.getElementById('context_closeDuplicateTabs').after(menu);
|
|
},
|
|
|
|
async changeTabWorkspace(workspaceID) {
|
|
const tabs = TabContextMenu.contextTab.multiselected ? gBrowser.selectedTabs : [TabContextMenu.contextTab];
|
|
const previousWorkspaceID = document.documentElement.getAttribute('zen-workspace-id');
|
|
for (let tab of tabs) {
|
|
tab.setAttribute('zen-workspace-id', workspaceID);
|
|
if (this._lastSelectedWorkspaceTabs[previousWorkspaceID] === tab) {
|
|
// This tab is no longer the last selected tab in the previous workspace because it's being moved to
|
|
// the current workspace
|
|
delete this._lastSelectedWorkspaceTabs[previousWorkspaceID];
|
|
}
|
|
}
|
|
const workspaces = await this._workspaces();
|
|
await this.changeWorkspace(workspaces.workspaces.find((workspace) => workspace.uuid === workspaceID));
|
|
},
|
|
|
|
// Tab browser utilities
|
|
createContainerTabMenu(event) {
|
|
let window = event.target.ownerGlobal;
|
|
const workspace = this._workspaceCache.workspaces.find((workspace) => this._contextMenuId === workspace.uuid);
|
|
let containerTabId = workspace.containerTabId;
|
|
return window.createUserContextMenu(event, {
|
|
isContextMenu: true,
|
|
excludeUserContextId: containerTabId,
|
|
showDefaultTab: true,
|
|
});
|
|
},
|
|
|
|
getContextIdIfNeeded(userContextId) {
|
|
if (typeof userContextId !== 'undefined' || !this.workspaceEnabled) {
|
|
return [userContextId, false];
|
|
}
|
|
const activeWorkspace = this.getActiveWorkspaceFromCache();
|
|
return [activeWorkspace?.containerTabId, true];
|
|
},
|
|
};
|
|
|