Adding upstream version 1:115.7.0.upstream/1%115.7.0upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 875 insertions, 0 deletions

diff --git a/comm/suite/chatzilla/xul/content/channels.js b/comm/suite/chatzilla/xul/content/channels.js
new file mode 100644
index 0000000000..912e62c14a
--- /dev/null
+++ b/comm/suite/chatzilla/xul/content/channels.js
@@ -0,0 +1,875 @@
+/* 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/. */
+
+var client;
+var network;
+var channels = new Array();
+var tree = { view: null, newItem: null, share: new Object() };
+var xul = new Object();
+
+
+// Create list of operations. These are handled by common code.
+const OPS = new Array();
+OPS.push({ key: "noop",   ignore: true   });
+OPS.push({ key: "list",   canStop: false });
+OPS.push({ key: "load",   canStop: true  });
+OPS.push({ key: "filter", canStop: true  });
+
+
+// Define constants for each operation.
+// JavaScript won't let you delete things declared with "var", workaround:
+// NOTE: This order MUST be the same as those above!
+window.s = 0;
+const OP_LIST   = ++s;  // A /list operation on the server.
+const OP_LOAD   = ++s;  // Loading the saved file.
+const OP_FILTER = ++s;  // Filtering the loaded list.
+
+
+// Define constants for the valid states of each operation.
+// All states before STATE_START must be idle (stopped) states.
+// All states from STATE_START onwards must be busy (running) states.
+s = 0;
+const STATE_IDLE  = ++s;  // Not doing this operation.
+const STATE_ERROR = ++s;  // Error occurred: don't try do to any more.
+const STATE_START = ++s;  // Starting an operation.
+const STATE_RUN   = ++s;  // Running...
+const STATE_STOP  = ++s;  // Clean-up/ending operation.
+delete window.s;
+
+
+// Store all the operation data here.
+var data = {
+    list:   { state: STATE_IDLE },
+    load:   { state: STATE_IDLE },
+    filter: { state: STATE_IDLE }
+};
+
+
+// This should keep things responsive enough, for the user to click buttons and
+// edit the filter text and options, without giving up too much time to letting
+// Gecko catch up.
+const PROCESS_TIME_MAX = 200;
+const PROCESS_DELAY    =  50;
+
+const colIDToSortKey = { chanColName: "name",
+                         chanColUsers: "users",
+                         chanColTopic: "topic" };
+const sortKeyToColID = { name: "chanColName",
+                         users: "chanColUsers",
+                         topic: "chanColTopic" };
+
+function onLoad()
+{
+    function ondblclick(event) { tree.view.onRouteDblClick(event); };
+    function onkeypress(event) { tree.view.onRouteKeyPress(event); };
+    function onfocus(event)    { tree.view.onRouteFocus(event); };
+    function onblur(event)     { tree.view.onRouteBlur(event); };
+
+    function doJoin()
+    {
+        if (joinChannel())
+            window.close();
+    };
+
+    client = window.arguments[0].client;
+    client.joinDialog = window;
+
+    window.dd = client.mainWindow.dd;
+    window.ASSERT = client.mainWindow.ASSERT;
+    window.toUnicode = client.mainWindow.toUnicode;
+    window.getMsg = client.mainWindow.getMsg;
+    window.MSG_CHANNEL_OPENED = client.mainWindow.MSG_CHANNEL_OPENED;
+    window.MSG_FMT_JSEXCEPTION = client.mainWindow.MSG_FMT_JSEXCEPTION;
+    window.MT_INFO = client.mainWindow.MT_INFO;
+
+    // Import "MSG_CD_*"...
+    for (var m in client.mainWindow)
+    {
+        if (m.substr(0, 7) == "MSG_CD_")
+            window[m] = client.mainWindow[m];
+    }
+
+    // Cache all the XUL DOM elements.
+    var elements = ["network", "networks", "channel", "includeTopic",
+                    "lastUpdated", "join", "minUsers", "maxUsers", "refresh",
+                    "bottomPanel", "channels", "loadContainer", "loadLabel",
+                    "loadBarDeck", "loadBar"];
+    for (var i = 0; i < elements.length; i++)
+        xul[elements[i]] = document.getElementById(elements[i]);
+
+    // Set the <dialog>'s class so we can do platform-specific CSS.
+    var dialog = document.getElementById("chatzilla-window");
+    dialog.className = "platform-" + client.platform;
+
+    // Set up the channel tree view.
+    tree.view = new XULTreeView(tree.share);
+    tree.view.onRowCommand = doJoin;
+    tree.view.cycleHeader = changeSort;
+    xul.channels.treeBoxObject.view = tree.view;
+
+    // If the new "search" binding is not working (i.e. doesn't exist)...
+    if (!("searchButton" in xul.channel))
+    {
+        // ...restore the text boxes to their former selves.
+        xul.channel.setAttribute("timeout", "500");
+        xul.channel.setAttribute("type", "timed");
+        xul.minUsers.setAttribute("timeout", "500");
+        xul.minUsers.setAttribute("type", "timed");
+        xul.maxUsers.setAttribute("timeout", "500");
+        xul.maxUsers.setAttribute("type", "timed");
+    }
+
+    // Sort by user count, descending.
+    changeSort("chanColUsers");
+
+    xul.channels.addEventListener("dblclick", ondblclick, false);
+    xul.channels.addEventListener("keypress", onkeypress, false);
+    xul.channels.addEventListener("focus", onfocus, false);
+    xul.channels.addEventListener("blur", onblur, false);
+
+    tree.newItem = new ChannelEntry("", "", MSG_CD_CREATE);
+    tree.newItem.first = true;
+    tree.view.childData.appendChild(tree.newItem);
+
+    var opener = window.arguments[0].opener;
+    if (opener)
+    {
+        // Force the window to be the right size now, not later.
+        window.sizeToContent();
+
+        // Position it centered over, but never up or left of parent.
+        var sx = Math.max((opener.outerWidth  - window.outerWidth ) / 2, 0);
+        var sy = Math.max((opener.outerHeight - window.outerHeight) / 2, 0);
+        window.moveTo(opener.screenX + sx, opener.screenY + sy);
+    }
+
+    setNetwork(window.arguments[0].network);
+    setTimeout(updateOperations, PROCESS_DELAY);
+    if (network)
+        xul.channel.focus();
+    else
+        xul.network.focus();
+}
+
+function onUnload()
+{
+    delete client.joinDialog;
+}
+
+function onKeyPress(event)
+{
+    if (event.keyCode == event.DOM_VK_RETURN)
+    {
+        if (joinChannel())
+            window.close();
+        event.stopPropagation();
+        event.preventDefault();
+    }
+    else if (event.keyCode == event.DOM_VK_UP)
+    {
+        if (tree.view.selectedIndex > 0)
+        {
+            tree.view.selectedIndex = tree.view.selectedIndex - 1;
+            ensureRowIsVisible();
+        }
+        event.preventDefault();
+    }
+    else if (event.keyCode == event.DOM_VK_DOWN)
+    {
+        if (tree.view.selectedIndex < tree.view.rowCount - 1)
+        {
+            tree.view.selectedIndex = tree.view.selectedIndex + 1;
+            ensureRowIsVisible();
+        }
+        event.preventDefault();
+    }
+}
+
+function onShowingNetworks()
+{
+    while (xul.networks.lastChild)
+        xul.networks.removeChild(xul.networks.lastChild);
+
+    /* Show any network meeting at least 1 requirement:
+     *   - Non-temporary (i.e. real network).
+     *   - Currently connected.
+     *   - Has visible tab in main window.
+     */
+    var networks = new Array();
+    for (var n in client.networks)
+    {
+        if (!client.networks[n].temporary
+            || client.networks[n].isConnected()
+            || client.mainWindow.getTabForObject(client.networks[n]))
+        {
+            networks.push(client.networks[n].unicodeName);
+        }
+    }
+    networks.sort();
+    for (var i = 0; i < networks.length; i++)
+    {
+        var menuitem = document.createElement("menuitem");
+        menuitem.setAttribute("label",  networks[i]);
+        xul.networks.appendChild(menuitem);
+    }
+}
+
+function onSelectionChange()
+{
+    update();
+}
+
+function onFilter()
+{
+    update();
+    if (network)
+        startOperation(OP_FILTER);
+}
+
+function setNetwork(newNetwork, noUpdate)
+{
+    xul.network.value = newNetwork ? newNetwork.unicodeName : "";
+    update();
+}
+
+function update()
+{
+    let newNetwork = client.getNetwork(xul.network.value);
+    if (network != newNetwork)
+    {
+        network = newNetwork;
+        if (network)
+            startOperation(OP_LOAD);
+    }
+
+    if (network)
+    {
+        var index = tree.view.selectedIndex;
+        var rows = tree.view.childData;
+        var row = index == -1 ? null : rows.locateChildByVisualRow(index);
+        var listFile = getListFile();
+        var listMod = 0;
+        if (listFile.exists() && (listFile.fileSize > 0))
+            listMod = listFile.lastModifiedTime;
+
+        xul.join.disabled = network.isConnected() && (!row || !row.name);
+        xul.lastUpdated.value = listMod ? getMsg(MSG_CD_UPDATED, [strftime(MSG_CD_UPDATED_FORMAT, new Date(listMod))]) : MSG_CD_UPDATED_NEVER;
+        xul.refresh.disabled = !network.isConnected() ||
+                               (getOperationState(OP_LIST) == STATE_START) ||
+                               (getOperationState(OP_LIST) == STATE_RUN);
+        xul.bottomPanel.selectedIndex = 1;
+    }
+    else
+    {
+        xul.join.disabled = !xul.network.value;
+        xul.lastUpdated.value = "";
+        xul.refresh.disabled = true;
+        xul.bottomPanel.selectedIndex = 0;
+    }
+}
+
+function joinChannel()
+{
+    update();
+    if (xul.join.disabled)
+        return false;
+
+    /* Calculate the row index AS IF the 'create' row is visible. We're going
+     * to use this so that the index chosen by the user is always consistent,
+     * whatever the visibility of the 'create' row - an index of 0 is ALWAYS
+     * the 'create' row, and >= 1 is ALWAYS the searched rows.
+     */
+    var index = tree.view.selectedIndex;
+    var row = tree.view.childData.locateChildByVisualRow(index);
+    var realIndex = index + (tree.newItem.isHidden ? 1 : 0);
+
+    client.dispatch("attach", { ircUrl: xul.network.value + "/" + row.name });
+
+    return true;
+}
+
+function focusSearch()
+{
+    xul.channel.focus();
+}
+
+function refreshList()
+{
+    startOperation(OP_LIST);
+}
+
+function updateProgress(label, pro)
+{
+    if (label)
+    {
+        xul.loadLabel.value = label;
+    }
+    else
+    {
+        var msg = getMsg(MSG_CD_SHOWING,
+             [(tree.view.rowCount - (tree.newItem.isHidden ? 0 : 1)),
+              channels.length]);
+        xul.loadLabel.value = msg;
+    }
+
+    xul.loadBarDeck.selectedIndex = (typeof pro == "undefined") ? 1 : 0;
+
+    if ((typeof pro == "undefined") || (pro == -1))
+    {
+        xul.loadBar.mode = "undetermined";
+    }
+    else
+    {
+        xul.loadBar.mode = "determined";
+        xul.loadBar.value = pro;
+    }
+}
+
+function changeSort(col)
+{
+    if (typeof col == "object")
+        col = col.id;
+
+    col = colIDToSortKey[col];
+    // Users default to descending, others ascending.
+    var dir = (col == "users" ? -1 : 1);
+
+    if (col == tree.share.sortColumn)
+        dir = -tree.share.sortDirection;
+
+    var colID = sortKeyToColID[tree.share.sortColumn];
+    var colNode = document.getElementById(colID);
+    if (colNode)
+    {
+        colNode.removeAttribute("sortActive");
+        colNode.removeAttribute("sortDirection");
+    }
+
+    tree.view.childData.setSortColumn(col, dir);
+
+    colID = sortKeyToColID[tree.share.sortColumn];
+    colNode = document.getElementById(colID);
+    if (colNode)
+    {
+        colNode.setAttribute("sortActive", "true");
+        var sortDir = (dir > 0 ? "ascending" : "descending");
+        colNode.setAttribute("sortDirection", sortDir);
+    }
+}
+
+
+// ***** BEGIN OPERATIONS CODE *****
+
+
+/* Return the static data about an operation (e.g. whether it can be
+ * stopped, etc.). The data returned is always the same for a given op code.
+ */
+function getOperation(op)
+{
+    ASSERT(op in OPS, "Invalid op-code: " + op);
+    return OPS[op];
+}
+
+/* Returns the live data about an operation (e.g. current state). Accepts
+ * either the op ID or the static data (as returned from getOperation(op)).
+ */
+function getOperationData(op)
+{
+    if (typeof op == "object")
+        return data[op.key];
+    return data[getOperation(op).key];
+}
+
+// Returns the current state of an operation; accepts same as getOperationData.
+function getOperationState(op)
+{
+    return getOperationData(op).state;
+}
+
+function startOperation(op)
+{
+    var ops = getOperation(op);
+    if (ops.ignore)
+        return;
+
+    var dbg = "startOperation(" + ops.key + ")";
+    var opData = getOperationData(ops);
+
+    // STATE_ERROR operations must not do anything. Assert and bail.
+    if (!ASSERT(opData.state != STATE_ERROR, dbg + " in STATE_ERROR"))
+        return;
+
+    // Check we can stop a non-idle operation.
+    if (!ASSERT((opData.state == STATE_IDLE) || ops.canStop,
+           dbg + " not in STATE_IDLE and can't stop"))
+    {
+        return;
+    }
+
+    // Stop the current operation.
+    if (opData.state != STATE_IDLE)
+        stopOperation(op);
+
+    // Begin!
+    var opData = getOperationData(op);
+    opData.state = STATE_START;
+    processOperation(op);
+    ASSERT(opData.state == STATE_RUN, dbg + " didn't enter STATE_RUN");
+}
+
+function updateOperations()
+{
+    for (var i = 1; i < OPS.length; i++)
+    {
+        var state = getOperationState(i);
+        if ((state == STATE_RUN) || (state == STATE_STOP))
+            processOperation(i);
+    }
+
+    setTimeout(updateOperations, PROCESS_DELAY);
+}
+
+function processOperation(op)
+{
+    var ops = getOperation(op);
+    if (ops.ignore)
+        return;
+
+    var dbg = "processOperation(" + ops.key + ")";
+    var opData = getOperationData(ops);
+
+    var fn = "processOp";
+    fn += ops.key[0].toUpperCase() + ops.key.substr(1);
+    if (opData.state == STATE_START)
+        fn += "Start";
+    else if (opData.state == STATE_RUN)
+        fn += "Run";
+    else if (opData.state == STATE_STOP)
+        fn += "Stop";
+    // assert and return if we're in a different state:
+    else if (!ASSERT(false, dbg + " invalid state: " + opData.state))
+        return;
+
+    try
+    {
+        var newState = window[fn](opData);
+        if (typeof newState != "undefined")
+            opData.state = newState;
+    }
+    catch(ex)
+    {
+        /* If an error has occurred, we display it (updateProgress) and then
+         * halt our operations to prevent further damage.
+         */
+        dd("Exception in channels.js: " + dbg + ": " + fn + ": " + formatException(ex));
+        updateProgress(formatException(ex));
+        opData.state = STATE_ERROR;
+    }
+}
+
+function stopOperation(op)
+{
+    var ops = getOperation(op);
+    if (ops.ignore)
+        return;
+
+    var dbg = "stopOperation(" + ops.key + ")";
+    var opData = getOperationData(ops);
+
+    // STATE_ERROR operations must not do anything. Assert and bail.
+    if (!ASSERT(opData.state != STATE_ERROR, dbg + " in STATE_ERROR"))
+        return;
+
+    // Nothing to do for STATE_IDLE. We shouldn't really be here, so assert.
+    if (!ASSERT(opData.state != STATE_IDLE, dbg + " in STATE_IDLE"))
+        return;
+
+    // Force the end and process synchronously.
+    opData.state = STATE_STOP;
+    processOperation(op);
+    ASSERT(opData.state == STATE_IDLE, dbg + " didn't enter STATE_IDLE");
+}
+
+// *****  END OPERATIONS CODE  *****
+
+
+// ***** BEGIN OPERATION HANDLERS *****
+
+function processOpListStart(opData)
+{
+    ASSERT(network, "No network");
+    ASSERT(network.isConnected(), "Network is disconnected");
+
+    // Updates the refresh button.
+    update();
+
+    // Show a general message until we get some data.
+    updateProgress(MSG_CD_FETCHING, -1);
+
+    // Get the file we're going to save to, and start the /list.
+    var file = getListFile();
+    network.list("", file.path);
+
+    return STATE_RUN;
+}
+
+function processOpListRun(opData)
+{
+    // Update the progress and end if /list done for "list only" state.
+    updateProgress(getMsg(MSG_CD_FETCHED, network._list.count), -1);
+
+    // Stop if the network's /list has finished.
+    return (network._list.done ? STATE_STOP : STATE_RUN);
+}
+
+function processOpListStop(opData)
+{
+    // Updates the refresh button.
+    update();
+
+    // Check that /list finished okay if we're just doing a list.
+    if ("error" in network._list)
+    {
+        updateProgress(MSG_CD_ERROR_LIST);
+    }
+    else
+    {
+        updateProgress();
+        if (getOperationState(OP_LOAD) == STATE_IDLE)
+            startOperation(OP_LOAD);
+    }
+
+    return STATE_IDLE;
+}
+
+function processOpLoadStart(opData)
+{
+    ASSERT(network, "No network");
+
+    // Nuke contents.
+    tree.view.selectedIndex = -1;
+    if (tree.view.childData.childData.length > 1)
+        tree.view.childData.removeChildrenAtIndex(1, tree.view.childData.childData.length - 1);
+
+    var file = getListFile();
+    if (!file.exists())
+    {
+        // We tried to do a load, but the file does not exist. Start a list to
+        // fill up the file.
+        startOperation(OP_LIST);
+
+        // File still doesn't exist, just give up.
+        if (!file.exists())
+            return STATE_IDLE;
+    }
+
+    // Nuke more stuff.
+    channels = new Array();
+
+    // And... here we go.
+    opData.loadFile = new LocalFile(file, "<");
+    opData.loadPendingData = "";
+    opData.loadChunk = 10000;
+    opData.loadedSoFar = 0;
+
+    return STATE_RUN;
+}
+
+function processOpLoadRun(opData)
+{
+    // All states before STATE_START are "not running" states.
+    var opListRunning = (getOperationState(OP_LIST) >= STATE_START);
+
+    var end = Number(new Date()) + PROCESS_TIME_MAX;
+    while (Number(new Date()) < end)
+    {
+        var nlIndex = opData.loadPendingData.indexOf("\n");
+        if (nlIndex == -1)
+        {
+            opData.loadedSoFar += opData.loadChunk;
+            var newChunk = opData.loadFile.read(opData.loadChunk);
+            if (newChunk)
+                opData.loadPendingData += newChunk;
+            nlIndex = opData.loadPendingData.indexOf("\n");
+            if (nlIndex == -1)
+                break;
+        }
+
+        var line = opData.loadPendingData.substr(0, nlIndex);
+        opData.loadPendingData = opData.loadPendingData.substr(nlIndex + 1);
+
+        line = toUnicode(line, "UTF-8");
+        var ary = line.match(/^([^ ]+) ([^ ]+) (.*)$/);
+        if (ary)
+        {
+            var chan = new ChannelEntry(ary[1], ary[2], ary[3]);
+            channels.push(chan);
+        }
+    }
+
+    var dataLeft = opData.loadFile.inputStream.available();
+
+    // We shouldn't update the display when listing as well, as we're not
+    // going to show anything useful (always 100% or near to it, and
+    // replaces the 'fetching' message).
+    if (!opListRunning)
+    {
+        var pro = opData.loadedSoFar / (opData.loadedSoFar + dataLeft);
+        pro = Math.round(100 * pro);
+        updateProgress(getMsg(MSG_CD_LOADED, channels.length), pro);
+    }
+
+    // Done if there is no more data, and we're not *expecting* any more.
+    if ((dataLeft == 0) && !opListRunning)
+        return STATE_STOP;
+
+    return STATE_RUN;
+}
+
+function processOpLoadStop(opData)
+{
+    if (channels.length > 0)
+        tree.view.childData.appendChildren(channels);
+    opData.loadFile.close();
+    delete opData.loadFile;
+    delete opData.loadPendingData;
+    delete opData.loadChunk;
+    delete opData.loadedSoFar;
+    delete opData.loadNeverComplete;
+    updateProgress();
+
+    startOperation(OP_FILTER);
+
+    return STATE_IDLE;
+}
+
+function processOpFilterStart(opData)
+{
+    // Catch filtering with the same options on the same channels:
+    var newOptions = {network: xul.network.value.toLowerCase(),
+                      text: xul.channel.value.toLowerCase(),
+                      min: xul.minUsers.value * 1,
+                      max: xul.maxUsers.value * 1,
+                      listLen: channels.length,
+                      searchTopics: xul.includeTopic.checked};
+
+    if (("filterOptions" in window) &&
+        equalsObject(window.filterOptions, newOptions))
+    {
+        return STATE_IDLE;
+    }
+
+    window.filterOptions = newOptions;
+
+    opData.text = newOptions.text;
+    opData.searchTopics = newOptions.searchTopics;
+    opData.minUsers = newOptions.min;
+    opData.maxUsers = newOptions.max;
+    opData.exactMatch = null;
+    opData.currentIndex = 0;
+    opData.channelText = opData.text;
+
+    // Log the filter, indicating which features the user is using.
+    var filters = new Array();
+    if (opData.channelText)
+        filters.push("name");
+    if (opData.searchTopics)
+        filters.push("topics");
+    if (opData.minUsers)
+        filters.push("min-users");
+    if (opData.maxUsers)
+        filters.push("max-users");
+
+    if (opData.channelText &&
+        (arrayIndexOf(["#", "&", "+", "!"], opData.channelText[0]) == -1))
+    {
+        opData.channelText = "#" + opData.channelText;
+    }
+    else
+    {
+        // Log that user has specified an explicit prefix.
+        filters.push("prefix");
+    }
+
+    // Update special "create channel" row, and select it.
+    tree.newItem.name = opData.channelText;
+    tree.newItem.unHide();
+
+    // Scroll to the top and select the "create channel" row.
+    tree.view.selectedIndex = 0;
+    xul.channels.treeBoxObject.invalidateRow(0);
+    xul.channels.treeBoxObject.scrollToRow(0);
+    ensureRowIsVisible();
+
+    updateProgress(getMsg(MSG_CD_FILTERING, [0, channels.length]), 0);
+
+    return STATE_RUN;
+}
+
+function processOpFilterRun(opData)
+{
+    var end = Number(new Date()) + PROCESS_TIME_MAX;
+    var more = false;
+
+    // Save selection because freeze/thaw screws it up.
+    // Note that we only save the item if it isn't the "create channel" row.
+    var index = tree.view.selectedIndex;
+    var item = null;
+    if (index > 0)
+        item = tree.view.childData.locateChildByVisualRow(index);
+
+    tree.view.freeze();
+    for (var i = opData.currentIndex; i < channels.length; i++)
+    {
+        var c = channels[i];
+
+        var match = (c.nameLC.indexOf(opData.text) != -1) ||
+                    (opData.searchTopics &&
+                     (c.topicLC.indexOf(opData.text) != -1));
+
+        if (opData.minUsers && (c.users < opData.minUsers))
+            match = false;
+        if (opData.maxUsers && (c.users > opData.maxUsers))
+            match = false;
+
+        if (match)
+            c.unHide();
+        else
+            c.hide();
+
+        if (match && (c.nameLC == opData.channelText))
+            opData.exactMatch = c;
+
+        opData.currentIndex = i;
+        if ((new Date()) > end)
+        {
+            more = true;
+            break;
+        }
+    }
+    tree.view.thaw();
+
+    // No item selected by user, so use our exact match instead.
+    if (!item && opData.exactMatch)
+        item = opData.exactMatch;
+
+    // Restore selected item.
+    if (item)
+        tree.view.selectedIndex = item.calculateVisualRow();
+    else
+        tree.view.selectedIndex = 0;
+
+    ensureRowIsVisible();
+
+    updateProgress(getMsg(MSG_CD_FILTERING,
+                          [opData.currentIndex, channels.length]),
+                   100 * opData.currentIndex / channels.length);
+
+    return (more ? STATE_RUN : STATE_STOP);
+}
+
+function processOpFilterStop(opData)
+{
+    if (opData.exactMatch)
+    {
+        tree.newItem.hide();
+    }
+    // If nothing is selected, select the "create channel" row.
+    else if (tree.view.selectedIndex < 0)
+    {
+        tree.view.selectedIndex = 0;
+    }
+
+    ensureRowIsVisible();
+
+    delete opData.text;
+    delete opData.searchTopics;
+    delete opData.minUsers;
+    delete opData.maxUsers;
+    delete opData.exactMatch;
+    delete opData.currentIndex;
+    delete opData.channelText;
+    updateProgress();
+
+    return STATE_IDLE;
+}
+
+
+// *****  END OPERATION HANDLERS  *****
+
+
+function ensureRowIsVisible()
+{
+    if (tree.view.selectedIndex >= 0)
+        xul.channels.treeBoxObject.ensureRowIsVisible(tree.view.selectedIndex);
+    else
+        xul.channels.treeBoxObject.ensureRowIsVisible(0);
+}
+
+function getListFile(temp)
+{
+    ASSERT(network, "No network");
+    var file = new LocalFile(network.prefs["logFileName"]);
+    if (temp)
+        file.localFile.leafName = "list.temp";
+    else
+        file.localFile.leafName = "list.txt";
+    return file.localFile;
+}
+
+
+// Tree ChannelEntry objects //
+function ChannelEntry(name, users, topic)
+{
+    this.setColumnPropertyName("chanColName", "name");
+    this.setColumnPropertyName("chanColUsers", "users");
+    this.setColumnPropertyName("chanColTopic", "topic");
+
+    // Nuke color codes and bold etc.
+    topic = topic.replace(/[\x1F\x02\x0F\x16]/g, "");
+    topic = topic.replace(/\x03\d{1,2}(?:,\d{1,2})?/g, "");
+
+    this.name  = name;
+    this.users = users;
+    this.topic = topic;
+
+    this.nameLC = this.name.toLowerCase();
+    this.topicLC = this.topic.toLowerCase();
+}
+
+ChannelEntry.prototype = new XULTreeViewRecord(tree.share);
+
+ChannelEntry.prototype.sortCompare =
+function chanentry_sortcmp(a, b)
+{
+    var sc = a._share.sortColumn;
+    var sd = a._share.sortDirection;
+
+    // Make sure the special 'first' row is always first.
+    if ("first" in a)
+        return -1;
+    if ("first" in b)
+        return 1;
+
+    if (sc == "users")
+    {
+        // Force a numeric comparison.
+        a = 1 * a[sc];
+        b = 1 * b[sc];
+    }
+    else
+    {
+        // Case-insensitive, please.
+        a = a[sc].toLowerCase();
+        b = b[sc].toLowerCase();
+    }
+
+    if (a < b)
+        return -1 * sd;
+
+    if (a > b)
+        return 1 * sd;
+
+    return 0;
+}