2 * (C) Copyright 2004-2007 Shawn Betts
3 * (C) Copyright 2007-2008 John J. Foerch
4 * (C) Copyright 2007-2008 Jeremy Maitin-Shepard
6 * Use, modification, and distribution are subject to the terms specified in the
10 var define_buffer_local_hook = local_hook_definer("window");
12 function define_current_buffer_hook(hook_name, existing_hook)
14 define_buffer_local_hook(hook_name);
15 add_hook(existing_hook, function (buffer) {
16 if (!buffer.window.buffers || buffer != buffer.window.buffers.current)
18 var hook = conkeror[hook_name];
19 hook.run.apply(hook, Array.prototype.slice.call(arguments));
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");
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");
37 function buffer_configuration(existing_configuration) {
38 if (existing_configuration != null) {
39 this.cwd = existing_configuration.cwd;
42 this.cwd = default_directory.path;
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);
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.");
61 function buffer(window, element)
63 this.constructor_begin();
64 keywords(arguments, $configuration = null);
66 this.configuration = new buffer_configuration(arguments.$configuration);
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);
78 /* Manually set up session history.
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
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);
97 // remove the disablehistory attribute so the browser cleans up, as
98 // though it had done this work itself
99 browser.removeAttribute("disablehistory");
101 // enable global history
102 browser.docShell.QueryInterface(Ci.nsIDocShellHistory).useGlobalHistory = true;
104 this.window.buffers.buffer_list.push(this);
105 this.element = element;
106 this.browser = element.firstChild;
107 this.element.conkeror_buffer_object = this;
109 this.enabled_modes = [];
110 this.local_variables = {};
114 this.browser.addEventListener("scroll", function (event) {
115 buffer_scroll_hook.run(buffer);
116 }, true /* capture */, false /* ignore untrusted events */);
118 this.browser.addEventListener("DOMContentLoaded", function (event) {
119 buffer_dom_content_loaded_hook.run(buffer);
120 }, true /* capture */, false /*ignore untrusted events */);
122 this.browser.addEventListener("load", function (event) {
123 buffer_loaded_hook.run(buffer);
124 }, true /* capture */, false /*ignore untrusted events */);
126 this.browser.addEventListener("DOMWindowClose", function (event) {
127 /* This call to preventDefault is very important; without
128 * it, somehow Mozilla does something bad and as a result
129 * the window loses focus, causing keyboard commands to
131 event.preventDefault();
133 if (allow_browser_window_close)
134 kill_buffer(buffer, true);
137 this.constructor_end();
141 /* Saved focus state */
142 saved_focused_frame : null,
143 saved_focused_element : null,
145 on_switch_away : null,
146 // get title () [must be defined by subclasses]
147 // get name () [must be defined by subclasses]
148 dead : false, /* This is set when the buffer is killed */
150 default_message : "",
153 if (x in this.local_variables)
154 return this.local_variables[x];
158 set_default_message : function (str) {
159 this.default_message = str;
160 if (this == this.window.buffers.current)
161 this.window.minibuffer.set_default_message(str);
164 constructors_running : 0,
166 constructor_begin : function () {
167 this.constructors_running++;
170 constructor_end : function () {
171 if (--this.constructors_running == 0)
172 create_buffer_hook.run(this);
175 /* General accessors */
176 get cwd () { return this.configuration.cwd; },
178 /* Browser accessors */
179 get top_frame () { return this.browser.contentWindow; },
180 get document () { return this.browser.contentDocument; },
181 get web_navigation () { return this.browser.webNavigation; },
182 get doc_shell () { return this.browser.docShell; },
183 get markup_document_viewer () { return this.browser.markupDocumentViewer; },
184 get current_URI () { return this.browser.currentURI; },
186 is_child_element : function (element)
188 return (element && this.is_child_frame(element.ownerDocument.defaultView));
191 is_child_frame : function (frame)
193 return (frame && frame.top == this.top_frame);
196 // This method is like focused_frame, except that if no content
197 // frame actually has focus, this returns null.
198 get focused_frame_or_null () {
199 var frame = this.window.document.commandDispatcher.focusedWindow;
200 var top = this.top_frame;
201 if (this.is_child_frame(frame))
206 get focused_frame () {
207 var frame = this.window.document.commandDispatcher.focusedWindow;
208 var top = this.top_frame;
209 if (this.is_child_frame(frame))
211 return this.top_frame;
214 get focused_element () {
215 var element = this.window.document.commandDispatcher.focusedElement;
216 if (this.is_child_element(element))
221 do_command : function (command)
223 function attempt_command(element, command)
226 if (element.controllers
227 && (controller = element.controllers.getControllerForCommand(command)) != null
228 && controller.isCommandEnabled(command))
230 controller.doCommand(command);
236 var element = this.focused_element;
237 if (element && attempt_command(element, command))
239 var win = this.focused_frame;
241 if (attempt_command(win, command))
243 if (!win.parent || win == win.parent)
249 handle_kill : function () {
253 this.saved_focused_frame = null;
254 this.saved_focused_element = null;
255 kill_buffer_hook.run(this);
259 function check_buffer(obj, type) {
260 if (!(obj instanceof type))
261 throw interactive_error("Buffer has invalid type.");
263 throw interactive_error("Buffer has already been killed.");
267 function buffer_container(window, create_initial_buffer)
269 this.window = window;
270 this.container = window.document.getElementById("buffer-container");
271 this.buffer_list = [];
272 window.buffers = this;
274 create_initial_buffer(window, this.container.firstChild);
277 buffer_container.prototype = {
278 constructor : buffer_container,
281 return this.container.selectedPanel.conkeror_buffer_object;
284 set current (buffer) {
285 var old_value = this.current;
286 if (old_value == buffer)
289 this.buffer_list.splice(this.buffer_list.indexOf(buffer), 1);
290 this.buffer_list.unshift(buffer);
292 this._switch_away_from(this.current);
293 this._switch_to(buffer);
296 select_buffer_hook.run(buffer);
299 _switch_away_from : function (old_value) {
301 old_value.saved_focused_frame = old_value.focused_frame;
302 old_value.saved_focused_element = old_value.focused_element;
304 old_value.browser.setAttribute("type", "content");
307 _switch_to : function (buffer) {
308 // Select new buffer in the XUL deck
309 this.container.selectedPanel = buffer.element;
311 buffer.browser.setAttribute("type", "content-primary");
314 * This next focus call seems to be needed to avoid focus
315 * somehow getting lost (and the keypress handler therefore
316 * not getting called at all) when killing buffers.
320 // Restore focus state
321 if (buffer.saved_focused_element)
322 set_focus_no_scroll(this.window, buffer.saved_focused_element);
323 else if (buffer.saved_focused_frame)
324 set_focus_no_scroll(this.window, buffer.saved_focused_frame);
326 buffer.saved_focused_element = null;
327 buffer.saved_focused_frame = null;
329 this.window.minibuffer.set_default_message(buffer.default_message);
333 return this.container.childNodes.length;
336 get_buffer : function (index) {
337 if (index >= 0 && index < this.count)
338 return this.container.childNodes.item(index).conkeror_buffer_object;
342 get selected_index () {
343 var nodes = this.container.childNodes;
344 var count = nodes.length;
345 for (var i = 0; i < count; ++i)
346 if (nodes.item(i) == this.container.selectedPanel)
351 index_of : function (b) {
352 var nodes = this.container.childNodes;
353 var count = nodes.length;
354 for (var i = 0; i < count; ++i)
355 if (nodes.item(i) == b.element)
360 get unique_name_list () {
361 var existing_names = new string_hashset();
363 this.for_each(function(b) {
364 var base_name = b.name;
365 var name = base_name;
367 while (existing_names.contains(name))
370 name = base_name + "<" + index + ">";
372 existing_names.add(name);
373 bufs.push([name, b]);
378 kill_buffer : function (b) {
381 var count = this.count;
384 var new_buffer = this.buffer_list[0];
386 if (b == new_buffer) {
387 new_buffer = this.buffer_list[1];
390 this._switch_away_from(this.current);
391 this.container.removeChild(b.element);
392 this.buffer_list.splice(this.buffer_list.indexOf(b), 1);
393 this._switch_to(new_buffer);
395 select_buffer_hook.run(new_buffer);
396 this.buffer_list.splice(this.buffer_list.indexOf(new_buffer), 1);
397 this.buffer_list.unshift(new_buffer);
403 bury_buffer : function(b) {
404 var new_buffer = this.buffer_list[0];
405 if (b == new_buffer) new_buffer = this.buffer_list[1];
406 this._switch_to(this.buffer_list[1]);
407 this.buffer_list.splice(this.buffer_list.indexOf(b), 1);
408 this.buffer_list.push(b);
409 this._switch_to(new_buffer);
413 for_each : function (f) {
414 var count = this.count;
415 for (var i = 0; i < count; ++i)
416 f(this.get_buffer(i));
420 function buffer_initialize_window_early(window)
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.
428 var create_initial_buffer
429 = window.args.initial_buffer_creator || buffer_creator(content_buffer);
430 new buffer_container(window, create_initial_buffer);
433 add_hook("window_initialize_early_hook", buffer_initialize_window_early);
436 define_buffer_local_hook("buffer_kill_before_hook", RUN_HOOK_UNTIL_FAILURE);
437 function buffer_before_window_close(window)
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)))
447 add_hook("window_before_close_hook", buffer_before_window_close);
449 function buffer_window_close_handler(window)
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);
458 add_hook("window_close_hook", buffer_window_close_handler);
460 /* open/follow targets */
461 const OPEN_CURRENT_BUFFER = 0; // only valid for open if the current
462 // buffer is a content_buffer; for
463 // follow, equivalent to
465 const OPEN_NEW_BUFFER = 1;
466 const OPEN_NEW_BUFFER_BACKGROUND = 2;
467 const OPEN_NEW_WINDOW = 3;
469 const FOLLOW_DEFAULT = 4; // for open, implies OPEN_CURRENT_BUFFER
470 const FOLLOW_CURRENT_FRAME = 5; // for open, implies OPEN_CURRENT_BUFFER
471 const FOLLOW_TOP_FRAME = 6; // for open, implies OPEN_CURRENT_BUFFER
473 var TARGET_PROMPTS = [" in current buffer",
475 " in new buffer (background)",
481 var TARGET_NAMES = ["current buffer",
483 "new buffer (background)",
490 function browse_target_prompt(target, prefix) {
493 return prefix + TARGET_PROMPTS[target] + ":";
497 var default_browse_targets = {};
498 default_browse_targets["follow"] = [FOLLOW_DEFAULT, OPEN_NEW_BUFFER, OPEN_NEW_WINDOW];
499 default_browse_targets["follow-top"] = [FOLLOW_TOP_FRAME, FOLLOW_CURRENT_FRAME];
501 interactive_context.prototype.browse_target = function (action) {
502 var prefix = this.prefix_argument;
503 var targets = action;
504 while (typeof(targets) == "string")
505 targets = default_browse_targets[targets];
506 if (prefix == null || typeof(prefix) != "object")
510 while (num >= 4 && index + 1 < targets.length) {
514 return targets[index];
517 function create_buffer(window, creator, target) {
519 case OPEN_NEW_BUFFER:
520 window.buffers.current = creator(window, null);
522 case OPEN_NEW_BUFFER_BACKGROUND:
523 creator(window, null);
525 case OPEN_NEW_WINDOW:
526 make_window(creator);
529 throw new Error("invalid target");
533 var queued_buffer_creators = null;
534 function _process_queued_buffer_creators(window) {
535 for (var i = 0; i < queued_buffer_creators.length; ++i) {
536 var x = queued_buffer_creators[i];
537 create_buffer(window, x[0], x[1]);
539 queued_buffer_creators = null;
541 function create_buffer_in_current_window(creator, target, focus_existing) {
542 if (target == OPEN_NEW_WINDOW)
543 throw new Error("invalid target");
544 var window = get_recent_conkeror_window();
548 create_buffer(window, creator, target);
549 } else if (queued_buffer_creators != null) {
550 queued_buffer_creators.push([creator,target]);
552 queued_buffer_creators = [];
553 window = make_window(creator);
554 add_hook.call(window, "window_initialize_late_hook", _process_queued_buffer_creators);
558 minibuffer_auto_complete_preferences["buffer"] = true;
559 define_keywords("$default");
560 minibuffer.prototype.read_buffer = function () {
561 var window = this.window;
562 var buffer = this.window.buffers.current;
563 keywords(arguments, $prompt = "Buffer:",
565 $history = "buffer");
566 var completer = all_word_completer(
567 $completions = function (visitor) window.buffers.for_each(visitor),
568 $get_string = function (x) x.description,
569 $get_description = function (x) x.title);
570 var result = yield this.read(
571 $prompt = arguments.$prompt,
572 $history = arguments.$history,
573 $completer = completer,
574 $match_required = true,
575 $auto_complete = "buffer",
576 $auto_complete_initial = true,
577 $auto_complete_delay = 0,
578 $default_completion = arguments.$default);
579 yield co_return(result);
582 interactive_context.prototype.__defineGetter__("cwd", function () this.buffer.cwd);
584 function buffer_next (window, count)
586 var index = window.buffers.selected_index;
587 var total = window.buffers.count;
588 index = (index + count) % total;
591 window.buffers.current = window.buffers.get_buffer(index);
593 interactive("buffer-next",
594 "Switch to the next buffer.",
595 function (I) {buffer_next(I.window, I.p);});
596 interactive("buffer-previous",
597 "Switch to the previous buffer.",
598 function (I) {buffer_next(I.window, -I.p);});
600 function switch_to_buffer (window, buffer)
602 if (buffer && !buffer.dead)
603 window.buffers.current = buffer;
605 interactive("switch-to-buffer",
606 "Switch to a buffer specified in the minibuffer.",
610 (yield I.minibuffer.read_buffer(
611 $prompt = "Switch to buffer:",
612 $default = (I.window.buffers.count > 1 ?
613 I.window.buffers.buffer_list[1] :
618 define_variable("can_kill_last_buffer", true,
619 "If this is set to true, kill-buffer can kill the last remaining buffer, and close the window.");
621 function kill_buffer(buffer, force)
625 var buffers = buffer.window.buffers;
626 if (buffers.count == 1 && buffer == buffers.current) {
627 if (can_kill_last_buffer || force) {
628 delete_window(buffer.window);
632 throw interactive_error("Can't kill last buffer.");
634 buffers.kill_buffer(buffer);
636 interactive("kill-buffer",
637 "Kill a buffer specified in the minibuffer.\n" +
638 "If `can_kill_last_buffer' is set to true, an attempt to kill the last remaining " +
639 "buffer in a window will cause the window to be closed.",
640 function (I) {kill_buffer((yield I.minibuffer.read_buffer($prompt = "Kill buffer:")))});
642 interactive("kill-current-buffer",
643 "Kill the current buffer.\n" +
644 "If `can_kill_last_buffer' is set to true, an attempt to kill the last remaining " +
645 "buffer in a window will cause the window to be closed.",
646 function (I) {kill_buffer(I.buffer)});
648 interactive("bury-buffer",
649 "Bury the current buffer.\n Put the current buffer at the end of " +
650 "the buffer list, so that it is the least likely buffer to be " +
651 "selected by `switch-to-buffer'.",
652 function (I) {I.window.buffers.bury_buffer(I.buffer);});
654 function change_directory(buffer, dir) {
655 buffer.configuration.cwd = dir;
657 interactive("change-current-directory",
658 "Change the current directory of the selected buffer.",
662 (yield I.minibuffer.read_existing_directory_path(
663 $prompt = "New current directory:",
664 $initial_value = I.cwd)));
667 interactive("shell-command", function (I) {
669 var cmd = (yield I.minibuffer.read_shell_command($cwd = cwd));
670 yield shell_command(cmd, $cwd = cwd);
673 function unfocus(window, buffer)
675 var elem = buffer.focused_element;
680 var win = buffer.focused_frame;
681 if (win != buffer.top_frame)
683 clear_selection(buffer);
684 buffer.top_frame.focus();
686 interactive("unfocus", function (I) {
687 unfocus(I.window, I.buffer);
688 I.window.minibuffer.message("unfocus");
691 require_later("content-buffer.js");
693 var mode_functions = {};
695 var mode_display_names = {};
697 define_buffer_local_hook("buffer_mode_change_hook");
698 define_current_buffer_hook("current_buffer_mode_change_hook", "buffer_mode_change_hook");
700 define_keywords("$class", "$enable", "$disable", "$doc");
701 function define_buffer_mode(name, display_name) {
704 var hyphen_name = name.replace("_","-","g");
705 var mode_class = arguments.$class;
706 var enable = arguments.$enable;
707 var disable = arguments.$disable;
709 mode_display_names[name] = display_name;
713 if (disable == false) {
719 var state = (mode_class != null) ? mode_class : (name + "_enabled");
720 var enable_hook_name = name + "_enable_hook";
721 var disable_hook_name = name + "_disable_hook";
722 define_buffer_local_hook(enable_hook_name);
723 define_buffer_local_hook(disable_hook_name);
725 var change_hook_name = null;
728 mode_functions[name] = {enable: enable,
730 mode_class: mode_class,
731 disable_hook_name: disable_hook_name};
732 change_hook_name = mode_class + "_change_hook";
733 define_buffer_local_hook(change_hook_name);
736 function func(buffer, arg) {
737 var old_state = buffer[state];
738 var cur_state = (old_state == name);
739 var new_state = (arg == null) ? !cur_state : (arg > 0);
740 if ((new_state == cur_state) || (!can_disable && !new_state))
743 if (mode_class && old_state != null) {
744 buffer.enabled_modes.splice(buffer.enabled_modes.indexOf(old_state), 1);
745 let x = mode_functions[old_state];
748 conkeror[x.disable_hook_name].run(buffer);
750 buffer[state] = name;
753 conkeror[enable_hook_name].run(buffer);
754 buffer.enabled_modes.push(name);
756 buffer.enabled_modes.splice(buffer.enabled_modes.indexOf(name), 1);
758 conkeror[disable_hook_name].run(buffer);
759 buffer[state] = null;
761 if (change_hook_name)
762 conkeror[change_hook_name].run(buffer, buffer[state]);
763 buffer_mode_change_hook.run(buffer);
766 conkeror[name] = func;
767 interactive(hyphen_name, arguments.$doc, function (I) {
769 var new_state = func(I.buffer, arg && univ_arg_to_number(arg));
770 I.minibuffer.message(hyphen_name + (new_state ? " enabled" : " disabled"));
773 ignore_function_for_get_caller_source_code_reference("define_buffer_mode");
776 function minibuffer_mode_indicator(window) {
777 this.window = window;
778 var element = create_XUL(window, "label");
779 element.setAttribute("id", "minibuffer-mode-indicator");
780 element.collapsed = true;
781 element.setAttribute("class", "minibuffer");
782 window.document.getElementById("minibuffer").appendChild(element);
783 this.element = element;
784 this.hook_func = method_caller(this, this.update);
785 add_hook.call(window, "select_buffer_hook", this.hook_func);
786 add_hook.call(window, "current_buffer_mode_change_hook", this.hook_func);
789 minibuffer_mode_indicator.prototype = {
790 update : function () {
791 var buf = this.window.buffers.current;
792 var modes = buf.enabled_modes;
793 var str = modes.map( function (x) {
794 let y = mode_display_names[x];
796 return "[" + y + "]";
799 } ).filter( function (x) x != null ).join(" ");
800 this.element.collapsed = (str.length == 0);
801 this.element.value = str;
803 uninstall : function () {
804 remove_hook.call(window, "select_buffer_hook", this.hook_fun);
805 remove_hook.call(window, "current_buffer_mode_change_hook", this.hook_fun);
806 this.element.parentNode.removeChild(this.element);
809 define_global_window_mode("minibuffer_mode_indicator", "window_initialize_hook");
810 minibuffer_mode_indicator_mode(true);