forked from ZenBrowserMirrors/zen-desktop
643 lines
21 KiB
JavaScript
643 lines
21 KiB
JavaScript
{
|
|
const lazy = {};
|
|
|
|
class ZenPinnedTabsObserver {
|
|
static ALL_EVENTS = ['TabPinned', 'TabUnpinned', 'TabMove'];
|
|
|
|
#listeners = [];
|
|
|
|
constructor() {
|
|
XPCOMUtils.defineLazyPreferenceGetter(
|
|
lazy,
|
|
'zenPinnedTabRestorePinnedTabsToPinnedUrl',
|
|
'zen.pinned-tab-manager.restore-pinned-tabs-to-pinned-url',
|
|
false
|
|
);
|
|
XPCOMUtils.defineLazyPreferenceGetter(
|
|
lazy,
|
|
'zenPinnedTabCloseShortcutBehavior',
|
|
'zen.pinned-tab-manager.close-shortcut-behavior',
|
|
'switch'
|
|
);
|
|
ChromeUtils.defineESModuleGetters(lazy, { E10SUtils: 'resource://gre/modules/E10SUtils.sys.mjs' });
|
|
this.#listenPinnedTabEvents();
|
|
}
|
|
|
|
#listenPinnedTabEvents() {
|
|
const eventListener = this.#eventListener.bind(this);
|
|
for (const event of ZenPinnedTabsObserver.ALL_EVENTS) {
|
|
window.addEventListener(event, eventListener);
|
|
}
|
|
window.addEventListener('unload', () => {
|
|
for (const event of ZenPinnedTabsObserver.ALL_EVENTS) {
|
|
window.removeEventListener(event, eventListener);
|
|
}
|
|
});
|
|
}
|
|
|
|
#eventListener(event) {
|
|
for (const listener of this.#listeners) {
|
|
listener(event.type, event);
|
|
}
|
|
}
|
|
|
|
addPinnedTabListener(listener) {
|
|
this.#listeners.push(listener);
|
|
}
|
|
}
|
|
|
|
class ZenPinnedTabManager extends ZenDOMOperatedFeature {
|
|
async init() {
|
|
if (!this.enabled) {
|
|
return;
|
|
}
|
|
this._canLog = Services.prefs.getBoolPref('zen.pinned-tab-manager.debug', false);
|
|
this.observer = new ZenPinnedTabsObserver();
|
|
this._initClosePinnedTabShortcut();
|
|
this._insertItemsIntoTabContextMenu();
|
|
this.observer.addPinnedTabListener(this._onPinnedTabEvent.bind(this));
|
|
|
|
this._zenClickEventListener = this._onTabClick.bind(this);
|
|
ZenWorkspaces.addChangeListeners(this.onWorkspaceChange.bind(this));
|
|
|
|
await ZenPinnedTabsStorage.promiseInitialized;
|
|
ZenWorkspaces._resolvePinnedInitialized();
|
|
}
|
|
|
|
async onWorkspaceChange(newWorkspace, onInit) {
|
|
if (!this.enabled || PrivateBrowsingUtils.isWindowPrivate(window)) {
|
|
return;
|
|
}
|
|
|
|
await this._refreshPinnedTabs(newWorkspace, { init: onInit });
|
|
}
|
|
|
|
log(message) {
|
|
if (this._canLog) {
|
|
console.log(`[ZenPinnedTabManager] ${message}`);
|
|
}
|
|
}
|
|
|
|
onTabIconChanged(tab, url = null) {
|
|
const iconUrl = url ?? tab.iconImage.src;
|
|
if (tab.hasAttribute('zen-essential')) {
|
|
tab.querySelector('.tab-background').style.setProperty('--zen-tab-icon', `url(${iconUrl})`);
|
|
}
|
|
}
|
|
|
|
get enabled() {
|
|
if (typeof this._enabled === 'undefined') {
|
|
this._enabled = !(
|
|
PrivateBrowsingUtils.isWindowPrivate(window) ||
|
|
document.documentElement.getAttribute('chromehidden')?.includes('toolbar') ||
|
|
document.documentElement.getAttribute('chromehidden')?.includes('menubar')
|
|
);
|
|
}
|
|
return this._enabled;
|
|
}
|
|
|
|
async _refreshPinnedTabs(currentWorkspace, { init = false } = {}) {
|
|
await this._initializePinsCache();
|
|
await this._initializePinnedTabs(init, currentWorkspace);
|
|
}
|
|
|
|
async _initializePinsCache() {
|
|
try {
|
|
// Get pin data
|
|
const pins = await ZenPinnedTabsStorage.getPins();
|
|
|
|
// Enhance pins with favicons
|
|
const enhancedPins = await Promise.all(
|
|
pins.map(async (pin) => {
|
|
try {
|
|
const image = await this.getFaviconAsBase64(Services.io.newURI(pin.url).spec);
|
|
return {
|
|
...pin,
|
|
iconUrl: image || null,
|
|
};
|
|
} catch (ex) {
|
|
// If favicon fetch fails, continue without icon
|
|
return {
|
|
...pin,
|
|
iconUrl: null,
|
|
};
|
|
}
|
|
})
|
|
);
|
|
|
|
this._pinsCache = enhancedPins.sort((a, b) => {
|
|
if (!a.workspaceUuid && b.workspaceUuid) return -1;
|
|
if (a.workspaceUuid && !b.workspaceUuid) return 1;
|
|
return 0;
|
|
});
|
|
} catch (ex) {
|
|
console.error('Failed to initialize pins cache:', ex);
|
|
this._pinsCache = [];
|
|
}
|
|
|
|
this.log(`Initialized pins cache with ${this._pinsCache.length} pins`);
|
|
return this._pinsCache;
|
|
}
|
|
|
|
async _initializePinnedTabs(init = false, currentWorkspace) {
|
|
const pins = this._pinsCache;
|
|
if (!pins?.length) {
|
|
return;
|
|
}
|
|
|
|
const workspaces = await ZenWorkspaces._workspaces();
|
|
|
|
const activeTab = gBrowser.selectedTab;
|
|
const pinnedTabsByUUID = new Map();
|
|
const pinsToCreate = new Set(pins.map((p) => p.uuid));
|
|
|
|
// First pass: identify existing tabs and remove those without pins
|
|
for (let tab of gBrowser.tabs) {
|
|
const pinId = tab.getAttribute('zen-pin-id');
|
|
if (!pinId) {
|
|
continue;
|
|
}
|
|
|
|
if (pinsToCreate.has(pinId)) {
|
|
// This is a valid pinned tab that matches a pin
|
|
pinnedTabsByUUID.set(pinId, tab);
|
|
pinsToCreate.delete(pinId);
|
|
|
|
if (lazy.zenPinnedTabRestorePinnedTabsToPinnedUrl && init) {
|
|
this._resetTabToStoredState(tab);
|
|
}
|
|
} else {
|
|
// This is a pinned tab that no longer has a corresponding pin
|
|
gBrowser.removeTab(tab);
|
|
}
|
|
}
|
|
|
|
// Second pass: create new tabs for pins that don't have tabs
|
|
for (let pin of pins) {
|
|
if (!pinsToCreate.has(pin.uuid)) {
|
|
continue; // Skip pins that already have tabs
|
|
}
|
|
|
|
if (!this._shouldShowPin(pin, currentWorkspace, workspaces)) {
|
|
continue; // Skip pins not relevant to current workspace
|
|
}
|
|
|
|
let params = {
|
|
skipAnimation: true,
|
|
allowInheritPrincipal: false,
|
|
skipBackgroundNotify: true,
|
|
userContextId: pin.containerTabId || 0,
|
|
createLazyBrowser: true,
|
|
skipLoad: true,
|
|
noInitialLabel: false,
|
|
};
|
|
|
|
// Create and initialize the tab
|
|
let newTab = gBrowser.addTrustedTab(pin.url, params);
|
|
|
|
// Set initial label/title
|
|
if (pin.title) {
|
|
gBrowser.setInitialTabTitle(newTab, pin.title);
|
|
}
|
|
|
|
// Set the icon if we have it cached
|
|
if (pin.iconUrl) {
|
|
gBrowser.setIcon(newTab, pin.iconUrl);
|
|
}
|
|
|
|
newTab.setAttribute('zen-pin-id', pin.uuid);
|
|
|
|
if (pin.workspaceUuid) {
|
|
newTab.setAttribute('zen-workspace-id', pin.workspaceUuid);
|
|
}
|
|
|
|
if (pin.isEssential) {
|
|
newTab.setAttribute('zen-essential', 'true');
|
|
}
|
|
|
|
// Initialize browser state if needed
|
|
if (!newTab.linkedBrowser._remoteAutoRemoved) {
|
|
let state = {
|
|
entries: [
|
|
{
|
|
url: pin.url,
|
|
title: pin.title,
|
|
triggeringPrincipal_base64: E10SUtils.SERIALIZED_SYSTEMPRINCIPAL,
|
|
},
|
|
],
|
|
userContextId: pin.containerTabId || 0,
|
|
image: pin.iconUrl,
|
|
};
|
|
|
|
SessionStore.setTabState(newTab, state);
|
|
}
|
|
|
|
this.log(`Created new pinned tab for pin ${pin.uuid} (isEssential: ${pin.isEssential})`);
|
|
gBrowser.pinTab(newTab);
|
|
|
|
newTab.initialize();
|
|
}
|
|
|
|
// Restore active tab
|
|
if (!activeTab.closing) {
|
|
gBrowser.selectedTab = activeTab;
|
|
}
|
|
|
|
gBrowser._updateTabBarForPinnedTabs();
|
|
}
|
|
|
|
_shouldShowPin(pin, currentWorkspace, workspaces) {
|
|
const isEssential = pin.isEssential;
|
|
const pinWorkspaceUuid = pin.workspaceUuid;
|
|
const pinContextId = pin.containerTabId ? pin.containerTabId.toString() : '0';
|
|
const workspaceContextId = currentWorkspace.containerTabId?.toString() || '0';
|
|
const containerSpecificEssentials = ZenWorkspaces.containerSpecificEssentials;
|
|
|
|
// Handle essential pins
|
|
if (isEssential) {
|
|
if (!containerSpecificEssentials) {
|
|
return true; // Show all essential pins when containerSpecificEssentials is false
|
|
}
|
|
|
|
if (workspaceContextId !== '0') {
|
|
// In workspaces with default container: Show essentials that match the container
|
|
return pinContextId === workspaceContextId;
|
|
} else {
|
|
// In workspaces without a default container: Show essentials that aren't in container-specific workspaces
|
|
// or have userContextId="0" or no userContextId
|
|
return (
|
|
!pinContextId ||
|
|
pinContextId === '0' ||
|
|
!workspaces.workspaces.some((workspace) => workspace.containerTabId === parseInt(pinContextId, 10))
|
|
);
|
|
}
|
|
}
|
|
|
|
// For non-essential pins
|
|
if (!pinWorkspaceUuid) {
|
|
// Pins without a workspace belong to all workspaces (if that's your desired behavior)
|
|
return true;
|
|
}
|
|
|
|
// Show if pin belongs to current workspace
|
|
return pinWorkspaceUuid === currentWorkspace.uuid;
|
|
}
|
|
|
|
_onPinnedTabEvent(action, event) {
|
|
if (!this.enabled) return;
|
|
const tab = event.target;
|
|
switch (action) {
|
|
case 'TabPinned':
|
|
tab._zenClickEventListener = this._zenClickEventListener;
|
|
tab.addEventListener('click', tab._zenClickEventListener);
|
|
this._setPinnedAttributes(tab);
|
|
break;
|
|
case 'TabUnpinned':
|
|
this._removePinnedAttributes(tab);
|
|
if (tab._zenClickEventListener) {
|
|
tab.removeEventListener('click', tab._zenClickEventListener);
|
|
delete tab._zenClickEventListener;
|
|
}
|
|
break;
|
|
case 'TabMove':
|
|
this._onTabMove(tab);
|
|
break;
|
|
default:
|
|
console.warn('ZenPinnedTabManager: Unhandled tab event', action);
|
|
break;
|
|
}
|
|
}
|
|
|
|
async _onTabMove(tab) {
|
|
if (!tab.pinned) {
|
|
return;
|
|
}
|
|
|
|
// Recollect pinned tabs and essentials after a tab move
|
|
const currentWorkspace = await ZenWorkspaces.getActiveWorkspace();
|
|
|
|
tab.position = tab._tPos;
|
|
|
|
for (let otherTab of gBrowser.tabs) {
|
|
if (otherTab.pinned && otherTab._tPos > tab.position) {
|
|
const actualPin = this._pinsCache.find((pin) => pin.uuid === otherTab.getAttribute('zen-pin-id'));
|
|
actualPin.position = otherTab._tPos;
|
|
await ZenPinnedTabsStorage.savePin(actualPin, false);
|
|
}
|
|
}
|
|
|
|
const actualPin = this._pinsCache.find((pin) => pin.uuid === tab.getAttribute('zen-pin-id'));
|
|
actualPin.position = tab.position;
|
|
await ZenPinnedTabsStorage.savePin(actualPin);
|
|
}
|
|
|
|
_onTabClick(e) {
|
|
const tab = e.target?.closest('tab');
|
|
if (e.button === 1 && tab) {
|
|
this._onCloseTabShortcut(e, tab);
|
|
}
|
|
}
|
|
|
|
async resetPinnedTab(tab) {
|
|
if (!tab) {
|
|
tab = TabContextMenu.contextTab;
|
|
}
|
|
|
|
if (!tab || !tab.pinned) {
|
|
return;
|
|
}
|
|
|
|
await this._resetTabToStoredState(tab);
|
|
}
|
|
|
|
async replacePinnedUrlWithCurrent() {
|
|
const tab = TabContextMenu.contextTab;
|
|
if (!tab || !tab.pinned || !tab.getAttribute('zen-pin-id')) {
|
|
return;
|
|
}
|
|
|
|
const browser = tab.linkedBrowser;
|
|
|
|
const pin = this._pinsCache.find((pin) => pin.uuid === tab.getAttribute('zen-pin-id'));
|
|
|
|
if (!pin) {
|
|
return;
|
|
}
|
|
|
|
const userContextId = tab.getAttribute('usercontextid');
|
|
|
|
pin.title = tab.label || browser.contentTitle;
|
|
pin.url = browser.currentURI.spec;
|
|
pin.workspaceUuid = tab.getAttribute('zen-workspace-id');
|
|
pin.userContextId = userContextId ? parseInt(userContextId, 10) : 0;
|
|
|
|
await ZenPinnedTabsStorage.savePin(pin);
|
|
const currentWorkspace = await ZenWorkspaces.getActiveWorkspace();
|
|
await this._refreshPinnedTabs(currentWorkspace);
|
|
}
|
|
|
|
async _setPinnedAttributes(tab) {
|
|
if (tab.hasAttribute('zen-pin-id')) {
|
|
return;
|
|
}
|
|
|
|
this.log(`Setting pinned attributes for tab ${tab.linkedBrowser.currentURI.spec}`);
|
|
const browser = tab.linkedBrowser;
|
|
|
|
const uuid = gZenUIManager.generateUuidv4();
|
|
const userContextId = tab.getAttribute('usercontextid');
|
|
|
|
let entry = null;
|
|
|
|
if (tab.getAttribute('zen-pinned-entry')) {
|
|
entry = JSON.parse(tab.getAttribute('zen-pinned-entry'));
|
|
}
|
|
|
|
await ZenPinnedTabsStorage.savePin({
|
|
uuid,
|
|
title: entry?.title || tab.label || browser.contentTitle,
|
|
url: entry?.url || browser.currentURI.spec,
|
|
containerTabId: userContextId ? parseInt(userContextId, 10) : 0,
|
|
workspaceUuid: tab.getAttribute('zen-workspace-id'),
|
|
isEssential: tab.getAttribute('zen-essential') === 'true',
|
|
});
|
|
|
|
tab.setAttribute('zen-pin-id', uuid);
|
|
|
|
// This is used while migrating old pins to new system - we don't want to refresh when migrating
|
|
if (tab.getAttribute('zen-pinned-entry')) {
|
|
tab.removeAttribute('zen-pinned-entry');
|
|
return;
|
|
}
|
|
const currentWorkspace = await ZenWorkspaces.getActiveWorkspace();
|
|
await this._refreshPinnedTabs(currentWorkspace);
|
|
}
|
|
|
|
async _removePinnedAttributes(tab, isClosing = false) {
|
|
if (!tab.getAttribute('zen-pin-id') || this._temporarilyUnpiningEssential) {
|
|
this._temporarilyUnpiningEssential = false;
|
|
return;
|
|
}
|
|
|
|
if (Services.startup.shuttingDown || window.skipNextCanClose) {
|
|
return;
|
|
}
|
|
|
|
this.log(`Removing pinned attributes for tab ${tab.getAttribute('zen-pin-id')}`);
|
|
await ZenPinnedTabsStorage.removePin(tab.getAttribute('zen-pin-id'));
|
|
|
|
if (!isClosing) {
|
|
tab.removeAttribute('zen-pin-id');
|
|
|
|
if (!tab.hasAttribute('zen-workspace-id') && ZenWorkspaces.workspaceEnabled) {
|
|
const workspace = await ZenWorkspaces.getActiveWorkspace();
|
|
tab.setAttribute('zen-workspace-id', workspace.uuid);
|
|
}
|
|
}
|
|
const currentWorkspace = await ZenWorkspaces.getActiveWorkspace();
|
|
await this._refreshPinnedTabs(currentWorkspace);
|
|
}
|
|
|
|
_initClosePinnedTabShortcut() {
|
|
let cmdClose = document.getElementById('cmd_close');
|
|
|
|
if (cmdClose) {
|
|
cmdClose.addEventListener('command', this._onCloseTabShortcut.bind(this));
|
|
}
|
|
}
|
|
|
|
_onCloseTabShortcut(event, selectedTab = gBrowser.selectedTab) {
|
|
if (!selectedTab?.pinned) {
|
|
return;
|
|
}
|
|
|
|
event.stopPropagation();
|
|
event.preventDefault();
|
|
|
|
const behavior = lazy.zenPinnedTabCloseShortcutBehavior;
|
|
|
|
switch (behavior) {
|
|
case 'close':
|
|
this._removePinnedAttributes(selectedTab, true);
|
|
gBrowser.removeTab(selectedTab, { animate: true });
|
|
break;
|
|
case 'reset-unload-switch':
|
|
case 'unload-switch':
|
|
case 'reset-switch':
|
|
case 'switch':
|
|
this._handleTabSwitch(selectedTab);
|
|
if (behavior.includes('reset')) {
|
|
this._resetTabToStoredState(selectedTab);
|
|
}
|
|
if (behavior.includes('unload')) {
|
|
gBrowser.discardBrowser(selectedTab);
|
|
}
|
|
break;
|
|
case 'reset':
|
|
this._resetTabToStoredState(selectedTab);
|
|
break;
|
|
default:
|
|
return;
|
|
}
|
|
}
|
|
|
|
_handleTabSwitch(selectedTab) {
|
|
if (selectedTab !== gBrowser.selectedTab) {
|
|
return;
|
|
}
|
|
const findNextTab = (direction) =>
|
|
gBrowser.tabContainer.findNextTab(selectedTab, {
|
|
direction,
|
|
filter: (tab) => !tab.hidden && !tab.pinned,
|
|
});
|
|
|
|
let nextTab = findNextTab(1) || findNextTab(-1);
|
|
|
|
if (!nextTab) {
|
|
ZenWorkspaces._createNewTabForWorkspace({ uuid: ZenWorkspaces.activeWorkspace });
|
|
|
|
nextTab = findNextTab(1) || findNextTab(-1);
|
|
}
|
|
|
|
if (nextTab) {
|
|
gBrowser.selectedTab = nextTab;
|
|
}
|
|
}
|
|
|
|
async _resetTabToStoredState(tab) {
|
|
const id = tab.getAttribute('zen-pin-id');
|
|
if (!id) {
|
|
return;
|
|
}
|
|
|
|
const pin = this._pinsCache.find((pin) => pin.uuid === id);
|
|
if (!pin) {
|
|
return;
|
|
}
|
|
|
|
const tabState = SessionStore.getTabState(tab);
|
|
const state = JSON.parse(tabState);
|
|
|
|
state.entries = [
|
|
{
|
|
url: pin.url,
|
|
title: pin.title,
|
|
triggeringPrincipal_base64: lazy.E10SUtils.SERIALIZED_SYSTEMPRINCIPAL,
|
|
},
|
|
];
|
|
|
|
state.image = pin.iconUrl || null;
|
|
state.index = 0;
|
|
|
|
SessionStore.setTabState(tab, state);
|
|
}
|
|
|
|
async getFaviconAsBase64(pageUrl) {
|
|
try {
|
|
// Get the favicon data
|
|
const faviconData = await PlacesUtils.promiseFaviconData(pageUrl);
|
|
|
|
// The data comes as an array buffer, we need to convert it to base64
|
|
// First create a byte array from the data
|
|
const array = new Uint8Array(faviconData.data);
|
|
|
|
// Convert to base64
|
|
const base64String = btoa(
|
|
Array.from(array)
|
|
.map((b) => String.fromCharCode(b))
|
|
.join('')
|
|
);
|
|
|
|
// Return as a proper data URL
|
|
return `data:${faviconData.mimeType};base64,${base64String}`;
|
|
} catch (ex) {
|
|
// console.error("Failed to get favicon:", ex);
|
|
return `page-icon:${pageUrl}`; // Use this as a fallback
|
|
}
|
|
}
|
|
|
|
addToEssentials() {
|
|
const tabs = TabContextMenu.contextTab.multiselected ? gBrowser.selectedTabs : [TabContextMenu.contextTab];
|
|
for (let i = 0; i < tabs.length; i++) {
|
|
const tab = tabs[i];
|
|
tab.setAttribute('zen-essential', 'true');
|
|
if (tab.hasAttribute('zen-workspace-id')) {
|
|
tab.removeAttribute('zen-workspace-id');
|
|
}
|
|
if (tab.pinned) {
|
|
this._temporarilyUnpiningEssential = true;
|
|
gBrowser.unpinTab(tab);
|
|
}
|
|
gBrowser.pinTab(tab);
|
|
this.onTabIconChanged(tab);
|
|
}
|
|
}
|
|
|
|
removeEssentials() {
|
|
const tabs = TabContextMenu.contextTab.multiselected ? gBrowser.selectedTabs : [TabContextMenu.contextTab];
|
|
for (let i = 0; i < tabs.length; i++) {
|
|
const tab = tabs[i];
|
|
tab.removeAttribute('zen-essential');
|
|
if (ZenWorkspaces.workspaceEnabled && ZenWorkspaces.getActiveWorkspaceFromCache.uuid) {
|
|
tab.setAttribute('zen-workspace-id', ZenWorkspaces.getActiveWorkspaceFromCache.uuid);
|
|
}
|
|
gBrowser.unpinTab(tab);
|
|
}
|
|
}
|
|
|
|
_insertItemsIntoTabContextMenu() {
|
|
const elements = window.MozXULElement.parseXULToFragment(`
|
|
<menuseparator id="context_zen-pinned-tab-separator" hidden="true"/>
|
|
<menuitem id="context_zen-replace-pinned-url-with-current"
|
|
data-lazy-l10n-id="tab-context-zen-replace-pinned-url-with-current"
|
|
hidden="true"
|
|
oncommand="gZenPinnedTabManager.replacePinnedUrlWithCurrent();"/>
|
|
<menuitem id="context_zen-reset-pinned-tab"
|
|
data-lazy-l10n-id="tab-context-zen-reset-pinned-tab"
|
|
hidden="true"
|
|
oncommand="gZenPinnedTabManager.resetPinnedTab();"/>
|
|
`);
|
|
document.getElementById('tabContextMenu').appendChild(elements);
|
|
|
|
const element = window.MozXULElement.parseXULToFragment(`
|
|
<menuitem id="context_zen-add-essential"
|
|
data-lazy-l10n-id="tab-context-zen-add-essential"
|
|
hidden="true"
|
|
oncommand="gZenPinnedTabManager.addToEssentials();"/>
|
|
<menuitem id="context_zen-remove-essential"
|
|
data-lazy-l10n-id="tab-context-zen-remove-essential"
|
|
hidden="true"
|
|
oncommand="gZenPinnedTabManager.removeEssentials();"/>
|
|
`);
|
|
|
|
document.getElementById('context_pinTab')?.before(element);
|
|
}
|
|
|
|
// TODO: remove this as it's not possible to know the base pinned url any more as it's now stored in tab state
|
|
resetPinnedTabData(tabData) {
|
|
if (lazy.zenPinnedTabRestorePinnedTabsToPinnedUrl && tabData.pinned && tabData.zenPinnedEntry) {
|
|
tabData.entries = [JSON.parse(tabData.zenPinnedEntry)];
|
|
tabData.image = tabData.zenPinnedIcon;
|
|
tabData.index = 0;
|
|
}
|
|
}
|
|
|
|
updatePinnedTabContextMenu(contextTab) {
|
|
if (!this.enabled) {
|
|
return;
|
|
}
|
|
const isVisible = contextTab.pinned && !contextTab.multiselected;
|
|
document.getElementById('context_zen-reset-pinned-tab').hidden = !isVisible || !contextTab.getAttribute('zen-pin-id');
|
|
document.getElementById('context_zen-replace-pinned-url-with-current').hidden = !isVisible;
|
|
document.getElementById('context_zen-add-essential').hidden = contextTab.getAttribute('zen-essential');
|
|
document.getElementById('context_zen-remove-essential').hidden = !contextTab.getAttribute('zen-essential');
|
|
document.getElementById('context_unpinTab').hidden =
|
|
document.getElementById('context_unpinTab').hidden || contextTab.getAttribute('zen-essential');
|
|
document.getElementById('context_unpinSelectedTabs').hidden =
|
|
document.getElementById('context_unpinSelectedTabs').hidden || contextTab.getAttribute('zen-essential');
|
|
document.getElementById('context_zen-pinned-tab-separator').hidden = !isVisible;
|
|
}
|
|
}
|
|
|
|
window.gZenPinnedTabManager = new ZenPinnedTabManager();
|
|
}
|