modules/content-buffer-input.js

   1 /**
   2  * (C) Copyright 2007-2008 Jeremy Maitin-Shepard
   3  * (C) Copyright 2008 John J. Foerch
   4  *
   5  * Use, modification, and distribution are subject to the terms specified in the
   6  * COPYING file.
   7 **/
   8
   9 require("content-buffer.js");
  10
  11 define_current_buffer_hook("current_buffer_input_mode_change_hook", "input_mode_change_hook");
  12
  13 var content_buffer_input_mode_keymaps = {};
  14
  15 function define_input_mode(base_name, display_name, keymap_name, doc) {
  16     var name = base_name + "_input_mode";
  17     content_buffer_input_mode_keymaps[name] = keymap_name;
  18     define_buffer_mode(name,
  19                        display_name,
  20                        $class = "input_mode",
  21                        $enable = function (buffer) {
  22                            check_buffer(buffer, content_buffer);
  23                            content_buffer_update_keymap_for_input_mode(buffer); },
  24                        $disable = false,
  25                        $doc = doc);
  26 }
  27 ignore_function_for_get_caller_source_code_reference("define_input_mode");
  28
  29 function content_buffer_update_keymap_for_input_mode(buffer) {
  30     if (buffer.input_mode)
  31         buffer.keymap = buffer.get(content_buffer_input_mode_keymaps[buffer.input_mode]);
  32 }
  33
  34 add_hook("page_mode_change_hook", content_buffer_update_keymap_for_input_mode);
  35
  36 add_hook("content_buffer_location_change_hook", function (buf) { normal_input_mode(buf, true); });
  37
  38
  39 // Input mode for "normal" view mode
  40 define_input_mode("normal", null, "content_buffer_normal_keymap");
  41
  42 // Input modes for form elements
  43 define_input_mode("select", "input:SELECT", "content_buffer_select_keymap");
  44 define_input_mode("text", "input:TEXT", "content_buffer_text_keymap");
  45 define_input_mode("textarea", "input:TEXTAREA", "content_buffer_textarea_keymap");
  46 define_input_mode("richedit", "input:RICHEDIT", "content_buffer_richedit_keymap");
  47 define_input_mode("checkbox", "input:CHECKBOX/RADIOBUTTON", "content_buffer_checkbox_keymap");
  48
  49 // Input modes for sending key events to gecko
  50 define_input_mode(
  51     "quote_next", "input:PASS-THROUGH(next)", "content_buffer_quote_next_keymap",
  52     "This input mode sends the next key combo to the buffer, "+
  53         "bypassing Conkeror's normal key handling.  The mode disengages "+
  54         "after one key combo.");
  55 define_input_mode(
  56     "quote", "input:PASS-THROUGH", "content_buffer_quote_keymap",
  57     "This input mode sends all key combos to the buffer, "+
  58         "bypassing Conkeror's normal key handling, until the "+
  59         "Escape key is pressed.");
  60
  61 // Input mode for the visible caret
  62 define_input_mode("caret", null, "content_buffer_caret_keymap");
  63
  64
  65 function content_buffer_update_input_mode_for_focus(buffer, force) {
  66     var mode = buffer.input_mode;
  67     var form_input_mode_enabled = (mode == "text_input_mode" ||
  68                                    mode == "textarea_input_mode" ||
  69                                    mode == "select_input_mode" ||
  70                                    mode == "checkbox_input_mode" ||
  71                                    mode == "richedit_input_mode");
  72
  73     if (force || form_input_mode_enabled || mode == "normal_input_mode") {
  74         let elem = buffer.focused_element;
  75
  76         if (elem) {
  77             var input_mode_function = null;
  78             if (elem instanceof Ci.nsIDOMHTMLInputElement) {
  79                 var type = elem.getAttribute("type");
  80                 if (type != null) type = type.toLowerCase();
  81                 if (type == "checkbox" || type == "radio")
  82                     input_mode_function = checkbox_input_mode;
  83                 else if (type != "submit" &&
  84                          type != "reset")
  85                     input_mode_function = text_input_mode;
  86             }
  87             else if (elem instanceof Ci.nsIDOMHTMLTextAreaElement)
  88                 input_mode_function = textarea_input_mode;
  89
  90             else if (elem instanceof Ci.nsIDOMHTMLSelectElement)
  91                 input_mode_function = select_input_mode;
  92         }
  93
  94         if (!input_mode_function) {
  95
  96             let frame = buffer.focused_frame;
  97             let in_design_mode = false;
  98             if (frame && frame.document.designMode == "on")
  99                 in_design_mode = true;
 100             else {
 101                 outer:
 102                 while (elem) {
 103                     switch (elem.contentEditable) {
 104                     case "true":
 105                         in_design_mode = true;
 106                         break outer;
 107                     case "false":
 108                         break outer;
 109                     default: // == "inherit"
 110                         elem = elem.parentNode;
 111                     }
 112                 }
 113             }
 114             if (in_design_mode)
 115                 input_mode_function = richedit_input_mode;
 116         }
 117
 118         if (input_mode_function) {
 119             if (!force &&
 120                 browser_prevent_automatic_form_focus_mode_enabled &&
 121                 !form_input_mode_enabled &&
 122                 (buffer.last_user_input_received == null ||
 123                  (Date.now() - buffer.last_user_input_received)
 124                  > browser_automatic_form_focus_window_duration)) {
 125                 // Automatic focus attempt blocked
 126                 elem.blur();
 127             } else
 128                 input_mode_function(buffer, true);
 129             return;
 130         }
 131
 132         normal_input_mode(buffer, true);
 133     }
 134 }
 135
 136 add_hook("content_buffer_focus_change_hook",
 137          function (buf) {
 138              content_buffer_update_input_mode_for_focus(buf, false);
 139          });
 140
 141 define_buffer_mode('caret_mode', 'CARET',
 142                    $enable = function(buffer) {
 143                        buffer.browser.setAttribute('showcaret', 'true');
 144                        let sc = getFocusedSelCtrl(buffer);
 145                        sc.setCaretEnabled(true);
 146                        buffer.top_frame.focus();
 147                        caret_input_mode(buffer, true);
 148                    },
 149                    $disable = function(buffer) {
 150                        buffer.browser.setAttribute('showcaret', '');
 151                        let sc = getFocusedSelCtrl(buffer);
 152                        sc.setCaretEnabled(false);
 153                        buffer.browser.focus();
 154                        content_buffer_update_input_mode_for_focus(buffer, true);
 155                    });
 156
 157 //XXX: CARET_PREF is defined in find.js---why?
 158 watch_pref(CARET_PREF, function() {
 159                if (get_pref(CARET_PREF)) {
 160                    session_pref(CARET_PREF, false);
 161                    let window = window_watcher.activeWindow;
 162                    let buffer = window.buffers.current;
 163                    caret_mode(buffer);
 164                }
 165            });
 166
 167 interactive("content-buffer-update-input-mode-for-focus", null, function (I) {
 168     content_buffer_update_input_mode_for_focus(I.buffer, true);
 169 });
 170
 171 function minibuffer_input_mode_indicator(window) {
 172     this.window = window;
 173     this.hook_func = method_caller(this, this.update);
 174     add_hook.call(window, "select_buffer_hook", this.hook_func);
 175     add_hook.call(window, "current_buffer_input_mode_change_hook", this.hook_func);
 176     this.update();
 177 }
 178
 179 minibuffer_input_mode_indicator.prototype = {
 180     update : function () {
 181         var buf = this.window.buffers.current;
 182         var mode = buf.input_mode;
 183         if (mode)
 184             this.window.minibuffer.element.className = "minibuffer-" + buf.input_mode.replace("_","-","g");
 185     },
 186     uninstall : function () {
 187         remove_hook.call(window, "select_buffer_hook", this.hook_func);
 188         remove_hook.call(window, "current_buffer_input_mode_change_hook", this.hook_func);
 189     }
 190 };
 191
 192 define_global_window_mode("minibuffer_input_mode_indicator", "window_initialize_hook");
 193 minibuffer_input_mode_indicator_mode(true);
 194
 195 // Milliseconds
 196 define_variable("browser_automatic_form_focus_window_duration", 20,
 197                 "Time window (in milliseconds) during which a form element "+
 198                 "is allowed to gain focus following a mouse click or key "+
 199                 "press, if `browser_prevent_automatic_form_focus_mode' is "+
 200                 "enabled.");;
 201
 202 define_global_mode("browser_prevent_automatic_form_focus_mode",
 203                    function () {}, // enable
 204                    function () {} // disable
 205                   );
 206 browser_prevent_automatic_form_focus_mode(true);
 207
 208 define_variable(
 209     "browser_form_field_xpath_expression",
 210     "//input[" + (
 211         //        "translate(@type,'RADIO','radio')!='radio' and " +
 212         //        "translate(@type,'CHECKBOX','checkbox')!='checkbox' and " +
 213         "translate(@type,'HIDEN','hiden')!='hidden'"
 214         //        "translate(@type,'SUBMIT','submit')!='submit' and " +
 215         //        "translate(@type,'REST','rest')!='reset'"
 216     ) +  "] | " +
 217         "//xhtml:input[" + (
 218             //        "translate(@type,'RADIO','radio')!='radio' and " +
 219             //        "translate(@type,'CHECKBOX','checkbox')!='checkbox' and " +
 220             "translate(@type,'HIDEN','hiden')!='hidden'"
 221             //        "translate(@type,'SUBMIT','submit')!='submit' and " +
 222             //        "translate(@type,'REST','rest')!='reset'"
 223         ) +  "] |" +
 224         "//select | //xhtml:select | " +
 225         "//textarea | //xhtml:textarea | " +
 226         "//textbox | //xul:textbox",
 227     "XPath expression matching elements to be selected by `browser-focus-next-form-field' " +
 228         "and `browser-focus-previous-form-field.'");
 229
 230 function browser_focus_next_form_field(buffer, count, xpath_expr) {
 231     var focused_elem = buffer.focused_element;
 232     if (count == 0)
 233         return; // invalid count
 234
 235     function helper(win, skip_win) {
 236         if (win == skip_win)
 237             return null;
 238         var doc = win.document;
 239         var res = doc.evaluate(xpath_expr, doc, xpath_lookup_namespace,
 240             Ci.nsIDOMXPathResult.ORDERED_NODE_SNAPSHOT_TYPE,
 241             null /* existing results */);
 242         var length = res.snapshotLength;
 243         if (length > 0) {
 244             let valid_nodes = [];
 245             for (let i = 0; i < length; ++i) {
 246                 let elem = res.snapshotItem(i);
 247                 if (elem.clientWidth == 0 &&
 248                     elem.clientHeight == 0)
 249                     continue;
 250                 let style = win.getComputedStyle(elem, "");
 251                 if (style.display == "none" || style.visibility == "hidden")
 252                     continue;
 253                 valid_nodes.push(elem);
 254             }
 255
 256             if (valid_nodes.length > 0) {
 257                 var index = -1;
 258                 if (focused_elem != null)
 259                     index = valid_nodes.indexOf(focused_elem);
 260                 if (index == -1) {
 261                     if (count > 0)
 262                         index = count - 1;
 263                     else
 264                         index = -count;
 265                 }
 266                 else
 267                     index = index + count;
 268                 index = index % valid_nodes.length;
 269                 if (index < 0)
 270                     index += valid_nodes.length;
 271
 272                 return valid_nodes[index];
 273             }
 274         }
 275         // Recurse on sub-frames
 276         for (var i = 0; i < win.frames.length; ++i) {
 277             var elem = helper(win.frames[i], skip_win);
 278             if (elem)
 279                 return elem;
 280         }
 281         return null;
 282     }
 283
 284     var focused_win = buffer.focused_frame;
 285     var elem = helper(focused_win, null);
 286     if (!elem)
 287         elem = helper(buffer.top_frame, focused_win);
 288     if (elem) {
 289         browser_element_focus(buffer, elem);
 290     } else
 291         throw interactive_error("No form field found");
 292 }
 293
 294 interactive("browser-focus-next-form-field",
 295             "Focus the next element matching "+
 296             "`browser_form_field_xpath_expression'.",
 297             function (I) {
 298                 browser_focus_next_form_field(
 299                     I.buffer, I.p, browser_form_field_xpath_expression);
 300             });
 301
 302 interactive("browser-focus-previous-form-field",
 303             "Focus the previous element matching "+
 304             "`browser_form_field_xpath_expression'.",
 305             function (I) {
 306                 browser_focus_next_form_field(
 307                     I.buffer, -I.p, browser_form_field_xpath_expression);
 308             });
 309
 310 function edit_field_in_external_editor(buffer, elem) {
 311     if (elem instanceof Ci.nsIDOMHTMLInputElement) {
 312         var type = elem.getAttribute("type");
 313         if (type != null)
 314             type = type.toLowerCase();
 315         if (type == "hidden" || type == "checkbox" || type == "radio")
 316             throw interactive_error("Element is not a text field.");
 317     } else if (!(elem instanceof Ci.nsIDOMHTMLTextAreaElement))
 318         throw interactive_error("Element is not a text field.");
 319
 320     var name = elem.getAttribute("name");
 321     if (!name || name.length == 0)
 322         name = elem.getAttribute("id");
 323     if (!name)
 324         name = "";
 325     name = name.replace(/[^a-zA-Z0-9\-_]/g, "");
 326     if (name.length == 0)
 327         name = "text";
 328     name += ".txt";
 329     var file = get_temporary_file(name);
 330
 331     // Write to file
 332     try {
 333         write_text_file(file, elem.value);
 334     } catch (e) {
 335         file.remove(false);
 336         throw e;
 337     }
 338
 339     // FIXME: decide if we should do this
 340     var old_class = elem.className;
 341     elem.className = "__conkeror_textbox_edited_externally " + old_class;
 342
 343     try {
 344         yield open_file_with_external_editor(file);
 345
 346         elem.value = read_text_file(file);
 347     } finally {
 348         elem.className = old_class;
 349
 350         file.remove(false);
 351     }
 352 }
 353 interactive("edit-current-field-in-external-editor",
 354             "Edit the contents of the currently-focused text field in an external editor.",
 355             function (I) {
 356                 var buf = I.buffer;
 357                 yield edit_field_in_external_editor(buf, buf.focused_element);
 358                 unfocus(I.window, buf);
 359             });
 360
 361 define_variable("kill_whole_line", false,
 362                 "If true, `kill-line' with no arg at beg of line kills the whole line.");
 363
 364 function cut_to_end_of_line (buffer) {
 365     var elem = buffer.focused_element;
 366     try {
 367         var st = elem.selectionStart;
 368         var en = elem.selectionEnd;
 369         if (st == en) {
 370             // there is no selection.  set one up.
 371             var eol = elem.value.indexOf ("\n", en);
 372             if (eol == -1)
 373             {
 374                 elem.selectionEnd = elem.textLength;
 375             } else if (eol == st) {
 376                 elem.selectionEnd = eol + 1;
 377             } else if (kill_whole_line &&
 378                        (st == 0 || elem.value[st - 1] == "\n"))
 379             {
 380                 elem.selectionEnd = eol + 1;
 381             } else {
 382                 elem.selectionEnd = eol;
 383             }
 384         }
 385         buffer.do_command ('cmd_cut');
 386     } catch (e) {
 387         /* FIXME: Make this work for richedit mode as well */
 388     }
 389 }
 390
 391 interactive (
 392     "cut-to-end-of-line",
 393     null,
 394     function (I) {
 395         cut_to_end_of_line (I.buffer);
 396     });