From 64b12db9907f714376450f32b1da27ece196b08b Mon Sep 17 00:00:00 2001
From: Kris Maglione <maglione.k@gmail.com>
Date: Sun, 23 Jan 2011 17:37:59 -0500
Subject: [PATCH 01/36] Begin replacing the key processing rat's nest.

--HG--
branch : key-processing
---
 common/content/commandline.js |   4 +-
 common/content/events.js      | 457 ++++++++++++++++++----------------
 common/content/mappings.js    |  18 +-
 common/content/modes.js       |  20 +-
 common/modules/base.jsm       |   2 +-
 5 files changed, 260 insertions(+), 241 deletions(-)

diff --git a/common/content/commandline.js b/common/content/commandline.js
index f1ec7d79..a838e4bd 100644
--- a/common/content/commandline.js
+++ b/common/content/commandline.js
@@ -1115,9 +1115,9 @@ var CommandLine = Module("commandline", {
             }
 
             // TODO: Wouldn't multiple handlers be cleaner? --djk
-            if (event.type == "click" && (event.target instanceof HTMLAnchorElement ||
-                                          event.originalTarget.hasAttributeNS(NS, "command"))) {
+            if (event.type == "click" && event.target instanceof HTMLAnchorElement) {
 
+                util.dump(event.getPreventDefault(), event.target);
                 if (event.getPreventDefault())
                     return;
 
diff --git a/common/content/events.js b/common/content/events.js
index 1784f64e..02a1b734 100644
--- a/common/content/events.js
+++ b/common/content/events.js
@@ -8,11 +8,219 @@
 
 /** @scope modules */
 
+var ProcessorStack = Class("ProcessorStack", {
+    init: function (mode, hives, keyModes) {
+        this.main = mode.main;
+        this.actions = [];
+        this.buffer = "";
+        this.events = [];
+
+        this.processors = keyModes.map(function (m) hives.map(function (h) KeyProcessor(m, h)))
+                                  .flatten().array;
+
+        for (let [i, input] in Iterator(this.processors)) {
+            let params = input.main == mode.main ? mode.params : input.main.params;
+            if (params.preExecute)
+                input.preExecute = params.preExecute;
+            if (params.postExecute)
+                input.postExecute = params.postExecute;
+            if (params.onEvent && input.hive === mappings.builtin)
+                input.fallthrough = function (event) {
+                    return params.onEvent(event) === false ? Events.KILL : Events.PASS;
+                };
+            }
+    },
+
+    process: function process(event) {
+        function dbg() {}
+
+        let key = events.toString(event);
+        this.events.push(event);
+
+        this.buffer += key;
+
+        let actions = [];
+        let processors = [];
+
+        dbg("\n\n");
+        dbg("KEY: " + key + " skipmap: " + event.skipmap + " macro: " + event.isMacro);
+
+        for (let [i, input] in Iterator(this.processors)) {
+            let res = input.process(event);
+            if (res !== Events.ABORT)
+                var result = res;
+
+            dbg("RES: " + input + " " + (callable(res) ? {}.toString.call(res) : res));
+
+            if (res === Events.KILL)
+                break;
+
+            buffer = buffer || input.inputBuffer;
+
+            if (callable(res))
+                actions.push(res);
+
+            if (isinstance(res, KeyProcessor))
+                processors.push(res);
+            if (res === Events.WAIT || input.waiting)
+                processors.push(input);
+        }
+
+        dbg("RESULT: " + (callable(result) ? {}.toString.call(result) : result) + " " + event.getPreventDefault());
+        dbg("ACTIONS: " + actions.length + " " + this.actions.length);
+        dbg("PROCESSORS:", processors);
+
+        if (!processors.some(function (p) p.main.ownsBuffer))
+            statusline.updateInputBuffer(processors.length ? this.buffer : "");
+
+        this.actions = actions.concat(this.actions);
+
+        if (result === Events.KILL)
+            this.actions = [];
+        else if (!this.actions.length)
+            for (let input in values(this.processors))
+                if (input.fallthrough) {
+                    if (result === Events.KILL)
+                        break;
+                    result = dactyl.trapErrors(input.fallthrough, input, event);
+                }
+
+        this.processors = processors;
+
+        if (processors.length)
+            result = Events.KILL;
+        else if (this.actions.length) {
+            if (actions.length == 0)
+                dactyl.beep();
+            result = this.actions[0]() === Events.PASS ? Events.PASS : Events.KILL;
+        }
+        else if (result !== Events.KILL && processors.some(function (p) !p.main.passUnknown)) {
+            result = Events.KILL;
+            dactyl.beep();
+        }
+        else if (result === undefined)
+            result = Events.PASS;
+
+        if (result !== Events.PASS)
+            Events.kill(event);
+
+        if (result === Events.PASS || result === Events.ABORT)
+            this.events.filter(function (e) e.getPreventDefault())
+                .forEach(function (event, i) {
+                    if (event.originalTarget) {
+                        let evt = events.create(event.originalTarget.ownerDocument, event.type, event);
+                        events.dispatch(event.originalTarget, evt, { skipmap: true, isMacro: true });
+                    }
+                    else if (i > 0)
+                        events.onKeyPress(event);
+                });
+        return this.processors.length == 0;
+    }
+});
+
+var KeyProcessor = Class("KeyProcessor", {
+    init: function init(main, hive) {
+        this.main = main;
+        this.events = [];
+        this.hive = hive;
+        this.wantCount = this.main.count;
+    },
+
+    get toStringParams() [this.main.name, this.hive.name],
+
+    countStr: "",
+    command: "",
+    get count() this.countStr ? Number(this.countStr) : null,
+
+    append: function append(event) {
+        this.events.push(event);
+        let key = events.toString(event);
+
+        if (this.wantCount && !this.command &&
+                (this.countStr ? /^[0-9]$/ : /^[1-9]$/).test(key))
+            this.countStr += key;
+        else
+            this.command += key;
+        return this.events;
+    },
+
+    process: function process(event) {
+        this.append(event);
+        this.waiting = false;
+        return this.onKeyPress(event);
+    },
+
+    execute: function execute(map)
+        let (self = this, args = arguments)
+            function execute() {
+                if (self.preExecute)
+                    self.preExecute.apply(self, args);
+                let res = map.execute.apply(map, Array.slice(args, 1));
+                if (self.postExecute)
+                    self.postExecute.apply(self, args);
+                return res;
+            },
+
+    onKeyPress: function onKeyPress(event) {
+        if (event.skipmap)
+            return Events.ABORT;
+
+        if (!this.command)
+            return Events.WAIT;
+
+        var map = this.hive.get(this.main, this.command);
+        this.waiting = this.hive.getCandidates(this.main, this.command);
+        if (map) {
+            if (map.arg)
+                return KeyArgProcessor(this, map, false, "arg");
+            else if (map.motion)
+                return KeyArgProcessor(this, map, true, "motion");
+            else if (modes.replaying && !events.waitForPageLoad())
+                return Events.KILL;
+
+            return this.execute(map, { count: this.count, command: this.command, events: this.events });
+        }
+
+        if (!this.waiting)
+            return this.main.input ? Events.PASS : Events.ABORT;
+
+        return Events.WAIT;
+    }
+});
+
+var KeyArgProcessor = Class("KeyArgProcessor", KeyProcessor, {
+    init: function init(input, map, wantCount, argName) {
+        init.supercall(this, input.main, input.hive);
+        this.map = map;
+        this.parent = input;
+        this.argName = argName;
+        this.wantCount = wantCount;
+    },
+
+    onKeyPress: function onKeyPress(event) {
+        if (Events.isEscape(event))
+            return Events.KILL;
+        if (!this.command)
+            return Events.WAIT;
+
+        let args = {
+            command: this.parent.command,
+            count:   this.count || this.parent.count,
+            events:  this.parent.events.concat(this.events)
+        };
+        args[this.argName] = this.command;
+
+        return this.execute(this.map, args);
+    }
+});
+
 /**
  * @instance events
  */
 var Events = Module("events", {
     init: function () {
+        const self = this;
+
         util.overlayWindow(window, {
             append: <e4x xmlns={XUL}>
                 <window id={document.documentElement.id}>
@@ -32,7 +240,6 @@ var Events = Module("events", {
         this._currentMacro = "";
         this._macroKeys = [];
         this._lastMacro = "";
-        this._processors = [];
 
         this.sessionListeners = [];
 
@@ -103,6 +310,10 @@ var Events = Module("events", {
         this.addSessionListener(window, "popuphidden", this.onPopupHidden, true);
         this.addSessionListener(window, "popupshown", this.onPopupShown, true);
         this.addSessionListener(window, "resize", this.onResize, true);
+
+        dactyl.registerObserver("modeChange", function () {
+            delete this.processor;
+        });
     },
 
     destroy: function () {
@@ -863,15 +1074,6 @@ var Events = Module("events", {
     onKeyPress: function onKeyPress(event) {
         event.dactylDefaultPrevented = event.getPreventDefault();
 
-        function kill(event) {
-            event.preventDefault();
-            event.stopPropagation();
-        }
-
-        function shouldPass()
-            (!dactyl.focusedElement || events.isContentNode(dactyl.focusedElement)) &&
-            options.get("passkeys").has(events.toString(event));
-
         let duringFeed = this.duringFeed || [];
         this.duringFeed = [];
         try {
@@ -906,16 +1108,14 @@ var Events = Module("events", {
                 else
                     duringFeed.push(event);
 
-                return kill(event);
+                return Events.kill(event);
             }
 
-            let mode = modes.getStack(0);
-            if (event.dactylMode)
-                mode = Modes.StackElement(event.dactylMode);
+            if (!this.processor) {
+                let mode = modes.getStack(0);
+                if (event.dactylMode)
+                    mode = Modes.StackElement(event.dactylMode);
 
-            let processors = this._processors;
-            this._processors = [];
-            if (!processors.length) {
                 let ignore = false;
                 let overrideMode = null;
 
@@ -930,7 +1130,7 @@ var Events = Module("events", {
                         mode.params.mainMode = modes.getStack(2).main;
                         ignore = Events.isEscape(key);
                     }
-                    else if (shouldPass())
+                    else if (events.shouldPass(event))
                         mode.params.mainMode = modes.getStack(1).main;
                     else
                         ignore = true;
@@ -938,7 +1138,7 @@ var Events = Module("events", {
                     if (ignore && !Events.isEscape(key))
                         modes.pop();
                 }
-                else if (!event.isMacro && !event.noremap && shouldPass())
+                else if (!event.isMacro && !event.noremap && events.shouldPass(event))
                     ignore = true;
 
                 if (ignore)
@@ -957,78 +1157,14 @@ var Events = Module("events", {
 
                 let hives = mappings.hives.slice(event.noremap ? -1 : 0);
 
-                processors = keyModes.map(function (m) hives.map(function (h) Events.KeyProcessor(m, h)))
-                                     .flatten().array;
-
-                for (let [i, input] in Iterator(processors)) {
-                    let params = input.main == mode.main ? mode.params : input.main.params;
-                    if (params.preExecute)
-                        input.preExecute = params.preExecute;
-                    if (params.postExecute)
-                        input.postExecute = params.postExecute;
-                    if (params.onEvent && input.hive === mappings.builtin)
-                        input.fallthrough = function (event) {
-                            return params.onEvent(event) === false ? Events.KILL : Events.PASS;
-                        };
-                    }
+                this.processor = ProcessorStack(mode, hives, keyModes);
             }
 
-            let refeed, buffer, waiting = 0, action;
-            for (let input in values(processors)) {
-                var res = input.process(event);
-                waiting += res == Events.WAIT;
-                buffer = buffer || input.inputBuffer;
-                if (callable(res))
-                    action = action || res;
+            let processor = this.processor;
+            this.processor = null;
+            if (!processor.process(event))
+                this.processor = processor;
 
-                if (isArray(res) && !waiting)
-                    refeed = res;
-                if (res === Events.KILL)
-                    break;
-            }
-
-            if (!refeed || refeed.length == 1)
-                for (let input in values(processors))
-                    if (input.fallthrough) {
-                        if (res === Events.KILL)
-                            break;
-                        res = dactyl.trapErrors(input.fallthrough, input, event);
-                    }
-
-            if (!processors.some(function (p) p.main.ownsBuffer))
-                statusline.updateInputBuffer(buffer);
-
-            if (waiting) {
-                res = Events.KILL;
-                this._processors = processors;
-            }
-            else if (action)
-                res = action(res) === Events.PASS ? Events.PASS : Events.KILL;
-
-            if (res !== Events.KILL && (mode.main & (modes.TEXT_EDIT | modes.VISUAL))) {
-                res = Events.KILL;
-                dactyl.beep();
-            }
-
-            if (res !== Events.PASS && !isArray(res))
-                refeed = null;
-
-            if (refeed && refeed[0] && (!refeed[0].getPreventDefault() || refeed[0].dactylDefaultPrevented)) {
-                res = Events.PASS;
-                refeed.shift();
-            }
-
-            if (res !== Events.PASS)
-                kill(event);
-
-            if (refeed)
-                for (let [i, event] in Iterator(refeed))
-                    if (event.originalTarget) {
-                        let evt = events.create(event.originalTarget.ownerDocument, event.type, event);
-                        events.dispatch(event.originalTarget, evt, { skipmap: true, isMacro: true });
-                    }
-                    else if (i > 0)
-                        events.onKeyPress(event);
         }
         catch (e) {
             dactyl.reportError(e);
@@ -1053,15 +1189,11 @@ var Events = Module("events", {
         // before we get a chance to process our key bindings on the
         // "keypress" event.
 
-        function shouldPass() // FIXME.
-            (!dactyl.focusedElement || events.isContentNode(dactyl.focusedElement)) &&
-            options.get("passkeys").has(events.toString(event));
-
         if (modes.main == modes.PASS_THROUGH ||
             modes.main == modes.QUOTE
                 && modes.getStack(1).main !== modes.PASS_THROUGH
-                && !shouldPass() ||
-            !modes.passThrough && shouldPass())
+                && !events.shouldPass(event) ||
+            !modes.passThrough && events.shouldPass(event))
             return;
 
         if (!Events.isInputElement(dactyl.focusedElement))
@@ -1110,137 +1242,17 @@ var Events = Module("events", {
             else if (modes.main == modes.CARET)
                 modes.push(modes.VISUAL);
         }
-    }
+    },
+
+    shouldPass: function shouldPass(event)
+        (!dactyl.focusedElement || events.isContentNode(dactyl.focusedElement)) &&
+        options.get("passkeys").has(events.toString(event))
 }, {
+    ABORT: {},
     KILL: true,
     PASS: false,
     WAIT: null,
 
-
-    KeyProcessor: Class("KeyProcessor", {
-        init: function init(main, hive) {
-            this.main = main;
-            this.events = [];
-            this.hive = hive;
-        },
-
-        get toStringParams() [this.main.name, this.hive.name],
-
-        buffer: "",             // partial command storage
-        pendingMotionMap: null, // e.g. "d{motion}" if we wait for a motion of the "d" command
-        pendingArgMap: null,    // pending map storage for commands like m{a-z}
-        count: null,            // parsed count from the input buffer
-        motionCount: null,
-
-        append: function append(event) {
-            this.events.push(event);
-            this.buffer += events.toString(event);
-            return this.events;
-        },
-
-        process: function process(event) {
-            function kill(event) {
-                event.stopPropagation();
-                event.preventDefault();
-            }
-
-            let res = this.onKeyPress(event);
-
-            if (res != Events.WAIT)
-                this.inputBuffer = "";
-            else {
-                let motionMap = (this.pendingMotionMap && this.pendingMotionMap.names[0]) || "";
-                this.inputBuffer = motionMap + this.buffer;
-            }
-
-            return res;
-        },
-
-        execute: function execute(map)
-            let (self = this, args = arguments)
-                function execute() {
-                    if (self.preExecute)
-                        self.preExecute.apply(self, args);
-                    let res = map.execute.apply(map, Array.slice(args, 1));
-                    if (self.postExecute) // To do: get rid of self.
-                        self.postExecute.apply(self, args);
-                    return res;
-                },
-
-        onKeyPress: function onKeyPress(event) {
-            // This all needs to go. It's horrible. --Kris
-
-            let key = events.toString(event);
-            let [, countStr, command] = /^((?:[1-9][0-9]*)?)(.*)/.exec(this.buffer + key);
-
-            var map = this.hive.get(this.main, command);
-
-            let candidates = this.hive.getCandidates(this.main, command);
-            if (candidates == 0 && !map) {
-                [map] = this.pendingMap || [];
-                this.pendingMap = null;
-                if (map && map.arg)
-                    this.pendingArgMap = [map, command];
-            }
-
-            // counts must be at the start of a complete mapping (10j -> go 10 lines down)
-            if (countStr && !command) {
-                // no count for insert mode mappings
-                if (!this.main.count)
-                    return this.append(event);
-                else if (this.main.input)
-                    return Events.PASS;
-                else
-                    this.append(event);
-            }
-            else if (this.pendingArgMap) {
-                let [map, command] = this.pendingArgMap;
-                if (!Events.isEscape(key))
-                    return this.execute(map, null, this.count, key, command);
-                return Events.KILL;
-            }
-            else if (!event.skipmap && map && candidates == 0) {
-                this.pendingMap = null;
-
-                let count = this.pendingMotionMap ? "motionCount" : "count";
-                this[count] = parseInt(countStr, 10);
-
-                if (isNaN(this[count]))
-                    this[count] = null;
-
-                if (map.arg) {
-                    this.append(event);
-                    this.pendingArgMap = [map, command];
-                }
-                else if (this.pendingMotionMap) {
-                    let [map, command] = this.pendingMotionMap;
-                    if (!Events.isEscape(key))
-                        return this.execute(map, command, this.motionCount || this.count, null, command);
-                    return Events.KILL;
-                }
-                else if (map.motion) {
-                    this.buffer = "";
-                    this.pendingMotionMap = [map, command];
-                }
-                else {
-                    if (modes.replaying && !events.waitForPageLoad())
-                        return Events.KILL;
-
-                    return this.execute(map, null, this.count, null, command);
-                }
-            }
-            else if (!event.skipmap && this.hive.getCandidates(this.main, command) > 0) {
-                this.append(event);
-                this.pendingMap = [map, command];
-            }
-            else {
-                this.append(event);
-                return this.events;
-            }
-            return Events.WAIT;
-        }
-    }),
-
     isEscape: function isEscape(event)
         let (key = isString(event) ? event : events.toString(event))
             key === "<Esc>" || key === "<C-[>",
@@ -1252,6 +1264,11 @@ var Events = Module("events", {
                                  HTMLTextAreaElement,
                                  Ci.nsIDOMXULTreeElement, Ci.nsIDOMXULTextBoxElement]) ||
                elem instanceof Window && Editor.getEditor(elem);
+    },
+
+    kill: function kill(event) {
+        event.stopPropagation();
+        event.preventDefault();
     }
 }, {
     commands: function () {
diff --git a/common/content/mappings.js b/common/content/mappings.js
index 124aab47..e9364c91 100644
--- a/common/content/mappings.js
+++ b/common/content/mappings.js
@@ -95,22 +95,20 @@ var Map = Class("Map", {
     /**
      * Execute the action for this mapping.
      *
-     * @param {string} motion The motion argument if accepted by this mapping.
-     *     E.g. "w" for "dw"
-     * @param {number} count The associated count. E.g. "5" for "5j"
-     * @default -1
-     * @param {string} argument The normal argument if accepted by this
-     *     mapping. E.g. "a" for "ma"
+     * @param {object} args The arguments object for the given mapping.
      */
-    execute: function (motion, count, argument, command) {
-        let args = { count: count, arg: argument, motion: motion, command: command };
+    execute: function (args) {
+        if (!isObject(args)) // Backwards compatibility :(
+            args = iter(["motion", "count", "arg", "command"])
+                .map(function ([i, prop]) [prop, this[i]], arguments)
+                .toObject()
 
         let self = this;
         function repeat() self.action(args)
         if (this.names[0] != ".") // FIXME: Kludge.
             mappings.repeat = repeat;
 
-        dactyl.assert(!this.executing, "Attempt to execute mapping recursively");
+        dactyl.assert(!this.executing, "Attempt to execute mapping recursively: " + args.command);
         this.executing = true;
         let res = dactyl.trapErrors(repeat);
         this.executing = false;
@@ -382,7 +380,7 @@ var Mappings = Module("mappings", {
      * @returns {Map}
      */
     get: function get(mode, cmd) {
-        return this.hives.nth(function (h) h.get(mode, command), 0);
+        return this.hives.nth(function (h) h.get(mode, cmd), 0);
     },
 
     /**
diff --git a/common/content/modes.js b/common/content/modes.js
index a32011af..023e9ca5 100644
--- a/common/content/modes.js
+++ b/common/content/modes.js
@@ -60,9 +60,10 @@ var Modes = Module("modes", {
         this.addMode("VISUAL", {
             char: "v",
             description: "Active when text is selected",
+            display: function () "VISUAL" + (this._extended & modes.LINE ? " LINE" : ""),
             bases: [this.COMMAND],
             ownsFocus: true,
-            display: function () "VISUAL" + (this._extended & modes.LINE ? " LINE" : "")
+            passUnknown: false
         }, {
             leave: function (stack, newMode) {
                 if (newMode.main == modes.CARET) {
@@ -98,7 +99,8 @@ var Modes = Module("modes", {
             char: "t",
             description: "Vim-like editing of input elements",
             bases: [this.COMMAND],
-            ownsFocus: true
+            ownsFocus: true,
+            passUnknown: false
         });
         this.addMode("OUTPUT_MULTILINE", {
             description: "Active when the multi-line output buffer is open",
@@ -432,11 +434,7 @@ var Modes = Module("modes", {
 
         get bases() this.input ? [modes.INPUT] : [modes.MAIN],
 
-        get toStringParams() [this.name],
-
-        valueOf: function () this.id,
-
-        count: true,
+        get count() !this.input,
 
         get description() this._display,
 
@@ -450,7 +448,13 @@ var Modes = Module("modes", {
 
         input: false,
 
-        get mask() this
+        passUnknown: false,
+
+        get mask() this,
+
+        get toStringParams() [this.name],
+
+        valueOf: function () this.id
     }, {
         _id: 0
     }),
diff --git a/common/modules/base.jsm b/common/modules/base.jsm
index 071688eb..caaab70b 100644
--- a/common/modules/base.jsm
+++ b/common/modules/base.jsm
@@ -427,7 +427,7 @@ function isinstance(object, interfaces) {
             if (objproto.toString.call(object) === "[object " + interfaces[i] + "]")
                 return true;
         }
-        else if ("isinstance" in object && object.isinstance !== isinstance) {
+        else if (typeof object === "object" && "isinstance" in object && object.isinstance !== isinstance) {
             if (object.isinstance(interfaces[i]))
                 return true;
         }

From e83708cea4c7c0519fb1891fade94b5bb03b8d53 Mon Sep 17 00:00:00 2001
From: Kris Maglione <maglione.k@gmail.com>
Date: Sun, 23 Jan 2011 18:11:45 -0500
Subject: [PATCH 02/36] Fix bug in last commit.

--HG--
branch : key-processing
---
 common/content/events.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/common/content/events.js b/common/content/events.js
index 02a1b734..a9994e9c 100644
--- a/common/content/events.js
+++ b/common/content/events.js
@@ -312,7 +312,7 @@ var Events = Module("events", {
         this.addSessionListener(window, "resize", this.onResize, true);
 
         dactyl.registerObserver("modeChange", function () {
-            delete this.processor;
+            delete self.processor;
         });
     },
 

From 2b6fdc861b38ef304c45267b6e03109fb73575b6 Mon Sep 17 00:00:00 2001
From: Kris Maglione <maglione.k@gmail.com>
Date: Sun, 23 Jan 2011 18:20:11 -0500
Subject: [PATCH 03/36] Fix arbitrary limit on the number of substrings to
 highlight in template.highlightSubstrings.

--HG--
branch : key-processing
---
 common/modules/template.jsm | 17 +++++++++--------
 1 file changed, 9 insertions(+), 8 deletions(-)

diff --git a/common/modules/template.jsm b/common/modules/template.jsm
index 1cd8764a..36847f6d 100644
--- a/common/modules/template.jsm
+++ b/common/modules/template.jsm
@@ -182,10 +182,12 @@ var Template = Module("Template", {
         str = String(str).replace(" ", "\u00a0");
         let s = <></>;
         let start = 0;
-        let n = 0;
+        let n = 0, _i;
         for (let [i, length, args] in iter) {
-            if (n++ > 50) // Prevent infinite loops.
+            if (i == _i || i < _i)
                 break;
+            _i = i;
+
             XML.ignoreWhitespace = false;
             s += <>{str.substring(start, i)}</>;
             s += highlight.apply(this, Array.concat(args || str.substr(i, length)));
@@ -227,14 +229,13 @@ var Template = Module("Template", {
 
     linkifyHelp: function linkifyHelp(str, help) {
         let re = util.regexp(<![CDATA[
-            ([/\s]|^)
-            ( '[\w-]+' | :(?:[\w-]+|!) | (?:._)?<[\w-]+> )
-            (?=[[!,;./\s]|$)
+            (?P<pre> [/\s]|^)
+            (?P<tag> '[\w-]+' | :(?:[\w-]+|!) | (?:._)?<[\w-]+> )
+            (?=      [[!,;./\s]|$)
         ]]>, "g");
         return this.highlightSubstrings(str, (function () {
-            let res;
-            while ((res = re.exec(str)) && res[2].length)
-                yield [res.index + res[1].length, res[2].length];
+            for (let res in re.iterate(str))
+                yield [res.index + res.pre.length, res.tag.length];
         })(), template[help ? "HelpLink" : "helpLink"]);
     },
 

From d7efe3374b6fd526d7799ce04aa29cdcad1a9a93 Mon Sep 17 00:00:00 2001
From: Kris Maglione <maglione.k@gmail.com>
Date: Sun, 23 Jan 2011 20:07:50 -0500
Subject: [PATCH 04/36] Fix error when closing last about:blank tab on FF36.
 Closes issue #299.

--HG--
branch : key-processing
---
 common/content/buffer.js      | 7 +------
 pentadactyl/content/config.js | 2 +-
 2 files changed, 2 insertions(+), 7 deletions(-)

diff --git a/common/content/buffer.js b/common/content/buffer.js
index 21008477..6a030a2b 100644
--- a/common/content/buffer.js
+++ b/common/content/buffer.js
@@ -425,12 +425,7 @@ var Buffer = Module("buffer", {
     /**
      * @property {string} The current top-level document's URL.
      */
-    get URL() {
-        let str = String(content.location.href);
-        for (let [k, v] in Iterator(util.newURI(content.location.href)))
-            str[k] = v;
-        return str;
-    },
+    get URL() update(content.location.href, util.newURI(content.location.href)),
 
     /**
      * @property {number} The buffer's height in pixels.
diff --git a/pentadactyl/content/config.js b/pentadactyl/content/config.js
index bed5b294..3c98bca7 100644
--- a/pentadactyl/content/config.js
+++ b/pentadactyl/content/config.js
@@ -85,7 +85,7 @@ var Config = Module("config", ConfigBase, {
             if (this.tabbrowser.mTabs.length > 1)
                 this.tabbrowser.removeTab(tab);
             else {
-                if (modules.buffer.URL != "about:blank" || window.getWebNavigation().sessionHistory.count > 0) {
+                if (modules.buffer.uri.spec !== "about:blank" || window.getWebNavigation().sessionHistory.count > 0) {
                     dactyl.open("about:blank", dactyl.NEW_BACKGROUND_TAB);
                     this.tabbrowser.removeTab(tab);
                 }

From 590e8d22b5ec3169006d6fed621b438a02983183 Mon Sep 17 00:00:00 2001
From: Kris Maglione <maglione.k@gmail.com>
Date: Sun, 23 Jan 2011 20:30:16 -0500
Subject: [PATCH 05/36] Muck with event listener registration.

--HG--
branch : key-processing
---
 common/content/events.js | 458 +++++++++++++++++++--------------------
 1 file changed, 227 insertions(+), 231 deletions(-)

diff --git a/common/content/events.js b/common/content/events.js
index a9994e9c..186464aa 100644
--- a/common/content/events.js
+++ b/common/content/events.js
@@ -112,7 +112,7 @@ var ProcessorStack = Class("ProcessorStack", {
                         events.dispatch(event.originalTarget, evt, { skipmap: true, isMacro: true });
                     }
                     else if (i > 0)
-                        events.onKeyPress(event);
+                        events.events.keypress.call(events, event);
                 });
         return this.processors.length == 0;
     }
@@ -299,17 +299,8 @@ var Events = Module("events", {
         }
 
         this._activeMenubar = false;
-        this.addSessionListener(window, "DOMMenuBarActive", this.onDOMMenuBarActive, true);
-        this.addSessionListener(window, "DOMMenuBarInactive", this.onDOMMenuBarInactive, true);
-        this.addSessionListener(window, "blur", this.onBlur, true);
-        this.addSessionListener(window, "focus", this.onFocus, true);
-        this.addSessionListener(window, "keydown", this.onKeyUpOrDown, true);
-        this.addSessionListener(window, "keypress", this.onKeyPress, true);
-        this.addSessionListener(window, "keyup", this.onKeyUpOrDown, true);
-        this.addSessionListener(window, "mousedown", this.onMouseDown, true);
-        this.addSessionListener(window, "popuphidden", this.onPopupHidden, true);
-        this.addSessionListener(window, "popupshown", this.onPopupShown, true);
-        this.addSessionListener(window, "resize", this.onResize, true);
+        for (let [event, callback] in Iterator(this.events))
+            this.addSessionListener(window, event, callback, true);
 
         dactyl.registerObserver("modeChange", function () {
             delete self.processor;
@@ -507,7 +498,7 @@ var Events = Module("events", {
                     if (!evt_obj.dactylString && !evt_obj.dactylShift && !mode)
                         events.dispatch(dactyl.focusedElement || buffer.focusedFrame, event, evt);
                     else
-                        events.onKeyPress(event);
+                        events.events.keypress.call(events, event);
                 }
 
                 if (!this.feedingKeys)
@@ -908,16 +899,6 @@ var Events = Module("events", {
         return buffer.loaded;
     },
 
-    onDOMMenuBarActive: function () {
-        this._activeMenubar = true;
-        modes.add(modes.MENU);
-    },
-
-    onDOMMenuBarInactive: function () {
-        this._activeMenubar = false;
-        modes.remove(modes.MENU);
-    },
-
     /**
      * Ensures that the currently focused element is visible and blurs
      * it if it's not.
@@ -934,65 +915,240 @@ var Events = Module("events", {
         }
     },
 
-    onBlur: function onFocus(event) {
-        if (event.originalTarget instanceof Window && services.focus.activeWindow == null) {
-            // Deals with circumstances where, after the main window
-            // blurs while a collapsed frame has focus, re-activating
-            // the main window does not restore focus and we lose key
-            // input.
-            services.focus.clearFocus(window);
-            document.commandDispatcher.focusedWindow = content;
-        }
-    },
+    events: {
+        DOMMenuBarActive: function () {
+            this._activeMenubar = true;
+            modes.add(modes.MENU);
+        },
 
-    // TODO: Merge with onFocusChange
-    onFocus: function onFocus(event) {
-        let elem = event.originalTarget;
-        if (elem instanceof Element) {
+        DOMMenuBarInactive: function () {
+            this._activeMenubar = false;
+            modes.remove(modes.MENU);
+        },
+
+        blur: function onBlur(event) {
+            if (event.originalTarget instanceof Window && services.focus.activeWindow == null) {
+                // Deals with circumstances where, after the main window
+                // blurs while a collapsed frame has focus, re-activating
+                // the main window does not restore focus and we lose key
+                // input.
+                services.focus.clearFocus(window);
+                document.commandDispatcher.focusedWindow = content;
+            }
+        },
+
+        // TODO: Merge with onFocusChange
+        focus: function onFocus(event) {
+            let elem = event.originalTarget;
+            if (elem instanceof Element) {
+                let win = elem.ownerDocument.defaultView;
+
+                if (event.target instanceof Ci.nsIDOMXULTextBoxElement)
+                    for (let e = elem; e instanceof Element; e = e.parentNode)
+                        if (util.computedStyle(e).visibility !== "visible") {
+                            elem.blur();
+                            break;
+                        }
+
+                if (events.isContentNode(elem) && !buffer.focusAllowed(elem)
+                    && !(services.focus.getLastFocusMethod(win) & 0x7000)
+                    && isinstance(elem, [HTMLInputElement, HTMLSelectElement, HTMLTextAreaElement, Window])) {
+                    if (elem.frameElement)
+                        dactyl.focusContent(true);
+                    else if (!(elem instanceof Window) || Editor.getEditor(elem))
+                        elem.blur();
+                }
+            }
+        },
+
+        /*
+        onFocus: function onFocus(event) {
+            let elem = event.originalTarget;
+            if (!(elem instanceof Element))
+                return;
             let win = elem.ownerDocument.defaultView;
 
-            if (event.target instanceof Ci.nsIDOMXULTextBoxElement)
-                for (let e = elem; e instanceof Element; e = e.parentNode)
-                    if (util.computedStyle(e).visibility !== "visible") {
+            try {
+                util.dump(elem, services.focus.getLastFocusMethod(win) & (0x7000));
+                if (buffer.focusAllowed(win))
+                    win.dactylLastFocus = elem;
+                else if (isinstance(elem, [HTMLInputElement, HTMLSelectElement, HTMLTextAreaElement])) {
+                    if (win.dactylLastFocus)
+                        dactyl.focus(win.dactylLastFocus);
+                    else
                         elem.blur();
-                        break;
+                }
+            }
+            catch (e) {
+                util.dump(win, String(elem.ownerDocument), String(elem.ownerDocument && elem.ownerDocument.defaultView));
+                util.reportError(e);
+            }
+        },
+        */
+
+        // this keypress handler gets always called first, even if e.g.
+        // the command-line has focus
+        // TODO: ...help me...please...
+        keypress: function onKeyPress(event) {
+            event.dactylDefaultPrevented = event.getPreventDefault();
+
+            let duringFeed = this.duringFeed || [];
+            this.duringFeed = [];
+            try {
+                if (this.feedingEvent && [!(k in event) || event[k] === v for ([k, v] in Iterator(this.feedingEvent))].every(util.identity)) {
+                    for (let [k, v] in Iterator(this.feedingEvent))
+                        if (!(k in event))
+                            event[k] = v;
+                    this.feedingEvent = null;
+                }
+
+                let key = events.toString(event);
+                if (!key)
+                     return null;
+
+                if (modes.recording && (!this._input || !mappings.user.hasMap(modes.main, this._input.buffer + key)))
+                    events._macroKeys.push(key);
+
+                // feedingKeys needs to be separate from interrupted so
+                // we can differentiate between a recorded <C-c>
+                // interrupting whatever it's started and a real <C-c>
+                // interrupting our playback.
+                if (events.feedingKeys && !event.isMacro) {
+                    if (!event.originalTarget)
+                        util.dumpStack();
+                    if (key == "<C-c>") {
+                        events.feedingKeys = false;
+                        if (modes.replaying) {
+                            modes.replaying = false;
+                            this.timeout(function () { dactyl.echomsg("Canceled playback of macro '" + this._lastMacro + "'"); }, 100);
+                        }
                     }
+                    else
+                        duringFeed.push(event);
+
+                    return Events.kill(event);
+                }
+
+                if (!this.processor) {
+                    let mode = modes.getStack(0);
+                    if (event.dactylMode)
+                        mode = Modes.StackElement(event.dactylMode);
+
+                    let ignore = false;
+                    let overrideMode = null;
+
+                    // menus have their own command handlers
+                    if (modes.extended & modes.MENU)
+                        overrideMode = modes.MENU;
+
+                    if (modes.main == modes.PASS_THROUGH)
+                        ignore = !Events.isEscape(key) && key != "<C-v>";
+                    else if (modes.main == modes.QUOTE) {
+                        if (modes.getStack(1).main == modes.PASS_THROUGH) {
+                            mode.params.mainMode = modes.getStack(2).main;
+                            ignore = Events.isEscape(key);
+                        }
+                        else if (events.shouldPass(event))
+                            mode.params.mainMode = modes.getStack(1).main;
+                        else
+                            ignore = true;
+
+                        if (ignore && !Events.isEscape(key))
+                            modes.pop();
+                    }
+                    else if (!event.isMacro && !event.noremap && events.shouldPass(event))
+                        ignore = true;
+
+                    if (ignore)
+                        return null;
+
+                    if (key == "<C-c>")
+                        util.interrupted = true;
+
+                    if (config.ignoreKeys[key] & mode.main)
+                        return null;
+
+                    if (overrideMode)
+                        var keyModes = array([overrideMode]);
+                    else
+                        keyModes = array([mode.params.keyModes, mode.main, mode.main.allBases]).flatten().compact();
+
+                    let hives = mappings.hives.slice(event.noremap ? -1 : 0);
+
+                    this.processor = ProcessorStack(mode, hives, keyModes);
+                }
+
+                let processor = this.processor;
+                this.processor = null;
+                if (!processor.process(event))
+                    this.processor = processor;
 
-            if (events.isContentNode(elem) && !buffer.focusAllowed(elem)
-                && !(services.focus.getLastFocusMethod(win) & 0x7000)
-                && isinstance(elem, [HTMLInputElement, HTMLSelectElement, HTMLTextAreaElement, Window])) {
-                if (elem.frameElement)
-                    dactyl.focusContent(true);
-                else if (!(elem instanceof Window) || Editor.getEditor(elem))
-                    elem.blur();
             }
-        }
-    },
-
-    /*
-    onFocus: function onFocus(event) {
-        let elem = event.originalTarget;
-        if (!(elem instanceof Element))
-            return;
-        let win = elem.ownerDocument.defaultView;
-
-        try {
-            util.dump(elem, services.focus.getLastFocusMethod(win) & (0x7000));
-            if (buffer.focusAllowed(win))
-                win.dactylLastFocus = elem;
-            else if (isinstance(elem, [HTMLInputElement, HTMLSelectElement, HTMLTextAreaElement])) {
-                if (win.dactylLastFocus)
-                    dactyl.focus(win.dactylLastFocus);
+            catch (e) {
+                dactyl.reportError(e);
+            }
+            finally {
+                [duringFeed, this.duringFeed] = [this.duringFeed, duringFeed];
+                if (this.feedingKeys)
+                    this.duringFeed = this.duringFeed.concat(duringFeed);
                 else
-                    elem.blur();
+                    for (let event in values(duringFeed))
+                        try {
+                            this.dispatch(event.originalTarget, event, event);
+                        }
+                        catch (e) {
+                            util.reportError(e);
+                        }
+            }
+        },
+
+        keyup: function onKeyUp(event) {
+            // Prevent certain sites from transferring focus to an input box
+            // before we get a chance to process our key bindings on the
+            // "keypress" event.
+
+            if (modes.main == modes.PASS_THROUGH ||
+                modes.main == modes.QUOTE
+                    && modes.getStack(1).main !== modes.PASS_THROUGH
+                    && !events.shouldPass(event) ||
+                !modes.passThrough && events.shouldPass(event))
+                return;
+
+            if (!Events.isInputElement(dactyl.focusedElement))
+                event.stopPropagation();
+        },
+        keydown: function onKeyDown(event) {
+            this.events.keyup.call(this, event);
+        },
+
+        mousedown: function onMouseDown(event) {
+            let elem = event.target;
+            let win = elem.ownerDocument && elem.ownerDocument.defaultView || elem;
+
+            for (; win; win = win != win.parent && win.parent)
+                win.document.dactylFocusAllowed = true;
+        },
+
+        popupshown: function onPopupShown(event) {
+            if (event.originalTarget.localName !== "tooltip" && event.originalTarget.id !== "dactyl-visualbell")
+                modes.add(modes.MENU);
+        },
+
+        popuphidden: function onPopupHidden() {
+            // gContextMenu is set to NULL, when a context menu is closed
+            if (window.gContextMenu == null && !this._activeMenubar)
+                modes.remove(modes.MENU);
+        },
+
+        resize: function onResize(event) {
+            if (window.fullScreen != this._fullscreen) {
+                statusline.statusBar.removeAttribute("moz-collapsed");
+                this._fullscreen = window.fullScreen;
+                dactyl.triggerObserver("fullscreen", this._fullscreen);
+                autocommands.trigger("Fullscreen", { url: this._fullscreen ? "on" : "off", state: this._fullscreen });
             }
         }
-        catch (e) {
-            util.dump(win, String(elem.ownerDocument), String(elem.ownerDocument && elem.ownerDocument.defaultView));
-            util.reportError(e);
-        }
     },
-    */
 
     // argument "event" is deliberately not used, as i don't seem to have
     // access to the real focus target
@@ -1068,166 +1224,6 @@ var Events = Module("events", {
         }
     },
 
-    // this keypress handler gets always called first, even if e.g.
-    // the command-line has focus
-    // TODO: ...help me...please...
-    onKeyPress: function onKeyPress(event) {
-        event.dactylDefaultPrevented = event.getPreventDefault();
-
-        let duringFeed = this.duringFeed || [];
-        this.duringFeed = [];
-        try {
-            if (this.feedingEvent && [!(k in event) || event[k] === v for ([k, v] in Iterator(this.feedingEvent))].every(util.identity)) {
-                for (let [k, v] in Iterator(this.feedingEvent))
-                    if (!(k in event))
-                        event[k] = v;
-                this.feedingEvent = null;
-            }
-
-            let key = events.toString(event);
-            if (!key)
-                 return null;
-
-            if (modes.recording && (!this._input || !mappings.user.hasMap(modes.main, this._input.buffer + key)))
-                events._macroKeys.push(key);
-
-            // feedingKeys needs to be separate from interrupted so
-            // we can differentiate between a recorded <C-c>
-            // interrupting whatever it's started and a real <C-c>
-            // interrupting our playback.
-            if (events.feedingKeys && !event.isMacro) {
-                if (!event.originalTarget)
-                    util.dumpStack();
-                if (key == "<C-c>") {
-                    events.feedingKeys = false;
-                    if (modes.replaying) {
-                        modes.replaying = false;
-                        this.timeout(function () { dactyl.echomsg("Canceled playback of macro '" + this._lastMacro + "'"); }, 100);
-                    }
-                }
-                else
-                    duringFeed.push(event);
-
-                return Events.kill(event);
-            }
-
-            if (!this.processor) {
-                let mode = modes.getStack(0);
-                if (event.dactylMode)
-                    mode = Modes.StackElement(event.dactylMode);
-
-                let ignore = false;
-                let overrideMode = null;
-
-                // menus have their own command handlers
-                if (modes.extended & modes.MENU)
-                    overrideMode = modes.MENU;
-
-                if (modes.main == modes.PASS_THROUGH)
-                    ignore = !Events.isEscape(key) && key != "<C-v>";
-                else if (modes.main == modes.QUOTE) {
-                    if (modes.getStack(1).main == modes.PASS_THROUGH) {
-                        mode.params.mainMode = modes.getStack(2).main;
-                        ignore = Events.isEscape(key);
-                    }
-                    else if (events.shouldPass(event))
-                        mode.params.mainMode = modes.getStack(1).main;
-                    else
-                        ignore = true;
-
-                    if (ignore && !Events.isEscape(key))
-                        modes.pop();
-                }
-                else if (!event.isMacro && !event.noremap && events.shouldPass(event))
-                    ignore = true;
-
-                if (ignore)
-                    return null;
-
-                if (key == "<C-c>")
-                    util.interrupted = true;
-
-                if (config.ignoreKeys[key] & mode.main)
-                    return null;
-
-                if (overrideMode)
-                    var keyModes = array([overrideMode]);
-                else
-                    keyModes = array([mode.params.keyModes, mode.main, mode.main.allBases]).flatten().compact();
-
-                let hives = mappings.hives.slice(event.noremap ? -1 : 0);
-
-                this.processor = ProcessorStack(mode, hives, keyModes);
-            }
-
-            let processor = this.processor;
-            this.processor = null;
-            if (!processor.process(event))
-                this.processor = processor;
-
-        }
-        catch (e) {
-            dactyl.reportError(e);
-        }
-        finally {
-            [duringFeed, this.duringFeed] = [this.duringFeed, duringFeed];
-            if (this.feedingKeys)
-                this.duringFeed = this.duringFeed.concat(duringFeed);
-            else
-                for (let event in values(duringFeed))
-                    try {
-                        this.dispatch(event.originalTarget, event, event);
-                    }
-                    catch (e) {
-                        util.reportError(e);
-                    }
-        }
-    },
-
-    onKeyUpOrDown: function onKeyUpOrDown(event) {
-        // Prevent certain sites from transferring focus to an input box
-        // before we get a chance to process our key bindings on the
-        // "keypress" event.
-
-        if (modes.main == modes.PASS_THROUGH ||
-            modes.main == modes.QUOTE
-                && modes.getStack(1).main !== modes.PASS_THROUGH
-                && !events.shouldPass(event) ||
-            !modes.passThrough && events.shouldPass(event))
-            return;
-
-        if (!Events.isInputElement(dactyl.focusedElement))
-            event.stopPropagation();
-    },
-
-    onMouseDown: function onMouseDown(event) {
-        let elem = event.target;
-        let win = elem.ownerDocument && elem.ownerDocument.defaultView || elem;
-
-        for (; win; win = win != win.parent && win.parent)
-            win.document.dactylFocusAllowed = true;
-    },
-
-    onPopupShown: function onPopupShown(event) {
-        if (event.originalTarget.localName !== "tooltip" && event.originalTarget.id !== "dactyl-visualbell")
-            modes.add(modes.MENU);
-    },
-
-    onPopupHidden: function onPopupHidden() {
-        // gContextMenu is set to NULL, when a context menu is closed
-        if (window.gContextMenu == null && !this._activeMenubar)
-            modes.remove(modes.MENU);
-    },
-
-    onResize: function onResize(event) {
-        if (window.fullScreen != this._fullscreen) {
-            statusline.statusBar.removeAttribute("moz-collapsed");
-            this._fullscreen = window.fullScreen;
-            dactyl.triggerObserver("fullscreen", this._fullscreen);
-            autocommands.trigger("Fullscreen", { url: this._fullscreen ? "on" : "off", state: this._fullscreen });
-        }
-    },
-
     onSelectionChange: function onSelectionChange(event) {
         let controller = document.commandDispatcher.getControllerForCommand("cmd_copy");
         let couldCopy = controller && controller.isCommandEnabled("cmd_copy");

From 8ae02f49520c4c8df1e36577a4506dffa6a39462 Mon Sep 17 00:00:00 2001
From: Kris Maglione <maglione.k@gmail.com>
Date: Sun, 23 Jan 2011 21:55:49 -0500
Subject: [PATCH 06/36] Cleanup the hints.js rat's nest a bit.

--HG--
branch : key-processing
---
 common/content/hints.js | 870 +++++++++++++++++++---------------------
 common/modules/base.jsm |   4 +-
 2 files changed, 424 insertions(+), 450 deletions(-)

diff --git a/common/content/hints.js b/common/content/hints.js
index cdece8bc..6951d778 100644
--- a/common/content/hints.js
+++ b/common/content/hints.js
@@ -9,177 +9,102 @@
 /** @scope modules */
 /** @instance hints */
 
-var Hints = Module("hints", {
-    init: function init() {
-        const self = this;
+var HintSession = Class("HintSession", {
+    init: function init(mode, opts) {
+        opts = opts || {};
 
-        this._hintMode = null;
-        this._submode = "";             // used for extended mode, can be "o", "t", "y", etc.
-        this._hintString = "";          // the typed string part of the hint is in this string
-        this._hintNumber = 0;           // only the numerical part of the hint
-        this._usedTabKey = false;       // when we used <Tab> to select an element
-        this.prevInput = "";            // record previous user input type, "text" || "number"
-        this._extendedhintCount = null; // for the count argument of Mode#action (extended hint only)
+        // Hack.
+        if (!opts.window && modes.main == modes.OUTPUT_MULTILINE)
+            opts.window = commandline.widgets.multilineOutput.contentWindow;
 
-        this._pageHints = [];
-        this._validHints = []; // store the indices of the "hints" array with valid elements
+        this.mode = hints.modes[mode];
+        dactyl.assert(this.mode);
 
-        this._activeTimeout = null; // needed for hinttimeout > 0
+        this.activeTimeout = null; // needed for hinttimeout > 0
+        this.continue = Boolean(opts.continue);
+        this.docs = [];
+        this.hintKeys = events.fromString(options["hintkeys"]).map(events.closure.toString);
+        this.hintNumber = 0;
+        this.hintString = opts.filter || "";
+        this.pageHints = [];
+        this.prevInput = "";
+        this.usedTabKey = false;
+        this.validHints = []; // store the indices of the "hints" array with valid elements
 
-        // keep track of the documents which we generated the hints for
-        // this._docs = { doc: document, start: start_index in hints[], end: end_index in hints[] }
-        this._docs = [];
+        commandline.input(UTF8(this.mode.prompt) + ": ", null, this);
+        modes.extended = modes.HINTS;
 
-        this._resizeTimer = Timer(100, 500, function () {
-            if (self._top && (modes.extended & modes.HINTS)) {
-                self._removeHints(0, true);
-                self._generate(self._top);
-                self._showHints();
-            }
-        });
-        let appContent = document.getElementById("appcontent");
-        if (appContent)
-            events.addSessionListener(appContent, "scroll", this._resizeTimer.closure.tell, false);
+        this.top = opts.window || content;
+        this.top.addEventListener("resize", hints.resizeTimer.closure.tell, true);
 
-        const Mode = Hints.Mode;
-        Mode.defaultValue("tags", function () function () options["hinttags"]);
-        Mode.prototype.__defineGetter__("xpath", function ()
-            options.get("extendedhinttags").getKey(this.name, this.tags()));
+        this.generate();
 
-        this._hintModes = {};
-        this.addMode(";", "Focus hint",                           buffer.closure.focusElement);
-        this.addMode("?", "Show information for hint",            function (elem) buffer.showElementInfo(elem));
-        this.addMode("s", "Save hint",                            function (elem) buffer.saveLink(elem, false));
-        this.addMode("f", "Focus frame",                          function (elem) dactyl.focus(elem.ownerDocument.defaultView));
-        this.addMode("F", "Focus frame or pseudo-frame",          buffer.closure.focusElement, null, isScrollable);
-        this.addMode("o", "Follow hint",                          function (elem) buffer.followLink(elem, dactyl.CURRENT_TAB));
-        this.addMode("t", "Follow hint in a new tab",             function (elem) buffer.followLink(elem, dactyl.NEW_TAB));
-        this.addMode("b", "Follow hint in a background tab",      function (elem) buffer.followLink(elem, dactyl.NEW_BACKGROUND_TAB));
-        this.addMode("w", "Follow hint in a new window",          function (elem) buffer.followLink(elem, dactyl.NEW_WINDOW));
-        this.addMode("O", "Generate an ‘:open URL’ prompt",       function (elem, loc) commandline.open(":", "open " + loc, modes.EX));
-        this.addMode("T", "Generate a ‘:tabopen URL’ prompt",     function (elem, loc) commandline.open(":", "tabopen " + loc, modes.EX));
-        this.addMode("W", "Generate a ‘:winopen URL’ prompt",     function (elem, loc) commandline.open(":", "winopen " + loc, modes.EX));
-        this.addMode("a", "Add a bookmark",                       function (elem) bookmarks.addSearchKeyword(elem));
-        this.addMode("S", "Add a search keyword",                 function (elem) bookmarks.addSearchKeyword(elem));
-        this.addMode("v", "View hint source",                     function (elem, loc) buffer.viewSource(loc, false));
-        this.addMode("V", "View hint source in external editor",  function (elem, loc) buffer.viewSource(loc, true));
-        this.addMode("y", "Yank hint location",                   function (elem, loc) dactyl.clipboardWrite(loc, true));
-        this.addMode("Y", "Yank hint description",                function (elem) dactyl.clipboardWrite(elem.textContent || "", true));
-        this.addMode("c", "Open context menu",                    function (elem) buffer.openContextMenu(elem));
-        this.addMode("i", "Show image",                           function (elem) dactyl.open(elem.src));
-        this.addMode("I", "Show image in a new tab",              function (elem) dactyl.open(elem.src, dactyl.NEW_TAB));
+        this.show();
 
-        function isScrollable(elem) isinstance(elem, [HTMLFrameElement, HTMLIFrameElement]) ||
-            Buffer.isScrollable(elem, 0, true) || Buffer.isScrollable(elem, 0, false);
+        if (this.validHints.length == 0) {
+            dactyl.beep();
+            modes.pop();
+        }
+        else if (this.validHints.length == 1 && !this.continue)
+            this.process(false);
+        else // Ticket #185
+            this.checkUnique();
+    },
+
+    get extended() modes.HINTS,
+
+    checkUnique: function _checkUnique() {
+        if (this.hintNumber == 0)
+            return;
+        dactyl.assert(this.hintNumber <= this.validHints.length);
+
+        // if we write a numeric part like 3, but we have 45 hints, only follow
+        // the hint after a timeout, as the user might have wanted to follow link 34
+        if (this.hintNumber > 0 && this.hintNumber * this.hintKeys.length <= this.validHints.length) {
+            let timeout = options["hinttimeout"];
+            if (timeout > 0)
+                this.activeTimeout = this.timeout(function () {
+                    this.process(true);
+                }, timeout);
+        }
+        else // we have a unique hint
+            this.process(true);
     },
 
     /**
      * Clear any timeout which might be active after pressing a number
      */
     clearTimeout: function () {
-        if (this._activeTimeout)
-            this._activeTimeout.cancel();
-        this._activeTimeout = null;
+        if (this.activeTimeout)
+            this.activeTimeout.cancel();
+        this.activeTimeout = null;
     },
 
     /**
-     * Reset hints, so that they can be cleanly used again.
+     * Returns the hint string for a given number based on the values of
+     * the 'hintkeys' option.
+     *
+     * @param {number} n The number to transform.
+     * @returns {string}
      */
-    _reset: function _reset(slight) {
-        if (!slight) {
-            this.__reset();
-            this.prevInput = "";
-            this.escNumbers = false;
-            this._usedTabKey = false;
-            this._hintNumber = 0;
-            this._hintString = "";
-            statusline.updateInputBuffer("");
-            commandline.widgets.command = "";
+    getHintString: function getHintString(n) {
+        let res = [], len = this.hintKeys.length;
+        do {
+            res.push(this.hintKeys[n % len]);
+            n = Math.floor(n / len);
         }
-        this._pageHints = [];
-        this._validHints = [];
-        this._docs = [];
-        this.clearTimeout();
-    },
-    __reset: function __reset() {
-        if (!this._usedTabKey)
-            this._hintNumber = 0;
-        if (this._continue && this._validHints.length <= 1) {
-            this._hintString = "";
-            commandline.widgets.command = this._hintString;
-            this._showHints();
-        }
-        this._updateStatusline();
+        while (n > 0);
+        return res.reverse().join("");
     },
 
     /**
-     * Display the current status to the user.
+     * Returns true if the given key string represents a
+     * pseudo-hint-number.
+     *
+     * @param {string} key The key to test.
+     * @returns {boolean} Whether the key represents a hint number.
      */
-    _updateStatusline: function _updateStatusline() {
-        statusline.updateInputBuffer((hints.escNumbers ? options["mapleader"] : "") +
-                                     (this._hintNumber ? this.getHintString(this._hintNumber) : ""));
-    },
-
-    /**
-     * Get a hint for "input", "textarea" and "select".
-     *
-     * Tries to use <label>s if possible but does not try to guess that a
-     * neighboring element might look like a label. Only called by
-     * {@link #_generate}.
-     *
-     * If it finds a hint it returns it, if the hint is not the caption of the
-     * element it will return showText=true.
-     *
-     * @param {Object} elem The element used to generate hint text.
-     * @param {Document} doc The containing document.
-     *
-     * @returns [text, showText]
-     */
-    _getInputHint: function _getInputHint(elem, doc) {
-        // <input type="submit|button|reset"/>   Always use the value
-        // <input type="radio|checkbox"/>        Use the value if it is not numeric or label or name
-        // <input type="password"/>              Never use the value, use label or name
-        // <input type="text|file"/> <textarea/> Use value if set or label or name
-        // <input type="image"/>                 Use the alt text if present (showText) or label or name
-        // <input type="hidden"/>                Never gets here
-        // <select/>                             Use the text of the selected item or label or name
-
-        let type = elem.type;
-
-        if (elem instanceof HTMLInputElement && set.has(util.editableInputs, elem.type))
-            return [elem.value, false];
-        else {
-            for (let [, option] in Iterator(options["hintinputs"])) {
-                if (option == "value") {
-                    if (elem instanceof HTMLSelectElement) {
-                        if (elem.selectedIndex >= 0)
-                            return [elem.item(elem.selectedIndex).text.toLowerCase(), false];
-                    }
-                    else if (type == "image") {
-                        if (elem.alt)
-                            return [elem.alt.toLowerCase(), true];
-                    }
-                    else if (elem.value && type != "password") {
-                        // radio's and checkboxes often use internal ids as values - maybe make this an option too...
-                        if (! ((type == "radio" || type == "checkbox") && !isNaN(elem.value)))
-                            return [elem.value.toLowerCase(), (type == "radio" || type == "checkbox")];
-                    }
-                }
-                else if (option == "label") {
-                    if (elem.id) {
-                        // TODO: (possibly) do some guess work for label-like objects
-                        let label = util.evaluateXPath(["label[@for=" + elem.id.quote() + "]"], doc).snapshotItem(0);
-                        if (label)
-                            return [label.textContent.toLowerCase(), true];
-                    }
-                }
-                else if (option == "name")
-                    return [elem.name.toLowerCase(), true];
-            }
-        }
-
-        return ["", false];
-    },
+    isHintKey: function isHintKey(key) this.hintKeys.indexOf(key) >= 0,
 
     /**
      * Gets the actual offset of an imagemap area.
@@ -191,7 +116,7 @@ var Hints = Module("hints", {
      * @param {number} topPos The top offset of the image.
      * @returns [leftPos, topPos] The updated offsets.
      */
-    _getAreaOffset: function _getAreaOffset(elem, leftPos, topPos) {
+    getAreaOffset: function _getAreaOffset(elem, leftPos, topPos) {
         try {
             // Need to add the offset to the area element.
             // Always try to find the top-left point, as per dactyl default.
@@ -245,7 +170,7 @@ var Hints = Module("hints", {
     },
 
     // the containing block offsets with respect to the viewport
-    _getContainerOffsets: function _getContainerOffsets(doc) {
+    getContainerOffsets: function _getContainerOffsets(doc) {
         let body = doc.body || doc.documentElement;
         // TODO: getComputedStyle returns null for Facebook channel_iframe doc - probable Gecko bug.
         let style = util.computedStyle(body);
@@ -266,13 +191,13 @@ var Hints = Module("hints", {
      * @param {Window} win The window for which to generate hints.
      * @default content
      */
-    _generate: function _generate(win, offsets) {
+    generate: function _generate(win, offsets) {
         if (!win)
-            win = this._top;
+            win = this.top;
 
         let doc = win.document;
 
-        let [offsetX, offsetY] = this._getContainerOffsets(doc);
+        let [offsetX, offsetY] = this.getContainerOffsets(doc);
 
         offsets = offsets || { left: 0, right: 0, top: 0, bottom: 0 };
         offsets.right  = win.innerWidth  - offsets.right;
@@ -300,10 +225,10 @@ var Hints = Module("hints", {
 
             let baseNodeAbsolute = util.xmlToDom(<span highlight="Hint" style="display: none"/>, doc);
 
-            let mode = this._hintMode;
+            let mode = this.mode;
             let res = util.evaluateXPath(mode.xpath, doc, true);
 
-            let start = this._pageHints.length;
+            let start = this.pageHints.length;
             for (let elem in res) {
                 let hint = { elem: elem, showText: false };
 
@@ -313,7 +238,7 @@ var Hints = Module("hints", {
                 if (elem.hasAttributeNS(NS, "hint"))
                     [hint.text, hint.showText] = [elem.getAttributeNS(NS, "hint"), true];
                 else if (isinstance(elem, [HTMLInputElement, HTMLSelectElement, HTMLTextAreaElement]))
-                    [hint.text, hint.showText] = this._getInputHint(elem, doc);
+                    [hint.text, hint.showText] = hints.getInputHint(elem, doc);
                 else if (elem.firstElementChild instanceof HTMLImageElement && /^\s*$/.test(elem.textContent))
                     [hint.text, hint.showText] = [elem.firstElementChild.alt || elem.firstElementChild.title, true];
                 else
@@ -326,22 +251,22 @@ var Hints = Module("hints", {
                 let topPos  = Math.max((rect.top + offsetY), offsetY);
 
                 if (elem instanceof HTMLAreaElement)
-                    [leftPos, topPos] = this._getAreaOffset(elem, leftPos, topPos);
+                    [leftPos, topPos] = this.getAreaOffset(elem, leftPos, topPos);
 
                 hint.span.style.left = leftPos + "px";
                 hint.span.style.top =  topPos + "px";
                 container.appendChild(hint.span);
 
-                this._pageHints.push(hint);
+                this.pageHints.push(hint);
             }
 
-            this._docs.push({ doc: doc, start: start, end: this._pageHints.length - 1 });
+            this.docs.push({ doc: doc, start: start, end: this.pageHints.length - 1 });
         }
 
         Array.forEach(win.frames, function (f) {
             if (isVisible(f.frameElement)) {
                 let rect = f.frameElement.getBoundingClientRect();
-                this._generate(f, {
+                this.generate(f, {
                     left: Math.max(offsets.left - rect.left, 0),
                     right: Math.max(rect.right - offsets.right, 0),
                     top: Math.max(offsets.top - rect.top, 0),
@@ -353,26 +278,189 @@ var Hints = Module("hints", {
         return true;
     },
 
+    leave: function leave(stack) {
+        if (!stack.push) {
+            if (hints.hintSession == this)
+                hints.hintSession = null;
+            this.continue = false;
+            if (this.top)
+                this.top.removeEventListener("resize", hints.resizeTimer.closure.tell, true);
+
+            this.removeHints(0);
+        }
+    },
+
     /**
-     * Update the activeHint.
+     * Handle user input.
      *
-     * By default highlights it green instead of yellow.
+     * Will update the filter on displayed hints and follow the final hint if
+     * necessary.
      *
-     * @param {number} newId The hint to make active.
-     * @param {number} oldId The currently active hint.
+     * @param {Event} event The keypress event.
      */
-    _showActiveHint: function _showActiveHint(newId, oldId) {
-        let oldHint = this._validHints[oldId - 1];
-        if (oldHint) {
-            this._setClass(oldHint.elem, false);
-            oldHint.span.removeAttribute("active");
+    onChange: function onInput(event) {
+        this.prevInput = "text";
+
+        this.clearTimeout();
+
+        this.hintNumber = 0;
+        this.hintString = commandline.command;
+        this.updateStatusline();
+        this.show();
+        if (this.validHints.length == 1)
+            this.process(false);
+    },
+
+    /**
+     * Handle a hint mode event.
+     *
+     * @param {Event} event The event to handle.
+     */
+    onEvent: function onEvent(event) {
+        const KILL = false, PASS = true;
+        let key = events.toString(event);
+
+        this.clearTimeout();
+
+        if (!this.escNumbers && this.isHintKey(key)) {
+            this.prevInput = "number";
+
+            let oldHintNumber = this.hintNumber;
+            if (this.usedTabKey) {
+                this.hintNumber = 0;
+                this.usedTabKey = false;
+            }
+            this.hintNumber = this.hintNumber * this.hintKeys.length +
+                this.hintKeys.indexOf(key);
+
+            this.updateStatusline();
+
+            if (this.docs.length == 0) {
+                this.generate();
+                this.show();
+            }
+            this.showActiveHint(this.hintNumber, oldHintNumber || 1);
+
+            dactyl.assert(this.hintNumber != 0);
+
+            this.checkUnique();
+            return KILL;
         }
 
-        let newHint = this._validHints[newId - 1];
-        if (newHint) {
-            this._setClass(newHint.elem, true);
-            newHint.span.setAttribute("active", "true");
+        return PASS;
+    },
+
+    onResize: function () {
+        this.removeHints(0);
+        this.generate(this.top);
+        this.show();
+    },
+
+    /**
+     * Finish hinting.
+     *
+     * Called when there are one or zero hints in order to possibly activate it
+     * and, if activated, to clean up the rest of the hinting system.
+     *
+     * @param {boolean} followFirst Whether to force the following of the first
+     *     link (when 'followhints' is 1 or 2)
+     *
+     */
+    process: function _processHints(followFirst) {
+        dactyl.assert(this.validHints.length > 0);
+
+        // This "followhints" option is *too* confusing. For me, and
+        // presumably for users, too. --Kris
+        if (options["followhints"] > 0) {
+            if (!followFirst)
+                return; // no return hit; don't examine uniqueness
+
+            // OK. return hit. But there's more than one hint, and
+            // there's no tab-selected current link. Do not follow in mode 2
+            dactyl.assert(options["followhints"] != 2 || this.validHints.length == 1 || this.hintNumber);
         }
+
+        if (!followFirst) {
+            let firstHref = this.validHints[0].elem.getAttribute("href") || null;
+            if (firstHref) {
+                if (this.validHints.some(function (h) h.elem.getAttribute("href") != firstHref))
+                    return;
+            }
+            else if (this.validHints.length > 1)
+                return;
+        }
+
+        let timeout = followFirst || events.feedingKeys ? 0 : 500;
+        let activeIndex = (this.hintNumber ? this.hintNumber - 1 : 0);
+        let elem = this.validHints[activeIndex].elem;
+        let top = this.top;
+
+        if (this.continue)
+            this._reset();
+        else
+            this.removeHints(timeout);
+
+        let n = 5;
+        (function next() {
+            let hinted = n || this.validHints.some(function (h) h.elem === elem);
+            this.setClass(elem, n ? n % 2 : !hinted ? null : this.validHints[Math.max(0, this.hintNumber-1)].elem === elem);
+            if (n--)
+                this.timeout(next, 50);
+        }).call(this);
+
+        if (!this.continue) {
+            modes.pop();
+            if (timeout)
+                modes.push(modes.IGNORE, modes.HINTS);
+        }
+
+        this.timeout(function () {
+            if ((modes.extended & modes.HINTS) && !this.continue)
+                modes.pop();
+            commandline.lastEcho = null; // Hack.
+            dactyl.trapErrors(this.mode.action, this.mode,
+                              elem, elem.href || elem.src || "",
+                              this.extendedhintCount, top);
+            if (this.continue && this.top)
+                this.show();
+        }, timeout);
+    },
+
+    /**
+     * Remove all hints from the document, and reset the completions.
+     *
+     * Lingers on the active hint briefly to confirm the selection to the user.
+     *
+     * @param {number} timeout The number of milliseconds before the active
+     *     hint disappears.
+     */
+    removeHints: function _removeHints(timeout) {
+        for (let { doc, start, end } in values(this.docs)) {
+            for (let elem in util.evaluateXPath("//*[@dactyl:highlight='hints']", doc))
+                elem.parentNode.removeChild(elem);
+            for (let i in util.range(start, end + 1))
+                this.setClass(this.pageHints[i].elem, null);
+        }
+        styles.system.remove("hint-positions");
+
+        this.reset();
+    },
+
+    reset: function reset() {
+        this.pageHints = [];
+        this.validHints = [];
+        this.docs = [];
+        this.clearTimeout();
+    },
+    _reset: function _reset() {
+        if (!this.usedTabKey)
+            this.hintNumber = 0;
+        if (this.continue && this.validHints.length <= 1) {
+            this.hintString = "";
+            commandline.widgets.command = this.hintString;
+            this.show();
+        }
+        this.updateStatusline();
     },
 
     /**
@@ -381,7 +469,7 @@ var Hints = Module("hints", {
      * @param {Object} elem The element to toggle.
      * @param {boolean} active Whether it is the currently active hint or not.
      */
-    _setClass: function _setClass(elem, active) {
+    setClass: function _setClass(elem, active) {
         if (elem.dactylHighlight == null)
             elem.dactylHighlight = elem.getAttributeNS(NS, "highlight") || "";
 
@@ -400,18 +488,18 @@ var Hints = Module("hints", {
     /**
      * Display the hints in pageHints that are still valid.
      */
-    _showHints: function _showHints() {
+    show: function _show() {
         let hintnum = 1;
-        let validHint = this._hintMatcher(this._hintString.toLowerCase());
-        let activeHint = this._hintNumber || 1;
-        this._validHints = [];
+        let validHint = hints.hintMatcher(this.hintString.toLowerCase());
+        let activeHint = this.hintNumber || 1;
+        this.validHints = [];
 
-        for (let { doc, start, end } in values(this._docs)) {
-            let [offsetX, offsetY] = this._getContainerOffsets(doc);
+        for (let { doc, start, end } in values(this.docs)) {
+            let [offsetX, offsetY] = this.getContainerOffsets(doc);
 
         inner:
             for (let i in (util.interruptibleRange(start, end + 1, 500))) {
-                let hint = this._pageHints[i];
+                let hint = this.pageHints[i];
 
                 let valid = validHint(hint.text);
                 hint.span.style.display = (valid ? "" : "none");
@@ -419,7 +507,7 @@ var Hints = Module("hints", {
                     hint.imgSpan.style.display = (valid ? "" : "none");
 
                 if (!valid) {
-                    this._setClass(hint.elem, null);
+                    this.setClass(hint.elem, null);
                     continue inner;
                 }
 
@@ -437,7 +525,7 @@ var Hints = Module("hints", {
                         hint.imgSpan.style.height = (rect.bottom - rect.top) + "px";
                         hint.span.parentNode.appendChild(hint.imgSpan);
                     }
-                    this._setClass(hint.imgSpan, activeHint == hintnum);
+                    this.setClass(hint.imgSpan, activeHint == hintnum);
                 }
 
                 let str = this.getHintString(hintnum);
@@ -455,15 +543,15 @@ var Hints = Module("hints", {
                 if (hint.imgSpan)
                     hint.imgSpan.setAttribute("number", str);
                 else
-                    this._setClass(hint.elem, activeHint == hintnum);
-                this._validHints.push(hint);
+                    this.setClass(hint.elem, activeHint == hintnum);
+                this.validHints.push(hint);
                 hintnum++;
             }
         }
 
         if (options["usermode"]) {
             let css = [];
-            for (let hint in values(this._pageHints)) {
+            for (let hint in values(this.pageHints)) {
                 let selector = highlight.selector("Hint") + "[number=" + hint.span.getAttribute("number").quote() + "]";
                 let imgSpan = "[dactyl|hl=HintImage]";
                 css.push(selector + ":not(" + imgSpan + ") { " + hint.span.style.cssText + " }");
@@ -477,132 +565,157 @@ var Hints = Module("hints", {
     },
 
     /**
-     * Remove all hints from the document, and reset the completions.
+     * Update the activeHint.
      *
-     * Lingers on the active hint briefly to confirm the selection to the user.
+     * By default highlights it green instead of yellow.
      *
-     * @param {number} timeout The number of milliseconds before the active
-     *     hint disappears.
+     * @param {number} newId The hint to make active.
+     * @param {number} oldId The currently active hint.
      */
-    _removeHints: function _removeHints(timeout, slight) {
-        for (let { doc, start, end } in values(this._docs)) {
-            for (let elem in util.evaluateXPath("//*[@dactyl:highlight='hints']", doc))
-                elem.parentNode.removeChild(elem);
-            for (let i in util.range(start, end + 1))
-                this._setClass(this._pageHints[i].elem, null);
+    showActiveHint: function _showActiveHint(newId, oldId) {
+        let oldHint = this.validHints[oldId - 1];
+        if (oldHint) {
+            this.setClass(oldHint.elem, false);
+            oldHint.span.removeAttribute("active");
         }
-        styles.system.remove("hint-positions");
 
-        this._reset(slight);
+        let newHint = this.validHints[newId - 1];
+        if (newHint) {
+            this.setClass(newHint.elem, true);
+            newHint.span.setAttribute("active", "true");
+        }
     },
 
     /**
-     * Finish hinting.
-     *
-     * Called when there are one or zero hints in order to possibly activate it
-     * and, if activated, to clean up the rest of the hinting system.
-     *
-     * @param {boolean} followFirst Whether to force the following of the first
-     *     link (when 'followhints' is 1 or 2)
-     *
+     * Display the current status to the user.
      */
-    _processHints: function _processHints(followFirst) {
-        dactyl.assert(this._validHints.length > 0);
+    updateStatusline: function _updateStatusline() {
+        statusline.updateInputBuffer((hints.escNumbers ? options["mapleader"] : "") +
+                                     (this.hintNumber ? this.getHintString(this.hintNumber) : ""));
+    },
+});
 
-        // This "followhints" option is *too* confusing. For me, and
-        // presumably for users, too. --Kris
-        if (options["followhints"] > 0) {
-            if (!followFirst)
-                return; // no return hit; don't examine uniqueness
+var Hints = Module("hints", {
+    init: function init() {
+        this.resizeTimer = Timer(100, 500, function () {
+            if (modes.extended & modes.HINTS)
+                modes.getStack(0).params.onResize();
+        });
+        let appContent = document.getElementById("appcontent");
+        if (appContent)
+            events.addSessionListener(appContent, "scroll", this.resizeTimer.closure.tell, false);
 
-            // OK. return hit. But there's more than one hint, and
-            // there's no tab-selected current link. Do not follow in mode 2
-            dactyl.assert(options["followhints"] != 2 || this._validHints.length == 1 || this._hintNumber);
-        }
+        const Mode = Hints.Mode;
+        Mode.defaultValue("tags", function () function () options["hinttags"]);
+        Mode.prototype.__defineGetter__("xpath", function ()
+            options.get("extendedhinttags").getKey(this.name, this.tags()));
 
-        if (!followFirst) {
-            let firstHref = this._validHints[0].elem.getAttribute("href") || null;
-            if (firstHref) {
-                if (this._validHints.some(function (h) h.elem.getAttribute("href") != firstHref))
-                    return;
+        this.modes = {};
+        this.addMode(";", "Focus hint",                           buffer.closure.focusElement);
+        this.addMode("?", "Show information for hint",            function (elem) buffer.showElementInfo(elem));
+        this.addMode("s", "Save hint",                            function (elem) buffer.saveLink(elem, false));
+        this.addMode("f", "Focus frame",                          function (elem) dactyl.focus(elem.ownerDocument.defaultView));
+        this.addMode("F", "Focus frame or pseudo-frame",          buffer.closure.focusElement, null, isScrollable);
+        this.addMode("o", "Follow hint",                          function (elem) buffer.followLink(elem, dactyl.CURRENT_TAB));
+        this.addMode("t", "Follow hint in a new tab",             function (elem) buffer.followLink(elem, dactyl.NEW_TAB));
+        this.addMode("b", "Follow hint in a background tab",      function (elem) buffer.followLink(elem, dactyl.NEW_BACKGROUND_TAB));
+        this.addMode("w", "Follow hint in a new window",          function (elem) buffer.followLink(elem, dactyl.NEW_WINDOW));
+        this.addMode("O", "Generate an ‘:open URL’ prompt",       function (elem, loc) commandline.open(":", "open " + loc, modes.EX));
+        this.addMode("T", "Generate a ‘:tabopen URL’ prompt",     function (elem, loc) commandline.open(":", "tabopen " + loc, modes.EX));
+        this.addMode("W", "Generate a ‘:winopen URL’ prompt",     function (elem, loc) commandline.open(":", "winopen " + loc, modes.EX));
+        this.addMode("a", "Add a bookmark",                       function (elem) bookmarks.addSearchKeyword(elem));
+        this.addMode("S", "Add a search keyword",                 function (elem) bookmarks.addSearchKeyword(elem));
+        this.addMode("v", "View hint source",                     function (elem, loc) buffer.viewSource(loc, false));
+        this.addMode("V", "View hint source in external editor",  function (elem, loc) buffer.viewSource(loc, true));
+        this.addMode("y", "Yank hint location",                   function (elem, loc) dactyl.clipboardWrite(loc, true));
+        this.addMode("Y", "Yank hint description",                function (elem) dactyl.clipboardWrite(elem.textContent || "", true));
+        this.addMode("c", "Open context menu",                    function (elem) buffer.openContextMenu(elem));
+        this.addMode("i", "Show image",                           function (elem) dactyl.open(elem.src));
+        this.addMode("I", "Show image in a new tab",              function (elem) dactyl.open(elem.src, dactyl.NEW_TAB));
+
+        function isScrollable(elem) isinstance(elem, [HTMLFrameElement, HTMLIFrameElement]) ||
+            Buffer.isScrollable(elem, 0, true) || Buffer.isScrollable(elem, 0, false);
+    },
+
+    hintSession: Modes.boundProperty(),
+
+    /**
+     * Creates a new hint mode.
+     *
+     * @param {string} mode The letter that identifies this mode.
+     * @param {string} prompt The description to display to the user
+     *     about this mode.
+     * @param {function(Node)} action The function to be called with the
+     *     element that matches.
+     * @param {function():string} tags The function that returns an
+     *     XPath expression to decide which elements can be hinted (the
+     *     default returns options["hinttags"]).
+     * @optional
+     */
+    addMode: function (mode, prompt, action, tags) {
+        arguments[1] = UTF8(prompt);
+        this.modes[mode] = Hints.Mode.apply(Hints.Mode, arguments);
+    },
+
+    /**
+     * Get a hint for "input", "textarea" and "select".
+     *
+     * Tries to use <label>s if possible but does not try to guess that a
+     * neighboring element might look like a label. Only called by
+     * {@link #_generate}.
+     *
+     * If it finds a hint it returns it, if the hint is not the caption of the
+     * element it will return showText=true.
+     *
+     * @param {Object} elem The element used to generate hint text.
+     * @param {Document} doc The containing document.
+     *
+     * @returns [text, showText]
+     */
+    getInputHint: function _getInputHint(elem, doc) {
+        // <input type="submit|button|reset"/>   Always use the value
+        // <input type="radio|checkbox"/>        Use the value if it is not numeric or label or name
+        // <input type="password"/>              Never use the value, use label or name
+        // <input type="text|file"/> <textarea/> Use value if set or label or name
+        // <input type="image"/>                 Use the alt text if present (showText) or label or name
+        // <input type="hidden"/>                Never gets here
+        // <select/>                             Use the text of the selected item or label or name
+
+        let type = elem.type;
+
+        if (elem instanceof HTMLInputElement && set.has(util.editableInputs, elem.type))
+            return [elem.value, false];
+        else {
+            for (let [, option] in Iterator(options["hintinputs"])) {
+                if (option == "value") {
+                    if (elem instanceof HTMLSelectElement) {
+                        if (elem.selectedIndex >= 0)
+                            return [elem.item(elem.selectedIndex).text.toLowerCase(), false];
+                    }
+                    else if (type == "image") {
+                        if (elem.alt)
+                            return [elem.alt.toLowerCase(), true];
+                    }
+                    else if (elem.value && type != "password") {
+                        // radio's and checkboxes often use internal ids as values - maybe make this an option too...
+                        if (! ((type == "radio" || type == "checkbox") && !isNaN(elem.value)))
+                            return [elem.value.toLowerCase(), (type == "radio" || type == "checkbox")];
+                    }
+                }
+                else if (option == "label") {
+                    if (elem.id) {
+                        // TODO: (possibly) do some guess work for label-like objects
+                        let label = util.evaluateXPath(["label[@for=" + elem.id.quote() + "]"], doc).snapshotItem(0);
+                        if (label)
+                            return [label.textContent.toLowerCase(), true];
+                    }
+                }
+                else if (option == "name")
+                    return [elem.name.toLowerCase(), true];
             }
-            else if (this._validHints.length > 1)
-                return;
         }
 
-        let timeout = followFirst || events.feedingKeys ? 0 : 500;
-        let activeIndex = (this._hintNumber ? this._hintNumber - 1 : 0);
-        let elem = this._validHints[activeIndex].elem;
-        let top = this._top;
-
-        if (this._continue)
-            this.__reset();
-        else
-            this._removeHints(timeout);
-
-        let n = 5;
-        (function next() {
-            let hinted = n || this._validHints.some(function (h) h.elem === elem);
-            this._setClass(elem, n ? n % 2 : !hinted ? null : this._validHints[Math.max(0, this._hintNumber-1)].elem === elem);
-            if (n--)
-                this.timeout(next, 50);
-        }).call(this);
-
-        if (!this._continue) {
-            modes.pop();
-            if (timeout)
-                modes.push(modes.IGNORE, modes.HINTS);
-        }
-
-        this.timeout(function () {
-            if ((modes.extended & modes.HINTS) && !this._continue)
-                modes.pop();
-            commandline._lastEcho = null; // Hack.
-            dactyl.trapErrors(this._hintMode.action, this._hintMode,
-                              elem, elem.href || elem.src || "",
-                              this._extendedhintCount, top);
-            if (this._continue && this._top)
-                this._showHints();
-        }, timeout);
-    },
-
-    _checkUnique: function _checkUnique() {
-        if (this._hintNumber == 0)
-            return;
-        dactyl.assert(this._hintNumber <= this._validHints.length);
-
-        // if we write a numeric part like 3, but we have 45 hints, only follow
-        // the hint after a timeout, as the user might have wanted to follow link 34
-        if (this._hintNumber > 0 && this._hintNumber * this.hintKeys.length <= this._validHints.length) {
-            let timeout = options["hinttimeout"];
-            if (timeout > 0)
-                this._activeTimeout = this.timeout(function () {
-                    this._processHints(true);
-                }, timeout);
-        }
-        else // we have a unique hint
-            this._processHints(true);
-    },
-
-    /**
-     * Handle user input.
-     *
-     * Will update the filter on displayed hints and follow the final hint if
-     * necessary.
-     *
-     * @param {Event} event The keypress event.
-     */
-    _onInput: function _onInput(event) {
-        this.prevInput = "text";
-
-        this.clearTimeout();
-
-        this._hintNumber = 0;
-        this._hintString = commandline.command;
-        this._updateStatusline();
-        this._showHints();
-        if (this._validHints.length == 1)
-            this._processHints(false);
+        return ["", false];
     },
 
     /**
@@ -611,7 +724,7 @@ var Hints = Module("hints", {
      * @param {string} hintString The currently typed hint.
      * @returns {hintMatcher}
      */
-    _hintMatcher: function _hintMatcher(hintString) { //{{{
+    hintMatcher: function _hintMatcher(hintString) { //{{{
         /**
          * Divide a string by a regular expression.
          *
@@ -776,167 +889,28 @@ var Hints = Module("hints", {
         return null;
     }, //}}}
 
-    /**
-     * Creates a new hint mode.
-     *
-     * @param {string} mode The letter that identifies this mode.
-     * @param {string} prompt The description to display to the user
-     *     about this mode.
-     * @param {function(Node)} action The function to be called with the
-     *     element that matches.
-     * @param {function():string} tags The function that returns an
-     *     XPath expression to decide which elements can be hinted (the
-     *     default returns options["hinttags"]).
-     * @optional
-     */
-    addMode: function (mode, prompt, action, tags) {
-        arguments[1] = UTF8(prompt);
-        this._hintModes[mode] = Hints.Mode.apply(Hints.Mode, arguments);
-    },
-
-    /**
-     * Returns the hint string for a given number based on the values of
-     * the 'hintkeys' option.
-     *
-     * @param {number} n The number to transform.
-     * @returns {string}
-     */
-    getHintString: function getHintString(n) {
-        let res = [], len = this.hintKeys.length;
-        do {
-            res.push(this.hintKeys[n % len]);
-            n = Math.floor(n / len);
-        }
-        while (n > 0);
-        return res.reverse().join("");
-    },
-
-    /**
-     * Returns true if the given key string represents a
-     * pseudo-hint-number.
-     *
-     * @param {string} key The key to test.
-     * @returns {boolean} Whether the key represents a hint number.
-     */
-    isHintKey: function isHintKey(key) this.hintKeys.indexOf(key) >= 0,
-
     open: function open(mode, opts) {
         this._extendedhintCount = opts.count;
         commandline.input(mode, null, {
-            promptHighlight: "Normal",
             completer: function (context) {
                 context.compare = function () 0;
-                context.completions = [[k, v.prompt] for ([k, v] in Iterator(hints._hintModes))];
+                context.completions = [[k, v.prompt] for ([k, v] in Iterator(hints.modes))];
+            },
+            onAccept: function (arg) {
+                if (arg)
+                    util.timeout(function () {
+                        dactyl.trapErrors(hints.show, hints, arg, opts);
+                    });
             },
-            onAccept: function (arg) { arg && util.timeout(function () dactyl.trapErrors(hints.show, hints, arg, opts), 0); },
             get onCancel() this.onAccept,
-            onChange: function () { modes.pop(); }
+            onChange: function () { modes.pop(); },
+            promptHighlight: "Normal"
         });
     },
 
-    /**
-     * Updates the display of hints.
-     *
-     * @param {string} minor Which hint mode to use.
-     * @param {Object} opts Extra options.
-     */
-    show: function show(minor, opts) {
-        opts = opts || {};
-
-        // Hack.
-        if (!opts.window && modes.main == modes.OUTPUT_MULTILINE)
-            opts.window = commandline.widgets.multilineOutput.contentWindow;
-
-        this._hintMode = this._hintModes[minor];
-        dactyl.assert(this._hintMode);
-
-        commandline.input(UTF8(this._hintMode.prompt) + ": ", null, {
-            extended: modes.HINTS,
-            leave: function (stack) {
-                if (!stack.push)
-                    hints.hide();
-            },
-            onChange: this.closure._onInput,
-            onEvent: this.closure.onEvent
-        });
-        modes.extended = modes.HINTS;
-
-        this.hintKeys = events.fromString(options["hintkeys"]).map(events.closure.toString);
-        this._submode = minor;
-        this._hintString = opts.filter || "";
-        this._hintNumber = 0;
-        this._usedTabKey = false;
-        this.prevInput = "";
-        this._continue = Boolean(opts.continue);
-
-        this._top = opts.window || content;
-        this._top.addEventListener("resize", this._resizeTimer.closure.tell, true);
-
-        this._generate();
-
-        this._showHints();
-
-        if (this._validHints.length == 0) {
-            dactyl.beep();
-            modes.pop();
-        }
-        else if (this._validHints.length == 1 && !this._continue)
-            this._processHints(false);
-        else // Ticket #185
-            this._checkUnique();
-    },
-
-    /**
-     * Cancel all hinting.
-     */
-    hide: function hide() {
-        this._continue = false;
-        if (this._top)
-            this._top.removeEventListener("resize", this._resizeTimer.closure.tell, true);
-        this._top = null;
-
-        this._removeHints(0);
-    },
-
-    /**
-     * Handle a hint mode event.
-     *
-     * @param {Event} event The event to handle.
-     */
-    onEvent: function onEvent(event) {
-        const KILL = false, PASS = true;
-        let key = events.toString(event);
-
-        this.clearTimeout();
-
-        if (!this.escNumbers && this.isHintKey(key)) {
-            this.prevInput = "number";
-
-            let oldHintNumber = this._hintNumber;
-            if (this._usedTabKey) {
-                this._hintNumber = 0;
-                this._usedTabKey = false;
-            }
-            this._hintNumber = this._hintNumber * this.hintKeys.length +
-                this.hintKeys.indexOf(key);
-
-            this._updateStatusline();
-
-            if (this._docs.length == 0) {
-                this._generate();
-                this._showHints();
-            }
-            this._showActiveHint(this._hintNumber, oldHintNumber || 1);
-
-            dactyl.assert(this._hintNumber != 0);
-
-            this._checkUnique();
-            return KILL;
-        }
-
-        return PASS;
+    show: function show(mode, opts) {
+        this.hintSession = HintSession(mode, opts);
     }
-    //}}}
 }, {
     translitTable: Class.memoize(function () {
         const table = {};
diff --git a/common/modules/base.jsm b/common/modules/base.jsm
index caaab70b..8c83a3c2 100644
--- a/common/modules/base.jsm
+++ b/common/modules/base.jsm
@@ -1032,8 +1032,8 @@ var Timer = Class("Timer", {
 });
 
 /**
- * Returns the UTF-8 encoded value of a string mis-encoded into
- * ISO-8859-1.
+ * Idempotent function which returns the UTF-8 encoded value of an
+ * improperly-decoded string.
  *
  * @param {string} str
  * @returns {string}

From 6176b54e735607892dd10b9f0f7f42c3e124f502 Mon Sep 17 00:00:00 2001
From: Kris Maglione <maglione.k@gmail.com>
Date: Sun, 23 Jan 2011 22:16:24 -0500
Subject: [PATCH 07/36] Make command-line pseudo-mappings real mappings.

--HG--
branch : key-processing
---
 common/content/commandline.js | 83 +++++++++++++++++------------------
 1 file changed, 41 insertions(+), 42 deletions(-)

diff --git a/common/content/commandline.js b/common/content/commandline.js
index a838e4bd..faf2104c 100644
--- a/common/content/commandline.js
+++ b/common/content/commandline.js
@@ -1008,41 +1008,7 @@ var CommandLine = Module("commandline", {
                 let key = events.toString(event);
                 if (this._completions)
                     this._completions.previewClear();
-                if (!this.currentExtendedMode)
-                    return PASS;
 
-                // user pressed <Enter> to carry out a command
-                // user pressing <Esc> is handled in the global onEscape
-                // FIXME: <Esc> should trigger "cancel" event
-                if (events.isAcceptKey(key)) {
-                    this._keepCommand = userContext.hidden_option_command_afterimage;
-                    let mode = this.currentExtendedMode;
-                    this.currentExtendedMode = null; // Don't let modes.pop trigger "cancel"
-                    modes.pop();
-                    commandline.triggerCallback("submit", mode, command);
-                }
-                // user pressed <Up> or <Down> arrow to cycle history completion
-                else if (/^<(Up|Down|S-Up|S-Down)>$/.test(key)) {
-                    dactyl.assert(this._history);
-                    this._history.select(/Up/.test(key), !/S-/.test(key));
-                    return KILL;
-                }
-                // user pressed <Tab> to get completions of a command
-                else if (/^<(?:A-)?(?:S-)?Tab>$/.test(key)) {
-                    this._tabTimer.tell(event);
-                    return KILL;
-                }
-                else if (key == "<BS>") {
-                    // reset the tab completion
-                    //this.resetCompletions();
-
-                    // and blur the command line if there is no text left
-                    if (command.length == 0) {
-                        commandline.triggerCallback("cancel", this.currentExtendedMode);
-                        modes.pop();
-                    }
-                }
-                // allow this event to be handled by the host app
                 return PASS;
             }
             else if (event.type == "keyup") {
@@ -1717,6 +1683,47 @@ var CommandLine = Module("commandline", {
                 return Events.PASS;
             });
 
+        mappings.add([modes.COMMAND_LINE],
+            ["<Return>", "<C-j>", "<C-m>"], "Accept the current input",
+            function (args) {
+                commandline._keepCommand = userContext.hidden_option_command_afterimage;
+                let mode = commandline.currentExtendedMode;
+                commandline.currentExtendedMode = null; // Don't let modes.pop trigger "cancel"
+                modes.pop();
+                commandline.triggerCallback("submit", mode, commandline.command);
+            });
+
+        [
+            [["<Up>", "<A-p>"],                   "previous matching", true,  true],
+            [["<S-Up>", "<C-p>", "<PageUp>"],     "previous",          true,  false],
+            [["<Down>", "<A-n>"],                 "next matching",     false, true],
+            [["<S-Down>", "<C-n>", "<PageDown>"], "next",              false, false]
+        ].forEach(function ([keys, desc, up, search]) {
+            mappings.add([modes.COMMAND_LINE],
+                keys, "Recall the " + desc + " command line from the history list",
+                function (args) {
+                    dactyl.assert(commandline._history);
+                    commandline._history.select(up, search);
+                });
+        });
+
+        mappings.add([modes.COMMAND_LINE],
+            ["<A-Tab>", "<Tab>"], "Select the next matching completion item",
+            function ({ events }) { commandline._tabTimer.tell(events[0]); });
+
+        mappings.add([modes.COMMAND_LINE],
+            ["<A-S-Tab>", "<S-Tab>"], "Select the previous matching completion item",
+            function ({ events }) { commandline._tabTimer.tell(events[0]); });
+
+        mappings.add([modes.COMMAND_LINE],
+            ["<BS>", "<C-h>"], "Delete the previous character",
+            function () {
+                if (!commandline.command)
+                    modes.pop();
+                else
+                    return Events.PASS;
+            });
+
         mappings.add([modes.COMMAND_LINE],
             ["<C-]>", "<C-5>"], "Expand command line abbreviation",
             function () { editor.expandAbbreviation(modes.COMMAND_LINE); });
@@ -1728,14 +1735,6 @@ var CommandLine = Module("commandline", {
                 commandline._echoMultiline(commandline._lastMowOutput, commandline.HL_NORMAL);
             });
 
-        mappings.add([modes.COMMAND_LINE],
-            ["<C-p>", "<PageUp>"], "Recall the previous command line from the history list",
-            function () { events.feedkeys("<S-Up>"); });
-
-        mappings.add([modes.COMMAND_LINE],
-            ["<C-n>", "<PageDown>"], "Recall the next command line from the history list",
-            function () { events.feedkeys("<S-Down>"); });
-
         // add the ":" mapping in all but insert mode mappings
         mappings.add(modes.COMMAND,
             [":"], "Enter command-line mode",

From 3b43cde8df5e960b6f6a4d29e7e2259dd7b635f1 Mon Sep 17 00:00:00 2001
From: Kris Maglione <maglione.k@gmail.com>
Date: Sun, 23 Jan 2011 22:23:20 -0500
Subject: [PATCH 08/36] Cosmetic changes.

--HG--
branch : key-processing
---
 common/content/commandline.js | 96 ++++++++++++++++-------------------
 1 file changed, 45 insertions(+), 51 deletions(-)

diff --git a/common/content/commandline.js b/common/content/commandline.js
index faf2104c..febd98cd 100644
--- a/common/content/commandline.js
+++ b/common/content/commandline.js
@@ -1668,6 +1668,13 @@ var CommandLine = Module("commandline", {
     },
     mappings: function () {
 
+        mappings.add([modes.COMMAND],
+            [":"], "Enter command-line mode",
+            function () { commandline.open(":", "", modes.EX); });
+
+        let bind = function bind()
+            mappings.add.apply(mappings, [[modes.COMMAND_LINE]].concat(Array.slice(arguments)))
+
         // Any "non-keyword" character triggers abbreviation expansion
         // TODO: Add "<CR>" and "<Tab>" to this list
         //       At the moment, adding "<Tab>" breaks tab completion. Adding
@@ -1675,23 +1682,21 @@ var CommandLine = Module("commandline", {
         // TODO: Make non-keyword recognition smarter so that there need not
         //       be two lists of the same characters (one here and a regexp in
         //       mappings.js)
-        mappings.add([modes.COMMAND_LINE],
-            ["<Space>", '"', "'"], "Expand command line abbreviation",
-            function () {
-                commandline.resetCompletions();
-                editor.expandAbbreviation(modes.COMMAND_LINE);
-                return Events.PASS;
-            });
+        bind(["<Space>", '"', "'"], "Expand command line abbreviation",
+             function () {
+                 commandline.resetCompletions();
+                 editor.expandAbbreviation(modes.COMMAND_LINE);
+                 return Events.PASS;
+             });
 
-        mappings.add([modes.COMMAND_LINE],
-            ["<Return>", "<C-j>", "<C-m>"], "Accept the current input",
-            function (args) {
-                commandline._keepCommand = userContext.hidden_option_command_afterimage;
-                let mode = commandline.currentExtendedMode;
-                commandline.currentExtendedMode = null; // Don't let modes.pop trigger "cancel"
-                modes.pop();
-                commandline.triggerCallback("submit", mode, commandline.command);
-            });
+        bind(["<Return>", "<C-j>", "<C-m>"], "Accept the current input",
+             function (args) {
+                 commandline._keepCommand = userContext.hidden_option_command_afterimage;
+                 let mode = commandline.currentExtendedMode;
+                 commandline.currentExtendedMode = null; // Don't let modes.pop trigger "cancel"
+                 modes.pop();
+                 commandline.triggerCallback("submit", mode, commandline.command);
+             });
 
         [
             [["<Up>", "<A-p>"],                   "previous matching", true,  true],
@@ -1699,46 +1704,35 @@ var CommandLine = Module("commandline", {
             [["<Down>", "<A-n>"],                 "next matching",     false, true],
             [["<S-Down>", "<C-n>", "<PageDown>"], "next",              false, false]
         ].forEach(function ([keys, desc, up, search]) {
-            mappings.add([modes.COMMAND_LINE],
-                keys, "Recall the " + desc + " command line from the history list",
-                function (args) {
-                    dactyl.assert(commandline._history);
-                    commandline._history.select(up, search);
-                });
+            bind(keys, "Recall the " + desc + " command line from the history list",
+                 function (args) {
+                     dactyl.assert(commandline._history);
+                     commandline._history.select(up, search);
+                 });
         });
 
-        mappings.add([modes.COMMAND_LINE],
-            ["<A-Tab>", "<Tab>"], "Select the next matching completion item",
-            function ({ events }) { commandline._tabTimer.tell(events[0]); });
+        bind(["<A-Tab>", "<Tab>"], "Select the next matching completion item",
+             function ({ events }) { commandline._tabTimer.tell(events[0]); });
 
-        mappings.add([modes.COMMAND_LINE],
-            ["<A-S-Tab>", "<S-Tab>"], "Select the previous matching completion item",
-            function ({ events }) { commandline._tabTimer.tell(events[0]); });
+        bind(["<A-S-Tab>", "<S-Tab>"], "Select the previous matching completion item",
+             function ({ events }) { commandline._tabTimer.tell(events[0]); });
 
-        mappings.add([modes.COMMAND_LINE],
-            ["<BS>", "<C-h>"], "Delete the previous character",
-            function () {
-                if (!commandline.command)
-                    modes.pop();
-                else
-                    return Events.PASS;
-            });
+        bind(["<BS>", "<C-h>"], "Delete the previous character",
+             function () {
+                 if (!commandline.command)
+                     modes.pop();
+                 else
+                     return Events.PASS;
+             });
 
-        mappings.add([modes.COMMAND_LINE],
-            ["<C-]>", "<C-5>"], "Expand command line abbreviation",
-            function () { editor.expandAbbreviation(modes.COMMAND_LINE); });
+        bind(["<C-]>", "<C-5>"], "Expand command line abbreviation",
+             function () { editor.expandAbbreviation(modes.COMMAND_LINE); });
 
-        mappings.add([modes.NORMAL],
-            ["g<"], "Redisplay the last command output",
-            function () {
-                dactyl.assert(commandline._lastMowOutput, "No previous command output");
-                commandline._echoMultiline(commandline._lastMowOutput, commandline.HL_NORMAL);
-            });
-
-        // add the ":" mapping in all but insert mode mappings
-        mappings.add(modes.COMMAND,
-            [":"], "Enter command-line mode",
-            function () { commandline.open(":", "", modes.EX); });
+        bind(["g<"], "Redisplay the last command output",
+             function () {
+                 dactyl.assert(commandline._lastMowOutput, "No previous command output");
+                 commandline._echoMultiline(commandline._lastMowOutput, commandline.HL_NORMAL);
+             });
 
         let mow = modules.mow = {
             __noSuchMethod__: function (meth, args) Buffer[meth].apply(Buffer, [this.body].concat(args))
@@ -1750,7 +1744,7 @@ var CommandLine = Module("commandline", {
         const DROP = false;
         const BEEP = {};
 
-        function bind(keys, description, action, test, default_) {
+        bind = function bind(keys, description, action, test, default_) {
             mappings.add([modes.OUTPUT_MULTILINE],
                 keys, description,
                 function (command) {

From 3cd40141f92abd39a0512a486ad3308a539adf36 Mon Sep 17 00:00:00 2001
From: Kris Maglione <maglione.k@gmail.com>
Date: Sun, 23 Jan 2011 23:25:08 -0500
Subject: [PATCH 09/36] Move :downloads button logic into binding classes.

--HG--
branch : key-processing
---
 common/content/commandline.js |  1 -
 common/content/events.js      |  8 ++--
 common/modules/downloads.jsm  | 26 ++---------
 common/modules/template.jsm   | 81 +++++++++++++++++++++++++++++++++++
 common/modules/util.jsm       | 16 ++++---
 5 files changed, 100 insertions(+), 32 deletions(-)

diff --git a/common/content/commandline.js b/common/content/commandline.js
index febd98cd..8f03cbf6 100644
--- a/common/content/commandline.js
+++ b/common/content/commandline.js
@@ -1083,7 +1083,6 @@ var CommandLine = Module("commandline", {
             // TODO: Wouldn't multiple handlers be cleaner? --djk
             if (event.type == "click" && event.target instanceof HTMLAnchorElement) {
 
-                util.dump(event.getPreventDefault(), event.target);
                 if (event.getPreventDefault())
                     return;
 
diff --git a/common/content/events.js b/common/content/events.js
index 186464aa..29a8086c 100644
--- a/common/content/events.js
+++ b/common/content/events.js
@@ -92,7 +92,11 @@ var ProcessorStack = Class("ProcessorStack", {
         else if (this.actions.length) {
             if (actions.length == 0)
                 dactyl.beep();
-            result = this.actions[0]() === Events.PASS ? Events.PASS : Events.KILL;
+
+            if (modes.replaying && !events.waitForPageLoad())
+                result = Events.KILL;
+            else
+                result = this.actions[0]() === Events.PASS ? Events.PASS : Events.KILL;
         }
         else if (result !== Events.KILL && processors.some(function (p) !p.main.passUnknown)) {
             result = Events.KILL;
@@ -175,8 +179,6 @@ var KeyProcessor = Class("KeyProcessor", {
                 return KeyArgProcessor(this, map, false, "arg");
             else if (map.motion)
                 return KeyArgProcessor(this, map, true, "motion");
-            else if (modes.replaying && !events.waitForPageLoad())
-                return Events.KILL;
 
             return this.execute(map, { count: this.count, command: this.command, events: this.events });
         }
diff --git a/common/modules/downloads.jsm b/common/modules/downloads.jsm
index aff156fe..cfb322e7 100644
--- a/common/modules/downloads.jsm
+++ b/common/modules/downloads.jsm
@@ -25,7 +25,9 @@ var Download = Class("Download", {
         this.instance = this;
         this.list = list;
 
-        this.nodes = {};
+        this.nodes = {
+            commandTarget: self
+        };
         util.xmlToDom(
             <li highlight="Download" key="row" xmlns:dactyl={NS} xmlns={XHTML}>
                 <span highlight="DownloadTitle">
@@ -54,22 +56,6 @@ var Download = Class("Download", {
             </li>,
             this.list.document, this.nodes);
 
-        for (let [key, node] in Iterator(this.nodes)) {
-            node.dactylDownload = self;
-            if (node.getAttributeNS(NS, "highlight") == "Button") {
-                node.setAttributeNS(NS, "command", "download.command");
-                update(node, {
-                    set collapsed(collapsed) {
-                        if (collapsed)
-                            this.setAttribute("collapsed", "true");
-                        else
-                            this.removeAttribute("collapsed");
-                    },
-                    get collapsed() !!this.getAttribute("collapsed")
-                });
-            }
-        }
-
         self.updateStatus();
         return self;
     },
@@ -289,12 +275,6 @@ var Downloads = Module("downloads", {
                 if (modules.commandline.savingOutput)
                     util.waitFor(function () downloads.document);
             });
-    },
-    dactyl: function (dactyl, modules, window) {
-        dactyl.commands["download.command"] = function (event) {
-            let elem = event.originalTarget;
-            elem.dactylDownload.command(elem.getAttribute("key"));
-        }
     }
 });
 
diff --git a/common/modules/template.jsm b/common/modules/template.jsm
index 36847f6d..565cfbf6 100644
--- a/common/modules/template.jsm
+++ b/common/modules/template.jsm
@@ -13,6 +13,68 @@ defineModule("template", {
 
 default xml namespace = XHTML;
 
+var Binding = Class("Binding", {
+    init: function (node) {
+        this.node = node;
+        node.dactylBinding = this;
+
+        Object.defineProperties(node, this.constructor.properties);
+
+        for (let [event, handler] in values(this.constructor.events))
+            node.addEventListener(event, handler, false);
+    },
+
+    set collapsed(collapsed) {
+        if (collapsed)
+            this.setAttribute("collapsed", "true");
+        else
+            this.removeAttribute("collapsed");
+    },
+    get collapsed() !!this.getAttribute("collapsed"),
+
+    __noSuchMethod__: function __noSuchMethod__(meth, args) {
+        return this.node[meth].apply(this.node, args);
+    }
+}, {
+    get bindings() {
+        let bindingProto = Object.getPrototypeOf(Binding.prototype);
+        for (let obj = this.prototype; obj !== bindingProto; obj = Object.getPrototypeOf(obj))
+            yield obj;
+    },
+
+    bind: function bind(func) function bound() {
+        try {
+            return func.apply(this.dactylBinding, arguments);
+        }
+        catch (e) {
+            util.reportError(e);
+            throw e;
+        }
+    },
+
+    events: Class.memoize(function () {
+        let res = [];
+        for (let obj in this.bindings)
+            if (Object.getOwnPropertyDescriptor(obj, "events"))
+                for (let [event, handler] in Iterator(obj.events))
+                    res.push([event, this.bind(handler)]);
+        return res;
+    }),
+
+    properties: Class.memoize(function () {
+        let res = {};
+        for (let obj in this.bindings)
+            for (let prop in properties(obj)) {
+                let desc = Object.getOwnPropertyDescriptor(obj, prop);
+                for (let k in values(["get", "set", "value"]))
+                    if (typeof desc[k] === "function")
+                        desc[k] = this.bind(desc[k]);
+                res[prop] = desc;
+            }
+        return res;
+    })
+});
+
 var Template = Module("Template", {
     add: function add(a, b) a + b,
     join: function join(c) function (a, b) a + c + b,
@@ -36,6 +98,25 @@ var Template = Module("Template", {
         return ret;
     },
 
+    bindings: {
+        Button: Class("Button", Binding, {
+            init: function init(node, params) {
+                init.supercall(this, node);
+
+                this.target = params.commandTarget;
+                if (callable(this.target))
+                    this.target = { command: this.target }
+            },
+
+            events: {
+                "click": function onClick(event) {
+                    event.preventDefault();
+                    this.target.command(this.getAttribute("key"));
+                }
+            }
+        })
+    },
+
     bookmarkDescription: function (item, text)
     <>
         {
diff --git a/common/modules/util.jsm b/common/modules/util.jsm
index 52debe7a..664f93de 100644
--- a/common/modules/util.jsm
+++ b/common/modules/util.jsm
@@ -1587,27 +1587,33 @@ var Util = Module("Util", XPCOM([Ci.nsIObserver, Ci.nsISupportsWeakReference]),
         XML.prettyPrinting = false;
         if (typeof node === "string") // Sandboxes can't currently pass us XML objects.
             node = XML(node);
+
         if (node.length() != 1) {
             let domnode = doc.createDocumentFragment();
             for each (let child in node)
                 domnode.appendChild(xmlToDom(child, doc, nodes));
             return domnode;
         }
+
         switch (node.nodeKind()) {
         case "text":
             return doc.createTextNode(String(node));
         case "element":
             let domnode = doc.createElementNS(node.namespace(), node.localName());
-            for each (let attr in node.@*::*)
-                if (attr.name() != "highlight")
-                    domnode.setAttributeNS(attr.namespace(), attr.localName(), String(attr));
-                else
-                    highlight.highlightNode(domnode, String(attr));
 
             for each (let child in node.*::*)
                 domnode.appendChild(xmlToDom(child, doc, nodes));
             if (nodes && node.@key)
                 nodes[node.@key] = domnode;
+
+            for each (let attr in node.@*::*)
+                if (attr.name() != "highlight")
+                    domnode.setAttributeNS(attr.namespace(), attr.localName(), String(attr));
+                else {
+                    highlight.highlightNode(domnode, String(attr));
+                    if (attr in template.bindings)
+                        template.bindings[attr](domnode, nodes);
+                }
             return domnode;
         default:
             return null;

From 0a422502baaf59a99be649c7d8aeff2547cbc7c6 Mon Sep 17 00:00:00 2001
From: Kris Maglione <maglione.k@gmail.com>
Date: Mon, 24 Jan 2011 00:37:32 -0500
Subject: [PATCH 10/36] Add Clear button to :downloads.

--HG--
branch : key-processing
---
 common/content/commandline.js | 13 ++++----
 common/modules/config.jsm     | 20 ++++++------
 common/modules/downloads.jsm  | 59 +++++++++++++++++++++++++++--------
 common/modules/template.jsm   | 23 ++++++++++++--
 4 files changed, 84 insertions(+), 31 deletions(-)

diff --git a/common/content/commandline.js b/common/content/commandline.js
index d3d19848..e217bb58 100644
--- a/common/content/commandline.js
+++ b/common/content/commandline.js
@@ -893,20 +893,21 @@ var CommandLine = Module("commandline", {
      */
     input: function _input(prompt, callback, extra) {
         extra = extra || {};
+        let closure = extra.closure || extra;
 
         this._input = {
-            submit: callback || extra.onAccept,
-            change: extra.onChange,
-            complete: extra.completer,
-            cancel: extra.onCancel
+            submit: callback || closure.onAccept,
+            change: closure.onChange,
+            complete: closure.completer,
+            cancel: closure.onCancel
         };
 
         modes.push(modes.COMMAND_LINE, modes.PROMPT | extra.extended,
                    update(Object.create(extra), {
-                       onEvent: extra.onEvent || this.closure.onEvent,
+                       onEvent: closure.onEvent || this.closure.onEvent,
                        leave: function leave(stack) {
                            commandline.leave(stack);
-                           leave.supercall(this, stack);
+                           leave.supercall(extra, stack);
                        },
                        keyModes: [extra.extended, modes.PROMPT]
                    }));
diff --git a/common/modules/config.jsm b/common/modules/config.jsm
index c0ff190b..c603940a 100644
--- a/common/modules/config.jsm
+++ b/common/modules/config.jsm
@@ -499,23 +499,25 @@ var ConfigBase = Class("ConfigBase", {
         Button::after           content: "]"; color: gray; text-decoration: none !important;
         Button:not([collapsed]) ~ Button:not([collapsed])::before  content: "/[";
 
+        DownloadCell                    display: table-cell; padding: 0 1ex;
+
         Downloads                       display: table; margin: 0; padding: 0;
         DownloadHead;;;CompTitle        display: table-row;
-        DownloadHead>*;;;DownloadCell   display: table-cell;
+        DownloadHead>*;;;DownloadCell
 
         Download                        display: table-row;
         Download:not([active])          color: gray;
 
-        DownloadCell                    display: table-cell; padding: 0 1ex;
-        DownloadButtons;;;DownloadCell
-        DownloadPercent;;;DownloadCell
-        DownloadProgress;;;DownloadCell
+        Download>*;;;DownloadCell
+        DownloadButtons
+        DownloadPercent
+        DownloadProgress
         DownloadProgressHave
         DownloadProgressTotal
-        DownloadSource;;;DownloadCell,URL
-        DownloadState;;;DownloadCell
-        DownloadTime;;;DownloadCell
-        DownloadTitle;;;DownloadCell,URL
+        DownloadSource
+        DownloadState
+        DownloadTime
+        DownloadTitle
 
         // </css>
     ]]></>, /&#x0d;/g, "\n")),
diff --git a/common/modules/downloads.jsm b/common/modules/downloads.jsm
index cfb322e7..d463e28b 100644
--- a/common/modules/downloads.jsm
+++ b/common/modules/downloads.jsm
@@ -66,7 +66,7 @@ var Download = Class("Download", {
 
     get alive() this.inState(["downloading", "notstarted", "paused", "queued", "scanning"]),
 
-    allowed: Class.memoize(function () let (self = this) ({
+    allowedCommands: Class.memoize(function () let (self = this) ({
         get cancel() self.cancelable && self.inState(["downloading", "paused", "starting"]),
         get delete() !this.cancel && self.targetFile.exists(),
         get launch() self.targetFile.exists() && self.inState(["finished"]),
@@ -78,13 +78,10 @@ var Download = Class("Download", {
     })),
 
     command: function command(name) {
-        util.assert(set.has(this.allowed, name), "Unknown command");
-        util.assert(this.allowed[name], "Command not allowed");
+        util.assert(set.has(this.allowedCommands, name), "Unknown command");
+        util.assert(this.allowedCommands[name], "Command not allowed");
 
-        if (set.has(this.commands, name))
-            this.commands[name].call(this);
-        else
-            services.downloadManager[name + "Download"](this.id);
+        services.downloadManager[name + "Download"](this.id);
     },
 
     commands: {
@@ -154,8 +151,11 @@ var Download = Class("Download", {
 
         this.nodes.row.setAttribute("status", this.status);
         this.nodes.state.textContent = util.capitalize(this.status);
-        for (let [command, enabled] in Iterator(this.allowed))
-            this.nodes[command].collapsed = !enabled;
+
+        for (let node in values(this.nodes))
+            if (node.update)
+                node.update();
+
         this.updateProgress();
     }
 });
@@ -166,7 +166,9 @@ var DownloadList = Class("DownloadList",
                                 Ci.nsISupportsWeakReference]), {
     init: function init(modules) {
         this.modules = modules;
-        this.nodes = {};
+        this.nodes = {
+            commandTarget: this
+        };
         this.downloads = {};
     },
     cleanup: function cleanup() {
@@ -180,17 +182,30 @@ var DownloadList = Class("DownloadList",
                         <li highlight="DownloadHead">
                             <span>Title</span>
                             <span>Status</span>
-                            <span></span>
+                            <span/>
                             <span>Progress</span>
-                            <span></span>
+                            <span/>
                             <span>Time remaining</span>
                             <span>Source</span>
                         </li>
+                        <li highlight="Download"><span><div style="min-height: 1ex; /* FIXME */"/></span></li>
+                        <li highlight="Download" key="totals">
+                            <span highlight="Title">Totals:</span>
+                            <span/>
+                            <span highlight="DownloadButtons">
+                                <a highlight="Button" key="clear">Clear</a>
+                            </span>
+                            <span/>
+                            <span/>
+                            <span/>
+                            <span/>
+                        </li>
                       </ul>, this.document, this.nodes);
 
         for (let row in iter(services.downloadManager.DBConnection
                                      .createStatement("SELECT id FROM moz_downloads")))
             this.addDownload(row.id);
+        this.update();
 
         util.addObserver(this);
         services.downloadManager.addListener(this);
@@ -220,14 +235,31 @@ var DownloadList = Class("DownloadList",
             this.cleanup();
     },
 
+    allowedCommands: Class.memoize(function () let (self = this) ({
+        get clear() values(self.downloads).some(function (dl) dl.allowedCommands.remove)
+    })),
+
+    commands: {
+        clear: function () {
+            services.downloadManager.cleanUp();
+        }
+    },
+
+    update: function update() {
+        for (let node in values(this.nodes))
+            if (node.update && node.update != update)
+                node.update();
+    },
+
     observers: {
         "download-manager-remove-download": function (id) {
             if (id == null)
-                id = [k for ([k, dl] in iter(this.downloads)) if (dl.allowed.remove)];
+                id = [k for ([k, dl] in iter(this.downloads)) if (dl.allowedCommands.remove)];
             else
                 id = [id.QueryInterface(Ci.nsISupportsPRUint32).data];
 
             Array.concat(id).map(this.closure.removeDownload);
+            this.update();
         }
     },
 
@@ -241,6 +273,7 @@ var DownloadList = Class("DownloadList",
                 this.modules.commandline.updateOutputHeight(false);
                 this.nodes.list.scrollIntoView(false);
             }
+            this.update();
         }
         catch (e) {
             util.reportError(e);
diff --git a/common/modules/template.jsm b/common/modules/template.jsm
index 178d0259..d9db8cb6 100644
--- a/common/modules/template.jsm
+++ b/common/modules/template.jsm
@@ -104,15 +104,32 @@ var Template = Module("Template", {
                 init.supercall(this, node);
 
                 this.target = params.commandTarget;
-                if (callable(this.target))
-                    this.target = { command: this.target }
             },
 
+            get command() this.getAttribute("command") || this.getAttribute("key"),
+
             events: {
                 "click": function onClick(event) {
                     event.preventDefault();
-                    this.target.command(this.getAttribute("key"));
+                    if (this.commandAllowed) {
+                        if (set.has(this.target.commands || {}, this.command))
+                            this.target.commands[this.command].call(this.target);
+                        else
+                            this.target.command(this.command);
+                    }
                 }
+            },
+
+            get commandAllowed() {
+                if (set.has(this.target.allowedCommands || {}, this.command))
+                    return this.target.allowedCommands[this.command];
+                if ("commandAllowed" in this.target)
+                    return this.target.commandAllowed(this.command);
+                return true;
+            },
+
+            update: function update() {
+                this.collapsed = !this.commandAllowed;
             }
         })
     },

From b3d91db6b477a4022829f4f473861c0eed00b434 Mon Sep 17 00:00:00 2001
From: Kris Maglione <maglione.k@gmail.com>
Date: Mon, 24 Jan 2011 02:37:14 -0500
Subject: [PATCH 11/36] Fix some hinting bugs.

--HG--
branch : key-processing
---
 common/content/commandline.js |  25 ++++---
 common/content/editor.js      |   4 +-
 common/content/events.js      |  25 ++++++-
 common/content/hints.js       | 130 ++++++++++++++++++----------------
 common/modules/base.jsm       |  17 ++++-
 5 files changed, 119 insertions(+), 82 deletions(-)

diff --git a/common/content/commandline.js b/common/content/commandline.js
index e217bb58..b1ad96ca 100644
--- a/common/content/commandline.js
+++ b/common/content/commandline.js
@@ -893,18 +893,17 @@ var CommandLine = Module("commandline", {
      */
     input: function _input(prompt, callback, extra) {
         extra = extra || {};
-        let closure = extra.closure || extra;
 
         this._input = {
-            submit: callback || closure.onAccept,
-            change: closure.onChange,
-            complete: closure.completer,
-            cancel: closure.onCancel
+            submit: callback || extra.onAccept,
+            change: extra.onChange,
+            complete: extra.completer,
+            cancel: extra.onCancel
         };
 
         modes.push(modes.COMMAND_LINE, modes.PROMPT | extra.extended,
                    update(Object.create(extra), {
-                       onEvent: closure.onEvent || this.closure.onEvent,
+                       onEvent: extra.onEvent || this.extra.onEvent,
                        leave: function leave(stack) {
                            commandline.leave(stack);
                            leave.supercall(extra, stack);
@@ -965,7 +964,6 @@ var CommandLine = Module("commandline", {
 
             for (let node in array.iterValues(event.target.children)) {
                 let group = node.getAttributeNS(NS, "group");
-                util.dump(node, group, group && !group.split(/\s+/).every(function (g) enabled[g]));
                 node.hidden = group && !group.split(/\s+/).every(function (g) enabled[g]);
             }
         }
@@ -1672,6 +1670,13 @@ var CommandLine = Module("commandline", {
             [":"], "Enter command-line mode",
             function () { commandline.open(":", "", modes.EX); });
 
+        mappings.add([modes.COMMAND],
+            ["g<lt>"], "Redisplay the last command output",
+            function () {
+                dactyl.assert(commandline._lastMowOutput, "No previous command output");
+                commandline._echoMultiline(commandline._lastMowOutput, commandline.HL_NORMAL);
+            });
+
         let bind = function bind()
             mappings.add.apply(mappings, [[modes.COMMAND_LINE]].concat(Array.slice(arguments)))
 
@@ -1728,12 +1733,6 @@ var CommandLine = Module("commandline", {
         bind(["<C-]>", "<C-5>"], "Expand command line abbreviation",
              function () { editor.expandAbbreviation(modes.COMMAND_LINE); });
 
-        bind(["g<"], "Redisplay the last command output",
-             function () {
-                 dactyl.assert(commandline._lastMowOutput, "No previous command output");
-                 commandline._echoMultiline(commandline._lastMowOutput, commandline.HL_NORMAL);
-             });
-
         let mow = modules.mow = {
             __noSuchMethod__: function (meth, args) Buffer[meth].apply(Buffer, [this.body].concat(args))
         };
diff --git a/common/content/editor.js b/common/content/editor.js
index ffbe217c..e0e99895 100644
--- a/common/content/editor.js
+++ b/common/content/editor.js
@@ -51,9 +51,7 @@ var Editor = Module("editor", {
             elem.scrollTop = top;
             elem.scrollLeft = left;
 
-            let event = elem.ownerDocument.createEvent("Event");
-            event.initEvent("input", true, false);
-            events.dispatch(elem, event);
+            events.dispatch(elem, events.create(elem.ownerDocument, "input"));
         }
     },
 
diff --git a/common/content/events.js b/common/content/events.js
index 241e39f1..95bd8519 100644
--- a/common/content/events.js
+++ b/common/content/events.js
@@ -530,9 +530,10 @@ var Events = Module("events", {
      *
      * @param {Document} doc The DOM document to associate this event with
      * @param {Type} type The type of event (keypress, click, etc.)
-     * @param {Object} opts The pseudo-event.
+     * @param {Object} opts The pseudo-event. @optional
      */
     create: function (doc, type, opts) {
+        opts = opts || {};
         var DEFAULTS = {
             HTML: {
                 type: type, bubbles: true, cancelable: false
@@ -557,7 +558,7 @@ var Events = Module("events", {
             }
         };
         const TYPES = {
-            change: "",
+            change: "", input: "",
             click: "Mouse", mousedown: "Mouse", mouseup: "Mouse",
             mouseover: "Mouse", mouseout: "Mouse",
             keypress: "Key", keyup: "Key", keydown: "Key"
@@ -566,7 +567,9 @@ var Events = Module("events", {
         var evt = doc.createEvent((t || "HTML") + "Events");
 
         let defaults = DEFAULTS[t || "HTML"]
-        evt["init" + t + "Event"].apply(evt, Object.keys(defaults).map(function (k) k in opts ? opts[k] : defaults[k]));
+        evt["init" + t + "Event"].apply(evt, Object.keys(defaults)
+                                                   .map(function (k) k in opts ? opts[k]
+                                                                               : defaults[k]));
         return evt;
     },
 
@@ -988,12 +991,28 @@ var Events = Module("events", {
         },
         */
 
+        input: function onInput(event) {
+            delete event.originalTarget.dactylKeyPress;
+        },
+
         // this keypress handler gets always called first, even if e.g.
         // the command-line has focus
         // TODO: ...help me...please...
         keypress: function onKeyPress(event) {
             event.dactylDefaultPrevented = event.getPreventDefault();
 
+            // Hack to deal with <BS> and so forth not dispatching input
+            // events
+            if (event.originalTarget instanceof HTMLInputElement) {
+                let elem = event.originalTarget;
+                elem.dactylKeyPress = elem.value;
+                util.timeout(function () {
+                    if ("dactylKeyPress" in elem && elem.value !== elem.dactylKeyPress)
+                        events.dispatch(elem, events.create(elem.ownerDocument, "input"));
+                    delete events.dactylKeyPress;
+                });
+            }
+
             let duringFeed = this.duringFeed || [];
             this.duringFeed = [];
             try {
diff --git a/common/content/hints.js b/common/content/hints.js
index ddb0feb7..b2571170 100644
--- a/common/content/hints.js
+++ b/common/content/hints.js
@@ -31,7 +31,7 @@ var HintSession = Class("HintSession", {
         this.usedTabKey = false;
         this.validHints = []; // store the indices of the "hints" array with valid elements
 
-        commandline.input(UTF8(this.mode.prompt) + ": ", null, this);
+        commandline.input(UTF8(this.mode.prompt) + ": ", null, this.closure);
         modes.extended = modes.HINTS;
 
         this.top = opts.window || content;
@@ -80,6 +80,17 @@ var HintSession = Class("HintSession", {
         this.activeTimeout = null;
     },
 
+    _escapeNumbers: false,
+    get escapeNumbers() this._escapeNumbers,
+    set escapeNumbers(val) {
+        this.clearTimeout();
+        this._escapeNumbers = !!val;
+        if (val && this.usedTabKey)
+            this.hintNumber = 0;
+
+        this.updateStatusline();
+    },
+
     /**
      * Returns the hint string for a given number based on the values of
      * the 'hintkeys' option.
@@ -322,7 +333,7 @@ var HintSession = Class("HintSession", {
 
         this.clearTimeout();
 
-        if (!this.escNumbers && this.isHintKey(key)) {
+        if (!this.escapeNumbers && this.isHintKey(key)) {
             this.prevInput = "number";
 
             let oldHintNumber = this.hintNumber;
@@ -586,11 +597,61 @@ var HintSession = Class("HintSession", {
         }
     },
 
+    backspace: function () {
+        this.clearTimeout();
+        if (this.prevInput !== "number")
+            return Events.PASS;
+
+        if (this.hintNumber > 0 && !this.usedTabKey) {
+            this.hintNumber = Math.floor(this.hintNumber / this.hintKeys.length);
+            if (this.hintNumber == 0)
+                this.prevInput = "text";
+            this.update(false);
+        }
+        else {
+            this.usedTabKey = false;
+            this.hintNumber = 0;
+            dactyl.beep();
+        }
+        return Events.KILL;
+    },
+
+    tab: function tab(previous) {
+        this.clearTimeout();
+        this.usedTabKey = true;
+        if (this.hintNumber == 0)
+            this.hintNumber = 1;
+
+        let oldId = this.hintNumber;
+        if (!previous) {
+            if (++this.hintNumber > this.validHints.length)
+                this.hintNumber = 1;
+        }
+        else {
+            if (--this.hintNumber < 1)
+                this.hintNumber = this.validHints.length;
+        }
+
+        this.showActiveHint(this.hintNumber, oldId);
+        this.updateStatusline();
+    },
+
+    update: function update(followFirst) {
+        this.clearTimeout();
+        this.updateStatusline();
+
+        if (this.docs.length == 0 && this.hintString.length > 0)
+            this.generate();
+
+        this.show();
+        this.process(followFirst);
+    },
+
     /**
      * Display the current status to the user.
      */
     updateStatusline: function _updateStatusline() {
-        statusline.updateInputBuffer((hints.escNumbers ? options["mapleader"] : "") +
+        statusline.updateInputBuffer((this.escapeNumbers ? options["mapleader"] : "") +
                                      (this.hintNumber ? this.getHintString(this.hintNumber) : ""));
     },
 });
@@ -1034,79 +1095,26 @@ var Hints = Module("hints", {
             function ({ count }) { hints.open("g;", { continue: true, count: count }); },
             { count: true });
 
-        function update(followFirst) {
-            hints.clearTimeout();
-            hints._updateStatusline();
-
-            if (hints._docs.length == 0 && hints._hintString.length > 0)
-                hints._generate();
-
-            hints._showHints();
-            hints._processHints(followFirst);
-        }
-
         mappings.add(modes.HINTS, ["<Return>"],
             "Follow the selected hint",
-            function () { update(true); });
-
-        function tab(previous) {
-            hints.clearTimeout();
-            this._usedTabKey = true;
-            if (this._hintNumber == 0)
-                this._hintNumber = 1;
-
-            let oldId = this._hintNumber;
-            if (!previous) {
-                if (++this._hintNumber > this._validHints.length)
-                    this._hintNumber = 1;
-            }
-            else {
-                if (--this._hintNumber < 1)
-                    this._hintNumber = this._validHints.length;
-            }
-
-            this._showActiveHint(this._hintNumber, oldId);
-            this._updateStatusline();
-        }
+            function () { hints.hintSession.update(true); });
 
         mappings.add(modes.HINTS, ["<Tab>"],
             "Focus the next matching hint",
-            function () { tab.call(hints, false); });
+            function () { hints.hintSession.tab(false); });
 
         mappings.add(modes.HINTS, ["<S-Tab>"],
             "Focus the previous matching hint",
-            function () { tab.call(hints, true); });
+            function () { hints.hintSession.tab(true); });
 
         mappings.add(modes.HINTS, ["<BS>", "<C-h>"],
             "Delete the previous character",
-            function () {
-                hints.clearTimeout();
-                if (hints.prevInput !== "number")
-                    return Events.PASS;
-
-                if (hints._hintNumber > 0 && !hints._usedTabKey) {
-                    hints._hintNumber = Math.floor(hints._hintNumber / hints.hintKeys.length);
-                    if (hints._hintNumber == 0)
-                        hints.prevInput = "text";
-                    update(false);
-                }
-                else {
-                    hints._usedTabKey = false;
-                    hints._hintNumber = 0;
-                    dactyl.beep();
-                }
-                return Events.KILL;
-            });
+            function () hints.hintSession.backspace());
 
         mappings.add(modes.HINTS, ["<Leader>"],
             "Toggle hint filtering",
             function () {
-                hints.clearTimeout();
-                hints.escNumbers = !hints.escNumbers;
-                if (hints.escNumbers && hints._usedTabKey)
-                    hints._hintNumber = 0;
-
-                hints._updateStatusline();
+                hints.hintSession.escapeNumbers = !hints.hintSession.escapeNumbers;
             });
     },
     options: function () {
diff --git a/common/modules/base.jsm b/common/modules/base.jsm
index 8c83a3c2..0d7f92c5 100644
--- a/common/modules/base.jsm
+++ b/common/modules/base.jsm
@@ -803,10 +803,23 @@ Class.prototype = {
 };
 memoize(Class.prototype, "closure", function () {
     const self = this;
-    function closure(fn) function () fn.apply(self, arguments);
-    for (let k in iter(properties(this), properties(this, true)))
+    function closure(fn) function () {
+        try {
+            return fn.apply(self, arguments);
+        }
+        catch (e) {
+            util.reportError(e);
+        }
+    }
+    iter(properties(this), properties(this, true)).forEach(function (k) {
         if (!this.__lookupGetter__(k) && callable(this[k]))
             closure[k] = closure(this[k]);
+        else if (!(k in closure || k in Object.prototype))
+            Object.defineProperty(closure, k, {
+                get: function get_proxy() self[k],
+                set: function set_proxy(val) self[k] = val,
+            });
+    }, this);
     return closure;
 });
 

From 37719fdf1f1a20fe5e910a865631871e6f03819e Mon Sep 17 00:00:00 2001
From: Kris Maglione <maglione.k@gmail.com>
Date: Mon, 24 Jan 2011 03:34:13 -0500
Subject: [PATCH 12/36] Fix command history search bug.

--HG--
branch : key-processing
---
 common/content/commandline.js | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/common/content/commandline.js b/common/content/commandline.js
index b1ad96ca..a1e63184 100644
--- a/common/content/commandline.js
+++ b/common/content/commandline.js
@@ -1256,6 +1256,7 @@ var CommandLine = Module("commandline", {
          * @param {string} val The new value.
          */
         replace: function (val) {
+            delete this.input.dactylKeyPress;
             this.input.value = val;
             commandline.triggerCallback("change", commandline.currentExtendedMode, val, "history");
         },
@@ -1321,6 +1322,7 @@ var CommandLine = Module("commandline", {
             this.context = CompletionContext(input.QueryInterface(Ci.nsIDOMNSEditableElement).editor);
             this.context.onUpdate = this.closure._reset;
             this.editor = input.editor;
+            this.input = input;
             this.selected = null;
             this.wildmode = options.get("wildmode");
             this.wildtypes = this.wildmode.value;
@@ -1351,6 +1353,8 @@ var CommandLine = Module("commandline", {
             // Reset the caret to one position after the completion.
             this.caret = this.prefix.length + completion.length;
             this._caret = this.caret;
+
+            delete this.input.dactylKeyPress;
         },
 
         get caret() this.editor.selection.getRangeAt(0).startOffset,

From 93b9aade1d0eae9a2c035c56ceb4436f32d9eaed Mon Sep 17 00:00:00 2001
From: Kris Maglione <maglione.k@gmail.com>
Date: Mon, 24 Jan 2011 03:56:27 -0500
Subject: [PATCH 13/36] Update :extensions with live update and buttons like
 :downloads. Rename to :addons.

--HG--
branch : key-processing
---
 common/content/commandline.js |   8 +-
 common/content/dactyl.js      | 257 -----------------
 common/locale/en-US/gui.xml   |  19 +-
 common/modules/addons.jsm     | 515 ++++++++++++++++++++++++++++++++++
 common/modules/config.jsm     |  17 ++
 common/modules/downloads.jsm  |   5 +-
 common/modules/overlay.jsm    |   3 +-
 common/modules/services.jsm   |  80 +-----
 pentadactyl/NEWS              |   1 +
 9 files changed, 544 insertions(+), 361 deletions(-)
 create mode 100644 common/modules/addons.jsm

diff --git a/common/content/commandline.js b/common/content/commandline.js
index a1e63184..91856148 100644
--- a/common/content/commandline.js
+++ b/common/content/commandline.js
@@ -1188,17 +1188,19 @@ var CommandLine = Module("commandline", {
     },
 
     withOutputToString: function (fn, self) {
-        let buffer = [];
         dactyl.registerObserver("echoLine", observe, true);
         dactyl.registerObserver("echoMultiline", observe, true);
+
+        let output = [];
         function observe(str, highlight, dom) {
-            buffer.push(dom && !isString(str) ? util.domToString(dom) : str);
+            output.push(dom && !isString(str) ? dom : str);
         }
 
         this.savingOutput = true;
         dactyl.trapErrors.apply(dactyl, [fn, self].concat(Array.slice(arguments, 2)));
         this.savingOutput = false;
-        return buffer.join("\n");
+        return output.map(function (elem) elem instanceof Node ? util.domToString(elem) : elem)
+                     .join("\n");
     }
 }, {
     /**
diff --git a/common/content/dactyl.js b/common/content/dactyl.js
index a8922422..8c65f810 100644
--- a/common/content/dactyl.js
+++ b/common/content/dactyl.js
@@ -1527,14 +1527,6 @@ var Dactyl = Module("dactyl", XPCOM(Ci.nsISupportsWeakReference, ModuleBase), {
     },
 
     commands: function () {
-        commands.add(["addo[ns]"],
-            "Manage available Extensions and Themes",
-            function () {
-                dactyl.open("chrome://mozapps/content/extensions/extensions.xul",
-                    { from: "addons" });
-            },
-            { argCount: "0" });
-
         commands.add(["dia[log]"],
             "Open a " + config.appName + " dialog",
             function (args) {
@@ -1592,255 +1584,6 @@ var Dactyl = Module("dactyl", XPCOM(Ci.nsISupportsWeakReference, ModuleBase), {
                 literal: 0
             });
 
-        ///////////////////////////////////////////////////////////////////////////
-
-        const addonErrors = array.toObject([
-            [AddonManager.ERROR_NETWORK_FAILURE, "A network error occurred"],
-            [AddonManager.ERROR_INCORRECT_HASH,  "The downloaded file did not match the expected hash"],
-            [AddonManager.ERROR_CORRUPT_FILE,    "The file appears to be corrupt"],
-            [AddonManager.ERROR_FILE_ACCESS,     "There was an error accessing the filesystem"]]);
-
-        function listener(action, event)
-            function addonListener(install) {
-                if (typeof dactyl !== "undefined")
-                    dactyl[install.error ? "echoerr" : "echomsg"](
-                        "Add-on " + action + " " + event + ": " + (install.name || install.sourceURI.spec) +
-                        (install.error ? ": " + addonErrors[install.error] : ""));
-            }
-        const addonListener = {
-            onNewInstall:      function (install) {},
-            onExternalInstall: function (addon, existingAddon, needsRestart) {},
-            onDownloadStarted:   listener("download", "started"),
-            onDownloadEnded:     listener("download", "complete"),
-            onDownloadCancelled: listener("download", "cancelled"),
-            onDownloadFailed:    listener("download", "failed"),
-            onDownloadProgress:  function (install) {},
-            onInstallStarted:   function (install) {},
-            onInstallEnded:     listener("installation", "complete"),
-            onInstallCancelled: listener("installation", "cancelled"),
-            onInstallFailed:    listener("installation", "failed")
-        };
-
-        const updateAddons = Class("UpgradeListener", {
-            init: function init(addons) {
-                dactyl.assert(!addons.length || addons[0].findUpdates,
-                              "Not available on " + config.host + " " + services.runtime.version);
-                this.remaining = addons;
-                this.upgrade = [];
-                dactyl.echomsg("Checking updates for addons: " + addons.map(function (a) a.name).join(", "));
-                for (let addon in values(addons))
-                    addon.findUpdates(this, AddonManager.UPDATE_WHEN_USER_REQUESTED, null, null);
-            },
-            addonListener: {
-                __proto__: addonListener,
-                onDownloadStarted: function () {},
-                onDownloadEnded: function () {}
-            },
-            onUpdateAvailable: function (addon, install) {
-                this.upgrade.push(addon);
-                install.addListener(this.addonListener);
-                install.install();
-            },
-            onUpdateFinished: function (addon, error) {
-                this.remaining = this.remaining.filter(function (a) a != addon);
-                if (!this.remaining.length)
-                    dactyl.echomsg(
-                        this.upgrade.length
-                            ? "Installing updates for addons: " + this.upgrade.map(function (i) i.name).join(", ")
-                            : "No addon updates found");
-            }
-        });
-
-        ///////////////////////////////////////////////////////////////////////////
-
-        function callResult(method) {
-            let args = Array.slice(arguments, 1);
-            return function (result) { result[method].apply(result, args); };
-        }
-
-        commands.add(["exta[dd]"],
-            "Install an extension",
-            function (args) {
-                let url  = args[0];
-                let file = io.File(url);
-                function install(addonInstall) {
-                    addonInstall.addListener(addonListener);
-                    addonInstall.install();
-                }
-
-                if (!file.exists())
-                    AddonManager.getInstallForURL(url,   install, "application/x-xpinstall");
-                else if (file.isReadable() && file.isFile())
-                    AddonManager.getInstallForFile(file, install, "application/x-xpinstall");
-                else if (file.isDirectory())
-                    dactyl.echoerr("Cannot install a directory: " + file.path.quote());
-                else
-                    dactyl.echoerr("E484: Can't open file " + file.path);
-            }, {
-                argCount: "1",
-                completer: function (context) {
-                    context.filters.push(function ({ item }) item.isDirectory() || /\.xpi$/.test(item.leafName));
-                    completion.file(context);
-                },
-                literal: 0
-            });
-
-        // TODO: handle extension dependencies
-        [
-            {
-                name: "extde[lete]",
-                description: "Uninstall an extension",
-                action: callResult("uninstall"),
-                perm: "uninstall"
-            },
-            {
-                name: "exte[nable]",
-                description: "Enable an extension",
-                action: function (addon) addon.userDisabled = false,
-                filter: function ({ item }) item.userDisabled,
-                perm: "enable"
-            },
-            {
-                name: "extd[isable]",
-                description: "Disable an extension",
-                action: function (addon) addon.userDisabled = true,
-                filter: function ({ item }) !item.userDisabled,
-                perm: "disable"
-            },
-            {
-                name: "extr[ehash]",
-                description: "Reload an extension",
-                action: function (addon) {
-                    dactyl.assert(dactyl.has("Gecko2"), "This command is not useful in this version of " + config.host);
-                    util.timeout(function () {
-                        addon.userDisabled = true;
-                        addon.userDisabled = false;
-                    });
-                },
-                get filter() {
-                    let ids = set(keys(JSON.parse(prefs.get("extensions.bootstrappedAddons", "{}"))));
-                    return function ({ item }) !item.userDisabled && set.has(ids, item.id);
-                },
-                perm: "disable"
-            },
-            {
-                name: "extt[oggle]",
-                description: "Toggle an extension's enabled status",
-                action: function (addon) addon.userDisabled = !addon.userDisabled
-            },
-            {
-                name: "extu[pdate]",
-                description: "Update an extension",
-                actions: updateAddons,
-                perm: "upgrade"
-            }
-        ].forEach(function (command) {
-            let perm = command.perm && AddonManager["PERM_CAN_" + command.perm.toUpperCase()];
-            function ok(addon) !perm || addon.permissions & perm;
-            commands.add([command.name],
-                command.description,
-                function (args) {
-                    let name = args[0];
-                    if (args.bang)
-                        dactyl.assert(!name, "E488: Trailing characters");
-                    else
-                        dactyl.assert(name, "E471: Argument required");
-
-                    AddonManager.getAddonsByTypes(["extension"], dactyl.wrapCallback(function (list) {
-                        if (!args.bang) {
-                            list = list.filter(function (extension) extension.name == name);
-                            if (list.length == 0)
-                                return void dactyl.echoerr("E475: Invalid argument: " + name);
-                            if (!list.every(ok))
-                                return void dactyl.echoerr("Permission denied");
-                        }
-                        if (command.actions)
-                            command.actions(list);
-                        else
-                            list.forEach(command.action);
-                    }));
-                }, {
-                    argCount: "?", // FIXME: should be "1"
-                    bang: true,
-                    completer: function (context) {
-                        completion.extension(context);
-                        context.filters.push(function ({ item }) ok(item));
-                        if (command.filter)
-                            context.filters.push(command.filter);
-                    },
-                    literal: 0
-                });
-        });
-
-        commands.add(["exto[ptions]", "extp[references]"],
-            "Open an extension's preference dialog",
-            function (args) {
-                AddonManager.getAddonsByTypes(["extension"], dactyl.wrapCallback(function (list) {
-                    list = list.filter(function (extension) extension.name == args[0]);
-                    if (!list.length || !list[0].optionsURL)
-                        dactyl.echoerr("E474: Invalid argument");
-                    else if (args.bang)
-                        window.openDialog(list[0].optionsURL, "_blank", "chrome");
-                    else
-                        dactyl.open(list[0].optionsURL, { from: "extoptions" });
-                }));
-            }, {
-                argCount: "1",
-                bang: true,
-                completer: function (context) {
-                    completion.extension(context);
-                    context.filters.push(function ({ item }) item.isActive && item.optionsURL);
-                },
-                literal: 0
-            });
-
-        commands.add(["extens[ions]", "exts"],
-            "List available extensions",
-            function (args) {
-                function addonExtra(e) {
-                    let extra;
-                    if (e.pendingOperations & AddonManager.PENDING_UNINSTALL)
-                        extra = ["Disabled", "uninstalled"];
-                    else if (e.pendingOperations & AddonManager.PENDING_DISABLE)
-                        extra = ["Disabled", "disabled"];
-                    else if (e.pendingOperations & AddonManager.PENDING_INSTALL)
-                        extra = ["Enabled", "installed"];
-                    else if (e.pendingOperations & AddonManager.PENDING_ENABLE)
-                        extra = ["Enabled", "enabled"];
-                    else if (e.pendingOperations & AddonManager.PENDING_UPGRADE)
-                        extra = ["Enabled", "upgraded"];
-                    if (extra)
-                        return <>&#xa0;(<span highlight={extra[0]}>{extra[1]}</span>
-                                        &#xa0;on restart)</>;
-                    return <></>;
-                }
-                let waiting = true;
-                AddonManager.getAddonsByTypes(["extension"], function (extensions) {
-                    if (args[0])
-                        extensions = extensions.filter(function (extension) extension.name.indexOf(args[0]) >= 0);
-                    extensions.sort(function (a, b) String.localeCompare(a.name, b.name));
-
-                    if (extensions.length > 0)
-                        commandline.commandOutput(
-                            template.tabular(["Name", "Version", "Status", "Description"], [],
-                                ([template.icon({ icon: e.iconURL }, e.name),
-                                  e.version,
-                                  (e.isActive ? <span highlight="Enabled">enabled</span>
-                                              : <span highlight="Disabled">disabled</span>) +
-                                  addonExtra(e),
-                                  e.description]
-                                for ([, e] in Iterator(extensions)))));
-                    else if (filter)
-                        dactyl.echoerr("Exxx: No extension matching " + filter.quote());
-                    else
-                        dactyl.echoerr("No extensions installed");
-                    waiting = false;
-                });
-                if (commandline.savingOutput)
-                    util.waitFor(function () !waiting);
-            },
-            { argCount: "?" });
-
         [
             {
                 name: "h[elp]",
diff --git a/common/locale/en-US/gui.xml b/common/locale/en-US/gui.xml
index fa1daf5d..e7054858 100644
--- a/common/locale/en-US/gui.xml
+++ b/common/locale/en-US/gui.xml
@@ -41,16 +41,11 @@
 <h2 tag="dialogs">Dialogs</h2>
 
 <item>
-    <tags>:addo :addons</tags>
+    <tags>:ao :addo :addons</tags>
     <strut/>
     <spec>:addo<oa>ns</oa></spec>
     <description>
-        <p>
-            Opens the &dactyl.host; addon manager, where extensions and themes
-            may be installed, removed, disabled, and configured. See also
-            <ex>:extensions</ex>, <ex>:extadd</ex>, <ex>:extoptions</ex>,
-            <ex>:extenable</ex>, <ex>:extdisable</ex>, and <ex>:extdelete</ex>.
-        </p>
+        <p>Opens the add-on list.</p>
     </description>
 </item>
 
@@ -129,16 +124,6 @@
     </description>
 </item>
 
-<item>
-    <tags>:exts :extens :extensions</tags>
-    <spec>:extens<oa>ions</oa></spec>
-    <spec>:exts</spec>
-    <strut/>
-    <description>
-        <p>List all installed extensions.</p>
-    </description>
-</item>
-
 <item>
     <tags>:exto :extoptions</tags>
     <spec>:exto<oa>ptions</oa><oa>!</oa> <a>extension</a></spec>
diff --git a/common/modules/addons.jsm b/common/modules/addons.jsm
new file mode 100644
index 00000000..4964d938
--- /dev/null
+++ b/common/modules/addons.jsm
@@ -0,0 +1,515 @@
+// Copyright (c) 2011 by Kris Maglione <maglione.k@gmail.com>
+//
+// This work is licensed for reuse under an MIT license. Details are
+// given in the LICENSE.txt file included with this file.
+"use strict";
+
+try {
+
+Components.utils.import("resource://dactyl/bootstrap.jsm");
+defineModule("addons", {
+    exports: ["AddonManager", "Addons", "Addon", "addons"],
+    require: ["services"],
+    use: ["config", "io", "prefs", "template", "util"]
+}, this);
+
+var callResult = function callResult(method) {
+    let args = Array.slice(arguments, 1);
+    return function (result) { result[method].apply(result, args); };
+}
+
+var listener = function listener(action, event)
+    function addonListener(install) {
+        this.dactyl[install.error ? "echoerr" : "echomsg"](
+            "Add-on " + action + " " + event + ": " + (install.name || install.sourceURI.spec) +
+            (install.error ? ": " + addonErrors[install.error] : ""));
+    }
+
+var AddonListener = Class("AddonListener", {
+    init: function init(modules) {
+        this.dactyl = modules.dactyl;
+    },
+
+    onNewInstall:      function (install) {},
+    onExternalInstall: function (addon, existingAddon, needsRestart) {},
+    onDownloadStarted:   listener("download", "started"),
+    onDownloadEnded:     listener("download", "complete"),
+    onDownloadCancelled: listener("download", "cancelled"),
+    onDownloadFailed:    listener("download", "failed"),
+    onDownloadProgress:  function (install) {},
+    onInstallStarted:   function (install) {},
+    onInstallEnded:     listener("installation", "complete"),
+    onInstallCancelled: listener("installation", "cancelled"),
+    onInstallFailed:    listener("installation", "failed")
+});
+
+var updateAddons = Class("UpgradeListener", AddonListener, {
+    init: function init(addons, modules) {
+        init.supercall(this, modules);
+
+        util.assert(!addons.length || addons[0].findUpdates,
+                    "Not available on " + config.host + " " + services.runtime.version);
+
+        this.remaining = addons;
+        this.upgrade = [];
+        this.dactyl.echomsg("Checking updates for addons: " + addons.map(function (a) a.name).join(", "));
+        for (let addon in values(addons))
+            addon.findUpdates(this, AddonManager.UPDATE_WHEN_USER_REQUESTED, null, null);
+
+    },
+    onUpdateAvailable: function (addon, install) {
+        this.upgrade.push(addon);
+        install.addListener(this);
+        install.install();
+    },
+    onUpdateFinished: function (addon, error) {
+        this.remaining = this.remaining.filter(function (a) a != addon);
+        if (!this.remaining.length)
+            this.dactyl.echomsg(
+                this.upgrade.length
+                    ? "Installing updates for addons: " + this.upgrade.map(function (i) i.name).join(", ")
+                    : "No addon updates found");
+    }
+});
+
+var actions = {
+    delete: {
+        name: "extde[lete]",
+        description: "Uninstall an extension",
+        action: callResult("uninstall"),
+        perm: "uninstall"
+    },
+    enable: {
+        name: "exte[nable]",
+        description: "Enable an extension",
+        action: function (addon) addon.userDisabled = false,
+        filter: function ({ item }) item.userDisabled,
+        perm: "enable"
+    },
+    disable: {
+        name: "extd[isable]",
+        description: "Disable an extension",
+        action: function (addon) addon.userDisabled = true,
+        filter: function ({ item }) !item.userDisabled,
+        perm: "disable"
+    },
+    rehash: {
+        name: "extr[ehash]",
+        description: "Reload an extension",
+        action: function (addon) {
+            dactyl.assert(dactyl.has("Gecko2"), "This command is not useful in this version of " + config.host);
+            util.timeout(function () {
+                addon.userDisabled = true;
+                addon.userDisabled = false;
+            });
+        },
+        get filter() {
+            let ids = set(keys(JSON.parse(prefs.get("extensions.bootstrappedAddons", "{}"))));
+            return function ({ item }) !item.userDisabled && set.has(ids, item.id);
+        },
+        perm: "disable"
+    },
+    toggle: {
+        name: "extt[oggle]",
+        description: "Toggle an extension's enabled status",
+        action: function (addon) addon.userDisabled = !addon.userDisabled
+    },
+    update: {
+        name: "extu[pdate]",
+        description: "Update an extension",
+        actions: updateAddons,
+        perm: "upgrade"
+    }
+};
+
+
+var Addon = Class("Addon", {
+    init: function init(addon, list) {
+        this.addon = addon;
+        this.instance = this;
+        this.list = list;
+
+        this.nodes = {
+            commandTarget: this
+        };
+        util.xmlToDom(
+            <li highlight="Addon" key="row" xmlns:dactyl={NS} xmlns={XHTML}>
+                <span highlight="AddonName" key="name">
+                </span>
+                <span highlight="AddonVersion" key="version"/>
+                <span highlight="AddonStatus" key="status"/>
+                <span highlight="AddonButtons Buttons">
+                    <a highlight="Button" key="enable">On&#xa0;</a>
+                    <a highlight="Button" key="disable">Off</a>
+                    <a highlight="Button" key="delete">Del</a>
+                    <a highlight="Button" key="update">Upd</a>
+                </span>
+                <span highlight="AddonDescription" key="description"/>
+            </li>,
+            this.list.document, this.nodes);
+
+        this.update();
+    },
+
+    commandAllowed: function commandAllowed(cmd) {
+        util.assert(set.has(actions, cmd), "Unknown command");
+
+        let action = actions[cmd];
+        if ("perm" in action && !(this.permissions & AddonManager["PERM_CAN_" + action.perm.toUpperCase()]))
+            return false;
+        if ("filter" in action && !action.filter({ item: this }))
+            return false;
+        return true;
+    },
+
+    command: function command(cmd) {
+        util.assert(this.commandAllowed(cmd), "Command not allowed");
+
+        let action = actions[cmd];
+        if (action.action)
+            action.action.call(this.modules, this);
+        else
+            action.actions([this], this.list.modules);
+    },
+
+    compare: function compare(other) String.localeCompare(this.name, other.name),
+
+    get statusInfo() {
+        let info = this.isActive ? <span highlight="Enabled">enabled</span>
+                                 : <span highlight="Disabled">disabled</span>;
+
+        let pending;
+        if (this.pendingOperations & AddonManager.PENDING_UNINSTALL)
+            pending = ["Disabled", "uninstalled"];
+        else if (this.pendingOperations & AddonManager.PENDING_DISABLE)
+            pending = ["Disabled", "disabled"];
+        else if (this.pendingOperations & AddonManager.PENDING_INSTALL)
+            pending = ["Enabled", "installed"];
+        else if (this.pendingOperations & AddonManager.PENDING_ENABLE)
+            pending = ["Enabled", "enabled"];
+        else if (this.pendingOperations & AddonManager.PENDING_UPGRADE)
+            pending = ["Enabled", "upgraded"];
+        if (pending)
+            return <>{info}&#xa0;(<span highlight={pending[0]}>{pending[1]}</span>
+                                  &#xa0;on restart)</>;
+        return info;
+    },
+
+    update: function callee() {
+        let self = this;
+        function update(key, xml) {
+            let node = self.nodes[key];
+            while (node.firstChild)
+                node.removeChild(node.firstChild);
+            node.appendChild(util.xmlToDom(<>{xml}</>, self.list.document));
+        }
+
+        update("name", template.icon({ icon: this.iconURL }, this.name));
+        this.nodes.version.textContent = this.version;
+        update("status", this.statusInfo);
+        this.nodes.description.textContent = this.description;
+
+        for (let node in values(this.nodes))
+            if (node.update && node.update !== callee)
+                node.update();
+    }
+});
+
+["cancelUninstall", "findUpdates", "getResourceURI", "hasResource",
+ "isCompatibleWith", "uninstall"].forEach(function (prop) {
+     Addon.prototype[prop] = function proxy() this.addon[prop].apply(this.addon, arguments);
+});
+
+["aboutURL", "appDisabled", "applyBackgroundUpdates", "blocklistState",
+ "contributors", "creator", "description", "developers", "homepageURL",
+ "iconURL", "id", "install", "installDate", "isActive", "isCompatible",
+ "isPlatformCompatible", "name", "operationsRequiringRestart",
+ "optionsURL", "pendingOperations", "pendingUpgrade", "permissions",
+ "providesUpdatesSecurely", "releaseNotesURI", "scope", "screenshots",
+ "size", "sourceURI", "translators", "type", "updateDate",
+ "userDisabled", "version"].forEach(function (prop) {
+    Object.defineProperty(Addon.prototype, prop, {
+        get: function get_proxy() this.addon[prop],
+        set: function set_proxy(val) this.addon[prop] = val
+    });
+});
+
+var AddonList = Class("AddonList", {
+    init: function init(modules, types) {
+        this.modules = modules;
+        this.nodes = {};
+        this.addons = [];
+        this.ready = false;
+
+        AddonManager.getAddonsByTypes(types, this.closure(function (addons) {
+            addons.forEach(this.closure.addAddon);
+            this.ready = true;
+            this.update();
+        }));
+        AddonManager.addAddonListener(this);
+    },
+    cleanup: function cleanup() {
+        AddonManager.removeAddonListener(this);
+    },
+
+    message: Class.memoize(function () {
+
+        util.xmlToDom(<ul highlight="Addons" key="list" xmlns={XHTML}>
+                        <li highlight="AddonHead">
+                            <span>Name</span>
+                            <span>Version</span>
+                            <span>Status</span>
+                            <span/>
+                            <span>Description</span>
+                        </li>
+                      </ul>, this.document, this.nodes);
+
+        return this.nodes.list;
+    }),
+
+    addAddon: function addAddon(addon) {
+        if (addon.id in this.addons)
+            this.update(addon);
+        else {
+            addon = Addon(addon, this);
+            this.addons[addon.id] = addon;
+
+            let index = values(this.addons).sort(function (a, b) a.compare(b))
+                                           .indexOf(addon);
+
+            this.nodes.list.insertBefore(addon.nodes.row,
+                                         this.nodes.list.childNodes[index + 1]);
+            this.update();
+        }
+    },
+    removeAddon: function removeAddon(addon) {
+        if (addon.id in this.addons) {
+            this.nodes.list.removeChild(this.addons[addon.id].nodes.row);
+            delete this.addons[addon.id];
+            this.update();
+        }
+    },
+
+    leave: function leave(stack) {
+        if (stack.pop)
+            this.cleanup();
+    },
+
+    update: function update(addon) {
+        if (addon && addon.id in this.addons)
+            this.addons[addon.id].update();
+        if (this.ready)
+            this.modules.commandline.updateOutputHeight(false);
+    },
+
+    onDisabled:           function (addon) { this.update(addon); },
+    onDisabling:          function (addon) { this.update(addon); },
+    onEnabled:            function (addon) { this.update(addon); },
+    onEnabling:           function (addon) { this.update(addon); },
+    onInstalled:          function (addon) { this.addAddon(addon); },
+    onInstalling:         function (addon) { this.update(addon); },
+    onUninstalled:        function (addon) { this.removeAddon(addon); },
+    onUninstalling:       function (addon) { this.update(addon); },
+    onOperationCancelled: function (addon) { this.update(addon); },
+    onPropertyChanged: function onPropertyChanged(addon, properties) {}
+});
+
+var Addons = Module("addons", {
+}, {
+}, {
+    commands: function (dactyl, modules, window) {
+        const { commands, completion } = modules;
+
+        let addonListener = AddonListener(modules);
+
+        commands.add(["exta[dd]"],
+            "Install an extension",
+            function (args) {
+                let url  = args[0];
+                let file = io.File(url);
+                function install(addonInstall) {
+                    addonInstall.addListener(addonListener);
+                    addonInstall.install();
+                }
+
+                if (!file.exists())
+                    AddonManager.getInstallForURL(url,   install, "application/x-xpinstall");
+                else if (file.isReadable() && file.isFile())
+                    AddonManager.getInstallForFile(file, install, "application/x-xpinstall");
+                else if (file.isDirectory())
+                    dactyl.echoerr("Cannot install a directory: " + file.path.quote());
+                else
+                    dactyl.echoerr("E484: Can't open file " + file.path);
+            }, {
+                argCount: "1",
+                completer: function (context) {
+                    context.filters.push(function ({ item }) item.isDirectory() || /\.xpi$/.test(item.leafName));
+                    completion.file(context);
+                },
+                literal: 0
+            });
+
+        // TODO: handle extension dependencies
+        values(actions).forEach(function (command) {
+            let perm = command.perm && AddonManager["PERM_CAN_" + command.perm.toUpperCase()];
+            function ok(addon) !perm || addon.permissions & perm;
+
+            commands.add([command.name],
+                command.description,
+                function (args) {
+                    let name = args[0];
+                    if (args.bang)
+                        dactyl.assert(!name, "E488: Trailing characters");
+                    else
+                        dactyl.assert(name, "E471: Argument required");
+
+                    AddonManager.getAddonsByTypes(["extension"], dactyl.wrapCallback(function (list) {
+                        if (!args.bang) {
+                            list = list.filter(function (extension) extension.name == name);
+                            if (list.length == 0)
+                                return void dactyl.echoerr("E475: Invalid argument: " + name);
+                            if (!list.every(ok))
+                                return void dactyl.echoerr("Permission denied");
+                        }
+                        if (command.actions)
+                            command.actions(list, this.modules);
+                        else
+                            list.forEach(command.action, this.modules);
+                    }));
+                }, {
+                    argCount: "?", // FIXME: should be "1"
+                    bang: true,
+                    completer: function (context) {
+                        completion.extension(context);
+                        context.filters.push(function ({ item }) ok(item));
+                        if (command.filter)
+                            context.filters.push(command.filter);
+                    },
+                    literal: 0
+                });
+        });
+
+        commands.add(["exto[ptions]", "extp[references]"],
+            "Open an extension's preference dialog",
+            function (args) {
+                AddonManager.getAddonsByTypes(["extension"], dactyl.wrapCallback(function (list) {
+                    list = list.filter(function (extension) extension.name == args[0]);
+                    if (!list.length || !list[0].optionsURL)
+                        dactyl.echoerr("E474: Invalid argument");
+                    else if (args.bang)
+                        window.openDialog(list[0].optionsURL, "_blank", "chrome");
+                    else
+                        dactyl.open(list[0].optionsURL, { from: "extoptions" });
+                }));
+            }, {
+                argCount: "1",
+                bang: true,
+                completer: function (context) {
+                    completion.extension(context);
+                    context.filters.push(function ({ item }) item.isActive && item.optionsURL);
+                },
+                literal: 0
+            });
+
+        commands.add(["addo[ns]", "ao"],
+            "List installed extensions",
+            function (args) {
+                let addons = AddonList(modules, ["extension"]);
+                modules.commandline.echo(addons);
+
+                if (modules.commandline.savingOutput)
+                    util.waitFor(function () addons.ready);
+            });
+    }
+});
+
+if (!Ci.nsIExtensionManager || !services.extensionManager)
+    Components.utils.import("resource://gre/modules/AddonManager.jsm");
+else
+    var AddonManager = {
+        getAddonByID: function (id, callback) {
+            callback = callback || util.identity;
+            let addon = id;
+            if (!isObject(addon))
+                addon = services.extensionManager.getItemForID(id);
+            if (!addon)
+                return callback(null);
+            addon = Object.create(addon);
+
+            function getRdfProperty(item, property) {
+                let resource = services.rdf.GetResource("urn:mozilla:item:" + item.id);
+                let value = "";
+
+                if (resource) {
+                    let target = services.extensionManager.datasource.GetTarget(resource,
+                        services.rdf.GetResource("http://www.mozilla.org/2004/em-rdf#" + property), true);
+                    if (target && target instanceof Ci.nsIRDFLiteral)
+                        value = target.Value;
+                }
+
+                return value;
+            }
+
+            ["aboutURL", "creator", "description", "developers",
+             "homepageURL", "installDate", "optionsURL",
+             "releaseNotesURI", "updateDate"].forEach(function (item) {
+                memoize(addon, item, function (item) getRdfProperty(this, item));
+            });
+
+            update(addon, {
+
+                appDisabled: false,
+
+                installLocation: Class.memoize(function () services.extensionManager.getInstallLocation(this.id)),
+                getResourceURI: function getResourceURI(path) {
+                    let file = this.installLocation.getItemFile(this.id, path);
+                    return services.io.newFileURI(file);
+                },
+
+                isActive: getRdfProperty(addon, "isDisabled") != "true",
+
+                uninstall: function uninstall() {
+                    services.extensionManager.uninstallItem(this.id);
+                },
+
+                get userDisabled() getRdfProperty(addon, "userDisabled") === "true",
+                set userDisabled(val) {
+                    services.extensionManager[val ? "disableItem" : "enableItem"](this.id);
+                }
+            });
+
+            return callback(addon);
+        },
+        getAddonsByTypes: function (types, callback) {
+            let res = [];
+            for (let [, type] in Iterator(types))
+                for (let [, item] in Iterator(services.extensionManager
+                            .getItemList(Ci.nsIUpdateItem["TYPE_" + type.toUpperCase()], {})))
+                    res.push(this.getAddonByID(item));
+            return (callback || util.identity)(res);
+        },
+        getInstallForFile: function (file, callback, mimetype) {
+            callback({
+                addListener: function () {},
+                install: function () {
+                    services.extensionManager.installItemFromFile(file, "app-profile");
+                }
+            });
+        },
+        getInstallForURL: function (url, callback, mimetype) {
+            dactyl.assert(false, "Install by URL not implemented");
+        },
+    };
+
+var addonErrors = array.toObject([
+    [AddonManager.ERROR_NETWORK_FAILURE, "A network error occurred"],
+    [AddonManager.ERROR_INCORRECT_HASH,  "The downloaded file did not match the expected hash"],
+    [AddonManager.ERROR_CORRUPT_FILE,    "The file appears to be corrupt"],
+    [AddonManager.ERROR_FILE_ACCESS,     "There was an error accessing the filesystem"]]);
+
+
+endModule();
+
+} catch(e){ if (isString(e)) e = Error(e); dump(e.fileName+":"+e.lineNumber+": "+e+"\n" + e.stack); }
+
+// vim: set fdm=marker sw=4 ts=4 et ft=javascript:
diff --git a/common/modules/config.jsm b/common/modules/config.jsm
index c603940a..98579722 100644
--- a/common/modules/config.jsm
+++ b/common/modules/config.jsm
@@ -499,6 +499,8 @@ var ConfigBase = Class("ConfigBase", {
         Button::after           content: "]"; color: gray; text-decoration: none !important;
         Button:not([collapsed]) ~ Button:not([collapsed])::before  content: "/[";
 
+        Buttons
+
         DownloadCell                    display: table-cell; padding: 0 1ex;
 
         Downloads                       display: table; margin: 0; padding: 0;
@@ -519,6 +521,21 @@ var ConfigBase = Class("ConfigBase", {
         DownloadTime
         DownloadTitle
 
+        AddonCell                    display: table-cell; padding: 0 1ex;
+
+        Addons                       display: table; margin: 0; padding: 0;
+        AddonHead;;;CompTitle        display: table-row;
+        AddonHead>*;;;AddonCell
+
+        Addon                        display: table-row;
+
+        Addon>*;;;AddonCell
+        AddonButtons
+        AddonDescription
+        AddonName
+        AddonStatus
+        AddonVersion
+
         // </css>
     ]]></>, /&#x0d;/g, "\n")),
 
diff --git a/common/modules/downloads.jsm b/common/modules/downloads.jsm
index d463e28b..16c10446 100644
--- a/common/modules/downloads.jsm
+++ b/common/modules/downloads.jsm
@@ -38,7 +38,7 @@ var Download = Class("Download", {
                     </span>
                 </span>
                 <span highlight="DownloadState" key="state"/>
-                <span highlight="DownloadButtons">
+                <span highlight="DownloadButtons Buttons">
                     <a highlight="Button" key="pause">Pause</a>
                     <a highlight="Button" key="remove">Remove</a>
                     <a highlight="Button" key="resume">Resume</a>
@@ -304,9 +304,6 @@ var Downloads = Module("downloads", {
             function (args) {
                 let downloads = DownloadList(modules);
                 modules.commandline.echo(downloads);
-
-                if (modules.commandline.savingOutput)
-                    util.waitFor(function () downloads.document);
             });
     }
 });
diff --git a/common/modules/overlay.jsm b/common/modules/overlay.jsm
index 391553c8..72eb99a9 100644
--- a/common/modules/overlay.jsm
+++ b/common/modules/overlay.jsm
@@ -148,7 +148,8 @@ var Overlay = Module("Overlay", {
                 let prefix = [BASE, "resource://dactyl-local-content/"];
 
                 defineModule.time("load", null, function _load() {
-                    ["base",
+                    ["addons",
+                     "base",
                      "completion",
                      "config",
                      "downloads",
diff --git a/common/modules/services.jsm b/common/modules/services.jsm
index 71e002e1..48629933 100644
--- a/common/modules/services.jsm
+++ b/common/modules/services.jsm
@@ -9,7 +9,7 @@ try {
 var global = this;
 Components.utils.import("resource://dactyl/bootstrap.jsm");
 defineModule("services", {
-    exports: ["AddonManager", "services"],
+    exports: ["services"],
     use: ["util"]
 }, this);
 
@@ -86,84 +86,6 @@ var Services = Module("Services", {
         this.addClass("Xmlhttp",      "@mozilla.org/xmlextras/xmlhttprequest;1",   Ci.nsIXMLHttpRequest);
         this.addClass("ZipReader",    "@mozilla.org/libjar/zip-reader;1",          Ci.nsIZipReader, "open");
         this.addClass("ZipWriter",    "@mozilla.org/zipwriter;1",                  Ci.nsIZipWriter);
-
-        if (!Ci.nsIExtensionManager || !this.extensionManager)
-            Components.utils.import("resource://gre/modules/AddonManager.jsm");
-        else
-            global.AddonManager = {
-                getAddonByID: function (id, callback) {
-                    callback = callback || util.identity;
-                    let addon = id;
-                    if (!isObject(addon))
-                        addon = services.extensionManager.getItemForID(id);
-                    if (!addon)
-                        return callback(null);
-                    addon = Object.create(addon);
-
-                    function getRdfProperty(item, property) {
-                        let resource = services.rdf.GetResource("urn:mozilla:item:" + item.id);
-                        let value = "";
-
-                        if (resource) {
-                            let target = services.extensionManager.datasource.GetTarget(resource,
-                                services.rdf.GetResource("http://www.mozilla.org/2004/em-rdf#" + property), true);
-                            if (target && target instanceof Ci.nsIRDFLiteral)
-                                value = target.Value;
-                        }
-
-                        return value;
-                    }
-
-                    ["aboutURL", "creator", "description", "developers",
-                     "homepageURL", "installDate", "optionsURL",
-                     "releaseNotesURI", "updateDate"].forEach(function (item) {
-                        memoize(addon, item, function (item) getRdfProperty(this, item));
-                    });
-
-                    update(addon, {
-
-                        appDisabled: false,
-
-                        installLocation: Class.memoize(function () services.extensionManager.getInstallLocation(this.id)),
-                        getResourceURI: function getResourceURI(path) {
-                            let file = this.installLocation.getItemFile(this.id, path);
-                            return services.io.newFileURI(file);
-                        },
-
-                        isActive: getRdfProperty(addon, "isDisabled") != "true",
-
-                        uninstall: function uninstall() {
-                            services.extensionManager.uninstallItem(this.id);
-                        },
-
-                        get userDisabled() getRdfProperty(addon, "userDisabled") === "true",
-                        set userDisabled(val) {
-                            services.extensionManager[val ? "disableItem" : "enableItem"](this.id);
-                        }
-                    });
-
-                    return callback(addon);
-                },
-                getAddonsByTypes: function (types, callback) {
-                    let res = [];
-                    for (let [, type] in Iterator(types))
-                        for (let [, item] in Iterator(services.extensionManager
-                                    .getItemList(Ci.nsIUpdateItem["TYPE_" + type.toUpperCase()], {})))
-                            res.push(this.getAddonByID(item));
-                    return (callback || util.identity)(res);
-                },
-                getInstallForFile: function (file, callback, mimetype) {
-                    callback({
-                        addListener: function () {},
-                        install: function () {
-                            services.extensionManager.installItemFromFile(file, "app-profile");
-                        }
-                    });
-                },
-                getInstallForURL: function (url, callback, mimetype) {
-                    dactyl.assert(false, "Install by URL not implemented");
-                },
-            };
     },
     reinit: function () {},
 
diff --git a/pentadactyl/NEWS b/pentadactyl/NEWS
index 578f3d62..abf2e334 100644
--- a/pentadactyl/NEWS
+++ b/pentadactyl/NEWS
@@ -66,6 +66,7 @@
         and linking to source code locations).
       - :downloads now opens a download list in the multi-line output
         buffer.
+      - :extensions has been replaced with a more powerful :addons
       - Added :cookies command.
       * :extadd now supports remote URLs as well as local files on Firefox 4.
       * Added :if/:elseif/:else/:endif conditionals.

From e0e2e805f7cf500680443620b3b6dbd7b94b3ce4 Mon Sep 17 00:00:00 2001
From: Kris Maglione <maglione.k@gmail.com>
Date: Mon, 24 Jan 2011 05:05:57 -0500
Subject: [PATCH 14/36] Add filtering to :addons and :downloads. Add -type flag
 to :addons.

--HG--
branch : key-processing
---
 common/content/commandline.js |  2 +-
 common/content/commands.js    |  8 +++++--
 common/modules/addons.jsm     | 44 +++++++++++++++++++++++++++++++----
 common/modules/base.jsm       |  4 ++--
 common/modules/completion.jsm |  7 ++++++
 common/modules/config.jsm     |  4 +++-
 common/modules/downloads.jsm  | 17 ++++++++++----
 7 files changed, 71 insertions(+), 15 deletions(-)

diff --git a/common/content/commandline.js b/common/content/commandline.js
index 91856148..e0e969ee 100644
--- a/common/content/commandline.js
+++ b/common/content/commandline.js
@@ -903,7 +903,7 @@ var CommandLine = Module("commandline", {
 
         modes.push(modes.COMMAND_LINE, modes.PROMPT | extra.extended,
                    update(Object.create(extra), {
-                       onEvent: extra.onEvent || this.extra.onEvent,
+                       onEvent: extra.onEvent || this.closure.onEvent,
                        leave: function leave(stack) {
                            commandline.leave(stack);
                            leave.supercall(extra, stack);
diff --git a/common/content/commands.js b/common/content/commands.js
index 173b59e3..44164529 100644
--- a/common/content/commands.js
+++ b/common/content/commands.js
@@ -916,7 +916,7 @@ var Commands = Module("commands", {
                                         }
                                     }
 
-                                    if (arg != null || opt.type == CommandOption.NOARG)
+                                    if (arg != null || opt.type == CommandOption.NOARG) {
                                         // option allowed multiple times
                                         if (opt.multiple)
                                             args[opt.names[0]] = (args[opt.names[0]] || []).concat(arg);
@@ -924,6 +924,7 @@ var Commands = Module("commands", {
                                             Class.replaceProperty(args, opt.names[0], opt.type == CommandOption.NOARG || arg);
 
                                         args.explicitOpts[opt.names[0]] = args[opt.names[0]];
+                                    }
 
                                     i += optname.length + count;
                                     if (i == str.length)
@@ -989,14 +990,17 @@ var Commands = Module("commands", {
                 if (args.completeOpt) {
                     let opt = args.completeOpt;
                     let context = complete.fork(opt.names[0], args.completeStart);
-                    let arg = args[opt.names[0]];
+                    let arg = args.explicitOpts[opt.names[0]];
                     context.filter = args.completeFilter;
+
                     if (isArray(arg))
                         context.filters.push(function (item) arg.indexOf(item.text) === -1);
+
                     if (typeof opt.completer == "function")
                         var compl = opt.completer(context, args);
                     else
                         compl = opt.completer || [];
+
                     context.title = [opt.names[0]];
                     context.quote = args.quote;
                     if (compl)
diff --git a/common/modules/addons.jsm b/common/modules/addons.jsm
index 4964d938..a1bd8272 100644
--- a/common/modules/addons.jsm
+++ b/common/modules/addons.jsm
@@ -10,7 +10,7 @@ Components.utils.import("resource://dactyl/bootstrap.jsm");
 defineModule("addons", {
     exports: ["AddonManager", "Addons", "Addon", "addons"],
     require: ["services"],
-    use: ["config", "io", "prefs", "template", "util"]
+    use: ["completion", "config", "io", "prefs", "template", "util"]
 }, this);
 
 var callResult = function callResult(method) {
@@ -235,8 +235,9 @@ var Addon = Class("Addon", {
 });
 
 var AddonList = Class("AddonList", {
-    init: function init(modules, types) {
+    init: function init(modules, types, filter) {
         this.modules = modules;
+        this.filter = filter && filter.toLowerCase();
         this.nodes = {};
         this.addons = [];
         this.ready = false;
@@ -271,6 +272,9 @@ var AddonList = Class("AddonList", {
         if (addon.id in this.addons)
             this.update(addon);
         else {
+            if (this.filter && addon.name.toLowerCase().indexOf(this.filter) === -1)
+                return;
+
             addon = Addon(addon, this);
             this.addons[addon.id] = addon;
 
@@ -318,7 +322,7 @@ var Addons = Module("addons", {
 }, {
 }, {
     commands: function (dactyl, modules, window) {
-        const { commands, completion } = modules;
+        const { CommandOption, commands, completion } = modules;
 
         let addonListener = AddonListener(modules);
 
@@ -414,12 +418,44 @@ var Addons = Module("addons", {
         commands.add(["addo[ns]", "ao"],
             "List installed extensions",
             function (args) {
-                let addons = AddonList(modules, ["extension"]);
+                let addons = AddonList(modules, args["-types"], args[0]);
                 modules.commandline.echo(addons);
 
                 if (modules.commandline.savingOutput)
                     util.waitFor(function () addons.ready);
+            },
+            {
+                argCount: "?",
+                options: [
+                    {
+                        names: ["-types", "-type", "-t"],
+                        description: "The add-on types to list",
+                        default: ["extension"],
+                        completer: function (context, args) completion.addonType(context),
+                        type: CommandOption.LIST
+                    }
+                ]
             });
+    },
+    completion: function (dactyl, modules, window) {
+        completion.addonType = function addonType(context) {
+            let base = ["extension", "theme"];
+            function update(types) {
+                context.completions = types.map(function (t) [t, util.capitalize(t)]);
+            }
+
+            context.generate = function generate() {
+                update(base);
+                if (AddonManager.getAllAddons) {
+                    context.incomplete = true;
+                    AddonManager.getAllAddons(function (addons) {
+                        context.incomplete = false;
+                        update(array.uniq(base.concat(addons.map(function (a) a.type)),
+                                          true));
+                    });
+                }
+            }
+        }
     }
 });
 
diff --git a/common/modules/base.jsm b/common/modules/base.jsm
index 0d7f92c5..2ffc9586 100644
--- a/common/modules/base.jsm
+++ b/common/modules/base.jsm
@@ -297,11 +297,11 @@ function deprecated(alternative, fn) {
  * @param {object} obj The object to inspect.
  * @returns {Generator}
  */
-function keys(obj) {
+function keys(obj) iter(function keys() {
     for (var k in obj)
         if (hasOwnProperty.call(obj, k))
             yield k;
-}
+}());
 /**
  * Iterates over all of the top-level, iterable property values of an
  * object.
diff --git a/common/modules/completion.jsm b/common/modules/completion.jsm
index 7c352d1b..8594deeb 100644
--- a/common/modules/completion.jsm
+++ b/common/modules/completion.jsm
@@ -481,6 +481,13 @@ var CompletionContext = Class("CompletionContext", {
             let filtered = this.filterFunc(this._cache.constructed);
             if (this.maxItems)
                 filtered = filtered.slice(0, this.maxItems);
+            if (/types/.test(this.name)) {
+                let self = this;
+                util.dump(this.filters[1]);
+                util.dump("FILTERED", this._cache.constructed.map(function (item) [item.text.quote(), self.filters[0].call(self, item.text)]));
+                util.dump("FILTERED", this._cache.constructed.map(function (item)
+                    self.filters.map(function (filter) filter.call(self, item))));
+            }
 
             // Sorting
             if (this.sortResults && this.compare)
diff --git a/common/modules/config.jsm b/common/modules/config.jsm
index 98579722..33242e9b 100644
--- a/common/modules/config.jsm
+++ b/common/modules/config.jsm
@@ -424,6 +424,7 @@ var ConfigBase = Class("ConfigBase", {
         Link                        position: relative; padding-right: 2em;
         Link:not(:hover)>LinkInfo   opacity: 0; left: 0; width: 1px; height: 1px; overflow: hidden;
         LinkInfo                    {
+            color: black;
             position: absolute;
             left: 100%;
             padding: 1ex;
@@ -520,6 +521,7 @@ var ConfigBase = Class("ConfigBase", {
         DownloadState
         DownloadTime
         DownloadTitle
+        DownloadTitle>Link>a         max-width: 48ex; overflow: hidden; display: inline-block;
 
         AddonCell                    display: table-cell; padding: 0 1ex;
 
@@ -532,7 +534,7 @@ var ConfigBase = Class("ConfigBase", {
         Addon>*;;;AddonCell
         AddonButtons
         AddonDescription
-        AddonName
+        AddonName                    max-width: 48ex; overflow: hidden;
         AddonStatus
         AddonVersion
 
diff --git a/common/modules/downloads.jsm b/common/modules/downloads.jsm
index 16c10446..b1a2ea38 100644
--- a/common/modules/downloads.jsm
+++ b/common/modules/downloads.jsm
@@ -164,8 +164,9 @@ var DownloadList = Class("DownloadList",
                          XPCOM([Ci.nsIDownloadProgressListener,
                                 Ci.nsIObserver,
                                 Ci.nsISupportsWeakReference]), {
-    init: function init(modules) {
+    init: function init(modules, filter) {
         this.modules = modules;
+        this.filter = filter && filter.toLowerCase();
         this.nodes = {
             commandTarget: this
         };
@@ -214,12 +215,15 @@ var DownloadList = Class("DownloadList",
 
     addDownload: function addDownload(id) {
         if (!(id in this.downloads)) {
-            this.downloads[id] = Download(id, this);
+            let download = Download(id, this);
+            if (this.filter && download.displayName.indexOf(this.filter) === -1)
+                return;
 
+            this.downloads[id] = download;
             let index = values(this.downloads).sort(function (a, b) a.compare(b))
-                                              .indexOf(this.downloads[id]);
+                                              .indexOf(download);
 
-            this.nodes.list.insertBefore(this.downloads[id].nodes.row,
+            this.nodes.list.insertBefore(download.nodes.row,
                                          this.nodes.list.childNodes[index + 1]);
         }
     },
@@ -302,8 +306,11 @@ var Downloads = Module("downloads", {
         commands.add(["downl[oads]", "dl"],
             "Display the downloads list",
             function (args) {
-                let downloads = DownloadList(modules);
+                let downloads = DownloadList(modules, args[0]);
                 modules.commandline.echo(downloads);
+            },
+            {
+                argCount: "?"
             });
     }
 });

From 19f35d412a67d0ffb16845f629f42d7a4aeca903 Mon Sep 17 00:00:00 2001
From: Kris Maglione <maglione.k@gmail.com>
Date: Mon, 24 Jan 2011 05:11:17 -0500
Subject: [PATCH 15/36] Remove dump statements.

--HG--
branch : key-processing
---
 common/modules/completion.jsm | 7 -------
 1 file changed, 7 deletions(-)

diff --git a/common/modules/completion.jsm b/common/modules/completion.jsm
index 8594deeb..7c352d1b 100644
--- a/common/modules/completion.jsm
+++ b/common/modules/completion.jsm
@@ -481,13 +481,6 @@ var CompletionContext = Class("CompletionContext", {
             let filtered = this.filterFunc(this._cache.constructed);
             if (this.maxItems)
                 filtered = filtered.slice(0, this.maxItems);
-            if (/types/.test(this.name)) {
-                let self = this;
-                util.dump(this.filters[1]);
-                util.dump("FILTERED", this._cache.constructed.map(function (item) [item.text.quote(), self.filters[0].call(self, item.text)]));
-                util.dump("FILTERED", this._cache.constructed.map(function (item)
-                    self.filters.map(function (filter) filter.call(self, item))));
-            }
 
             // Sorting
             if (this.sortResults && this.compare)

From af7e84210d26db75bfe38e05d29c1534dfc28285 Mon Sep 17 00:00:00 2001
From: Kris Maglione <maglione.k@gmail.com>
Date: Mon, 24 Jan 2011 06:38:51 -0500
Subject: [PATCH 16/36] Add [Opt] button to :addons. Move :extopt with the rest
 of the add-on command specs.

--HG--
branch : key-processing
---
 common/modules/addons.jsm | 89 ++++++++++++++++++---------------------
 1 file changed, 40 insertions(+), 49 deletions(-)

diff --git a/common/modules/addons.jsm b/common/modules/addons.jsm
index a1bd8272..8dad4c78 100644
--- a/common/modules/addons.jsm
+++ b/common/modules/addons.jsm
@@ -93,6 +93,18 @@ var actions = {
         filter: function ({ item }) !item.userDisabled,
         perm: "disable"
     },
+    options: {
+        name: ["exto[ptions]", "extp[references]"],
+        description: "Open an extension's preference dialog",
+        bang: true,
+        action: function (addon, bang) {
+            if (bang)
+                this.window.openDialog(addon.optionsURL, "_blank", "chrome");
+            else
+                this.dactyl.open(addon.optionsURL, { from: "extoptions" });
+        },
+        filter: function ({ item }) item.isActive && item.optionsURL
+    },
     rehash: {
         name: "extr[ehash]",
         description: "Reload an extension",
@@ -143,6 +155,7 @@ var Addon = Class("Addon", {
                     <a highlight="Button" key="disable">Off</a>
                     <a highlight="Button" key="delete">Del</a>
                     <a highlight="Button" key="update">Upd</a>
+                    <a highlight="Button" key="options">Opt</a>
                 </span>
                 <span highlight="AddonDescription" key="description"/>
             </li>,
@@ -167,7 +180,7 @@ var Addon = Class("Addon", {
 
         let action = actions[cmd];
         if (action.action)
-            action.action.call(this.modules, this);
+            action.action.call(this.list.modules, this, true);
         else
             action.actions([this], this.list.modules);
     },
@@ -324,6 +337,28 @@ var Addons = Module("addons", {
     commands: function (dactyl, modules, window) {
         const { CommandOption, commands, completion } = modules;
 
+        commands.add(["addo[ns]", "ao"],
+            "List installed extensions",
+            function (args) {
+                let addons = AddonList(modules, args["-types"], args[0]);
+                modules.commandline.echo(addons);
+
+                if (modules.commandline.savingOutput)
+                    util.waitFor(function () addons.ready);
+            },
+            {
+                argCount: "?",
+                options: [
+                    {
+                        names: ["-types", "-type", "-t"],
+                        description: "The add-on types to list",
+                        default: ["extension"],
+                        completer: function (context, args) completion.addonType(context),
+                        type: CommandOption.LIST
+                    }
+                ]
+            });
+
         let addonListener = AddonListener(modules);
 
         commands.add(["exta[dd]"],
@@ -358,17 +393,17 @@ var Addons = Module("addons", {
             let perm = command.perm && AddonManager["PERM_CAN_" + command.perm.toUpperCase()];
             function ok(addon) !perm || addon.permissions & perm;
 
-            commands.add([command.name],
+            commands.add(Array.concat(command.name),
                 command.description,
                 function (args) {
                     let name = args[0];
-                    if (args.bang)
+                    if (args.bang && !command.bang)
                         dactyl.assert(!name, "E488: Trailing characters");
                     else
                         dactyl.assert(name, "E471: Argument required");
 
                     AddonManager.getAddonsByTypes(["extension"], dactyl.wrapCallback(function (list) {
-                        if (!args.bang) {
+                        if (!args.bang || command.bang) {
                             list = list.filter(function (extension) extension.name == name);
                             if (list.length == 0)
                                 return void dactyl.echoerr("E475: Invalid argument: " + name);
@@ -378,7 +413,7 @@ var Addons = Module("addons", {
                         if (command.actions)
                             command.actions(list, this.modules);
                         else
-                            list.forEach(command.action, this.modules);
+                            list.forEach(function (addon) command.action.call(this.modules, addon, args.bang), this);
                     }));
                 }, {
                     argCount: "?", // FIXME: should be "1"
@@ -392,50 +427,6 @@ var Addons = Module("addons", {
                     literal: 0
                 });
         });
-
-        commands.add(["exto[ptions]", "extp[references]"],
-            "Open an extension's preference dialog",
-            function (args) {
-                AddonManager.getAddonsByTypes(["extension"], dactyl.wrapCallback(function (list) {
-                    list = list.filter(function (extension) extension.name == args[0]);
-                    if (!list.length || !list[0].optionsURL)
-                        dactyl.echoerr("E474: Invalid argument");
-                    else if (args.bang)
-                        window.openDialog(list[0].optionsURL, "_blank", "chrome");
-                    else
-                        dactyl.open(list[0].optionsURL, { from: "extoptions" });
-                }));
-            }, {
-                argCount: "1",
-                bang: true,
-                completer: function (context) {
-                    completion.extension(context);
-                    context.filters.push(function ({ item }) item.isActive && item.optionsURL);
-                },
-                literal: 0
-            });
-
-        commands.add(["addo[ns]", "ao"],
-            "List installed extensions",
-            function (args) {
-                let addons = AddonList(modules, args["-types"], args[0]);
-                modules.commandline.echo(addons);
-
-                if (modules.commandline.savingOutput)
-                    util.waitFor(function () addons.ready);
-            },
-            {
-                argCount: "?",
-                options: [
-                    {
-                        names: ["-types", "-type", "-t"],
-                        description: "The add-on types to list",
-                        default: ["extension"],
-                        completer: function (context, args) completion.addonType(context),
-                        type: CommandOption.LIST
-                    }
-                ]
-            });
     },
     completion: function (dactyl, modules, window) {
         completion.addonType = function addonType(context) {

From d7fd505417b97a2b2bc25c7a5fa276b5f5a5b99f Mon Sep 17 00:00:00 2001
From: Kris Maglione <maglione.k@gmail.com>
Date: Mon, 24 Jan 2011 06:42:54 -0500
Subject: [PATCH 17/36] Fix urlbar focus bug when urlbar is in the menu bar.

--HG--
branch : key-processing
---
 common/content/events.js | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/common/content/events.js b/common/content/events.js
index 95bd8519..476f8b55 100644
--- a/common/content/events.js
+++ b/common/content/events.js
@@ -950,7 +950,8 @@ var Events = Module("events", {
 
                 if (event.target instanceof Ci.nsIDOMXULTextBoxElement)
                     for (let e = elem; e instanceof Element; e = e.parentNode)
-                        if (util.computedStyle(e).visibility !== "visible") {
+                        if (util.computedStyle(e).visibility !== "visible" ||
+                                e.boxObject && e.boxObject.height === 0) {
                             elem.blur();
                             break;
                         }

From 3fd86c2ca465909e8610b5ef93b3bf00b37e0bb2 Mon Sep 17 00:00:00 2001
From: Kris Maglione <maglione.k@gmail.com>
Date: Mon, 24 Jan 2011 06:57:39 -0500
Subject: [PATCH 18/36] Make MENU mode a "main" mode.

--HG--
branch : key-processing
---
 common/content/events.js | 18 ++++++----------
 common/content/modes.js  | 44 +++++++++++++++++-----------------------
 2 files changed, 25 insertions(+), 37 deletions(-)

diff --git a/common/content/events.js b/common/content/events.js
index 476f8b55..93f297a1 100644
--- a/common/content/events.js
+++ b/common/content/events.js
@@ -923,7 +923,8 @@ var Events = Module("events", {
     events: {
         DOMMenuBarActive: function () {
             this._activeMenubar = true;
-            modes.add(modes.MENU);
+            if (modes.main != modes.MENU)
+                modes.push(modes.MENU);
         },
 
         DOMMenuBarInactive: function () {
@@ -1057,11 +1058,6 @@ var Events = Module("events", {
                         mode = Modes.StackElement(event.dactylMode);
 
                     let ignore = false;
-                    let overrideMode = null;
-
-                    // menus have their own command handlers
-                    if (modes.extended & modes.MENU)
-                        overrideMode = modes.MENU;
 
                     if (modes.main == modes.PASS_THROUGH)
                         ignore = !Events.isEscape(key) && key != "<C-v>";
@@ -1090,13 +1086,10 @@ var Events = Module("events", {
                     if (config.ignoreKeys[key] & mode.main)
                         return null;
 
-                    if (overrideMode)
-                        var keyModes = array([overrideMode]);
-                    else
-                        keyModes = array([mode.params.keyModes, mode.main, mode.main.allBases]).flatten().compact();
-
                     let hives = mappings.hives.slice(event.noremap ? -1 : 0);
 
+                    let keyModes = array([mode.params.keyModes, mode.main, mode.main.allBases]).flatten().compact();
+
                     this.processor = ProcessorStack(mode, hives, keyModes);
                 }
 
@@ -1153,7 +1146,8 @@ var Events = Module("events", {
 
         popupshown: function onPopupShown(event) {
             if (event.originalTarget.localName !== "tooltip" && event.originalTarget.id !== "dactyl-visualbell")
-                modes.add(modes.MENU);
+                if (modes.main != modes.MENU)
+                    modes.push(modes.MENU);
         },
 
         popuphidden: function onPopupHidden() {
diff --git a/common/content/modes.js b/common/content/modes.js
index b4a89b0a..422bbee1 100644
--- a/common/content/modes.js
+++ b/common/content/modes.js
@@ -155,6 +155,11 @@ var Modes = Module("modes", {
             bases: []
         });
 
+        this.addMode("MENU", {
+            description: "Active when a menu or other pop-up is open",
+            input: true
+        });
+
         // this._extended modes, can include multiple modes, and even main modes
         this.addMode("EX", {
             extended: true,
@@ -172,14 +177,9 @@ var Modes = Module("modes", {
             hidden: true,
             input: true
         });
-        this.addMode("MENU", {
-            extended: true,
-            input: true,
-            description: "Active when a menu or other pop-up is open",
-        }); // a popupmenu is active
         this.addMode("LINE", {
             extended: true, hidden: true
-        }); // linewise visual mode
+        });
         this.addMode("PROMPT", {
             extended: true,
             description: "Active when a prompt is open in the command line",
@@ -219,14 +219,9 @@ var Modes = Module("modes", {
         else if (modes.replaying)
             macromode = "replaying";
 
-        let ext = "";
-        if (this._extended & modes.MENU) // TODO: desirable?
-            ext += " (menu)";
-        ext += " --" + macromode;
-
         let val = this._modeMap[this._main].display();
         if (val)
-            return "-- " + val + ext;
+            return "-- " + val + " --" + macromode;;
         return macromode;
     },
 
@@ -270,6 +265,8 @@ var Modes = Module("modes", {
 
     getStack: function (idx) this._modeStack[this._modeStack.length - idx - 1] || this._modeStack[0],
 
+    get stack() this._modeStack.slice(),
+
     getCharModes: function (chr) (this.modeChars[chr] || []).slice(),
 
     matchModes: function (obj)
@@ -285,10 +282,11 @@ var Modes = Module("modes", {
             commandline.widgets.mode = msg || null;
     },
 
-    // add/remove always work on the this._extended mode only
-    add: function add(mode) {
-        this._extended |= mode;
-        this.show();
+    remove: function remove(mode) {
+        if (this.stack.some(function (m) m.main == mode)) {
+            this.pop(mode);
+            this.pop();
+        }
     },
 
     delayed: [],
@@ -391,13 +389,6 @@ var Modes = Module("modes", {
             this.pop();
     },
 
-    remove: function remove(mode) {
-        if (this._extended & mode) {
-            this._extended &= ~mode;
-            this.show();
-        }
-    },
-
     get recording() this._recording,
     set recording(value) { this._recording = value; this.show(); },
 
@@ -505,10 +496,13 @@ var Modes = Module("modes", {
             "Return to the previous mode",
             function () { modes.pop(); });
 
-        mappings.add([modes.MENU],
-            ["<Esc>", "<C-[>"],
+        mappings.add([modes.MENU], ["<Esc>"],
             "Close the current popup",
             function () Events.PASS);
+
+        mappings.add([modes.MENU], ["<C-[>"],
+            "Close the current popup",
+            function () { events.feedkeys("<Esc>") });
     },
     prefs: function () {
         prefs.watch("accessibility.browsewithcaret", modes.closure.onCaretChange);

From 1d08056350e0fa9678ad5f24653e7f1afb7e9979 Mon Sep 17 00:00:00 2001
From: Kris Maglione <maglione.k@gmail.com>
Date: Mon, 24 Jan 2011 07:46:09 -0500
Subject: [PATCH 19/36] Fix copyright info in addons.jsm.

--HG--
branch : key-processing
---
 common/modules/addons.jsm | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/common/modules/addons.jsm b/common/modules/addons.jsm
index 8dad4c78..80090bb7 100644
--- a/common/modules/addons.jsm
+++ b/common/modules/addons.jsm
@@ -1,4 +1,5 @@
-// Copyright (c) 2011 by Kris Maglione <maglione.k@gmail.com>
+// Copyright (c) 2009-2011 by Kris Maglione <maglione.k@gmail.com>
+// Copyright (c) 2009-2010 by Doug Kearns <dougkearns@gmail.com>
 //
 // This work is licensed for reuse under an MIT license. Details are
 // given in the LICENSE.txt file included with this file.

From 8980c91978a872c5c508bb0f3d8bdd03baec5707 Mon Sep 17 00:00:00 2001
From: Kris Maglione <maglione.k@gmail.com>
Date: Mon, 24 Jan 2011 08:53:58 -0500
Subject: [PATCH 20/36] Linkify 'restart' in :addons.

--HG--
branch : key-processing
---
 common/content/dactyl.js  | 3 +++
 common/modules/addons.jsm | 8 ++++++--
 common/skin/dactyl.css    | 3 +++
 3 files changed, 12 insertions(+), 2 deletions(-)

diff --git a/common/content/dactyl.js b/common/content/dactyl.js
index 8c65f810..d169299d 100644
--- a/common/content/dactyl.js
+++ b/common/content/dactyl.js
@@ -37,6 +37,9 @@ var Dactyl = Module("dactyl", XPCOM(Ci.nsISupportsWeakReference, ModuleBase), {
             let elem = event.originalTarget;
             dactyl.help(elem.getAttribute("tag") || elem.textContent);
         };
+        this.commands["dactyl.restart"] = function (event) {
+            dactyl.restart();
+        };
     },
 
     cleanup: function () {
diff --git a/common/modules/addons.jsm b/common/modules/addons.jsm
index 80090bb7..ed971c1c 100644
--- a/common/modules/addons.jsm
+++ b/common/modules/addons.jsm
@@ -145,6 +145,7 @@ var Addon = Class("Addon", {
         this.nodes = {
             commandTarget: this
         };
+        XML.ignoreWhitespace = true;
         util.xmlToDom(
             <li highlight="Addon" key="row" xmlns:dactyl={NS} xmlns={XHTML}>
                 <span highlight="AddonName" key="name">
@@ -189,6 +190,9 @@ var Addon = Class("Addon", {
     compare: function compare(other) String.localeCompare(this.name, other.name),
 
     get statusInfo() {
+        XML.ignoreWhitespace = XML.prettyPrinting = false;
+        default xml namespace = XHTML;
+
         let info = this.isActive ? <span highlight="Enabled">enabled</span>
                                  : <span highlight="Disabled">disabled</span>;
 
@@ -205,7 +209,7 @@ var Addon = Class("Addon", {
             pending = ["Enabled", "upgraded"];
         if (pending)
             return <>{info}&#xa0;(<span highlight={pending[0]}>{pending[1]}</span>
-                                  &#xa0;on restart)</>;
+                                  &#xa0;on <a href="#" dactyl:command="dactyl.restart" xmlns:dactyl={NS}>restart</a>)</>;
         return info;
     },
 
@@ -269,6 +273,7 @@ var AddonList = Class("AddonList", {
 
     message: Class.memoize(function () {
 
+        XML.ignoreWhitespace = true;
         util.xmlToDom(<ul highlight="Addons" key="list" xmlns={XHTML}>
                         <li highlight="AddonHead">
                             <span>Name</span>
@@ -535,7 +540,6 @@ var addonErrors = array.toObject([
     [AddonManager.ERROR_CORRUPT_FILE,    "The file appears to be corrupt"],
     [AddonManager.ERROR_FILE_ACCESS,     "There was an error accessing the filesystem"]]);
 
-
 endModule();
 
 } catch(e){ if (isString(e)) e = Error(e); dump(e.fileName+":"+e.lineNumber+": "+e+"\n" + e.stack); }
diff --git a/common/skin/dactyl.css b/common/skin/dactyl.css
index 116df39b..43788990 100644
--- a/common/skin/dactyl.css
+++ b/common/skin/dactyl.css
@@ -83,6 +83,9 @@ input[type=file][dactyl|highlight~=HintElem] {
     url-prefix(dactyl:),
     url-prefix(resource://dactyl) {
 
+*:-moz-any-link {
+    color: green;
+}
 *:-moz-any-link:hover {
     text-decoration: underline;
 }

From 304d4fffd73bc366a6de1cd064d5260835b7f355 Mon Sep 17 00:00:00 2001
From: Kris Maglione <maglione.k@gmail.com>
Date: Mon, 24 Jan 2011 09:21:31 -0500
Subject: [PATCH 21/36] Fix wheel scrolling in the MOW.

--HG--
branch : key-processing
---
 common/content/commandline.js | 11 +++++++----
 common/content/dactyl.js      |  1 +
 common/content/events.js      |  1 +
 common/content/statusline.js  |  1 +
 common/modules/addons.jsm     |  6 +++---
 common/skin/dactyl.css        |  1 -
 6 files changed, 13 insertions(+), 8 deletions(-)

diff --git a/common/content/commandline.js b/common/content/commandline.js
index e0e969ee..3581f1ff 100644
--- a/common/content/commandline.js
+++ b/common/content/commandline.js
@@ -12,6 +12,7 @@ var CommandWidgets = Class("CommandWidgets", {
     init: function () {
         let _status = "dactyl-statusline-field-";
 
+        XML.ignoreWhitespace = true;
         util.overlayWindow(window, {
             append: <e4x xmlns={XUL} xmlns:dactyl={NS}>
                 <window id={document.documentElement.id}>
@@ -166,10 +167,9 @@ var CommandWidgets = Class("CommandWidgets", {
         let fontSize = util.computedStyle(document.documentElement).fontSize;
         styles.registerSheet("resource://dactyl-skin/dactyl.css");
         styles.system.add("font-size", "dactyl://content/buffer.xhtml",
-                          "body { font-size: " + fontSize + "; }");
-    },
-    cleanup: function cleanup() {
-        styles.unregisterSheet("resource://dactyl-skin/dactyl.css");
+                          "body { font-size: " + fontSize + "; } \
+                           html|html > xul|scrollbar { visibility: collapse !important; }",
+                          true);
     },
     addElement: function (obj) {
         const self = this;
@@ -474,6 +474,9 @@ var CommandLine = Module("commandline", {
                 dactyl.trapErrors(callback, self, value != null ? value : commandline.command);
         }
     },
+    cleanup: function cleanup() {
+        styles.unregisterSheet("resource://dactyl-skin/dactyl.css");
+    },
 
     /**
      * Determines whether the command line should be visible.
diff --git a/common/content/dactyl.js b/common/content/dactyl.js
index d169299d..f05f893e 100644
--- a/common/content/dactyl.js
+++ b/common/content/dactyl.js
@@ -212,6 +212,7 @@ var Dactyl = Module("dactyl", XPCOM(Ci.nsISupportsWeakReference, ModuleBase), {
                 bell: document.getElementById("dactyl-bell"),
                 strut: document.getElementById("dactyl-bell-strut")
             }
+            XML.ignoreWhitespace = true;
             if (!elems.bell)
                 util.overlayWindow(window, {
                     objects: elems,
diff --git a/common/content/events.js b/common/content/events.js
index 93f297a1..163aab60 100644
--- a/common/content/events.js
+++ b/common/content/events.js
@@ -223,6 +223,7 @@ var Events = Module("events", {
     init: function () {
         const self = this;
 
+        XML.ignoreWhitespace = true;
         util.overlayWindow(window, {
             append: <e4x xmlns={XUL}>
                 <window id={document.documentElement.id}>
diff --git a/common/content/statusline.js b/common/content/statusline.js
index 84bafca4..090366ed 100644
--- a/common/content/statusline.js
+++ b/common/content/statusline.js
@@ -39,6 +39,7 @@ var StatusLine = Module("statusline", {
             ]]>)({ padding: util.OS.isMacOSX ? "padding-right: 10px !important;" : "" }));
         }
 
+        XML.ignoreWhitespace = true;
         let _commandline = "if (window.dactyl) return dactyl.modules.commandline";
         let prepend = <e4x xmlns={XUL} xmlns:dactyl={NS}>
             <statusbar id="status-bar" highlight="StatusLine">
diff --git a/common/modules/addons.jsm b/common/modules/addons.jsm
index ed971c1c..f3778cff 100644
--- a/common/modules/addons.jsm
+++ b/common/modules/addons.jsm
@@ -83,14 +83,14 @@ var actions = {
     enable: {
         name: "exte[nable]",
         description: "Enable an extension",
-        action: function (addon) addon.userDisabled = false,
+        action: function (addon) { addon.userDisabled = false; },
         filter: function ({ item }) item.userDisabled,
         perm: "enable"
     },
     disable: {
         name: "extd[isable]",
         description: "Disable an extension",
-        action: function (addon) addon.userDisabled = true,
+        action: function (addon) { addon.userDisabled = true; },
         filter: function ({ item }) !item.userDisabled,
         perm: "disable"
     },
@@ -125,7 +125,7 @@ var actions = {
     toggle: {
         name: "extt[oggle]",
         description: "Toggle an extension's enabled status",
-        action: function (addon) addon.userDisabled = !addon.userDisabled
+        action: function (addon) { addon.userDisabled = !addon.userDisabled; }
     },
     update: {
         name: "extu[pdate]",
diff --git a/common/skin/dactyl.css b/common/skin/dactyl.css
index 43788990..df1c4cfe 100644
--- a/common/skin/dactyl.css
+++ b/common/skin/dactyl.css
@@ -187,7 +187,6 @@ statusbarpanel {
 .dactyl-completions,
 #dactyl-multiline-output,
 #dactyl-multiline-input {
-    overflow: hidden;
     background-color: white;
     color: black;
 }

From 56777f59c313fbe94671ab5b0b738507cbfc193b Mon Sep 17 00:00:00 2001
From: Kris Maglione <maglione.k@gmail.com>
Date: Mon, 24 Jan 2011 10:14:01 -0500
Subject: [PATCH 22/36] Add totals columns to the download manager.

--HG--
branch : key-processing
---
 common/modules/downloads.jsm | 33 ++++++++++++++++++++++++++++-----
 common/modules/util.jsm      |  3 ++-
 2 files changed, 30 insertions(+), 6 deletions(-)

diff --git a/common/modules/downloads.jsm b/common/modules/downloads.jsm
index b1a2ea38..a7ee8ed8 100644
--- a/common/modules/downloads.jsm
+++ b/common/modules/downloads.jsm
@@ -190,15 +190,18 @@ var DownloadList = Class("DownloadList",
                             <span>Source</span>
                         </li>
                         <li highlight="Download"><span><div style="min-height: 1ex; /* FIXME */"/></span></li>
-                        <li highlight="Download" key="totals">
-                            <span highlight="Title">Totals:</span>
+                        <li highlight="Download" key="totals" active="true">
+                            <span><span highlight="Title">Totals:</span>&#xa0;<span key="total"/></span>
                             <span/>
                             <span highlight="DownloadButtons">
                                 <a highlight="Button" key="clear">Clear</a>
                             </span>
-                            <span/>
-                            <span/>
-                            <span/>
+                            <span highlight="DownloadProgress" key="progress">
+                                <span highlight="DownloadProgressHave" key="progressHave"
+                                />/<span highlight="DownloadProgressTotal" key="progressTotal"/>
+                            </span>
+                            <span highlight="DownloadPercent" key="percent"/>
+                            <span highlight="DownloadTime" key="time"/>
                             <span/>
                         </li>
                       </ul>, this.document, this.nodes);
@@ -253,6 +256,25 @@ var DownloadList = Class("DownloadList",
         for (let node in values(this.nodes))
             if (node.update && node.update != update)
                 node.update();
+        this.updateProgress();
+    },
+
+    timeRemaining: Infinity,
+
+    updateProgress: function updateProgress() {
+        let downloads = values(this.downloads).toArray();
+
+        let self = Object.create(this);
+        for (let prop in values(["amountTransferred", "size", "speed", "timeRemaining"]))
+            this[prop] = downloads.reduce(function (acc, dl) dl[prop] + acc, 0);
+
+        Download.prototype.updateProgress.call(self);
+
+        let active = downloads.filter(function (dl) dl.alive).length;
+        if (active)
+            this.nodes.total.textContent = active + " active";
+        else for (let key in values(["total", "percent", "time"]))
+            this.nodes[key].textContent = "";
     },
 
     observers: {
@@ -290,6 +312,7 @@ var DownloadList = Class("DownloadList",
         try {
             if (download.id in this.downloads)
                 this.downloads[download.id].updateProgress();
+            this.updateProgress();
         }
         catch (e) {
             util.reportError(e);
diff --git a/common/modules/util.jsm b/common/modules/util.jsm
index a58a116e..7ee979c8 100644
--- a/common/modules/util.jsm
+++ b/common/modules/util.jsm
@@ -672,6 +672,7 @@ var Util = Module("Util", XPCOM([Ci.nsIObserver, Ci.nsISupportsWeakReference]),
      * @returns {string}
      */
     formatSeconds: function formatSeconds(seconds) {
+        function pad(n, val) ("0000000" + val).substr(-Math.max(n, String(val).length));
         function div(num, denom) [Math.round(num / denom), Math.round(num % denom)];
         let days, hours, minutes;
 
@@ -683,7 +684,7 @@ var Util = Module("Util", XPCOM([Ci.nsIObserver, Ci.nsISupportsWeakReference]),
         if (hours)
             return hours + "h " + minutes + "m";
         if (minutes)
-            return minutes + ":" + seconds;
+            return minutes + ":" + pad(2, seconds);
         return seconds + "s";
     },
 

From 97861715205fecd171da81241137fede5e571e23 Mon Sep 17 00:00:00 2001
From: Kris Maglione <maglione.k@gmail.com>
Date: Mon, 24 Jan 2011 12:50:08 -0500
Subject: [PATCH 23/36] Get rid of horrible coalesced event handlers in
 commandline.js.

--HG--
branch : key-processing
---
 common/content/commandline.js | 297 ++++++++++++++++------------------
 common/content/events.js      |   4 +-
 common/content/hints.js       |   2 +-
 common/content/modes.js       |   4 +-
 common/content/statusline.js  |   9 +-
 common/modules/addons.jsm     |  26 ++-
 common/modules/highlight.jsm  |  13 +-
 common/modules/overlay.jsm    |   8 +-
 common/modules/template.jsm   |  10 ++
 common/modules/util.jsm       |  14 +-
 10 files changed, 181 insertions(+), 206 deletions(-)

diff --git a/common/content/commandline.js b/common/content/commandline.js
index 3581f1ff..819ec0c5 100644
--- a/common/content/commandline.js
+++ b/common/content/commandline.js
@@ -9,11 +9,16 @@
 /** @scope modules */
 
 var CommandWidgets = Class("CommandWidgets", {
-    init: function () {
-        let _status = "dactyl-statusline-field-";
+    depends: ["statusline"],
+
+    init: function init() {
+        let s = "dactyl-statusline-field-";
 
         XML.ignoreWhitespace = true;
         util.overlayWindow(window, {
+            objects: {
+                eventTarget: commandline
+            },
             append: <e4x xmlns={XUL} xmlns:dactyl={NS}>
                 <window id={document.documentElement.id}>
                     <popupset>
@@ -39,16 +44,15 @@ var CommandWidgets = Class("CommandWidgets", {
 
                     <vbox class="dactyl-container" id="dactyl-multiline-output-container" hidden="false" collapsed="true">
                         <iframe id="dactyl-multiline-output" src="dactyl://content/buffer.xhtml"
-                                flex="1" hidden="false" collapsed="false"
-                                contextmenu="dactyl-contextmenu"
-                                onclick="dactyl.modules.commandline.onMultilineOutputEvent(event)"/>
+                                flex="1" hidden="false" collapsed="false" contextmenu="dactyl-contextmenu"
+                                highlight="Events" events="multilineOutputEvents" />
                     </vbox>
 
                     <vbox class="dactyl-container" hidden="false" collapsed="true">
                         <iframe class="dactyl-completions" id="dactyl-completions-dactyl-commandline" src="dactyl://content/buffer.xhtml"
                                 contextmenu="dactyl-contextmenu"
                                 flex="1" hidden="false" collapsed="false"
-                                onclick="dactyl.modules.commandline.onMultilineOutputEvent(event)"/>
+                                highlight="Events" events="multilineOutputEvents" />
                     </vbox>
 
                     <stack orient="horizontal" align="stretch" class="dactyl-container" id="dactyl-container" highlight="CmdLine CmdCmdLine">
@@ -59,30 +63,31 @@ var CommandWidgets = Class("CommandWidgets", {
                         <hbox id="dactyl-commandline" hidden="false" class="dactyl-container" highlight="Normal CmdNormal" collapsed="true">
                             <label   id="dactyl-commandline-prompt"  class="dactyl-commandline-prompt  plain" flex="0" crop="end" value="" collapsed="true"/>
                             <textbox id="dactyl-commandline-command" class="dactyl-commandline-command plain" flex="1" type="input" timeout="100"
-                                     oninput="dactyl.modules.commandline.onEvent(event);"
-                                     onkeyup="dactyl.modules.commandline.onEvent(event);"
-                                     onfocus="dactyl.modules.commandline.onEvent(event);"
-                                     onblur="dactyl.modules.commandline.onEvent(event);"/>
+                                     highlight="Events" />
                         </hbox>
                     </stack>
 
                     <vbox class="dactyl-container" hidden="false" collapsed="false" highlight="CmdLine">
                         <textbox id="dactyl-multiline-input" class="plain" flex="1" rows="1" hidden="false" collapsed="true" multiline="true"
-                                 highlight="Normal"
-                                 onkeypress="dactyl.modules.commandline.onMultilineInputEvent(event);"
-                                 oninput="dactyl.modules.commandline.onMultilineInputEvent(event);"
-                                 onblur="dactyl.modules.commandline.onMultilineInputEvent(event);"/>
+                                 highlight="Normal Events" events="multilineInputEvents" />
                     </vbox>
                 </vbox>
+
+                <stack id="dactyl-statusline-stack">
+                    <hbox id={s + "commandline"} hidden="false" class="dactyl-container" highlight="Normal StatusNormal" collapsed="true">
+                        <label id={s + "commandline-prompt"}    class="dactyl-commandline-prompt  plain" flex="0" crop="end" value="" collapsed="true"/>
+                        <textbox id={s + "commandline-command"} class="dactyl-commandline-command plain" flex="1" type="text" timeout="100"
+                                 highlight="Events" />
+                    </hbox>
+                </stack>
             </e4x>.elements(),
 
             before: <e4x xmlns={XUL} xmlns:dactyl={NS}>
                 <toolbar id={statusline.statusBar.id}>
-                    <vbox id={"dactyl-completions-" + _status + "commandline-container"} class="dactyl-container" hidden="false" collapsed="true">
-                        <iframe class="dactyl-completions" id={"dactyl-completions-" + _status + "commandline"} src="dactyl://content/buffer.xhtml"
-                                contextmenu="dactyl-contextmenu"
-                                flex="1" hidden="false" collapsed="false"
-                                onclick="dactyl.modules.commandline.onMultilineOutputEvent(event)"/>
+                    <vbox id={"dactyl-completions-" + s + "commandline-container"} class="dactyl-container" hidden="false" collapsed="true">
+                        <iframe class="dactyl-completions" id={"dactyl-completions-" + s + "commandline"} src="dactyl://content/buffer.xhtml"
+                                contextmenu="dactyl-contextmenu" flex="1" hidden="false" collapsed="false"
+                                highlight="Events" events="multilineOutputEvents" />
                     </vbox>
                 </toolbar>
             </e4x>.elements()
@@ -171,7 +176,7 @@ var CommandWidgets = Class("CommandWidgets", {
                            html|html > xul|scrollbar { visibility: collapse !important; }",
                           true);
     },
-    addElement: function (obj) {
+    addElement: function addElement(obj) {
         const self = this;
         this.elements[obj.name] = obj;
 
@@ -185,13 +190,13 @@ var CommandWidgets = Class("CommandWidgets", {
 
         if (!(obj.noValue || obj.getValue))
             Object.defineProperty(this, obj.name, Modes.boundProperty({
-                get: function () {
+                get: function get_widgetValue() {
                     let elem = self.getGroup(obj.name, obj.value)[obj.name];
                     if (obj.value != null)
                         return [obj.value[0], obj.get ? obj.get.call(this, elem) : elem.value];
                     return null;
                 },
-                set: function (val) {
+                set: function set_widgetValue(val) {
                     if (val != null && !isArray(val))
                         val = [obj.defaultGroup || "", val];
                     obj.value = val;
@@ -222,12 +227,12 @@ var CommandWidgets = Class("CommandWidgets", {
                                                      .map(function (g) g + " " + nodeSet.group + g).join(" "));
             });
     },
-    getGroup: function (name, value) {
+    getGroup: function getgroup(name, value) {
         if (!statusline.visible)
             return this.commandbar;
         return this.elements[name].getGroup.call(this, arguments.length > 1 ? value : this[name]);
     },
-    updateVisibility: function () {
+    updateVisibility: function updateVisibility() {
         for (let elem in values(this.elements))
             if (elem.getGroup) {
                 let value = elem.getValue ? elem.getValue.call(this)
@@ -260,10 +265,10 @@ var CommandWidgets = Class("CommandWidgets", {
     commandbar: Class.memoize(function () ({ group: "Cmd" })),
     statusbar: Class.memoize(function ()  ({ group: "Status" })),
 
-    _whenReady: function (name, id, processor) {
+    _whenReady: function _whenReady(name, id, processor) {
         Object.defineProperty(this, name, {
             configurable: true, enumerable: true,
-            get: function () {
+            get: function get_whenReady() {
                 let elem = document.getElementById(id);
                 while (elem.contentDocument.documentURI != elem.getAttribute("src") ||
                        ["viewable", "complete"].indexOf(elem.contentDocument.readyState) < 0)
@@ -295,7 +300,7 @@ var CommandWidgets = Class("CommandWidgets", {
     multilineInput: Class.memoize(function () document.getElementById("dactyl-multiline-input")),
     mowContainer: Class.memoize(function () document.getElementById("dactyl-multiline-output-container"))
 }, {
-    getEditor: function (elem) {
+    getEditor: function getEditor(elem) {
         elem.inputField.QueryInterface(Ci.nsIDOMNSEditableElement);
         return elem;
     }
@@ -308,7 +313,7 @@ var CommandWidgets = Class("CommandWidgets", {
  * this class when the chrome is ready.
  */
 var CommandLine = Module("commandline", {
-    init: function () {
+    init: function init() {
         const self = this;
 
         this._callbacks = {};
@@ -489,7 +494,7 @@ var CommandLine = Module("commandline", {
     /**
      * Ensure that the multiline input widget is the correct size.
      */
-    _autosizeMultilineInputWidget: function () {
+    _autosizeMultilineInputWidget: function _autosizeMultilineInputWidget() {
         let lines = this.widgets.multilineInput.value.split("\n").length - 1;
 
         this.widgets.multilineInput.setAttribute("rows", Math.max(lines, 1));
@@ -538,13 +543,13 @@ var CommandLine = Module("commandline", {
     //  "change"
     //  "cancel"
     //  "complete"
-    registerCallback: function (type, mode, func) {
+    registerCallback: function registerCallback(type, mode, func) {
         if (!(type in this._callbacks))
             this._callbacks[type] = {};
         this._callbacks[type][mode] = func;
     },
 
-    triggerCallback: function (type, mode) {
+    triggerCallback: function triggerCallback(type, mode) {
         if (this._callbacks[type] && this._callbacks[type][mode])
             try {
                 this._callbacks[type][mode].apply(this, Array.slice(arguments, 2));
@@ -554,14 +559,14 @@ var CommandLine = Module("commandline", {
             }
     },
 
-    runSilently: function (func, self) {
+    runSilently: function runSilently(func, self) {
         this.withSavedValues(["_silent"], function () {
             this._silent = true;
             func.call(self);
         });
     },
 
-    hideCompletions: function () {
+    hideCompletions: function hideCompletions() {
         for (let nodeSet in values([this.widgets.statusbar, this.widgets.commandbar]))
             if (nodeSet.commandline._completionList)
                 nodeSet.commandline._completionList.hide();
@@ -575,10 +580,10 @@ var CommandLine = Module("commandline", {
     messages: Modes.boundProperty(),
 
     multilineInputVisible: Modes.boundProperty({
-        set: function (value) { this.widgets.multilineInput.collapsed = !value; }
+        set: function set_miwVisible(value) { this.widgets.multilineInput.collapsed = !value; }
     }),
     multilineOutputVisible: Modes.boundProperty({
-        set: function (value) {
+        set: function set_mowVisible(value) {
             this.widgets.mowContainer.collapsed = !value;
             let elem = this.widgets.multilineOutput;
             if (!value && elem && elem.contentWindow == document.commandDispatcher.focusedWindow)
@@ -602,7 +607,7 @@ var CommandLine = Module("commandline", {
         this.currentExtendedMode = extendedMode || null;
         modes.push(modes.COMMAND_LINE, this.currentExtendedMode, {
             autocomplete: cmd.length,
-            onEvent: this.closure.onEvent,
+            onKeyPress: this.closure.onKeyPress,
             history: (extendedMode || {}).params.history,
             leave: function (params) {
                 if (params.pop)
@@ -671,7 +676,7 @@ var CommandLine = Module("commandline", {
     get lastCommand() this._lastCommand || this.command,
     set lastCommand(val) { this._lastCommand = val },
 
-    clear: function () {
+    clear: function clear() {
         if (this.widgets.message && this.widgets.message[1] === this._lastClearable)
             this.widgets.message = null;
         if (modes.main != modes.COMMAND_LINE)
@@ -688,7 +693,7 @@ var CommandLine = Module("commandline", {
      *
      * @param {XML} xml The output as an E4X XML object.
      */
-    commandOutput: function (xml) {
+    commandOutput: function commandOutput(xml) {
         XML.ignoreWhitespace = false;
         XML.prettyPrinting = false;
         if (this.command)
@@ -747,7 +752,7 @@ var CommandLine = Module("commandline", {
         this._startHints = false;
         if (modes.main != modes.OUTPUT_MULTILINE) {
             modes.push(modes.OUTPUT_MULTILINE, null, {
-                onEvent: this.closure.onMultilineOutputEvent,
+                onKeyPress: this.closure.onMOWKeyPress,
                 leave: this.closure(function leave(stack) {
                     if (stack.pop)
                         for (let message in values(this.messages))
@@ -906,7 +911,7 @@ var CommandLine = Module("commandline", {
 
         modes.push(modes.COMMAND_LINE, modes.PROMPT | extra.extended,
                    update(Object.create(extra), {
-                       onEvent: extra.onEvent || this.closure.onEvent,
+                       onKeyPress: extra.onEvent || this.closure.onKeyPress,
                        leave: function leave(stack) {
                            commandline.leave(stack);
                            leave.supercall(extra, stack);
@@ -922,7 +927,7 @@ var CommandLine = Module("commandline", {
         this.enter();
     },
 
-    readHeredoc: function (end) {
+    readHeredoc: function readHeredoc(end) {
         let args;
         commandline.inputMultiline(end,
             function (res) { args = res; });
@@ -946,7 +951,7 @@ var CommandLine = Module("commandline", {
         if (cmd != false)
             this._echoLine(cmd, this.HL_NORMAL);
 
-        // save the arguments, they are needed in the event handler onEvent
+        // save the arguments, they are needed in the event handler onKeyPress
         this._multilineEnd = "\n" + end + "\n";
         this._multilineCallback = callbackFunc;
 
@@ -976,53 +981,36 @@ var CommandLine = Module("commandline", {
         return true;
     },
 
-    /**
-     * Handles all command-line events. All key events are passed here when
-     * COMMAND_LINE mode is active, as well as all input, keyup, focus, and
-     * blur events sent to the command-line XUL element.
-     *
-     * @param {Event} event
-     * @private
-     */
-    onEvent: function onEvent(event) {
-        const KILL = false, PASS = true;
+    onKeyPress: function onKeyPress(event) {
+        let key = events.toString(event);
+        if (this._completions)
+            this._completions.previewClear();
 
-        try {
-            let command = this.command;
+        return true; /* Pass event */
+    },
 
-            if (event.type == "blur") {
-                this.timeout(function () {
-                    if (this.commandVisible && event.originalTarget == this.widgets.active.command.inputField)
-                        dactyl.focus(this.widgets.active.command.inputField);
-                });
-            }
-            else if (event.type == "focus") {
-                if (!this.commandVisible && event.target == this.widgets.active.command.inputField) {
-                    event.target.blur();
-                    dactyl.beep();
-                }
-            }
-            else if (event.type == "input") {
-                this.resetCompletions();
-                commandline.triggerCallback("change", this.currentExtendedMode, command);
-            }
-            else if (event.type == "keypress") {
-                let key = events.toString(event);
-                if (this._completions)
-                    this._completions.previewClear();
-
-                return PASS;
-            }
-            else if (event.type == "keyup") {
-                let key = events.toString(event);
-                if (/^<(?:A-)?(?:S-)?Tab>$/.test(key))
-                    this._tabTimer.flush();
+    events: {
+        blur: function onBlur(event) {
+            this.timeout(function () {
+                if (this.commandVisible && event.originalTarget == this.widgets.active.command.inputField)
+                    dactyl.focus(this.widgets.active.command.inputField);
+            });
+        },
+        focus: function onFocus(event) {
+            if (!this.commandVisible && event.target == this.widgets.active.command.inputField) {
+                event.target.blur();
+                dactyl.beep();
             }
+        },
+        input: function onInput(event) {
+            this.resetCompletions();
+            this.triggerCallback("change", this.currentExtendedMode, this.command);
+        },
+        keyup: function onKeyUp(event) {
+            let key = events.toString(event);
+            if (/-?Tab>$/.test(key))
+                this._tabTimer.flush();
         }
-        catch (e) {
-            dactyl.reportError(e, true);
-        }
-        return PASS;
     },
 
     /**
@@ -1031,10 +1019,17 @@ var CommandLine = Module("commandline", {
      *
      * @param {Event} event
      */
-    onMultilineInputEvent: function onMultilineInputEvent(event) {
-        const KILL = false, PASS = true;
-
-        if (event.type == "keypress") {
+    multilineInputEvents: {
+        blur: function onBlur(event) {
+            if (modes.extended & modes.INPUT_MULTILINE)
+                this.timeout(function () {
+                    dactyl.focus(this.widgets.multilineInput.inputField);
+                });
+        },
+        input: function onInput(event) {
+            this._autosizeMultilineInputWidget();
+        },
+        keypress: function onKeyPress(event) {
             let key = events.toString(event);
             if (events.isAcceptKey(key)) {
                 let text = "\n" + this.widgets.multilineInput.value.substr(0, this.widgets.multilineInput.selectionStart) + "\n";
@@ -1050,78 +1045,52 @@ var CommandLine = Module("commandline", {
                 modes.pop();
             }
         }
-        else if (event.type == "blur") {
-            if (modes.extended & modes.INPUT_MULTILINE)
-                this.timeout(function () { dactyl.focus(this.widgets.multilineInput.inputField); }, 0);
-        }
-        else if (event.type == "input")
-            this._autosizeMultilineInputWidget();
-        return PASS;
     },
 
-    /**
-     * Handle events when we are in multi-line output mode, these come from
-     * dactyl when modes.extended & modes.OUTPUT_MULTILINE and also from
-     * #dactyl-multiline-output in the XUL.
-     *
-     * @param {Event} event
-     */
-    // FIXME: if 'more' is set and the MOW is not scrollable we should still
-    // allow a down motion after an up rather than closing
-    onMultilineOutputEvent: function onMultilineOutputEvent(event) {
-        try {
-            const KILL = false, PASS = true;
-
-            let win = this.widgets.multilineOutput.contentWindow;
-            let elem = win.document.documentElement;
-
-            let key = events.toString(event);
+    multilineOutputEvents: {
+        click: function onClick(event) {
+            if (event.getPreventDefault())
+                return;
 
             const openLink = function openLink(where) {
                 event.preventDefault();
                 dactyl.open(event.target.href, where);
             }
 
-            // TODO: Wouldn't multiple handlers be cleaner? --djk
-            if (event.type == "click" && event.target instanceof HTMLAnchorElement) {
-
-                if (event.getPreventDefault())
-                    return;
-
-                switch (key) {
+            if (event.target instanceof HTMLAnchorElement)
+                switch (events.toString(event)) {
                 case "<LeftMouse>":
-                    event.preventDefault();
                     openLink(dactyl.CURRENT_TAB);
-                    return KILL;
+                    break;
                 case "<MiddleMouse>":
                 case "<C-LeftMouse>":
                 case "<C-M-LeftMouse>":
                     openLink({ where: dactyl.NEW_TAB, background: true });
-                    return KILL;
+                    break;
                 case "<S-MiddleMouse>":
                 case "<C-S-LeftMouse>":
                 case "<C-M-S-LeftMouse>":
                     openLink({ where: dactyl.NEW_TAB, background: false });
-                    return KILL;
+                    break;
                 case "<S-LeftMouse>":
                     openLink(dactyl.NEW_WINDOW);
-                    return KILL;
+                    break;
                 }
-                return PASS;
-            }
-
-            if (event instanceof MouseEvent)
-                return KILL;
-
-            if (!options["more"] || !mow.isScrollable(1)) {
-                modes.pop();
-                events.feedkeys(key);
-            }
-            else
-                commandline.updateMorePrompt(false, true);
+        },
+        unload: function onUnload(event) {
+            event.preventDefault();
         }
-        catch (e) {
-            util.reportError(e);
+    },
+
+    onMOWKeyPress: function onMOWKeyPress(event) {
+        const KILL = false, PASS = true;
+
+        if (options["more"] && mos.isScrollable(1))
+            commandline.updateMorePrompt(false, true);
+        else {
+            modes.pop();
+            events.feedkeys(events.toString(event));
+            return KILL;
         }
         return PASS;
     },
@@ -1190,7 +1159,7 @@ var CommandLine = Module("commandline", {
             this._history.reset();
     },
 
-    withOutputToString: function (fn, self) {
+    withOutputToString: function withOutputToString(fn, self) {
         dactyl.registerObserver("echoLine", observe, true);
         dactyl.registerObserver("echoMultiline", observe, true);
 
@@ -1213,7 +1182,7 @@ var CommandLine = Module("commandline", {
      * @param {string} mode The mode for which we need history.
      */
     History: Class("History", {
-        init: function (inputField, mode) {
+        init: function init(inputField, mode) {
             this.mode = mode;
             this.input = inputField;
             this.reset();
@@ -1223,14 +1192,14 @@ var CommandLine = Module("commandline", {
         /**
          * Reset the history index to the first entry.
          */
-        reset: function () {
+        reset: function reset() {
             this.index = null;
         },
         /**
          * Save the last entry to the permanent store. All duplicate entries
          * are removed and the list is truncated, if necessary.
          */
-        save: function () {
+        save: function save() {
             if (events.feedingKeys)
                 return;
             let str = this.input.value;
@@ -1249,7 +1218,7 @@ var CommandLine = Module("commandline", {
          * @property {function} Returns whether a data item should be
          * considered private.
          */
-        checkPrivate: function (str) {
+        checkPrivate: function checkPrivate(str) {
             // Not really the ideal place for this check.
             if (this.mode == "command")
                 return commands.hasPrivateData(str);
@@ -1260,7 +1229,7 @@ var CommandLine = Module("commandline", {
          *
          * @param {string} val The new value.
          */
-        replace: function (val) {
+        replace: function replace(val) {
             delete this.input.dactylKeyPress;
             this.input.value = val;
             commandline.triggerCallback("change", commandline.currentExtendedMode, val, "history");
@@ -1273,7 +1242,7 @@ var CommandLine = Module("commandline", {
          * @param {boolean} matchCurrent Search for matches starting
          *      with the current input value.
          */
-        select: function (backward, matchCurrent) {
+        select: function select(backward, matchCurrent) {
             // always reset the tab completion if we use up/down keys
             if (commandline._completions)
                 commandline._completions.reset();
@@ -1323,7 +1292,7 @@ var CommandLine = Module("commandline", {
      * @param {Object} input
      */
     Completions: Class("Completions", {
-        init: function (input) {
+        init: function init(input) {
             this.context = CompletionContext(input.QueryInterface(Ci.nsIDOMNSEditableElement).editor);
             this.context.onUpdate = this.closure._reset;
             this.editor = input.editor;
@@ -1385,7 +1354,7 @@ var CommandLine = Module("commandline", {
             this.wildIndex = 0;
         },
 
-        haveType: function (type)
+        haveType: function haveType(type)
             this.wildmode.checkHas(this.wildtype, type == "first" ? "" : type),
 
         preview: function preview() {
@@ -1612,7 +1581,7 @@ var CommandLine = Module("commandline", {
         return arg;
     }
 }, {
-    commands: function () {
+    commands: function init_commands() {
         [
             {
                 name: "ec[ho]",
@@ -1673,7 +1642,7 @@ var CommandLine = Module("commandline", {
                 subCommand: 0
             });
     },
-    mappings: function () {
+    mappings: function init_mappings() {
 
         mappings.add([modes.COMMAND],
             [":"], "Enter command-line mode",
@@ -1705,11 +1674,15 @@ var CommandLine = Module("commandline", {
 
         bind(["<Return>", "<C-j>", "<C-m>"], "Accept the current input",
              function (args) {
+
                  commandline._keepCommand = userContext.hidden_option_command_afterimage;
-                 let mode = commandline.currentExtendedMode;
+
+                 let mode    = commandline.currentExtendedMode;
+                 let command = commandline.command;
                  commandline.currentExtendedMode = null; // Don't let modes.pop trigger "cancel"
                  modes.pop();
-                 commandline.triggerCallback("submit", mode, commandline.command);
+
+                 commandline.triggerCallback("submit", mode, command);
              });
 
         [
@@ -1822,7 +1795,7 @@ var CommandLine = Module("commandline", {
              function () {},
              function () false, DROP);
     },
-    options: function () {
+    options: function init_options() {
         options.add(["history", "hi"],
             "Number of Ex commands and search patterns to store in the command-line history",
             "number", 500,
@@ -1846,7 +1819,7 @@ var CommandLine = Module("commandline", {
             "Show the current mode in the command line",
             "boolean", true);
     },
-    sanitizer: function () {
+    sanitizer: function init_sanitizer() {
         sanitizer.addItem("commandline", {
             description: "Command-line and search history",
             persistent: true,
@@ -1893,7 +1866,7 @@ var CommandLine = Module("commandline", {
  *     necessary.
  */
 var ItemList = Class("ItemList", {
-    init: function (id) {
+    init: function init(id) {
         this._completionElements = [];
 
         var iframe = document.getElementById(id);
@@ -1917,9 +1890,9 @@ var ItemList = Class("ItemList", {
         this._minHeight = 0;
     },
 
-    _dom: function (xml, map) util.xmlToDom(xml instanceof XML ? xml : <>{xml}</>, this._doc, map),
+    _dom: function _dom(xml, map) util.xmlToDom(xml instanceof XML ? xml : <>{xml}</>, this._doc, map),
 
-    _autoSize: function () {
+    _autoSize: function _autoSize() {
         if (this._container.collapsed)
             this._div.style.minWidth = document.getElementById("dactyl-commandline").scrollWidth + "px";
 
@@ -1938,9 +1911,9 @@ var ItemList = Class("ItemList", {
         this.timeout(function () { this._container.height -= commandline.getSpaceNeeded(); }, 0);
     },
 
-    _getCompletion: function (index) this._completionElements.snapshotItem(index - this._startIndex),
+    _getCompletion: function _getCompletion(index) this._completionElements.snapshotItem(index - this._startIndex),
 
-    _init: function () {
+    _init: function _init() {
         this._div = this._dom(
             <div class="ex-command-output" highlight="Normal" style="white-space: nowrap">
                 <div highlight="Completions" key="noCompletions"><span highlight="Title">No Completions</span></div>
@@ -1985,7 +1958,7 @@ var ItemList = Class("ItemList", {
      *
      * @param {number} offset Start at this index and show options["maxitems"].
      */
-    _fill: function (offset) {
+    _fill: function _fill(offset) {
         XML.ignoreWhiteSpace = false;
         let diff = offset - this._startIndex;
         if (this._items == null || offset == null || diff == 0 || offset < 0)
@@ -2068,7 +2041,7 @@ var ItemList = Class("ItemList", {
     show: function show() { this._container.collapsed = false; },
     visible: function visible() !this._container.collapsed,
 
-    reset: function (brief) {
+    reset: function reset(brief) {
         this._startIndex = this._endIndex = this._selIndex = -1;
         this._div = null;
         if (!brief)
@@ -2138,7 +2111,7 @@ var ItemList = Class("ItemList", {
         //    util.dump({ time: Date.now() - this.start });
     },
 
-    onEvent: function onEvent(event) false
+    onKeyPress: function onKeyPress(event) false
 }, {
     WAITING_MESSAGE: "Generating results..."
 });
diff --git a/common/content/events.js b/common/content/events.js
index 163aab60..22c41d55 100644
--- a/common/content/events.js
+++ b/common/content/events.js
@@ -24,9 +24,9 @@ var ProcessorStack = Class("ProcessorStack", {
                 input.preExecute = params.preExecute;
             if (params.postExecute)
                 input.postExecute = params.postExecute;
-            if (params.onEvent && input.hive === mappings.builtin)
+            if (params.onKeyPress && input.hive === mappings.builtin)
                 input.fallthrough = function (event) {
-                    return params.onEvent(event) === false ? Events.KILL : Events.PASS;
+                    return params.onKeyPress(event) === false ? Events.KILL : Events.PASS;
                 };
             }
     },
diff --git a/common/content/hints.js b/common/content/hints.js
index b2571170..9381de8d 100644
--- a/common/content/hints.js
+++ b/common/content/hints.js
@@ -327,7 +327,7 @@ var HintSession = Class("HintSession", {
      *
      * @param {Event} event The event to handle.
      */
-    onEvent: function onEvent(event) {
+    onKeyPress: function onKeyPress(event) {
         const KILL = false, PASS = true;
         let key = events.toString(event);
 
diff --git a/common/content/modes.js b/common/content/modes.js
index 422bbee1..8904aeec 100644
--- a/common/content/modes.js
+++ b/common/content/modes.js
@@ -148,10 +148,10 @@ var Modes = Module("modes", {
             // Fix me.
             preExecute: function (map) { if (modes.main == modes.QUOTE && map.name !== "<C-v>") modes.pop() },
             postExecute: function (map) { if (modes.main == modes.QUOTE && map.name === "<C-v>") modes.pop() },
-            onEvent: function () { if (modes.main == modes.QUOTE) modes.pop() }
+            onKeyPress: function () { if (modes.main == modes.QUOTE) modes.pop() }
         });
         this.addMode("IGNORE", { hidden: true }, {
-            onEvent: function (event) Events.KILL,
+            onKeyPress: function (event) Events.KILL,
             bases: []
         });
 
diff --git a/common/content/statusline.js b/common/content/statusline.js
index 090366ed..ccc3b454 100644
--- a/common/content/statusline.js
+++ b/common/content/statusline.js
@@ -46,20 +46,13 @@ var StatusLine = Module("statusline", {
                 <!-- insertbefore="dactyl.statusBefore;" insertafter="dactyl.statusAfter;" -->
                 <hbox key="container" hidden="false" align="center"  flex="1">
                     <stack orient="horizontal"       align="stretch" flex="1" highlight="CmdLine StatusCmdLine" class="dactyl-container">
-                        <hbox                                                 highlight="CmdLine StatusCmdLine" class="dactyl-container">
+                        <hbox                                                 highlight="CmdLine StatusCmdLine" class="dactyl-container" id="dactyl-statusline-stack">
                             <label key="mode"          crop="end"                                               class="plain" collapsed="true"/>
                             <stack                                   flex="1" highlight="CmdLine StatusCmdLine" class="dactyl-container">
                                 <textbox key="url"     crop="end"    flex="1"                                   class="plain dactyl-status-field-url" readonly="true"/>
                                 <textbox key="message" crop="end"    flex="1" highlight="Normal StatusNormal"   class="plain"                         readonly="true"/>
                             </stack>
                         </hbox>
-
-                        <hbox key="commandline" hidden="false" class="dactyl-container" highlight="Normal StatusNormal" collapsed="true">
-                            <label key="commandline-prompt"    class="dactyl-commandline-prompt  plain" flex="0" crop="end" value="" collapsed="true"/>
-                            <textbox key="commandline-command" class="dactyl-commandline-command plain" flex="1" type="text" timeout="100"
-                                     oninput={_commandline + ".onEvent(event);"} onkeyup={_commandline + ".onEvent(event);"}
-                                     onfocus={_commandline + ".onEvent(event);"} onblur={_commandline + ".onEvent(event);"}/>
-                        </hbox>
                     </stack>
                     <label class="plain" key="inputbuffer"    flex="0"/>
                     <label class="plain" key="progress"       flex="0"/>
diff --git a/common/modules/addons.jsm b/common/modules/addons.jsm
index f3778cff..00ae81de 100644
--- a/common/modules/addons.jsm
+++ b/common/modules/addons.jsm
@@ -233,23 +233,15 @@ var Addon = Class("Addon", {
     }
 });
 
-["cancelUninstall", "findUpdates", "getResourceURI", "hasResource",
- "isCompatibleWith", "uninstall"].forEach(function (prop) {
-     Addon.prototype[prop] = function proxy() this.addon[prop].apply(this.addon, arguments);
-});
-
-["aboutURL", "appDisabled", "applyBackgroundUpdates", "blocklistState",
- "contributors", "creator", "description", "developers", "homepageURL",
- "iconURL", "id", "install", "installDate", "isActive", "isCompatible",
- "isPlatformCompatible", "name", "operationsRequiringRestart",
- "optionsURL", "pendingOperations", "pendingUpgrade", "permissions",
- "providesUpdatesSecurely", "releaseNotesURI", "scope", "screenshots",
- "size", "sourceURI", "translators", "type", "updateDate",
- "userDisabled", "version"].forEach(function (prop) {
-    Object.defineProperty(Addon.prototype, prop, {
-        get: function get_proxy() this.addon[prop],
-        set: function set_proxy(val) this.addon[prop] = val
-    });
+iter.forEach(properties(config.addon), function (prop) {
+    let desc = Object.getOwnPropertyDescriptor(config.addon, prop);
+    if (callable(desc.value))
+        Addon.prototype[prop] = function proxy() this.addon[prop].apply(this.addon, arguments);
+    else
+        Object.defineProperty(Addon.prototype, prop, {
+            get: function get_proxy() this.addon[prop],
+            set: function set_proxy(val) this.addon[prop] = val
+        });
 });
 
 var AddonList = Class("AddonList", {
diff --git a/common/modules/highlight.jsm b/common/modules/highlight.jsm
index b032d66c..ac9496f0 100644
--- a/common/modules/highlight.jsm
+++ b/common/modules/highlight.jsm
@@ -188,10 +188,17 @@ var Highlights = Module("Highlight", {
      * @param {Node} node
      * @param {string} group
      */
-    highlightNode: function (node, group) {
+    highlightNode: function (node, group, applyBindings) {
         node.setAttributeNS(NS.uri, "highlight", group);
-        for each (let h in group.split(" "))
-            this.loaded[h] = true;
+
+        let groups = group.split(" ");
+        for each (let group in groups)
+            this.loaded[group] = true;
+
+        if (applyBindings)
+            for each (let group in groups)
+                if (group in template.bindings)
+                    template.bindings[group](node, applyBindings);
     },
 
     /**
diff --git a/common/modules/overlay.jsm b/common/modules/overlay.jsm
index 72eb99a9..dc1e7431 100644
--- a/common/modules/overlay.jsm
+++ b/common/modules/overlay.jsm
@@ -270,9 +270,11 @@ var Overlay = Module("Overlay", {
 
                 modules.events.addSessionListener(window, "unload", function onUnload() {
                     window.removeEventListener("unload", onUnload.wrapped, false);
-                    for (let [, mod] in iter(modules))
-                        if (mod instanceof ModuleBase && "destroy" in mod)
-                            util.trapErrors(mod.destroy, mod);
+                    for (let prop in properties(modules)) {
+                        let desc = Object.getOwnPropertyDescriptor(modules, prop);
+                        if (desc.value instanceof ModuleBase && "destroy" in desc.value)
+                            util.trapErrors(desc.value.destroy, desc.value);
+                    }
                 }, false);
             }
         }));
diff --git a/common/modules/template.jsm b/common/modules/template.jsm
index d9db8cb6..8948ec89 100644
--- a/common/modules/template.jsm
+++ b/common/modules/template.jsm
@@ -131,6 +131,16 @@ var Template = Module("Template", {
             update: function update() {
                 this.collapsed = !this.commandAllowed;
             }
+        }),
+
+        Events: Class("Events", Binding, {
+            init: function init(node, params) {
+                init.supercall(this, node);
+
+                let obj = params.eventTarget;
+                for (let [event, handler] in Iterator(obj[this.getAttribute("events") || "events"]))
+                    node.addEventListener(event, obj.closure(handler), false);
+            }
         })
     },
 
diff --git a/common/modules/util.jsm b/common/modules/util.jsm
index 7ee979c8..023264d6 100644
--- a/common/modules/util.jsm
+++ b/common/modules/util.jsm
@@ -1602,19 +1602,17 @@ var Util = Module("Util", XPCOM([Ci.nsIObserver, Ci.nsISupportsWeakReference]),
         case "element":
             let domnode = doc.createElementNS(node.namespace(), node.localName());
 
+            for each (let attr in node.@*::*)
+                if (attr.name() != "highlight")
+                    domnode.setAttributeNS(attr.namespace(), attr.localName(), String(attr));
+
             for each (let child in node.*::*)
                 domnode.appendChild(xmlToDom(child, doc, nodes));
             if (nodes && node.@key)
                 nodes[node.@key] = domnode;
 
-            for each (let attr in node.@*::*)
-                if (attr.name() != "highlight")
-                    domnode.setAttributeNS(attr.namespace(), attr.localName(), String(attr));
-                else {
-                    highlight.highlightNode(domnode, String(attr));
-                    if (attr in template.bindings)
-                        template.bindings[attr](domnode, nodes);
-                }
+            if (node.@highlight)
+                highlight.highlightNode(domnode, String(node.@highlight), nodes || true);
             return domnode;
         default:
             return null;

From aee85a739677f4ce9daaccd09c9b08c1dcd67d44 Mon Sep 17 00:00:00 2001
From: Kris Maglione <maglione.k@gmail.com>
Date: Mon, 24 Jan 2011 13:55:00 -0500
Subject: [PATCH 24/36] Fix stray onEvent in commandline.js.

--HG--
branch : key-processing
---
 common/content/commandline.js | 2 +-
 common/modules/util.jsm       | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/common/content/commandline.js b/common/content/commandline.js
index 819ec0c5..775b6d37 100644
--- a/common/content/commandline.js
+++ b/common/content/commandline.js
@@ -911,7 +911,7 @@ var CommandLine = Module("commandline", {
 
         modes.push(modes.COMMAND_LINE, modes.PROMPT | extra.extended,
                    update(Object.create(extra), {
-                       onKeyPress: extra.onEvent || this.closure.onKeyPress,
+                       onKeyPress: extra.onKeyPress || this.closure.onKeyPress,
                        leave: function leave(stack) {
                            commandline.leave(stack);
                            leave.supercall(extra, stack);
diff --git a/common/modules/util.jsm b/common/modules/util.jsm
index 023264d6..3f521db7 100644
--- a/common/modules/util.jsm
+++ b/common/modules/util.jsm
@@ -332,7 +332,7 @@ var Util = Module("Util", XPCOM([Ci.nsIObserver, Ci.nsISupportsWeakReference]),
             ([^]*?) // 1
             (?:
                 (<\{) | // 2
-                (< ((?:[a-z]-)?[a-z-]*?) >) | // 3 4
+                (< ((?:[a-z]-)?[a-z-]+?) >) | // 3 4
                 (\}>) // 5
             )
         ]]>, "giy");

From 635caffb240d36e5921267389f334b7a1a533151 Mon Sep 17 00:00:00 2001
From: Kris Maglione <maglione.k@gmail.com>
Date: Mon, 24 Jan 2011 15:31:44 -0500
Subject: [PATCH 25/36] Add horribly formatted :help versions page.

--HG--
branch : key-processing
---
 common/content/dactyl.js | 66 ++++++++++++++++++++++++++++++++++++++--
 1 file changed, 64 insertions(+), 2 deletions(-)

diff --git a/common/content/dactyl.js b/common/content/dactyl.js
index f05f893e..332f5672 100644
--- a/common/content/dactyl.js
+++ b/common/content/dactyl.js
@@ -619,8 +619,7 @@ var Dactyl = Module("dactyl", XPCOM(Ci.nsISupportsWeakReference, ModuleBase), {
             });
 
             // Process plugin help entries.
-            XML.ignoreWhiteSpace = false;
-            XML.prettyPrinting = false;
+            XML.ignoreWhiteSpace = XML.prettyPrinting = false;
 
             let body = XML();
             for (let [, context] in Iterator(plugins.contexts))
@@ -654,6 +653,69 @@ var Dactyl = Module("dactyl", XPCOM(Ci.nsISupportsWeakReference, ModuleBase), {
                 </document>.toXMLString()));
             fileMap["plugins"] = function () ['text/xml;charset=UTF-8', help];
 
+            fileMap["versions"] = function () {
+                let NEWS = util.httpGet(config.addon.getResourceURI("NEWS").spec).responseText;
+
+                let re = util.regexp(<![CDATA[
+                    ^ (?P<space> \s*)
+                      (?P<char>  [-*+]) \x20
+                    (?P<content> .*\n
+                       (?: \1\x20\x20.*\n | \s*\n)* )
+                    |
+                    (?P<par>
+                        (?: ^ [^\S\n]*
+                            (?:[^-*+\s] | [-*+]\S)
+                            .*\n
+                        )+
+                    )
+                    |
+                    (?: ^ [^\S\n]* \n) +
+                ]]>, "gmy");
+
+                default xml namespace = NS;
+                function rec(text, level) {
+                    let res = <></>;
+                    let list, space;
+
+                    for (let match in re.iterate(text)) {
+                        if (match.char) {
+                            if (!list)
+                                res += list = <ul/>;
+                            list.* += <li>{rec(match.content.replace(RegExp("^" + match.space, "gm"), ""), level + 1)}</li>;
+                        }
+                        else if (match.par) {
+                            list = null;
+                            if (level == 0 && /^.*:\n$/.test(match.par))
+                                res += <h2>{template.linkifyHelp(match.par.slice(0, -1), true)}</h2>;
+                            else {
+                                let [, a, b] = /^(IMPORTANT:?)?([^]*)/.exec(match.par);
+                                res += <p>{
+                                    a ? <hl key="HelpWarning">{a}</hl> : ""
+                                }{
+                                    template.linkifyHelp(b, true)
+                                }</p>;
+                            }
+                        }
+                    }
+                    return res;
+                }
+
+                XML.prettyPrinting = XML.ignoreWhitespace = false;
+                return ["application/xml",
+                    '<?xml version="1.0"?>\n' +
+                    '<?xml-stylesheet type="text/xsl" href="dactyl://content/help.xsl"?>\n' +
+                    '<!DOCTYPE document SYSTEM "resource://dactyl-content/dactyl.dtd">\n' +
+                    unescape(encodeURI( // UTF-8 handling hack.
+                    <document xmlns={NS}
+                        name="versions" title={config.appName + " Versions"}>
+                        <h1 tag="versions">Versions</h1>
+                        <toc start="2"/>
+
+                        {rec(NEWS, 0)}
+                    </document>.toXMLString()))
+                ]
+            }
+
             default xml namespace = NS;
 
             overlayMap["index"] = function () ['text/xml;charset=UTF-8',

From 73b9e0ecdbbb280a8b02dbc75fec20119c986042 Mon Sep 17 00:00:00 2001
From: Kris Maglione <maglione.k@gmail.com>
Date: Mon, 24 Jan 2011 15:41:49 -0500
Subject: [PATCH 26/36] Make :help versions slightly less horrible.

--HG--
branch : key-processing
---
 common/modules/config.jsm | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/common/modules/config.jsm b/common/modules/config.jsm
index bc52366c..18b7aa4c 100644
--- a/common/modules/config.jsm
+++ b/common/modules/config.jsm
@@ -592,8 +592,8 @@ var ConfigBase = Class("ConfigBase", {
         HelpOrderedList3;ol[level="3"],ol ol ol;dactyl://help/*     list-style: outside lower-roman;
         HelpOrderedList4;ol[level="4"],ol ol ol ol;dactyl://help/*  list-style: outside decimal;
 
-        HelpList;html|ul;dactyl://help/*     display: block; list-style: outside disc;
-        HelpListItem;html|li;dactyl://help/* display: list-item;
+        HelpList;html|ul;dactyl://help/*      display: block; list-style-position: outside; margin: 1em 0;
+        HelpListItem;html|li;dactyl://help/*  display: list-item;
 
 
         HelpNote                                    color: red; font-weight: bold;

From 60a97323b3f87b13e51157dc32c2aacc58a1a531 Mon Sep 17 00:00:00 2001
From: Kris Maglione <maglione.k@gmail.com>
Date: Mon, 24 Jan 2011 15:43:24 -0500
Subject: [PATCH 27/36] Extend previous change to OLs, too.

--HG--
branch : key-processing
---
 common/modules/config.jsm | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/common/modules/config.jsm b/common/modules/config.jsm
index 18b7aa4c..ca65a065 100644
--- a/common/modules/config.jsm
+++ b/common/modules/config.jsm
@@ -586,7 +586,7 @@ var ConfigBase = Class("ConfigBase", {
         HelpTOC
         HelpTOC>ol ol                               margin-left: -1em;
 
-        HelpOrderedList;ol;dactyl://help/*
+        HelpOrderedList;ol;dactyl://help/*                          margin: 1em 0;
         HelpOrderedList1;ol[level="1"],ol;dactyl://help/*           list-style: outside decimal; display: block;
         HelpOrderedList2;ol[level="2"],ol ol;dactyl://help/*        list-style: outside upper-alpha;
         HelpOrderedList3;ol[level="3"],ol ol ol;dactyl://help/*     list-style: outside lower-roman;

From 90e42e72c1a6faa67786ce0283190ee9bf0b2841 Mon Sep 17 00:00:00 2001
From: Kris Maglione <maglione.k@gmail.com>
Date: Mon, 24 Jan 2011 15:47:59 -0500
Subject: [PATCH 28/36] Fix some formatting issues in starting.xml.

--HG--
branch : key-processing
---
 common/locale/en-US/starting.xml | 18 +++++++++---------
 1 file changed, 9 insertions(+), 9 deletions(-)

diff --git a/common/locale/en-US/starting.xml b/common/locale/en-US/starting.xml
index 678a4f6e..eeedc1d1 100644
--- a/common/locale/en-US/starting.xml
+++ b/common/locale/en-US/starting.xml
@@ -17,7 +17,7 @@
 <p>
     Command-line options can be passed to &dactyl.appName; via the -&dactyl.name; &dactyl.host;
     option. These are passed as single string argument.
-    E.g., &dactyl.hostbin; -&dactyl.name; <str>++cmd 'set exrc' +u 'tempRcFile' ++noplugin</str>
+    E.g., <tt>&dactyl.hostbin; -&dactyl.name; <str><t>++cmd</t> 'set exrc' <t>+u</t> 'tempRcFile' <t>++noplugin</t></str></tt>
 </p>
 
 <item>
@@ -52,9 +52,9 @@
     <description>
         <p>
             The file <a>rcfile</a> is used for user initialization commands. If <a>rcfile</a> is
-            "NORC" then no startup initialization is performed except for the loading of
+            <str>NORC</str> then no startup initialization is performed except for the loading of
             plugins, i.e., steps 1. and 2. in <t>initialization</t> are skipped. If <a>rcfile</a>
-            is "NONE" then plugin loading is also skipped.
+            is <str>NONE</str> then plugin loading is also skipped.
         </p>
     </description>
 </item>
@@ -89,7 +89,7 @@
                 <em>~/_&dactyl.name;rc</em>
                 <strut/>
                 Windows only. If this file exists, its contents
-                are executed and <em>$MY_&dactyl.idName;RC</em> set to its path.
+                are executed and <tt>$MY_&dactyl.idName;RC</tt> set to its path.
             </li>
             <li>
                 <em>~/.&dactyl.name;rc</em>
@@ -116,8 +116,8 @@
 
         <ul>
             <li><o>noloadplugins</o> is set,</li>
-            <li>the ++noplugin command-line option was specified, or</li>
-            <li>the +u=NONE command-line option was specified.</li>
+            <li>the <t>++noplugin</t> command-line option was specified, or</li>
+            <li>the <tt><t>+u</t>=NONE</tt> command-line option was specified.</li>
         </ul>
 
         <p>
@@ -132,11 +132,11 @@
 </p>
 
 <ul>
-    <li>On Unix and Mac, the environment variable  <em>$HOME</em> is used.</li>
+    <li>On Unix and Mac, the environment variable <tt>$HOME</tt> is used.</li>
     <li>
         On Windows, &dactyl.appName; checks for the existence of
-        <em>%HOME%</em>, then <em>%USERPROFILE%</em>, and then
-        <em>%HOMEDRIVE%%HOMEPATH%</em>. It uses the first one it
+        <tt>%HOME%</tt>, then <tt>%USERPROFILE%</tt>, and then
+        <tt>%HOMEDRIVE%%HOMEPATH%</tt>. It uses the first one it
         finds.
     </li>
 </ul>

From a3692374ed71a46bf29c08c376f8348c3497ca4d Mon Sep 17 00:00:00 2001
From: Kris Maglione <maglione.k@gmail.com>
Date: Mon, 24 Jan 2011 15:48:49 -0500
Subject: [PATCH 29/36] Fix some formatting issues in starting.xml.

--HG--
branch : key-processing
---
 common/locale/en-US/starting.xml | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/common/locale/en-US/starting.xml b/common/locale/en-US/starting.xml
index eeedc1d1..2205d601 100644
--- a/common/locale/en-US/starting.xml
+++ b/common/locale/en-US/starting.xml
@@ -22,6 +22,7 @@
 
 <item>
     <tags>+c</tags>
+    <strut/>
     <spec>+c <a>command</a></spec>
     <description>
         <p>
@@ -35,6 +36,7 @@
 
 <item>
     <tags>++cmd</tags>
+    <strut/>
     <spec>++cmd <a>command</a></spec>
     <description>
         <p>
@@ -48,6 +50,7 @@
 
 <item>
     <tags>+u</tags>
+    <strut/>
     <spec>+u <a>rcfile</a></spec>
     <description>
         <p>
@@ -61,6 +64,7 @@
 
 <item>
     <tags>++noplugin</tags>
+    <strut/>
     <spec>++noplugin</spec>
     <description>
         <p>Prevents plugin scripts from being loaded at startup. See <o>loadplugins</o>.</p>

From 2b7906cf8c61514734169fe6a452cc1a16a7169b Mon Sep 17 00:00:00 2001
From: Kris Maglione <maglione.k@gmail.com>
Date: Mon, 24 Jan 2011 15:49:49 -0500
Subject: [PATCH 30/36] Fix some formatting issues in starting.xml.

--HG--
branch : key-processing
---
 common/locale/en-US/starting.xml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/common/locale/en-US/starting.xml b/common/locale/en-US/starting.xml
index 2205d601..cd9ca6c9 100644
--- a/common/locale/en-US/starting.xml
+++ b/common/locale/en-US/starting.xml
@@ -170,7 +170,7 @@
 <item>
     <tags>:res :restart</tags>
     <spec>:res<oa>tart</oa></spec>
-    <description>
+    <description short="true">
         <p>Force &dactyl.host; to restart. Useful when installing extensions.</p>
     </description>
 </item>

From 5e8a11fe696f3237bb936b59b8aa51b9411d7c5b Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=C5=A0t=C4=9Bp=C3=A1n=20N=C4=9Bmec?= <stepnem@gmail.com>
Date: Mon, 24 Jan 2011 21:58:33 +0100
Subject: [PATCH 31/36] Add tags et al. for the versions help page.

--HG--
branch : key-processing
---
 common/content/about.xul | 4 +---
 common/content/dactyl.js | 3 ++-
 2 files changed, 3 insertions(+), 4 deletions(-)

diff --git a/common/content/about.xul b/common/content/about.xul
index 353a2eea..433402c8 100644
--- a/common/content/about.xul
+++ b/common/content/about.xul
@@ -22,9 +22,7 @@ by Kris Maglione, Doug Kearns, et al.
 type :q&lt;<span class="key">Enter</span>>                 to exit         <!---->
 type :help&lt;<span class="key">Enter</span>>  or  &lt;<span class="key">F1</span>>    for on-line help
 type :help faq&lt;<span class="key">Enter</span>>          for the FAQ page
-<!--
-type :help version-&dactyl.version;&lt;<span class="key">Enter</span>>  for version info
--->
+type :help versions&lt;<span class="key">Enter</span>>     for version info
       </div>
     <spring flex="1"/>
   </hbox>
diff --git a/common/content/dactyl.js b/common/content/dactyl.js
index 332f5672..6293114c 100644
--- a/common/content/dactyl.js
+++ b/common/content/dactyl.js
@@ -708,13 +708,14 @@ var Dactyl = Module("dactyl", XPCOM(Ci.nsISupportsWeakReference, ModuleBase), {
                     unescape(encodeURI( // UTF-8 handling hack.
                     <document xmlns={NS}
                         name="versions" title={config.appName + " Versions"}>
-                        <h1 tag="versions">Versions</h1>
+                        <h1 tag="versions news">{config.appName} Versions</h1>
                         <toc start="2"/>
 
                         {rec(NEWS, 0)}
                     </document>.toXMLString()))
                 ]
             }
+            addTags("versions", util.httpGet("dactyl://help/versions").responseXML);
 
             default xml namespace = NS;
 

From dbfd64729e38cdaa522e2d3e67c3fc7359a36e72 Mon Sep 17 00:00:00 2001
From: Kris Maglione <maglione.k@gmail.com>
Date: Mon, 24 Jan 2011 16:55:43 -0500
Subject: [PATCH 32/36] Fix the MIW.

--HG--
branch : key-processing
---
 common/content/commandline.js | 70 +++++++++++++++++------------------
 common/content/events.js      |  7 +++-
 common/content/mappings.js    |  2 +
 3 files changed, 42 insertions(+), 37 deletions(-)

diff --git a/common/content/commandline.js b/common/content/commandline.js
index 775b6d37..8b3bae08 100644
--- a/common/content/commandline.js
+++ b/common/content/commandline.js
@@ -427,23 +427,17 @@ var CommandLine = Module("commandline", {
         // way of calling "open"
         this.currentExtendedMode = null; // the extended mode which we last opened the command line for
 
-        // save the arguments for the inputMultiline method which are needed in the event handler
-        this._multilineEnd = null;
-        this._multilineCallback = null;
-
         this._input = {};
 
         this.registerCallback("submit", modes.EX, function (command) {
-            try {
-                var readHeredoc = io.readHeredoc;
-                io.readHeredoc = commandline.readHeredoc;
+            io.withSavedValues(["readHeredoc", "sourcing"], function () {
+                this.sourcing = { file: "[Command Line]", line: 1 };
+                this.readHeredoc = commandline.readHeredoc;
                 commands.repeat = command;
-                commands.execute(command);
-            }
-            finally {
-                io.readHeredoc = readHeredoc;
-            }
+                dactyl.execute(command);
+            });
         });
+
         this.registerCallback("complete", modes.EX, function (context) {
             context.fork("ex", 0, completion, "ex");
         });
@@ -572,6 +566,9 @@ var CommandLine = Module("commandline", {
                 nodeSet.commandline._completionList.hide();
     },
 
+    _multilineEnd: Modes.boundProperty(),
+    _multilineCallback: Modes.boundProperty(),
+
     currentExtendedMode: Modes.boundProperty(),
     _completions: Modes.boundProperty(),
     _history: Modes.boundProperty(),
@@ -929,10 +926,8 @@ var CommandLine = Module("commandline", {
 
     readHeredoc: function readHeredoc(end) {
         let args;
-        commandline.inputMultiline(end,
-            function (res) { args = res; });
-        while (args === undefined)
-            util.threadYield(true);
+        commandline.inputMultiline(end, function (res) { args = res; });
+        util.waitFor(function () args !== undefined);
         return args;
     },
 
@@ -947,7 +942,9 @@ var CommandLine = Module("commandline", {
     // FIXME: Buggy, especially when pasting.
     inputMultiline: function inputMultiline(end, callbackFunc) {
         let cmd = this.command;
-        modes.push(modes.COMMAND_LINE, modes.INPUT_MULTILINE);
+        modes.push(modes.COMMAND_LINE, modes.INPUT_MULTILINE, {
+            keyModes: [modes.INPUT_MULTILINE]
+        });
         if (cmd != false)
             this._echoLine(cmd, this.HL_NORMAL);
 
@@ -1028,22 +1025,6 @@ var CommandLine = Module("commandline", {
         },
         input: function onInput(event) {
             this._autosizeMultilineInputWidget();
-        },
-        keypress: function onKeyPress(event) {
-            let key = events.toString(event);
-            if (events.isAcceptKey(key)) {
-                let text = "\n" + this.widgets.multilineInput.value.substr(0, this.widgets.multilineInput.selectionStart) + "\n";
-                let index = text.indexOf(this._multilineEnd);
-                if (index >= 0) {
-                    text = text.substring(1, index);
-                    let callback = this._multilineCallback;
-                    modes.pop();
-                    callback.call(this, text);
-                }
-            }
-            else if (events.isCancelKey(key)) {
-                modes.pop();
-            }
         }
     },
 
@@ -1085,7 +1066,7 @@ var CommandLine = Module("commandline", {
     onMOWKeyPress: function onMOWKeyPress(event) {
         const KILL = false, PASS = true;
 
-        if (options["more"] && mos.isScrollable(1))
+        if (options["more"] && mow.isScrollable(1))
             commandline.updateMorePrompt(false, true);
         else {
             modes.pop();
@@ -1655,6 +1636,25 @@ var CommandLine = Module("commandline", {
                 commandline._echoMultiline(commandline._lastMowOutput, commandline.HL_NORMAL);
             });
 
+
+        mappings.add([modes.INPUT_MULTILINE],
+            ["<Return>", "<C-j>", "<C-m>"], "Begin a new line",
+            function (args) {
+                let text = "\n" + commandline.widgets.multilineInput
+                                             .value.substr(0, commandline.widgets.multilineInput.selectionStart)
+                         + "\n";
+
+                let index = text.indexOf(commandline._multilineEnd);
+                if (index >= 0) {
+                    text = text.substring(1, index);
+                    let callback = commandline._multilineCallback;
+                    modes.pop();
+
+                    return function () callback.call(commandline, text);
+                }
+                return Events.PASS;
+            });
+
         let bind = function bind()
             mappings.add.apply(mappings, [[modes.COMMAND_LINE]].concat(Array.slice(arguments)))
 
@@ -1682,7 +1682,7 @@ var CommandLine = Module("commandline", {
                  commandline.currentExtendedMode = null; // Don't let modes.pop trigger "cancel"
                  modes.pop();
 
-                 commandline.triggerCallback("submit", mode, command);
+                 return function () commandline.triggerCallback("submit", mode, command);
              });
 
         [
diff --git a/common/content/events.js b/common/content/events.js
index 22c41d55..c2d7ab91 100644
--- a/common/content/events.js
+++ b/common/content/events.js
@@ -95,8 +95,11 @@ var ProcessorStack = Class("ProcessorStack", {
 
             if (modes.replaying && !events.waitForPageLoad())
                 result = Events.KILL;
-            else
-                result = this.actions[0]() === Events.PASS ? Events.PASS : Events.KILL;
+            else {
+                for (var res = this.actions[0]; callable(res);)
+                    res = res();
+                result = res === Events.PASS ? Events.PASS : Events.KILL;
+            }
         }
         else if (result !== Events.KILL && processors.some(function (p) !p.main.passUnknown)) {
             result = Events.KILL;
diff --git a/common/content/mappings.js b/common/content/mappings.js
index 7369d52c..bb83522e 100644
--- a/common/content/mappings.js
+++ b/common/content/mappings.js
@@ -110,6 +110,8 @@ var Map = Class("Map", {
         if (this.names[0] != ".") // FIXME: Kludge.
             mappings.repeat = repeat;
 
+        if (this.executing)
+            util.dumpStack("Attempt to execute mapping recursively: " + args.command);
         dactyl.assert(!this.executing, "Attempt to execute mapping recursively: " + args.command);
         this.executing = true;
         let res = dactyl.trapErrors(repeat);

From 506abdcd85b17964f14c8925326f8685cc0f1dac Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=C5=A0t=C4=9Bp=C3=A1n=20N=C4=9Bmec?= <stepnem@gmail.com>
Date: Tue, 25 Jan 2011 00:24:22 +0100
Subject: [PATCH 33/36] Recognise closing paren as a delimiter in linkifyHelp.

--HG--
branch : key-processing
---
 common/modules/template.jsm | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/common/modules/template.jsm b/common/modules/template.jsm
index 8948ec89..902d6f04 100644
--- a/common/modules/template.jsm
+++ b/common/modules/template.jsm
@@ -339,7 +339,7 @@ var Template = Module("Template", {
         let re = util.regexp(<![CDATA[
             (?P<pre> [/\s]|^)
             (?P<tag> '[\w-]+' | :(?:[\w-]+|!) | (?:._)?<[\w-]+> )
-            (?=      [[!,;./\s]|$)
+            (?=      [[\)!,;./\s]|$)
         ]]>, "g");
         return this.highlightSubstrings(str, (function () {
             for (let res in re.iterate(str))

From f06d5653c793f99cf561db423077e0957d3370bc Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=C5=A0t=C4=9Bp=C3=A1n=20N=C4=9Bmec?= <stepnem@gmail.com>
Date: Tue, 25 Jan 2011 00:27:24 +0100
Subject: [PATCH 34/36] Typos, corrections and consistency fixes.

--HG--
branch : key-processing
---
 common/content/commands.js |  2 +-
 common/content/dactyl.js   |  5 ++---
 pentadactyl/NEWS           | 19 ++++++++++---------
 3 files changed, 13 insertions(+), 13 deletions(-)

diff --git a/common/content/commands.js b/common/content/commands.js
index 44164529..be60a5ef 100644
--- a/common/content/commands.js
+++ b/common/content/commands.js
@@ -24,7 +24,6 @@
  *         (@link CommandOption.FLOAT),
  *         (@link CommandOption.LIST),
  *         (@link CommandOption.ANY)
- * @property {object} default The option's default value
  * @property {function} validator A validator function
  * @property {function (CompletionContext, object)} completer A list of
  *    completions, or a completion function which will be passed a
@@ -33,6 +32,7 @@
  *      completeOpt - The name of the option currently being completed.
  * @property {boolean} multiple Whether this option can be specified multiple times
  * @property {string} description A description of the option
+ * @property {object} default The option's default value
  */
 
 var CommandOption = Struct("names", "type", "validator", "completer", "multiple", "description", "default");
diff --git a/common/content/dactyl.js b/common/content/dactyl.js
index 6293114c..95b7c6f6 100644
--- a/common/content/dactyl.js
+++ b/common/content/dactyl.js
@@ -527,7 +527,7 @@ var Dactyl = Module("dactyl", XPCOM(Ci.nsISupportsWeakReference, ModuleBase), {
     /**
      * Returns the URL of the specified help *topic* if it exists.
      *
-     * @param {string} topic The help topic to lookup.
+     * @param {string} topic The help topic to look up.
      * @param {boolean} unchunked Whether to search the unchunked help page.
      * @returns {string}
      */
@@ -851,7 +851,7 @@ var Dactyl = Module("dactyl", XPCOM(Ci.nsISupportsWeakReference, ModuleBase), {
     }, [function (context, args) completion.file(context)]),
 
     /**
-     * Generates a help entry and writes it to the clipboard.
+     * Generates a help entry and returns it as a string.
      *
      * @param {Command|Map|Option} obj A dactyl *Command*, *Map* or *Option*
      *     object
@@ -953,7 +953,6 @@ var Dactyl = Module("dactyl", XPCOM(Ci.nsISupportsWeakReference, ModuleBase), {
      *
      * @param {string} topic The help topic to open.
      * @param {boolean} unchunked Whether to use the unchunked help page.
-     * @returns {string}
      */
     help: function (topic, unchunked) {
         dactyl.initHelp();
diff --git a/pentadactyl/NEWS b/pentadactyl/NEWS
index abf2e334..88787654 100644
--- a/pentadactyl/NEWS
+++ b/pentadactyl/NEWS
@@ -57,7 +57,7 @@
       completion system customization.
     * The external editor can now be configured to open to a given
       line number and column, used for opening source links and
-      editing input fields with <C-i>. See :h 'editor'.
+      editing input fields with i_<C-i>. See :h 'editor'.
     * Command changes:
       - :viusage, :optionusage and :exusage were replaced with :listkeys,
         :listoptions and :listcommands, providing more powerful and
@@ -66,16 +66,17 @@
         and linking to source code locations).
       - :downloads now opens a download list in the multi-line output
         buffer.
-      - :extensions has been replaced with a more powerful :addons
+      - :extensions has been replaced with a more powerful :addons.
       - Added :cookies command.
-      * :extadd now supports remote URLs as well as local files on Firefox 4.
-      * Added :if/:elseif/:else/:endif conditionals.
+      - :extadd now supports remote URLs as well as local files on Firefox 4.
+      - Added :if/:elseif/:else/:endif conditionals.
       - Added -charset and -post to :bmark.
       - Added -keyword, -tags, -title to :delbmarks.
       - Added :extrehash, :exttoggle, :extupdate, and :rehash commands.
       - Added :feedkeys command.
       - Added -sort option to :history.
-      - Added several new options, including -javascript, to :abbrev and :map.
+      - Added several new options, including -javascript, to :abbreviate and
+        :map.
       - Added :mksyntax command to auto-generate Vim syntax files.
       - :open now only opens files beginning with /, ./, ../, or ~/
       - :saveas now provides completions for default file names, and
@@ -87,7 +88,7 @@
       - Added :yank command.
       - :delmarks, :marks and :qmarks now also accept ranges, same as
         :delqmarks.
-      - :command now accepts comma-separated alternative command names
+      - :command now accepts comma-separated alternative command names.
       - :command -complete custom now also accepts a completions array, see
         :h :command-completion-custom.
     * Improvements to :style and :highlight:
@@ -127,7 +128,7 @@
     * Option changes:
       - Added "bookmarks", "diverted", and "links" to 'activate'
         option.
-      - Added 'altwildmode' and <A-Tab> command-line key binding.
+      - Added 'altwildmode' and c_<A-Tab> command-line key binding.
       - Added 'autocomplete' option for specifying which completion
         groups should be auto-completed.
       - Added 'banghist' option.
@@ -135,7 +136,7 @@
       - 'complete' now defaults to "slf" but file completion only
         triggers when the URL begins as above.
       - Added 'passkeys' option.
-      - Changed 'urlseparator' default value to '|'.
+      - Changed 'urlseparator' default value to "|".
       - Added "passwords" and "venkman" dialogs to :dialog.
       - Added 'wildanchor' option.
       - Added 'cookies', 'cookieaccept', and 'cookielifetime' options.
@@ -150,7 +151,7 @@
     * Completion list now behaves better when the multi-line output
       window is displayed.
     * Major help system improvements:
-      - Plugins may now provide full-fledged ':help' documentation.
+      - Plugins may now provide full-fledged :help documentation.
       - Add basic plugin authorship documentation.
       - The help system is newly modularized and features significant
         updates, rewrites, and formatting improvements.

From fd9319726d1d0c1f783f6b0d06393cee84dc8507 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=C5=A0t=C4=9Bp=C3=A1n=20N=C4=9Bmec?= <stepnem@gmail.com>
Date: Tue, 25 Jan 2011 00:29:03 +0100
Subject: [PATCH 35/36] Delete done TODO items.

--HG--
branch : key-processing
---
 pentadactyl/TODO | 3 ---
 1 file changed, 3 deletions(-)

diff --git a/pentadactyl/TODO b/pentadactyl/TODO
index c155e5d2..9e11e725 100644
--- a/pentadactyl/TODO
+++ b/pentadactyl/TODO
@@ -16,7 +16,6 @@ BUGS:
 - :sidebar improvements (:sidebar! Downloads while downloads is open should refocus the sidebar)
 - ;s saves the page rather than the image
 - RC file is sourced once per window
-- the :help version-information page is no longer generated
 
 FEATURES:
 8 registers
@@ -38,7 +37,6 @@ FEATURES:
 7 describe-key command (prompt for a key and display its binding with documentation)
 7 Specify all INSERT mode mappings rather than falling through to the host apps
   mystery meat mappings.
-7 consider generating most of :help :index
 7 use ctrl-n/p in insert mode for word completion
 7 implement QuickFix window based on ItemList
 7 wherever possible: get rid of dialogs and ask console-like dialog questions
@@ -70,4 +68,3 @@ FEATURES:
 3 Splitting Windows with [:sp :vsp ctrl-w,s ctrl-w,v] and closing with [ctrl-w,q], moving with [ctrl-w,w or tab]
   have a look into the split browser extension
 1 Reformat dactyl/HACKING so that git diff can find sections and report changes @ somewhere
-

From 3e446bcaa5b6373a6ab133e35291b5ef993d1ffc Mon Sep 17 00:00:00 2001
From: Kris Maglione <maglione.k@gmail.com>
Date: Tue, 25 Jan 2011 20:36:01 -0500
Subject: [PATCH 36/36] Fix JAR URI completion.

--HG--
branch : key-processing
---
 common/modules/io.jsm | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/common/modules/io.jsm b/common/modules/io.jsm
index a60c4ea5..f98c363f 100644
--- a/common/modules/io.jsm
+++ b/common/modules/io.jsm
@@ -921,7 +921,7 @@ unlet s:cpo_save
                               isDirectory: function () s.substr(-1) == "/",
                               leafName: /([^\/]*)\/?$/.exec(s)[1]
                         }
-                        for (s in io.listJar(getDir(uri.JARFile, uri.JAREntry)))]
+                        for (s in io.listJar(uri.JARFile, getDir(uri.JAREntry)))]
                 };
             else
                 context.generate = function generate_file() {