mirror of
https://github.com/zen-browser/desktop.git
synced 2025-10-05 17:36:34 +00:00
464 lines
14 KiB
JavaScript
464 lines
14 KiB
JavaScript
{
|
|
const lazy = {};
|
|
|
|
class ZenPinnedTabsObserver {
|
|
static ALL_EVENTS = ['TabPinned', 'TabUnpinned', 'TabClose'];
|
|
|
|
#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 ZenPreloadedFeature {
|
|
|
|
init() {
|
|
this.observer = new ZenPinnedTabsObserver();
|
|
this._initClosePinnedTabShortcut();
|
|
this._insertItemsIntoTabContextMenu();
|
|
this.observer.addPinnedTabListener(this._onPinnedTabEvent.bind(this));
|
|
|
|
this._zenClickEventListener = this._onTabClick.bind(this);
|
|
}
|
|
|
|
async initTabs() {
|
|
await ZenPinnedTabsStorage.init();
|
|
}
|
|
|
|
async _refreshPinnedTabs() {
|
|
await this._initializePinsCache();
|
|
this._initializePinnedTabs();
|
|
}
|
|
|
|
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 faviconData = await PlacesUtils.promiseFaviconData(pin.url);
|
|
return {
|
|
...pin,
|
|
iconUrl: faviconData?.uri?.spec || 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 = [];
|
|
}
|
|
|
|
return this._pinsCache;
|
|
}
|
|
|
|
_initializePinnedTabs() {
|
|
const pins = this._pinsCache;
|
|
if (!pins?.length) {
|
|
return;
|
|
}
|
|
|
|
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);
|
|
} 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
|
|
}
|
|
|
|
let newTab = gBrowser.addTrustedTab(pin.url, {
|
|
skipAnimation: true,
|
|
userContextId: pin.containerTabId || 0,
|
|
allowInheritPrincipal: false,
|
|
createLazyBrowser: true,
|
|
skipLoad: true,
|
|
});
|
|
|
|
// Set the favicon from cache
|
|
if (!!pin.iconUrl) {
|
|
// TODO: Figure out if there is a better way -
|
|
// calling gBrowser.setIcon messes shit up and should be avoided. I think this works for now.
|
|
newTab.setAttribute("image", pin.iconUrl);
|
|
}
|
|
|
|
newTab.setAttribute("zen-pin-id", pin.uuid);
|
|
gBrowser.setInitialTabTitle(newTab, pin.title);
|
|
|
|
if (pin.workspaceUuid) {
|
|
newTab.setAttribute("zen-workspace-id", pin.workspaceUuid);
|
|
}
|
|
|
|
if (pin.isEssential) {
|
|
newTab.setAttribute("zen-essential", "true");
|
|
}
|
|
|
|
gBrowser.pinTab(newTab);
|
|
}
|
|
|
|
// Restore active tab
|
|
if (!activeTab.closing) {
|
|
gBrowser.selectedTab = activeTab;
|
|
}
|
|
}
|
|
|
|
_onPinnedTabEvent(action, event) {
|
|
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 "TabClose":
|
|
this._removePinnedAttributes(tab);
|
|
break;
|
|
default:
|
|
console.warn('ZenPinnedTabManager: Unhandled tab event', action);
|
|
break;
|
|
}
|
|
}
|
|
|
|
_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);
|
|
await this._refreshPinnedTabs();
|
|
}
|
|
|
|
async _setPinnedAttributes(tab) {
|
|
|
|
if (tab.hasAttribute("zen-pin-id")) {
|
|
return;
|
|
}
|
|
|
|
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;
|
|
}
|
|
|
|
await this._refreshPinnedTabs();
|
|
}
|
|
|
|
async _removePinnedAttributes(tab) {
|
|
if(!tab.getAttribute("zen-pin-id")) {
|
|
return;
|
|
}
|
|
|
|
await ZenPinnedTabsStorage.removePin(tab.getAttribute("zen-pin-id"));
|
|
|
|
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);
|
|
}
|
|
|
|
await this._refreshPinnedTabs();
|
|
}
|
|
|
|
_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':
|
|
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) {
|
|
const tabState = SessionStore.getTabState(tab);
|
|
const state = JSON.parse(tabState);
|
|
let icon = undefined;
|
|
try {
|
|
icon = await PlacesUtils.promiseFaviconData(pin.url);
|
|
} catch (e) {
|
|
console.warn("Error trying to get favicon for pinned tab", e);
|
|
}
|
|
|
|
state.entries = [{
|
|
url: pin.url,
|
|
title: pin.title,
|
|
triggeringPrincipal_base64: lazy.E10SUtils.SERIALIZED_SYSTEMPRINCIPAL
|
|
}];
|
|
if (icon instanceof Ci.nsIURI || typeof icon === "string") {
|
|
state.image = icon;
|
|
} else {
|
|
state.image = null;
|
|
}
|
|
state.index = 0;
|
|
|
|
SessionStore.setTabState(tab, state);
|
|
}
|
|
}
|
|
|
|
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) {
|
|
gBrowser.unpinTab(tab);
|
|
}
|
|
gBrowser.pinTab(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')?.after(element);
|
|
}
|
|
|
|
resetPinnedTabData(tabData) {
|
|
if (lazy.zenPinnedTabRestorePinnedTabsToPinnedUrl && tabData.pinned && tabData.zenPinnedEntry) {
|
|
tabData.entries = [JSON.parse(tabData.zenPinnedEntry)];
|
|
tabData.image = tabData.zenPinnedIcon;
|
|
tabData.index = 0;
|
|
}
|
|
}
|
|
|
|
updatePinnedTabContextMenu(contextTab) {
|
|
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();
|
|
} |