modules/buffer.js

   1 /**
   2  * (C) Copyright 2004-2007 Shawn Betts
   3  * (C) Copyright 2007-2008 John J. Foerch
   4  * (C) Copyright 2007-2008 Jeremy Maitin-Shepard
   5  *
   6  * Use, modification, and distribution are subject to the terms specified in the
   7  * COPYING file.
   8 **/
   9
  10 var define_buffer_local_hook = local_hook_definer("window");
  11
  12 function define_current_buffer_hook(hook_name, existing_hook)
  13 {
  14     define_buffer_local_hook(hook_name);
  15     add_hook(existing_hook, function (buffer) {
  16             if (!buffer.window.buffers || buffer != buffer.window.buffers.current)
  17                 return;
  18             var hook = conkeror[hook_name];
  19             hook.run.apply(hook, Array.prototype.slice.call(arguments));
  20         });
  21 }
  22
  23 define_buffer_local_hook("buffer_title_change_hook");
  24 define_buffer_local_hook("buffer_description_change_hook");
  25 define_buffer_local_hook("select_buffer_hook");
  26 define_buffer_local_hook("create_buffer_hook");
  27 define_buffer_local_hook("kill_buffer_hook");
  28 define_buffer_local_hook("buffer_scroll_hook");
  29 define_buffer_local_hook("buffer_dom_content_loaded_hook");
  30 define_buffer_local_hook("buffer_loaded_hook");
  31
  32 define_current_buffer_hook("current_buffer_title_change_hook", "buffer_title_change_hook");
  33 define_current_buffer_hook("current_buffer_description_change_hook", "buffer_description_change_hook");
  34 define_current_buffer_hook("current_buffer_scroll_hook", "buffer_scroll_hook");
  35 define_current_buffer_hook("current_buffer_dom_content_loaded_hook", "buffer_dom_content_loaded_hook");
  36
  37 function buffer_configuration(existing_configuration) {
  38     if (existing_configuration != null) {
  39         this.cwd = existing_configuration.cwd;
  40     }
  41     else {
  42         this.cwd = default_directory.path;
  43     }
  44 }
  45
  46 define_keywords("$configuration", "$element");
  47 function buffer_creator(type) {
  48     var args = forward_keywords(arguments);
  49     return function (window, element) {
  50         return new type(window, element, args);
  51     };
  52 }
  53
  54 define_variable("allow_browser_window_close", true,
  55                      "If this is set to true, if a content buffer page calls " +
  56                      "window.close() from JavaScript and is not prevented by the " +
  57                      "normal Mozilla mechanism that restricts pages from closing " +
  58                      "a window that was not opened by a script, the buffer will be " +
  59                      "killed, deleting the window as well if it is the only buffer.");
  60
  61 function buffer(window, element)
  62 {
  63     this.constructor_begin();
  64     keywords(arguments, $configuration = null);
  65     this.window = window;
  66     this.configuration = new buffer_configuration(arguments.$configuration);
  67     if (element == null)
  68     {
  69         element = create_XUL(window, "vbox");
  70         element.setAttribute("flex", "1");
  71         var browser = create_XUL(window, "browser");
  72         browser.setAttribute("type", "content");
  73         browser.setAttribute("flex", "1");
  74         browser.setAttribute("autocompletepopup", "popup_autocomplete");
  75         element.appendChild(browser);
  76         this.window.buffers.container.appendChild(element);
  77     } else {
  78         /* Manually set up session history.
  79          *
  80          * This is needed because when constructor for the XBL binding
  81          * (mozilla/toolkit/content/widgets/browser.xml#browser) for
  82          * the initial browser element of the window is called, the
  83          * docShell is not yet initialized and setting up the session
  84          * history will fail.  To work around this problem, we do as
  85          * tabbrowser.xml (Firefox) does and set the initial browser
  86          * to have the disablehistory=true attribute, and then repeat
  87          * the work that would normally be done in the XBL
  88          * constructor.
  89          */
  90
  91         // This code is taken from mozilla/browser/base/content/browser.js
  92         let browser = element.firstChild;
  93         browser.webNavigation.sessionHistory =
  94             Cc["@mozilla.org/browser/shistory;1"].createInstance(Ci.nsISHistory);
  95         observer_service.addObserver(browser, "browser:purge-session-history", false);
  96
  97         // remove the disablehistory attribute so the browser cleans up, as
  98         // though it had done this work itself
  99         browser.removeAttribute("disablehistory");
 100
 101         // enable global history
 102         browser.docShell.QueryInterface(Ci.nsIDocShellHistory).useGlobalHistory = true;
 103     }
 104     this.window.buffers.buffer_list.push(this);
 105     this.element = element;
 106     this.browser = element.firstChild;
 107     this.element.conkeror_buffer_object = this;
 108
 109     this.enabled_modes = [];
 110     this.local_variables = {};
 111     this.default_browser_object_classes = {};
 112
 113     var buffer = this;
 114
 115     this.browser.addEventListener("scroll", function (event) {
 116             buffer_scroll_hook.run(buffer);
 117         }, true /* capture */, false /* ignore untrusted events */);
 118
 119     this.browser.addEventListener("DOMContentLoaded", function (event) {
 120             buffer_dom_content_loaded_hook.run(buffer);
 121         }, true /* capture */, false /*ignore untrusted events */);
 122
 123     this.browser.addEventListener("load", function (event) {
 124             buffer_loaded_hook.run(buffer);
 125         }, true /* capture */, false /*ignore untrusted events */);
 126
 127     this.browser.addEventListener("DOMWindowClose", function (event) {
 128             /* This call to preventDefault is very important; without
 129              * it, somehow Mozilla does something bad and as a result
 130              * the window loses focus, causing keyboard commands to
 131              * stop working. */
 132             event.preventDefault();
 133
 134             if (allow_browser_window_close)
 135                 kill_buffer(buffer, true);
 136         }, true);
 137
 138     this.constructor_end();
 139 }
 140
 141 buffer.prototype = {
 142     /* Saved focus state */
 143     saved_focused_frame : null,
 144     saved_focused_element : null,
 145     on_switch_to : null,
 146     on_switch_away : null,
 147     // get title ()   [must be defined by subclasses]
 148     // get name ()    [must be defined by subclasses]
 149     dead : false, /* This is set when the buffer is killed */
 150
 151     default_message : "",
 152
 153     get : function (x) {
 154         if (x in this.local_variables)
 155             return this.local_variables[x];
 156         return conkeror[x];
 157     },
 158
 159     set_default_message : function (str) {
 160         this.default_message = str;
 161         if (this == this.window.buffers.current)
 162             this.window.minibuffer.set_default_message(str);
 163     },
 164
 165     constructors_running : 0,
 166
 167     constructor_begin : function () {
 168         this.constructors_running++;
 169     },
 170
 171     constructor_end : function () {
 172         if (--this.constructors_running == 0)
 173             create_buffer_hook.run(this);
 174     },
 175
 176     /* General accessors */
 177     get cwd () { return this.configuration.cwd; },
 178
 179     /* Browser accessors */
 180     get top_frame () { return this.browser.contentWindow; },
 181     get document () { return this.browser.contentDocument; },
 182     get web_navigation () { return this.browser.webNavigation; },
 183     get doc_shell () { return this.browser.docShell; },
 184     get markup_document_viewer () { return this.browser.markupDocumentViewer; },
 185     get current_URI () { return this.browser.currentURI; },
 186
 187     is_child_element : function (element)
 188     {
 189         return (element && this.is_child_frame(element.ownerDocument.defaultView));
 190     },
 191
 192     is_child_frame : function (frame)
 193     {
 194         return (frame && frame.top == this.top_frame);
 195     },
 196
 197     // This method is like focused_frame, except that if no content
 198     // frame actually has focus, this returns null.
 199     get focused_frame_or_null () {
 200         var frame = this.window.document.commandDispatcher.focusedWindow;
 201         var top = this.top_frame;
 202         if (this.is_child_frame(frame))
 203             return frame;
 204         return null;
 205     },
 206
 207     get focused_frame () {
 208         var frame = this.window.document.commandDispatcher.focusedWindow;
 209         var top = this.top_frame;
 210         if (this.is_child_frame(frame))
 211             return frame;
 212         return this.top_frame;
 213     },
 214
 215     get focused_element () {
 216         var element = this.window.document.commandDispatcher.focusedElement;
 217         if (this.is_child_element(element))
 218             return element;
 219         return null;
 220     },
 221
 222     do_command : function (command)
 223     {
 224         function attempt_command(element, command)
 225         {
 226             var controller;
 227             if (element.controllers
 228                 && (controller = element.controllers.getControllerForCommand(command)) != null
 229                 && controller.isCommandEnabled(command))
 230             {
 231                 controller.doCommand(command);
 232                 return true;
 233             }
 234             return false;
 235         }
 236
 237         var element = this.focused_element;
 238         if (element && attempt_command(element, command))
 239             return;
 240         var win = this.focused_frame;
 241         do  {
 242             if (attempt_command(win, command))
 243                 return;
 244             if (!win.parent || win == win.parent)
 245                 break;
 246             win = win.parent;
 247         } while (true);
 248     },
 249
 250     handle_kill : function () {
 251         this.dead = true;
 252         this.browser = null;
 253         this.element = null;
 254         this.saved_focused_frame = null;
 255         this.saved_focused_element = null;
 256         kill_buffer_hook.run(this);
 257     }
 258 };
 259
 260 function check_buffer(obj, type) {
 261     if (!(obj instanceof type))
 262         throw interactive_error("Buffer has invalid type.");
 263     if (obj.dead)
 264         throw interactive_error("Buffer has already been killed.");
 265     return obj;
 266 }
 267
 268 function buffer_container(window, create_initial_buffer)
 269 {
 270     this.window = window;
 271     this.container = window.document.getElementById("buffer-container");
 272     this.buffer_list = [];
 273     window.buffers = this;
 274
 275     create_initial_buffer(window, this.container.firstChild);
 276 }
 277
 278 buffer_container.prototype = {
 279     constructor : buffer_container,
 280
 281     get current () {
 282         return this.container.selectedPanel.conkeror_buffer_object;
 283     },
 284
 285     set current (buffer) {
 286         var old_value = this.current;
 287         if (old_value == buffer)
 288             return;
 289
 290         this.buffer_list.splice(this.buffer_list.indexOf(buffer), 1);
 291         this.buffer_list.unshift(buffer);
 292
 293         this._switch_away_from(this.current);
 294         this._switch_to(buffer);
 295
 296         // Run hooks
 297         select_buffer_hook.run(buffer);
 298     },
 299
 300     _switch_away_from : function (old_value) {
 301         // Save focus state
 302         old_value.saved_focused_frame = old_value.focused_frame;
 303         old_value.saved_focused_element = old_value.focused_element;
 304
 305         old_value.browser.setAttribute("type", "content");
 306     },
 307
 308     _switch_to : function (buffer) {
 309         // Select new buffer in the XUL deck
 310         this.container.selectedPanel = buffer.element;
 311
 312         buffer.browser.setAttribute("type", "content-primary");
 313
 314         /**
 315          * This next focus call seems to be needed to avoid focus
 316          * somehow getting lost (and the keypress handler therefore
 317          * not getting called at all) when killing buffers.
 318          */
 319         this.window.focus();
 320
 321         // Restore focus state
 322         if (buffer.saved_focused_element)
 323             set_focus_no_scroll(this.window, buffer.saved_focused_element);
 324         else if (buffer.saved_focused_frame)
 325             set_focus_no_scroll(this.window, buffer.saved_focused_frame);
 326
 327         buffer.saved_focused_element = null;
 328         buffer.saved_focused_frame = null;
 329
 330         this.window.minibuffer.set_default_message(buffer.default_message);
 331     },
 332
 333     get count () {
 334         return this.container.childNodes.length;
 335     },
 336
 337     get_buffer : function (index) {
 338         if (index >= 0 && index < this.count)
 339             return this.container.childNodes.item(index).conkeror_buffer_object;
 340         return null;
 341     },
 342
 343     get selected_index () {
 344         var nodes = this.container.childNodes;
 345         var count = nodes.length;
 346         for (var i = 0; i < count; ++i)
 347             if (nodes.item(i) == this.container.selectedPanel)
 348                 return i;
 349         return null;
 350     },
 351
 352     index_of : function (b) {
 353         var nodes = this.container.childNodes;
 354         var count = nodes.length;
 355         for (var i = 0; i < count; ++i)
 356             if (nodes.item(i) == b.element)
 357                 return i;
 358         return null;
 359     },
 360
 361     get unique_name_list () {
 362         var existing_names = new string_hashset();
 363         var bufs = [];
 364         this.for_each(function(b) {
 365                 var base_name = b.name;
 366                 var name = base_name;
 367                 var index = 1;
 368                 while (existing_names.contains(name))
 369                 {
 370                     ++index;
 371                     name = base_name + "<" + index + ">";
 372                 }
 373                 existing_names.add(name);
 374                 bufs.push([name, b]);
 375             });
 376         return bufs;
 377     },
 378
 379     kill_buffer : function (b) {
 380         if (b.dead)
 381             return true;
 382         var count = this.count;
 383         if (count <= 1)
 384             return false;
 385         var new_buffer = this.buffer_list[0];
 386         var changed = false;
 387         if (b == new_buffer) {
 388             new_buffer = this.buffer_list[1];
 389             changed = true;
 390         }
 391         this._switch_away_from(this.current);
 392         this.container.removeChild(b.element);
 393         this.buffer_list.splice(this.buffer_list.indexOf(b), 1);
 394         this._switch_to(new_buffer);
 395         if (changed) {
 396             select_buffer_hook.run(new_buffer);
 397             this.buffer_list.splice(this.buffer_list.indexOf(new_buffer), 1);
 398             this.buffer_list.unshift(new_buffer);
 399         }
 400         b.handle_kill();
 401         return true;
 402     },
 403
 404     bury_buffer : function(b) {
 405       var new_buffer = this.buffer_list[0];
 406       if (b == new_buffer) new_buffer = this.buffer_list[1];
 407       this.buffer_list.splice(this.buffer_list.indexOf(b), 1);
 408       this.buffer_list.push(b);
 409       this.current = new_buffer;
 410       return true;
 411     },
 412
 413     for_each : function (f) {
 414         var count = this.count;
 415         for (var i = 0; i < count; ++i)
 416             f(this.get_buffer(i));
 417     }
 418 };
 419
 420 function buffer_initialize_window_early(window)
 421 {
 422     /**
 423      * Use content_buffer by default to handle an unusual case where
 424      * browser.chromeURI is used perhaps.  In general this default
 425      * should not be needed.
 426      */
 427
 428     var create_initial_buffer
 429         = window.args.initial_buffer_creator || buffer_creator(content_buffer);
 430     new buffer_container(window, create_initial_buffer);
 431 }
 432
 433 add_hook("window_initialize_early_hook", buffer_initialize_window_early);
 434
 435
 436 define_buffer_local_hook("buffer_kill_before_hook", RUN_HOOK_UNTIL_FAILURE);
 437 function buffer_before_window_close(window)
 438 {
 439     var bs = window.buffers;
 440     var count = bs.count;
 441     for (let i = 0; i < count; ++i) {
 442         if (!buffer_kill_before_hook.run(bs.get_buffer(i)))
 443             return false;
 444     }
 445     return true;
 446 }
 447 add_hook("window_before_close_hook", buffer_before_window_close);
 448
 449 function buffer_window_close_handler(window)
 450 {
 451     var bs = window.buffers;
 452     var count = bs.count;
 453     for (let i = 0; i < count; ++i) {
 454         let b = bs.get_buffer(i);
 455         b.handle_kill();
 456     }
 457 }
 458 add_hook("window_close_hook", buffer_window_close_handler);
 459
 460 /* open/follow targets */
 461 const OPEN_CURRENT_BUFFER = 0; // only valid for open if the current
 462                                // buffer is a content_buffer.
 463 const OPEN_NEW_BUFFER = 1;
 464 const OPEN_NEW_BUFFER_BACKGROUND = 2;
 465 const OPEN_NEW_WINDOW = 3;
 466
 467 const FOLLOW_DEFAULT = 4; // for open, implies OPEN_CURRENT_BUFFER
 468 const FOLLOW_CURRENT_FRAME = 5; // for open, implies OPEN_CURRENT_BUFFER
 469
 470 var TARGET_PROMPTS = [" in current buffer",
 471                       " in new buffer",
 472                       " in new buffer (background)",
 473                       " in new window",
 474                       "",
 475                       " in current frame"];
 476
 477 var TARGET_NAMES = ["current buffer",
 478                     "new buffer",
 479                     "new buffer (background)",
 480                     "new window",
 481                     "default",
 482                     "current frame"];
 483
 484
 485 function create_buffer(window, creator, target) {
 486     switch (target) {
 487     case OPEN_NEW_BUFFER:
 488         window.buffers.current = creator(window, null);
 489         break;
 490     case OPEN_NEW_BUFFER_BACKGROUND:
 491         creator(window, null);
 492         break;
 493     case OPEN_NEW_WINDOW:
 494         make_window(creator);
 495         break;
 496     default:
 497         throw new Error("invalid target");
 498     }
 499 }
 500
 501 var queued_buffer_creators = null;
 502 function _process_queued_buffer_creators(window) {
 503     for (var i = 0; i < queued_buffer_creators.length; ++i) {
 504         var x = queued_buffer_creators[i];
 505         create_buffer(window, x[0], x[1]);
 506     }
 507     queued_buffer_creators = null;
 508 }
 509 function create_buffer_in_current_window(creator, target, focus_existing) {
 510     if (target == OPEN_NEW_WINDOW)
 511         throw new Error("invalid target");
 512     var window = get_recent_conkeror_window();
 513     if (window) {
 514         if (focus_existing)
 515             window.focus();
 516         create_buffer(window, creator, target);
 517     } else if (queued_buffer_creators != null) {
 518         queued_buffer_creators.push([creator,target]);
 519     } else {
 520         queued_buffer_creators = [];
 521         window = make_window(creator);
 522         add_hook.call(window, "window_initialize_late_hook", _process_queued_buffer_creators);
 523     }
 524 }
 525
 526 minibuffer_auto_complete_preferences["buffer"] = true;
 527 define_keywords("$default");
 528 minibuffer.prototype.read_buffer = function () {
 529     var window = this.window;
 530     var buffer = this.window.buffers.current;
 531     keywords(arguments, $prompt = "Buffer:",
 532              $default = buffer,
 533              $history = "buffer");
 534     var completer = all_word_completer(
 535         $completions = function (visitor) window.buffers.for_each(visitor),
 536         $get_string = function (x) x.description,
 537         $get_description = function (x) x.title);
 538     var result = yield this.read(
 539         $prompt = arguments.$prompt,
 540         $history = arguments.$history,
 541         $completer = completer,
 542         $match_required = true,
 543         $auto_complete = "buffer",
 544         $auto_complete_initial = true,
 545         $auto_complete_delay = 0,
 546         $default_completion = arguments.$default);
 547     yield co_return(result);
 548 };
 549
 550 interactive_context.prototype.__defineGetter__("cwd", function () this.buffer.cwd);
 551
 552 function buffer_next (window, count)
 553 {
 554     var index = window.buffers.selected_index;
 555     var total = window.buffers.count;
 556     index = (index + count) % total;
 557     if (index < 0)
 558         index += total;
 559     window.buffers.current = window.buffers.get_buffer(index);
 560 }
 561 interactive("buffer-next",
 562             "Switch to the next buffer.",
 563             function (I) {buffer_next(I.window, I.p);});
 564 interactive("buffer-previous",
 565             "Switch to the previous buffer.",
 566             function (I) {buffer_next(I.window, -I.p);});
 567
 568 function switch_to_buffer (window, buffer)
 569 {
 570     if (buffer && !buffer.dead)
 571         window.buffers.current = buffer;
 572 }
 573 interactive("switch-to-buffer",
 574             "Switch to a buffer specified in the minibuffer.",
 575             function (I) {
 576                 switch_to_buffer(
 577                     I.window,
 578                     (yield I.minibuffer.read_buffer(
 579                         $prompt = "Switch to buffer:",
 580                         $default = (I.window.buffers.count > 1 ?
 581                                     I.window.buffers.buffer_list[1] :
 582                                     I.buffer))));
 583             });
 584
 585 define_variable("can_kill_last_buffer", true,
 586                 "If this is set to true, kill-buffer can kill the last "+
 587                 "remaining buffer, and close the window.");
 588
 589 function kill_other_buffers(buffer)
 590 {
 591     if (!buffer)
 592         return;
 593     var bs = buffer.window.buffers;
 594     var b;
 595
 596     while ((b = bs.get_buffer(0)) != buffer)
 597             bs.kill_buffer(b);
 598     var count = bs.count;
 599     while (--count)
 600             bs.kill_buffer(bs.get_buffer(1));
 601 }
 602 interactive("kill-other-buffers",
 603             "Kill all buffers except current one.\n",
 604             function (I) { kill_other_buffers(I.buffer); });
 605
 606
 607 function kill_buffer(buffer, force)
 608 {
 609     if (!buffer)
 610         return;
 611     var buffers = buffer.window.buffers;
 612     if (buffers.count == 1 && buffer == buffers.current) {
 613         if (can_kill_last_buffer || force) {
 614             delete_window(buffer.window);
 615             return;
 616         }
 617         else
 618             throw interactive_error("Can't kill last buffer.");
 619     }
 620     buffers.kill_buffer(buffer);
 621 }
 622 interactive("kill-buffer",
 623             "Kill a buffer specified in the minibuffer.\n" +
 624             "If `can_kill_last_buffer' is set to true, an attempt to kill the last remaining " +
 625             "buffer in a window will cause the window to be closed.",
 626             function (I) { kill_buffer((yield I.minibuffer.read_buffer($prompt = "Kill buffer:"))); });
 627
 628 interactive("kill-current-buffer",
 629             "Kill the current buffer.\n" +
 630             "If `can_kill_last_buffer' is set to true, an attempt to kill the last remaining " +
 631             "buffer in a window will cause the window to be closed.",
 632             function (I) { kill_buffer(I.buffer); });
 633
 634 interactive("bury-buffer",
 635             "Bury the current buffer.\n Put the current buffer at the end of " +
 636             "the buffer list, so that it is the least likely buffer to be " +
 637             "selected by `switch-to-buffer'.",
 638             function (I) {I.window.buffers.bury_buffer(I.buffer);});
 639
 640 function change_directory(buffer, dir) {
 641     buffer.configuration.cwd = dir;
 642 }
 643 interactive("change-directory",
 644             "Change the current directory of the selected buffer.",
 645             function (I) {
 646                 change_directory(
 647                     I.buffer,
 648                     (yield I.minibuffer.read_existing_directory_path(
 649                         $prompt = "New current directory:",
 650                         $initial_value = I.cwd)));
 651             });
 652
 653 interactive("shell-command", null, function (I) {
 654     var cwd = I.cwd;
 655     var cmd = (yield I.minibuffer.read_shell_command($cwd = cwd));
 656     yield shell_command(cmd, $cwd = cwd);
 657 });
 658
 659 function unfocus(window, buffer)
 660 {
 661     var elem = buffer.focused_element;
 662     if (elem) {
 663         elem.blur();
 664         return;
 665     }
 666     var win = buffer.focused_frame;
 667     if (win != buffer.top_frame)
 668         return;
 669     clear_selection(buffer);
 670     buffer.top_frame.focus();
 671 }
 672 interactive("unfocus", null, function (I) {
 673     unfocus(I.window, I.buffer);
 674     I.window.minibuffer.message("unfocus");
 675 });
 676
 677 function for_each_buffer(f) {
 678     for_each_window(function (w) { w.buffers.for_each(f); });
 679 }
 680
 681 require_later("content-buffer.js");
 682
 683 var mode_functions = {};
 684
 685 var mode_display_names = {};
 686
 687 define_buffer_local_hook("buffer_mode_change_hook");
 688 define_current_buffer_hook("current_buffer_mode_change_hook", "buffer_mode_change_hook");
 689
 690 define_keywords("$class", "$enable", "$disable", "$doc");
 691 function define_buffer_mode(name, display_name) {
 692     keywords(arguments);
 693
 694     var hyphen_name = name.replace("_","-","g");
 695     var mode_class = arguments.$class;
 696     var enable = arguments.$enable;
 697     var disable = arguments.$disable;
 698
 699     mode_display_names[name] = display_name;
 700
 701     var can_disable;
 702
 703     if (disable == false) {
 704         can_disable = false;
 705         disable = null;
 706     } else
 707         can_disable = true;
 708
 709     var state = (mode_class != null) ? mode_class : (name + "_enabled");
 710     var enable_hook_name = name + "_enable_hook";
 711     var disable_hook_name = name + "_disable_hook";
 712     define_buffer_local_hook(enable_hook_name);
 713     define_buffer_local_hook(disable_hook_name);
 714
 715     var change_hook_name = null;
 716
 717     if (mode_class) {
 718         mode_functions[name] = {enable: enable,
 719                                 disable: disable,
 720                                 mode_class: mode_class,
 721                                 disable_hook_name: disable_hook_name};
 722         change_hook_name = mode_class + "_change_hook";
 723         define_buffer_local_hook(change_hook_name);
 724     }
 725
 726     function func(buffer, arg) {
 727         var old_state = buffer[state];
 728         var cur_state = (old_state == name);
 729         var new_state = (arg == null) ? !cur_state : (arg > 0);
 730         if ((new_state == cur_state) || (!can_disable && !new_state))
 731             return null;
 732         if (new_state) {
 733             if (mode_class && old_state != null)  {
 734                 buffer.enabled_modes.splice(buffer.enabled_modes.indexOf(old_state), 1);
 735                 let x = mode_functions[old_state];
 736                 let y = x.disable;
 737                 if (y) y(buffer);
 738                 conkeror[x.disable_hook_name].run(buffer);
 739             }
 740             buffer[state] = name;
 741             if (enable)
 742                 enable(buffer);
 743             conkeror[enable_hook_name].run(buffer);
 744             buffer.enabled_modes.push(name);
 745         } else {
 746             buffer.enabled_modes.splice(buffer.enabled_modes.indexOf(name), 1);
 747             disable(buffer);
 748             conkeror[disable_hook_name].run(buffer);
 749             buffer[state] = null;
 750         }
 751         if (change_hook_name)
 752             conkeror[change_hook_name].run(buffer, buffer[state]);
 753         buffer_mode_change_hook.run(buffer);
 754         return new_state;
 755     };
 756     conkeror[name] = func;
 757     interactive(hyphen_name, arguments.$doc, function (I) {
 758         var arg = I.P;
 759         var new_state = func(I.buffer, arg && univ_arg_to_number(arg));
 760         I.minibuffer.message(hyphen_name + (new_state ? " enabled" : " disabled"));
 761     });
 762 }
 763 ignore_function_for_get_caller_source_code_reference("define_buffer_mode");
 764
 765
 766 function minibuffer_mode_indicator(window) {
 767     this.window = window;
 768     var element = create_XUL(window, "label");
 769     element.setAttribute("id", "minibuffer-mode-indicator");
 770     element.collapsed = true;
 771     element.setAttribute("class", "minibuffer");
 772     window.document.getElementById("minibuffer").appendChild(element);
 773     this.element = element;
 774     this.hook_func = method_caller(this, this.update);
 775     add_hook.call(window, "select_buffer_hook", this.hook_func);
 776     add_hook.call(window, "current_buffer_mode_change_hook", this.hook_func);
 777     this.update();
 778 }
 779 minibuffer_mode_indicator.prototype = {
 780     update : function () {
 781         var buf = this.window.buffers.current;
 782         var modes = buf.enabled_modes;
 783         var str = modes.map( function (x) {
 784             let y = mode_display_names[x];
 785             if (y)
 786                 return "[" + y + "]";
 787             else
 788                 return null;
 789         } ).filter( function (x) x != null ).join(" ");
 790         this.element.collapsed = (str.length == 0);
 791         this.element.value = str;
 792     },
 793     uninstall : function () {
 794         remove_hook.call(window, "select_buffer_hook", this.hook_fun);
 795         remove_hook.call(window, "current_buffer_mode_change_hook", this.hook_fun);
 796         this.element.parentNode.removeChild(this.element);
 797     }
 798 };
 799 define_global_window_mode("minibuffer_mode_indicator", "window_initialize_hook");
 800 minibuffer_mode_indicator_mode(true);