Removing KBN null mode and replacing with enable/disable.

IPython/html/static/base/js/dialog.js

@@ -1,146 +1,147 b''
 //----------------------------------------------------------------------------
 //  Copyright (C) 2013  The IPython Development Team
 //
 //  Distributed under the terms of the BSD License.  The full license is in
 //  the file COPYING, distributed as part of this software.
 //----------------------------------------------------------------------------
 
 //============================================================================
 // Utility for modal dialogs with bootstrap
 //============================================================================
 
 IPython.namespace('IPython.dialog');
 
 IPython.dialog = (function (IPython) {
     "use strict";
     
     var modal = function (options) {
         var dialog = $("<div/>").addClass("modal").attr("role", "dialog");
         dialog.append(
             $("<div/>")
                 .addClass("modal-header")
                 .append($("<button>")
                     .addClass("close")
                     .attr("data-dismiss", "modal")
                     .html("&times;")
                 ).append(
                     $("<h3/>").text(options.title || "")
                 )
         ).append(
             $("<div/>").addClass("modal-body").append(
                 options.body || $("<p/>")
             )
         );
         
         var footer = $("<div/>").addClass("modal-footer");
         
         for (var label in options.buttons) {
             var btn_opts = options.buttons[label];
             var button = $("<button/>")
                 .addClass("btn")
                 .attr("data-dismiss", "modal")
                 .text(label);
             if (btn_opts.click) {
                 button.click($.proxy(btn_opts.click, dialog));
             }
             if (btn_opts.class) {
                 button.addClass(btn_opts.class);
             }
             footer.append(button);
         }
         dialog.append(footer);
         // hook up on-open event
         dialog.on("shown", function() {
             setTimeout(function() {
                 footer.find("button").last().focus();
                 if (options.open) {
                     $.proxy(options.open, dialog)();
                 }
             }, 0);
         });
         
         // destroy dialog on hide, unless explicitly asked not to
         if (options.destroy === undefined || options.destroy) {
             dialog.on("hidden", function () {
                 dialog.remove();
             });
         }
         dialog.on("hidden", function () {
             if (IPython.notebook) {
                 var cell = IPython.notebook.get_selected_cell();
                 if (cell) cell.select();
+                IPython.keyboard_manager.enable();
                 IPython.keyboard_manager.command_mode();
             }
         });
         
         if (IPython.keyboard_manager) {
-            IPython.keyboard_manager.null_mode();
+            IPython.keyboard_manager.disable();
         }
         
         return dialog.modal(options);
     };
 
     var edit_metadata = function (md, callback, name) {
         name = name || "Cell";
         var error_div = $('<div/>').css('color', 'red');
         var message = 
             "Manually edit the JSON below to manipulate the metadata for this " + name + "." +
             " We recommend putting custom metadata attributes in an appropriately named sub-structure," +
             " so they don't conflict with those of others.";
 
         var textarea = $('<textarea/>')
             .attr('rows', '13')
             .attr('cols', '80')
             .attr('name', 'metadata')
             .text(JSON.stringify(md || {}, null, 2));
         
         var dialogform = $('<div/>').attr('title', 'Edit the metadata')
             .append(
                 $('<form/>').append(
                     $('<fieldset/>').append(
                         $('<label/>')
                         .attr('for','metadata')
                         .text(message)
                         )
                         .append(error_div)
                         .append($('<br/>'))
                         .append(textarea)
                     )
             );
         var editor = CodeMirror.fromTextArea(textarea[0], {
             lineNumbers: true,
             matchBrackets: true,
             indentUnit: 2,
             autoIndent: true,
             mode: 'application/json',
         });
         IPython.dialog.modal({
             title: "Edit " + name + " Metadata",
             body: dialogform,
             buttons: {
                 OK: { class : "btn-primary",
                     click: function() {
                         // validate json and set it
                         var new_md;
                         try {
                             new_md = JSON.parse(editor.getValue());
                         } catch(e) {
                             console.log(e);
                             error_div.text('WARNING: Could not save invalid JSON.');
                             return false;
                         }
                         callback(new_md);
                     }
                 },
                 Cancel: {}
             }
         });
         editor.refresh();
     };
     
     return {
         modal : modal,
         edit_metadata : edit_metadata,
     };
 
 }(IPython));

