Add notion of action that differs from shortcuts.

This decouple the notion of shortcut from the notion of executed "action"
This allow the shortcuts manager to be purely describe as data, and the
same action to be later refered to either from the shortcut, from a toolbar
button or a menu.

This also implement a more complete keyboard shortcut handler which is
able ton interpete sequences like `Cmd-X,Meta-v` By storing the
shortcuts in a tree.

IPython/html/static/notebook/js/actions.js

@@ -0,0 +1,503 b''
+// Copyright (c) IPython Development Team.
+// Distributed under the terms of the Modified BSD License.
+
+define(['require'
+], function(require) {
+    "use strict";
+    
+    var ActionHandler = function (env) {
+        this.env = env || {};
+        Object.seal(this);
+    };
+
+    /**
+     *  A bunch of predefined `Simple Actions` used by IPython.
+     *  `Simple Actions` have the following keys:
+     *  help (optional): a short string the describe the action.
+     *      will be used in various context, like as menu name, tool tips on buttons,
+     *      and short description in help menu.
+     *  help_index (optional): a string used to sort action in help menu.
+     *  icon (optional): a short string that represent the icon that have to be used with this
+     *  action. this should mainly correspond to a Font_awesome class.
+     *  handler : a function which is called when the action is activated. It will receive at first parameter
+     *      a dictionary containing various handle to element of the notebook.
+     *
+     *  action need to be registered with a **name** that can be use to refer to this action.
+     *
+     *
+     *  if `help` is not provided it will be derived by replacing any dash by space
+     *  in the **name** of the action. It is advised to provide a prefix to action name to
+     *  avoid conflict the prefix should be all lowercase and end with a dot `.`
+     *  in the absence of a prefix the behavior of the action is undefined.
+     *
+     *  All action provided by IPython are prefixed with `ipython.`.
+     *
+     *  One can register extra actions or replace an existing action with another one is possible
+     *  but is considered undefined behavior.
+     *
+     **/
+    var _action = {
+        'run-select-next': {
+            icon: 'fa-play',
+            help    : 'run cell, select below',
+            help_index : 'ba',
+            handler : function (env) {
+                env.notebook.execute_cell_and_select_below();
+            }
+        },
+        'execute-in-place':{
+            help    : 'run cell',
+            help_index : 'bb',
+            handler : function (env) {
+                env.notebook.execute_cell();
+            }
+        },
+        'execute-and-insert-after':{
+            help    : 'run cell, insert below',
+            help_index : 'bc',
+            handler : function (env) {
+                env.notebook.execute_cell_and_insert_below();
+            }
+        },
+        'go-to-command-mode': {
+            help    : 'command mode',
+            help_index : 'aa',
+            handler : function (env) {
+                env.notebook.command_mode();
+            }
+        },
+        'split-cell-at-cursor': {
+            help    : 'split cell',
+            help_index : 'ea',
+            handler : function (env) {
+                env.notebook.split_cell();
+            }
+        },
+        'enter-edit-mode' : {
+            help_index : 'aa',
+            handler : function (env) {
+                env.notebook.edit_mode();
+            }
+        },
+        'select-previous-cell' : {
+            help_index : 'da',
+            handler : function (env) {
+                var index = env.notebook.get_selected_index();
+                if (index !== 0 && index !== null) {
+                    env.notebook.select_prev();
+                    env.notebook.focus_cell();
+                }
+            }
+        },
+        'select-next-cell' : {
+            help_index : 'db',
+            handler : function (env) {
+                var index = env.notebook.get_selected_index();
+                if (index !== (env.notebook.ncells()-1) && index !== null) {
+                    env.notebook.select_next();
+                    env.notebook.focus_cell();
+                }
+            }
+        },
+        'cut-selected-cell' : {
+            icon: 'fa-cut',
+            help_index : 'ee',
+            handler : function (env) {
+                env.notebook.cut_cell();
+            }
+        },
+        'copy-selected-cell' : {
+            icon: 'fa-copy',
+            help_index : 'ef',
+            handler : function (env) {
+                env.notebook.copy_cell();
+            }
+        },
+        'paste-cell-before' : {
+            help_index : 'eg',
+            handler : function (env) {
+                env.notebook.paste_cell_above();
+            }
+        },
+        'paste-cell-after' : {
+            icon: 'fa-paste',
+            help_index : 'eh',
+            handler : function (env) {
+                env.notebook.paste_cell_below();
+            }
+        },
+        'insert-cell-before' : {
+            help_index : 'ec',
+            handler : function (env) {
+                env.notebook.insert_cell_above();
+                env.notebook.select_prev();
+                env.notebook.focus_cell();
+            }
+        },
+        'insert-cell-after' : {
+            icon : 'fa-plus',
+            help_index : 'ed',
+            handler : function (env) {
+                env.notebook.insert_cell_below();
+                env.notebook.select_next();
+                env.notebook.focus_cell();
+            }
+        },
+        'change-selected-cell-to-code-cell' : {
+            help    : 'to code',
+            help_index : 'ca',
+            handler : function (env) {
+                env.notebook.to_code();
+            }
+        },
+        'change-selected-cell-to-markdown-cell' : {
+            help    : 'to markdown',
+            help_index : 'cb',
+            handler : function (env) {
+                env.notebook.to_markdown();
+            }
+        },
+        'change-selected-cell-to-raw-cell' : {
+            help    : 'to raw',
+            help_index : 'cc',
+            handler : function (env) {
+                env.notebook.to_raw();
+            }
+        },
+        'change-selected-cell-to-heading-1' : {
+            help    : 'to heading 1',
+            help_index : 'cd',
+            handler : function (env) {
+                env.notebook.to_heading(undefined, 1);
+            }
+        },
+        'change-selected-cell-to-heading-2' : {
+            help    : 'to heading 2',
+            help_index : 'ce',
+            handler : function (env) {
+                env.notebook.to_heading(undefined, 2);
+            }
+        },
+        'change-selected-cell-to-heading-3' : {
+            help    : 'to heading 3',
+            help_index : 'cf',
+            handler : function (env) {
+                env.notebook.to_heading(undefined, 3);
+            }
+        },
+        'change-selected-cell-to-heading-4' : {
+            help    : 'to heading 4',
+            help_index : 'cg',
+            handler : function (env) {
+                env.notebook.to_heading(undefined, 4);
+            }
+        },
+        'change-selected-cell-to-heading-5' : {
+            help    : 'to heading 5',
+            help_index : 'ch',
+            handler : function (env) {
+                env.notebook.to_heading(undefined, 5);
+            }
+        },
+        'change-selected-cell-to-heading-6' : {
+            help    : 'to heading 6',
+            help_index : 'ci',
+            handler : function (env) {
+                env.notebook.to_heading(undefined, 6);
+            }
+        },
+        'toggle-output-visibility-selected-cell' : {
+            help    : 'toggle output',
+            help_index : 'gb',
+            handler : function (env) {
+                env.notebook.toggle_output();
+            }
+        },
+        'toggle-output-scrolling-selected-cell' : {
+            help    : 'toggle output scrolling',
+            help_index : 'gc',
+            handler : function (env) {
+                env.notebook.toggle_output_scroll();
+            }
+        },
+        'move-selected-cell-down' : {
+            icon: 'fa-arrow-down',
+            help_index : 'eb',
+            handler : function (env) {
+                env.notebook.move_cell_down();
+            }
+        },
+        'move-selected-cell-up' : {
+            icon: 'fa-arrow-up',
+            help_index : 'ea',
+            handler : function (env) {
+                env.notebook.move_cell_up();
+            }
+        },
+        'toggle-line-number-selected-cell' : {
+            help    : 'toggle line numbers',
+            help_index : 'ga',
+            handler : function (env) {
+                env.notebook.cell_toggle_line_numbers();
+            }
+        },
+        'show-keyboard-shortcut-help-dialog' : {
+            help_index : 'ge',
+            handler : function (env) {
+                env.quick_help.show_keyboard_shortcuts();
+            }
+        },
+        'delete-cell': {
+            help_index : 'ej',
+            handler : function (env) {
+                env.notebook.delete_cell();
+            }
+        },
+        'interrupt-kernel':{
+            icon: 'fa-stop',
+            help_index : 'ha',
+            handler : function (env) {
+                env.notebook.kernel.interrupt();
+            }
+        },
+        'restart-kernel':{
+            icon: 'fa-repeat',
+            help_index : 'hb',
+            handler : function (env) {
+                env.notebook.restart_kernel();
+            }
+        },
+        'undo-last-cell-deletion' : {
+            help_index : 'ei',
+            handler : function (env) {
+                env.notebook.undelete_cell();
+            }
+        },
+        'merge-selected-cell-with-cell-after' : {
+            help    : 'merge cell below',
+            help_index : 'ek',
+            handler : function (env) {
+                env.notebook.merge_cell_below();
+            }
+        },
+        'close-pager' : {
+            help_index : 'gd',
+            handler : function (env) {
+                env.pager.collapse();
+            }
+        }
+
+    };
+
+    /**
+     * A bunch of `Advance actions` for IPython.
+     * Cf `Simple Action` plus the following properties.
+     *
+     * handler: first argument of the handler is the event that triggerd the action
+     *      (typically keypress). The handler is responsible for any modification of the
+     *      event and event propagation.
+     *      Is also responsible for returning false if the event have to be further ignored,
+     *      true, to tell keyboard manager that it ignored the event.
+     *
+     *      the second parameter of the handler is the environemnt passed to Simple Actions
+     *
+     **/
+    var custom_ignore = {
+        'ignore':{
+            handler : function () {
+                return true;
+            }
+        },
+        'move-cursor-up-or-previous-cell':{
+            handler : function (env, event) {
+                var index = env.notebook.get_selected_index();
+                var cell = env.notebook.get_cell(index);
+                var cm = env.notebook.get_selected_cell().code_mirror;
+                var cur = cm.getCursor();
+                if (cell && cell.at_top() && index !== 0 && cur.ch === 0) {
+                    if(event){
+                        event.preventDefault();
+                    }
+                    env.notebook.command_mode();
+                    env.notebook.select_prev();
+                    env.notebook.edit_mode();
+                    cm = env.notebook.get_selected_cell().code_mirror;
+                    cm.setCursor(cm.lastLine(), 0);
+                }
+                return false;
+            }
+        },
+        'move-cursor-down-or-next-cell':{
+            handler : function (env, event) {
+                var index = env.notebook.get_selected_index();
+                var cell = env.notebook.get_cell(index);
+                if (cell.at_bottom() && index !== (env.notebook.ncells()-1)) {
+                    if(event){
+                        event.preventDefault();
+                    }
+                    env.notebook.command_mode();
+                    env.notebook.select_next();
+                    env.notebook.edit_mode();
+                    var cm = env.notebook.get_selected_cell().code_mirror;
+                    cm.setCursor(0, 0);
+                }
+                return false;
+            }
+        },
+        'scroll-down': {
+            handler: function(env, event) {
+                if(event){
+                    event.preventDefault();
+                }
+                return env.notebook.scroll_manager.scroll(1);
+            },
+        },
+        'scroll-up': {
+            handler: function(env, event) {
+                if(event){
+                    event.preventDefault();
+                }
+                return env.notebook.scroll_manager.scroll(-1);
+            },
+        },
+        'save-notebook':{
+            help: "Save and Checkpoint",
+            help_index : 'fb',
+            icon: 'fa-save',
+            handler : function (env, event) {
+                env.notebook.save_checkpoint();
+                if(event){
+                    event.preventDefault();
+                }
+                return false;
+            }
+        },
+    };
+
+    // private stuff that prepend `.ipython` to actions names
+    // and uniformize/fill in missing pieces in of an action.
+    var _prepare_handler = function(registry, subkey, source){
+        registry['ipython.'+subkey] = {};
+        registry['ipython.'+subkey].help = source[subkey].help||subkey.replace(/-/g,' ');
+        registry['ipython.'+subkey].help_index = source[subkey].help_index;
+        registry['ipython.'+subkey].icon = source[subkey].icon;
+        return source[subkey].handler;
+    };
+
+    // Will actually generate/register all the IPython actions
+    var fun = function(){
+        var final_actions = {};
+        for(var k in _action){
+            // Js closure are function level not block level need to wrap in a IIFE
+            // and append ipython to event name these things do intercept event so are wrapped
+            // in a function that return false.
+            var handler = _prepare_handler(final_actions, k, _action);
+            (function(key, handler){
+                final_actions['ipython.'+key].handler = function(env, event){
+                    handler(env);
+                    if(event){
+                        event.preventDefault();
+                    }
+                    return false;
+                };
+            })(k, handler);
+        }
+
+        for(var k in custom_ignore){
+            // Js closure are function level not block level need to wrap in a IIFE
+            // same as above, but decide for themselves wether or not they intercept events.
+            var handler = _prepare_handler(final_actions, k, custom_ignore);
+            (function(key, handler){
+                final_actions['ipython.'+key].handler = function(env, event){
+                    return handler(env, event);
+                };
+            })(k, handler);
+        }
+
+        return final_actions;
+    };
+    ActionHandler.prototype._actions = fun();
+
+
+    /**
+     *  extend the environment variable that will be pass to handlers
+     **/
+    ActionHandler.prototype.extend_env = function(env){
+        for(var k in env){
+            this.env[k] = env[k];
+        }
+    };
+
+    ActionHandler.prototype.register = function(action, name, prefix){
+        /**
+         * Register an `action` with an optional name and prefix. 
+         *
+         * if name and prefix are not given they will be determined automatically. 
+         * if action if just a `function` it will be wrapped in an anonymous action.
+         *
+         * @return the full name to access this action .
+         **/
+        action = this.normalise(action);
+        if( !name ){
+            name = 'autogenerated-'+String(action.handler);
+        }
+        prefix = prefix || 'auto';
+        var full_name = prefix+'.'+name;
+        this._actions[full_name] = action;
+        return full_name;
+
+    };
+
+
+    ActionHandler.prototype.normalise = function(data){
+        /**
+         * given an `action` or `function`, return a normalised `action`
+         * by setting all known attributes and removing unknown attributes;
+         **/
+        if(typeof(data) === 'function'){
+            data = {handler:data};
+        }
+        if(typeof(data.handler) !== 'function'){
+            throw('unknown datatype, cannot register');
+        }
+        var _data = data;
+        data = {};
+        data.handler = _data.handler;
+        data.help = data.help || '';
+        data.icon = data.icon || '';
+        data.help_index = data.help_index || '';
+        return data;
+    };
+
+    ActionHandler.prototype.get_name = function(name_or_data){
+        /**
+         * given an `action` or `name` of a action, return the name attached to this action.
+         * if given the name of and corresponding actions does not exist in registry, return `null`.
+         **/
+
+        if(typeof(name_or_data) === 'string'){
+            if(this.exists(name_or_data)){
+                return name_or_data;
+            } else {
+                return null;
+            }
+        } else {
+            return this.register(name_or_data);
+        }
+    };
+
+    ActionHandler.prototype.get = function(name){
+        return this._actions[name];
+    };
+
+    ActionHandler.prototype.call = function(name, event, env){
+        return this._actions[name].handler(env|| this.env, event);
+    };
+
+    ActionHandler.prototype.exists = function(name){
+        return (typeof(this._actions[name]) !== 'undefined');
+    };
+
+    return {init:ActionHandler};
+
+});

