summaryrefslogtreecommitdiffstats
path: root/comm/mail/base/content/folderDisplay.js
diff options
context:
space:
mode:
Diffstat (limited to '')
-rw-r--r--comm/mail/base/content/folderDisplay.js2649
1 files changed, 2649 insertions, 0 deletions
diff --git a/comm/mail/base/content/folderDisplay.js b/comm/mail/base/content/folderDisplay.js
new file mode 100644
index 0000000000..dfd5824c6b
--- /dev/null
+++ b/comm/mail/base/content/folderDisplay.js
@@ -0,0 +1,2649 @@
+/* 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/. */
+
+/* import-globals-from SearchDialog.js */
+
+/* globals ViewPickerBinding */ // From msgViewPickerOverlay.js
+
+/* TODO: Now used exclusively in SearchDialog.xhtml. Needs dead code removal. */
+
+var { XPCOMUtils } = ChromeUtils.importESModule(
+ "resource://gre/modules/XPCOMUtils.sys.mjs"
+);
+
+ChromeUtils.defineESModuleGetters(this, {
+ TreeSelection: "chrome://messenger/content/tree-selection.mjs",
+});
+
+XPCOMUtils.defineLazyModuleGetters(this, {
+ DBViewWrapper: "resource:///modules/DBViewWrapper.jsm",
+});
+
+var gDBView;
+var nsMsgKey_None = 0xffffffff;
+var nsMsgViewIndex_None = 0xffffffff;
+
+/**
+ * Maintains a list of listeners for all FolderDisplayWidget instances in this
+ * window. The assumption is that because of our multiplexed tab
+ * implementation all consumers are effectively going to care about all such
+ * tabs.
+ *
+ * We are not just a global list so that we can add brains about efficiently
+ * building lists, provide try-wrapper convenience, etc.
+ */
+var FolderDisplayListenerManager = {
+ _listeners: [],
+
+ /**
+ * Register a listener that implements one or more of the methods defined on
+ * |IDBViewWrapperListener|. Note that a change from those interface
+ * signatures is that the first argument is always a reference to the
+ * FolderDisplayWidget generating the notification.
+ *
+ * We additionally support the following notifications:
+ * - onMakeActive. Invoked when makeActive is called on the
+ * FolderDisplayWidget. The second argument (after the folder display) is
+ * aWasInactive.
+ *
+ * - onActiveCreatedView. onCreatedView deferred to when the tab is actually
+ * made active.
+ *
+ * - onActiveMessagesLoaded. onMessagesLoaded deferred to when the
+ * tab is actually made active. Use this if the actions you need to take
+ * are based on the folder display actually being visible, such as updating
+ * some UI widget, etc. Not all messages may have been loaded, but some.
+ *
+ */
+ registerListener(aListener) {
+ this._listeners.push(aListener);
+ },
+
+ /**
+ * Unregister a previously registered event listener.
+ */
+ unregisterListener(aListener) {
+ let idx = this._listeners.indexOf(aListener);
+ if (idx >= 0) {
+ this._listeners.splice(idx, 1);
+ }
+ },
+
+ /**
+ * For use by FolderDisplayWidget to trigger listener invocation.
+ */
+ _fireListeners(aEventName, aArgs) {
+ for (let listener of this._listeners) {
+ if (aEventName in listener) {
+ try {
+ listener[aEventName].apply(listener, aArgs);
+ } catch (e) {
+ console.error(
+ aEventName + " event listener FAILED; " + e + " at: " + e.stack
+ );
+ }
+ }
+ }
+ },
+};
+
+/**
+ * Abstraction for a widget that (roughly speaking) displays the contents of
+ * folders. The widget belongs to a tab and has a lifetime as long as the tab
+ * that contains it. This class is strictly concerned with the UI aspects of
+ * this; the DBViewWrapper class handles the view details (and is exposed on
+ * the 'view' attribute.)
+ *
+ * The search window subclasses this into the SearchFolderDisplayWidget rather
+ * than us attempting to generalize everything excessively. This is because
+ * we hate the search window and don't want to clutter up this code for it.
+ * The standalone message display window also subclasses us; we do not hate it,
+ * but it's not invited to our birthday party either.
+ * For reasons of simplicity and the original order of implementation, this
+ * class does alter its behavior slightly for the benefit of the standalone
+ * message window. If no tab info is provided, we avoid touching tabmail
+ * (which is good, because it won't exist!) And now we guard against treeBox
+ * manipulations...
+ */
+function FolderDisplayWidget() {
+ // If the folder does not get handled by the DBViewWrapper, stash it here.
+ // ex: when isServer is true.
+ this._nonViewFolder = null;
+
+ this.view = new DBViewWrapper(this);
+
+ /**
+ * The XUL tree node, as retrieved by getDocumentElementById. The caller is
+ * responsible for setting this.
+ */
+ this.tree = null;
+
+ /**
+ * The nsIMsgWindow corresponding to the window that holds us. There is only
+ * one of these per tab. The caller is responsible for setting this.
+ */
+ this.msgWindow = null;
+ /**
+ * The nsIMessenger instance that corresponds to our tab/window. We do not
+ * use this ourselves, but are responsible for using it to update the
+ * global |messenger| object so that our tab maintains its own undo and
+ * navigation history. At some point we might touch it for those reasons.
+ */
+ this.messenger = null;
+ this.threadPaneCommandUpdater = this;
+
+ /**
+ * Flag to expose whether all messages are loaded or not. Set by
+ * onMessagesLoaded() when aAll is true.
+ */
+ this._allMessagesLoaded = false;
+
+ /**
+ * Save the top row displayed when we go inactive, restore when we go active,
+ * nuke it when we destroy the view.
+ */
+ this._savedFirstVisibleRow = null;
+ /** the next view index to select once the delete completes */
+ this._nextViewIndexAfterDelete = null;
+ /**
+ * Track when a mass move is in effect (we get told by hintMassMoveStarting,
+ * and hintMassMoveCompleted) so that we can avoid deletion-triggered
+ * moving to _nextViewIndexAfterDelete until the mass move completes.
+ */
+ this._massMoveActive = false;
+ /**
+ * Track when a message is being deleted so we can respond appropriately.
+ */
+ this._deleteInProgress = false;
+
+ /**
+ * Used by pushNavigation to queue a navigation request for when we enter the
+ * next folder; onMessagesLoaded(true) is the one that processes it.
+ */
+ this._pendingNavigation = null;
+
+ this._active = false;
+ /**
+ * A list of methods to call on 'this' object when we are next made active.
+ * This list is populated by calls to |_notifyWhenActive| when we are
+ * not active at the moment.
+ */
+ this._notificationsPendingActivation = [];
+
+ this._mostRecentSelectionCounts = [];
+ this._mostRecentCurrentIndices = [];
+}
+FolderDisplayWidget.prototype = {
+ /**
+ * @returns the currently displayed folder. This is just proxied from the
+ * view wrapper.
+ * @groupName Displayed
+ */
+ get displayedFolder() {
+ return this._nonViewFolder || this.view.displayedFolder;
+ },
+
+ /**
+ * @returns true if the selection should be summarized for this folder. This
+ * is based on the mail.operate_on_msgs_in_collapsed_threads pref and
+ * if we are in a newsgroup folder. XXX When bug 478167 is fixed, this
+ * should be limited to being disabled for newsgroups that are not stored
+ * offline.
+ */
+ get summarizeSelectionInFolder() {
+ return (
+ Services.prefs.getBoolPref("mail.operate_on_msgs_in_collapsed_threads") &&
+ !(this.displayedFolder instanceof Ci.nsIMsgNewsFolder)
+ );
+ },
+
+ /**
+ * @returns the nsITreeSelection object for our tree view. This exists for
+ * the benefit of message tabs that haven't been switched to yet.
+ * We provide a fake tree selection in those cases.
+ * @protected
+ */
+ get treeSelection() {
+ // If we haven't switched to this tab yet, dbView will exist but
+ // dbView.selection won't, so use the fake tree selection instead.
+ if (this.view.dbView) {
+ return this.view.dbView.selection;
+ }
+ return null;
+ },
+
+ /**
+ * Determine which pane currently has focus (one of the folder pane, thread
+ * pane, or message pane). The message pane node is the common ancestor of
+ * the single- and multi-message content windows. When changing focus to the
+ * message pane, be sure to focus the appropriate content window in addition
+ * to the messagepanebox (doing both is required in order to blur the
+ * previously-focused chrome element).
+ *
+ * @returns the focused pane
+ */
+ get focusedPane() {
+ let panes = ["threadTree", "folderTree", "messagepanebox"].map(id =>
+ document.getElementById(id)
+ );
+
+ let currentNode = top.document.activeElement;
+
+ while (currentNode) {
+ if (panes.includes(currentNode)) {
+ return currentNode;
+ }
+
+ currentNode = currentNode.parentNode;
+ }
+ return null;
+ },
+
+ /**
+ * Number of headers to tell the message database to cache when we enter a
+ * folder. This value is being propagated from legacy code which provided
+ * no explanation for its choice.
+ *
+ * We definitely want the header cache size to be larger than the number of
+ * rows that can be displayed on screen simultaneously.
+ *
+ * @private
+ */
+ PERF_HEADER_CACHE_SIZE: 100,
+
+ /**
+ * @name Selection Persistence
+ * @private
+ */
+ // @{
+
+ /**
+ * An optional object, with the following properties:
+ * - messages: This is a list where each item is an object with the following
+ * attributes sufficient to re-establish the selected items even in the
+ * face of folder renaming.
+ * - messageId: The value of the message's message-id header.
+ *
+ * That's right, we only save the message-id header value. This is arguably
+ * overkill and ambiguous in the face of duplicate messages, but it's the
+ * most persistent/reliable thing we have without gloda.
+ * Using the view index was ruled out because it is hardly stable. Using the
+ * message key alone is insufficient for cross-folder searches. Using a
+ * folder identifier and message key is insufficient for local folders in the
+ * face of compaction, let alone complexities where the folder name may
+ * change due to renaming/moving. Which means we eventually need to fall
+ * back to message-id anyways. Feel free to add in lots of complexity if
+ * you actually write unit tests for all the many possible cases.
+ * Additional justification is that selection saving/restoration should not
+ * happen all that frequently. A nice freebie is that message-id is
+ * definitely persistable.
+ *
+ * - forceSelect: Whether we are allowed to drop all filters in our quest to
+ * select messages.
+ */
+ _savedSelection: null,
+
+ /**
+ * Save the current view selection for when we the view is getting destroyed
+ * or otherwise re-ordered in such a way that the nsITreeSelection will lose
+ * track of things (because it just has a naive view-index 'view' of the
+ * world.) We just save each message's message-id header. This is overkill
+ * and ambiguous in the face of duplicate messages (and expensive to
+ * restore), but is also the most reliable option for this use case.
+ */
+ _saveSelection() {
+ this._savedSelection = {
+ messages: this.selectedMessages.map(msgHdr => ({
+ messageId: msgHdr.messageId,
+ })),
+ forceSelect: false,
+ };
+ },
+
+ /**
+ * Clear the saved selection.
+ */
+ _clearSavedSelection() {
+ this._savedSelection = null;
+ },
+
+ /**
+ * Restore the view selection if we have a saved selection. We must be
+ * active!
+ *
+ * @returns true if we were able to restore the selection and there was
+ * a selection, false if there was no selection (anymore).
+ */
+ _restoreSelection() {
+ if (!this._savedSelection || !this._active) {
+ return false;
+ }
+
+ // translate message IDs back to messages. this is O(s(m+n)) where:
+ // - s is the number of messages saved in the selection
+ // - m is the number of messages in the view (from findIndexOfMsgHdr)
+ // - n is the number of messages in the underlying folders (from
+ // DBViewWrapper.getMsgHdrForMessageID).
+ // which ends up being O(sn)
+ let messages = this._savedSelection.messages
+ .map(savedInfo => this.view.getMsgHdrForMessageID(savedInfo.messageId))
+ .filter(msgHdr => !!msgHdr);
+
+ this.selectMessages(messages, this._savedSelection.forceSelect, true);
+ this._savedSelection = null;
+
+ return this.selectedCount != 0;
+ },
+
+ /**
+ * Restore the last expandAll/collapseAll state, for both grouped and threaded
+ * views. Not all views respect viewFlags, ie single folder non-virtual.
+ */
+ restoreThreadState() {
+ if (!this._active || !this.tree || !this.view.dbView.viewFolder) {
+ return;
+ }
+
+ if (
+ this.view._threadExpandAll &&
+ !(this.view.dbView.viewFlags & Ci.nsMsgViewFlagsType.kExpandAll)
+ ) {
+ this.view.dbView.doCommand(Ci.nsMsgViewCommandType.expandAll);
+ }
+ if (
+ !this.view._threadExpandAll &&
+ this.view.dbView.viewFlags & Ci.nsMsgViewFlagsType.kExpandAll
+ ) {
+ this.view.dbView.doCommand(Ci.nsMsgViewCommandType.collapseAll);
+ }
+ },
+ // @}
+
+ /**
+ * @name Columns
+ * @protected
+ */
+ // @{
+
+ /**
+ * The map of all stock sortable columns and their sortType. The key must
+ * match the column's xul <treecol> id.
+ */
+ COLUMNS_MAP: new Map([
+ ["accountCol", "byAccount"],
+ ["attachmentCol", "byAttachments"],
+ ["senderCol", "byAuthor"],
+ ["correspondentCol", "byCorrespondent"],
+ ["dateCol", "byDate"],
+ ["flaggedCol", "byFlagged"],
+ ["idCol", "byId"],
+ ["junkStatusCol", "byJunkStatus"],
+ ["locationCol", "byLocation"],
+ ["priorityCol", "byPriority"],
+ ["receivedCol", "byReceived"],
+ ["recipientCol", "byRecipient"],
+ ["sizeCol", "bySize"],
+ ["statusCol", "byStatus"],
+ ["subjectCol", "bySubject"],
+ ["tagsCol", "byTags"],
+ ["threadCol", "byThread"],
+ ["unreadButtonColHeader", "byUnread"],
+ ]),
+
+ /**
+ * The map of stock non-sortable columns. The key must match the column's
+ * xul <treecol> id.
+ */
+ COLUMNS_MAP_NOSORT: new Set([
+ "selectCol",
+ "totalCol",
+ "unreadCol",
+ "deleteCol",
+ ]),
+
+ /**
+ * The set of potential default columns in their default display order. Each
+ * column in this list is checked against |COLUMN_DEFAULT_TESTERS| to see if
+ * it is actually an appropriate default for the folder type.
+ */
+ DEFAULT_COLUMNS: [
+ "threadCol",
+ "attachmentCol",
+ "flaggedCol",
+ "subjectCol",
+ "unreadButtonColHeader",
+ "senderCol", // news folders or incoming folders when correspondents not in use
+ "recipientCol", // outgoing folders when correspondents not in use
+ "correspondentCol", // mail folders
+ "junkStatusCol",
+ "dateCol",
+ "locationCol", // multiple-folder backed folders
+ ],
+
+ /**
+ * Maps column ids to functions that test whether the column is a good default
+ * for display for the folder. Each function should expect a DBViewWrapper
+ * instance as its argument. The intent is that the various helper
+ * properties like isMailFolder/isIncomingFolder/isOutgoingFolder allow the
+ * constraint to be expressed concisely. If a helper does not exist, add
+ * one! (If doing so is out of reach, than access viewWrapper.displayedFolder
+ * to get at the nsIMsgFolder.)
+ * If a column does not have a function, it is assumed that it should be
+ * displayed by default.
+ */
+ COLUMN_DEFAULT_TESTERS: {
+ correspondentCol(viewWrapper) {
+ if (Services.prefs.getBoolPref("mail.threadpane.use_correspondents")) {
+ // Don't show the correspondent for news or RSS where it doesn't make sense.
+ return viewWrapper.isMailFolder && !viewWrapper.isFeedFolder;
+ }
+ return false;
+ },
+ senderCol(viewWrapper) {
+ if (Services.prefs.getBoolPref("mail.threadpane.use_correspondents")) {
+ // Show the sender even if correspondent is enabled for news and feeds.
+ return viewWrapper.isNewsFolder || viewWrapper.isFeedFolder;
+ }
+ // senderCol = From. You only care in incoming folders.
+ return viewWrapper.isIncomingFolder;
+ },
+ recipientCol(viewWrapper) {
+ if (Services.prefs.getBoolPref("mail.threadpane.use_correspondents")) {
+ // No recipient column if we use correspondent.
+ return false;
+ }
+ // recipientCol = To. You only care in outgoing folders.
+ return viewWrapper.isOutgoingFolder;
+ },
+ // Only show the location column for non-single-folder results
+ locationCol(viewWrapper) {
+ return !viewWrapper.isSingleFolder;
+ },
+ // core UI does not provide an ability to mark newsgroup messages as spam
+ junkStatusCol(viewWrapper) {
+ return !viewWrapper.isNewsFolder;
+ },
+ },
+
+ /**
+ * The property name we use to store the column states on the
+ * dbFolderInfo.
+ */
+ PERSISTED_COLUMN_PROPERTY_NAME: "columnStates",
+
+ /**
+ * Given a dbFolderInfo, extract the persisted state from it if there is any.
+ *
+ * @returns null if there was no persisted state, the persisted state in object
+ * form otherwise. (Ideally the state conforms to the documentation on
+ * |_savedColumnStates| but we can't stop people from doing bad things.)
+ */
+ _depersistColumnStatesFromDbFolderInfo(aDbFolderInfo) {
+ let columnJsonString = aDbFolderInfo.getCharProperty(
+ this.PERSISTED_COLUMN_PROPERTY_NAME
+ );
+ if (!columnJsonString) {
+ return null;
+ }
+
+ return JSON.parse(columnJsonString);
+ },
+
+ /**
+ * Persist the column state for the currently displayed folder. We are
+ * assuming that the message database is already open when we are called and
+ * therefore that we do not need to worry about cleaning up after the message
+ * database.
+ * The caller should only call this when they have reason to suspect that the
+ * column state has been changed. This could be because there was no
+ * persisted state so we figured out a default one and want to save it.
+ * Otherwise this should be because the user explicitly changed up the column
+ * configurations. You should not call this willy-nilly.
+ *
+ * @param aState State to persist.
+ */
+ _persistColumnStates(aState) {
+ if (this.view.isSynthetic) {
+ let syntheticView = this.view._syntheticView;
+ if ("setPersistedSetting" in syntheticView) {
+ syntheticView.setPersistedSetting("columns", aState);
+ }
+ return;
+ }
+
+ if (!this.view.displayedFolder || !this.view.displayedFolder.msgDatabase) {
+ return;
+ }
+
+ let msgDatabase = this.view.displayedFolder.msgDatabase;
+ let dbFolderInfo = msgDatabase.dBFolderInfo;
+ dbFolderInfo.setCharProperty(
+ this.PERSISTED_COLUMN_PROPERTY_NAME,
+ JSON.stringify(aState)
+ );
+ msgDatabase.commit(Ci.nsMsgDBCommitType.kLargeCommit);
+ },
+
+ /**
+ * Let us know that the state of the columns has changed. This is either due
+ * to a re-ordering or hidden-ness being toggled.
+ *
+ * This method should only be called on (the active) gFolderDisplay.
+ */
+ hintColumnsChanged() {
+ // ignore this if we are the ones doing things
+ if (this._touchingColumns) {
+ return;
+ }
+ this._persistColumnStates(this.getColumnStates());
+ },
+
+ /**
+ * Either inherit the column state of another folder or use heuristics to
+ * figure out the best column state for the current folder.
+ */
+ _getDefaultColumnsForCurrentFolder(aDoNotInherit) {
+ // If the view is synthetic, try asking it for its default columns. If it
+ // fails, just return nothing, since most synthetic views don't care about
+ // columns anyway.
+ if (this.view.isSynthetic) {
+ if ("getDefaultSetting" in this.view._syntheticView) {
+ return this.view._syntheticView.getDefaultSetting("columns");
+ }
+ return {};
+ }
+
+ // do not inherit from the inbox if:
+ // - It's an outgoing folder; these have a different use-case and there
+ // should be a small number of these, so it's okay to have no defaults.
+ // - It's a virtual folder (single or multi-folder backed). Who knows what
+ // the intent of the user is in this case. This should also be bounded
+ // in number and our default heuristics should be pretty good.
+ // - It's a multiple folder; this is either a search view (which has no
+ // displayed folder) or a virtual folder (which we eliminated above).
+ // - News folders. There is no inbox so there's nothing to inherit from.
+ // (Although we could try and see if they have opened any other news
+ // folders in the same account. But it's not all that important to us.)
+ // - It's an inbox!
+ let doNotInherit =
+ aDoNotInherit ||
+ this.view.isOutgoingFolder ||
+ this.view.isVirtual ||
+ this.view.isMultiFolder ||
+ this.view.isNewsFolder ||
+ this.displayedFolder.getFlag(Ci.nsMsgFolderFlags.Inbox);
+
+ // Try and grab the inbox for this account's settings. we may not be able
+ // to, in which case we just won't inherit. (It ends up the same since the
+ // inbox is obviously not customized in this case.)
+ if (!doNotInherit) {
+ let inboxFolder = this.displayedFolder.rootFolder.getFolderWithFlags(
+ Ci.nsMsgFolderFlags.Inbox
+ );
+ if (inboxFolder) {
+ let state = this._depersistColumnStatesFromDbFolderInfo(
+ inboxFolder.msgDatabase.dBFolderInfo
+ );
+ // inbox message databases don't get closed as a matter of policy.
+
+ if (state) {
+ return state;
+ }
+ }
+ }
+
+ // if we are still here, use the defaults and helper functions
+ let state = {};
+ for (let colId of this.DEFAULT_COLUMNS) {
+ let shouldShowColumn = true;
+ if (colId in this.COLUMN_DEFAULT_TESTERS) {
+ // This is potentially going to be used by extensions; avoid them
+ // killing us.
+ try {
+ shouldShowColumn = this.COLUMN_DEFAULT_TESTERS[colId](this.view);
+ } catch (ex) {
+ shouldShowColumn = false;
+ console.error(ex);
+ }
+ }
+ state[colId] = { visible: shouldShowColumn };
+ }
+ return state;
+ },
+
+ /**
+ * Is setColumnStates messing with the columns' DOM? This is used by
+ * hintColumnsChanged to avoid wasteful state persistence.
+ */
+ _touchingColumns: false,
+
+ /**
+ * Set the column states of this FolderDisplay to the provided state.
+ *
+ * @param aColumnStates an object of the form described on
+ * |_savedColumnStates|. If ordinal attributes are omitted then no
+ * re-ordering will be performed. This is intentional, but potentially a
+ * bad idea. (Right now only gloda search underspecifies ordinals.)
+ * @param [aPersistChanges=false] Should we persist the changes to the view?
+ * This only has an effect if we are active.
+ *
+ * @public
+ */
+ setColumnStates(aColumnStates, aPersistChanges) {
+ // If we are not active, just overwrite our current state with the provided
+ // state and bail.
+ if (!this._active) {
+ this._savedColumnStates = aColumnStates;
+ return;
+ }
+
+ this._touchingColumns = true;
+
+ try {
+ let cols = document.getElementById("threadCols");
+ let colChildren = cols.children;
+
+ for (let iKid = 0; iKid < colChildren.length; iKid++) {
+ let colChild = colChildren[iKid];
+ if (colChild == null) {
+ continue;
+ }
+
+ // We only care about treecols. The splitters do not need to be marked
+ // hidden or un-hidden.
+ if (colChild.tagName == "treecol") {
+ // if it doesn't have preserved state it should be hidden
+ let shouldBeHidden = true;
+ // restore state
+ if (colChild.id in aColumnStates) {
+ let colState = aColumnStates[colChild.id];
+ if ("visible" in colState) {
+ shouldBeHidden = !colState.visible;
+ }
+ if ("ordinal" in colState && colChild.ordinal != colState.ordinal) {
+ colChild.ordinal = colState.ordinal;
+ }
+ }
+ let isHidden = colChild.hidden;
+ if (isHidden != shouldBeHidden) {
+ if (shouldBeHidden) {
+ colChild.setAttribute("hidden", "true");
+ } else {
+ colChild.removeAttribute("hidden");
+ }
+ }
+ }
+ }
+ } finally {
+ this._touchingColumns = false;
+ }
+
+ if (aPersistChanges) {
+ this.hintColumnsChanged();
+ }
+ },
+
+ /**
+ * A dictionary that maps column ids to dictionaries where each dictionary
+ * has the following fields:
+ * - visible: Is the column visible.
+ * - ordinal: The 1-based XUL 'ordinal' value assigned to the column. This
+ * corresponds to the position but is not something you want to manipulate.
+ * See the documentation in _saveColumnStates for more information.
+ */
+ _savedColumnStates: null,
+
+ /**
+ * Return a dictionary in the form of |_savedColumnStates| representing the
+ * current column states.
+ *
+ * @public
+ */
+ getColumnStates() {
+ if (!this._active) {
+ return this._savedColumnStates;
+ }
+
+ let columnStates = {};
+
+ let cols = document.getElementById("threadCols");
+ let colChildren = cols.children;
+ for (let iKid = 0; iKid < colChildren.length; iKid++) {
+ let colChild = colChildren[iKid];
+ if (colChild.tagName != "treecol") {
+ continue;
+ }
+ columnStates[colChild.id] = {
+ visible: !colChild.hidden,
+ ordinal: colChild.ordinal,
+ };
+ }
+
+ return columnStates;
+ },
+
+ /**
+ * For now, just save the visible columns into a dictionary for use in a
+ * subsequent call to |setColumnStates|.
+ */
+ _saveColumnStates() {
+ // In the actual TreeColumn, the index property indicates the column
+ // number. This column number is a 0-based index with no gaps; it only
+ // increments the number each time it sees a column.
+ // However, this is subservient to the 'ordinal' property which
+ // defines the _apparent content sequence_ provided by GetNextSibling.
+ // The underlying content ordering is still the same, which is how
+ // _ensureColumnOrder() can reset things to their XUL definition sequence.
+ // The 'ordinal' stuff works because nsBoxFrame::RelayoutChildAtOrdinal
+ // messes with the sibling relationship.
+ // Ordinals are 1-based. _ensureColumnOrder() apparently is dumb and does
+ // not know this, although the ordering is relative so it doesn't actually
+ // matter. The annoying splitters do have ordinals, and live between
+ // tree columns. The splitters adjacent to a tree column do not need to
+ // have any 'ordinal' relationship, although it would appear user activity
+ // tends to move them around in a predictable fashion with oddness involved
+ // at the edges.
+ // Changes to the ordinal attribute should take immediate effect in terms of
+ // sibling relationship, but will merely invalidate the columns rather than
+ // cause a re-computation of column relationships every time.
+ // _ensureColumnOrder() invalidates the tree when it is done re-ordering;
+ // I'm not sure that's entirely necessary...
+ this._savedColumnStates = this.getColumnStates();
+ },
+
+ /**
+ * Restores the visible columns saved by |_saveColumnStates|.
+ */
+ _restoreColumnStates() {
+ if (this._savedColumnStates) {
+ this.setColumnStates(this._savedColumnStates);
+ this._savedColumnStates = null;
+ }
+ },
+ // @}
+
+ /**
+ * @name What To Display
+ * @protected
+ */
+ // @{
+ showFolderUri(aFolderURI) {
+ return this.show(MailUtils.getExistingFolder(aFolderURI));
+ },
+
+ /**
+ * Invoked by showFolder when it turns out the folder is in fact a server.
+ *
+ * @private
+ */
+ _showServer() {
+ // currently nothing to do. makeActive handles everything for us (because
+ // what is displayed needs to be re-asserted each time we are activated
+ // too.)
+ },
+
+ /**
+ * Select a folder for display.
+ *
+ * @param aFolder The nsIMsgDBFolder to display.
+ */
+ show(aFolder) {
+ if (aFolder == null) {
+ this._nonViewFolder = null;
+ this.view.close();
+ } else if (aFolder instanceof Ci.nsIMsgFolder) {
+ if (aFolder.isServer) {
+ this._nonViewFolder = aFolder;
+ this._showServer();
+ this.view.close();
+ // A server is fully loaded immediately, for now. (When we have the
+ // account summary, we might want to change this to wait for the page
+ // load to complete.)
+ this._allMessagesLoaded = true;
+ } else {
+ this._nonViewFolder = null;
+ this.view.open(aFolder);
+ }
+ } else {
+ // it must be a synthetic view
+ this.view.openSynthetic(aFolder);
+ }
+ if (this._active) {
+ this.makeActive();
+ }
+ },
+
+ /**
+ * Clone an existing view wrapper as the basis for our display.
+ */
+ cloneView(aViewWrapper) {
+ this.view = aViewWrapper.clone(this);
+ // generate a view created notification; this will cause us to do the right
+ // thing in terms of associating the view with the tree and such.
+ this.onCreatedView();
+ if (this._active) {
+ this.makeActive();
+ }
+ },
+
+ /**
+ * Close resources associated with the currently displayed folder because you
+ * no longer care about this FolderDisplayWidget.
+ */
+ close() {
+ // Mark ourselves as inactive without doing any of the hard work of becoming
+ // inactive. This saves us from trying to update things as they go away.
+ this._active = false;
+
+ this.view.close();
+ this.messenger.setWindow(null, null);
+ this.messenger = null;
+ },
+ // @}
+
+ /* =============================== */
+ /* ===== IDBViewWrapper Listener ===== */
+ /* =============================== */
+
+ /**
+ * @name IDBViewWrapperListener Interface
+ * @private
+ */
+ // @{
+
+ /**
+ * @returns true if the mail view picker is visible. This affects whether the
+ * DBViewWrapper will actually use the persisted mail view or not.
+ */
+ get shouldUseMailViews() {
+ return ViewPickerBinding.isVisible;
+ },
+
+ /**
+ * Let the viewWrapper know if we should defer message display because we
+ * want the user to connect to the server first so password authentication
+ * can occur.
+ *
+ * @returns true if the folder should be shown immediately, false if we should
+ * wait for updateFolder to complete.
+ */
+ get shouldDeferMessageDisplayUntilAfterServerConnect() {
+ let passwordPromptRequired = false;
+
+ if (Services.prefs.getBoolPref("mail.password_protect_local_cache")) {
+ passwordPromptRequired =
+ this.view.displayedFolder.server.passwordPromptRequired;
+ }
+
+ return passwordPromptRequired;
+ },
+
+ /**
+ * Let the viewWrapper know if it should mark the messages read when leaving
+ * the provided folder.
+ *
+ * @returns true if the preference is set for the folder's server type.
+ */
+ shouldMarkMessagesReadOnLeavingFolder(aMsgFolder) {
+ return Services.prefs.getBoolPref(
+ "mailnews.mark_message_read." + aMsgFolder.server.type
+ );
+ },
+
+ /**
+ * The view wrapper tells us when it starts loading a folder, and we set the
+ * cursor busy. Setting the cursor busy on a per-tab basis is us being
+ * nice to the future. Loading a folder is a blocking operation that is going
+ * to make us unresponsive and accordingly make it very hard for the user to
+ * change tabs.
+ */
+ onFolderLoading(aFolderLoading) {
+ FolderDisplayListenerManager._fireListeners("onFolderLoading", [
+ this,
+ aFolderLoading,
+ ]);
+ },
+
+ /**
+ * The view wrapper tells us when a search is active, and we mark the tab as
+ * thinking so the user knows something is happening. 'Searching' in this
+ * case is more than just a user-initiated search. Virtual folders / saved
+ * searches, mail views, plus the more obvious quick search are all based off
+ * of searches and we will receive a notification for them.
+ */
+ onSearching(aIsSearching) {
+ FolderDisplayListenerManager._fireListeners("onSearching", [
+ this,
+ aIsSearching,
+ ]);
+ },
+
+ /**
+ * Things we do on creating a view:
+ * - notify the observer service so that custom column handler providers can
+ * add their custom columns to our view.
+ */
+ onCreatedView() {
+ // All of our messages are not displayed if the view was just created. We
+ // will get an onMessagesLoaded(true) nearly immediately if this is a local
+ // folder where view creation is synonymous with having all messages.
+ this._allMessagesLoaded = false;
+
+ FolderDisplayListenerManager._fireListeners("onCreatedView", [this]);
+
+ this._notifyWhenActive(this._activeCreatedView);
+ },
+ _activeCreatedView() {
+ gDBView = this.view.dbView; // eslint-disable-line no-global-assign
+
+ // A change in view may result in changes to sorts, the view menu, etc.
+ // Do this before we 'reroot' the dbview.
+ this._updateThreadDisplay();
+
+ // this creates a new selection object for the view.
+ if (this.tree) {
+ this.tree.view = this.view.dbView;
+ }
+
+ FolderDisplayListenerManager._fireListeners("onActiveCreatedView", [this]);
+
+ // The data payload used to be viewType + ":" + viewFlags. We no longer
+ // do this because we already have the implied contract that gDBView is
+ // valid at the time we generate the notification. In such a case, you
+ // can easily get that information from the gDBView. (The documentation
+ // on creating a custom column assumes gDBView.)
+ Services.obs.notifyObservers(this.displayedFolder, "MsgCreateDBView");
+ },
+
+ /**
+ * If our view is being destroyed and it is coming back, we want to save the
+ * current selection so we can restore it when the view comes back.
+ */
+ onDestroyingView(aFolderIsComingBack) {
+ // try and persist the selection's content if we can
+ if (this._active) {
+ // If saving the selection throws an exception, we still want continue
+ // destroying the view. Saving the selection can fail if an underlying
+ // local folder has been compacted, invalidating the message keys.
+ // See bug 536676 for more info.
+ try {
+ // If a new selection is coming up, there's no point in trying to
+ // persist any selections.
+ if (aFolderIsComingBack && !this._aboutToSelectMessage) {
+ this._saveSelection();
+ } else {
+ this._clearSavedSelection();
+ }
+ } catch (ex) {
+ console.error(ex);
+ }
+ gDBView = null; // eslint-disable-line no-global-assign
+ }
+
+ FolderDisplayListenerManager._fireListeners("onDestroyingView", [
+ this,
+ aFolderIsComingBack,
+ ]);
+
+ // if we have no view, no messages could be loaded.
+ this._allMessagesLoaded = false;
+
+ // but the actual tree view selection (based on view indices) is a goner no
+ // matter what, make everyone forget.
+ this.view.dbView.selection = null;
+ this._savedFirstVisibleRow = null;
+ this._nextViewIndexAfterDelete = null;
+ // although the move may still be active, its relation to the view is moot.
+ this._massMoveActive = false;
+
+ // Anything pending needs to get cleared out; the new view and its related
+ // events will re-schedule anything required or simply run it when it
+ // has its initial call to makeActive compelled.
+ this._notificationsPendingActivation = [];
+ },
+
+ /**
+ * Restore persisted information about what columns to display for the folder.
+ * If we have no persisted information, we leave/set _savedColumnStates null.
+ * The column states will be set to default values in onDisplayingFolder in
+ * that case.
+ */
+ onLoadingFolder(aDbFolderInfo) {
+ this._savedColumnStates =
+ this._depersistColumnStatesFromDbFolderInfo(aDbFolderInfo);
+
+ FolderDisplayListenerManager._fireListeners("onLoadingFolder", [
+ this,
+ aDbFolderInfo,
+ ]);
+ },
+
+ /**
+ * We are entering the folder for display:
+ * - set the header cache size.
+ * - Setup the columns if we did not already depersist in |onLoadingFolder|.
+ */
+ onDisplayingFolder() {
+ let displayedFolder = this.view.displayedFolder;
+ let msgDatabase = displayedFolder && displayedFolder.msgDatabase;
+ if (msgDatabase) {
+ msgDatabase.resetHdrCacheSize(this.PERF_HEADER_CACHE_SIZE);
+ }
+
+ // makeActive will restore the folder state
+ if (!this._savedColumnStates) {
+ if (
+ this.view.isSynthetic &&
+ "getPersistedSetting" in this.view._syntheticView
+ ) {
+ let columns = this.view._syntheticView.getPersistedSetting("columns");
+ this._savedColumnStates = columns;
+ } else {
+ // get the default for this folder
+ this._savedColumnStates = this._getDefaultColumnsForCurrentFolder();
+ // and save it so it doesn't wiggle if the inbox/prototype changes
+ this._persistColumnStates(this._savedColumnStates);
+ }
+ }
+
+ FolderDisplayListenerManager._fireListeners("onDisplayingFolder", [this]);
+
+ if (this.active) {
+ this.makeActive();
+ }
+ },
+
+ /**
+ * Notification from DBViewWrapper that it is closing the folder. This can
+ * happen for reasons other than our own 'close' method closing the view.
+ * For example, user deletion of the folder or underlying folder closes it.
+ */
+ onLeavingFolder() {
+ FolderDisplayListenerManager._fireListeners("onLeavingFolder", [this]);
+
+ // Keep the msgWindow's openFolder up-to-date; it powers nsMessenger's
+ // concept of history so that it can bring you back to the actual folder
+ // you were looking at, rather than just the underlying folder.
+ if (this._active) {
+ msgWindow.openFolder = null;
+ }
+ },
+
+ /**
+ * Indicates whether we are done loading the messages that should be in this
+ * folder. This is being surfaced for testing purposes, but could be useful
+ * to other code as well. But don't poll this property; ask for an event
+ * that you can hook.
+ */
+ get allMessagesLoaded() {
+ return this._allMessagesLoaded;
+ },
+
+ /**
+ * Things to do once some or all the messages that should show up in a folder
+ * have shown up. For a real folder, this happens when the folder is
+ * entered. For a virtual folder, this happens when the search completes.
+ *
+ * What we do:
+ * - Any scrolling required!
+ */
+ onMessagesLoaded(aAll) {
+ this._allMessagesLoaded = aAll;
+
+ FolderDisplayListenerManager._fireListeners("onMessagesLoaded", [
+ this,
+ aAll,
+ ]);
+
+ this._notifyWhenActive(this._activeMessagesLoaded);
+ },
+ _activeMessagesLoaded() {
+ FolderDisplayListenerManager._fireListeners("onActiveMessagesLoaded", [
+ this,
+ ]);
+
+ // - if a selectMessage's coming up, get out of here
+ if (this._aboutToSelectMessage) {
+ return;
+ }
+
+ // - restore user's last expand/collapse choice.
+ this.restoreThreadState();
+
+ // - restore selection
+ // Attempt to restore the selection (if we saved it because the view was
+ // being destroyed or otherwise manipulated in a fashion that the normal
+ // nsTreeSelection would be unable to handle.)
+ if (this._restoreSelection()) {
+ this.ensureRowIsVisible(this.view.dbView.viewIndexForFirstSelectedMsg);
+ return;
+ }
+
+ // - pending navigation from pushNavigation (probably spacebar triggered)
+ // Need to have all messages loaded first.
+ if (this._pendingNavigation) {
+ // Move it to a local and clear the state in case something bad happens.
+ // (We don't want to swallow the exception.)
+ let pendingNavigation = this._pendingNavigation;
+ this._pendingNavigation = null;
+ this.navigate.apply(this, pendingNavigation);
+ return;
+ }
+
+ // - if something's already selected (e.g. in a message tab), scroll to the
+ // first selected message and get out
+ if (this.view.dbView.numSelected > 0) {
+ this.ensureRowIsVisible(this.view.dbView.viewIndexForFirstSelectedMsg);
+ return;
+ }
+
+ // - new messages
+ // if configured to scroll to new messages, try that
+ if (
+ Services.prefs.getBoolPref("mailnews.scroll_to_new_message") &&
+ this.navigate(Ci.nsMsgNavigationType.firstNew, /* select */ false)
+ ) {
+ return;
+ }
+
+ // - last selected message
+ // if configured to load the last selected message (this is currently more
+ // persistent than our saveSelection/restoreSelection stuff), and the view
+ // is backed by a single underlying folder (the only way having just a
+ // message key works out), try that
+ if (
+ Services.prefs.getBoolPref("mailnews.remember_selected_message") &&
+ this.view.isSingleFolder &&
+ this.view.displayedFolder
+ ) {
+ // use the displayed folder; nsMsgDBView goes to the effort to save the
+ // state to the viewFolder, so this is the correct course of action.
+ let lastLoadedMessageKey = this.view.displayedFolder.lastMessageLoaded;
+ if (lastLoadedMessageKey != nsMsgKey_None) {
+ this.view.dbView.selectMsgByKey(lastLoadedMessageKey);
+ // The message key may not be present in the view for a variety of
+ // reasons. Beyond message deletion, it simply may not match the
+ // active mail view or quick search, for example.
+ if (this.view.dbView.numSelected > 0) {
+ this.ensureRowIsVisible(
+ this.view.dbView.viewIndexForFirstSelectedMsg
+ );
+ return;
+ }
+ }
+ }
+
+ // - towards the newest messages, but don't select
+ if (
+ this.view.isSortedAscending &&
+ this.view.sortImpliesTemporalOrdering &&
+ this.navigate(Ci.nsMsgNavigationType.lastMessage, /* select */ false)
+ ) {
+ return;
+ }
+
+ // - to the top, the coliseum
+ this.ensureRowIsVisible(0);
+ },
+
+ /**
+ * The DBViewWrapper tells us when someone (possibly the wrapper itself)
+ * changes the active mail view so that we can kick the UI to update.
+ */
+ onMailViewChanged() {
+ // only do this if we're currently active. no need to queue it because we
+ // always update the mail view whenever we are made active.
+ if (this.active) {
+ // you cannot cancel a view change!
+ window.dispatchEvent(
+ new Event("MailViewChanged", { bubbles: false, cancelable: false })
+ );
+ }
+ },
+
+ /**
+ * Just the sort or threading was changed, without changing other things. We
+ * will not get this notification if the view was re-created, for example.
+ */
+ onSortChanged() {
+ if (this.active) {
+ UpdateSortIndicators(
+ this.view.primarySortType,
+ this.view.primarySortOrder
+ );
+ }
+
+ FolderDisplayListenerManager._fireListeners("onSortChanged", [this]);
+ },
+
+ /**
+ * Messages (that may have been displayed) have been removed; this may impact
+ * our message selection. We might know it's coming; if we do then
+ * this._nextViewIndexAfterDelete should know what view index to select next.
+ * For the imap mark-as-deleted we won't know beforehand.
+ */
+ onMessagesRemoved() {
+ FolderDisplayListenerManager._fireListeners("onMessagesRemoved", [this]);
+
+ this._deleteInProgress = false;
+
+ // - we saw this coming
+ let rowCount = this.view.dbView.rowCount;
+ if (!this._massMoveActive && this._nextViewIndexAfterDelete != null) {
+ // adjust the index if it is after the last row...
+ // (this can happen if the "mail.delete_matches_sort_order" pref is not
+ // set and the message is the last message in the view.)
+ if (this._nextViewIndexAfterDelete >= rowCount) {
+ this._nextViewIndexAfterDelete = rowCount - 1;
+ }
+ // just select the index and get on with our lives
+ this.selectViewIndex(this._nextViewIndexAfterDelete);
+ this._nextViewIndexAfterDelete = null;
+ return;
+ }
+
+ // - we didn't see it coming
+
+ // A deletion happened to our folder.
+ let treeSelection = this.treeSelection;
+ // we can't fix the selection if we have no selection
+ if (!treeSelection) {
+ return;
+ }
+
+ // For reasons unknown (but theoretically knowable), sometimes the selection
+ // object will be invalid. At least, I've reliably seen a selection of
+ // [0, 0] with 0 rows. If that happens, we need to fix up the selection
+ // here.
+ if (rowCount == 0 && treeSelection.count) {
+ // nsTreeSelection doesn't generate an event if we use clearRange, so use
+ // that to avoid spurious events, given that we are going to definitely
+ // trigger a change notification below.
+ treeSelection.clearRange(0, 0);
+ }
+
+ // Check if we now no longer have a selection, but we had exactly one
+ // message selected previously. If we did, then try and do some
+ // 'persistence of having a thing selected'.
+ if (
+ treeSelection.count == 0 &&
+ this._mostRecentSelectionCounts.length > 1 &&
+ this._mostRecentSelectionCounts[1] == 1 &&
+ this._mostRecentCurrentIndices[1] != -1
+ ) {
+ let targetIndex = this._mostRecentCurrentIndices[1];
+ if (targetIndex >= rowCount) {
+ targetIndex = rowCount - 1;
+ }
+ this.selectViewIndex(targetIndex);
+ return;
+ }
+
+ // Otherwise, just tell the view that things have changed so it can update
+ // itself to the new state of things.
+ // tell the view that things have changed so it can update itself suitably.
+ if (this.view.dbView) {
+ this.view.dbView.selectionChanged();
+ }
+ },
+
+ /**
+ * Messages were not actually removed, but we were expecting that they would
+ * be. Clean-up what onMessagesRemoved would have cleaned up, namely the
+ * next view index to select.
+ */
+ onMessageRemovalFailed() {
+ this._nextViewIndexAfterDelete = null;
+ FolderDisplayListenerManager._fireListeners("onMessagesRemovalFailed", [
+ this,
+ ]);
+ },
+
+ /**
+ * Update the status bar to reflect our exciting message counts.
+ */
+ onMessageCountsChanged() {},
+ // @}
+ /* ===== End IDBViewWrapperListener ===== */
+
+ /* ================================== */
+ /* ===== nsIMsgDBViewCommandUpdater ===== */
+ /* ================================== */
+
+ /**
+ * @name nsIMsgDBViewCommandUpdater Interface
+ * @private
+ */
+ // @{
+
+ /**
+ * This gets called when the selection changes AND !suppressCommandUpdating
+ * AND (we're not removing a row OR we are now out of rows).
+ * In response, we update the toolbar.
+ */
+ updateCommandStatus() {},
+
+ /**
+ * This gets called by nsMsgDBView::UpdateDisplayMessage following a call
+ * to nsIMessenger.OpenURL to kick off message display OR (UDM gets called)
+ * by nsMsgDBView::SelectionChanged in lieu of loading the message because
+ * mSupressMsgDisplay.
+ * In other words, we get notified immediately after the process of displaying
+ * a message triggered by the nsMsgDBView happens. We get some arguments
+ * that are display optimizations for historical reasons (as usual).
+ *
+ * Things this makes us want to do:
+ * - Set the tab title, perhaps. (If we are a message display.)
+ * - Update message counts, because things might have changed, why not.
+ * - Update some toolbar buttons, why not.
+ *
+ * @param aFolder The display/view folder, as opposed to the backing folder.
+ * @param aSubject The subject with "Re: " if it's got one, which makes it
+ * notably different from just directly accessing the message header's
+ * subject.
+ * @param aKeywords The keywords, which roughly translates to message tags.
+ */
+ displayMessageChanged(aFolder, aSubject, aKeywords) {},
+
+ /**
+ * This gets called as a hint that the currently selected message is junk and
+ * said junked message is going to be moved out of the current folder, or
+ * right before a header is removed from the db view. The legacy behaviour
+ * is to retrieve the msgToSelectAfterDelete attribute off the db view,
+ * stashing it for benefit of the code that gets called when a message
+ * move/deletion is completed so that we can trigger its display.
+ */
+ updateNextMessageAfterDelete() {
+ this.hintAboutToDeleteMessages();
+ },
+
+ /**
+ * The most recent currentIndexes on the selection (from the last time
+ * summarizeSelection got called). We use this in onMessagesRemoved if
+ * we get an unexpected notification.
+ * We keep a maximum of 2 entries in this list.
+ */
+ _mostRecentCurrentIndices: undefined, // initialized in constructor
+ /**
+ * The most recent counts on the selection (from the last time
+ * summarizeSelection got called). We use this in onMessagesRemoved if
+ * we get an unexpected notification.
+ * We keep a maximum of 2 entries in this list.
+ */
+ _mostRecentSelectionCounts: undefined, // initialized in constructor
+
+ /**
+ * Always called by the db view when the selection changes in
+ * SelectionChanged. This event will come after the notification to
+ * displayMessageChanged (if one happens), and before the notification to
+ * updateCommandStatus (if one happens).
+ */
+ summarizeSelection() {
+ // save the current index off in case the selection gets deleted out from
+ // under us and we want to have persistence of actually-having-something
+ // selected.
+ let treeSelection = this.treeSelection;
+ if (treeSelection) {
+ this._mostRecentCurrentIndices.unshift(treeSelection.currentIndex);
+ this._mostRecentCurrentIndices.splice(2);
+ this._mostRecentSelectionCounts.unshift(treeSelection.count);
+ this._mostRecentSelectionCounts.splice(2);
+ }
+ },
+ // @}
+ /* ===== End nsIMsgDBViewCommandUpdater ===== */
+
+ /* ===== Hints from the command infrastructure ===== */
+ /**
+ * @name Command Infrastructure Hints
+ * @protected
+ */
+ // @{
+
+ /**
+ * doCommand helps us out by telling us when it is telling the view to delete
+ * some messages. Ideally it should go through us / the DB View Wrapper to
+ * kick off the delete in the first place, but that's a thread I don't want
+ * to pull on right now.
+ * We use this hint to figure out the next message to display once the
+ * deletion completes. We do this before the deletion happens because the
+ * selection is probably going away (except in the IMAP delete model), and it
+ * might be too late to figure this out after the deletion happens.
+ * Our automated complement (that calls us) is updateNextMessageAfterDelete.
+ */
+ hintAboutToDeleteMessages() {
+ this._deleteInProgress = true;
+ // save the value, even if it is nsMsgViewIndex_None.
+ this._nextViewIndexAfterDelete = this.view.dbView.msgToSelectAfterDelete;
+ },
+
+ /**
+ * The archive code tells us when it is starting to archive messages. This
+ * is different from hinting about deletion because it will also tell us
+ * when it has completed its mass move.
+ * The UI goal is that we do not immediately jump beyond the selected messages
+ * to the next message until all of the selected messages have been
+ * processed (moved). Ideally we would also do this when deleting messages
+ * from a multiple-folder backed message view, but we don't know when the
+ * last job completes in that case (whereas in this case we do because of the
+ * call to hintMassMoveCompleted.)
+ */
+ hintMassMoveStarting() {
+ this.hintAboutToDeleteMessages();
+ this._massMoveActive = true;
+ },
+
+ /**
+ * The archival has completed, we can finally let onMessagseRemoved run to
+ * completion.
+ */
+ hintMassMoveCompleted() {
+ this._massMoveActive = false;
+ this.onMessagesRemoved();
+ },
+
+ /**
+ * When a right-click on the thread pane is going to alter our selection, we
+ * get this notification (currently from |ChangeSelectionWithoutContentLoad|
+ * in threadPane.js), which lets us save our state.
+ * This ends one of two ways: we get made inactive because a new tab popped up
+ * or we get a call to |hintRightClickSelectionPerturbationDone|.
+ *
+ * Ideally, we could just save off our current nsITreeSelection and restore it
+ * when this is all over. This assumption would rely on the underlying view
+ * not having any changes to its rows before we restore the selection. I am
+ * not confident we can rule out background processes making changes, plus
+ * the right-click itself may mutate the view (although we could try and get
+ * it to restore the selection before it gets to the mutation part). Our
+ * only way to resolve this would be to create a 'tee' like fake selection
+ * that would proxy view change notifications to both sets of selections.
+ * That is hard.
+ * So we just use the existing _saveSelection/_restoreSelection mechanism
+ * which is potentially very costly.
+ */
+ hintRightClickPerturbingSelection() {
+ this._saveSelection();
+ },
+
+ /**
+ * When a right-click on the thread pane altered our selection (which we
+ * should have received a call to |hintRightClickPerturbingSelection| for),
+ * we should receive this notification from
+ * |RestoreSelectionWithoutContentLoad| when it wants to put things back.
+ */
+ hintRightClickSelectionPerturbationDone() {
+ this._restoreSelection();
+ },
+ // @}
+ /* ===== End hints from the command infrastructure ==== */
+
+ _updateThreadDisplay() {
+ if (this.active) {
+ if (this.view.dbView) {
+ UpdateSortIndicators(
+ this.view.dbView.sortType,
+ this.view.dbView.sortOrder
+ );
+ SetNewsFolderColumns();
+ UpdateSelectCol();
+ }
+ }
+ },
+
+ /**
+ * Update the UI display apart from the thread tree because the folder being
+ * displayed has changed. This can be the result of changing the folder in
+ * this FolderDisplayWidget, or because this FolderDisplayWidget is being
+ * made active. _updateThreadDisplay handles the parts of the thread tree
+ * that need updating.
+ */
+ _updateContextDisplay() {
+ if (this.active) {
+ UpdateStatusQuota(this.displayedFolder);
+
+ // - mail view combo-box.
+ this.onMailViewChanged();
+ }
+ },
+
+ /**
+ * @name Activation Control
+ * @protected
+ */
+ // @{
+
+ /**
+ * Run the provided notification function right now if we are 'active' (the
+ * currently displayed tab), otherwise queue it to be run when we become
+ * active. We do this because our tabbing model uses multiplexed (reused)
+ * widgets, and extensions likewise depend on these global/singleton things.
+ * If the requested notification function is already queued, it will not be
+ * added a second time, and the original call ordering will be maintained.
+ * If a new call ordering is required, the list of notifications should
+ * probably be reset by the 'big bang' event (new view creation?).
+ */
+ _notifyWhenActive(aNotificationFunc) {
+ if (this._active) {
+ aNotificationFunc.call(this);
+ } else if (
+ !this._notificationsPendingActivation.includes(aNotificationFunc)
+ ) {
+ this._notificationsPendingActivation.push(aNotificationFunc);
+ }
+ },
+
+ /**
+ * Some notifications cannot run while the FolderDisplayWidget is inactive
+ * (presumbly because it is in a background tab). We accumulate those in
+ * _notificationsPendingActivation and then this method runs them when we
+ * become active again.
+ */
+ _runNotificationsPendingActivation() {
+ if (!this._notificationsPendingActivation.length) {
+ return;
+ }
+
+ let pendingNotifications = this._notificationsPendingActivation;
+ this._notificationsPendingActivation = [];
+ for (let notif of pendingNotifications) {
+ notif.call(this);
+ }
+ },
+
+ // This is not guaranteed to be up to date if the folder display is active
+ _folderPaneVisible: null,
+
+ /**
+ * Whether the folder pane is visible. When we're inactive, we stash the value
+ * in |this._folderPaneVisible|.
+ */
+ get folderPaneVisible() {
+ // Early return if the user wants to use Thunderbird without an email
+ // account and no account is configured.
+ if (
+ Services.prefs.getBoolPref("app.use_without_mail_account", false) &&
+ !MailServices.accounts.accounts.length
+ ) {
+ return false;
+ }
+
+ if (this._active) {
+ let folderPaneBox = document.getElementById("folderPaneBox");
+ if (folderPaneBox) {
+ return !folderPaneBox.collapsed;
+ }
+ } else {
+ return this._folderPaneVisible;
+ }
+
+ return null;
+ },
+
+ /**
+ * Sets the visibility of the folder pane. This should reflect reality and
+ * not define it (for active tabs at least).
+ */
+ set folderPaneVisible(aVisible) {
+ this._folderPaneVisible = aVisible;
+ },
+
+ get active() {
+ return this._active;
+ },
+
+ /**
+ * Make this FolderDisplayWidget the 'active' widget by updating globals and
+ * linking us up to the UI widgets. This is intended for use by the tabbing
+ * logic.
+ */
+ makeActive(aWasInactive) {
+ let wasInactive = !this._active;
+
+ // -- globals
+ // update per-tab globals that we own
+ gFolderDisplay = this; // eslint-disable-line no-global-assign
+ gDBView = this.view.dbView; // eslint-disable-line no-global-assign
+ messenger = this.messenger; // eslint-disable-line no-global-assign
+
+ // update singleton globals' state
+ msgWindow.openFolder = this.view.displayedFolder;
+
+ this._active = true;
+ this._runNotificationsPendingActivation();
+
+ FolderDisplayListenerManager._fireListeners("onMakeActive", [
+ this,
+ aWasInactive,
+ ]);
+
+ // -- UI
+
+ // thread pane if we have a db view
+ if (this.view.dbView) {
+ // Make sure said thread pane is visible. If we do this after we re-root
+ // the tree, the thread pane may not actually replace the account central
+ // pane. Concerning...
+ this._showThreadPane();
+
+ // some things only need to happen if we are transitioning from inactive
+ // to active
+ if (wasInactive) {
+ if (this.tree) {
+ // Setting the 'view' attribute on treeBox results in the following
+ // effective calls, noting that in makeInactive we made sure to null
+ // out its view so that it won't try and clean up any views or their
+ // selections. (The actual actions happen in
+ // nsTreeBodyFrame::SetView)
+ // - this.view.dbView.selection.tree = this.tree
+ // - this.view.dbView.setTree(this.tree)
+ // - this.tree.view = this.view.dbView (in
+ // nsTreeBodyObject::SetView)
+ this.tree.view = this.view.dbView;
+
+ if (this._savedFirstVisibleRow != null) {
+ this.tree.scrollToRow(this._savedFirstVisibleRow);
+ }
+ }
+ }
+
+ // Always restore the column state if we have persisted state. We restore
+ // state on folder entry, in which case we were probably not inactive.
+ this._restoreColumnStates();
+
+ // update the columns and such that live inside the thread pane
+ this._updateThreadDisplay();
+ }
+
+ this._updateContextDisplay();
+ },
+
+ /**
+ * Cause the displayBox to display the thread pane.
+ */
+ _showThreadPane() {
+ document.getElementById("accountCentralBox").collapsed = true;
+ document.getElementById("threadPaneBox").collapsed = false;
+ },
+
+ /**
+ * Cause the displayBox to display the (preference configurable) account
+ * central page.
+ */
+ _showAccountCentral() {
+ if (!this.displayedFolder && MailServices.accounts.accounts.length > 0) {
+ // If we have any accounts set up, but no folder is selected yet,
+ // we expect another selection event to come when session restore finishes.
+ // Until then, do nothing.
+ return;
+ }
+ document.getElementById("accountCentralBox").collapsed = false;
+ document.getElementById("threadPaneBox").collapsed = true;
+
+ // Prevent a second load if necessary.
+ let loadURL =
+ "chrome://messenger/content/msgAccountCentral.xhtml" +
+ (this.displayedFolder
+ ? "?folderURI=" + encodeURIComponent(this.displayedFolder.URI)
+ : "");
+ if (window.frames.accountCentralPane.location.href != loadURL) {
+ window.frames.accountCentralPane.location.href = loadURL;
+ }
+ },
+
+ /**
+ * Call this when the tab using us is being hidden.
+ */
+ makeInactive() {
+ // - things to do before we mark ourselves inactive (because they depend on
+ // us being active)
+
+ // getColumnStates returns _savedColumnStates when we are inactive (and is
+ // used by _saveColumnStates) so we must do this before marking inactive.
+ this._saveColumnStates();
+
+ // - mark us inactive
+ this._active = false;
+
+ // - (everything after this point doesn't care that we are marked inactive)
+ // save the folder pane's state always
+ this._folderPaneVisible =
+ !document.getElementById("folderPaneBox").collapsed;
+
+ if (this.view.dbView) {
+ if (this.tree) {
+ this._savedFirstVisibleRow = this.tree.getFirstVisibleRow();
+ }
+
+ // save the message pane's state only when it is potentially visible
+ this.messagePaneCollapsed = document.getElementById(
+ "messagepaneboxwrapper"
+ ).collapsed;
+ }
+ },
+ // @}
+
+ /**
+ * @name Command Support
+ */
+ // @{
+
+ /**
+ * @returns true if there is a db view and the command is enabled on the view.
+ * This function hides some of the XPCOM-odditities of the getCommandStatus
+ * call.
+ */
+ getCommandStatus(aCommandType, aEnabledObj, aCheckStatusObj) {
+ // no view means not enabled
+ if (!this.view.dbView) {
+ return false;
+ }
+ let enabledObj = {},
+ checkStatusObj = {};
+ this.view.dbView.getCommandStatus(aCommandType, enabledObj, checkStatusObj);
+ return enabledObj.value;
+ },
+
+ /**
+ * Make code cleaner by allowing peoples to call doCommand on us rather than
+ * having to do folderDisplayWidget.view.dbView.doCommand.
+ *
+ * @param aCommandName The command name to invoke.
+ */
+ doCommand(aCommandName) {
+ return this.view.dbView && this.view.dbView.doCommand(aCommandName);
+ },
+
+ /**
+ * Make code cleaner by allowing peoples to call doCommandWithFolder on us
+ * rather than having to do:
+ * folderDisplayWidget.view.dbView.doCommandWithFolder.
+ *
+ * @param aCommandName The command name to invoke.
+ * @param aFolder The folder context for the command.
+ */
+ doCommandWithFolder(aCommandName, aFolder) {
+ return (
+ this.view.dbView &&
+ this.view.dbView.doCommandWithFolder(aCommandName, aFolder)
+ );
+ },
+ // @}
+
+ /**
+ * @returns true when account central is being displayed.
+ * @groupName Displayed
+ */
+ get isAccountCentralDisplayed() {
+ return this.view.dbView == null;
+ },
+
+ /**
+ * @name Navigation
+ * @protected
+ */
+ // @{
+
+ /**
+ * Navigate using nsMsgNavigationType rules and ensuring the resulting row is
+ * visible. This is trickier than it used to be because we now support
+ * treating collapsed threads as the set of all the messages in the collapsed
+ * thread rather than just the root message in that thread.
+ *
+ * @param {nsMsgNavigationType} aNavType navigation command.
+ * @param {boolean} [aSelect=true] should we select the message if we find
+ * one?
+ *
+ * @returns true if the navigation constraint matched anything, false if not.
+ * We will have navigated if true, we will have done nothing if false.
+ */
+ navigate(aNavType, aSelect) {
+ if (aSelect === undefined) {
+ aSelect = true;
+ }
+ let resultKeyObj = {},
+ resultIndexObj = {},
+ threadIndexObj = {};
+
+ let summarizeSelection = this.summarizeSelectionInFolder;
+
+ let treeSelection = this.treeSelection; // potentially magic getter
+ let currentIndex = treeSelection ? treeSelection.currentIndex : 0;
+
+ let viewIndex;
+ // if we're doing next unread, and a collapsed thread is selected, and
+ // the top level message is unread, just set the result manually to
+ // the top level message, without using viewNavigate.
+ if (
+ summarizeSelection &&
+ aNavType == Ci.nsMsgNavigationType.nextUnreadMessage &&
+ currentIndex != -1 &&
+ this.view.isCollapsedThreadAtIndex(currentIndex) &&
+ !(this.view.dbView.getFlagsAt(currentIndex) & Ci.nsMsgMessageFlags.Read)
+ ) {
+ viewIndex = currentIndex;
+ } else {
+ // always 'wrap' because the start index is relative to the selection.
+ // (keep in mind that many forms of navigation do not care about the
+ // starting position or 'wrap' at all; for example, firstNew just finds
+ // the first new message.)
+ // allegedly this does tree-expansion for us.
+ this.view.dbView.viewNavigate(
+ aNavType,
+ resultKeyObj,
+ resultIndexObj,
+ threadIndexObj,
+ true
+ );
+ viewIndex = resultIndexObj.value;
+ }
+
+ if (viewIndex == nsMsgViewIndex_None) {
+ return false;
+ }
+
+ // - Expand if required.
+ // (The nsMsgDBView isn't really aware of the varying semantics of
+ // collapsed threads, so viewNavigate might tell us about the root message
+ // and leave it collapsed, not realizing that it needs to be expanded.)
+ if (summarizeSelection && this.view.isCollapsedThreadAtIndex(viewIndex)) {
+ this.view.dbView.toggleOpenState(viewIndex);
+ }
+
+ if (aSelect) {
+ this.selectViewIndex(viewIndex);
+ } else {
+ this.ensureRowIsVisible(viewIndex);
+ }
+ return true;
+ },
+
+ /**
+ * Push a call to |navigate| to be what we do once we successfully open the
+ * next folder. This is intended to be used by cross-folder navigation
+ * code. It should call this method before triggering the folder change.
+ */
+ pushNavigation(aNavType, aSelect) {
+ this._pendingNavigation = [aNavType, aSelect];
+ },
+ // @}
+
+ /**
+ * @name Selection
+ */
+ // @{
+
+ /**
+ * @returns the message header for the first selected message, or null if
+ * there is no selected message.
+ *
+ * If the user has right-clicked on a message, this method will return that
+ * message and not the 'current index' (the dude with the dotted selection
+ * rectangle around him.) If you instead always want the currently
+ * displayed message (which is not impacted by right-clicking), then you
+ * would want to access the displayedMessage property on the
+ * MessageDisplayWidget. You can get to that via the messageDisplay
+ * attribute on this object or (potentially) via the gMessageDisplay object.
+ */
+ get selectedMessage() {
+ // there are inconsistencies in hdrForFirstSelectedMessage between
+ // nsMsgDBView and nsMsgSearchDBView in whether they use currentIndex,
+ // do it ourselves. (nsMsgDBView does not use currentIndex, search does.)
+ let treeSelection = this.treeSelection;
+ if (!treeSelection || !treeSelection.count) {
+ return null;
+ }
+ let minObj = {},
+ maxObj = {};
+ treeSelection.getRangeAt(0, minObj, maxObj);
+ return this.view.dbView.getMsgHdrAt(minObj.value);
+ },
+
+ /**
+ * @returns true if there is a selected message and it's an RSS feed message;
+ * a feed message does not have to be in an rss account folder if stored in
+ * Tb15 and later.
+ */
+ get selectedMessageIsFeed() {
+ return FeedUtils.isFeedMessage(this.selectedMessage);
+ },
+
+ /**
+ * @returns true if there is a selected message and it's an IMAP message.
+ */
+ get selectedMessageIsImap() {
+ let message = this.selectedMessage;
+ return Boolean(
+ message &&
+ message.folder &&
+ message.folder.flags & Ci.nsMsgFolderFlags.ImapBox
+ );
+ },
+
+ /**
+ * @returns true if there is a selected message and it's a news message. It
+ * would be great if messages knew this about themselves, but they don't.
+ */
+ get selectedMessageIsNews() {
+ let message = this.selectedMessage;
+ return Boolean(
+ message &&
+ message.folder &&
+ message.folder.flags & Ci.nsMsgFolderFlags.Newsgroup
+ );
+ },
+
+ /**
+ * @returns true if there is a selected message and it's an external message,
+ * meaning it is loaded from an .eml file on disk or is an rfc822 attachment
+ * on a message.
+ */
+ get selectedMessageIsExternal() {
+ let message = this.selectedMessage;
+ // Dummy messages currently lack a folder. This is not a great heuristic.
+ // I have annotated msgHdrView.js which provides the dummy header to
+ // express this implementation dependency.
+ // (Currently, since external mails can only be opened in standalone windows
+ // which subclass us, we could always return false, and have the subclass
+ // return true using its own heuristics. But since we are moving to a tab
+ // model more heavily, at some point the 3-pane will need this.)
+ return Boolean(message && !message.folder);
+ },
+
+ /**
+ * @returns true if there is a selected message and the message belongs to an
+ * ignored thread.
+ */
+ get selectedMessageThreadIgnored() {
+ let message = this.selectedMessage;
+ return Boolean(
+ message &&
+ message.folder &&
+ message.folder.msgDatabase.isIgnored(message.messageKey)
+ );
+ },
+
+ /**
+ * @returns true if there is a selected message and the message is the base
+ * message for an ignored subthread.
+ */
+ get selectedMessageSubthreadIgnored() {
+ let message = this.selectedMessage;
+ return Boolean(
+ message && message.folder && message.flags & Ci.nsMsgMessageFlags.Ignored
+ );
+ },
+
+ /**
+ * @returns true if there is a selected message and the message belongs to a
+ * watched thread.
+ */
+ get selectedMessageThreadWatched() {
+ let message = this.selectedMessage;
+ return Boolean(
+ message &&
+ message.folder &&
+ message.folder.msgDatabase.isWatched(message.messageKey)
+ );
+ },
+
+ /**
+ * @returns the number of selected messages. If summarizeSelectionInFolder is
+ * true, then any collapsed thread roots that are selected will also
+ * conceptually have all of the messages in that thread selected.
+ */
+ get selectedCount() {
+ return this.selectedMessages.length;
+ },
+
+ /**
+ * Provides a list of the view indices that are selected which is *not* the
+ * same as the rows of the selected messages. When
+ * summarizeSelectionInFolder is true, messages may be selected but not
+ * visible (because the thread root is selected.)
+ * You probably want to use the |selectedMessages| attribute instead of this
+ * one. (Or selectedMessageUris in some rare cases.)
+ *
+ * If the user has right-clicked on a message, this will return that message
+ * and not the selection prior to the right-click.
+ *
+ * @returns a list of the view indices that are currently selected
+ */
+ get selectedIndices() {
+ if (!this.view.dbView) {
+ return [];
+ }
+
+ return this.view.dbView.getIndicesForSelection();
+ },
+
+ /**
+ * Provides a list of the message headers for the currently selected messages.
+ * If summarizeSelectionInFolder is true, then any collapsed thread roots
+ * that are selected will also (conceptually) have all of the messages in
+ * that thread selected and they will be included in the returned list.
+ *
+ * If the user has right-clicked on a message, this will return that message
+ * (and any collapsed children if so enabled) and not the selection prior to
+ * the right-click.
+ *
+ * @returns a list of the message headers for the currently selected messages.
+ * If there are no selected messages, the result is an empty list.
+ */
+ get selectedMessages() {
+ if (!this._active && this._savedSelection?.messages) {
+ return this._savedSelection.messages
+ .map(savedInfo => this.view.getMsgHdrForMessageID(savedInfo.messageId))
+ .filter(msgHdr => !!msgHdr);
+ }
+ if (!this.view.dbView) {
+ return [];
+ }
+ return this.view.dbView.getSelectedMsgHdrs();
+ },
+
+ /**
+ * @returns a list of the URIs for the currently selected messages or null
+ * (instead of a list) if there are no selected messages. Do not
+ * pass around URIs unless you have a good reason. Legacy code is an
+ * ok reason.
+ *
+ * If the user has right-clicked on a message, this will return that message's
+ * URI and not the selection prior to the right-click.
+ */
+ get selectedMessageUris() {
+ if (!this.view.dbView) {
+ return null;
+ }
+
+ let messageArray = this.view.dbView.getURIsForSelection();
+ return messageArray.length ? messageArray : null;
+ },
+
+ /**
+ * @returns true if all the selected messages can be archived, false otherwise.
+ */
+ get canArchiveSelectedMessages() {
+ return false;
+ },
+
+ /**
+ * The maximum number of messages canMarkThreadAsRead will look through.
+ * If the number exceeds this limit, as a performance measure, we return
+ * true rather than looking through the messages and possible
+ * submessages.
+ */
+ MAX_COUNT_FOR_MARK_THREAD: 1000,
+
+ /**
+ * Check if the thread for the currently selected message can be marked as
+ * read. A thread can be marked as read if and only if it has at least one
+ * unread message.
+ */
+ get canMarkThreadAsRead() {
+ if (
+ (this.displayedFolder && this.displayedFolder.getNumUnread(false) > 0) ||
+ this.view._underlyingData === this.view.kUnderlyingSynthetic
+ ) {
+ // If the messages limit is exceeded we bail out early and return true.
+ if (this.selectedIndices.length > this.MAX_COUNT_FOR_MARK_THREAD) {
+ return true;
+ }
+
+ for (let i of this.selectedIndices) {
+ if (
+ this.view.dbView.getThreadContainingIndex(i).numUnreadChildren > 0
+ ) {
+ return true;
+ }
+ }
+ }
+ return false;
+ },
+
+ /**
+ * @returns true if all the selected messages can be deleted from their
+ * folders, false otherwise.
+ */
+ get canDeleteSelectedMessages() {
+ if (!this.view.dbView) {
+ return false;
+ }
+
+ let selectedMessages = this.selectedMessages;
+ for (let i = 0; i < selectedMessages.length; ++i) {
+ if (
+ selectedMessages[i].folder &&
+ (!selectedMessages[i].folder.canDeleteMessages ||
+ selectedMessages[i].folder.flags & Ci.nsMsgFolderFlags.Newsgroup)
+ ) {
+ return false;
+ }
+ }
+ return true;
+ },
+
+ /**
+ * Clear the tree selection, making sure the message pane is cleared and
+ * the context display (toolbars, etc.) are updated.
+ */
+ clearSelection() {
+ let treeSelection = this.treeSelection; // potentially magic getter
+ if (!treeSelection) {
+ return;
+ }
+ treeSelection.clearSelection();
+ this._updateContextDisplay();
+ },
+
+ // Whether we're about to select a message
+ _aboutToSelectMessage: false,
+
+ /**
+ * This needs to be called to let us know that a selectMessage or equivalent
+ * is coming up right after a show() call, so that we know that a double
+ * message load won't be happening.
+ *
+ * This can be assumed to be idempotent.
+ */
+ selectMessageComingUp() {
+ this._aboutToSelectMessage = true;
+ },
+
+ /**
+ * Select a message for display by header. Attempt to select the message
+ * right now. If we were unable to find it, update our saved selection
+ * to want to display the message. Threads are expanded to find the header.
+ *
+ * @param aMsgHdr The message header to select for display.
+ * @param [aForceSelect] If the message is not in the view and this is true,
+ * we will drop any applied view filters to look for the
+ * message. The dropping of view filters is persistent,
+ * so use with care. Defaults to false.
+ */
+ selectMessage(aMsgHdr, aForceSelect) {
+ let viewIndex = this.view.getViewIndexForMsgHdr(aMsgHdr, aForceSelect);
+ if (viewIndex != nsMsgViewIndex_None) {
+ this._savedSelection = null;
+ this.selectViewIndex(viewIndex);
+ } else {
+ this._savedSelection = {
+ messages: [{ messageId: aMsgHdr.messageId }],
+ forceSelect: aForceSelect,
+ };
+ // queue the selection to be restored once we become active if we are not
+ // active.
+ if (!this.active) {
+ this._notifyWhenActive(this._restoreSelection);
+ }
+ }
+
+ // Do this here instead of at the beginning to prevent reentrancy issues
+ this._aboutToSelectMessage = false;
+ },
+
+ /**
+ * Select all of the provided nsIMsgDBHdrs in the aMessages array, expanding
+ * threads as required. If we were not able to find all of the messages,
+ * update our saved selection to want to display the messages. The messages
+ * will then be selected when we are made active or all messages in the
+ * folder complete loading. This is to accommodate the use-case where we
+ * are backed by an in-progress search and no
+ *
+ * @param aMessages An array of nsIMsgDBHdr instances.
+ * @param [aForceSelect] If a message is not in the view and this is true,
+ * we will drop any applied view filters to look for the
+ * message. The dropping of view filters is persistent,
+ * so use with care. Defaults to false.
+ * @param aDoNotNeedToFindAll If true (can be omitted and left undefined), we
+ * do not attempt to save the selection for future use. This is intended
+ * for use by the _restoreSelection call which is the end-of-the-line for
+ * restoring the selection. (Once it gets called all of our messages
+ * should have already been loaded.)
+ */
+ selectMessages(aMessages, aForceSelect, aDoNotNeedToFindAll) {
+ let treeSelection = this.treeSelection; // potentially magic getter
+ let foundAll = true;
+ if (treeSelection) {
+ let minRow = null,
+ maxRow = null;
+
+ treeSelection.selectEventsSuppressed = true;
+ treeSelection.clearSelection();
+
+ for (let msgHdr of aMessages) {
+ let viewIndex = this.view.getViewIndexForMsgHdr(msgHdr, aForceSelect);
+
+ if (viewIndex != nsMsgViewIndex_None) {
+ if (minRow == null || viewIndex < minRow) {
+ minRow = viewIndex;
+ }
+ if (maxRow == null || viewIndex > maxRow) {
+ maxRow = viewIndex;
+ }
+ // nsTreeSelection is actually very clever about doing this
+ // efficiently.
+ treeSelection.rangedSelect(viewIndex, viewIndex, true);
+ } else {
+ foundAll = false;
+ }
+
+ // make sure the selection is as visible as possible
+ if (minRow != null) {
+ this.ensureRowRangeIsVisible(minRow, maxRow);
+ }
+ }
+
+ treeSelection.selectEventsSuppressed = false;
+
+ // If we haven't selected every message, we'll set |this._savedSelection|
+ // below, so it's fine to null it out at this point.
+ this._savedSelection = null;
+ }
+
+ // Do this here instead of at the beginning to prevent reentrancy issues
+ this._aboutToSelectMessage = false;
+
+ // Two cases.
+ // 1. The tree selection isn't there at all.
+ // 2. The tree selection is there, and we needed to find all messages, but
+ // we didn't.
+ if (!treeSelection || (!aDoNotNeedToFindAll && !foundAll)) {
+ this._savedSelection = {
+ messages: aMessages.map(msgHdr => ({ messageId: msgHdr.messageId })),
+ forceSelect: aForceSelect,
+ };
+ if (!this.active) {
+ this._notifyWhenActive(this._restoreSelection);
+ }
+ }
+ },
+
+ /**
+ * Select the message at view index.
+ *
+ * @param aViewIndex The view index to select. This will be bounds-checked
+ * and if it is outside the bounds, we will clear the selection and
+ * bail.
+ */
+ selectViewIndex(aViewIndex) {
+ let treeSelection = this.treeSelection;
+ // if we have no selection, we can't select something
+ if (!treeSelection) {
+ return;
+ }
+ let rowCount = this.view.dbView.rowCount;
+ if (
+ aViewIndex == nsMsgViewIndex_None ||
+ aViewIndex < 0 ||
+ aViewIndex >= rowCount
+ ) {
+ this.clearSelection();
+ return;
+ }
+
+ // Check whether the index is already selected/current. This can be the
+ // case when we are here as the result of a deletion. Assuming
+ // nsMsgDBView::NoteChange ran and was not suppressing change
+ // notifications, then it's very possible the selection is already where
+ // we want it to go. However, in that case, nsMsgDBView::SelectionChanged
+ // bailed without doing anything because m_deletingRows...
+ // So we want to generate a change notification if that is the case. (And
+ // we still want to call ensureRowIsVisible, as there may be padding
+ // required.)
+ if (
+ treeSelection.count == 1 &&
+ (treeSelection.currentIndex == aViewIndex ||
+ treeSelection.isSelected(aViewIndex))
+ ) {
+ // Make sure the index we just selected is also the current index.
+ // This can happen when the tree selection adjusts itself as a result of
+ // changes to the tree as a result of deletion. This will not trigger
+ // a notification.
+ treeSelection.select(aViewIndex);
+ this.view.dbView.selectionChanged();
+ } else {
+ // Previous code was concerned about avoiding updating commands on the
+ // assumption that only the selection count mattered. We no longer
+ // make this assumption.
+ // Things that may surprise you about the call to treeSelection.select:
+ // 1) This ends up calling the onselect method defined on the XUL 'tree'
+ // tag. For the 3pane this is the ThreadPaneSelectionChanged method in
+ // threadPane.js. That code checks a global to see if it is dealing
+ // with a right-click, and ignores it if so.
+ treeSelection.select(aViewIndex);
+ }
+
+ if (this._active) {
+ this.ensureRowIsVisible(aViewIndex);
+ }
+
+ // The saved selection is invalidated, since we've got something newer
+ this._savedSelection = null;
+
+ // Do this here instead of at the beginning to prevent reentrancy issues
+ this._aboutToSelectMessage = false;
+ },
+
+ /**
+ * For every selected message in the display that is part of a (displayed)
+ * thread and is not the root message, de-select it and ensure that the
+ * root message of the thread is selected.
+ * This is primarily intended to be used when collapsing visible threads.
+ *
+ * We do nothing if we are not in a threaded display mode.
+ */
+ selectSelectedThreadRoots() {
+ if (!this.view.showThreaded) {
+ return;
+ }
+
+ // There are basically two implementation strategies available to us:
+ // 1) For each selected view index with a level > 0, keep walking 'up'
+ // (numerically smaller) until we find a message with level 0.
+ // The inefficiency here is the potentially large number of JS calls
+ // into XPCOM space that will be required.
+ // 2) Ask for the thread that each view index belongs to, use that to
+ // efficiently retrieve the thread root, then find the root using
+ // the message header. The inefficiency here is that the view
+ // currently does a linear scan, albeit a relatively efficient one.
+ // And the winner is... option 2, because the code is simpler because we
+ // can reuse selectMessages to do most of the work.
+ let selectedIndices = this.selectedIndices;
+ let newSelectedMessages = [];
+ let dbView = this.view.dbView;
+ for (let index of selectedIndices) {
+ let thread = dbView.getThreadContainingIndex(index);
+ newSelectedMessages.push(thread.getRootHdr());
+ }
+ this.selectMessages(newSelectedMessages);
+ },
+
+ // @}
+
+ /**
+ * @name Ensure Visibility
+ */
+ // @{
+
+ /**
+ * Minimum number of lines to display between the 'focused' message and the
+ * top / bottom of the thread pane.
+ */
+ get visibleRowPadding() {
+ let topPadding, bottomPadding;
+
+ // If we can get the height of the folder pane, treat the values as
+ // percentages of that.
+ if (this.tree) {
+ let topPercentPadding = Services.prefs.getIntPref(
+ "mail.threadpane.padding.top_percent"
+ );
+ let bottomPercentPadding = Services.prefs.getIntPref(
+ "mail.threadpane.padding.bottom_percent"
+ );
+
+ // Assume the bottom row is half-visible and should generally be ignored.
+ // (We could actually do the legwork to see if there is a partial one...)
+ let paneHeight = this.tree.getPageLength() - 1;
+
+ // Convert from percentages to absolute row counts.
+ topPadding = Math.ceil((topPercentPadding / 100) * paneHeight);
+ bottomPadding = Math.ceil((bottomPercentPadding / 100) * paneHeight);
+
+ // We need one visible row not counted in either padding, for the actual
+ // target message. Also helps correct for rounding errors.
+ if (topPadding + bottomPadding > paneHeight) {
+ if (topPadding > bottomPadding) {
+ topPadding--;
+ } else {
+ bottomPadding--;
+ }
+ }
+ } else {
+ // Something's gone wrong elsewhere, and we likely have bigger problems.
+ topPadding = 0;
+ bottomPadding = 0;
+ console.error("Unable to get height of folder pane (treeBox is null)");
+ }
+
+ return [topPadding, bottomPadding];
+ },
+
+ /**
+ * Ensure the given view index is visible, optionally with some padding.
+ * By padding, we mean that the index will not be the first or last message
+ * displayed, but rather have messages on either side.
+ * We have the concept of a 'lip' when we are at the end of the message
+ * display. If we are near the end of the display, we want to show an
+ * empty row (at the bottom) so the user knows they are at the end. Also,
+ * if a message shows up that is new and things are sorted ascending, this
+ * turns out to be useful.
+ */
+ ensureRowIsVisible(aViewIndex, aBounced) {
+ // Dealing with the tree view layout is a nightmare, let's just always make
+ // sure we re-schedule ourselves. The most particular rationale here is
+ // that the message pane may be toggling its state and it's much simpler
+ // and reliable if we ensure that all of FolderDisplayWidget's state
+ // change logic gets to run to completion before we run ourselves.
+ if (!aBounced) {
+ let dis = this;
+ window.setTimeout(function () {
+ dis.ensureRowIsVisible(aViewIndex, true);
+ }, 0);
+ }
+
+ let tree = this.tree;
+ if (!tree || !tree.view) {
+ return;
+ }
+
+ // try and trigger a reflow...
+ tree.getBoundingClientRect();
+
+ let maxIndex = tree.view.rowCount - 1;
+
+ let first = tree.getFirstVisibleRow();
+ // Assume the bottom row is half-visible and should generally be ignored.
+ // (We could actually do the legwork to see if there is a partial one...)
+ const halfVisible = 1;
+ let last = tree.getLastVisibleRow() - halfVisible;
+ let span = tree.getPageLength() - halfVisible;
+ let [topPadding, bottomPadding] = this.visibleRowPadding;
+
+ let target;
+ if (aViewIndex >= last - bottomPadding) {
+ // The index is after the last visible guy (with padding),
+ // move down so that the target index is padded in 1 from the bottom.
+ target = Math.min(maxIndex, aViewIndex + bottomPadding) - span;
+ } else if (aViewIndex <= first + topPadding) {
+ // The index is before the first visible guy (with padding), move up.
+ target = Math.max(0, aViewIndex - topPadding);
+ } else {
+ // It is already visible.
+ return;
+ }
+
+ // this sets the first visible row
+ tree.scrollToRow(target);
+ },
+
+ /**
+ * Ensure that the given range of rows is maximally visible in the thread
+ * pane. If the range is larger than the number of rows that can be
+ * displayed in the thread pane, we bias towards showing the min row (with
+ * padding).
+ *
+ * @param aMinRow The numerically smallest row index defining the start of
+ * the inclusive range.
+ * @param aMaxRow The numberically largest row index defining the end of the
+ * inclusive range.
+ */
+ ensureRowRangeIsVisible(aMinRow, aMaxRow, aBounced) {
+ // Dealing with the tree view layout is a nightmare, let's just always make
+ // sure we re-schedule ourselves. The most particular rationale here is
+ // that the message pane may be toggling its state and it's much simpler
+ // and reliable if we ensure that all of FolderDisplayWidget's state
+ // change logic gets to run to completion before we run ourselves.
+ if (!aBounced) {
+ let dis = this;
+ window.setTimeout(function () {
+ dis.ensureRowRangeIsVisible(aMinRow, aMaxRow, true);
+ }, 0);
+ }
+
+ let tree = this.tree;
+ if (!tree) {
+ return;
+ }
+ let first = tree.getFirstVisibleRow();
+ const halfVisible = 1;
+ let last = tree.getLastVisibleRow() - halfVisible;
+ let span = tree.getPageLength() - halfVisible;
+ let [topPadding, bottomPadding] = this.visibleRowPadding;
+
+ // bail if the range is already visible with padding constraints handled
+ if (first + topPadding <= aMinRow && last - bottomPadding >= aMaxRow) {
+ return;
+ }
+
+ let target;
+ // if the range is bigger than we can fit, optimize position for the min row
+ // with padding to make it obvious the range doesn't extend above the row.
+ if (aMaxRow - aMinRow > span) {
+ target = Math.max(0, aMinRow - topPadding);
+ } else {
+ // So the range must fit, and it's a question of how we want to position
+ // it. For now, the answer is we try and center it, why not.
+ let rowSpan = aMaxRow - aMinRow + 1;
+ let halfSpare = Math.floor(
+ (span - rowSpan - topPadding - bottomPadding) / 2
+ );
+ target = aMinRow - halfSpare - topPadding;
+ }
+ tree.scrollToRow(target);
+ },
+
+ /**
+ * Ensure that the selection is visible to the extent possible.
+ */
+ ensureSelectionIsVisible() {
+ let treeSelection = this.treeSelection; // potentially magic getter
+ if (!treeSelection || !treeSelection.count) {
+ return;
+ }
+
+ let minRow = null,
+ maxRow = null;
+
+ let rangeCount = treeSelection.getRangeCount();
+ for (let iRange = 0; iRange < rangeCount; iRange++) {
+ let rangeMinObj = {},
+ rangeMaxObj = {};
+ treeSelection.getRangeAt(iRange, rangeMinObj, rangeMaxObj);
+ let rangeMin = rangeMinObj.value,
+ rangeMax = rangeMaxObj.value;
+ if (minRow == null || rangeMin < minRow) {
+ minRow = rangeMin;
+ }
+ if (maxRow == null || rangeMax > maxRow) {
+ maxRow = rangeMax;
+ }
+ }
+
+ this.ensureRowRangeIsVisible(minRow, maxRow);
+ },
+ // @}
+};
+
+function SetNewsFolderColumns() {
+ var sizeColumn = document.getElementById("sizeCol");
+ var bundle = document.getElementById("bundle_messenger");
+
+ if (gDBView.usingLines) {
+ sizeColumn.setAttribute("label", bundle.getString("linesColumnHeader"));
+ sizeColumn.setAttribute(
+ "tooltiptext",
+ bundle.getString("linesColumnTooltip2")
+ );
+ } else {
+ sizeColumn.setAttribute("label", bundle.getString("sizeColumnHeader"));
+ sizeColumn.setAttribute(
+ "tooltiptext",
+ bundle.getString("sizeColumnTooltip2")
+ );
+ }
+}
+
+function UpdateStatusQuota(folder) {
+ if (!document.getElementById("quotaPanel")) {
+ // No quotaPanel in here, like for the search window.
+ return;
+ }
+
+ if (!(folder && folder instanceof Ci.nsIMsgImapMailFolder)) {
+ document.getElementById("quotaPanel").hidden = true;
+ return;
+ }
+
+ let quotaUsagePercentage = q =>
+ Number((100n * BigInt(q.usage)) / BigInt(q.limit));
+
+ // For display on main window panel only include quota names containing
+ // "STORAGE" or "MESSAGE". This will exclude unusual quota names containing
+ // items like "MAILBOX" and "LEVEL" from the panel bargraph. All quota names
+ // will still appear on the folder properties quota window.
+ // Note: Quota name is typically something like "User Quota / STORAGE".
+ let folderQuota = folder
+ .getQuota()
+ .filter(
+ quota =>
+ quota.name.toUpperCase().includes("STORAGE") ||
+ quota.name.toUpperCase().includes("MESSAGE")
+ );
+ // If folderQuota not empty, find the index of the element with highest
+ // percent usage and determine if it is above the panel display threshold.
+ if (folderQuota.length > 0) {
+ let highest = folderQuota.reduce((acc, current) =>
+ quotaUsagePercentage(acc) > quotaUsagePercentage(current) ? acc : current
+ );
+ let percent = quotaUsagePercentage(highest);
+ if (
+ percent <
+ Services.prefs.getIntPref("mail.quota.mainwindow_threshold.show")
+ ) {
+ document.getElementById("quotaPanel").hidden = true;
+ } else {
+ document.getElementById("quotaPanel").hidden = false;
+ document.getElementById("quotaMeter").setAttribute("value", percent);
+ var bundle = document.getElementById("bundle_messenger");
+ document.getElementById("quotaLabel").value = bundle.getFormattedString(
+ "percent",
+ [percent]
+ );
+ document.getElementById("quotaLabel").tooltipText =
+ bundle.getFormattedString("quotaTooltip2", [
+ highest.usage,
+ highest.limit,
+ ]);
+ let quotaPanel = document.getElementById("quotaPanel");
+ if (
+ percent <
+ Services.prefs.getIntPref("mail.quota.mainwindow_threshold.warning")
+ ) {
+ quotaPanel.classList.remove("alert-warning", "alert-critical");
+ } else if (
+ percent <
+ Services.prefs.getIntPref("mail.quota.mainwindow_threshold.critical")
+ ) {
+ quotaPanel.classList.remove("alert-critical");
+ quotaPanel.classList.add("alert-warning");
+ } else {
+ quotaPanel.classList.remove("alert-warning");
+ quotaPanel.classList.add("alert-critical");
+ }
+ }
+ } else {
+ document.getElementById("quotaPanel").hidden = true;
+ }
+}