/* This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this file, * You can obtain one at http://mozilla.org/MPL/2.0/. */ /* eslint-env mozilla/browser-window */ /** * The base view implements everything that's common to all the views. * It should not be instanced directly, use a derived class instead. */ class PlacesViewBase { /** * @param {string} placesUrl * The query string associated with the view. * @param {DOMElement} rootElt * The root element for the view. * @param {DOMElement} viewElt * The view element. */ constructor(placesUrl, rootElt, viewElt) { this._rootElt = rootElt; this._viewElt = viewElt; // Do initialization in subclass now that `this` exists. this._init?.(); this._controller = new PlacesController(this); this.place = placesUrl; this._viewElt.controllers.appendController(this._controller); } // The xul element that holds the entire view. _viewElt = null; get associatedElement() { return this._viewElt; } get controllers() { return this._viewElt.controllers; } // The xul element that represents the root container. _rootElt = null; // Set to true for views that are represented by native widgets (i.e. // the native mac menu). _nativeView = false; static interfaces = [ Ci.nsINavHistoryResultObserver, Ci.nsISupportsWeakReference, ]; QueryInterface = ChromeUtils.generateQI(PlacesViewBase.interfaces); _place = ""; get place() { return this._place; } set place(val) { this._place = val; let history = PlacesUtils.history; let query = {}, options = {}; history.queryStringToQuery(val, query, options); let result = history.executeQuery(query.value, options.value); result.addObserver(this); } _result = null; get result() { return this._result; } set result(val) { if (this._result == val) { return; } if (this._result) { this._result.removeObserver(this); this._resultNode.containerOpen = false; } if (this._rootElt.localName == "menupopup") { this._rootElt._built = false; } this._result = val; if (val) { this._resultNode = val.root; this._rootElt._placesNode = this._resultNode; this._domNodes = new Map(); this._domNodes.set(this._resultNode, this._rootElt); // This calls _rebuild through invalidateContainer. this._resultNode.containerOpen = true; } else { this._resultNode = null; delete this._domNodes; } } /** * Gets the DOM node used for the given places node. * * @param {object} aPlacesNode * a places result node. * @param {boolean} aAllowMissing * whether the node may be missing * @returns {object|null} The associated DOM node. * @throws if there is no DOM node set for aPlacesNode. */ _getDOMNodeForPlacesNode(aPlacesNode, aAllowMissing = false) { let node = this._domNodes.get(aPlacesNode, null); if (!node && !aAllowMissing) { throw new Error( "No DOM node set for aPlacesNode.\nnode.type: " + aPlacesNode.type + ". node.parent: " + aPlacesNode ); } return node; } get controller() { return this._controller; } get selType() { return "single"; } selectItems() {} selectAll() {} get selectedNode() { if (this._contextMenuShown) { let anchor = this._contextMenuShown.triggerNode; if (!anchor) { return null; } if (anchor._placesNode) { return this._rootElt == anchor ? null : anchor._placesNode; } anchor = anchor.parentNode; return this._rootElt == anchor ? null : anchor._placesNode || null; } return null; } get hasSelection() { return this.selectedNode != null; } get selectedNodes() { let selectedNode = this.selectedNode; return selectedNode ? [selectedNode] : []; } get singleClickOpens() { return true; } get removableSelectionRanges() { // On static content the current selectedNode would be the selection's // parent node. We don't want to allow removing a node when the // selection is not explicit. let popupNode = PlacesUIUtils.lastContextMenuTriggerNode; if (popupNode && (popupNode == "menupopup" || !popupNode._placesNode)) { return []; } return [this.selectedNodes]; } get draggableSelection() { return [this._draggedElt]; } get insertionPoint() { // There is no insertion point for history queries, so bail out now and // save a lot of work when updating commands. let resultNode = this._resultNode; if ( PlacesUtils.nodeIsQuery(resultNode) && PlacesUtils.asQuery(resultNode).queryOptions.queryType == Ci.nsINavHistoryQueryOptions.QUERY_TYPE_HISTORY ) { return null; } // By default, the insertion point is at the top level, at the end. let index = PlacesUtils.bookmarks.DEFAULT_INDEX; let container = this._resultNode; let orientation = Ci.nsITreeView.DROP_BEFORE; let tagName = null; let selectedNode = this.selectedNode; if (selectedNode) { let popupNode = PlacesUIUtils.lastContextMenuTriggerNode; if ( !popupNode._placesNode || popupNode._placesNode == this._resultNode || popupNode._placesNode.itemId == -1 || !selectedNode.parent ) { // If a static menuitem is selected, or if the root node is selected, // the insertion point is inside the folder, at the end. container = selectedNode; orientation = Ci.nsITreeView.DROP_ON; } else { // In all other cases the insertion point is before that node. container = selectedNode.parent; index = container.getChildIndex(selectedNode); if (PlacesUtils.nodeIsTagQuery(container)) { tagName = PlacesUtils.asQuery(container).query.tags[0]; } } } if (this.controller.disallowInsertion(container)) { return null; } return new PlacesInsertionPoint({ parentGuid: PlacesUtils.getConcreteItemGuid(container), index, orientation, tagName, }); } buildContextMenu(aPopup) { this._contextMenuShown = aPopup; window.updateCommands("places"); // Ensure that an existing "Show Other Bookmarks" item is removed before adding it // again. let existingOtherBookmarksItem = aPopup.querySelector( "#show-other-bookmarks_PersonalToolbar" ); existingOtherBookmarksItem?.remove(); let manageBookmarksMenu = aPopup.querySelector( "#placesContext_showAllBookmarks" ); // Add the View menu for the Bookmarks Toolbar and "Show Other Bookmarks" menu item // if the click originated from the Bookmarks Toolbar. let existingSubmenu = aPopup.querySelector("#toggle_PersonalToolbar"); existingSubmenu?.remove(); let bookmarksToolbar = document.getElementById("PersonalToolbar"); if (bookmarksToolbar?.contains(aPopup.triggerNode)) { manageBookmarksMenu.removeAttribute("hidden"); let menu = BookmarkingUI.buildBookmarksToolbarSubmenu(bookmarksToolbar); aPopup.insertBefore(menu, manageBookmarksMenu); if ( aPopup.triggerNode.id === "OtherBookmarks" || aPopup.triggerNode.id === "PlacesChevron" || aPopup.triggerNode.id === "PlacesToolbarItems" || aPopup.triggerNode.parentNode.id === "PlacesToolbarItems" ) { let otherBookmarksMenuItem = BookmarkingUI.buildShowOtherBookmarksMenuItem(); if (otherBookmarksMenuItem) { aPopup.insertBefore(otherBookmarksMenuItem, menu.nextElementSibling); } } } else { manageBookmarksMenu.setAttribute("hidden", "true"); } return this.controller.buildContextMenu(aPopup); } destroyContextMenu() { this._contextMenuShown = null; } clearAllContents(aPopup) { let kid = aPopup.firstElementChild; while (kid) { let next = kid.nextElementSibling; if (!kid.classList.contains("panel-header")) { kid.remove(); } kid = next; } aPopup._emptyMenuitem = aPopup._startMarker = aPopup._endMarker = null; } _cleanPopup(aPopup, aDelay) { // Ensure markers are here when `invalidateContainer` is called before the // popup is shown, which may the case for panelviews, for example. this._ensureMarkers(aPopup); // Remove Places nodes from the popup. let child = aPopup._startMarker; while (child.nextElementSibling != aPopup._endMarker) { let sibling = child.nextElementSibling; if (sibling._placesNode && !aDelay) { aPopup.removeChild(sibling); } else if (sibling._placesNode && aDelay) { // HACK (bug 733419): the popups originating from the OS X native // menubar don't live-update while open, thus we don't clean it // until the next popupshowing, to avoid zombie menuitems. if (!aPopup._delayedRemovals) { aPopup._delayedRemovals = []; } aPopup._delayedRemovals.push(sibling); child = child.nextElementSibling; } else { child = child.nextElementSibling; } } } _rebuildPopup(aPopup) { let resultNode = aPopup._placesNode; if (!resultNode.containerOpen) { return; } this._cleanPopup(aPopup); let cc = resultNode.childCount; if (cc > 0) { this._setEmptyPopupStatus(aPopup, false); let fragment = document.createDocumentFragment(); for (let i = 0; i < cc; ++i) { let child = resultNode.getChild(i); this._insertNewItemToPopup(child, fragment); } aPopup.insertBefore(fragment, aPopup._endMarker); } else { this._setEmptyPopupStatus(aPopup, true); } aPopup._built = true; } _removeChild(aChild) { aChild.remove(); } _setEmptyPopupStatus(aPopup, aEmpty) { if (!aPopup._emptyMenuitem) { aPopup._emptyMenuitem = document.createXULElement("menuitem"); aPopup._emptyMenuitem.setAttribute("disabled", true); aPopup._emptyMenuitem.className = "bookmark-item"; document.l10n.setAttributes( aPopup._emptyMenuitem, "places-empty-bookmarks-folder" ); } if (aEmpty) { aPopup.setAttribute("emptyplacesresult", "true"); // Don't add the menuitem if there is static content. if ( !aPopup._startMarker.previousElementSibling && !aPopup._endMarker.nextElementSibling ) { aPopup.insertBefore(aPopup._emptyMenuitem, aPopup._endMarker); } } else { aPopup.removeAttribute("emptyplacesresult"); try { aPopup.removeChild(aPopup._emptyMenuitem); } catch (ex) {} } } _createDOMNodeForPlacesNode(aPlacesNode) { this._domNodes.delete(aPlacesNode); let element; let type = aPlacesNode.type; if (type == Ci.nsINavHistoryResultNode.RESULT_TYPE_SEPARATOR) { element = document.createXULElement("menuseparator"); } else { if (type == Ci.nsINavHistoryResultNode.RESULT_TYPE_URI) { element = document.createXULElement("menuitem"); element.className = "menuitem-iconic bookmark-item menuitem-with-favicon"; element.setAttribute( "scheme", PlacesUIUtils.guessUrlSchemeForUI(aPlacesNode.uri) ); } else if (PlacesUtils.containerTypes.includes(type)) { element = document.createXULElement("menu"); element.setAttribute("container", "true"); if (aPlacesNode.type == Ci.nsINavHistoryResultNode.RESULT_TYPE_QUERY) { element.setAttribute("query", "true"); if (PlacesUtils.nodeIsTagQuery(aPlacesNode)) { element.setAttribute("tagContainer", "true"); } else if (PlacesUtils.nodeIsDay(aPlacesNode)) { element.setAttribute("dayContainer", "true"); } else if (PlacesUtils.nodeIsHost(aPlacesNode)) { element.setAttribute("hostContainer", "true"); } } let popup = document.createXULElement("menupopup", { is: "places-popup", }); popup._placesNode = PlacesUtils.asContainer(aPlacesNode); if (!this._nativeView) { popup.setAttribute("placespopup", "true"); } element.appendChild(popup); element.className = "menu-iconic bookmark-item"; this._domNodes.set(aPlacesNode, popup); } else { throw new Error("Unexpected node"); } element.setAttribute("label", PlacesUIUtils.getBestTitle(aPlacesNode)); let icon = aPlacesNode.icon; if (icon) { element.setAttribute("image", icon); } } element._placesNode = aPlacesNode; if (!this._domNodes.has(aPlacesNode)) { this._domNodes.set(aPlacesNode, element); } return element; } _insertNewItemToPopup(aNewChild, aInsertionNode, aBefore = null) { let element = this._createDOMNodeForPlacesNode(aNewChild); aInsertionNode.insertBefore(element, aBefore); return element; } toggleCutNode(aPlacesNode, aValue) { let elt = this._getDOMNodeForPlacesNode(aPlacesNode); // We may get the popup for menus, but we need the menu itself. if (elt.localName == "menupopup") { elt = elt.parentNode; } if (aValue) { elt.setAttribute("cutting", "true"); } else { elt.removeAttribute("cutting"); } } nodeURIChanged(aPlacesNode) { let elt = this._getDOMNodeForPlacesNode(aPlacesNode, true); // There's no DOM node, thus there's nothing to be done when the URI changes. if (!elt) { return; } // Here we need the . if (elt.localName == "menupopup") { elt = elt.parentNode; } elt.setAttribute( "scheme", PlacesUIUtils.guessUrlSchemeForUI(aPlacesNode.uri) ); } nodeIconChanged(aPlacesNode) { let elt = this._getDOMNodeForPlacesNode(aPlacesNode, true); // There's no UI representation for the root node, or there's no DOM node, // thus there's nothing to be done when the icon changes. if (!elt || elt == this._rootElt) { return; } // Here we need the . if (elt.localName == "menupopup") { elt = elt.parentNode; } // We must remove and reset the attribute to force an update. elt.removeAttribute("image"); elt.setAttribute("image", aPlacesNode.icon); } nodeTitleChanged(aPlacesNode, aNewTitle) { let elt = this._getDOMNodeForPlacesNode(aPlacesNode); // There's no UI representation for the root node, thus there's // nothing to be done when the title changes. if (elt == this._rootElt) { return; } // Here we need the . if (elt.localName == "menupopup") { elt = elt.parentNode; } if (!aNewTitle && elt.localName != "toolbarbutton") { // Many users consider toolbars as shortcuts containers, so explicitly // allow empty labels on toolbarbuttons. For any other element try to be // smarter, guessing a title from the uri. elt.setAttribute("label", PlacesUIUtils.getBestTitle(aPlacesNode)); } else { elt.setAttribute("label", aNewTitle); } } nodeRemoved(aParentPlacesNode, aPlacesNode) { let parentElt = this._getDOMNodeForPlacesNode(aParentPlacesNode); let elt = this._getDOMNodeForPlacesNode(aPlacesNode); // Here we need the . if (elt.localName == "menupopup") { elt = elt.parentNode; } if (parentElt._built) { parentElt.removeChild(elt); // Figure out if we need to show the "" menu-item. // TODO Bug 517701: This doesn't seem to handle the case of an empty // root. if (parentElt._startMarker.nextElementSibling == parentElt._endMarker) { this._setEmptyPopupStatus(parentElt, true); } } } // Opt-out of history details updates, since all the views derived from this // are not showing them. skipHistoryDetailsNotifications = true; nodeHistoryDetailsChanged() {} nodeTagsChanged() {} nodeDateAddedChanged() {} nodeLastModifiedChanged() {} nodeKeywordChanged() {} sortingChanged() {} batching() {} nodeInserted(aParentPlacesNode, aPlacesNode, aIndex) { let parentElt = this._getDOMNodeForPlacesNode(aParentPlacesNode); if (!parentElt._built) { return; } let index = Array.prototype.indexOf.call(parentElt.children, parentElt._startMarker) + aIndex + 1; this._insertNewItemToPopup( aPlacesNode, parentElt, parentElt.children[index] || parentElt._endMarker ); this._setEmptyPopupStatus(parentElt, false); } nodeMoved( aPlacesNode, aOldParentPlacesNode, aOldIndex, aNewParentPlacesNode, aNewIndex ) { // Note: the current implementation of moveItem does not actually // use this notification when the item in question is moved from one // folder to another. Instead, it calls nodeRemoved and nodeInserted // for the two folders. Thus, we can assume old-parent == new-parent. let elt = this._getDOMNodeForPlacesNode(aPlacesNode); // Here we need the . if (elt.localName == "menupopup") { elt = elt.parentNode; } // If our root node is a folder, it might be moved. There's nothing // we need to do in that case. if (elt == this._rootElt) { return; } let parentElt = this._getDOMNodeForPlacesNode(aNewParentPlacesNode); if (parentElt._built) { // Move the node. parentElt.removeChild(elt); let index = Array.prototype.indexOf.call( parentElt.children, parentElt._startMarker ) + aNewIndex + 1; parentElt.insertBefore(elt, parentElt.children[index]); } } containerStateChanged(aPlacesNode, aOldState, aNewState) { if ( aNewState == Ci.nsINavHistoryContainerResultNode.STATE_OPENED || aNewState == Ci.nsINavHistoryContainerResultNode.STATE_CLOSED ) { this.invalidateContainer(aPlacesNode); } } /** * Checks whether the popup associated with the provided element is open. * This method may be overridden by classes that extend this base class. * * @param {Element} elt * The element to check. * @returns {boolean} */ _isPopupOpen(elt) { return !!elt.parentNode.open; } invalidateContainer(aPlacesNode) { let elt = this._getDOMNodeForPlacesNode(aPlacesNode); elt._built = false; // If the menupopup is open we should live-update it. if (this._isPopupOpen(elt)) { this._rebuildPopup(elt); } } uninit() { if (this._result) { this._result.removeObserver(this); this._resultNode.containerOpen = false; this._resultNode = null; this._result = null; } if (this._controller) { this._controller.terminate(); // Removing the controller will fail if it is already no longer there. // This can happen if the view element was removed/reinserted without // our knowledge. There is no way to check for that having happened // without the possibility of an exception. :-( try { this._viewElt.controllers.removeController(this._controller); } catch (ex) { } finally { this._controller = null; } } delete this._viewElt._placesView; } get isRTL() { if ("_isRTL" in this) { return this._isRTL; } return (this._isRTL = document.defaultView.getComputedStyle(this._viewElt).direction == "rtl"); } get ownerWindow() { return window; } /** * Adds an "Open All in Tabs" menuitem to the bottom of the popup. * * @param {object} aPopup * a Places popup. */ _mayAddCommandsItems(aPopup) { // The command items are never added to the root popup. if (aPopup == this._rootElt) { return; } let hasMultipleURIs = false; // Check if the popup contains at least 2 menuitems with places nodes. // We don't currently support opening multiple uri nodes when they are not // populated by the result. if (aPopup._placesNode.childCount > 0) { let currentChild = aPopup.firstElementChild; let numURINodes = 0; while (currentChild) { if (currentChild.localName == "menuitem" && currentChild._placesNode) { if (++numURINodes == 2) { break; } } currentChild = currentChild.nextElementSibling; } hasMultipleURIs = numURINodes > 1; } if (!hasMultipleURIs) { // We don't have to show any option. if (aPopup._endOptOpenAllInTabs) { aPopup.removeChild(aPopup._endOptOpenAllInTabs); aPopup._endOptOpenAllInTabs = null; aPopup.removeChild(aPopup._endOptSeparator); aPopup._endOptSeparator = null; } } else if (!aPopup._endOptOpenAllInTabs) { // Create a separator before options. aPopup._endOptSeparator = document.createXULElement("menuseparator"); aPopup._endOptSeparator.className = "bookmarks-actions-menuseparator"; aPopup.appendChild(aPopup._endOptSeparator); // Add the "Open All in Tabs" menuitem. aPopup._endOptOpenAllInTabs = document.createXULElement("menuitem"); aPopup._endOptOpenAllInTabs.className = "openintabs-menuitem"; aPopup._endOptOpenAllInTabs.setAttribute( "oncommand", "PlacesUIUtils.openMultipleLinksInTabs(this.parentNode._placesNode, event, " + "PlacesUIUtils.getViewForNode(this));" ); aPopup._endOptOpenAllInTabs.setAttribute( "label", gNavigatorBundle.getString("menuOpenAllInTabs.label") ); aPopup.appendChild(aPopup._endOptOpenAllInTabs); } } _ensureMarkers(aPopup) { if (aPopup._startMarker) { return; } // Places nodes are appended between _startMarker and _endMarker, that // are hidden menuseparators. By default they take the whole panel... aPopup._startMarker = document.createXULElement("menuseparator"); aPopup._startMarker.hidden = true; aPopup.insertBefore(aPopup._startMarker, aPopup.firstElementChild); aPopup._endMarker = document.createXULElement("menuseparator"); aPopup._endMarker.hidden = true; aPopup.appendChild(aPopup._endMarker); // ...but there can be static content before or after the places nodes, thus // we move the markers to the right position, by checking for static content // at the beginning of the view, and for an element with "afterplacescontent" // attribute. // TODO: In the future we should just use a container element. let firstNonStaticNodeFound = false; for (let child of aPopup.children) { if (child.hasAttribute("afterplacescontent")) { aPopup.insertBefore(aPopup._endMarker, child); break; } // Check for the first Places node that is not a view. if (child._placesNode && !child._placesView && !firstNonStaticNodeFound) { firstNonStaticNodeFound = true; aPopup.insertBefore(aPopup._startMarker, child); } } if (!firstNonStaticNodeFound) { // Just put the start marker before the end marker. aPopup.insertBefore(aPopup._startMarker, aPopup._endMarker); } } _onPopupShowing(aEvent) { // Avoid handling popupshowing of inner views. let popup = aEvent.originalTarget; this._ensureMarkers(popup); // Remove any delayed element, see _cleanPopup for details. if ("_delayedRemovals" in popup) { while (popup._delayedRemovals.length) { popup.removeChild(popup._delayedRemovals.shift()); } } if (popup._placesNode && PlacesUIUtils.getViewForNode(popup) == this) { if (!popup._placesNode.containerOpen) { popup._placesNode.containerOpen = true; } if (!popup._built) { this._rebuildPopup(popup); } this._mayAddCommandsItems(popup); } } _addEventListeners(aObject, aEventNames, aCapturing = false) { for (let i = 0; i < aEventNames.length; i++) { aObject.addEventListener(aEventNames[i], this, aCapturing); } } _removeEventListeners(aObject, aEventNames, aCapturing = false) { for (let i = 0; i < aEventNames.length; i++) { aObject.removeEventListener(aEventNames[i], this, aCapturing); } } } /** * Toolbar View implementation. */ class PlacesToolbar extends PlacesViewBase { constructor(placesUrl, rootElt, viewElt) { let startTime = Date.now(); super(placesUrl, rootElt, viewElt); this._addEventListeners(this._dragRoot, this._cbEvents, false); this._addEventListeners( this._rootElt, ["popupshowing", "popuphidden"], true ); this._addEventListeners(this._rootElt, ["overflow", "underflow"], true); this._addEventListeners(window, ["resize", "unload"], false); // If personal-bookmarks has been dragged to the tabs toolbar, // we have to track addition and removals of tabs, to properly // recalculate the available space for bookmarks. // TODO (bug 734730): Use a performant mutation listener when available. if ( this._viewElt.parentNode.parentNode == document.getElementById("TabsToolbar") ) { this._addEventListeners( gBrowser.tabContainer, ["TabOpen", "TabClose"], false ); } Services.telemetry .getHistogramById("FX_BOOKMARKS_TOOLBAR_INIT_MS") .add(Date.now() - startTime); } // Called by PlacesViewBase so we can init properties that class // initialization depends on. PlacesViewBase will assign this.place which // calls which sets `this.result` through its places observer, which changes // containerOpen, which calls invalidateContainer(), which calls rebuild(), // which needs `_overFolder`, `_chevronPopup` and various other things to // exist. _init() { this._overFolder = { elt: null, openTimer: null, hoverTime: 350, closeTimer: null, }; // Add some smart getters for our elements. let thisView = this; [ ["_dropIndicator", "PlacesToolbarDropIndicator"], ["_chevron", "PlacesChevron"], ["_chevronPopup", "PlacesChevronPopup"], ].forEach(function (elementGlobal) { let [name, id] = elementGlobal; thisView.__defineGetter__(name, function () { let element = document.getElementById(id); if (!element) { return null; } delete thisView[name]; return (thisView[name] = element); }); }); this._viewElt._placesView = this; this._dragRoot = BookmarkingUI.toolbar.contains(this._viewElt) ? BookmarkingUI.toolbar : this._viewElt; this._updatingNodesVisibility = false; } _cbEvents = [ "dragstart", "dragover", "dragleave", "dragend", "drop", "mousemove", "mouseover", "mouseout", "mousedown", ]; QueryInterface = ChromeUtils.generateQI([ "nsINamed", "nsITimerCallback", ...PlacesViewBase.interfaces, ]); uninit() { if (this._dragRoot) { this._removeEventListeners(this._dragRoot, this._cbEvents, false); } this._removeEventListeners( this._rootElt, ["popupshowing", "popuphidden"], true ); this._removeEventListeners(this._rootElt, ["overflow", "underflow"], true); this._removeEventListeners(window, ["resize", "unload"], false); this._removeEventListeners( gBrowser.tabContainer, ["TabOpen", "TabClose"], false ); if (this._chevron._placesView) { this._chevron._placesView.uninit(); } if (this._otherBookmarks?._placesView) { this._otherBookmarks._placesView.uninit(); } super.uninit(); } _openedMenuButton = null; _allowPopupShowing = true; promiseRebuilt() { return this._rebuilding?.promise; } get _isAlive() { return this._resultNode && this._rootElt; } _runBeforeFrameRender(callback) { return new Promise((resolve, reject) => { window.requestAnimationFrame(() => { try { resolve(callback()); } catch (err) { reject(err); } }); }); } async _rebuild() { // Clear out references to existing nodes, since they will be removed // and re-added. if (this._overFolder.elt) { this._clearOverFolder(); } this._openedMenuButton = null; while (this._rootElt.hasChildNodes()) { this._rootElt.firstChild.remove(); } let cc = this._resultNode.childCount; if (cc > 0) { // There could be a lot of nodes, but we only want to build the ones that // are more likely to be shown, not all of them. // We also don't want to wait for reflows at every node insertion, to // calculate a precise number of visible items, thus we guess a size from // the first non-separator node (because separators have flexible size). let startIndex = 0; let limit = await this._runBeforeFrameRender(() => { if (!this._isAlive) { return cc; } // Look for the first non-separator node. let elt; while (startIndex < cc) { elt = this._insertNewItem( this._resultNode.getChild(startIndex), this._rootElt ); ++startIndex; if (elt.localName != "toolbarseparator") { break; } } if (!elt) { return cc; } return window.promiseDocumentFlushed(() => { // We assume a button with just the icon will be more or less a square, // then compensate the measurement error by considering a larger screen // width. Moreover the window could be bigger than the screen. let size = elt.clientHeight || 1; // Sanity fallback. return Math.min(cc, parseInt((window.screen.width * 1.5) / size)); }); }); if (!this._isAlive) { return; } let fragment = document.createDocumentFragment(); for (let i = startIndex; i < limit; ++i) { this._insertNewItem(this._resultNode.getChild(i), fragment); } await new Promise(resolve => window.requestAnimationFrame(resolve)); if (!this._isAlive) { return; } this._rootElt.appendChild(fragment); this.updateNodesVisibility(); } if (this._chevronPopup.hasAttribute("type")) { // Chevron has already been initialized, but since we are forcing // a rebuild of the toolbar, it has to be rebuilt. // Otherwise, it will be initialized when the toolbar overflows. this._chevronPopup.place = this.place; } // Rebuild the "Other Bookmarks" folder if it already exists. let otherBookmarks = document.getElementById("OtherBookmarks"); otherBookmarks?.remove(); BookmarkingUI.maybeShowOtherBookmarksFolder().catch(console.error); } _insertNewItem(aChild, aInsertionNode, aBefore = null) { this._domNodes.delete(aChild); let type = aChild.type; let button; if (type == Ci.nsINavHistoryResultNode.RESULT_TYPE_SEPARATOR) { button = document.createXULElement("toolbarseparator"); } else { button = document.createXULElement("toolbarbutton"); button.className = "bookmark-item"; button.setAttribute("label", aChild.title || ""); if (PlacesUtils.containerTypes.includes(type)) { button.setAttribute("type", "menu"); button.setAttribute("container", "true"); if (PlacesUtils.nodeIsQuery(aChild)) { button.setAttribute("query", "true"); if (PlacesUtils.nodeIsTagQuery(aChild)) { button.setAttribute("tagContainer", "true"); } } let popup = document.createXULElement("menupopup", { is: "places-popup", }); popup.setAttribute("placespopup", "true"); popup.classList.add("toolbar-menupopup"); button.appendChild(popup); popup._placesNode = PlacesUtils.asContainer(aChild); popup.setAttribute("context", "placesContext"); this._domNodes.set(aChild, popup); } else if (PlacesUtils.nodeIsURI(aChild)) { button.setAttribute( "scheme", PlacesUIUtils.guessUrlSchemeForUI(aChild.uri) ); } } button._placesNode = aChild; let { icon } = button._placesNode; if (icon) { button.setAttribute("image", icon); } if (!this._domNodes.has(aChild)) { this._domNodes.set(aChild, button); } if (aBefore) { aInsertionNode.insertBefore(button, aBefore); } else { aInsertionNode.appendChild(button); } return button; } _updateChevronPopupNodesVisibility() { // Note the toolbar by default builds less nodes than the chevron popup. for ( let toolbarNode = this._rootElt.firstElementChild, node = this._chevronPopup._startMarker.nextElementSibling; toolbarNode && node; toolbarNode = toolbarNode.nextElementSibling, node = node.nextElementSibling ) { node.hidden = toolbarNode.style.visibility != "hidden"; } } _onChevronPopupShowing(aEvent) { // Handle popupshowing only for the chevron popup, not for nested ones. if (aEvent.target != this._chevronPopup) { return; } if (!this._chevron._placesView) { this._chevron._placesView = new PlacesMenu(aEvent, this.place); } this._updateChevronPopupNodesVisibility(); } _onOtherBookmarksPopupShowing(aEvent) { if (aEvent.target != this._otherBookmarksPopup) { return; } if (!this._otherBookmarks._placesView) { this._otherBookmarks._placesView = new PlacesMenu( aEvent, "place:parent=" + PlacesUtils.bookmarks.unfiledGuid ); } } handleEvent(aEvent) { switch (aEvent.type) { case "unload": this.uninit(); break; case "resize": // This handler updates nodes visibility in both the toolbar // and the chevron popup when a window resize does not change // the overflow status of the toolbar. if (aEvent.target == aEvent.currentTarget) { this.updateNodesVisibility(); } break; case "overflow": if (!this._isOverflowStateEventRelevant(aEvent)) { return; } // Avoid triggering overflow in containers if possible aEvent.stopPropagation(); this._onOverflow(); break; case "underflow": if (!this._isOverflowStateEventRelevant(aEvent)) { return; } // Avoid triggering underflow in containers if possible aEvent.stopPropagation(); this._onUnderflow(); break; case "TabOpen": case "TabClose": this.updateNodesVisibility(); break; case "dragstart": this._onDragStart(aEvent); break; case "dragover": this._onDragOver(aEvent); break; case "dragleave": this._onDragLeave(aEvent); break; case "dragend": this._onDragEnd(aEvent); break; case "drop": this._onDrop(aEvent); break; case "mouseover": this._onMouseOver(aEvent); break; case "mousemove": this._onMouseMove(aEvent); break; case "mouseout": this._onMouseOut(aEvent); break; case "mousedown": this._onMouseDown(aEvent); break; case "popupshowing": this._onPopupShowing(aEvent); break; case "popuphidden": this._onPopupHidden(aEvent); break; default: throw new Error("Trying to handle unexpected event."); } } _isOverflowStateEventRelevant(aEvent) { // Ignore events not aimed at ourselves, as well as purely vertical ones: return aEvent.target == aEvent.currentTarget && aEvent.detail > 0; } _onOverflow() { // Attach the popup binding to the chevron popup if it has not yet // been initialized. if (!this._chevronPopup.hasAttribute("type")) { this._chevronPopup.setAttribute("place", this.place); this._chevronPopup.setAttribute("type", "places"); } this._chevron.collapsed = false; this.updateNodesVisibility(); } _onUnderflow() { this.updateNodesVisibility(); this._chevron.collapsed = true; } updateNodesVisibility() { // Update the chevron on a timer. This will avoid repeated work when // lot of changes happen in a small timeframe. if (this._updateNodesVisibilityTimer) { this._updateNodesVisibilityTimer.cancel(); } this._updateNodesVisibilityTimer = this._setTimer(100); } async _updateNodesVisibilityTimerCallback() { if (this._updatingNodesVisibility || window.closed) { return; } this._updatingNodesVisibility = true; let dwu = window.windowUtils; let scrollRect = await window.promiseDocumentFlushed(() => dwu.getBoundsWithoutFlushing(this._rootElt) ); let childOverflowed = false; // We're about to potentially update a bunch of nodes, so we do it // in a requestAnimationFrame so that other JS that's might execute // in the same tick can avoid flushing styles and layout for these // changes. window.requestAnimationFrame(() => { for (let child of this._rootElt.children) { // Once a child overflows, all the next ones will. if (!childOverflowed) { let childRect = dwu.getBoundsWithoutFlushing(child); childOverflowed = this.isRTL ? childRect.left < scrollRect.left : childRect.right > scrollRect.right; } if (childOverflowed) { child.removeAttribute("image"); child.style.visibility = "hidden"; } else { let icon = child._placesNode.icon; if (icon) { child.setAttribute("image", icon); } child.style.removeProperty("visibility"); } } // We rebuild the chevron on popupShowing, so if it is open // we must update it. if (!this._chevron.collapsed && this._chevron.open) { this._updateChevronPopupNodesVisibility(); } let event = new CustomEvent("BookmarksToolbarVisibilityUpdated", { bubbles: true, }); this._viewElt.dispatchEvent(event); this._updatingNodesVisibility = false; }); } nodeInserted(aParentPlacesNode, aPlacesNode, aIndex) { let parentElt = this._getDOMNodeForPlacesNode(aParentPlacesNode); if (parentElt == this._rootElt) { // Node is on the toolbar. let children = this._rootElt.children; // Nothing to do if it's a never-visible node, but note it's possible // we are appending. if (aIndex > children.length) { return; } // Note that childCount is already accounting for the node being added, // thus we must subtract one node from it. if (this._resultNode.childCount - 1 > children.length) { if (aIndex == children.length) { // If we didn't build all the nodes and new node is being appended, // we can skip it as well. return; } // Keep the number of built nodes consistent. this._rootElt.removeChild(this._rootElt.lastElementChild); } let button = this._insertNewItem( aPlacesNode, this._rootElt, children[aIndex] || null ); let prevSiblingOverflowed = aIndex > 0 && aIndex <= children.length && children[aIndex - 1].style.visibility == "hidden"; if (prevSiblingOverflowed) { button.style.visibility = "hidden"; } else { let icon = aPlacesNode.icon; if (icon) { button.setAttribute("image", icon); } this.updateNodesVisibility(); } return; } super.nodeInserted(aParentPlacesNode, aPlacesNode, aIndex); } nodeRemoved(aParentPlacesNode, aPlacesNode, aIndex) { let parentElt = this._getDOMNodeForPlacesNode(aParentPlacesNode); if (parentElt == this._rootElt) { // Node is on the toolbar. let elt = this._getDOMNodeForPlacesNode(aPlacesNode, true); // Nothing to do if it's a never-visible node. if (!elt) { return; } // Here we need the . if (elt.localName == "menupopup") { elt = elt.parentNode; } let overflowed = elt.style.visibility == "hidden"; this._removeChild(elt); if (this._resultNode.childCount > this._rootElt.children.length) { // A new node should be built to keep a coherent number of children. this._insertNewItem( this._resultNode.getChild(this._rootElt.children.length), this._rootElt ); } if (!overflowed) { this.updateNodesVisibility(); } return; } super.nodeRemoved(aParentPlacesNode, aPlacesNode, aIndex); } nodeMoved( aPlacesNode, aOldParentPlacesNode, aOldIndex, aNewParentPlacesNode, aNewIndex ) { let parentElt = this._getDOMNodeForPlacesNode(aNewParentPlacesNode); if (parentElt == this._rootElt) { // Node is on the toolbar. // Do nothing if the node will never be visible. let lastBuiltIndex = this._rootElt.children.length - 1; if (aOldIndex > lastBuiltIndex && aNewIndex > lastBuiltIndex + 1) { return; } let elt = this._getDOMNodeForPlacesNode(aPlacesNode, true); if (elt) { // Here we need the . if (elt.localName == "menupopup") { elt = elt.parentNode; } this._removeChild(elt); } if (aNewIndex > lastBuiltIndex + 1) { if (this._resultNode.childCount > this._rootElt.children.length) { // If the element was built and becomes non built, another node should // be built to keep a coherent number of children. this._insertNewItem( this._resultNode.getChild(this._rootElt.children.length), this._rootElt ); } return; } if (!elt) { // The node has not been inserted yet, so we must create it. elt = this._insertNewItem( aPlacesNode, this._rootElt, this._rootElt.children[aNewIndex] ); let icon = aPlacesNode.icon; if (icon) { elt.setAttribute("image", icon); } } else { this._rootElt.insertBefore(elt, this._rootElt.children[aNewIndex]); } // The chevron view may get nodeMoved after the toolbar. In such a case, // we should ensure (by manually swapping menuitems) that the actual nodes // are in the final position before updateNodesVisibility tries to update // their visibility, or the chevron may go out of sync. // Luckily updateNodesVisibility runs on a timer, so, by the time it updates // nodes, the menu has already handled the notification. this.updateNodesVisibility(); return; } super.nodeMoved( aPlacesNode, aOldParentPlacesNode, aOldIndex, aNewParentPlacesNode, aNewIndex ); } nodeTitleChanged(aPlacesNode, aNewTitle) { let elt = this._getDOMNodeForPlacesNode(aPlacesNode, true); // Nothing to do if it's a never-visible node. if (!elt || elt == this._rootElt) { return; } super.nodeTitleChanged(aPlacesNode, aNewTitle); // Here we need the . if (elt.localName == "menupopup") { elt = elt.parentNode; } if (elt.parentNode == this._rootElt) { // Node is on the toolbar. if (elt.style.visibility != "hidden") { this.updateNodesVisibility(); } } } invalidateContainer(aPlacesNode) { let elt = this._getDOMNodeForPlacesNode(aPlacesNode, true); // Nothing to do if it's a never-visible node. if (!elt) { return; } if (elt == this._rootElt) { // Container is the toolbar itself. let instance = (this._rebuildingInstance = {}); if (!this._rebuilding) { this._rebuilding = Promise.withResolvers(); } this._rebuild() .catch(console.error) .finally(() => { if (instance == this._rebuildingInstance) { this._rebuilding.resolve(); this._rebuilding = null; } }); return; } super.invalidateContainer(aPlacesNode); } _clearOverFolder() { // The mouse is no longer dragging over the stored menubutton. // Close the menubutton, clear out drag styles, and clear all // timers for opening/closing it. if (this._overFolder.elt && this._overFolder.elt.menupopup) { if (!this._overFolder.elt.menupopup.hasAttribute("dragover")) { this._overFolder.elt.menupopup.hidePopup(); } this._overFolder.elt.removeAttribute("dragover"); this._overFolder.elt = null; } if (this._overFolder.openTimer) { this._overFolder.openTimer.cancel(); this._overFolder.openTimer = null; } if (this._overFolder.closeTimer) { this._overFolder.closeTimer.cancel(); this._overFolder.closeTimer = null; } } /** * This function returns information about where to drop when dragging over * the toolbar. * * @param {object} aEvent * The associated event. * @returns {object} * - ip: the insertion point for the bookmarks service. * - beforeIndex: child index to drop before, for the drop indicator. * - folderElt: the folder to drop into, if applicable. */ _getDropPoint(aEvent) { if (!PlacesUtils.nodeIsFolder(this._resultNode)) { return null; } let dropPoint = { ip: null, beforeIndex: null, folderElt: null }; let elt = aEvent.target; if ( elt._placesNode && elt != this._rootElt && elt.localName != "menupopup" ) { let eltRect = elt.getBoundingClientRect(); let eltIndex = Array.prototype.indexOf.call(this._rootElt.children, elt); if ( PlacesUtils.nodeIsFolder(elt._placesNode) && !PlacesUIUtils.isFolderReadOnly(elt._placesNode) ) { // This is a folder. // If we are in the middle of it, drop inside it. // Otherwise, drop before it, with regards to RTL mode. let threshold = eltRect.width * 0.25; if ( this.isRTL ? aEvent.clientX > eltRect.right - threshold : aEvent.clientX < eltRect.left + threshold ) { // Drop before this folder. dropPoint.ip = new PlacesInsertionPoint({ parentGuid: PlacesUtils.getConcreteItemGuid(this._resultNode), index: eltIndex, orientation: Ci.nsITreeView.DROP_BEFORE, }); dropPoint.beforeIndex = eltIndex; } else if ( this.isRTL ? aEvent.clientX > eltRect.left + threshold : aEvent.clientX < eltRect.right - threshold ) { // Drop inside this folder. let tagName = PlacesUtils.nodeIsTagQuery(elt._placesNode) ? elt._placesNode.title : null; dropPoint.ip = new PlacesInsertionPoint({ parentGuid: PlacesUtils.getConcreteItemGuid(elt._placesNode), tagName, }); dropPoint.beforeIndex = eltIndex; dropPoint.folderElt = elt; } else { // Drop after this folder. let beforeIndex = eltIndex == this._rootElt.children.length - 1 ? -1 : eltIndex + 1; dropPoint.ip = new PlacesInsertionPoint({ parentGuid: PlacesUtils.getConcreteItemGuid(this._resultNode), index: beforeIndex, orientation: Ci.nsITreeView.DROP_BEFORE, }); dropPoint.beforeIndex = beforeIndex; } } else { // This is a non-folder node or a read-only folder. // Drop before it with regards to RTL mode. let threshold = eltRect.width * 0.5; if ( this.isRTL ? aEvent.clientX > eltRect.left + threshold : aEvent.clientX < eltRect.left + threshold ) { // Drop before this bookmark. dropPoint.ip = new PlacesInsertionPoint({ parentGuid: PlacesUtils.getConcreteItemGuid(this._resultNode), index: eltIndex, orientation: Ci.nsITreeView.DROP_BEFORE, }); dropPoint.beforeIndex = eltIndex; } else { // Drop after this bookmark. let beforeIndex = eltIndex == this._rootElt.children.length - 1 ? -1 : eltIndex + 1; dropPoint.ip = new PlacesInsertionPoint({ parentGuid: PlacesUtils.getConcreteItemGuid(this._resultNode), index: beforeIndex, orientation: Ci.nsITreeView.DROP_BEFORE, }); dropPoint.beforeIndex = beforeIndex; } } } else { // We are most likely dragging on the empty area of the // toolbar, we should drop after the last node. dropPoint.ip = new PlacesInsertionPoint({ parentGuid: PlacesUtils.getConcreteItemGuid(this._resultNode), orientation: Ci.nsITreeView.DROP_BEFORE, }); dropPoint.beforeIndex = -1; } return dropPoint; } _setTimer(aTime) { let timer = Cc["@mozilla.org/timer;1"].createInstance(Ci.nsITimer); timer.initWithCallback(this, aTime, timer.TYPE_ONE_SHOT); return timer; } get name() { return "PlacesToolbar"; } notify(aTimer) { if (aTimer == this._updateNodesVisibilityTimer) { this._updateNodesVisibilityTimer = null; this._updateNodesVisibilityTimerCallback(); } else if (aTimer == this._overFolder.openTimer) { // * Timer to open a menubutton that's being dragged over. // Set the autoopen attribute on the folder's menupopup so that // the menu will automatically close when the mouse drags off of it. this._overFolder.elt.menupopup.setAttribute("autoopened", "true"); this._overFolder.elt.open = true; this._overFolder.openTimer = null; } else if (aTimer == this._overFolder.closeTimer) { // * Timer to close a menubutton that's been dragged off of. // Close the menubutton if we are not dragging over it or one of // its children. The autoopened attribute will let the menu know to // close later if the menu is still being dragged over. let currentPlacesNode = PlacesControllerDragHelper.currentDropTarget; let inHierarchy = false; while (currentPlacesNode) { if (currentPlacesNode == this._rootElt) { inHierarchy = true; break; } currentPlacesNode = currentPlacesNode.parentNode; } // The _clearOverFolder() function will close the menu for // _overFolder.elt. So null it out if we don't want to close it. if (inHierarchy) { this._overFolder.elt = null; } // Clear out the folder and all associated timers. this._clearOverFolder(); } } _onMouseOver(aEvent) { let button = aEvent.target; if ( button.parentNode == this._rootElt && button._placesNode && PlacesUtils.nodeIsURI(button._placesNode) ) { window.XULBrowserWindow.setOverLink(aEvent.target._placesNode.uri); } } _onMouseOut() { window.XULBrowserWindow.setOverLink(""); } _onMouseDown(aEvent) { let target = aEvent.target; if ( aEvent.button == 0 && target.localName == "toolbarbutton" && target.getAttribute("type") == "menu" ) { let modifKey = aEvent.shiftKey || aEvent.getModifierState("Accel"); if (modifKey) { // Do not open the popup since BEH_onClick is about to // open all child uri nodes in tabs. this._allowPopupShowing = false; } } if (target._placesNode?.uri) { PlacesUIUtils.setupSpeculativeConnection(target._placesNode.uri, window); } } _cleanupDragDetails() { // Called on dragend and drop. PlacesControllerDragHelper.currentDropTarget = null; this._draggedElt = null; this._dropIndicator.collapsed = true; } _onDragStart(aEvent) { // Sub menus have their own d&d handlers. let draggedElt = aEvent.target; if (draggedElt.parentNode != this._rootElt || !draggedElt._placesNode) { return; } if ( draggedElt.localName == "toolbarbutton" && draggedElt.getAttribute("type") == "menu" ) { // If the drag gesture on a container is toward down we open instead // of dragging. let translateY = this._cachedMouseMoveEvent.clientY - aEvent.clientY; let translateX = this._cachedMouseMoveEvent.clientX - aEvent.clientX; if (translateY >= Math.abs(translateX / 2)) { // Don't start the drag. aEvent.preventDefault(); // Open the menu. draggedElt.open = true; return; } // If the menu is open, close it. if (draggedElt.open) { draggedElt.menupopup.hidePopup(); draggedElt.open = false; } } // Activate the view and cache the dragged element. this._draggedElt = draggedElt._placesNode; this._rootElt.focus(); this._controller.setDataTransfer(aEvent); aEvent.stopPropagation(); } _onDragOver(aEvent) { // Cache the dataTransfer PlacesControllerDragHelper.currentDropTarget = aEvent.target; let dt = aEvent.dataTransfer; let dropPoint = this._getDropPoint(aEvent); if ( !dropPoint || !dropPoint.ip || !PlacesControllerDragHelper.canDrop(dropPoint.ip, dt) ) { this._dropIndicator.collapsed = true; aEvent.stopPropagation(); return; } if (dropPoint.folderElt || aEvent.originalTarget == this._chevron) { // Dropping over a menubutton or chevron button. // Set styles and timer to open relative menupopup. let overElt = dropPoint.folderElt || this._chevron; if (this._overFolder.elt != overElt) { this._clearOverFolder(); this._overFolder.elt = overElt; this._overFolder.openTimer = this._setTimer(this._overFolder.hoverTime); } if (!this._overFolder.elt.hasAttribute("dragover")) { this._overFolder.elt.setAttribute("dragover", "true"); } this._dropIndicator.collapsed = true; } else { // Dragging over a normal toolbarbutton, // show indicator bar and move it to the appropriate drop point. let ind = this._dropIndicator; ind.parentNode.collapsed = false; let halfInd = ind.clientWidth / 2; let translateX; if (this.isRTL) { halfInd = Math.ceil(halfInd); translateX = 0 - this._rootElt.getBoundingClientRect().right - halfInd; if (this._rootElt.firstElementChild) { if (dropPoint.beforeIndex == -1) { translateX += this._rootElt.lastElementChild.getBoundingClientRect().left; } else { translateX += this._rootElt.children[ dropPoint.beforeIndex ].getBoundingClientRect().right; } } } else { halfInd = Math.floor(halfInd); translateX = 0 - this._rootElt.getBoundingClientRect().left + halfInd; if (this._rootElt.firstElementChild) { if (dropPoint.beforeIndex == -1) { translateX += this._rootElt.lastElementChild.getBoundingClientRect().right; } else { translateX += this._rootElt.children[ dropPoint.beforeIndex ].getBoundingClientRect().left; } } } ind.style.transform = "translate(" + Math.round(translateX) + "px)"; ind.style.marginInlineStart = -ind.clientWidth + "px"; ind.collapsed = false; // Clear out old folder information. this._clearOverFolder(); } aEvent.preventDefault(); aEvent.stopPropagation(); } _onDrop(aEvent) { PlacesControllerDragHelper.currentDropTarget = aEvent.target; let dropPoint = this._getDropPoint(aEvent); if (dropPoint && dropPoint.ip) { PlacesControllerDragHelper.onDrop( dropPoint.ip, aEvent.dataTransfer ).catch(console.error); aEvent.preventDefault(); } this._cleanupDragDetails(); aEvent.stopPropagation(); } _onDragLeave() { PlacesControllerDragHelper.currentDropTarget = null; this._dropIndicator.collapsed = true; // If we hovered over a folder, close it now. if (this._overFolder.elt) { this._overFolder.closeTimer = this._setTimer(this._overFolder.hoverTime); } } _onDragEnd() { this._cleanupDragDetails(); } _onPopupShowing(aEvent) { if (!this._allowPopupShowing) { this._allowPopupShowing = true; aEvent.preventDefault(); return; } let parent = aEvent.target.parentNode; if (parent.localName == "toolbarbutton") { this._openedMenuButton = parent; } super._onPopupShowing(aEvent); } _onPopupHidden(aEvent) { let popup = aEvent.target; let placesNode = popup._placesNode; // Avoid handling popuphidden of inner views if ( placesNode && PlacesUIUtils.getViewForNode(popup) == this && // UI performance: folder queries are cheap, keep the resultnode open // so we don't rebuild its contents whenever the popup is reopened. !PlacesUtils.nodeIsFolder(placesNode) ) { placesNode.containerOpen = false; } let parent = popup.parentNode; if (parent.localName == "toolbarbutton") { this._openedMenuButton = null; // Clear the dragover attribute if present, if we are dragging into a // folder in the hierachy of current opened popup we don't clear // this attribute on clearOverFolder. See Notify for closeTimer. if (parent.hasAttribute("dragover")) { parent.removeAttribute("dragover"); } } } _onMouseMove(aEvent) { // Used in dragStart to prevent dragging folders when dragging down. this._cachedMouseMoveEvent = aEvent; if ( this._openedMenuButton == null || PlacesControllerDragHelper.getSession() ) { return; } let target = aEvent.originalTarget; if ( this._openedMenuButton != target && target.localName == "toolbarbutton" && target.type == "menu" ) { this._openedMenuButton.open = false; target.open = true; } } } /** * View for Places menus. This object should be created during the first * popupshowing that's dispatched on the menu. * */ class PlacesMenu extends PlacesViewBase { /** * * @param {Event} popupShowingEvent * The event associated with opening the menu. * @param {string} placesUrl * The query associated with the view on the menu. */ constructor(popupShowingEvent, placesUrl) { super( placesUrl, popupShowingEvent.target, // popupShowingEvent.target.parentNode // ); this._addEventListeners( this._rootElt, ["popupshowing", "popuphidden"], true ); this._addEventListeners(window, ["unload"], false); this._addEventListeners(this._rootElt, ["mousedown"], false); if (AppConstants.platform === "macosx") { // Must walk up to support views in sub-menus, like Bookmarks Toolbar menu. for (let elt = this._viewElt.parentNode; elt; elt = elt.parentNode) { if (elt.localName == "menubar") { this._nativeView = true; break; } } } this._onPopupShowing(popupShowingEvent); } _init() { this._viewElt._placesView = this; } _removeChild(aChild) { super._removeChild(aChild); } uninit() { this._removeEventListeners( this._rootElt, ["popupshowing", "popuphidden"], true ); this._removeEventListeners(window, ["unload"], false); this._removeEventListeners(this._rootElt, ["mousedown"], false); super.uninit(); } handleEvent(aEvent) { switch (aEvent.type) { case "unload": this.uninit(); break; case "popupshowing": this._onPopupShowing(aEvent); break; case "popuphidden": this._onPopupHidden(aEvent); break; case "mousedown": this._onMouseDown(aEvent); break; } } _onPopupHidden(aEvent) { // Avoid handling popuphidden of inner views. let popup = aEvent.originalTarget; let placesNode = popup._placesNode; if (!placesNode || PlacesUIUtils.getViewForNode(popup) != this) { return; } // UI performance: folder queries are cheap, keep the resultnode open // so we don't rebuild its contents whenever the popup is reopened. if (!PlacesUtils.nodeIsFolder(placesNode)) { placesNode.containerOpen = false; } // The autoopened attribute is set for folders which have been // automatically opened when dragged over. Turn off this attribute // when the folder closes because it is no longer applicable. popup.removeAttribute("autoopened"); popup.removeAttribute("dragstart"); } // We don't have a facility for catch "mousedown" events on the native // Mac menus because Mac doesn't expose it _onMouseDown(aEvent) { let target = aEvent.target; if (target._placesNode?.uri) { PlacesUIUtils.setupSpeculativeConnection(target._placesNode.uri, window); } } } // This is used from CustomizableWidgets.sys.mjs using a `window` reference, // so we have to expose this on the global. this.PlacesPanelview = class PlacesPanelview extends PlacesViewBase { constructor(placeUrl, rootElt, viewElt) { super(placeUrl, rootElt, viewElt); this._viewElt._placesView = this; // We're simulating a popup show, because a panelview may only be shown when // its containing popup is already shown. this._onPopupShowing({ originalTarget: this._rootElt }); this._addEventListeners(window, ["unload"]); this._rootElt.setAttribute("context", "placesContext"); } get events() { if (this._events) { return this._events; } return (this._events = [ "click", "command", "dragend", "dragstart", "ViewHiding", "ViewShown", ]); } handleEvent(event) { switch (event.type) { case "click": // For middle clicks, fall through to the command handler. if (event.button != 1) { break; } // fall through case "command": this._onCommand(event); break; case "dragend": this._onDragEnd(event); break; case "dragstart": this._onDragStart(event); break; case "unload": this.uninit(event); break; case "ViewHiding": this._onPopupHidden(event); break; case "ViewShown": this._onViewShown(event); break; } } _onCommand(event) { event = getRootEvent(event); let button = event.originalTarget; if (!button._placesNode) { return; } let modifKey = AppConstants.platform === "macosx" ? event.metaKey : event.ctrlKey; if (!PlacesUIUtils.openInTabClosesMenu && modifKey) { // If 'Recent Bookmarks' in Bookmarks Panel. if (button.parentNode.id == "panelMenu_bookmarksMenu") { button.setAttribute("closemenu", "none"); } } else { button.removeAttribute("closemenu"); } PlacesUIUtils.openNodeWithEvent(button._placesNode, event); // Unlike left-click, middle-click requires manual menu closing. if ( button.parentNode.id != "panelMenu_bookmarksMenu" || (event.type == "click" && event.button == 1 && PlacesUIUtils.openInTabClosesMenu) ) { this.panelMultiView.closest("panel").hidePopup(); } } _onDragEnd() { this._draggedElt = null; } _onDragStart(event) { let draggedElt = event.originalTarget; if (draggedElt.parentNode != this._rootElt || !draggedElt._placesNode) { return; } // Activate the view and cache the dragged element. this._draggedElt = draggedElt._placesNode; this._rootElt.focus(); this._controller.setDataTransfer(event); event.stopPropagation(); } uninit(event) { this._removeEventListeners(this.panelMultiView, this.events); this._removeEventListeners(window, ["unload"]); delete this.panelMultiView; super.uninit(event); } _createDOMNodeForPlacesNode(placesNode) { this._domNodes.delete(placesNode); let element; let type = placesNode.type; if (type == Ci.nsINavHistoryResultNode.RESULT_TYPE_SEPARATOR) { element = document.createXULElement("toolbarseparator"); } else { if (type != Ci.nsINavHistoryResultNode.RESULT_TYPE_URI) { throw new Error("Unexpected node"); } element = document.createXULElement("toolbarbutton"); element.classList.add( "subviewbutton", "subviewbutton-iconic", "bookmark-item" ); element.setAttribute( "scheme", PlacesUIUtils.guessUrlSchemeForUI(placesNode.uri) ); element.setAttribute("label", PlacesUIUtils.getBestTitle(placesNode)); let icon = placesNode.icon; if (icon) { element.setAttribute("image", icon); } } element._placesNode = placesNode; if (!this._domNodes.has(placesNode)) { this._domNodes.set(placesNode, element); } return element; } _setEmptyPopupStatus(panelview, empty = false) { if (!panelview._emptyMenuitem) { panelview._emptyMenuitem = document.createXULElement("toolbarbutton"); panelview._emptyMenuitem.setAttribute("disabled", true); panelview._emptyMenuitem.className = "subviewbutton"; document.l10n.setAttributes( panelview._emptyMenuitem, "places-empty-bookmarks-folder" ); } if (empty) { panelview.setAttribute("emptyplacesresult", "true"); // Don't add the menuitem if there is static content. // We also support external usage for custom crafted panels - which'll have // no markers present. if ( !panelview._startMarker || (!panelview._startMarker.previousElementSibling && !panelview._endMarker.nextElementSibling) ) { panelview.insertBefore(panelview._emptyMenuitem, panelview._endMarker); } } else { panelview.removeAttribute("emptyplacesresult"); try { panelview.removeChild(panelview._emptyMenuitem); } catch (ex) {} } } _isPopupOpen() { return PanelView.forNode(this._viewElt).active; } _onPopupHidden(event) { let panelview = event.originalTarget; let placesNode = panelview._placesNode; // Avoid handling ViewHiding of inner views if ( placesNode && PlacesUIUtils.getViewForNode(panelview) == this && // UI performance: folder queries are cheap, keep the resultnode open // so we don't rebuild its contents whenever the popup is reopened. !PlacesUtils.nodeIsFolder(placesNode) ) { placesNode.containerOpen = false; } } _onPopupShowing(event) { // If the event came from the root element, this is the first time // we ever get here. if (event.originalTarget == this._rootElt) { // Start listening for events from all panels inside the panelmultiview. this.panelMultiView = this._viewElt.panelMultiView; this._addEventListeners(this.panelMultiView, this.events); } super._onPopupShowing(event); } _onViewShown(event) { if (event.originalTarget != this._viewElt) { return; } // Because PanelMultiView reparents the panelview internally, the controller // may get lost. In that case we'll append it again, because we certainly // need it later! if (!this.controllers.getControllerCount() && this._controller) { this.controllers.appendController(this._controller); } } };