IPython/html/static/notebook/js/completer.js

@@ -1,357 +1,357 b''
 // function completer.
 //
 // completer should be a class that takes an cell instance
 var IPython = (function (IPython) {
     // that will prevent us from misspelling
     "use strict";
 
     // easier key mapping
     var key = IPython.utils.keycodes;
 
     function prepend_n_prc(str, n) {
         for( var i =0 ; i< n ; i++){
             str = '%'+str ;
         }
         return str;
     }
 
     function _existing_completion(item, completion_array){
         for( var c in completion_array ) {
             if(completion_array[c].trim().substr(-item.length) == item)
             { return true; }
         }
        return false;
     }
 
     // what is the common start of all completions
     function shared_start(B, drop_prct) {
         if (B.length == 1) {
             return B[0];
         }
         var A = new Array();
         var common;
         var min_lead_prct = 10;
         for (var i = 0; i < B.length; i++) {
             var str = B[i].str;
             var localmin = 0;
             if(drop_prct === true){
                 while ( str.substr(0, 1) == '%') {
                     localmin = localmin+1;
                     str = str.substring(1);
                 }
             }
             min_lead_prct = Math.min(min_lead_prct, localmin);
             A.push(str);
         }
 
         if (A.length > 1) {
             var tem1, tem2, s;
             A = A.slice(0).sort();
             tem1 = A[0];
             s = tem1.length;
             tem2 = A.pop();
             while (s && tem2.indexOf(tem1) == -1) {
                 tem1 = tem1.substring(0, --s);
             }
             if (tem1 === "" || tem2.indexOf(tem1) !== 0) {
                 return {
                     str:prepend_n_prc('', min_lead_prct),
                     type: "computed",
                     from: B[0].from,
                     to: B[0].to
                     };
             }
             return {
                 str: prepend_n_prc(tem1, min_lead_prct),
                 type: "computed",
                 from: B[0].from,
                 to: B[0].to
             };
         }
         return null;
     }
 
 
     var Completer = function (cell) {
         this.cell = cell;
         this.editor = cell.code_mirror;
         var that = this;
         $([IPython.events]).on('status_busy.Kernel', function () {
             that.skip_kernel_completion = true;
         });
         $([IPython.events]).on('status_idle.Kernel', function () {
             that.skip_kernel_completion = false;
         });
     };
 
 
     Completer.prototype.startCompletion = function () {
         // call for a 'first' completion, that will set the editor and do some
         // special behaviour like autopicking if only one completion availlable
         //
         if (this.editor.somethingSelected()) return;
         this.done = false;
         // use to get focus back on opera
         this.carry_on_completion(true);
     };
 
 
     // easy access for julia to monkeypatch
     //
     Completer.reinvoke_re = /[%0-9a-z._/\\:~-]/i;
 
     Completer.prototype.reinvoke= function(pre_cursor, block, cursor){
         return Completer.reinvoke_re.test(pre_cursor);
     }
 
     /**
      *
      * pass true as parameter if this is the first invocation of the completer
      * this will prevent the completer to dissmiss itself if it is not on a
      * word boundary like pressing tab after a space, and make it autopick the
      * only choice if there is only one which prevent from popping the UI.  as
      * well as fast-forwarding the typing if all completion have a common
      * shared start
      **/
     Completer.prototype.carry_on_completion = function (first_invocation) {
         // Pass true as parameter if you want the completer to autopick when
         // only one completion. This function is automatically reinvoked at
         // each keystroke with first_invocation = false
         var cur = this.editor.getCursor();
         var line = this.editor.getLine(cur.line);
         var pre_cursor = this.editor.getRange({
             line: cur.line,
             ch: cur.ch - 1
         }, cur);
 
         // we need to check that we are still on a word boundary
         // because while typing the completer is still reinvoking itself
         // so dismiss if we are on a "bad" caracter
         if (!this.reinvoke(pre_cursor) && !first_invocation) {
             this.close();
             return;
         }
 
         this.autopick = false;
         if (first_invocation) {
             this.autopick = true;
         }
 
         // We want a single cursor position.
         if (this.editor.somethingSelected()) {
             return;
         };
 
         // one kernel completion came back, finish_completing will be called with the results
         // we fork here and directly call finish completing if kernel is busy
         if (this.skip_kernel_completion == true) {
             this.finish_completing({
                 'matches': [],
                 matched_text: ""
             })
         } else {
             this.cell.kernel.complete(line, cur.ch, $.proxy(this.finish_completing, this));
         }
     };
 
     Completer.prototype.finish_completing = function (msg) {
         // let's build a function that wrap all that stuff into what is needed
         // for the new completer:
         var content = msg.content;
         var matched_text = content.matched_text;
         var matches = content.matches;
 
         var cur = this.editor.getCursor();
         var results = CodeMirror.contextHint(this.editor);
         var filterd_results = Array();
         //remove results from context completion
         //that are already in kernel completion
         for(var elm in results) {
             if(_existing_completion(results[elm]['str'], matches) == false)
             { filterd_results.push(results[elm]); }
         }
 
         // append the introspection result, in order, at at the beginning of
         // the table and compute the replacement range from current cursor
         // positon and matched_text length.
         for (var i = matches.length - 1; i >= 0; --i) {
             filterd_results.unshift({
                 str: matches[i],
                 type: "introspection",
                 from: {
                     line: cur.line,
                     ch: cur.ch - matched_text.length
                 },
                 to: {
                     line: cur.line,
                     ch: cur.ch
                 }
             });
         }
 
         // one the 2 sources results have been merge, deal with it
         this.raw_result = filterd_results;
 
         // if empty result return
         if (!this.raw_result || !this.raw_result.length) return;
 
         // When there is only one completion, use it directly.
         if (this.autopick == true && this.raw_result.length == 1) {
             this.insert(this.raw_result[0]);
             return;
         }
 
         if (this.raw_result.length == 1) {
             // test if first and only completion totally matches
             // what is typed, in this case dismiss
             var str = this.raw_result[0].str;
             var pre_cursor = this.editor.getRange({
                 line: cur.line,
                 ch: cur.ch - str.length
             }, cur);
             if (pre_cursor == str) {
                 this.close();
                 return;
             }
         }
 
         this.complete = $('<div/>').addClass('completions');
         this.complete.attr('id', 'complete');
 
         // Currently webkit doesn't use the size attr correctly. See:
         // https://code.google.com/p/chromium/issues/detail?id=4579
         this.sel = $('<select style="width: auto"/>')
             .attr('multiple', 'true')
             .attr('size', Math.min(10, this.raw_result.length));
         this.complete.append(this.sel);
         $('body').append(this.complete);
 
         // After everything is on the page, compute the postion.
         // We put it above the code if it is too close to the bottom of the page.
         var cur = this.editor.getCursor();
         cur.ch = cur.ch-matched_text.length;
         var pos = this.editor.cursorCoords(cur);
         var left = pos.left-3;
         var top;
         var cheight = this.complete.height();
         var wheight = $(window).height();
         if (pos.bottom+cheight+5 > wheight) {
             top = pos.top-cheight-4;
         } else {
             top = pos.bottom+1;
         }
         this.complete.css('left', left + 'px');
         this.complete.css('top', top + 'px');
 
 
         //build the container
         var that = this;
         this.sel.dblclick(function () {
             that.pick();
         });
         this.sel.blur(this.close);
         this.sel.keydown(function (event) {
             that.keydown(event);
         });
 
         this.build_gui_list(this.raw_result);
 
         this.sel.focus();
-        IPython.keyboard_manager.null_mode();
+        IPython.keyboard_manager.disable();
         // Opera sometimes ignores focusing a freshly created node
         if (window.opera) setTimeout(function () {
             if (!this.done) this.sel.focus();
         }, 100);
         return true;
     }
 
     Completer.prototype.insert = function (completion) {
         this.editor.replaceRange(completion.str, completion.from, completion.to);
     }
 
     Completer.prototype.build_gui_list = function (completions) {
         for (var i = 0; i < completions.length; ++i) {
             var opt = $('<option/>').text(completions[i].str).addClass(completions[i].type);
             this.sel.append(opt);
         }
         this.sel.children().first().attr('selected', 'true');
         this.sel.scrollTop(0);
     }
 
     Completer.prototype.close = function () {
         if (this.done) return;
         this.done = true;
         $('.completions').remove();
-        IPython.keyboard_manager.edit_mode();
+        IPython.keyboard_manager.enable();
     }
 
     Completer.prototype.pick = function () {
         this.insert(this.raw_result[this.sel[0].selectedIndex]);
         this.close();
         var that = this;
         setTimeout(function () {
             that.editor.focus();
         }, 50);
     }
 
 
     Completer.prototype.keydown = function (event) {
         var code = event.keyCode;
         var that = this;
         var special_key = false;
 
         // detect special keys like SHIFT,PGUP,...
         for( var _key in key ) {
             if (code == key[_key] ) {
                 special_key = true;
             }
         };
 
         // Enter
         if (code == key.ENTER) {
             CodeMirror.e_stop(event);
             this.pick();
         }
         // Escape or backspace
         else if (code == key.ESC) {
             CodeMirror.e_stop(event);
             this.close();
             this.editor.focus();
         } else if (code == key.SPACE || code == key.BACKSPACE) {
             this.close();
             this.editor.focus();
         } else if (code == key.TAB) {
             //all the fastforwarding operation,
             //Check that shared start is not null which can append with prefixed completion
             // like %pylab , pylab have no shred start, and ff will result in py<tab><tab>
             // to erase py
             var sh = shared_start(this.raw_result, true);
             if (sh) {
                 this.insert(sh);
             }
             this.close();
             CodeMirror.e_stop(event);
             this.editor.focus();
             //reinvoke self
             setTimeout(function () {
                 that.carry_on_completion();
             }, 50);
         } else if (code == key.UPARROW || code == key.DOWNARROW) {
             // need to do that to be able to move the arrow
             // when on the first or last line ofo a code cell
             event.stopPropagation();
         } else if (special_key != true) {
             this.close();
             this.editor.focus();
             //we give focus to the editor immediately and call sell in 50 ms
             setTimeout(function () {
                 that.carry_on_completion();
             }, 50);
         }
     }
 
 
     IPython.Completer = Completer;
 
     return IPython;
 }(IPython));

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

