Add macro utility bindings. Add named aliases for some mappings.

--HG--
branch : key-processing

common/content/browser.js

@@ -65,7 +65,7 @@ var Browser = Module("browser", {
 
     mappings: function () {
         mappings.add([modes.NORMAL],
-            ["y"], "Yank current location to the clipboard",
+            ["y", "<yank-location>"], "Yank current location to the clipboard",
             function () { dactyl.clipboardWrite(buffer.uri.spec, true); });
 
         // opening websites

common/content/buffer.js

@@ -1651,7 +1651,7 @@ var Buffer = Module("buffer", {
     mappings: function () {
         var myModes = config.browserModes;
 
-        mappings.add(myModes, ["."],
+        mappings.add(myModes, [".", "<repeat-key>"],
             "Repeat the last key event",
             function (args) {
                 if (mappings.repeat) {
@@ -1670,31 +1670,31 @@ var Buffer = Module("buffer", {
             function () { ex.stop(); });
 
         // scrolling
-        mappings.add(myModes, ["j", "<Down>", "<C-e>"],
+        mappings.add(myModes, ["j", "<Down>", "<C-e>", "<scroll-down-line>"],
             "Scroll document down",
             function (args) { buffer.scrollVertical("lines", Math.max(args.count, 1)); },
             { count: true });
 
-        mappings.add(myModes, ["k", "<Up>", "<C-y>"],
+        mappings.add(myModes, ["k", "<Up>", "<C-y>", "<scroll-up-line>"],
             "Scroll document up",
             function (args) { buffer.scrollVertical("lines", -Math.max(args.count, 1)); },
             { count: true });
 
-        mappings.add(myModes, dactyl.has("mail") ? ["h"] : ["h", "<Left>"],
+        mappings.add(myModes, dactyl.has("mail") ? ["h", "<scroll-left-column>"] : ["h", "<Left>", "<scroll-left-column>"],
             "Scroll document to the left",
             function (args) { buffer.scrollHorizontal("columns", -Math.max(args.count, 1)); },
             { count: true });
 
-        mappings.add(myModes, dactyl.has("mail") ? ["l"] : ["l", "<Right>"],
+        mappings.add(myModes, dactyl.has("mail") ? ["l", "<scroll-right-column>"] : ["l", "<Right>", "<scroll-right-column>"],
             "Scroll document to the right",
             function (args) { buffer.scrollHorizontal("columns", Math.max(args.count, 1)); },
             { count: true });
 
-        mappings.add(myModes, ["0", "^"],
+        mappings.add(myModes, ["0", "^", "<scroll-begin>"],
             "Scroll to the absolute left of the document",
             function () { buffer.scrollToPercent(0, null); });
 
-        mappings.add(myModes, ["$"],
+        mappings.add(myModes, ["$", "<scroll-end>"],
             "Scroll to the absolute right of the document",
             function () { buffer.scrollToPercent(100, null); });
 
@@ -1708,7 +1708,7 @@ var Buffer = Module("buffer", {
             function (args) { buffer.scrollToPercent(null, args.count != null ? args.count : 100); },
             { count: true });
 
-        mappings.add(myModes, ["%"],
+        mappings.add(myModes, ["%", "<scroll-percent>"],
             "Scroll to {count} percent of the document",
             function (args) {
                 dactyl.assert(args.count > 0 && args.count <= 100);
@@ -1716,59 +1716,59 @@ var Buffer = Module("buffer", {
             },
             { count: true });
 
-        mappings.add(myModes, ["<C-d>"],
+        mappings.add(myModes, ["<C-d>", "<scroll-down>"],
             "Scroll window downwards in the buffer",
             function (args) { buffer._scrollByScrollSize(args.count, true); },
             { count: true });
 
-        mappings.add(myModes, ["<C-u>"],
+        mappings.add(myModes, ["<C-u>", "<scroll-up>"],
             "Scroll window upwards in the buffer",
             function (args) { buffer._scrollByScrollSize(args.count, false); },
             { count: true });
 
-        mappings.add(myModes, ["<C-b>", "<PageUp>", "<S-Space>"],
+        mappings.add(myModes, ["<C-b>", "<PageUp>", "<S-Space>", "<scroll-page-up>"],
             "Scroll up a full page",
             function (args) { buffer.scrollVertical("pages", -Math.max(args.count, 1)); },
             { count: true });
 
-        mappings.add(myModes, ["<C-f>", "<PageDown>", "<Space>"],
+        mappings.add(myModes, ["<C-f>", "<PageDown>", "<Space>", "<scroll-page-down>"],
             "Scroll down a full page",
             function (args) { buffer.scrollVertical("pages", Math.max(args.count, 1)); },
             { count: true });
 
-        mappings.add(myModes, ["]f"],
+        mappings.add(myModes, ["]f", "<previous-frame>"],
             "Focus next frame",
             function (args) { buffer.shiftFrameFocus(Math.max(args.count, 1)); },
             { count: true });
 
-        mappings.add(myModes, ["[f"],
+        mappings.add(myModes, ["[f", "<next-frame>"],
             "Focus previous frame",
             function (args) { buffer.shiftFrameFocus(-Math.max(args.count, 1)); },
             { count: true });
 
-        mappings.add(myModes, ["]]"],
+        mappings.add(myModes, ["]]", "<next-page>"],
             "Follow the link labeled 'next' or '>' if it exists",
             function (args) {
                 buffer.findLink("next", options["nextpattern"], (args.count || 1) - 1, true);
             },
             { count: true });
 
-        mappings.add(myModes, ["[["],
+        mappings.add(myModes, ["[[", "<previous-page>"],
             "Follow the link labeled 'prev', 'previous' or '<' if it exists",
             function (args) {
                 buffer.findLink("previous", options["previouspattern"], (args.count || 1) - 1, true);
             },
             { count: true });
 
-        mappings.add(myModes, ["gf"],
+        mappings.add(myModes, ["gf", "<view-source>"],
             "Toggle between rendered and source view",
             function () { buffer.viewSource(null, false); });
 
-        mappings.add(myModes, ["gF"],
+        mappings.add(myModes, ["gF", "<view-source-externally>"],
             "View source with an external editor",
             function () { buffer.viewSource(null, true); });
 
-        mappings.add(myModes, ["gi"],
+        mappings.add(myModes, ["gi", "<focus-input>"],
             "Focus last used input field",
             function (args) {
                 let elem = buffer.lastInputField;
@@ -1808,7 +1808,7 @@ var Buffer = Module("buffer", {
                 dactyl.open(url, { from: "paste", where: dactyl.NEW_TAB, background: true });
             });
 
-        mappings.add(myModes, ["p", "<MiddleMouse>"],
+        mappings.add(myModes, ["p", "<MiddleMouse>", "<open-clipboard-url>"],
             "Open (put) a URL based on the current clipboard contents in the current buffer",
             function () {
                 let url = dactyl.clipboardRead();
@@ -1816,7 +1816,7 @@ var Buffer = Module("buffer", {
                 dactyl.open(url);
             });
 
-        mappings.add(myModes, ["P"],
+        mappings.add(myModes, ["P", "<tab-open-clipboard-url>"],
             "Open (put) a URL based on the current clipboard contents in a new buffer",
             function () {
                 let url = dactyl.clipboardRead();
@@ -1825,16 +1825,16 @@ var Buffer = Module("buffer", {
             });
 
         // reloading
-        mappings.add(myModes, ["r"],
+        mappings.add(myModes, ["r", "<reload>"],
             "Reload the current web page",
             function () { tabs.reload(tabs.getTab(), false); });
 
-        mappings.add(myModes, ["R"],
+        mappings.add(myModes, ["R", "<full-reload>"],
             "Reload while skipping the cache",
             function () { tabs.reload(tabs.getTab(), true); });
 
         // yanking
-        mappings.add(myModes, ["Y"],
+        mappings.add(myModes, ["Y", "<yank-word>"],
             "Copy selected text or current word",
             function () {
                 let sel = buffer.getCurrentWord();
@@ -1843,62 +1843,62 @@ var Buffer = Module("buffer", {
             });
 
         // zooming
-        mappings.add(myModes, ["zi", "+"],
+        mappings.add(myModes, ["zi", "+", "<text-zoom-in>"],
             "Enlarge text zoom of current web page",
             function (args) { buffer.zoomIn(Math.max(args.count, 1), false); },
             { count: true });
 
-        mappings.add(myModes, ["zm"],
+        mappings.add(myModes, ["zm", "<text-zoom-more>"],
             "Enlarge text zoom of current web page by a larger amount",
             function (args) { buffer.zoomIn(Math.max(args.count, 1) * 3, false); },
             { count: true });
 
-        mappings.add(myModes, ["zo", "-"],
+        mappings.add(myModes, ["zo", "-", "<text-zoom-out>"],
             "Reduce text zoom of current web page",
             function (args) { buffer.zoomOut(Math.max(args.count, 1), false); },
             { count: true });
 
-        mappings.add(myModes, ["zr"],
+        mappings.add(myModes, ["zr", "<text-zoom-reduce>"],
             "Reduce text zoom of current web page by a larger amount",
             function (args) { buffer.zoomOut(Math.max(args.count, 1) * 3, false); },
             { count: true });
 
-        mappings.add(myModes, ["zz"],
+        mappings.add(myModes, ["zz", "<text-zoom>"],
             "Set text zoom value of current web page",
             function (args) { buffer.setZoom(args.count > 1 ? args.count : 100, false); },
             { count: true });
 
-        mappings.add(myModes, ["ZI", "zI"],
+        mappings.add(myModes, ["ZI", "zI", "<full-zoom-in>"],
             "Enlarge full zoom of current web page",
             function (args) { buffer.zoomIn(Math.max(args.count, 1), true); },
             { count: true });
 
-        mappings.add(myModes, ["ZM", "zM"],
+        mappings.add(myModes, ["ZM", "zM", "<full-zoom-more>"],
             "Enlarge full zoom of current web page by a larger amount",
             function (args) { buffer.zoomIn(Math.max(args.count, 1) * 3, true); },
             { count: true });
 
-        mappings.add(myModes, ["ZO", "zO"],
+        mappings.add(myModes, ["ZO", "zO", "<full-zoom-out>"],
             "Reduce full zoom of current web page",
             function (args) { buffer.zoomOut(Math.max(args.count, 1), true); },
             { count: true });
 
-        mappings.add(myModes, ["ZR", "zR"],
+        mappings.add(myModes, ["ZR", "zR", "<full-zoom-reduce>"],
             "Reduce full zoom of current web page by a larger amount",
             function (args) { buffer.zoomOut(Math.max(args.count, 1) * 3, true); },
             { count: true });
 
-        mappings.add(myModes, ["zZ"],
+        mappings.add(myModes, ["zZ", "<full-zoom>"],
             "Set full zoom value of current web page",
             function (args) { buffer.setZoom(args.count > 1 ? args.count : 100, true); },
             { count: true });
 
         // page info
-        mappings.add(myModes, ["<C-g>"],
+        mappings.add(myModes, ["<C-g>", "<page-info>"],
             "Print the current file name",
             function () { buffer.showPageInfo(false); });
 
-        mappings.add(myModes, ["g<C-g>"],
+        mappings.add(myModes, ["g<C-g>", "<more-page-info>"],
             "Print file information",
             function () { buffer.showPageInfo(true); });
     },

common/content/commandline.js

@@ -372,7 +372,6 @@ var CommandMode = Class("CommandMode", {
                 if (!this.completions.itemList.visible)
                     this.autocompleteTimer.flush();
             }
-            util.dump("input", commandline.command, this.widgets.command[1]);
             this.onChange(commandline.command);
         },
         keyup: function onKeyUp(event) {

common/content/events.js

@@ -33,6 +33,7 @@ var ProcessorStack = Class("ProcessorStack", {
 
     process: function process(event) {
         function dbg() {}
+        let dbg = util.closure.dump;
 
         let key = events.toString(event);
         this.events.push(event);
@@ -90,21 +91,20 @@ var ProcessorStack = Class("ProcessorStack", {
         if (processors.length)
             result = Events.KILL;
         else if (this.actions.length) {
-            if (actions.length == 0)
+            if (actions.length == 0) {
                 dactyl.beep();
-
-            if (modes.replaying && !events.waitForPageLoad())
-                result = Events.KILL;
-            else {
-                for (var res = this.actions[0]; callable(res);)
-                    res = res();
-                result = res === Events.PASS ? Events.PASS : Events.KILL;
+                events.feedingKeys = false;
             }
+
+            for (var res = this.actions[0]; callable(res);)
+                res = res();
+            result = res === Events.PASS ? Events.PASS : Events.KILL;
         }
         else if (result !== Events.KILL && !this.actions.length &&
                  processors.some(function (p) !p.main.passUnknown)) {
             result = Events.KILL;
             dactyl.beep();
+            events.feedingKeys = false;
         }
         else if (result === undefined)
             result = Events.PASS;
@@ -115,9 +115,11 @@ var ProcessorStack = Class("ProcessorStack", {
         if (result === Events.PASS || result === Events.ABORT)
             this.events.filter(function (e) e.getPreventDefault())
                 .forEach(function (event, i) {
+                    let elem = event.originalTarget;
                     if (event.originalTarget) {
-                        let evt = events.create(event.originalTarget.ownerDocument, event.type, event);
-                        events.dispatch(event.originalTarget, evt, { skipmap: true, isMacro: true });
+                        let doc = elem.ownerDocument || elem.document || elem;
+                        let evt = events.create(doc, event.type, event);
+                        events.dispatch(elem, evt, { skipmap: true, isMacro: true, isReplay: true });
                     }
                     else if (i > 0)
                         events.events.keypress.call(events, event);
@@ -491,6 +493,8 @@ var Events = Module("events", {
             util.threadYield(1, true);
 
             for (let [, evt_obj] in Iterator(events.fromString(keys))) {
+                let now = Date.now();
+                util.dump("+feed", events.toString(evt_obj));
                 for (let type in values(["keydown", "keyup", "keypress"])) {
                     let evt = update({}, evt_obj, { type: type });
 
@@ -508,13 +512,10 @@ var Events = Module("events", {
                     else
                         events.events.keypress.call(events, event);
                 }
+                util.dump("-feed", events.toString(evt_obj), this.feedingKeys);
 
                 if (!this.feedingKeys)
                     break;
-
-                // Stop feeding keys if page loading failed.
-                if (modes.replaying && !this.waitForPageLoad())
-                    break;
             }
         }
         catch (e) {
@@ -594,9 +595,14 @@ var Events = Module("events", {
      * of x.
      *
      * @param {string} keys Messy form.
+     * @param {boolean} unknownOk Whether unknown keys are passed
+     *     through rather than being converted to <lt>keyname>.
+     *     @default false
      * @returns {string} Canonical form.
      */
     canonicalKeys: function (keys, unknownOk) {
+        if (arguments.length === 1)
+            unknownOk = true;
         return events.fromString(keys, unknownOk).map(events.closure.toString).join("");
     },
 
@@ -1035,7 +1041,7 @@ var Events = Module("events", {
                 if (!key)
                      return null;
 
-                if (modes.recording && (!this._input || !mappings.user.hasMap(modes.main, this._input.buffer + key)))
+                if (modes.recording && !event.isReplay)
                     events._macroKeys.push(key);
 
                 // feedingKeys needs to be separate from interrupted so
@@ -1043,8 +1049,6 @@ var Events = Module("events", {
                 // 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) {
@@ -1323,11 +1327,11 @@ var Events = Module("events", {
     },
     mappings: function () {
         mappings.add(modes.all,
-            ["<C-z>"], "Temporarily ignore all " + config.appName + " key bindings",
+            ["<C-z>", "<pass-all-keys>"], "Temporarily ignore all " + config.appName + " key bindings",
             function () { modes.push(modes.PASS_THROUGH); });
 
         mappings.add(modes.all,
-            ["<C-v>"], "Pass through next key",
+            ["<C-v>", "<pass-next-key>"], "Pass through next key",
             function () {
                 if (modes.main == modes.QUOTE)
                     return Events.PASS;
@@ -1340,7 +1344,7 @@ var Events = Module("events", {
 
         // macros
         mappings.add([modes.NORMAL, modes.TEXT_AREA, modes.PLAYER].filter(util.identity),
-            ["q"], "Record a key sequence into a macro",
+            ["q", "<record-macro>"], "Record a key sequence into a macro",
             function ({ arg }) {
                 events._macroKeys.pop();
                 events[modes.recording ? "finishRecording" : "startRecording"](arg);
@@ -1348,13 +1352,34 @@ var Events = Module("events", {
             { get arg() !modes.recording });
 
         mappings.add([modes.NORMAL, modes.TEXT_AREA, modes.PLAYER].filter(util.identity),
-            ["@"], "Play a macro",
+            ["@", "<play-macro>"], "Play a macro",
             function ({ arg, count }) {
                 count = Math.max(count, 1);
                 while (count-- && events.playMacro(arg))
                     ;
             },
             { arg: true, count: true });
+
+        mappings.add([modes.COMMAND],
+            ["<A-m>s", "<sleep>"], "Sleep for {count} milliseconds before continuing macro playback",
+            function ({ command, count }) {
+                let now = Date.now();
+                util.dump("+<sleep>", count);
+                dactyl.assert(count, "Count required for " + command);
+                if (events.feedingKeys)
+                    util.sleep(count);
+                util.dump("-<sleep>", count, now - Date.now());
+            },
+            { count: true });
+
+        mappings.add([modes.MAIN],
+            ["<A-m>l", "<wait-for-page-load>"], "Wait for the current page to finish loading before continuing macro playback",
+            function () {
+                if (!events.waitForPageLoad()) {
+                    util.interrupted = true;
+                    throw Error("Interrupted");
+                }
+            });
     },
     options: function () {
         options.add(["passkeys", "pk"],

common/content/mappings.js

@@ -113,9 +113,17 @@ var Map = Class("Map", {
         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);
-        this.executing = false;
+
+        try {
+            this.executing = true;
+            var res = repeat();
+        }
+        catch (e) {
+            events.feedingKeys = false;
+        }
+        finally {
+            this.executing = false;
+        }
         return res;
     }