IPython/html/static/base/js/keyboard.js

@@ -1,288 +1,454 b''
 // Copyright (c) IPython Development Team.
 // Distributed under the terms of the Modified BSD License.
 /**
  *
  *
  * @module keyboard
  * @namespace keyboard
  * @class ShortcutManager
  */
 
 define([
     'base/js/namespace',
     'jquery',
     'base/js/utils',
-], function(IPython, $, utils) {
+    'underscore',
+], function(IPython, $, utils, _) {
     "use strict";
 
 
-    // Setup global keycodes and inverse keycodes.
+    /**
+     * Setup global keycodes and inverse keycodes.
+     * 
+     * See http://unixpapa.com/js/key.html for a complete description. The short of
+     * it is that there are different keycode sets. Firefox uses the "Mozilla keycodes"
+     * and Webkit/IE use the "IE keycodes". These keycode sets are mostly the same
+     * but have minor differences.
+     **/
 
-    // See http://unixpapa.com/js/key.html for a complete description. The short of
-    // it is that there are different keycode sets. Firefox uses the "Mozilla keycodes"
-    // and Webkit/IE use the "IE keycodes". These keycode sets are mostly the same
-    // but have minor differences.
-
-    // These apply to Firefox, (Webkit and IE)
+     // These apply to Firefox, (Webkit and IE)
+     // This does work **only** on US keyboard.
     var _keycodes = {
         'a': 65, 'b': 66, 'c': 67, 'd': 68, 'e': 69, 'f': 70, 'g': 71, 'h': 72, 'i': 73,
         'j': 74, 'k': 75, 'l': 76, 'm': 77, 'n': 78, 'o': 79, 'p': 80, 'q': 81, 'r': 82,
         's': 83, 't': 84, 'u': 85, 'v': 86, 'w': 87, 'x': 88, 'y': 89, 'z': 90,
         '1 !': 49, '2 @': 50, '3 #': 51, '4 $': 52, '5 %': 53, '6 ^': 54,
         '7 &': 55, '8 *': 56, '9 (': 57, '0 )': 48, 
         '[ {': 219, '] }': 221, '` ~': 192,  ', <': 188, '. >': 190, '/ ?': 191,
         '\\ |': 220, '\' "': 222,
         'numpad0': 96, 'numpad1': 97, 'numpad2': 98, 'numpad3': 99, 'numpad4': 100,
         'numpad5': 101, 'numpad6': 102, 'numpad7': 103, 'numpad8': 104, 'numpad9': 105,
         'multiply': 106, 'add': 107, 'subtract': 109, 'decimal': 110, 'divide': 111,
         'f1': 112, 'f2': 113, 'f3': 114, 'f4': 115, 'f5': 116, 'f6': 117, 'f7': 118,
         'f8': 119, 'f9': 120, 'f11': 122, 'f12': 123, 'f13': 124, 'f14': 125, 'f15': 126,
         'backspace': 8, 'tab': 9, 'enter': 13, 'shift': 16, 'ctrl': 17, 'alt': 18,
         'meta': 91, 'capslock': 20, 'esc': 27, 'space': 32, 'pageup': 33, 'pagedown': 34,
         'end': 35, 'home': 36, 'left': 37, 'up': 38, 'right': 39, 'down': 40,
         'insert': 45, 'delete': 46, 'numlock': 144,
     };
     
     // These apply to Firefox and Opera
     var _mozilla_keycodes = {
         '; :': 59, '= +': 61, '- _': 173, 'meta': 224
     };
     
     // This apply to Webkit and IE
     var _ie_keycodes = {
         '; :': 186, '= +': 187, '- _': 189
     };
     
     var browser = utils.browser[0];
     var platform = utils.platform;
     
     if (browser === 'Firefox' || browser === 'Opera' || browser === 'Netscape') {
         $.extend(_keycodes, _mozilla_keycodes);
     } else if (browser === 'Safari' || browser === 'Chrome' || browser === 'MSIE') {
         $.extend(_keycodes, _ie_keycodes);
     }
 
     var keycodes = {};
     var inv_keycodes = {};
     for (var name in _keycodes) {
         var names = name.split(' ');
         if (names.length === 1) {
             var n = names[0];
             keycodes[n] = _keycodes[n];
             inv_keycodes[_keycodes[n]] = n;
         } else {
             var primary = names[0];
             var secondary = names[1];
             keycodes[primary] = _keycodes[name];
             keycodes[secondary] = _keycodes[name];
             inv_keycodes[_keycodes[name]] = primary;
         }
     }
 
     var normalize_key = function (key) {
         return inv_keycodes[keycodes[key]];
     };
 
     var normalize_shortcut = function (shortcut) {
-        // Put a shortcut into normalized form:
-        // 1. Make lowercase
-        // 2. Replace cmd by meta
-        // 3. Sort '-' separated modifiers into the order alt-ctrl-meta-shift
-        // 4. Normalize keys
+        /**
+         * @function _normalize_shortcut
+         * @private
+         * return a dict containing the normalized shortcut and the number of time it should be pressed:
+         *
+         * Put a shortcut into normalized form:
+         * 1. Make lowercase
+         * 2. Replace cmd by meta
+         * 3. Sort '-' separated modifiers into the order alt-ctrl-meta-shift
+         * 4. Normalize keys
+         **/
+        if (platform === 'MacOS') {
+            shortcut = shortcut.toLowerCase().replace('cmdtrl-', 'cmd-');
+        } else {
+            shortcut = shortcut.toLowerCase().replace('cmdtrl-', 'ctrl-');
+        }
+
         shortcut = shortcut.toLowerCase().replace('cmd', 'meta');
         shortcut = shortcut.replace(/-$/, '_');  // catch shortcuts using '-' key
+        shortcut = shortcut.replace(/,$/, 'comma');  // catch shortcuts using '-' key
+        if(shortcut.indexOf(',') !== -1){
+            var sht = shortcut.split(',');
+            sht = _.map(sht, normalize_shortcut);
+            return shortcut;
+        }
+        shortcut = shortcut.replace(/comma/g, ',');  // catch shortcuts using '-' key
         var values = shortcut.split("-");
         if (values.length === 1) {
             return normalize_key(values[0]);
         } else {
             var modifiers = values.slice(0,-1);
             var key = normalize_key(values[values.length-1]);
             modifiers.sort();
             return modifiers.join('-') + '-' + key;
         }
     };
 
     var shortcut_to_event = function (shortcut, type) {
-        // Convert a shortcut (shift-r) to a jQuery Event object
+        /**
+         * Convert a shortcut (shift-r) to a jQuery Event object
+         **/
         type = type || 'keydown';
         shortcut = normalize_shortcut(shortcut);
         shortcut = shortcut.replace(/-$/, '_');  // catch shortcuts using '-' key
         var values = shortcut.split("-");
         var modifiers = values.slice(0,-1);
         var key = values[values.length-1];
         var opts = {which: keycodes[key]};
         if (modifiers.indexOf('alt') !== -1) {opts.altKey = true;}
         if (modifiers.indexOf('ctrl') !== -1) {opts.ctrlKey = true;}
         if (modifiers.indexOf('meta') !== -1) {opts.metaKey = true;}
         if (modifiers.indexOf('shift') !== -1) {opts.shiftKey = true;}
         return $.Event(type, opts);
     };
 
+    var only_modifier_event = function(event){
+        /**
+         * Return `true` if the event only contains modifiers keys.
+         * false otherwise
+         **/
+        var key = inv_keycodes[event.which];
+        return ((event.altKey || event.ctrlKey || event.metaKey || event.shiftKey) && 
+         (key === 'alt'|| key === 'ctrl'|| key === 'meta'|| key === 'shift'));
+
+    };
+
     var event_to_shortcut = function (event) {
-        // Convert a jQuery Event object to a shortcut (shift-r)
+        /**
+         * Convert a jQuery Event object to a normalized shortcut string (shift-r)
+         **/
         var shortcut = '';
         var key = inv_keycodes[event.which];
         if (event.altKey && key !== 'alt') {shortcut += 'alt-';}
         if (event.ctrlKey && key !== 'ctrl') {shortcut += 'ctrl-';}
         if (event.metaKey && key !== 'meta') {shortcut += 'meta-';}
         if (event.shiftKey && key !== 'shift') {shortcut += 'shift-';}
         shortcut += key;
         return shortcut;
     };
 
     // Shortcut manager class
 
-    var ShortcutManager = function (delay, events) {
+    var ShortcutManager = function (delay, events, actions, env) {
         /**
          * A class to deal with keyboard event and shortcut
          *
          * @class ShortcutManager
          * @constructor
          */
         this._shortcuts = {};
-        this._counts = {};
-        this._timers = {};
         this.delay = delay || 800; // delay in milliseconds
         this.events = events;
+        this.actions = actions;
+        this.actions.extend_env(env);
+        this._queue = [];
+        this._cleartimeout = null;
+        Object.seal(this);
+    };
+
+    ShortcutManager.prototype.clearsoon = function(){
+        /**
+         * Clear the pending shortcut soon, and cancel previous clearing
+         * that might be registered.
+         **/ 
+         var that = this;
+         clearTimeout(this._cleartimeout);
+         this._cleartimeout = setTimeout(function(){that.clearqueue();}, this.delay);
+    };
+
+
+    ShortcutManager.prototype.clearqueue = function(){
+        /**
+         * clear the pending shortcut sequence now. 
+         **/
+        this._queue = [];
+        clearTimeout(this._cleartimeout);
+    };
+
+
+    var flatten_shorttree = function(tree){
+        /**
+         * Flatten a tree of shortcut sequences. 
+         * use full to iterate over all the key/values of available shortcuts.
+         **/
+        var  dct = {};
+        for(var key in tree){
+            var value = tree[key];
+            if(typeof(value) === 'string'){
+                dct[key] = value;
+            } else {
+                var ftree=flatten_shorttree(value);
+                for(var subkey in ftree){
+                    dct[key+','+subkey] = ftree[subkey];
+                }
+            } 
+        }
+        return dct;
     };
 
     ShortcutManager.prototype.help = function () {
         var help = [];
-        for (var shortcut in this._shortcuts) {
-            var help_string = this._shortcuts[shortcut].help;
-            var help_index = this._shortcuts[shortcut].help_index;
+        var ftree = flatten_shorttree(this._shortcuts);
+        for (var shortcut in ftree) {
+            var action = this.actions.get(ftree[shortcut]);
+            var help_string = action.help||'== no help ==';
+            var help_index = action.help_index;
             if (help_string) {
-                if (platform === 'MacOS') {
-                    shortcut = shortcut.replace('meta', 'cmd');
-                }
+                var shortstring = (action.shortstring||shortcut);
                 help.push({
-                    shortcut: shortcut,
+                    shortcut: shortstring,
                     help: help_string,
                     help_index: help_index}
                 );
             }
         }
         help.sort(function (a, b) {
-            if (a.help_index > b.help_index)
+            if (a.help_index > b.help_index){
                 return 1;
-            if (a.help_index < b.help_index)
+            }
+            if (a.help_index < b.help_index){
                 return -1;
+            }
             return 0;
         });
         return help;
     };
 
     ShortcutManager.prototype.clear_shortcuts = function () {
         this._shortcuts = {};
     };
 
-    ShortcutManager.prototype.add_shortcut = function (shortcut, data, suppress_help_update) {
-        if (typeof(data) === 'function') {
-            data = {help: '', help_index: '', handler: data};
+    ShortcutManager.prototype.get_shortcut = function (shortcut){
+        /**
+         * return a node of the shortcut tree which an action name (string) if leaf,
+         * and an object with `object.subtree===true`
+         **/
+        if(typeof(shortcut) === 'string'){
+            shortcut = shortcut.split(',');
+        }
+        
+        return this._get_leaf(shortcut, this._shortcuts);
+    };
+
+
+    ShortcutManager.prototype._get_leaf = function(shortcut_array, tree){
+        /**
+         * @private
+         * find a leaf/node in a subtree of the keyboard shortcut
+         *
+         **/
+        if(shortcut_array.length === 1){
+            return tree[shortcut_array[0]];
+        } else if(  typeof(tree[shortcut_array[0]]) !== 'string'){
+            return this._get_leaf(shortcut_array.slice(1), tree[shortcut_array[0]]);
+        }
+        return null;
+    };
+
+    ShortcutManager.prototype.set_shortcut = function( shortcut, action_name){
+        if( typeof(action_name) !== 'string'){ throw('action is not a string', action_name);}
+        if( typeof(shortcut) === 'string'){
+            shortcut = shortcut.split(',');
+        }
+        return this._set_leaf(shortcut, action_name, this._shortcuts);
+    };
+
+    ShortcutManager.prototype._is_leaf = function(shortcut_array, tree){
+        if(shortcut_array.length === 1){
+           return(typeof(tree[shortcut_array[0]]) === 'string');
+        } else {
+            var subtree = tree[shortcut_array[0]];
+            return this._is_leaf(shortcut_array.slice(1), subtree );
+        }
+    };
+
+    ShortcutManager.prototype._remove_leaf = function(shortcut_array, tree, allow_node){
+        if(shortcut_array.length === 1){
+            var current_node = tree[shortcut_array[0]];
+            if(typeof(current_node) === 'string'){
+                delete tree[shortcut_array[0]];
+            } else {
+                throw('try to delete non-leaf');
+            }
+        } else {
+            this._remove_leaf(shortcut_array.slice(1),  tree[shortcut_array[0]], allow_node);
+            if(_.keys(tree[shortcut_array[0]]).length === 0){
+                delete tree[shortcut_array[0]];
+            }
+        }
+    };
+
+    ShortcutManager.prototype._set_leaf = function(shortcut_array, action_name, tree){
+        var current_node = tree[shortcut_array[0]];
+        if(shortcut_array.length === 1){
+            if(current_node !== undefined && typeof(current_node) !== 'string'){
+                console.warn('[warning], you are overriting a long shortcut with a shorter one');
+            }
+            tree[shortcut_array[0]] = action_name;
+            return true;
+        } else {
+            if(typeof(current_node) === 'string'){
+                console.warn('you are trying to set a shortcut that will be shadowed'+
+                             'by a more specific one. Aborting for :', action_name, 'the follwing '+
+                             'will take precedence', current_node);
+                return false;
+            } else {
+                tree[shortcut_array[0]] = tree[shortcut_array[0]]||{};
+            }
+            this._set_leaf(shortcut_array.slice(1), action_name, tree[shortcut_array[0]]);
+            return true;
         }
-        data.help_index = data.help_index || '';
-        data.help = data.help || '';
-        data.count = data.count || 1;
-        if (data.help_index === '') {
-            data.help_index = 'zz';
+    };
+
+    ShortcutManager.prototype.add_shortcut = function (shortcut, data, suppress_help_update) {
+        /**
+         * Add a action to be handled by shortcut manager. 
+         * 
+         * - `shortcut` should be a `Shortcut Sequence` of the for `Ctrl-Alt-C,Meta-X`...
+         * - `data` could be an `action name`, an `action` or a `function`.
+         *   if a `function` is passed it will be converted to an anonymous `action`. 
+         *
+         **/
+        var action_name = this.actions.get_name(data);
+        if (! action_name){
+            throw('does nto know how to deal with ', data);
         }
+        
         shortcut = normalize_shortcut(shortcut);
-        this._counts[shortcut] = 0;
-        this._shortcuts[shortcut] = data;
+        this.set_shortcut(shortcut, action_name);
+
         if (!suppress_help_update) {
             // update the keyboard shortcuts notebook help
             this.events.trigger('rebuild.QuickHelp');
         }
     };
 
     ShortcutManager.prototype.add_shortcuts = function (data) {
+        /**
+         * Convenient methods to call `add_shortcut(key, value)` on several items
+         * 
+         *  data : Dict of the form {key:value, ...}
+         **/
         for (var shortcut in data) {
             this.add_shortcut(shortcut, data[shortcut], true);
         }
         // update the keyboard shortcuts notebook help
         this.events.trigger('rebuild.QuickHelp');
     };
 
     ShortcutManager.prototype.remove_shortcut = function (shortcut, suppress_help_update) {
+        /**
+         * Remove the binding of shortcut `sortcut` with its action.
+         * throw an error if trying to remove a non-exiting shortcut
+         **/
         shortcut = normalize_shortcut(shortcut);
-        delete this._counts[shortcut];
-        delete this._shortcuts[shortcut];
+        if( typeof(shortcut) === 'string'){
+            shortcut = shortcut.split(',');
+        }
+        this._remove_leaf(shortcut, this._shortcuts);
         if (!suppress_help_update) {
             // update the keyboard shortcuts notebook help
             this.events.trigger('rebuild.QuickHelp');
         }
     };
 
-    ShortcutManager.prototype.count_handler = function (shortcut, event, data) {
-        /**
-         * Seem to allow to call an handler only after several key press.
-         * like, I suppose `dd` that delete the current cell only after
-         * `d` has been pressed twice..
-         * @method count_handler
-         * @return {Boolean} `true|false`, whether or not the event has been handled.
-         * @param shortcut {shortcut}
-         * @param event {event}
-         * @param data {data}
-         */
-        var that = this;
-        var c = this._counts;
-        var t = this._timers;
-        var timer = null;
-        if (c[shortcut] === data.count-1) {
-            c[shortcut] = 0;
-            timer = t[shortcut];
-            if (timer) {clearTimeout(timer); delete t[shortcut];}
-            return data.handler(event);
-        } else {
-            c[shortcut] = c[shortcut] + 1;
-            timer = setTimeout(function () {
-                c[shortcut] = 0;
-            }, that.delay);
-            t[shortcut] = timer;
-        }
-        return false;
-    };
+
 
     ShortcutManager.prototype.call_handler = function (event) {
         /**
          * Call the corresponding shortcut handler for a keyboard event
          * @method call_handler
          * @return {Boolean} `true|false`, `false` if no handler was found, otherwise the  value return by the handler. 
          * @param event {event}
-         */
+         *
+         * given an event, call the corresponding shortcut. 
+         * return false is event wan handled, true otherwise 
+         * in any case returning false stop event propagation
+         **/
+
+
+        this.clearsoon();
+        if(only_modifier_event(event)){
+            return true;
+        }
         var shortcut = event_to_shortcut(event);
-        var data = this._shortcuts[shortcut];
-        if (data) {
-            var handler = data.handler;
-            if (handler) {
-                if (data.count === 1) {
-                    return handler(event);
-                } else if (data.count > 1) {
-                    return this.count_handler(shortcut, event, data);
-                }
-            }
+        this._queue.push(shortcut);
+        var action_name = this.get_shortcut(this._queue);
+
+        if (typeof(action_name) === 'undefined'|| action_name === null){
+            this.clearqueue();
+            return true;
+        }
+        
+        if (this.actions.exists(action_name)) {
+            event.preventDefault();
+            this.clearqueue();
+            return this.actions.call(action_name, event);
         }
-        return true;
+
+        return false;
     };
 
+
     ShortcutManager.prototype.handles = function (event) {
         var shortcut = event_to_shortcut(event);
-        var data = this._shortcuts[shortcut];
-        return !( data === undefined || data.handler === undefined );
+        var action_name = this.get_shortcut(this._queue.concat(shortcut));
+        return (typeof(action_name) !== 'undefined');
     };
 
     var keyboard = {
         keycodes : keycodes,
         inv_keycodes : inv_keycodes,
         ShortcutManager : ShortcutManager,
         normalize_key : normalize_key,
         normalize_shortcut : normalize_shortcut,
         shortcut_to_event : shortcut_to_event,
-        event_to_shortcut : event_to_shortcut
+        event_to_shortcut : event_to_shortcut,
     };
 
     // For backwards compatibility.
     IPython.keyboard = keyboard;
 
     return keyboard;
 });

IPython/html/static/notebook/js/keyboardmanager.js

@@ -1,602 +1,241 b''
 // Copyright (c) IPython Development Team.
 // Distributed under the terms of the Modified BSD License.
 /**
  *
  *
  * @module keyboardmanager
  * @namespace keyboardmanager
  * @class KeyboardManager
  */
 
 define([
     'base/js/namespace',
     'jquery',
     'base/js/utils',
     'base/js/keyboard',
 ], function(IPython, $, utils, keyboard) {
     "use strict";
     
-    var browser = utils.browser[0];
-    var platform = utils.platform;
-
     // Main keyboard manager for the notebook
     var keycodes = keyboard.keycodes;
 
     var KeyboardManager = function (options) {
         /**
          * A class to deal with keyboard event and shortcut
          *
          * @class KeyboardManager
          * @constructor
          * @param options {dict} Dictionary of keyword arguments :
          *    @param options.events {$(Events)} instance 
          *    @param options.pager: {Pager}  pager instance
          */
         this.mode = 'command';
         this.enabled = true;
         this.pager = options.pager;
         this.quick_help = undefined;
         this.notebook = undefined;
+        this.last_mode = undefined;
         this.bind_events();
-        this.command_shortcuts = new keyboard.ShortcutManager(undefined, options.events);
+        this.env = {pager:this.pager};
+        this.actions = options.actions;
+        this.command_shortcuts = new keyboard.ShortcutManager(undefined, options.events, this.actions, this.env );
         this.command_shortcuts.add_shortcuts(this.get_default_common_shortcuts());
         this.command_shortcuts.add_shortcuts(this.get_default_command_shortcuts());
-        this.edit_shortcuts = new keyboard.ShortcutManager(undefined, options.events);
+        this.edit_shortcuts = new keyboard.ShortcutManager(undefined, options.events, this.actions, this.env);
         this.edit_shortcuts.add_shortcuts(this.get_default_common_shortcuts());
         this.edit_shortcuts.add_shortcuts(this.get_default_edit_shortcuts());
+        Object.seal(this);
     };
 
+
+
+
     /**
      * Return a dict of common shortcut
      * @method get_default_common_shortcuts
      *
      * @example Example of returned shortcut
      * ```
-     * 'shortcut-key': // a string representing the shortcut as dash separated value.
-     *                 // e.g. 'shift' , 'shift-enter', 'cmd-t'
-     *  {
-     *     help: String // user facing help string 
-     *     help_index: String // string used internally to order the shortcut on the quickhelp
-     *     handler: function(event){return true|false} // function that takes an even as first and only parameter
-     *          // and return a boolean indicating whether or not the event should been handled further.
-     *   }
+     * 'shortcut-key': 'action-name'
+     * // a string representing the shortcut as dash separated value.
+     * // e.g. 'shift' , 'shift-enter', 'cmd-t'
      *```
      */
     KeyboardManager.prototype.get_default_common_shortcuts = function() {
-        var that = this;
-        var shortcuts = {
-            'shift' : {
-                help    : '',
-                help_index : '',
-                handler : function (event) {
-                    // ignore shift keydown
-                    return true;
-                }
-            },
-            'shift-enter' : {
-                help    : 'run cell, select below',
-                help_index : 'ba',
-                handler : function (event) {
-                    that.notebook.execute_cell_and_select_below();
-                    return false;
-                }
-            },
-            'ctrl-enter' : {
-                help    : 'run cell',
-                help_index : 'bb',
-                handler : function (event) {
-                    that.notebook.execute_cell();
-                    return false;
-                }
-            },
-            'alt-enter' : {
-                help    : 'run cell, insert below',
-                help_index : 'bc',
-                handler : function (event) {
-                    that.notebook.execute_cell_and_insert_below();
-                    return false;
-                }
-            }
+        return {
+            'shift'       : 'ipython.ignore',
+            'shift-enter' : 'ipython.run-select-next',
+            'ctrl-enter'  : 'ipython.execute-in-place',
+            'alt-enter'   : 'ipython.execute-and-insert-after',
+            // cmd on mac, ctrl otherwise
+            'cmdtrl-s'    : 'ipython.save-notebook',
         };
-
-        if (platform === 'MacOS') {
-            shortcuts['cmd-s'] =
-                {
-                    help    : 'save notebook',
-                    help_index : 'fb',
-                    handler : function (event) {
-                        that.notebook.save_checkpoint();
-                        event.preventDefault();
-                        return false;
-                    }
-                };
-        } else {
-            shortcuts['ctrl-s'] =
-                {
-                    help    : 'save notebook',
-                    help_index : 'fb',
-                    handler : function (event) {
-                        that.notebook.save_checkpoint();
-                        event.preventDefault();
-                        return false;
-                    }
-                };
-        }
-        return shortcuts;
     };
 
     KeyboardManager.prototype.get_default_edit_shortcuts = function() {
-        var that = this;
         return {
-            'esc' : {
-                help    : 'command mode',
-                help_index : 'aa',
-                handler : function (event) {
-                    that.notebook.command_mode();
-                    return false;
-                }
-            },
-            'ctrl-m' : {
-                help    : 'command mode',
-                help_index : 'ab',
-                handler : function (event) {
-                    that.notebook.command_mode();
-                    return false;
-                }
-            },
-            'up' : {
-                help    : '',
-                help_index : '',
-                handler : function (event) {
-                    var index = that.notebook.get_selected_index();
-                    var cell = that.notebook.get_cell(index);
-                    var cm = that.notebook.get_selected_cell().code_mirror;
-                    var cur = cm.getCursor()
-                    if (cell && cell.at_top() && index !== 0 && cur.ch === 0) {
-                        event.preventDefault();
-                        that.notebook.command_mode();
-                        that.notebook.select_prev();
-                        that.notebook.edit_mode();
-                        var cm = that.notebook.get_selected_cell().code_mirror;
-                        cm.setCursor(cm.lastLine(), 0);
-                    }
-                    return false;
-                }
-            },
-            'down' : {
-                help    : '',
-                help_index : '',
-                handler : function (event) {
-                    var index = that.notebook.get_selected_index();
-                    var cell = that.notebook.get_cell(index);
-                    if (cell.at_bottom() && index !== (that.notebook.ncells()-1)) {
-                        event.preventDefault();
-                        that.notebook.command_mode();
-                        that.notebook.select_next();
-                        that.notebook.edit_mode();
-                        var cm = that.notebook.get_selected_cell().code_mirror;
-                        cm.setCursor(0, 0);
-                        return false;
-                    }
-                    return false;
-                }
-            },
-            'ctrl-shift--' : {
-                help    : 'split cell',
-                help_index : 'ea',
-                handler : function (event) {
-                    that.notebook.split_cell();
-                    return false;
-                }
-            },
-            'ctrl-shift-subtract' : {
-                help    : '',
-                help_index : 'eb',
-                handler : function (event) {
-                    that.notebook.split_cell();
-                    return false;
-                }
-            },
+            'esc'                 : 'ipython.go-to-command-mode',
+            'ctrl-m'              : 'ipython.go-to-command-mode',
+            'up'                  : 'ipython.move-cursor-up-or-previous-cell',
+            'down'                : 'ipython.move-cursor-down-or-next-cell',
+            'ctrl-shift--'        : 'ipython.split-cell-at-cursor',
+            'ctrl-shift-subtract' : 'ipython.split-cell-at-cursor'
         };
     };
 
     KeyboardManager.prototype.get_default_command_shortcuts = function() {
-        var that = this;
         return {
-            'space': {
-                help: "Scroll down",
-                handler: function(event) {
-                    return that.notebook.scroll_manager.scroll(1);
-                },
-            },
-            'shift-space': {
-                help: "Scroll up",
-                handler: function(event) {
-                    return that.notebook.scroll_manager.scroll(-1);
-                },
-            },
-            'enter' : {
-                help    : 'edit mode',
-                help_index : 'aa',
-                handler : function (event) {
-                    that.notebook.edit_mode();
-                    return false;
-                }
-            },
-            'up' : {
-                help    : 'select previous cell',
-                help_index : 'da',
-                handler : function (event) {
-                    var index = that.notebook.get_selected_index();
-                    if (index !== 0 && index !== null) {
-                        that.notebook.select_prev();
-                        that.notebook.focus_cell();
-                    }
-                    return false;
-                }
-            },
-            'down' : {
-                help    : 'select next cell',
-                help_index : 'db',
-                handler : function (event) {
-                    var index = that.notebook.get_selected_index();
-                    if (index !== (that.notebook.ncells()-1) && index !== null) {
-                        that.notebook.select_next();
-                        that.notebook.focus_cell();
-                    }
-                    return false;
-                }
-            },
-            'k' : {
-                help    : 'select previous cell',
-                help_index : 'dc',
-                handler : function (event) {
-                    var index = that.notebook.get_selected_index();
-                    if (index !== 0 && index !== null) {
-                        that.notebook.select_prev();
-                        that.notebook.focus_cell();
-                    }
-                    return false;
-                }
-            },
-            'j' : {
-                help    : 'select next cell',
-                help_index : 'dd',
-                handler : function (event) {
-                    var index = that.notebook.get_selected_index();
-                    if (index !== (that.notebook.ncells()-1) && index !== null) {
-                        that.notebook.select_next();
-                        that.notebook.focus_cell();
-                    }
-                    return false;
-                }
-            },
-            'x' : {
-                help    : 'cut cell',
-                help_index : 'ee',
-                handler : function (event) {
-                    that.notebook.cut_cell();
-                    return false;
-                }
-            },
-            'c' : {
-                help    : 'copy cell',
-                help_index : 'ef',
-                handler : function (event) {
-                    that.notebook.copy_cell();
-                    return false;
-                }
-            },
-            'shift-v' : {
-                help    : 'paste cell above',
-                help_index : 'eg',
-                handler : function (event) {
-                    that.notebook.paste_cell_above();
-                    return false;
-                }
-            },
-            'v' : {
-                help    : 'paste cell below',
-                help_index : 'eh',
-                handler : function (event) {
-                    that.notebook.paste_cell_below();
-                    return false;
-                }
-            },
-            'd' : {
-                help    : 'delete cell (press twice)',
-                help_index : 'ej',
-                count: 2,
-                handler : function (event) {
-                    that.notebook.delete_cell();
-                    return false;
-                }
-            },
-            'a' : {
-                help    : 'insert cell above',
-                help_index : 'ec',
-                handler : function (event) {
-                    that.notebook.insert_cell_above();
-                    that.notebook.select_prev();
-                    that.notebook.focus_cell();
-                    return false;
-                }
-            },
-            'b' : {
-                help    : 'insert cell below',
-                help_index : 'ed',
-                handler : function (event) {
-                    that.notebook.insert_cell_below();
-                    that.notebook.select_next();
-                    that.notebook.focus_cell();
-                    return false;
-                }
-            },
-            'y' : {
-                help    : 'to code',
-                help_index : 'ca',
-                handler : function (event) {
-                    that.notebook.to_code();
-                    return false;
-                }
-            },
-            'm' : {
-                help    : 'to markdown',
-                help_index : 'cb',
-                handler : function (event) {
-                    that.notebook.to_markdown();
-                    return false;
-                }
-            },
-            'r' : {
-                help    : 'to raw',
-                help_index : 'cc',
-                handler : function (event) {
-                    that.notebook.to_raw();
-                    return false;
-                }
-            },
-            '1' : {
-                help    : 'to heading 1',
-                help_index : 'cd',
-                handler : function (event) {
-                    that.notebook.to_heading(undefined, 1);
-                    return false;
-                }
-            },
-            '2' : {
-                help    : 'to heading 2',
-                help_index : 'ce',
-                handler : function (event) {
-                    that.notebook.to_heading(undefined, 2);
-                    return false;
-                }
-            },
-            '3' : {
-                help    : 'to heading 3',
-                help_index : 'cf',
-                handler : function (event) {
-                    that.notebook.to_heading(undefined, 3);
-                    return false;
-                }
-            },
-            '4' : {
-                help    : 'to heading 4',
-                help_index : 'cg',
-                handler : function (event) {
-                    that.notebook.to_heading(undefined, 4);
-                    return false;
-                }
-            },
-            '5' : {
-                help    : 'to heading 5',
-                help_index : 'ch',
-                handler : function (event) {
-                    that.notebook.to_heading(undefined, 5);
-                    return false;
-                }
-            },
-            '6' : {
-                help    : 'to heading 6',
-                help_index : 'ci',
-                handler : function (event) {
-                    that.notebook.to_heading(undefined, 6);
-                    return false;
-                }
-            },
-            'o' : {
-                help    : 'toggle output',
-                help_index : 'gb',
-                handler : function (event) {
-                    that.notebook.toggle_output();
-                    return false;
-                }
-            },
-            'shift-o' : {
-                help    : 'toggle output scrolling',
-                help_index : 'gc',
-                handler : function (event) {
-                    that.notebook.toggle_output_scroll();
-                    return false;
-                }
-            },
-            's' : {
-                help    : 'save notebook',
-                help_index : 'fa',
-                handler : function (event) {
-                    that.notebook.save_checkpoint();
-                    return false;
-                }
-            },
-            'ctrl-j' : {
-                help    : 'move cell down',
-                help_index : 'eb',
-                handler : function (event) {
-                    that.notebook.move_cell_down();
-                    return false;
-                }
-            },
-            'ctrl-k' : {
-                help    : 'move cell up',
-                help_index : 'ea',
-                handler : function (event) {
-                    that.notebook.move_cell_up();
-                    return false;
-                }
-            },
-            'l' : {
-                help    : 'toggle line numbers',
-                help_index : 'ga',
-                handler : function (event) {
-                    that.notebook.cell_toggle_line_numbers();
-                    return false;
-                }
-            },
-            'i' : {
-                help    : 'interrupt kernel (press twice)',
-                help_index : 'ha',
-                count: 2,
-                handler : function (event) {
-                    that.notebook.kernel.interrupt();
-                    return false;
-                }
-            },
-            '0' : {
-                help    : 'restart kernel (press twice)',
-                help_index : 'hb',
-                count: 2,
-                handler : function (event) {
-                    that.notebook.restart_kernel();
-                    return false;
-                }
-            },
-            'h' : {
-                help    : 'keyboard shortcuts',
-                help_index : 'ge',
-                handler : function (event) {
-                    that.quick_help.show_keyboard_shortcuts();
-                    return false;
-                }
-            },
-            'z' : {
-                help    : 'undo last delete',
-                help_index : 'ei',
-                handler : function (event) {
-                    that.notebook.undelete_cell();
-                    return false;
-                }
-            },
-            'shift-m' : {
-                help    : 'merge cell below',
-                help_index : 'ek',
-                handler : function (event) {
-                    that.notebook.merge_cell_below();
-                    return false;
-                }
-            },
-            'q' : {
-                help    : 'close pager',
-                help_index : 'gd',
-                handler : function (event) {
-                    that.pager.collapse();
-                    return false;
-                }
+            'shift-space': 'ipython.scroll-up',
+            'shift-v' : 'ipython.paste-cell-before',
+            'shift-m' : 'ipython.merge-selected-cell-with-cell-after',
+            'shift-o' : 'ipython.toggle-output-scrolling-selected-cell',
+            'ctrl-j' : 'ipython.move-selected-cell-down',
+            'ctrl-k' : 'ipython.move-selected-cell-up',
+            'enter' : 'ipython.enter-edit-mode',
+            'space' : 'ipython.scroll-down',
+            'down' : 'ipython.select-next-cell',
+            'i,i' : 'ipython.interrupt-kernel',
+            '0,0' : 'ipython.restart-kernel',
+            'd,d' : 'ipython.delete-cell',
+            'up' : 'ipython.select-previous-cell',
+            'k' : 'ipython.select-previous-cell',
+            'j' : 'ipython.select-next-cell',
+            'x' : 'ipython.cut-selected-cell',
+            'c' : 'ipython.copy-selected-cell',
+            'v' : 'ipython.paste-cell-after',
+            'a' : 'ipython.insert-cell-before',
+            'b' : 'ipython.insert-cell-after',
+            'y' : 'ipython.change-selected-cell-to-code-cell',
+            'm' : 'ipython.change-selected-cell-to-markdown-cell',
+            'r' : 'ipython.change-selected-cell-to-raw-cell',
+            '1' : 'ipython.change-selected-cell-to-heading-1',
+            '2' : 'ipython.change-selected-cell-to-heading-2',
+            '3' : 'ipython.change-selected-cell-to-heading-3',
+            '4' : 'ipython.change-selected-cell-to-heading-4',
+            '5' : 'ipython.change-selected-cell-to-heading-5',
+            '6' : 'ipython.change-selected-cell-to-heading-6',
+            'o' : 'ipython.toggle-output-visibility-selected-cell',
+            's' : 'ipython.save-notebook',
+            'l' : 'ipython.toggle-line-number-selected-cell',
+            'h' : 'ipython.show-keyboard-shortcut-help-dialog',
+            'z' : 'ipython.undo-last-cell-deletion',
+            'q' : 'ipython.close-pager',
+            'i,e,e,e,e,e'   : function(){console.log('[[===>>> 5E <<<===]]');},
+            'i,d,d,q,d'   : function(){console.log('[[===>>> Trigger god mode <<<===]]');},
+            'i,d,d'   : function(){console.log('[[===>>>  should warn at registration <<<===]]');},
+            'i,d,k'   : function(){console.log('[[===>>> Trigger shadow mode <<<===]]');},
+            'i,d,k,r,q'   : function(){console.log('[[===>>> Trigger invisibility mode <<<===]]');},
+            ';,up,down,up,down,left,right,left,right,b,a'   : function(){console.log('[[===>>> Konami <<<===]]');},
+            'ctrl-x,meta-c,meta-b,u,t,t,e,r,f,l,y'   : function(){
+                console.log('[[Are you a real Programmer ?]]');
+                window.open('http://xkcd.com/378/','_blank');
             },
         };
     };
 
     KeyboardManager.prototype.bind_events = function () {
         var that = this;
         $(document).keydown(function (event) {
-
-            if(event._ipkmIgnore==true||(event.originalEvent||{})._ipkmIgnore==true){
+            if(event._ipkmIgnore===true||(event.originalEvent||{})._ipkmIgnore===true){
                 return false;
             }
             return that.handle_keydown(event);
         });
     };
 
+    KeyboardManager.prototype.set_notebook = function (notebook) {
+        this.notebook = notebook;
+        this.actions.extend_env({notebook:notebook});
+    };
+    
+    KeyboardManager.prototype.set_quickhelp = function (notebook) {
+        this.actions.extend_env({quick_help:notebook});
+    };
+
+
     KeyboardManager.prototype.handle_keydown = function (event) {
-        var notebook = this.notebook;
+        /**
+         *  returning false from this will stop event propagation
+         **/
 
         if (event.which === keycodes.esc) {
             // Intercept escape at highest level to avoid closing
             // websocket connection with firefox
             event.preventDefault();
         }
         
         if (!this.enabled) {
             if (event.which === keycodes.esc) {
-                // ESC
-                notebook.command_mode();
+                this.notebook.command_mode();
                 return false;
             }
             return true;
         }
         
         if (this.mode === 'edit') {
             return this.edit_shortcuts.call_handler(event);
         } else if (this.mode === 'command') {
             return this.command_shortcuts.call_handler(event);
         }
         return true;
     };
 
     KeyboardManager.prototype.edit_mode = function () {
         this.last_mode = this.mode;
         this.mode = 'edit';
     };
 
     KeyboardManager.prototype.command_mode = function () {
         this.last_mode = this.mode;
         this.mode = 'command';
     };
 
     KeyboardManager.prototype.enable = function () {
         this.enabled = true;
     };
 
     KeyboardManager.prototype.disable = function () {
         this.enabled = false;
     };
 
     KeyboardManager.prototype.register_events = function (e) {
         var that = this;
         var handle_focus = function () {
             that.disable();
         };
         var handle_blur = function () {
             that.enable();
         };
         e.on('focusin', handle_focus);
         e.on('focusout', handle_blur);
         // TODO: Very strange. The focusout event does not seem fire for the 
         // bootstrap textboxes on FF25&26...  This works around that by 
         // registering focus and blur events recursively on all inputs within
         // registered element.
         e.find('input').blur(handle_blur);
         e.on('DOMNodeInserted', function (event) {
             var target = $(event.target);
             if (target.is('input')) {
                 target.blur(handle_blur);
             } else {
                 target.find('input').blur(handle_blur);    
             }
           });
         // There are times (raw_input) where we remove the element from the DOM before
         // focusout is called. In this case we bind to the remove event of jQueryUI,
         // which gets triggered upon removal, iff it is focused at the time.
         // is_focused must be used to check for the case where an element within
         // the element being removed is focused.
         e.on('remove', function () {
             if (utils.is_focused(e[0])) {
                 that.enable();
             }
         });
     };
 
-    // For backwards compatability.
+
+    // For backwards compatibility.
     IPython.KeyboardManager = KeyboardManager;
 
     return {'KeyboardManager': KeyboardManager};
 });

IPython/html/static/notebook/js/main.js

@@ -1,146 +1,153 b''
 // Copyright (c) IPython Development Team.
 // Distributed under the terms of the Modified BSD License.
 
 require([
     'base/js/namespace',
     'jquery',
     'notebook/js/notebook',
     'base/js/utils',
     'base/js/page',
     'notebook/js/layoutmanager',
     'base/js/events',
     'auth/js/loginwidget',
     'notebook/js/maintoolbar',
     'notebook/js/pager',
     'notebook/js/quickhelp',
     'notebook/js/menubar',
     'notebook/js/notificationarea',
     'notebook/js/savewidget',
+    'notebook/js/actions',
     'notebook/js/keyboardmanager',
     'notebook/js/config',
     'notebook/js/kernelselector',
     'codemirror/lib/codemirror',
     // only loaded, not used, please keep sure this is loaded last
     'custom/custom'
 ], function(
     IPython, 
     $,
     notebook, 
     utils, 
     page, 
     layoutmanager, 
     events,
     loginwidget, 
     maintoolbar, 
     pager, 
     quickhelp, 
     menubar, 
     notificationarea, 
-    savewidget, 
+    savewidget,
+    actions,
     keyboardmanager,
     config,
     kernelselector,
     CodeMirror,
     // please keep sure that even if not used, this is loaded last
     custom
     ) {
     "use strict";
 
     // compat with old IPython, remove for IPython > 3.0
     window.CodeMirror = CodeMirror;
 
     var common_options = {
         ws_url : utils.get_body_data("wsUrl"),
         base_url : utils.get_body_data("baseUrl"),
         notebook_path : utils.get_body_data("notebookPath"),
         notebook_name : utils.get_body_data('notebookName')
     };
 
     var user_config = $.extend({}, config.default_config);
     var page = new page.Page();
     var layout_manager = new layoutmanager.LayoutManager();
     var pager = new pager.Pager('div#pager', 'div#pager_splitter', {
         layout_manager: layout_manager, 
         events: events});
+    var acts = new actions.init();
     var keyboard_manager = new keyboardmanager.KeyboardManager({
         pager: pager, 
-        events: events});
+        events: events, 
+        actions: acts });
     var save_widget = new savewidget.SaveWidget('span#save_widget', {
         events: events, 
         keyboard_manager: keyboard_manager});
     var notebook = new notebook.Notebook('div#notebook', $.extend({
         events: events,
         keyboard_manager: keyboard_manager,
         save_widget: save_widget,
         config: user_config},
         common_options));
     var login_widget = new loginwidget.LoginWidget('span#login_widget', common_options);
     var toolbar = new maintoolbar.MainToolBar('#maintoolbar-container', {
         notebook: notebook, 
-        events: events}); 
+        events: events, 
+        actions: acts}); 
     var quick_help = new quickhelp.QuickHelp({
         keyboard_manager: keyboard_manager, 
         events: events,
         notebook: notebook});
+    keyboard_manager.set_notebook(notebook);
+    keyboard_manager.set_quickhelp(quick_help);
     var menubar = new menubar.MenuBar('#menubar', $.extend({
         notebook: notebook, 
         layout_manager: layout_manager, 
         events: events, 
         save_widget: save_widget, 
         quick_help: quick_help}, 
         common_options));
     var notification_area = new notificationarea.NotificationArea(
         '#notification_area', {
         events: events, 
         save_widget: save_widget, 
         notebook: notebook,
         keyboard_manager: keyboard_manager});
     notification_area.init_notification_widgets();
     var kernel_selector = new kernelselector.KernelSelector(
         '#kernel_selector_widget', notebook);
 
     $('body').append('<div id="fonttest"><pre><span id="test1">x</span>'+
                      '<span id="test2" style="font-weight: bold;">x</span>'+
                      '<span id="test3" style="font-style: italic;">x</span></pre></div>');
     var nh = $('#test1').innerHeight();
     var bh = $('#test2').innerHeight();
     var ih = $('#test3').innerHeight();
     if(nh != bh || nh != ih) {
         $('head').append('<style>.CodeMirror span { vertical-align: bottom; }</style>');
     }
     $('#fonttest').remove();
 
     page.show();
 
     layout_manager.do_resize();
     var first_load = function () {
         layout_manager.do_resize();
         var hash = document.location.hash;
         if (hash) {
             document.location.hash = '';
             document.location.hash = hash;
         }
         notebook.set_autosave_interval(notebook.minimum_autosave_interval);
         // only do this once
         events.off('notebook_loaded.Notebook', first_load);
     };
     events.on('notebook_loaded.Notebook', first_load);
     
     IPython.page = page;
     IPython.layout_manager = layout_manager;
     IPython.notebook = notebook;
     IPython.pager = pager;
     IPython.quick_help = quick_help;
     IPython.login_widget = login_widget;
     IPython.menubar = menubar;
     IPython.toolbar = toolbar;
     IPython.notification_area = notification_area;
     IPython.keyboard_manager = keyboard_manager;
     IPython.save_widget = save_widget;
     IPython.config = user_config;
     IPython.tooltip = notebook.tooltip;
 
     events.trigger('app_initialized.NotebookApp');
     notebook.load_notebook(common_options.notebook_name, common_options.notebook_path);
 
 });

IPython/html/static/notebook/js/quickhelp.js

@@ -1,184 +1,187 b''
 // Copyright (c) IPython Development Team.
 // Distributed under the terms of the Modified BSD License.
 
 define([
     'base/js/namespace',
     'jquery',
     'base/js/utils',
     'base/js/dialog',
 ], function(IPython, $, utils, dialog) {
     "use strict";
     var platform = utils.platform;
 
     var QuickHelp = function (options) {
         // Constructor
         //
         // Parameters:
         //  options: dictionary
         //      Dictionary of keyword arguments.
         //          events: $(Events) instance
         //          keyboard_manager: KeyboardManager instance
         //          notebook: Notebook instance
         this.keyboard_manager = options.keyboard_manager;
         this.notebook = options.notebook;
         this.keyboard_manager.quick_help = this;
         this.events = options.events;
     };
 
     var cmd_ctrl = 'Ctrl-';
     var platform_specific;
 
     if (platform === 'MacOS') {
         // Mac OS X specific
         cmd_ctrl = 'Cmd-';
         platform_specific = [
             { shortcut: "Cmd-Up",     help:"go to cell start"  },
             { shortcut: "Cmd-Down",   help:"go to cell end"  },
-            { shortcut: "Opt-Left",   help:"go one word left"  },
-            { shortcut: "Opt-Right",  help:"go one word right"  },
-            { shortcut: "Opt-Backspace",      help:"del word before"  },
-            { shortcut: "Opt-Delete",         help:"del word after"  },
+            { shortcut: "Alt-Left",   help:"go one word left"  },
+            { shortcut: "Alt-Right",  help:"go one word right"  },
+            { shortcut: "Alt-Backspace",      help:"del word before"  },
+            { shortcut: "Alt-Delete",         help:"del word after"  },
         ];
     } else {
         // PC specific
         platform_specific = [
             { shortcut: "Ctrl-Home",  help:"go to cell start"  },
             { shortcut: "Ctrl-Up",     help:"go to cell start"  },
             { shortcut: "Ctrl-End",   help:"go to cell end"  },
             { shortcut: "Ctrl-Down",  help:"go to cell end"  },
             { shortcut: "Ctrl-Left",  help:"go one word left"  },
             { shortcut: "Ctrl-Right", help:"go one word right"  },
             { shortcut: "Ctrl-Backspace", help:"del word before"  },
             { shortcut: "Ctrl-Delete",    help:"del word after"  },
         ];
     }
 
     var cm_shortcuts = [
         { shortcut:"Tab",   help:"code completion or indent" },
         { shortcut:"Shift-Tab",   help:"tooltip" },
         { shortcut: cmd_ctrl + "]",   help:"indent"  },
         { shortcut: cmd_ctrl + "[",   help:"dedent"  },
         { shortcut: cmd_ctrl + "a",   help:"select all"  },
         { shortcut: cmd_ctrl + "z",   help:"undo"  },
         { shortcut: cmd_ctrl + "Shift-z",   help:"redo"  },
         { shortcut: cmd_ctrl + "y",   help:"redo"  },
     ].concat( platform_specific );
 
 
-
-      
-
-
     QuickHelp.prototype.show_keyboard_shortcuts = function () {
         // toggles display of keyboard shortcut dialog
         var that = this;
         if ( this.force_rebuild ) {
             this.shortcut_dialog.remove();
             delete(this.shortcut_dialog);
             this.force_rebuild = false;
         }
         if ( this.shortcut_dialog ){
             // if dialog is already shown, close it
             $(this.shortcut_dialog).modal("toggle");
             return;
         }
         var command_shortcuts = this.keyboard_manager.command_shortcuts.help();
         var edit_shortcuts = this.keyboard_manager.edit_shortcuts.help();
         var help, shortcut;
         var i, half, n;
         var element = $('<div/>');
 
         // The documentation
         var doc = $('<div/>').addClass('alert alert-warning');
         doc.append(
             $('<button/>').addClass('close').attr('data-dismiss','alert').html('&times;')
         ).append(
             'The IPython Notebook has two different keyboard input modes. <b>Edit mode</b> '+
             'allows you to type code/text into a cell and is indicated by a green cell '+
             'border. <b>Command mode</b> binds the keyboard to notebook level actions '+
             'and is indicated by a grey cell border.'
         );
         element.append(doc);
 
         // Command mode
         var cmd_div = this.build_command_help();
         element.append(cmd_div);
 
         // Edit mode
         var edit_div = this.build_edit_help(cm_shortcuts);
         element.append(edit_div);
 
         this.shortcut_dialog = dialog.modal({
             title : "Keyboard shortcuts",
             body : element,
             destroy : false,
             buttons : {
                 Close : {}
             },
             notebook: this.notebook,
             keyboard_manager: this.keyboard_manager,
         });
         this.shortcut_dialog.addClass("modal_stretch");
         
         this.events.on('rebuild.QuickHelp', function() { that.force_rebuild = true;});
     };
 
     QuickHelp.prototype.build_command_help = function () {
         var command_shortcuts = this.keyboard_manager.command_shortcuts.help();
         return build_div('<h4>Command Mode (press <code>Esc</code> to enable)</h4>', command_shortcuts);
     };
 
     var special_case = { pageup: "PageUp", pagedown: "Page Down", 'minus': '-' };
     var prettify = function (s) {
         s = s.replace(/-$/, 'minus'); // catch shortcuts using '-' key
         var keys = s.split('-');
         var k, i;
         for (i=0; i < keys.length; i++) {
             k = keys[i];
             if ( k.length == 1 ) {
                 keys[i] = "<code><strong>" + k + "</strong></code>";
                 continue; // leave individual keys lower-cased
             }
-            keys[i] = ( special_case[k] ? special_case[k] : k.charAt(0).toUpperCase() + k.slice(1) );
+            if (k.indexOf(',') === -1){
+                keys[i] = ( special_case[k] ? special_case[k] : k.charAt(0).toUpperCase() + k.slice(1) );
+            }
             keys[i] = "<code><strong>" + keys[i] + "</strong></code>";
         }
         return keys.join('-');
 
 
     };
 
     QuickHelp.prototype.build_edit_help = function (cm_shortcuts) {
         var edit_shortcuts = this.keyboard_manager.edit_shortcuts.help();
         jQuery.merge(cm_shortcuts, edit_shortcuts);
         return build_div('<h4>Edit Mode (press <code>Enter</code> to enable)</h4>', cm_shortcuts);
     };
 
     var build_one = function (s) {
         var help = s.help;
-        var shortcut = prettify(s.shortcut);
+        var shortcut = '';
+        if(s.shortcut){
+            shortcut = prettify(s.shortcut);
+        } else {
+            console.error('[debug] -  nothing for', s)
+        }
         return $('<div>').addClass('quickhelp').
             append($('<span/>').addClass('shortcut_key').append($(shortcut))).
             append($('<span/>').addClass('shortcut_descr').text(' : ' + help));
 
     };
 
     var build_div = function (title, shortcuts) {
         var i, half, n;
         var div = $('<div/>').append($(title));
         var sub_div = $('<div/>').addClass('hbox');
         var col1 = $('<div/>').addClass('box-flex1');
         var col2 = $('<div/>').addClass('box-flex1');
         n = shortcuts.length;
         half = ~~(n/2);  // Truncate :)
         for (i=0; i<half; i++) { col1.append( build_one(shortcuts[i]) ); }
         for (i=half; i<n; i++) { col2.append( build_one(shortcuts[i]) ); }
         sub_div.append(col1).append(col2);
         div.append(sub_div);
         return div;
     };
 
     // Backwards compatability.
     IPython.QuickHelp = QuickHelp;
 
     return {'QuickHelp': QuickHelp};
 });

IPython/html/static/notebook/js/toolbar.js

@@ -1,100 +1,100 b''
 // Copyright (c) IPython Development Team.
 // Distributed under the terms of the Modified BSD License.
 
 define([
     'base/js/namespace',
     'jquery',
 ], function(IPython, $) {
     "use strict";
 
     /**
      * A generic toolbar on which one can add button
      * @class ToolBar
      * @constructor
-     * @param {Dom_object} selector
+     * @param {Dom object} selector
      */
     var ToolBar = function (selector, layout_manager) {
         this.selector = selector;
         this.layout_manager = layout_manager;
         if (this.selector !== undefined) {
             this.element = $(selector);
             this.style();
         }
     };
 
     /**
      *  add a group of button into the current toolbar.
      *
      *
      *  @example
      *
      *      IPython.toolbar.add_buttons_group([
      *          {
      *            label:'my button',
      *            icon:'icon-hdd',
      *            callback:function(){alert('hoho')},
      *            id : 'my_button_id',    // this is optional
      *          },
      *          {
      *            label:'my second button',
      *            icon:'icon-play',
      *            callback:function(){alert('be carefull I cut')}
      *          }
      *        ],
      *        "my_button_group_id"
      *      )
      *
      *  @method add_buttons_group
      *  @param list {List}
      *      List of button of the group, with the following paramter for each :
      *      @param list.label {string} text to show on button hover
      *      @param list.icon {string} icon to choose from [Font Awesome](http://fortawesome.github.io/Font-Awesome)
      *      @param list.callback {function} function to be called on button click
      *      @param [list.id] {String} id to give to the button
      *  @param [group_id] {String} optionnal id to give to the group
      *
      */
     ToolBar.prototype.add_buttons_group = function (list, group_id) {
         var btn_group = $('<div/>').addClass("btn-group");
         if( group_id !== undefined ) {
             btn_group.attr('id',group_id);
         }
         var el;
         for(var i=0; i < list.length; i++) {
             el = list[i];
             var button  = $('<button/>')
                 .addClass('btn btn-default')
                 .attr("title", el.label)
                 .append(
                     $("<i/>").addClass(el.icon).addClass('fa')
                 );
             var id = el.id;
             if( id !== undefined )
                 button.attr('id',id);
             var fun = el.callback;
             button.click(fun);
             btn_group.append(button);
         }
         $(this.selector).append(btn_group);
     };
 
     ToolBar.prototype.style = function () {
         this.element.addClass('toolbar');
     };
 
     /**
      * Show and hide toolbar
      * @method toggle
      */
     ToolBar.prototype.toggle = function () {
         this.element.toggle();
         if (this.layout_manager !== undefined) {
             this.layout_manager.do_resize();
         }
     };
 
     // Backwards compatibility.
     IPython.ToolBar = ToolBar;
 
     return {'ToolBar': ToolBar};
 });