@@ -1,283 +1,265 b''
 //----------------------------------------------------------------------------
 //  Copyright (C) 2011  The IPython Development Team
 //
 //  Distributed under the terms of the BSD License.  The full license is in
 //  the file COPYING, distributed as part of this software.
 //----------------------------------------------------------------------------
 
 //============================================================================
 // Keyboard management
 //============================================================================
 
 var IPython = (function (IPython) {
     "use strict";
 
     var key   = IPython.utils.keycodes;
 
     var KeyboardManager = function () {
         this.mode = 'command';
-        this.last_mode = 'command';
+        this.enabled = true;
         this.bind_events();
     };
 
     KeyboardManager.prototype.bind_events = function () {
         var that = this;
         $(document).keydown(function (event) {
             return that.handle_keydown(event);
         });
     };
 
     KeyboardManager.prototype.handle_keydown = function (event) {
         var notebook = IPython.notebook;
         
         console.log('keyboard_manager', this.mode, event.keyCode);
         
         if (event.which === key.ESC) {
             // Intercept escape at highest level to avoid closing
             // websocket connection with firefox
             event.preventDefault();
         }
         
-        if (this.mode === 'null') {
-            return this.handle_null_mode(event);
+        if (!this.enabled) {
+            return true;
         }
         
         // Event handlers for both command and edit mode
         if ((event.ctrlKey || event.metaKey) && event.keyCode==83) {
             // Save (CTRL+S) or (Command+S on Mac)
             notebook.save_checkpoint();
             event.preventDefault();
             return false;
         } else if (event.which === key.ESC) {
             // Intercept escape at highest level to avoid closing
             // websocket connection with firefox
             event.preventDefault();
             // Don't return yet to allow edit/command modes to handle
         } else if (event.which === key.SHIFT) {
             // ignore shift keydown
             return true;
         } else if (event.which === key.ENTER && event.shiftKey) {
             notebook.execute_selected_cell('shift');
             return false;
         } else if (event.which === key.ENTER && event.altKey) {
             // Execute code cell, and insert new in place
             notebook.execute_selected_cell('alt');
             return false;
         } else if (event.which === key.ENTER && event.ctrlKey) {
             notebook.execute_selected_cell('ctrl');
             return false;
         }
         
         if (this.mode === 'edit') {
             return this.handle_edit_mode(event);
         } else if (this.mode === 'command' && !(event.ctrlKey || event.altKey || event.metaKey)) {
             return this.handle_command_mode(event);
         }
     }
 
-    KeyboardManager.prototype.handle_null_mode = function (event) {
-        return true;
-    }
-
-
     KeyboardManager.prototype.handle_edit_mode = function (event) {
         var notebook = IPython.notebook;
         
         if (event.which === key.ESC) {
             // ESC
             notebook.command_mode();
             return false;
         } else if (event.which === 77 && event.ctrlKey) {
             // Ctrl-m
             notebook.command_mode();
             return false;
         } else if (event.which === key.UPARROW && !event.shiftKey) {
             var cell = notebook.get_selected_cell();
             if (cell && cell.at_top()) {
                 event.preventDefault();
                 notebook.command_mode()
                 notebook.select_prev();
                 notebook.edit_mode();
                 return false;
             };
         } else if (event.which === key.DOWNARROW && !event.shiftKey) {
             var cell = notebook.get_selected_cell();
             if (cell && cell.at_bottom()) {
                 event.preventDefault();
                 notebook.command_mode()
                 notebook.select_next();
                 notebook.edit_mode();
                 return false;
             };
         };
         return true;
     }
 
     KeyboardManager.prototype.handle_command_mode = function (event) {
         var notebook = IPython.notebook;
         
         if (event.which === key.ENTER && !(event.ctrlKey || event.altKey || event.shiftKey)) {
             // Enter edit mode = ENTER alone
             notebook.edit_mode();
             return false;
         } else if (event.which === key.UPARROW && !event.shiftKey) {
             var index = notebook.get_selected_index();
             if (index !== 0 && index !== null) {
                 notebook.select_prev();
                 var cell = notebook.get_selected_cell();
                 cell.focus_cell();
             };
             return false;
         } else if (event.which === key.DOWNARROW && !event.shiftKey) {
             var index = notebook.get_selected_index();
             if (index !== (notebook.ncells()-1) && index !== null) {
                 notebook.select_next();
                 var cell = notebook.get_selected_cell();
                 cell.focus_cell();
             };
             return false;
         } else if (event.which === 88) {
             // Cut selected cell = x
             notebook.cut_cell();
             return false;
         } else if (event.which === 67) {
             // Copy selected cell = c
             notebook.copy_cell();
             return false;
         } else if (event.which === 86) {
             // Paste below selected cell = v
             notebook.paste_cell_below();
             return false;
         } else if (event.which === 68) {
             // Delete selected cell = d
             notebook.delete_cell();
             return false;
         } else if (event.which === 65) {
             // Insert code cell above selected = a
             notebook.insert_cell_above('code');
             notebook.select_prev();
             return false;
         } else if (event.which === 66) {
             // Insert code cell below selected = b
             notebook.insert_cell_below('code');
             notebook.select_next();
             return false;
         } else if (event.which === 89) {
             // To code = y
             notebook.to_code();
             return false;
         } else if (event.which === 77) {
             // To markdown = m
             notebook.to_markdown();
             return false;
         } else if (event.which === 84) {
             // To Raw = t
             notebook.to_raw();
             return false;
         } else if (event.which === 49) {
             // To Heading 1 = 1
             notebook.to_heading(undefined, 1);
             return false;
         } else if (event.which === 50) {
             // To Heading 2 = 2
             notebook.to_heading(undefined, 2);
             return false;
         } else if (event.which === 51) {
             // To Heading 3 = 3
             notebook.to_heading(undefined, 3);
             return false;
         } else if (event.which === 52) {
             // To Heading 4 = 4
             notebook.to_heading(undefined, 4);
             return false;
         } else if (event.which === 53) {
             // To Heading 5 = 5
             notebook.to_heading(undefined, 5);
             return false;
         } else if (event.which === 54) {
             // To Heading 6 = 6
             notebook.to_heading(undefined, 6);
             return false;
         } else if (event.which === 79) {
             // Toggle output = o
             if (event.shiftKey) {
                 notebook.toggle_output_scroll();
             } else {
                 notebook.toggle_output();
             };
             return false;
         } else if (event.which === 83) {
             // Save notebook = s
             notebook.save_checkpoint();
             return false;
         } else if (event.which === 74) {
             // Move cell down = j
             notebook.move_cell_down();
             return false;
         } else if (event.which === 75) {
             // Move cell up = k
             notebook.move_cell_up();
             return false;
         } else if (event.which === 80) {
             // Select previous = p
             notebook.select_prev();
             return false;
         } else if (event.which === 78) {
             // Select next = n
             notebook.select_next();
             return false;
         } else if (event.which === 76) {
             // Toggle line numbers = l
             notebook.cell_toggle_line_numbers();
             return false;
         } else if (event.which === 73) {
             // Interrupt kernel = i
             notebook.kernel.interrupt();
             return false;
         } else if (event.which === 190) {
             // Restart kernel = .  # matches qt console
             notebook.restart_kernel();
             return false;
         } else if (event.which === 72) {
             // Show keyboard shortcuts = h
             IPython.quick_help.show_keyboard_shortcuts();
             return false;
         } else if (event.which === 90) {
             // Undo last cell delete = z
             notebook.undelete();
             return false;
         };
         // If we havn't handled it, let someone else.
         return true;
     };
 
     KeyboardManager.prototype.edit_mode = function () {
         console.log('KeyboardManager', 'changing to edit mode');
         this.last_mode = this.mode;
         this.mode = 'edit';
     }
 
     KeyboardManager.prototype.command_mode = function () {
         console.log('KeyboardManager', 'changing to command mode');
         this.last_mode = this.mode;
         this.mode = 'command';
     }
 
-    KeyboardManager.prototype.null_mode = function () {
-        console.log('KeyboardManager', 'changing to null mode');
-        this.last_mode = this.mode;
-        this.mode = 'null';
-    }
-
-    KeyboardManager.prototype.last_mode = function () {
-        var lm = this.last_mode;
-        this.last_mode = this.mode;
-        this.mode = lm;
-    }
-
-
     IPython.KeyboardManager = KeyboardManager;
 
     return IPython;
 
 }(IPython));