зеркало из https://github.com/mozilla/gecko-dev.git
1975 строки
68 KiB
JavaScript
1975 строки
68 KiB
JavaScript
/* 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/. */
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
//// StarUI
|
|
|
|
var StarUI = {
|
|
_itemId: -1,
|
|
uri: null,
|
|
_batching: false,
|
|
_isNewBookmark: false,
|
|
_autoCloseTimer: 0,
|
|
|
|
_element: function(aID) {
|
|
return document.getElementById(aID);
|
|
},
|
|
|
|
// Edit-bookmark panel
|
|
get panel() {
|
|
delete this.panel;
|
|
var element = this._element("editBookmarkPanel");
|
|
// initially the panel is hidden
|
|
// to avoid impacting startup / new window performance
|
|
element.hidden = false;
|
|
element.addEventListener("keypress", this, false);
|
|
element.addEventListener("mouseout", this, false);
|
|
element.addEventListener("mousemove", this, false);
|
|
element.addEventListener("popuphidden", this, false);
|
|
element.addEventListener("popupshown", this, false);
|
|
return this.panel = element;
|
|
},
|
|
|
|
// Array of command elements to disable when the panel is opened.
|
|
get _blockedCommands() {
|
|
delete this._blockedCommands;
|
|
return this._blockedCommands =
|
|
["cmd_close", "cmd_closeWindow"].map(id => this._element(id));
|
|
},
|
|
|
|
_blockCommands: function SU__blockCommands() {
|
|
this._blockedCommands.forEach(function (elt) {
|
|
// make sure not to permanently disable this item (see bug 409155)
|
|
if (elt.hasAttribute("wasDisabled"))
|
|
return;
|
|
if (elt.getAttribute("disabled") == "true") {
|
|
elt.setAttribute("wasDisabled", "true");
|
|
} else {
|
|
elt.setAttribute("wasDisabled", "false");
|
|
elt.setAttribute("disabled", "true");
|
|
}
|
|
});
|
|
},
|
|
|
|
_restoreCommandsState: function SU__restoreCommandsState() {
|
|
this._blockedCommands.forEach(function (elt) {
|
|
if (elt.getAttribute("wasDisabled") != "true")
|
|
elt.removeAttribute("disabled");
|
|
elt.removeAttribute("wasDisabled");
|
|
});
|
|
},
|
|
|
|
// nsIDOMEventListener
|
|
handleEvent(aEvent) {
|
|
switch (aEvent.type) {
|
|
case "mousemove":
|
|
clearTimeout(this._autoCloseTimer);
|
|
break;
|
|
case "popuphidden":
|
|
clearTimeout(this._autoCloseTimer);
|
|
if (aEvent.originalTarget == this.panel) {
|
|
if (!this._element("editBookmarkPanelContent").hidden)
|
|
this.quitEditMode();
|
|
|
|
if (this._anchorToolbarButton) {
|
|
this._anchorToolbarButton.removeAttribute("open");
|
|
this._anchorToolbarButton = null;
|
|
}
|
|
this._restoreCommandsState();
|
|
this._itemId = -1;
|
|
if (this._batching)
|
|
this.endBatch();
|
|
|
|
if (this._uriForRemoval) {
|
|
if (this._isNewBookmark) {
|
|
if (!PlacesUtils.useAsyncTransactions) {
|
|
PlacesUtils.transactionManager.undoTransaction();
|
|
break;
|
|
}
|
|
PlacesTransactions().undo().catch(Cu.reportError);
|
|
break;
|
|
}
|
|
// Remove all bookmarks for the bookmark's url, this also removes
|
|
// the tags for the url.
|
|
if (!PlacesUIUtils.useAsyncTransactions) {
|
|
let itemIds = PlacesUtils.getBookmarksForURI(this._uriForRemoval);
|
|
for (let itemId of itemIds) {
|
|
let txn = new PlacesRemoveItemTransaction(itemId);
|
|
PlacesUtils.transactionManager.doTransaction(txn);
|
|
}
|
|
break;
|
|
}
|
|
|
|
PlacesTransactions.RemoveBookmarksForUrls([this._uriForRemoval])
|
|
.transact().catch(Cu.reportError);
|
|
}
|
|
}
|
|
break;
|
|
case "keypress":
|
|
clearTimeout(this._autoCloseTimer);
|
|
|
|
if (aEvent.defaultPrevented) {
|
|
// The event has already been consumed inside of the panel.
|
|
break;
|
|
}
|
|
|
|
switch (aEvent.keyCode) {
|
|
case KeyEvent.DOM_VK_ESCAPE:
|
|
this.panel.hidePopup();
|
|
break;
|
|
case KeyEvent.DOM_VK_RETURN:
|
|
if (aEvent.target.classList.contains("expander-up") ||
|
|
aEvent.target.classList.contains("expander-down") ||
|
|
aEvent.target.id == "editBMPanel_newFolderButton") {
|
|
//XXX Why is this necessary? The defaultPrevented check should
|
|
// be enough.
|
|
break;
|
|
}
|
|
this.panel.hidePopup();
|
|
break;
|
|
}
|
|
break;
|
|
case "mouseout":
|
|
// Explicit fall-through
|
|
case "popupshown":
|
|
// Don't handle events for descendent elements.
|
|
if (aEvent.target != aEvent.currentTarget) {
|
|
break;
|
|
}
|
|
// auto-close if new and not interacted with
|
|
if (this._isNewBookmark) {
|
|
// 3500ms matches the timeout that Pocket uses in
|
|
// browser/extensions/pocket/content/panels/js/saved.js
|
|
let delay = 3500;
|
|
if (this._closePanelQuickForTesting) {
|
|
delay /= 10;
|
|
}
|
|
this._autoCloseTimer = setTimeout(() => {
|
|
this.panel.hidePopup();
|
|
}, delay);
|
|
}
|
|
break;
|
|
}
|
|
},
|
|
|
|
_overlayLoaded: false,
|
|
_overlayLoading: false,
|
|
showEditBookmarkPopup: Task.async(function* (aNode, aAnchorElement, aPosition, aIsNewBookmark) {
|
|
// Slow double-clicks (not true double-clicks) shouldn't
|
|
// cause the panel to flicker.
|
|
if (this.panel.state == "showing" ||
|
|
this.panel.state == "open") {
|
|
return;
|
|
}
|
|
|
|
this._isNewBookmark = aIsNewBookmark;
|
|
this._uriForRemoval = "";
|
|
// TODO: Deprecate this once async transactions are enabled and the legacy
|
|
// transactions code is gone (bug 1131491) - we don't want addons to to use
|
|
// the completeNodeLikeObjectForItemId, so it's better if they keep passing
|
|
// the item-id for now).
|
|
if (typeof(aNode) == "number") {
|
|
let itemId = aNode;
|
|
if (PlacesUIUtils.useAsyncTransactions) {
|
|
let guid = yield PlacesUtils.promiseItemGuid(itemId);
|
|
aNode = yield PlacesUIUtils.promiseNodeLike(guid);
|
|
}
|
|
else {
|
|
aNode = { itemId };
|
|
yield PlacesUIUtils.completeNodeLikeObjectForItemId(aNode);
|
|
}
|
|
}
|
|
|
|
// Performance: load the overlay the first time the panel is opened
|
|
// (see bug 392443).
|
|
if (this._overlayLoading)
|
|
return;
|
|
|
|
if (this._overlayLoaded) {
|
|
this._doShowEditBookmarkPanel(aNode, aAnchorElement, aPosition);
|
|
return;
|
|
}
|
|
|
|
this._overlayLoading = true;
|
|
document.loadOverlay(
|
|
"chrome://browser/content/places/editBookmarkOverlay.xul",
|
|
(function (aSubject, aTopic, aData) {
|
|
// Move the header (star, title, button) into the grid,
|
|
// so that it aligns nicely with the other items (bug 484022).
|
|
let header = this._element("editBookmarkPanelHeader");
|
|
let rows = this._element("editBookmarkPanelGrid").lastChild;
|
|
rows.insertBefore(header, rows.firstChild);
|
|
header.hidden = false;
|
|
|
|
this._overlayLoading = false;
|
|
this._overlayLoaded = true;
|
|
this._doShowEditBookmarkPanel(aNode, aAnchorElement, aPosition);
|
|
}).bind(this)
|
|
);
|
|
}),
|
|
|
|
_doShowEditBookmarkPanel: Task.async(function* (aNode, aAnchorElement, aPosition) {
|
|
if (this.panel.state != "closed")
|
|
return;
|
|
|
|
this._blockCommands(); // un-done in the popuphidden handler
|
|
|
|
this._element("editBookmarkPanelTitle").value =
|
|
this._isNewBookmark ?
|
|
gNavigatorBundle.getString("editBookmarkPanel.pageBookmarkedTitle") :
|
|
gNavigatorBundle.getString("editBookmarkPanel.editBookmarkTitle");
|
|
|
|
// No description; show the Done, Remove;
|
|
this._element("editBookmarkPanelDescription").textContent = "";
|
|
this._element("editBookmarkPanelBottomButtons").hidden = false;
|
|
this._element("editBookmarkPanelContent").hidden = false;
|
|
|
|
// The label of the remove button differs if the URI is bookmarked
|
|
// multiple times.
|
|
let bookmarks = PlacesUtils.getBookmarksForURI(gBrowser.currentURI);
|
|
let forms = gNavigatorBundle.getString("editBookmark.removeBookmarks.label");
|
|
let label = PluralForm.get(bookmarks.length, forms).replace("#1", bookmarks.length);
|
|
this._element("editBookmarkPanelRemoveButton").label = label;
|
|
|
|
// unset the unstarred state, if set
|
|
this._element("editBookmarkPanelStarIcon").removeAttribute("unstarred");
|
|
|
|
this._itemId = aNode.itemId;
|
|
this.beginBatch();
|
|
|
|
if (aAnchorElement) {
|
|
// Set the open=true attribute if the anchor is a
|
|
// descendent of a toolbarbutton.
|
|
let parent = aAnchorElement.parentNode;
|
|
while (parent) {
|
|
if (parent.localName == "toolbarbutton") {
|
|
break;
|
|
}
|
|
parent = parent.parentNode;
|
|
}
|
|
if (parent) {
|
|
this._anchorToolbarButton = parent;
|
|
parent.setAttribute("open", "true");
|
|
}
|
|
}
|
|
this.panel.openPopup(aAnchorElement, aPosition);
|
|
|
|
gEditItemOverlay.initPanel({ node: aNode
|
|
, hiddenRows: ["description", "location",
|
|
"loadInSidebar", "keyword"]
|
|
, focusedElement: "preferred" });
|
|
}),
|
|
|
|
panelShown:
|
|
function SU_panelShown(aEvent) {
|
|
if (aEvent.target == this.panel) {
|
|
if (this._element("editBookmarkPanelContent").hidden) {
|
|
// Note this isn't actually used anymore, we should remove this
|
|
// once we decide not to bring back the page bookmarked notification
|
|
this.panel.focus();
|
|
}
|
|
}
|
|
},
|
|
|
|
quitEditMode: function SU_quitEditMode() {
|
|
this._element("editBookmarkPanelContent").hidden = true;
|
|
this._element("editBookmarkPanelBottomButtons").hidden = true;
|
|
gEditItemOverlay.uninitPanel(true);
|
|
},
|
|
|
|
removeBookmarkButtonCommand: function SU_removeBookmarkButtonCommand() {
|
|
this._uriForRemoval = PlacesUtils.bookmarks.getBookmarkURI(this._itemId);
|
|
this.panel.hidePopup();
|
|
},
|
|
|
|
// Matching the way it is used in the Library, editBookmarkOverlay implements
|
|
// an instant-apply UI, having no batched-Undo/Redo support.
|
|
// However, in this context (the Star UI) we have a Cancel button whose
|
|
// expected behavior is to undo all the operations done in the panel.
|
|
// Sometime in the future this needs to be reimplemented using a
|
|
// non-instant apply code path, but for the time being, we patch-around
|
|
// editBookmarkOverlay so that all of the actions done in the panel
|
|
// are treated by PlacesTransactions as a single batch. To do so,
|
|
// we start a PlacesTransactions batch when the star UI panel is shown, and
|
|
// we keep the batch ongoing until the panel is hidden.
|
|
_batchBlockingDeferred: null,
|
|
beginBatch() {
|
|
if (this._batching)
|
|
return;
|
|
if (PlacesUIUtils.useAsyncTransactions) {
|
|
this._batchBlockingDeferred = PromiseUtils.defer();
|
|
PlacesTransactions.batch(function* () {
|
|
yield this._batchBlockingDeferred.promise;
|
|
}.bind(this));
|
|
}
|
|
else {
|
|
PlacesUtils.transactionManager.beginBatch(null);
|
|
}
|
|
this._batching = true;
|
|
},
|
|
|
|
endBatch() {
|
|
if (!this._batching)
|
|
return;
|
|
|
|
if (PlacesUIUtils.useAsyncTransactions) {
|
|
this._batchBlockingDeferred.resolve();
|
|
this._batchBlockingDeferred = null;
|
|
}
|
|
else {
|
|
PlacesUtils.transactionManager.endBatch(false);
|
|
}
|
|
this._batching = false;
|
|
}
|
|
};
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
//// PlacesCommandHook
|
|
|
|
var PlacesCommandHook = {
|
|
/**
|
|
* Adds a bookmark to the page loaded in the given browser.
|
|
*
|
|
* @param aBrowser
|
|
* a <browser> element.
|
|
* @param [optional] aParent
|
|
* The folder in which to create a new bookmark if the page loaded in
|
|
* aBrowser isn't bookmarked yet, defaults to the unfiled root.
|
|
* @param [optional] aShowEditUI
|
|
* whether or not to show the edit-bookmark UI for the bookmark item
|
|
*/
|
|
bookmarkPage: Task.async(function* (aBrowser, aParent, aShowEditUI) {
|
|
if (PlacesUIUtils.useAsyncTransactions) {
|
|
yield this._bookmarkPagePT(aBrowser, aParent, aShowEditUI);
|
|
return;
|
|
}
|
|
|
|
var uri = aBrowser.currentURI;
|
|
var itemId = PlacesUtils.getMostRecentBookmarkForURI(uri);
|
|
let isNewBookmark = itemId == -1;
|
|
if (isNewBookmark) {
|
|
// Bug 1148838 - Make this code work for full page plugins.
|
|
var title;
|
|
var description;
|
|
var charset;
|
|
|
|
let docInfo = yield this._getPageDetails(aBrowser);
|
|
|
|
try {
|
|
title = docInfo.isErrorPage ? PlacesUtils.history.getPageTitle(uri)
|
|
: aBrowser.contentTitle;
|
|
title = title || uri.spec;
|
|
description = docInfo.description;
|
|
charset = aBrowser.characterSet;
|
|
}
|
|
catch (e) { }
|
|
|
|
if (aShowEditUI && isNewBookmark) {
|
|
// If we bookmark the page here but open right into a cancelable
|
|
// state (i.e. new bookmark in Library), start batching here so
|
|
// all of the actions can be undone in a single undo step.
|
|
StarUI.beginBatch();
|
|
}
|
|
|
|
var parent = aParent !== undefined ?
|
|
aParent : PlacesUtils.unfiledBookmarksFolderId;
|
|
var descAnno = { name: PlacesUIUtils.DESCRIPTION_ANNO, value: description };
|
|
var txn = new PlacesCreateBookmarkTransaction(uri, parent,
|
|
PlacesUtils.bookmarks.DEFAULT_INDEX,
|
|
title, null, [descAnno]);
|
|
PlacesUtils.transactionManager.doTransaction(txn);
|
|
itemId = txn.item.id;
|
|
// Set the character-set.
|
|
if (charset && !PrivateBrowsingUtils.isBrowserPrivate(aBrowser))
|
|
PlacesUtils.setCharsetForURI(uri, charset);
|
|
}
|
|
|
|
// Revert the contents of the location bar
|
|
gURLBar.handleRevert();
|
|
|
|
// If it was not requested to open directly in "edit" mode, we are done.
|
|
if (!aShowEditUI)
|
|
return;
|
|
|
|
// Try to dock the panel to:
|
|
// 1. the bookmarks menu button
|
|
// 2. the identity icon
|
|
// 3. the content area
|
|
if (BookmarkingUI.anchor) {
|
|
StarUI.showEditBookmarkPopup(itemId, BookmarkingUI.anchor,
|
|
"bottomcenter topright", isNewBookmark);
|
|
return;
|
|
}
|
|
|
|
let identityIcon = document.getElementById("identity-icon");
|
|
if (isElementVisible(identityIcon)) {
|
|
StarUI.showEditBookmarkPopup(itemId, identityIcon,
|
|
"bottomcenter topright", isNewBookmark);
|
|
} else {
|
|
StarUI.showEditBookmarkPopup(itemId, aBrowser, "overlap", isNewBookmark);
|
|
}
|
|
}),
|
|
|
|
// TODO: Replace bookmarkPage code with this function once legacy
|
|
// transactions are removed.
|
|
_bookmarkPagePT: Task.async(function* (aBrowser, aParentId, aShowEditUI) {
|
|
let url = new URL(aBrowser.currentURI.spec);
|
|
let info = yield PlacesUtils.bookmarks.fetch({ url });
|
|
let isNewBookmark = !info;
|
|
if (!info) {
|
|
let parentGuid = aParentId !== undefined ?
|
|
yield PlacesUtils.promiseItemGuid(aParentId) :
|
|
PlacesUtils.bookmarks.unfiledGuid;
|
|
info = { url, parentGuid };
|
|
// Bug 1148838 - Make this code work for full page plugins.
|
|
let description = null;
|
|
let charset = null;
|
|
|
|
let docInfo = yield this._getPageDetails(aBrowser);
|
|
|
|
try {
|
|
info.title = docInfo.isErrorPage ?
|
|
(yield PlacesUtils.promisePlaceInfo(aBrowser.currentURI)).title :
|
|
aBrowser.contentTitle;
|
|
info.title = info.title || url.href;
|
|
description = docInfo.description;
|
|
charset = aBrowser.characterSet;
|
|
}
|
|
catch (e) {
|
|
Components.utils.reportError(e);
|
|
}
|
|
|
|
if (aShowEditUI && isNewBookmark) {
|
|
// If we bookmark the page here but open right into a cancelable
|
|
// state (i.e. new bookmark in Library), start batching here so
|
|
// all of the actions can be undone in a single undo step.
|
|
StarUI.beginBatch();
|
|
}
|
|
|
|
if (description) {
|
|
info.annotations = [{ name: PlacesUIUtils.DESCRIPTION_ANNO
|
|
, value: description }];
|
|
}
|
|
|
|
info.guid = yield PlacesTransactions.NewBookmark(info).transact();
|
|
|
|
// Set the character-set
|
|
if (charset && !PrivateBrowsingUtils.isBrowserPrivate(aBrowser))
|
|
PlacesUtils.setCharsetForURI(makeURI(url.href), charset);
|
|
}
|
|
|
|
// Revert the contents of the location bar
|
|
gURLBar.handleRevert();
|
|
|
|
// If it was not requested to open directly in "edit" mode, we are done.
|
|
if (!aShowEditUI)
|
|
return;
|
|
|
|
let node = yield PlacesUIUtils.promiseNodeLikeFromFetchInfo(info);
|
|
|
|
// Try to dock the panel to:
|
|
// 1. the bookmarks menu button
|
|
// 2. the identity icon
|
|
// 3. the content area
|
|
if (BookmarkingUI.anchor) {
|
|
StarUI.showEditBookmarkPopup(node, BookmarkingUI.anchor,
|
|
"bottomcenter topright", isNewBookmark);
|
|
return;
|
|
}
|
|
|
|
let identityIcon = document.getElementById("identity-icon");
|
|
if (isElementVisible(identityIcon)) {
|
|
StarUI.showEditBookmarkPopup(node, identityIcon,
|
|
"bottomcenter topright", isNewBookmark);
|
|
} else {
|
|
StarUI.showEditBookmarkPopup(node, aBrowser, "overlap", isNewBookmark);
|
|
}
|
|
}),
|
|
|
|
_getPageDetails(browser) {
|
|
return new Promise(resolve => {
|
|
let mm = browser.messageManager;
|
|
mm.addMessageListener("Bookmarks:GetPageDetails:Result", function listener(msg) {
|
|
mm.removeMessageListener("Bookmarks:GetPageDetails:Result", listener);
|
|
resolve(msg.data);
|
|
});
|
|
|
|
mm.sendAsyncMessage("Bookmarks:GetPageDetails", { })
|
|
});
|
|
},
|
|
|
|
/**
|
|
* Adds a bookmark to the page loaded in the current tab.
|
|
*/
|
|
bookmarkCurrentPage: function PCH_bookmarkCurrentPage(aShowEditUI, aParent) {
|
|
this.bookmarkPage(gBrowser.selectedBrowser, aParent, aShowEditUI);
|
|
},
|
|
|
|
/**
|
|
* Adds a bookmark to the page targeted by a link.
|
|
* @param aParent
|
|
* The folder in which to create a new bookmark if aURL isn't
|
|
* bookmarked.
|
|
* @param aURL (string)
|
|
* the address of the link target
|
|
* @param aTitle
|
|
* The link text
|
|
* @param [optional] aDescription
|
|
* The linked page description, if available
|
|
*/
|
|
bookmarkLink: Task.async(function* (aParentId, aURL, aTitle, aDescription="") {
|
|
let node = yield PlacesUIUtils.fetchNodeLike({ url: aURL });
|
|
if (node) {
|
|
PlacesUIUtils.showBookmarkDialog({ action: "edit"
|
|
, node
|
|
}, window.top);
|
|
return;
|
|
}
|
|
|
|
let ip = new InsertionPoint(aParentId,
|
|
PlacesUtils.bookmarks.DEFAULT_INDEX,
|
|
Components.interfaces.nsITreeView.DROP_ON);
|
|
PlacesUIUtils.showBookmarkDialog({ action: "add"
|
|
, type: "bookmark"
|
|
, uri: makeURI(aURL)
|
|
, title: aTitle
|
|
, description: aDescription
|
|
, defaultInsertionPoint: ip
|
|
, hiddenRows: [ "description"
|
|
, "location"
|
|
, "loadInSidebar"
|
|
, "keyword" ]
|
|
}, window.top);
|
|
}),
|
|
|
|
/**
|
|
* List of nsIURI objects characterizing the tabs currently open in the
|
|
* browser, modulo pinned tabs. The URIs will be in the order in which their
|
|
* corresponding tabs appeared and duplicates are discarded.
|
|
*/
|
|
get uniqueCurrentPages() {
|
|
let uniquePages = {};
|
|
let URIs = [];
|
|
|
|
gBrowser.visibleTabs.forEach(tab => {
|
|
let browser = tab.linkedBrowser;
|
|
let uri = browser.currentURI;
|
|
let title = browser.contentTitle || tab.label;
|
|
let spec = uri.spec;
|
|
if (!tab.pinned && !(spec in uniquePages)) {
|
|
uniquePages[spec] = null;
|
|
URIs.push({ uri, title });
|
|
}
|
|
});
|
|
return URIs;
|
|
},
|
|
|
|
/**
|
|
* Adds a folder with bookmarks to all of the currently open tabs in this
|
|
* window.
|
|
*/
|
|
bookmarkCurrentPages: function PCH_bookmarkCurrentPages() {
|
|
let pages = this.uniqueCurrentPages;
|
|
if (pages.length > 1) {
|
|
PlacesUIUtils.showBookmarkDialog({ action: "add"
|
|
, type: "folder"
|
|
, URIList: pages
|
|
, hiddenRows: [ "description" ]
|
|
}, window);
|
|
}
|
|
},
|
|
|
|
/**
|
|
* Updates disabled state for the "Bookmark All Tabs" command.
|
|
*/
|
|
updateBookmarkAllTabsCommand:
|
|
function PCH_updateBookmarkAllTabsCommand() {
|
|
// There's nothing to do in non-browser windows.
|
|
if (window.location.href != getBrowserURL())
|
|
return;
|
|
|
|
// Disable "Bookmark All Tabs" if there are less than two
|
|
// "unique current pages".
|
|
goSetCommandEnabled("Browser:BookmarkAllTabs",
|
|
this.uniqueCurrentPages.length >= 2);
|
|
},
|
|
|
|
/**
|
|
* Adds a Live Bookmark to a feed associated with the current page.
|
|
* @param url
|
|
* The nsIURI of the page the feed was attached to
|
|
* @title title
|
|
* The title of the feed. Optional.
|
|
* @subtitle subtitle
|
|
* A short description of the feed. Optional.
|
|
*/
|
|
addLiveBookmark: Task.async(function *(url, feedTitle, feedSubtitle) {
|
|
let toolbarIP = new InsertionPoint(PlacesUtils.toolbarFolderId,
|
|
PlacesUtils.bookmarks.DEFAULT_INDEX,
|
|
Components.interfaces.nsITreeView.DROP_ON);
|
|
|
|
let feedURI = makeURI(url);
|
|
let title = feedTitle || gBrowser.contentTitle;
|
|
let description = feedSubtitle;
|
|
if (!description) {
|
|
description = (yield this._getPageDetails(gBrowser.selectedBrowser)).description;
|
|
}
|
|
|
|
PlacesUIUtils.showBookmarkDialog({ action: "add"
|
|
, type: "livemark"
|
|
, feedURI: feedURI
|
|
, siteURI: gBrowser.currentURI
|
|
, title: title
|
|
, description: description
|
|
, defaultInsertionPoint: toolbarIP
|
|
, hiddenRows: [ "feedLocation"
|
|
, "siteLocation"
|
|
, "description" ]
|
|
}, window);
|
|
}),
|
|
|
|
/**
|
|
* Opens the Places Organizer.
|
|
* @param aLeftPaneRoot
|
|
* The query to select in the organizer window - options
|
|
* are: History, AllBookmarks, BookmarksMenu, BookmarksToolbar,
|
|
* UnfiledBookmarks, Tags and Downloads.
|
|
*/
|
|
showPlacesOrganizer: function PCH_showPlacesOrganizer(aLeftPaneRoot) {
|
|
var organizer = Services.wm.getMostRecentWindow("Places:Organizer");
|
|
// Due to bug 528706, getMostRecentWindow can return closed windows.
|
|
if (!organizer || organizer.closed) {
|
|
// No currently open places window, so open one with the specified mode.
|
|
openDialog("chrome://browser/content/places/places.xul",
|
|
"", "chrome,toolbar=yes,dialog=no,resizable", aLeftPaneRoot);
|
|
}
|
|
else {
|
|
organizer.PlacesOrganizer.selectLeftPaneContainerByHierarchy(aLeftPaneRoot);
|
|
organizer.focus();
|
|
}
|
|
}
|
|
};
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
//// HistoryMenu
|
|
|
|
XPCOMUtils.defineLazyModuleGetter(this, "RecentlyClosedTabsAndWindowsMenuUtils",
|
|
"resource:///modules/sessionstore/RecentlyClosedTabsAndWindowsMenuUtils.jsm");
|
|
|
|
// View for the history menu.
|
|
function HistoryMenu(aPopupShowingEvent) {
|
|
// Workaround for Bug 610187. The sidebar does not include all the Places
|
|
// views definitions, and we don't need them there.
|
|
// Defining the prototype inheritance in the prototype itself would cause
|
|
// browser.js to halt on "PlacesMenu is not defined" error.
|
|
this.__proto__.__proto__ = PlacesMenu.prototype;
|
|
PlacesMenu.call(this, aPopupShowingEvent,
|
|
"place:sort=4&maxResults=15");
|
|
}
|
|
|
|
HistoryMenu.prototype = {
|
|
_getClosedTabCount() {
|
|
// SessionStore doesn't track the hidden window, so just return zero then.
|
|
if (window == Services.appShell.hiddenDOMWindow) {
|
|
return 0;
|
|
}
|
|
|
|
return SessionStore.getClosedTabCount(window);
|
|
},
|
|
|
|
toggleRecentlyClosedTabs: function HM_toggleRecentlyClosedTabs() {
|
|
// enable/disable the Recently Closed Tabs sub menu
|
|
var undoMenu = this._rootElt.getElementsByClassName("recentlyClosedTabsMenu")[0];
|
|
|
|
// no restorable tabs, so disable menu
|
|
if (this._getClosedTabCount() == 0)
|
|
undoMenu.setAttribute("disabled", true);
|
|
else
|
|
undoMenu.removeAttribute("disabled");
|
|
},
|
|
|
|
/**
|
|
* Populate when the history menu is opened
|
|
*/
|
|
populateUndoSubmenu: function PHM_populateUndoSubmenu() {
|
|
var undoMenu = this._rootElt.getElementsByClassName("recentlyClosedTabsMenu")[0];
|
|
var undoPopup = undoMenu.firstChild;
|
|
|
|
// remove existing menu items
|
|
while (undoPopup.hasChildNodes())
|
|
undoPopup.removeChild(undoPopup.firstChild);
|
|
|
|
// no restorable tabs, so make sure menu is disabled, and return
|
|
if (this._getClosedTabCount() == 0) {
|
|
undoMenu.setAttribute("disabled", true);
|
|
return;
|
|
}
|
|
|
|
// enable menu
|
|
undoMenu.removeAttribute("disabled");
|
|
|
|
// populate menu
|
|
let tabsFragment = RecentlyClosedTabsAndWindowsMenuUtils.getTabsFragment(window, "menuitem");
|
|
undoPopup.appendChild(tabsFragment);
|
|
},
|
|
|
|
toggleRecentlyClosedWindows: function PHM_toggleRecentlyClosedWindows() {
|
|
// enable/disable the Recently Closed Windows sub menu
|
|
var undoMenu = this._rootElt.getElementsByClassName("recentlyClosedWindowsMenu")[0];
|
|
|
|
// no restorable windows, so disable menu
|
|
if (SessionStore.getClosedWindowCount() == 0)
|
|
undoMenu.setAttribute("disabled", true);
|
|
else
|
|
undoMenu.removeAttribute("disabled");
|
|
},
|
|
|
|
/**
|
|
* Populate when the history menu is opened
|
|
*/
|
|
populateUndoWindowSubmenu: function PHM_populateUndoWindowSubmenu() {
|
|
let undoMenu = this._rootElt.getElementsByClassName("recentlyClosedWindowsMenu")[0];
|
|
let undoPopup = undoMenu.firstChild;
|
|
let menuLabelString = gNavigatorBundle.getString("menuUndoCloseWindowLabel");
|
|
let menuLabelStringSingleTab =
|
|
gNavigatorBundle.getString("menuUndoCloseWindowSingleTabLabel");
|
|
|
|
// remove existing menu items
|
|
while (undoPopup.hasChildNodes())
|
|
undoPopup.removeChild(undoPopup.firstChild);
|
|
|
|
// no restorable windows, so make sure menu is disabled, and return
|
|
if (SessionStore.getClosedWindowCount() == 0) {
|
|
undoMenu.setAttribute("disabled", true);
|
|
return;
|
|
}
|
|
|
|
// enable menu
|
|
undoMenu.removeAttribute("disabled");
|
|
|
|
// populate menu
|
|
let windowsFragment = RecentlyClosedTabsAndWindowsMenuUtils.getWindowsFragment(window, "menuitem");
|
|
undoPopup.appendChild(windowsFragment);
|
|
},
|
|
|
|
toggleTabsFromOtherComputers: function PHM_toggleTabsFromOtherComputers() {
|
|
// Enable/disable the Tabs From Other Computers menu. Some of the menus handled
|
|
// by HistoryMenu do not have this menuitem.
|
|
let menuitem = this._rootElt.getElementsByClassName("syncTabsMenuItem")[0];
|
|
if (!menuitem)
|
|
return;
|
|
|
|
if (!PlacesUIUtils.shouldShowTabsFromOtherComputersMenuitem()) {
|
|
menuitem.setAttribute("hidden", true);
|
|
return;
|
|
}
|
|
|
|
menuitem.setAttribute("hidden", false);
|
|
},
|
|
|
|
_onPopupShowing: function HM__onPopupShowing(aEvent) {
|
|
PlacesMenu.prototype._onPopupShowing.apply(this, arguments);
|
|
|
|
// Don't handle events for submenus.
|
|
if (aEvent.target != aEvent.currentTarget)
|
|
return;
|
|
|
|
this.toggleRecentlyClosedTabs();
|
|
this.toggleRecentlyClosedWindows();
|
|
this.toggleTabsFromOtherComputers();
|
|
},
|
|
|
|
_onCommand: function HM__onCommand(aEvent) {
|
|
let placesNode = aEvent.target._placesNode;
|
|
if (placesNode) {
|
|
if (!PrivateBrowsingUtils.isWindowPrivate(window))
|
|
PlacesUIUtils.markPageAsTyped(placesNode.uri);
|
|
openUILink(placesNode.uri, aEvent, { ignoreAlt: true });
|
|
}
|
|
}
|
|
};
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
//// BookmarksEventHandler
|
|
|
|
/**
|
|
* Functions for handling events in the Bookmarks Toolbar and menu.
|
|
*/
|
|
var BookmarksEventHandler = {
|
|
/**
|
|
* Handler for click event for an item in the bookmarks toolbar or menu.
|
|
* Menus and submenus from the folder buttons bubble up to this handler.
|
|
* Left-click is handled in the onCommand function.
|
|
* When items are middle-clicked (or clicked with modifier), open in tabs.
|
|
* If the click came through a menu, close the menu.
|
|
* @param aEvent
|
|
* DOMEvent for the click
|
|
* @param aView
|
|
* The places view which aEvent should be associated with.
|
|
*/
|
|
onClick: function BEH_onClick(aEvent, aView) {
|
|
// Only handle middle-click or left-click with modifiers.
|
|
let modifKey;
|
|
if (AppConstants.platform == "macosx") {
|
|
modifKey = aEvent.metaKey || aEvent.shiftKey;
|
|
} else {
|
|
modifKey = aEvent.ctrlKey || aEvent.shiftKey;
|
|
}
|
|
|
|
if (aEvent.button == 2 || (aEvent.button == 0 && !modifKey))
|
|
return;
|
|
|
|
var target = aEvent.originalTarget;
|
|
// If this event bubbled up from a menu or menuitem, close the menus.
|
|
// Do this before opening tabs, to avoid hiding the open tabs confirm-dialog.
|
|
if (target.localName == "menu" || target.localName == "menuitem") {
|
|
for (node = target.parentNode; node; node = node.parentNode) {
|
|
if (node.localName == "menupopup")
|
|
node.hidePopup();
|
|
else if (node.localName != "menu" &&
|
|
node.localName != "splitmenu" &&
|
|
node.localName != "hbox" &&
|
|
node.localName != "vbox" )
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (target._placesNode && PlacesUtils.nodeIsContainer(target._placesNode)) {
|
|
// Don't open the root folder in tabs when the empty area on the toolbar
|
|
// is middle-clicked or when a non-bookmark item except for Open in Tabs)
|
|
// in a bookmarks menupopup is middle-clicked.
|
|
if (target.localName == "menu" || target.localName == "toolbarbutton")
|
|
PlacesUIUtils.openContainerNodeInTabs(target._placesNode, aEvent, aView);
|
|
}
|
|
else if (aEvent.button == 1) {
|
|
// left-clicks with modifier are already served by onCommand
|
|
this.onCommand(aEvent, aView);
|
|
}
|
|
},
|
|
|
|
/**
|
|
* Handler for command event for an item in the bookmarks toolbar.
|
|
* Menus and submenus from the folder buttons bubble up to this handler.
|
|
* Opens the item.
|
|
* @param aEvent
|
|
* DOMEvent for the command
|
|
* @param aView
|
|
* The places view which aEvent should be associated with.
|
|
*/
|
|
onCommand: function BEH_onCommand(aEvent, aView) {
|
|
var target = aEvent.originalTarget;
|
|
if (target._placesNode)
|
|
PlacesUIUtils.openNodeWithEvent(target._placesNode, aEvent, aView);
|
|
},
|
|
|
|
fillInBHTooltip: function BEH_fillInBHTooltip(aDocument, aEvent) {
|
|
var node;
|
|
var cropped = false;
|
|
var targetURI;
|
|
|
|
if (aDocument.tooltipNode.localName == "treechildren") {
|
|
var tree = aDocument.tooltipNode.parentNode;
|
|
var tbo = tree.treeBoxObject;
|
|
var cell = tbo.getCellAt(aEvent.clientX, aEvent.clientY);
|
|
if (cell.row == -1)
|
|
return false;
|
|
node = tree.view.nodeForTreeIndex(cell.row);
|
|
cropped = tbo.isCellCropped(cell.row, cell.col);
|
|
}
|
|
else {
|
|
// Check whether the tooltipNode is a Places node.
|
|
// In such a case use it, otherwise check for targetURI attribute.
|
|
var tooltipNode = aDocument.tooltipNode;
|
|
if (tooltipNode._placesNode)
|
|
node = tooltipNode._placesNode;
|
|
else {
|
|
// This is a static non-Places node.
|
|
targetURI = tooltipNode.getAttribute("targetURI");
|
|
}
|
|
}
|
|
|
|
if (!node && !targetURI)
|
|
return false;
|
|
|
|
// Show node.label as tooltip's title for non-Places nodes.
|
|
var title = node ? node.title : tooltipNode.label;
|
|
|
|
// Show URL only for Places URI-nodes or nodes with a targetURI attribute.
|
|
var url;
|
|
if (targetURI || PlacesUtils.nodeIsURI(node))
|
|
url = targetURI || node.uri;
|
|
|
|
// Show tooltip for containers only if their title is cropped.
|
|
if (!cropped && !url)
|
|
return false;
|
|
|
|
var tooltipTitle = aDocument.getElementById("bhtTitleText");
|
|
tooltipTitle.hidden = (!title || (title == url));
|
|
if (!tooltipTitle.hidden)
|
|
tooltipTitle.textContent = title;
|
|
|
|
var tooltipUrl = aDocument.getElementById("bhtUrlText");
|
|
tooltipUrl.hidden = !url;
|
|
if (!tooltipUrl.hidden)
|
|
tooltipUrl.value = url;
|
|
|
|
// Show tooltip.
|
|
return true;
|
|
}
|
|
};
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
//// PlacesMenuDNDHandler
|
|
|
|
// Handles special drag and drop functionality for Places menus that are not
|
|
// part of a Places view (e.g. the bookmarks menu in the menubar).
|
|
var PlacesMenuDNDHandler = {
|
|
_springLoadDelayMs: 350,
|
|
_closeDelayMs: 500,
|
|
_loadTimer: null,
|
|
_closeTimer: null,
|
|
_closingTimerNode: null,
|
|
|
|
/**
|
|
* Called when the user enters the <menu> element during a drag.
|
|
* @param event
|
|
* The DragEnter event that spawned the opening.
|
|
*/
|
|
onDragEnter: function PMDH_onDragEnter(event) {
|
|
// Opening menus in a Places popup is handled by the view itself.
|
|
if (!this._isStaticContainer(event.target))
|
|
return;
|
|
|
|
// If we re-enter the same menu or anchor before the close timer runs out,
|
|
// we should ensure that we do not close:
|
|
if (this._closeTimer && this._closingTimerNode === event.currentTarget) {
|
|
this._closeTimer.cancel();
|
|
this._closingTimerNode = null;
|
|
this._closeTimer = null;
|
|
}
|
|
|
|
PlacesControllerDragHelper.currentDropTarget = event.target;
|
|
let popup = event.target.lastChild;
|
|
if (this._loadTimer || popup.state === "showing" || popup.state === "open")
|
|
return;
|
|
|
|
this._loadTimer = Cc["@mozilla.org/timer;1"].createInstance(Ci.nsITimer);
|
|
this._loadTimer.initWithCallback(() => {
|
|
this._loadTimer = null;
|
|
popup.setAttribute("autoopened", "true");
|
|
popup.showPopup(popup);
|
|
}, this._springLoadDelayMs, Ci.nsITimer.TYPE_ONE_SHOT);
|
|
event.preventDefault();
|
|
event.stopPropagation();
|
|
},
|
|
|
|
/**
|
|
* Handles dragleave on the <menu> element.
|
|
*/
|
|
onDragLeave: function PMDH_onDragLeave(event) {
|
|
// Handle menu-button separate targets.
|
|
if (event.relatedTarget === event.currentTarget ||
|
|
(event.relatedTarget &&
|
|
event.relatedTarget.parentNode === event.currentTarget))
|
|
return;
|
|
|
|
// Closing menus in a Places popup is handled by the view itself.
|
|
if (!this._isStaticContainer(event.target))
|
|
return;
|
|
|
|
PlacesControllerDragHelper.currentDropTarget = null;
|
|
let popup = event.target.lastChild;
|
|
|
|
if (this._loadTimer) {
|
|
this._loadTimer.cancel();
|
|
this._loadTimer = null;
|
|
}
|
|
this._closeTimer = Cc["@mozilla.org/timer;1"].createInstance(Ci.nsITimer);
|
|
this._closingTimerNode = event.currentTarget;
|
|
this._closeTimer.initWithCallback(function() {
|
|
this._closeTimer = null;
|
|
this._closingTimerNode = null;
|
|
let node = PlacesControllerDragHelper.currentDropTarget;
|
|
let inHierarchy = false;
|
|
while (node && !inHierarchy) {
|
|
inHierarchy = node == event.target;
|
|
node = node.parentNode;
|
|
}
|
|
if (!inHierarchy && popup && popup.hasAttribute("autoopened")) {
|
|
popup.removeAttribute("autoopened");
|
|
popup.hidePopup();
|
|
}
|
|
}, this._closeDelayMs, Ci.nsITimer.TYPE_ONE_SHOT);
|
|
},
|
|
|
|
/**
|
|
* Determines if a XUL element represents a static container.
|
|
* @returns true if the element is a container element (menu or
|
|
*` menu-toolbarbutton), false otherwise.
|
|
*/
|
|
_isStaticContainer: function PMDH__isContainer(node) {
|
|
let isMenu = node.localName == "menu" ||
|
|
(node.localName == "toolbarbutton" &&
|
|
(node.getAttribute("type") == "menu" ||
|
|
node.getAttribute("type") == "menu-button"));
|
|
let isStatic = !("_placesNode" in node) && node.lastChild &&
|
|
node.lastChild.hasAttribute("placespopup") &&
|
|
!node.parentNode.hasAttribute("placespopup");
|
|
return isMenu && isStatic;
|
|
},
|
|
|
|
/**
|
|
* Called when the user drags over the <menu> element.
|
|
* @param event
|
|
* The DragOver event.
|
|
*/
|
|
onDragOver: function PMDH_onDragOver(event) {
|
|
let ip = new InsertionPoint(PlacesUtils.bookmarksMenuFolderId,
|
|
PlacesUtils.bookmarks.DEFAULT_INDEX,
|
|
Components.interfaces.nsITreeView.DROP_ON);
|
|
if (ip && PlacesControllerDragHelper.canDrop(ip, event.dataTransfer))
|
|
event.preventDefault();
|
|
|
|
event.stopPropagation();
|
|
},
|
|
|
|
/**
|
|
* Called when the user drops on the <menu> element.
|
|
* @param event
|
|
* The Drop event.
|
|
*/
|
|
onDrop: function PMDH_onDrop(event) {
|
|
// Put the item at the end of bookmark menu.
|
|
let ip = new InsertionPoint(PlacesUtils.bookmarksMenuFolderId,
|
|
PlacesUtils.bookmarks.DEFAULT_INDEX,
|
|
Components.interfaces.nsITreeView.DROP_ON);
|
|
PlacesControllerDragHelper.onDrop(ip, event.dataTransfer);
|
|
PlacesControllerDragHelper.currentDropTarget = null;
|
|
event.stopPropagation();
|
|
}
|
|
};
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
//// PlacesToolbarHelper
|
|
|
|
/**
|
|
* This object handles the initialization and uninitialization of the bookmarks
|
|
* toolbar.
|
|
*/
|
|
var PlacesToolbarHelper = {
|
|
_place: "place:folder=TOOLBAR",
|
|
|
|
get _viewElt() {
|
|
return document.getElementById("PlacesToolbar");
|
|
},
|
|
|
|
get _placeholder() {
|
|
return document.getElementById("bookmarks-toolbar-placeholder");
|
|
},
|
|
|
|
init: function PTH_init(forceToolbarOverflowCheck) {
|
|
let viewElt = this._viewElt;
|
|
if (!viewElt || viewElt._placesView)
|
|
return;
|
|
|
|
// CustomizableUI.addListener is idempotent, so we can safely
|
|
// call this multiple times.
|
|
CustomizableUI.addListener(this);
|
|
|
|
// If the bookmarks toolbar item is:
|
|
// - not in a toolbar, or;
|
|
// - the toolbar is collapsed, or;
|
|
// - the toolbar is hidden some other way:
|
|
// don't initialize. Also, there is no need to initialize the toolbar if
|
|
// customizing, because that will happen when the customization is done.
|
|
let toolbar = this._getParentToolbar(viewElt);
|
|
if (!toolbar || toolbar.collapsed || this._isCustomizing ||
|
|
getComputedStyle(toolbar, "").display == "none")
|
|
return;
|
|
|
|
new PlacesToolbar(this._place);
|
|
if (forceToolbarOverflowCheck) {
|
|
viewElt._placesView.updateOverflowStatus();
|
|
}
|
|
this._shouldWrap = false;
|
|
this._setupPlaceholder();
|
|
},
|
|
|
|
uninit: function PTH_uninit() {
|
|
CustomizableUI.removeListener(this);
|
|
},
|
|
|
|
customizeStart: function PTH_customizeStart() {
|
|
try {
|
|
let viewElt = this._viewElt;
|
|
if (viewElt && viewElt._placesView)
|
|
viewElt._placesView.uninit();
|
|
} finally {
|
|
this._isCustomizing = true;
|
|
}
|
|
this._shouldWrap = this._getShouldWrap();
|
|
},
|
|
|
|
customizeChange: function PTH_customizeChange() {
|
|
this._setupPlaceholder();
|
|
},
|
|
|
|
_setupPlaceholder: function PTH_setupPlaceholder() {
|
|
let placeholder = this._placeholder;
|
|
if (!placeholder) {
|
|
return;
|
|
}
|
|
|
|
let shouldWrapNow = this._getShouldWrap();
|
|
if (this._shouldWrap != shouldWrapNow) {
|
|
if (shouldWrapNow) {
|
|
placeholder.setAttribute("wrap", "true");
|
|
} else {
|
|
placeholder.removeAttribute("wrap");
|
|
}
|
|
this._shouldWrap = shouldWrapNow;
|
|
}
|
|
},
|
|
|
|
customizeDone: function PTH_customizeDone() {
|
|
this._isCustomizing = false;
|
|
this.init(true);
|
|
},
|
|
|
|
_getShouldWrap: function PTH_getShouldWrap() {
|
|
let placement = CustomizableUI.getPlacementOfWidget("personal-bookmarks");
|
|
let area = placement && placement.area;
|
|
let areaType = area && CustomizableUI.getAreaType(area);
|
|
return !area || CustomizableUI.TYPE_MENU_PANEL == areaType;
|
|
},
|
|
|
|
onPlaceholderCommand: function () {
|
|
let widgetGroup = CustomizableUI.getWidget("personal-bookmarks");
|
|
let widget = widgetGroup.forWindow(window);
|
|
if (widget.overflowed ||
|
|
widgetGroup.areaType == CustomizableUI.TYPE_MENU_PANEL) {
|
|
PlacesCommandHook.showPlacesOrganizer("BookmarksToolbar");
|
|
}
|
|
},
|
|
|
|
_getParentToolbar: function(element) {
|
|
while (element) {
|
|
if (element.localName == "toolbar") {
|
|
return element;
|
|
}
|
|
element = element.parentNode;
|
|
}
|
|
return null;
|
|
},
|
|
|
|
onWidgetUnderflow: function(aNode, aContainer) {
|
|
// The view gets broken by being removed and reinserted by the overflowable
|
|
// toolbar, so we have to force an uninit and reinit.
|
|
let win = aNode.ownerGlobal;
|
|
if (aNode.id == "personal-bookmarks" && win == window) {
|
|
this._resetView();
|
|
}
|
|
},
|
|
|
|
onWidgetAdded: function(aWidgetId, aArea, aPosition) {
|
|
if (aWidgetId == "personal-bookmarks" && !this._isCustomizing) {
|
|
// It's possible (with the "Add to Menu", "Add to Toolbar" context
|
|
// options) that the Places Toolbar Items have been moved without
|
|
// letting us prepare and handle it with with customizeStart and
|
|
// customizeDone. If that's the case, we need to reset the views
|
|
// since they're probably broken from the DOM reparenting.
|
|
this._resetView();
|
|
}
|
|
},
|
|
|
|
_resetView: function() {
|
|
if (this._viewElt) {
|
|
// It's possible that the placesView might not exist, and we need to
|
|
// do a full init. This could happen if the Bookmarks Toolbar Items are
|
|
// moved to the Menu Panel, and then to the toolbar with the "Add to Toolbar"
|
|
// context menu option, outside of customize mode.
|
|
if (this._viewElt._placesView) {
|
|
this._viewElt._placesView.uninit();
|
|
}
|
|
this.init(true);
|
|
}
|
|
},
|
|
};
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
//// BookmarkingUI
|
|
|
|
/**
|
|
* Handles the bookmarks menu-button in the toolbar.
|
|
*/
|
|
|
|
var BookmarkingUI = {
|
|
BOOKMARK_BUTTON_ID: "bookmarks-menu-button",
|
|
BOOKMARK_BUTTON_SHORTCUT: "addBookmarkAsKb",
|
|
get button() {
|
|
delete this.button;
|
|
let widgetGroup = CustomizableUI.getWidget(this.BOOKMARK_BUTTON_ID);
|
|
return this.button = widgetGroup.forWindow(window).node;
|
|
},
|
|
|
|
/* Can't make this a self-deleting getter because it's anonymous content
|
|
* and might lose/regain bindings at some point. */
|
|
get star() {
|
|
return document.getAnonymousElementByAttribute(this.button, "anonid",
|
|
"button");
|
|
},
|
|
|
|
get anchor() {
|
|
if (!this._shouldUpdateStarState()) {
|
|
return null;
|
|
}
|
|
let widget = CustomizableUI.getWidget(this.BOOKMARK_BUTTON_ID)
|
|
.forWindow(window);
|
|
if (widget.overflowed)
|
|
return widget.anchor;
|
|
|
|
let star = this.star;
|
|
return star ? document.getAnonymousElementByAttribute(star, "class",
|
|
"toolbarbutton-icon")
|
|
: null;
|
|
},
|
|
|
|
get notifier() {
|
|
delete this.notifier;
|
|
return this.notifier = document.getElementById("bookmarked-notification-anchor");
|
|
},
|
|
|
|
get dropmarkerNotifier() {
|
|
delete this.dropmarkerNotifier;
|
|
return this.dropmarkerNotifier = document.getElementById("bookmarked-notification-dropmarker-anchor");
|
|
},
|
|
|
|
get broadcaster() {
|
|
delete this.broadcaster;
|
|
let broadcaster = document.getElementById("bookmarkThisPageBroadcaster");
|
|
return this.broadcaster = broadcaster;
|
|
},
|
|
|
|
STATUS_UPDATING: -1,
|
|
STATUS_UNSTARRED: 0,
|
|
STATUS_STARRED: 1,
|
|
get status() {
|
|
if (!this._shouldUpdateStarState()) {
|
|
return this.STATUS_UNSTARRED;
|
|
}
|
|
if (this._pendingStmt)
|
|
return this.STATUS_UPDATING;
|
|
return this.button.hasAttribute("starred") ? this.STATUS_STARRED
|
|
: this.STATUS_UNSTARRED;
|
|
},
|
|
|
|
get _starredTooltip()
|
|
{
|
|
delete this._starredTooltip;
|
|
return this._starredTooltip =
|
|
this._getFormattedTooltip("starButtonOn.tooltip2");
|
|
},
|
|
|
|
get _unstarredTooltip()
|
|
{
|
|
delete this._unstarredTooltip;
|
|
return this._unstarredTooltip =
|
|
this._getFormattedTooltip("starButtonOff.tooltip2");
|
|
},
|
|
|
|
_getFormattedTooltip: function(strId) {
|
|
let args = [];
|
|
let shortcut = document.getElementById(this.BOOKMARK_BUTTON_SHORTCUT);
|
|
if (shortcut)
|
|
args.push(ShortcutUtils.prettifyShortcut(shortcut));
|
|
return gNavigatorBundle.getFormattedString(strId, args);
|
|
},
|
|
|
|
/**
|
|
* The type of the area in which the button is currently located.
|
|
* When in the panel, we don't update the button's icon.
|
|
*/
|
|
_currentAreaType: null,
|
|
_shouldUpdateStarState: function() {
|
|
return this._currentAreaType == CustomizableUI.TYPE_TOOLBAR;
|
|
},
|
|
|
|
/**
|
|
* The popup contents must be updated when the user customizes the UI, or
|
|
* changes the personal toolbar collapsed status. In such a case, any needed
|
|
* change should be handled in the popupshowing helper, for performance
|
|
* reasons.
|
|
*/
|
|
_popupNeedsUpdate: true,
|
|
onToolbarVisibilityChange: function BUI_onToolbarVisibilityChange() {
|
|
this._popupNeedsUpdate = true;
|
|
},
|
|
|
|
onPopupShowing: function BUI_onPopupShowing(event) {
|
|
// Don't handle events for submenus.
|
|
if (event.target != event.currentTarget)
|
|
return;
|
|
|
|
// Ideally this code would never be reached, but if you click the outer
|
|
// button's border, some cpp code for the menu button's so-called XBL binding
|
|
// decides to open the popup even though the dropmarker is invisible.
|
|
if (this._currentAreaType == CustomizableUI.TYPE_MENU_PANEL) {
|
|
this._showSubview();
|
|
event.preventDefault();
|
|
event.stopPropagation();
|
|
return;
|
|
}
|
|
|
|
let widget = CustomizableUI.getWidget(this.BOOKMARK_BUTTON_ID)
|
|
.forWindow(window);
|
|
if (widget.overflowed) {
|
|
// Don't open a popup in the overflow popup, rather just open the Library.
|
|
event.preventDefault();
|
|
widget.node.removeAttribute("closemenu");
|
|
PlacesCommandHook.showPlacesOrganizer("BookmarksMenu");
|
|
return;
|
|
}
|
|
|
|
this._initRecentBookmarks(document.getElementById("BMB_recentBookmarks"),
|
|
"subviewbutton");
|
|
|
|
if (!this._popupNeedsUpdate)
|
|
return;
|
|
this._popupNeedsUpdate = false;
|
|
|
|
let popup = event.target;
|
|
let getPlacesAnonymousElement =
|
|
aAnonId => document.getAnonymousElementByAttribute(popup.parentNode,
|
|
"placesanonid",
|
|
aAnonId);
|
|
|
|
let viewToolbarMenuitem = getPlacesAnonymousElement("view-toolbar");
|
|
if (viewToolbarMenuitem) {
|
|
// Update View bookmarks toolbar checkbox menuitem.
|
|
viewToolbarMenuitem.classList.add("subviewbutton");
|
|
let personalToolbar = document.getElementById("PersonalToolbar");
|
|
viewToolbarMenuitem.setAttribute("checked", !personalToolbar.collapsed);
|
|
}
|
|
},
|
|
|
|
attachPlacesView: function(event, node) {
|
|
// If the view is already there, bail out early.
|
|
if (node.parentNode._placesView)
|
|
return;
|
|
|
|
new PlacesMenu(event, "place:folder=BOOKMARKS_MENU", {
|
|
extraClasses: {
|
|
entry: "subviewbutton",
|
|
footer: "panel-subview-footer"
|
|
},
|
|
insertionPoint: ".panel-subview-footer"
|
|
});
|
|
},
|
|
|
|
RECENTLY_BOOKMARKED_PREF: "browser.bookmarks.showRecentlyBookmarked",
|
|
|
|
_initRecentBookmarks(aHeaderItem, aExtraCSSClass) {
|
|
this._populateRecentBookmarks(aHeaderItem, aExtraCSSClass);
|
|
|
|
// Add observers and listeners and remove them again when the menupopup closes.
|
|
|
|
let bookmarksMenu = aHeaderItem.parentNode;
|
|
let placesContextMenu = document.getElementById("placesContext");
|
|
|
|
let prefObserver = () => {
|
|
this._populateRecentBookmarks(aHeaderItem, aExtraCSSClass);
|
|
};
|
|
|
|
this._recentlyBookmarkedObserver = {
|
|
QueryInterface: XPCOMUtils.generateQI([
|
|
Ci.nsINavBookmarkObserver,
|
|
Ci.nsISupportsWeakReference
|
|
])
|
|
};
|
|
this._recentlyBookmarkedObserver.onItemRemoved = () => {
|
|
// Update the menu when a bookmark has been removed.
|
|
// The native menubar on Mac doesn't support live update, so this won't
|
|
// work there.
|
|
this._populateRecentBookmarks(aHeaderItem, aExtraCSSClass);
|
|
};
|
|
|
|
let updatePlacesContextMenu = (shouldHidePrefUI = false) => {
|
|
let prefEnabled = !shouldHidePrefUI && Services.prefs.getBoolPref(this.RECENTLY_BOOKMARKED_PREF);
|
|
document.getElementById("placesContext_showRecentlyBookmarked").hidden = shouldHidePrefUI || prefEnabled;
|
|
document.getElementById("placesContext_hideRecentlyBookmarked").hidden = shouldHidePrefUI || !prefEnabled;
|
|
document.getElementById("placesContext_recentlyBookmarkedSeparator").hidden = shouldHidePrefUI;
|
|
};
|
|
|
|
let onPlacesContextMenuShowing = event => {
|
|
if (event.target == event.currentTarget) {
|
|
let triggerPopup = event.target.triggerNode;
|
|
while (triggerPopup && triggerPopup.localName != "menupopup") {
|
|
triggerPopup = triggerPopup.parentNode;
|
|
}
|
|
let shouldHidePrefUI = triggerPopup != bookmarksMenu;
|
|
updatePlacesContextMenu(shouldHidePrefUI);
|
|
}
|
|
};
|
|
|
|
let onBookmarksMenuHidden = event => {
|
|
if (event.target == event.currentTarget) {
|
|
updatePlacesContextMenu(true);
|
|
|
|
Services.prefs.removeObserver(this.RECENTLY_BOOKMARKED_PREF, prefObserver, false);
|
|
PlacesUtils.bookmarks.removeObserver(this._recentlyBookmarkedObserver);
|
|
this._recentlyBookmarkedObserver = null;
|
|
if (placesContextMenu) {
|
|
placesContextMenu.removeEventListener("popupshowing", onPlacesContextMenuShowing);
|
|
}
|
|
bookmarksMenu.removeEventListener("popuphidden", onBookmarksMenuHidden);
|
|
}
|
|
};
|
|
|
|
Services.prefs.addObserver(this.RECENTLY_BOOKMARKED_PREF, prefObserver, false);
|
|
PlacesUtils.bookmarks.addObserver(this._recentlyBookmarkedObserver, true);
|
|
|
|
// The context menu doesn't exist in non-browser windows on Mac
|
|
if (placesContextMenu) {
|
|
placesContextMenu.addEventListener("popupshowing", onPlacesContextMenuShowing);
|
|
}
|
|
|
|
bookmarksMenu.addEventListener("popuphidden", onBookmarksMenuHidden);
|
|
},
|
|
|
|
_populateRecentBookmarks(aHeaderItem, aExtraCSSClass = "") {
|
|
while (aHeaderItem.nextSibling &&
|
|
aHeaderItem.nextSibling.localName == "menuitem") {
|
|
aHeaderItem.nextSibling.remove();
|
|
}
|
|
|
|
let shouldShow = Services.prefs.getBoolPref(this.RECENTLY_BOOKMARKED_PREF);
|
|
let separator = aHeaderItem.previousSibling;
|
|
aHeaderItem.hidden = !shouldShow;
|
|
separator.hidden = !shouldShow;
|
|
|
|
if (!shouldShow) {
|
|
return;
|
|
}
|
|
|
|
const kMaxResults = 5;
|
|
|
|
let options = PlacesUtils.history.getNewQueryOptions();
|
|
options.excludeQueries = true;
|
|
options.queryType = options.QUERY_TYPE_BOOKMARKS;
|
|
options.sortingMode = options.SORT_BY_DATEADDED_DESCENDING;
|
|
options.maxResults = kMaxResults;
|
|
let query = PlacesUtils.history.getNewQuery();
|
|
|
|
let fragment = document.createDocumentFragment();
|
|
let root = PlacesUtils.history.executeQuery(query, options).root;
|
|
root.containerOpen = true;
|
|
for (let i = 0; i < root.childCount; i++) {
|
|
let node = root.getChild(i);
|
|
let uri = node.uri;
|
|
let title = node.title;
|
|
let icon = node.icon;
|
|
|
|
let item =
|
|
document.createElementNS("http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul",
|
|
"menuitem");
|
|
item.setAttribute("label", title || uri);
|
|
item.setAttribute("targetURI", uri);
|
|
item.setAttribute("simulated-places-node", true);
|
|
item.setAttribute("class", "menuitem-iconic menuitem-with-favicon bookmark-item " +
|
|
aExtraCSSClass);
|
|
if (icon) {
|
|
item.setAttribute("image", icon);
|
|
}
|
|
item._placesNode = node;
|
|
fragment.appendChild(item);
|
|
}
|
|
root.containerOpen = false;
|
|
aHeaderItem.parentNode.insertBefore(fragment, aHeaderItem.nextSibling);
|
|
},
|
|
|
|
showRecentlyBookmarked() {
|
|
Services.prefs.setBoolPref(this.RECENTLY_BOOKMARKED_PREF, true);
|
|
},
|
|
|
|
hideRecentlyBookmarked() {
|
|
Services.prefs.setBoolPref(this.RECENTLY_BOOKMARKED_PREF, false);
|
|
},
|
|
|
|
_updateCustomizationState: function BUI__updateCustomizationState() {
|
|
let placement = CustomizableUI.getPlacementOfWidget(this.BOOKMARK_BUTTON_ID);
|
|
this._currentAreaType = placement && CustomizableUI.getAreaType(placement.area);
|
|
},
|
|
|
|
_uninitView: function BUI__uninitView() {
|
|
// When an element with a placesView attached is removed and re-inserted,
|
|
// XBL reapplies the binding causing any kind of issues and possible leaks,
|
|
// so kill current view and let popupshowing generate a new one.
|
|
if (this.button._placesView)
|
|
this.button._placesView.uninit();
|
|
|
|
// We have to do the same thing for the "special" views underneath the
|
|
// the bookmarks menu.
|
|
const kSpecialViewNodeIDs = ["BMB_bookmarksToolbar", "BMB_unsortedBookmarks"];
|
|
for (let viewNodeID of kSpecialViewNodeIDs) {
|
|
let elem = document.getElementById(viewNodeID);
|
|
if (elem && elem._placesView) {
|
|
elem._placesView.uninit();
|
|
}
|
|
}
|
|
},
|
|
|
|
onCustomizeStart: function BUI_customizeStart(aWindow) {
|
|
if (aWindow == window) {
|
|
this._uninitView();
|
|
this._isCustomizing = true;
|
|
}
|
|
},
|
|
|
|
onWidgetAdded: function BUI_widgetAdded(aWidgetId) {
|
|
if (aWidgetId == this.BOOKMARK_BUTTON_ID) {
|
|
this._onWidgetWasMoved();
|
|
}
|
|
},
|
|
|
|
onWidgetRemoved: function BUI_widgetRemoved(aWidgetId) {
|
|
if (aWidgetId == this.BOOKMARK_BUTTON_ID) {
|
|
this._onWidgetWasMoved();
|
|
}
|
|
},
|
|
|
|
onWidgetReset: function BUI_widgetReset(aNode, aContainer) {
|
|
if (aNode == this.button) {
|
|
this._onWidgetWasMoved();
|
|
}
|
|
},
|
|
|
|
onWidgetUndoMove: function BUI_undoWidgetUndoMove(aNode, aContainer) {
|
|
if (aNode == this.button) {
|
|
this._onWidgetWasMoved();
|
|
}
|
|
},
|
|
|
|
_onWidgetWasMoved: function BUI_widgetWasMoved() {
|
|
let usedToUpdateStarState = this._shouldUpdateStarState();
|
|
this._updateCustomizationState();
|
|
if (!usedToUpdateStarState && this._shouldUpdateStarState()) {
|
|
this.updateStarState();
|
|
} else if (usedToUpdateStarState && !this._shouldUpdateStarState()) {
|
|
this._updateStar();
|
|
}
|
|
// If we're moved outside of customize mode, we need to uninit
|
|
// our view so it gets reconstructed.
|
|
if (!this._isCustomizing) {
|
|
this._uninitView();
|
|
}
|
|
},
|
|
|
|
onCustomizeEnd: function BUI_customizeEnd(aWindow) {
|
|
if (aWindow == window) {
|
|
this._isCustomizing = false;
|
|
this.onToolbarVisibilityChange();
|
|
}
|
|
},
|
|
|
|
init: function() {
|
|
CustomizableUI.addListener(this);
|
|
this._updateCustomizationState();
|
|
},
|
|
|
|
_hasBookmarksObserver: false,
|
|
_itemIds: [],
|
|
uninit: function BUI_uninit() {
|
|
this._updateBookmarkPageMenuItem(true);
|
|
CustomizableUI.removeListener(this);
|
|
|
|
this._uninitView();
|
|
|
|
if (this._hasBookmarksObserver) {
|
|
PlacesUtils.removeLazyBookmarkObserver(this);
|
|
}
|
|
|
|
if (this._pendingStmt) {
|
|
this._pendingStmt.cancel();
|
|
delete this._pendingStmt;
|
|
}
|
|
},
|
|
|
|
onLocationChange: function BUI_onLocationChange() {
|
|
if (this._uri && gBrowser.currentURI.equals(this._uri)) {
|
|
return;
|
|
}
|
|
this.updateStarState();
|
|
},
|
|
|
|
updateStarState: function BUI_updateStarState() {
|
|
// Reset tracked values.
|
|
this._uri = gBrowser.currentURI;
|
|
this._itemIds = [];
|
|
|
|
if (this._pendingStmt) {
|
|
this._pendingStmt.cancel();
|
|
delete this._pendingStmt;
|
|
}
|
|
|
|
this._pendingStmt = PlacesUtils.asyncGetBookmarkIds(this._uri, (aItemIds, aURI) => {
|
|
// Safety check that the bookmarked URI equals the tracked one.
|
|
if (!aURI.equals(this._uri)) {
|
|
Components.utils.reportError("BookmarkingUI did not receive current URI");
|
|
return;
|
|
}
|
|
|
|
// It's possible that onItemAdded gets called before the async statement
|
|
// calls back. For such an edge case, retain all unique entries from both
|
|
// arrays.
|
|
this._itemIds = this._itemIds.filter(
|
|
id => !aItemIds.includes(id)
|
|
).concat(aItemIds);
|
|
|
|
this._updateStar();
|
|
|
|
// Start observing bookmarks if needed.
|
|
if (!this._hasBookmarksObserver) {
|
|
try {
|
|
PlacesUtils.addLazyBookmarkObserver(this);
|
|
this._hasBookmarksObserver = true;
|
|
} catch (ex) {
|
|
Components.utils.reportError("BookmarkingUI failed adding a bookmarks observer: " + ex);
|
|
}
|
|
}
|
|
|
|
delete this._pendingStmt;
|
|
});
|
|
},
|
|
|
|
_updateStar: function BUI__updateStar() {
|
|
if (!this._shouldUpdateStarState()) {
|
|
if (this.broadcaster.hasAttribute("starred")) {
|
|
this.broadcaster.removeAttribute("starred");
|
|
this.broadcaster.removeAttribute("buttontooltiptext");
|
|
}
|
|
return;
|
|
}
|
|
|
|
if (this._itemIds.length > 0) {
|
|
this.broadcaster.setAttribute("starred", "true");
|
|
this.broadcaster.setAttribute("buttontooltiptext", this._starredTooltip);
|
|
if (this.button.getAttribute("overflowedItem") == "true") {
|
|
this.button.setAttribute("label", this._starButtonOverflowedStarredLabel);
|
|
}
|
|
}
|
|
else {
|
|
this.broadcaster.removeAttribute("starred");
|
|
this.broadcaster.setAttribute("buttontooltiptext", this._unstarredTooltip);
|
|
if (this.button.getAttribute("overflowedItem") == "true") {
|
|
this.button.setAttribute("label", this._starButtonOverflowedLabel);
|
|
}
|
|
}
|
|
},
|
|
|
|
/**
|
|
* forceReset is passed when we're destroyed and the label should go back
|
|
* to the default (Bookmark This Page) for OS X.
|
|
*/
|
|
_updateBookmarkPageMenuItem: function BUI__updateBookmarkPageMenuItem(forceReset) {
|
|
let isStarred = !forceReset && this._itemIds.length > 0;
|
|
let label = isStarred ? "editlabel" : "bookmarklabel";
|
|
if (this.broadcaster) {
|
|
this.broadcaster.setAttribute("label", this.broadcaster.getAttribute(label));
|
|
}
|
|
},
|
|
|
|
onMainMenuPopupShowing: function BUI_onMainMenuPopupShowing(event) {
|
|
// Don't handle events for submenus.
|
|
if (event.target != event.currentTarget)
|
|
return;
|
|
|
|
this._updateBookmarkPageMenuItem();
|
|
PlacesCommandHook.updateBookmarkAllTabsCommand();
|
|
this._initRecentBookmarks(document.getElementById("menu_recentBookmarks"));
|
|
},
|
|
|
|
_showBookmarkedNotification: function BUI_showBookmarkedNotification() {
|
|
function getCenteringTransformForRects(rectToPosition, referenceRect) {
|
|
let topDiff = referenceRect.top - rectToPosition.top;
|
|
let leftDiff = referenceRect.left - rectToPosition.left;
|
|
let heightDiff = referenceRect.height - rectToPosition.height;
|
|
let widthDiff = referenceRect.width - rectToPosition.width;
|
|
return [(leftDiff + .5 * widthDiff) + "px", (topDiff + .5 * heightDiff) + "px"];
|
|
}
|
|
|
|
if (this._notificationTimeout) {
|
|
clearTimeout(this._notificationTimeout);
|
|
}
|
|
|
|
if (this.notifier.style.transform == '') {
|
|
// Get all the relevant nodes and computed style objects
|
|
let dropmarker = document.getAnonymousElementByAttribute(this.button, "anonid", "dropmarker");
|
|
let dropmarkerIcon = document.getAnonymousElementByAttribute(dropmarker, "class", "dropmarker-icon");
|
|
let dropmarkerStyle = getComputedStyle(dropmarkerIcon);
|
|
|
|
// Check for RTL and get bounds
|
|
let isRTL = getComputedStyle(this.button).direction == "rtl";
|
|
let buttonRect = this.button.getBoundingClientRect();
|
|
let notifierRect = this.notifier.getBoundingClientRect();
|
|
let dropmarkerRect = dropmarkerIcon.getBoundingClientRect();
|
|
let dropmarkerNotifierRect = this.dropmarkerNotifier.getBoundingClientRect();
|
|
|
|
// Compute, but do not set, transform for star icon
|
|
let [translateX, translateY] = getCenteringTransformForRects(notifierRect, buttonRect);
|
|
let starIconTransform = "translate(" + translateX + ", " + translateY + ")";
|
|
if (isRTL) {
|
|
starIconTransform += " scaleX(-1)";
|
|
}
|
|
|
|
// Compute, but do not set, transform for dropmarker
|
|
[translateX, translateY] = getCenteringTransformForRects(dropmarkerNotifierRect, dropmarkerRect);
|
|
let dropmarkerTransform = "translate(" + translateX + ", " + translateY + ")";
|
|
|
|
// Do all layout invalidation in one go:
|
|
this.notifier.style.transform = starIconTransform;
|
|
this.dropmarkerNotifier.style.transform = dropmarkerTransform;
|
|
|
|
let dropmarkerAnimationNode = this.dropmarkerNotifier.firstChild;
|
|
dropmarkerAnimationNode.style.MozImageRegion = dropmarkerStyle.MozImageRegion;
|
|
dropmarkerAnimationNode.style.listStyleImage = dropmarkerStyle.listStyleImage;
|
|
}
|
|
|
|
let isInOverflowPanel = this.button.getAttribute("overflowedItem") == "true";
|
|
if (!isInOverflowPanel) {
|
|
this.notifier.setAttribute("notification", "finish");
|
|
this.button.setAttribute("notification", "finish");
|
|
this.dropmarkerNotifier.setAttribute("notification", "finish");
|
|
}
|
|
|
|
this._notificationTimeout = setTimeout( () => {
|
|
this.notifier.removeAttribute("notification");
|
|
this.dropmarkerNotifier.removeAttribute("notification");
|
|
this.button.removeAttribute("notification");
|
|
|
|
this.dropmarkerNotifier.style.transform = '';
|
|
this.notifier.style.transform = '';
|
|
}, 1000);
|
|
},
|
|
|
|
_showSubview: function() {
|
|
let view = document.getElementById("PanelUI-bookmarks");
|
|
view.addEventListener("ViewShowing", this);
|
|
view.addEventListener("ViewHiding", this);
|
|
let anchor = document.getElementById(this.BOOKMARK_BUTTON_ID);
|
|
anchor.setAttribute("closemenu", "none");
|
|
PanelUI.showSubView("PanelUI-bookmarks", anchor,
|
|
CustomizableUI.AREA_PANEL);
|
|
},
|
|
|
|
onCommand: function BUI_onCommand(aEvent) {
|
|
if (aEvent.target != aEvent.currentTarget) {
|
|
return;
|
|
}
|
|
|
|
// Handle special case when the button is in the panel.
|
|
let isBookmarked = this._itemIds.length > 0;
|
|
|
|
if (this._currentAreaType == CustomizableUI.TYPE_MENU_PANEL) {
|
|
this._showSubview();
|
|
return;
|
|
}
|
|
let widget = CustomizableUI.getWidget(this.BOOKMARK_BUTTON_ID)
|
|
.forWindow(window);
|
|
if (widget.overflowed) {
|
|
// Close the overflow panel because the Edit Bookmark panel will appear.
|
|
widget.node.removeAttribute("closemenu");
|
|
}
|
|
|
|
// Ignore clicks on the star if we are updating its state.
|
|
if (!this._pendingStmt) {
|
|
if (!isBookmarked)
|
|
this._showBookmarkedNotification();
|
|
PlacesCommandHook.bookmarkCurrentPage(true);
|
|
}
|
|
},
|
|
|
|
onCurrentPageContextPopupShowing() {
|
|
this._updateBookmarkPageMenuItem();
|
|
},
|
|
|
|
handleEvent: function BUI_handleEvent(aEvent) {
|
|
switch (aEvent.type) {
|
|
case "ViewShowing":
|
|
this.onPanelMenuViewShowing(aEvent);
|
|
break;
|
|
case "ViewHiding":
|
|
this.onPanelMenuViewHiding(aEvent);
|
|
break;
|
|
}
|
|
},
|
|
|
|
onPanelMenuViewShowing: function BUI_onViewShowing(aEvent) {
|
|
this._updateBookmarkPageMenuItem();
|
|
// Update checked status of the toolbar toggle.
|
|
let viewToolbar = document.getElementById("panelMenu_viewBookmarksToolbar");
|
|
let personalToolbar = document.getElementById("PersonalToolbar");
|
|
if (personalToolbar.collapsed)
|
|
viewToolbar.removeAttribute("checked");
|
|
else
|
|
viewToolbar.setAttribute("checked", "true");
|
|
// Get all statically placed buttons to supply them with keyboard shortcuts.
|
|
let staticButtons = viewToolbar.parentNode.getElementsByTagName("toolbarbutton");
|
|
for (let i = 0, l = staticButtons.length; i < l; ++i)
|
|
CustomizableUI.addShortcut(staticButtons[i]);
|
|
// Setup the Places view.
|
|
this._panelMenuView = new PlacesPanelMenuView("place:folder=BOOKMARKS_MENU",
|
|
"panelMenu_bookmarksMenu",
|
|
"panelMenu_bookmarksMenu", {
|
|
extraClasses: {
|
|
entry: "subviewbutton",
|
|
footer: "panel-subview-footer"
|
|
}
|
|
});
|
|
aEvent.target.removeEventListener("ViewShowing", this);
|
|
},
|
|
|
|
onPanelMenuViewHiding: function BUI_onViewHiding(aEvent) {
|
|
this._panelMenuView.uninit();
|
|
delete this._panelMenuView;
|
|
aEvent.target.removeEventListener("ViewHiding", this);
|
|
},
|
|
|
|
onPanelMenuViewCommand: function BUI_onPanelMenuViewCommand(aEvent, aView) {
|
|
let target = aEvent.originalTarget;
|
|
if (!target._placesNode)
|
|
return;
|
|
if (PlacesUtils.nodeIsContainer(target._placesNode))
|
|
PlacesCommandHook.showPlacesOrganizer([ "BookmarksMenu", target._placesNode.itemId ]);
|
|
else
|
|
PlacesUIUtils.openNodeWithEvent(target._placesNode, aEvent, aView);
|
|
PanelUI.hide();
|
|
},
|
|
|
|
// nsINavBookmarkObserver
|
|
onItemAdded: function BUI_onItemAdded(aItemId, aParentId, aIndex, aItemType,
|
|
aURI) {
|
|
if (aURI && aURI.equals(this._uri)) {
|
|
// If a new bookmark has been added to the tracked uri, register it.
|
|
if (!this._itemIds.includes(aItemId)) {
|
|
this._itemIds.push(aItemId);
|
|
// Only need to update the UI if it wasn't marked as starred before:
|
|
if (this._itemIds.length == 1) {
|
|
this._updateStar();
|
|
}
|
|
}
|
|
}
|
|
},
|
|
|
|
onItemRemoved: function BUI_onItemRemoved(aItemId) {
|
|
let index = this._itemIds.indexOf(aItemId);
|
|
// If one of the tracked bookmarks has been removed, unregister it.
|
|
if (index != -1) {
|
|
this._itemIds.splice(index, 1);
|
|
// Only need to update the UI if the page is no longer starred
|
|
if (this._itemIds.length == 0) {
|
|
this._updateStar();
|
|
}
|
|
}
|
|
},
|
|
|
|
onItemChanged: function BUI_onItemChanged(aItemId, aProperty,
|
|
aIsAnnotationProperty, aNewValue) {
|
|
if (aProperty == "uri") {
|
|
let index = this._itemIds.indexOf(aItemId);
|
|
// If the changed bookmark was tracked, check if it is now pointing to
|
|
// a different uri and unregister it.
|
|
if (index != -1 && aNewValue != this._uri.spec) {
|
|
this._itemIds.splice(index, 1);
|
|
// Only need to update the UI if the page is no longer starred
|
|
if (this._itemIds.length == 0) {
|
|
this._updateStar();
|
|
}
|
|
}
|
|
// If another bookmark is now pointing to the tracked uri, register it.
|
|
else if (index == -1 && aNewValue == this._uri.spec) {
|
|
this._itemIds.push(aItemId);
|
|
// Only need to update the UI if it wasn't marked as starred before:
|
|
if (this._itemIds.length == 1) {
|
|
this._updateStar();
|
|
}
|
|
}
|
|
}
|
|
},
|
|
|
|
onBeginUpdateBatch: function () {},
|
|
onEndUpdateBatch: function () {},
|
|
onBeforeItemRemoved: function () {},
|
|
onItemVisited: function () {},
|
|
onItemMoved: function () {},
|
|
|
|
// CustomizableUI events:
|
|
_starButtonLabel: null,
|
|
get _starButtonOverflowedLabel() {
|
|
delete this._starButtonOverflowedLabel;
|
|
return this._starButtonOverflowedLabel =
|
|
gNavigatorBundle.getString("starButtonOverflowed.label");
|
|
},
|
|
get _starButtonOverflowedStarredLabel() {
|
|
delete this._starButtonOverflowedStarredLabel;
|
|
return this._starButtonOverflowedStarredLabel =
|
|
gNavigatorBundle.getString("starButtonOverflowedStarred.label");
|
|
},
|
|
onWidgetOverflow: function(aNode, aContainer) {
|
|
let win = aNode.ownerGlobal;
|
|
if (aNode.id != this.BOOKMARK_BUTTON_ID || win != window)
|
|
return;
|
|
|
|
let currentLabel = aNode.getAttribute("label");
|
|
if (!this._starButtonLabel)
|
|
this._starButtonLabel = currentLabel;
|
|
|
|
if (currentLabel == this._starButtonLabel) {
|
|
let desiredLabel = this._itemIds.length > 0 ? this._starButtonOverflowedStarredLabel
|
|
: this._starButtonOverflowedLabel;
|
|
aNode.setAttribute("label", desiredLabel);
|
|
}
|
|
},
|
|
|
|
onWidgetUnderflow: function(aNode, aContainer) {
|
|
let win = aNode.ownerGlobal;
|
|
if (aNode.id != this.BOOKMARK_BUTTON_ID || win != window)
|
|
return;
|
|
|
|
// The view gets broken by being removed and reinserted. Uninit
|
|
// here so popupshowing will generate a new one:
|
|
this._uninitView();
|
|
|
|
if (aNode.getAttribute("label") != this._starButtonLabel)
|
|
aNode.setAttribute("label", this._starButtonLabel);
|
|
},
|
|
|
|
QueryInterface: XPCOMUtils.generateQI([
|
|
Ci.nsINavBookmarkObserver
|
|
])
|
|
};
|
|
|
|
var AutoShowBookmarksToolbar = {
|
|
init() {
|
|
Services.obs.addObserver(this, "autoshow-bookmarks-toolbar", false);
|
|
},
|
|
|
|
uninit() {
|
|
Services.obs.removeObserver(this, "autoshow-bookmarks-toolbar");
|
|
},
|
|
|
|
observe(subject, topic, data) {
|
|
let toolbar = document.getElementById("PersonalToolbar");
|
|
if (!toolbar.collapsed)
|
|
return;
|
|
|
|
let placement = CustomizableUI.getPlacementOfWidget("personal-bookmarks");
|
|
let area = placement && placement.area;
|
|
if (area != CustomizableUI.AREA_BOOKMARKS)
|
|
return;
|
|
|
|
setToolbarVisibility(toolbar, true);
|
|
}
|
|
};
|
|
|