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