modules/buffer.js

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