modules/hints.js

   1 /**
   2  * (C) Copyright 2007-2008 Jeremy Maitin-Shepard
   3  * (C) Copyright 2009-2010 John J. Foerch
   4  *
   5  * Portions of this file are derived from Vimperator,
   6  * (C) Copyright 2006-2007 Martin Stubenschrott.
   7  *
   8  * Use, modification, and distribution are subject to the terms specified in the
   9  * COPYING file.
  10 **/
  11
  12 in_module(null);
  13
  14 define_variable("active_img_hint_background_color", "#88FF00",
  15     "Color for the active image hint background.");
  16
  17 define_variable("img_hint_background_color", "yellow",
  18     "Color for inactive image hint backgrounds.");
  19
  20 define_variable("active_hint_background_color", "#88FF00",
  21     "Color for the active hint background.");
  22
  23 define_variable("hint_background_color", "yellow",
  24     "Color for the inactive hint.");
  25
  26
  27 define_variable("hint_digits", null,
  28     "Null or a string of the digits to use as the counting base "+
  29     "for hint numbers, starting with the digit that represents zero "+
  30     "and ascending.  If null, base 10 will be used with the normal "+
  31     "hindu-arabic numerals.");
  32
  33
  34 /**
  35  * hints_enumerate is a generator of natural numbers in the base defined
  36  * by hint_digits.
  37  */
  38 function hints_enumerate () {
  39     var base = hint_digits.length;
  40     var n = [1];
  41     var p = 1;
  42     while (true) {
  43         yield n.map(function (x) hint_digits[x]).join("");
  44         var i = p-1;
  45         n[i]++;
  46         while (n[i] >= base && i > 0) {
  47             n[i] = 0;
  48             n[--i]++;
  49         }
  50         if (n[0] >= base) {
  51             n[0] = 0;
  52             n.unshift(1);
  53             p++;
  54         }
  55     }
  56 }
  57
  58 /**
  59  * hints_parse converts a string that represents a natural number to an
  60  * int.  When hint_digits is non-null, it defines the base for conversion.
  61  */
  62 function hints_parse (str) {
  63     if (hint_digits) {
  64         var base = hint_digits.length;
  65         var n = 0;
  66         for (var i = 0, p = str.length - 1; p >= 0; i++, p--) {
  67             n += hint_digits.indexOf(str[i]) * Math.pow(base, p);
  68         }
  69         return n;
  70     } else
  71         return parseInt(str);
  72 }
  73
  74 /**
  75  * Register hints style sheet
  76  */
  77 const hints_stylesheet = "chrome://conkeror-gui/content/hints.css";
  78 register_user_stylesheet(hints_stylesheet);
  79
  80
  81 function hints_simple_text_match (text, pattern) {
  82     var pos = text.indexOf(pattern);
  83     if (pos == -1)
  84         return false;
  85     return [pos, pos + pattern.length];
  86 }
  87
  88 define_variable('hints_text_match', hints_simple_text_match,
  89     "A function which takes a string and a pattern (another string) "+
  90     "and returns an array of [start, end] indices if the pattern was "+
  91     "found in the string, or false if it was not.");
  92
  93
  94 /**
  95  *   In the hints interaction, a node can be selected either by typing
  96  * the number of its associated hint, or by typing substrings of the
  97  * text content of the node.  In the case of selecting by text
  98  * content, multiple substrings can be given by separating them with
  99  * spaces.
 100  */
 101 function hint_manager (window, xpath_expr, focused_frame, focused_element) {
 102     this.window = window;
 103     this.hints = [];
 104     this.valid_hints = [];
 105     this.xpath_expr = xpath_expr;
 106     this.focused_frame = focused_frame;
 107     this.focused_element = focused_element;
 108     this.last_selected_hint = null;
 109
 110     // Generate
 111     this.generate_hints();
 112 }
 113 hint_manager.prototype = {
 114     constructor: hint_manager,
 115     current_hint_string: "",
 116     current_hint_number: -1,
 117
 118     /**
 119      * Create an initially hidden hint span element absolutely
 120      * positioned over each element that matches
 121      * hint_xpath_expression.  This is done recursively for all frames
 122      * and iframes.  Information about the resulting hints are also
 123      * stored in the hints array.
 124      */
 125     generate_hints: function () {
 126         var topwin = this.window;
 127         var top_height = topwin.innerHeight;
 128         var top_width = topwin.innerWidth;
 129         var hints = this.hints;
 130         var xpath_expr = this.xpath_expr;
 131         var focused_frame_hint = null, focused_element_hint = null;
 132         var focused_frame = this.focused_frame;
 133         var focused_element = this.focused_element;
 134
 135         function helper (window, offsetX, offsetY) {
 136             var win_height = window.height;
 137             var win_width = window.width;
 138
 139             // Bounds
 140             var minX = offsetX < 0 ? -offsetX : 0;
 141             var minY = offsetY < 0 ? -offsetY : 0;
 142             var maxX = offsetX + win_width > top_width ? top_width - offsetX : top_width;
 143             var maxY = offsetY + win_height > top_height ? top_height - offsetY : top_height;
 144
 145             var scrollX = window.scrollX;
 146             var scrollY = window.scrollY;
 147
 148             var doc = window.document;
 149             if (! doc.documentElement)
 150                 return;
 151             var res = doc.evaluate(xpath_expr, doc, xpath_lookup_namespace,
 152                                    Ci.nsIDOMXPathResult.UNORDERED_NODE_SNAPSHOT_TYPE,
 153                                    null /* existing results */);
 154
 155             var base_node = doc.createElementNS(XHTML_NS, "span");
 156             base_node.className = "__conkeror_hint";
 157
 158             var fragment = doc.createDocumentFragment();
 159             var rect, elem, text, node, show_text;
 160             for (var j = 0; j < res.snapshotLength; j++) {
 161                 elem = res.snapshotItem(j);
 162                 rect = elem.getBoundingClientRect();
 163                 if (elem instanceof Ci.nsIDOMHTMLAreaElement) {
 164                     rect = { top: rect.top,
 165                              left: rect.left,
 166                              bottom: rect.bottom,
 167                              right: rect.right };
 168                     try {
 169                         var coords = elem.getAttribute("coords")
 170                             .match(/^\D*(-?\d+)\D+(-?\d+)/);
 171                         if (coords.length == 3) {
 172                             rect.left += parseInt(coords[1]);
 173                             rect.top += parseInt(coords[2]);
 174                         }
 175                     } catch (e) {}
 176                 }
 177                 if (!rect || rect.left > maxX || rect.right < minX || rect.top > maxY || rect.bottom < minY)
 178                     continue;
 179                 let style = topwin.getComputedStyle(elem, "");
 180                 if (style.display == "none" || style.visibility == "hidden")
 181                     continue;
 182                 if (! (elem instanceof Ci.nsIDOMHTMLAreaElement))
 183                     rect = elem.getClientRects()[0];
 184                 if (!rect)
 185                     continue;
 186                 var nchildren = elem.childNodes.length;
 187                 if (elem instanceof Ci.nsIDOMHTMLAnchorElement &&
 188                     rect.left == rect.right && rect.top == rect.bottom)
 189                 {
 190                     for (var c = 0; c < nchildren; ++c) {
 191                         var cc = elem.childNodes.item(c);
 192                         if (cc.getBoundingClientRect) {
 193                             rect = cc.getBoundingClientRect();
 194                             break;
 195                         }
 196                     }
 197                 }
 198                 show_text = false;
 199                 if (elem instanceof Ci.nsIDOMHTMLInputElement || elem instanceof Ci.nsIDOMHTMLTextAreaElement)
 200                     text = elem.value;
 201                 else if (elem instanceof Ci.nsIDOMHTMLSelectElement) {
 202                     if (elem.selectedIndex >= 0)
 203                         text = elem.item(elem.selectedIndex).text;
 204                     else
 205                         text = "";
 206                 } else if (elem instanceof Ci.nsIDOMHTMLFrameElement) {
 207                     text = elem.name ? elem.name : "";
 208                 } else if (/^\s*$/.test(elem.textContent) &&
 209                            nchildren == 1 &&
 210                            elem.childNodes.item(0) instanceof Ci.nsIDOMHTMLImageElement) {
 211                     text = elem.childNodes.item(0).alt;
 212                     show_text = true;
 213                 } else
 214                     text = elem.textContent;
 215
 216                 node = base_node.cloneNode(true);
 217                 node.style.left = (rect.left + scrollX) + "px";
 218                 node.style.top = (rect.top + scrollY) + "px";
 219                 fragment.appendChild(node);
 220
 221                 let hint = { text: text,
 222                              ltext: text.toLowerCase(),
 223                              elem: elem,
 224                              hint: node,
 225                              img_hint: null,
 226                              visible: false,
 227                              show_text: show_text };
 228                 if (elem.style) {
 229                     hint.saved_color = elem.style.color;
 230                     hint.saved_bgcolor = elem.style.backgroundColor;
 231                 }
 232                 hints.push(hint);
 233
 234                 if (elem == focused_element)
 235                     focused_element_hint = hint;
 236                 else if ((elem instanceof Ci.nsIDOMHTMLFrameElement ||
 237                           elem instanceof Ci.nsIDOMHTMLIFrameElement) &&
 238                          elem.contentWindow == focused_frame)
 239                     focused_frame_hint = hint;
 240             }
 241             doc.documentElement.appendChild(fragment);
 242
 243             /* Recurse into any IFRAME or FRAME elements */
 244             var frametag = "frame";
 245             while (true) {
 246                 var frames = doc.getElementsByTagName(frametag);
 247                 for (var i = 0, nframes = frames.length; i < nframes; ++i) {
 248                     elem = frames[i];
 249                     rect = elem.getBoundingClientRect();
 250                     if (!rect || rect.left > maxX || rect.right < minX || rect.top > maxY || rect.bottom < minY)
 251                         continue;
 252                     helper(elem.contentWindow, offsetX + rect.left, offsetY + rect.top);
 253                 }
 254                 if (frametag == "frame") frametag = "iframe"; else break;
 255             }
 256         }
 257         helper(topwin, 0, 0);
 258         this.last_selected_hint = focused_element_hint || focused_frame_hint;
 259     },
 260
 261     /* Updates valid_hints and also re-numbers and re-displays all hints. */
 262     update_valid_hints: function () {
 263         this.valid_hints = [];
 264         var cur_number = 1;
 265         if (hint_digits)
 266             var number_generator = hints_enumerate();
 267         var active_number = this.current_hint_number;
 268         var tokens = this.current_hint_string.split(" ");
 269         var case_sensitive = (this.current_hint_string !=
 270                               this.current_hint_string.toLowerCase());
 271         var rect, text, img_hint, doc, scrollX, scrollY;
 272     outer:
 273         for (var i = 0, h; (h = this.hints[i]); ++i) {
 274             if (case_sensitive)
 275                 text = h.text;
 276             else
 277                 text = h.ltext;
 278             for (var j = 0, ntokens = tokens.length; j < ntokens; ++j) {
 279                 if (! hints_text_match(text, tokens[j])) {
 280                     if (h.visible) {
 281                         h.visible = false;
 282                         h.hint.style.display = "none";
 283                         if (h.img_hint)
 284                             h.img_hint.style.display = "none";
 285                         if (h.saved_color != null) {
 286                             h.elem.style.backgroundColor = h.saved_bgcolor;
 287                             h.elem.style.color = h.saved_color;
 288                         }
 289                     }
 290                     continue outer;
 291                 }
 292             }
 293
 294             h.visible = true;
 295
 296             if (h == this.last_selected_hint && active_number == -1)
 297                 this.current_hint_number = active_number = cur_number;
 298
 299             var img_elem = null;
 300
 301             if (text == "" && h.elem.firstChild &&
 302                 h.elem.firstChild instanceof Ci.nsIDOMHTMLImageElement)
 303                 img_elem = h.elem.firstChild;
 304             else if (h.elem instanceof Ci.nsIDOMHTMLImageElement)
 305                 img_elem = h.elem;
 306
 307             if (img_elem) {
 308                 if (!h.img_hint) {
 309                     rect = img_elem.getBoundingClientRect();
 310                     if (rect) {
 311                         doc = h.elem.ownerDocument;
 312                         scrollX = doc.defaultView.scrollX;
 313                         scrollY = doc.defaultView.scrollY;
 314                         img_hint = doc.createElementNS(XHTML_NS, "span");
 315                         img_hint.className = "__conkeror_img_hint";
 316                         img_hint.style.left = (rect.left + scrollX) + "px";
 317                         img_hint.style.top = (rect.top + scrollY) + "px";
 318                         img_hint.style.width = (rect.right - rect.left) + "px";
 319                         img_hint.style.height = (rect.bottom - rect.top) + "px";
 320                         h.img_hint = img_hint;
 321                         doc.documentElement.appendChild(img_hint);
 322                     } else
 323                         img_elem = null;
 324                 }
 325                 if (img_elem) {
 326                     var bgcolor = (active_number == cur_number) ?
 327                         active_img_hint_background_color : img_hint_background_color;
 328                     h.img_hint.style.backgroundColor = bgcolor;
 329                     h.img_hint.style.display = "inline";
 330                 }
 331             }
 332
 333             if (!h.img_hint && h.elem.style)
 334                 h.elem.style.backgroundColor = (active_number == cur_number) ?
 335                     active_hint_background_color : hint_background_color;
 336
 337             if (h.elem.style)
 338                 h.elem.style.color = "black";
 339
 340             var label = "";
 341             if (hint_digits)
 342                 label = number_generator.next();
 343             else
 344                 label += cur_number;
 345             if (h.elem instanceof Ci.nsIDOMHTMLFrameElement) {
 346                 label +=  " " + text;
 347             } else if (h.show_text && !/^\s*$/.test(text)) {
 348                 let substrs = [[0,4]];
 349                 for (j = 0; j < ntokens; ++j) {
 350                     let m = hints_text_match(text, tokens[j]);
 351                     if (m == false) continue;
 352                     splice_range(substrs, m[0], m[1] + 2);
 353                 }
 354                 label += " " + substrs.map(function (x) {
 355                     return text.substring(x[0],Math.min(x[1], text.length));
 356                 }).join("..") + "..";
 357             }
 358             h.hint.textContent = label;
 359             h.hint.style.display = "inline";
 360             this.valid_hints.push(h);
 361             cur_number++;
 362         }
 363
 364         if (active_number == -1)
 365             this.select_hint(1);
 366     },
 367
 368     select_hint: function (index) {
 369         var old_index = this.current_hint_number;
 370         if (index == old_index)
 371             return;
 372         var vh = this.valid_hints;
 373         var vl = this.valid_hints.length;
 374         if (old_index >= 1 && old_index <= vl) {
 375             var h = vh[old_index - 1];
 376             if (h.img_hint)
 377                 h.img_hint.style.backgroundColor = img_hint_background_color;
 378             if (h.elem.style)
 379                 h.elem.style.backgroundColor = hint_background_color;
 380         }
 381         this.current_hint_number = index;
 382         this.last_selected_hint = null;
 383         if (index >= 1 && index <= vl) {
 384             h = vh[index - 1];
 385             if (h.img_hint)
 386                 h.img_hint.style.backgroundColor = active_img_hint_background_color;
 387             if (h.elem.style)
 388                 h.elem.style.backgroundColor = active_hint_background_color;
 389             this.last_selected_hint = h;
 390         }
 391     },
 392
 393     hide_hints: function () {
 394         for (var i = 0, h; h = this.hints[i]; ++i) {
 395             if (h.visible) {
 396                 h.visible = false;
 397                 if (h.saved_color != null) {
 398                     h.elem.style.color = h.saved_color;
 399                     h.elem.style.backgroundColor = h.saved_bgcolor;
 400                 }
 401                 if (h.img_hint)
 402                     h.img_hint.style.display = "none";
 403                 h.hint.style.display = "none";
 404             }
 405         }
 406     },
 407
 408     remove: function () {
 409         for (var i = 0, h; h = this.hints[i]; ++i) {
 410             if (h.visible && h.saved_color != null) {
 411                 h.elem.style.color = h.saved_color;
 412                 h.elem.style.backgroundColor = h.saved_bgcolor;
 413             }
 414             if (h.img_hint)
 415                 h.img_hint.parentNode.removeChild(h.img_hint);
 416             h.hint.parentNode.removeChild(h.hint);
 417         }
 418         this.hints = [];
 419         this.valid_hints = [];
 420     }
 421 };
 422
 423 /* Show panel with currently selected URL. */
 424 function hints_url_panel (hints, window) {
 425     var g = new dom_generator(window.document, XUL_NS);
 426
 427     var p = g.element("hbox", "class", "panel url", "flex", "0");
 428     g.element("label", p, "value", "URL:", "class", "url-panel-label");
 429     var url_value = g.element("label", p, "class", "url-panel-value",
 430                               "crop", "end", "flex", "1");
 431     window.minibuffer.insert_before(p);
 432
 433     p.update = function () {
 434         url_value.value = "";
 435         if (hints.manager && hints.manager.last_selected_hint) {
 436             var spec;
 437             try {
 438                 spec = load_spec(hints.manager.last_selected_hint.elem);
 439             } catch (e) {}
 440             if (spec) {
 441                 var uri = load_spec_uri_string(spec);
 442                 if (uri) url_value.value = uri;
 443             }
 444         }
 445     };
 446
 447     p.destroy = function () {
 448         this.parentNode.removeChild(this);
 449     };
 450
 451     return p;
 452 }
 453
 454 define_variable("hints_display_url_panel", false,
 455     "When selecting a hint, the URL can be displayed in a panel above "+
 456     "the minibuffer.  This is useful for confirming that the correct "+
 457     "link is selected and that the URL is not evil.  This option is "+
 458     "most useful when hints_auto_exit_delay is long or disabled.");
 459
 460 /**
 461  * keyword arguments:
 462  *
 463  * $prompt
 464  * $callback
 465  * $abort_callback
 466  */
 467 define_keywords("$keymap", "$auto", "$hint_xpath_expression", "$multiple");
 468 function hints_minibuffer_state (minibuffer, continuation, buffer) {
 469     keywords(arguments, $keymap = hint_keymap, $auto);
 470     basic_minibuffer_state.call(this, minibuffer, $prompt = arguments.$prompt,
 471                                 $keymap = arguments.$keymap);
 472     if (hints_display_url_panel)
 473         this.url_panel = hints_url_panel(this, buffer.window);
 474     this.original_prompt = arguments.$prompt;
 475     this.continuation = continuation;
 476     this.auto_exit = arguments.$auto ? true : false;
 477     this.xpath_expr = arguments.$hint_xpath_expression;
 478     this.auto_exit_timer_ID = null;
 479     this.multiple = arguments.$multiple;
 480     this.focused_element = buffer.focused_element;
 481     this.focused_frame = buffer.focused_frame;
 482 }
 483 hints_minibuffer_state.prototype = {
 484     constructor: hints_minibuffer_state,
 485     __proto__: basic_minibuffer_state.prototype,
 486     manager: null,
 487     typed_string: "",
 488     typed_number: "",
 489     load: function () {
 490         basic_minibuffer_state.prototype.load.call(this);
 491         if (!this.manager) {
 492             var buf = this.minibuffer.window.buffers.current;
 493             this.manager = new hint_manager(buf.top_frame, this.xpath_expr,
 494                                             this.focused_frame, this.focused_element);
 495         }
 496         this.manager.update_valid_hints();
 497         if (this.url_panel)
 498             this.url_panel.update();
 499     },
 500     clear_auto_exit_timer: function () {
 501         var window = this.minibuffer.window;
 502         if (this.auto_exit_timer_ID != null) {
 503             window.clearTimeout(this.auto_exit_timer_ID);
 504             this.auto_exit_timer_ID = null;
 505         }
 506     },
 507     unload: function () {
 508         this.clear_auto_exit_timer();
 509         this.manager.hide_hints();
 510         basic_minibuffer_state.prototype.unload.call(this);
 511     },
 512     destroy: function () {
 513         this.clear_auto_exit_timer();
 514         this.manager.remove();
 515         if (this.url_panel)
 516             this.url_panel.destroy();
 517         basic_minibuffer_state.prototype.destroy.call(this);
 518     },
 519     update_minibuffer: function (m) {
 520         if (this.typed_number.length > 0)
 521             m.prompt = this.original_prompt + " #" + this.typed_number;
 522         else
 523             m.prompt = this.original_prompt;
 524         if (this.url_panel)
 525             this.url_panel.update();
 526     },
 527
 528     handle_auto_exit: function (ambiguous) {
 529         var window = this.minibuffer.window;
 530         var num = this.manager.current_hint_number;
 531         if (!this.auto_exit)
 532             return;
 533         let s = this;
 534         let delay = ambiguous ? hints_ambiguous_auto_exit_delay : hints_auto_exit_delay;
 535         if (delay > 0)
 536             this.auto_exit_timer_ID = window.setTimeout(function () { hints_exit(window, s); },
 537                                                         delay);
 538     },
 539
 540     handle_input: function (m) {
 541         this.clear_auto_exit_timer();
 542         this.typed_number = "";
 543         this.typed_string = m._input_text;
 544         this.manager.current_hint_string = this.typed_string;
 545         this.manager.current_hint_number = -1;
 546         this.manager.update_valid_hints();
 547         if (this.manager.valid_hints.length == 1)
 548             this.handle_auto_exit(false /* unambiguous */);
 549         else if (this.manager.valid_hints.length > 1)
 550         this.handle_auto_exit(true /* ambiguous */);
 551         this.update_minibuffer(m);
 552     }
 553 };
 554
 555 define_variable("hints_auto_exit_delay", 0,
 556     "Delay (in milliseconds) after the most recent key stroke before a "+
 557     "sole matching element is automatically selected.  When zero, "+
 558     "automatic selection is disabled.  A value of 500 is a good "+
 559     "starting point for an average-speed typist.");
 560
 561 define_variable("hints_ambiguous_auto_exit_delay", 0,
 562     "Delay (in milliseconds) after the most recent key stroke before the "+
 563     "first of an ambiguous match is automatically selected.  If this is "+
 564     "set to 0, automatic selection in ambiguous matches is disabled.");
 565
 566
 567 define_key_match_predicate("match_hint_digit", "hint digit",
 568     function (e) {
 569         if (e.type != "keypress")
 570             return false;
 571         if (e.charCode == 48) //0 is special
 572             return true;
 573         if (hint_digits) {
 574             if (hint_digits.indexOf(String.fromCharCode(e.charCode)) > -1)
 575                 return true;
 576         } else if (e.charCode >= 49 && e.charCode <= 57)
 577             return true;
 578         return false;
 579     });
 580
 581 interactive("hints-handle-number",
 582     "This is the handler for numeric keys in hinting mode.  Normally, "+
 583     "that means '1' through '9' and '0', but the numeric base (and digits) "+
 584     "can be configured via the user variable 'hint_digits'.  No matter "+
 585     "what numeric base is in effect, the character '0' is special, and "+
 586     "will always be treated as a number 0, translated into the current "+
 587     "base if necessary.",
 588     function (I) {
 589         let s = I.minibuffer.check_state(hints_minibuffer_state);
 590         s.clear_auto_exit_timer();
 591         var ch = String.fromCharCode(I.event.charCode);
 592         if (hint_digits && ch == "0")
 593             ch = hint_digits[0];
 594         var auto_exit_ambiguous = null; // null -> no auto exit; false -> not ambiguous; true -> ambiguous
 595         s.typed_number += ch;
 596         s.manager.select_hint(hints_parse(s.typed_number));
 597         var num = s.manager.current_hint_number;
 598         if (num > 0 && num <= s.manager.valid_hints.length)
 599             auto_exit_ambiguous = num * 10 > s.manager.valid_hints.length ? false : true;
 600         else if (num == 0) {
 601             if (!s.multiple) {
 602                 hints_exit(I.window, s);
 603                 return;
 604             }
 605             auto_exit_ambiguous = false;
 606         }
 607         if (auto_exit_ambiguous !== null)
 608             s.handle_auto_exit(auto_exit_ambiguous);
 609         s.update_minibuffer(I.minibuffer);
 610     });
 611
 612 function hints_backspace (window, s) {
 613     let m = window.minibuffer;
 614     s.clear_auto_exit_timer();
 615     var l = s.typed_number.length;
 616     if (l > 0) {
 617         s.typed_number = s.typed_number.substring(0, --l);
 618         var num = l > 0 ? hints_parse(s.typed_number) : 1;
 619         s.manager.select_hint(num);
 620     } else if (s.typed_string.length > 0) {
 621         call_builtin_command(window, 'cmd_deleteCharBackward');
 622         s.typed_string = m._input_text;
 623         //m._set_selection();
 624         s.manager.current_hint_string = s.typed_string;
 625         s.manager.current_hint_number = -1;
 626         s.manager.update_valid_hints();
 627     }
 628     s.update_minibuffer(m);
 629 }
 630 interactive("hints-backspace", null,
 631     function (I) {
 632         hints_backspace(I.window, I.minibuffer.check_state(hints_minibuffer_state));
 633     });
 634
 635 function hints_next (window, s, count) {
 636     s.clear_auto_exit_timer();
 637     s.typed_number = "";
 638     var cur = s.manager.current_hint_number - 1;
 639     var vh = s.manager.valid_hints;
 640     var vl = s.manager.valid_hints.length;
 641     if (vl > 0) {
 642         cur = (cur + count) % vl;
 643         if (cur < 0)
 644             cur += vl;
 645         s.manager.select_hint(cur + 1);
 646     }
 647     s.update_minibuffer(window);
 648 }
 649 interactive("hints-next", null,
 650     function (I) {
 651         hints_next(I.window, I.minibuffer.check_state(hints_minibuffer_state), I.p);
 652     });
 653
 654 interactive("hints-previous", null,
 655     function (I) {
 656         hints_next(I.window, I.minibuffer.check_state(hints_minibuffer_state), -I.p);
 657     });
 658
 659 function hints_exit (window, s) {
 660     var cur = s.manager.current_hint_number;
 661     var elem = null;
 662     if (cur > 0 && cur <= s.manager.valid_hints.length)
 663         elem = s.manager.valid_hints[cur - 1].elem;
 664     else if (cur == 0)
 665         elem = window.buffers.current.top_frame;
 666     if (elem !== null) {
 667         var c = s.continuation;
 668         delete s.continuation;
 669         window.minibuffer.pop_state();
 670         if (c)
 671             c(elem);
 672     }
 673 }
 674
 675 interactive("hints-exit", null,
 676     function (I) {
 677         hints_exit(I.window, I.minibuffer.check_state(hints_minibuffer_state));
 678     });
 679
 680 interactive("hints-quote-next", null,
 681     function (I) {
 682         I.overlay_keymap = hint_quote_next_keymap;
 683     },
 684     $prefix);
 685
 686
 687 define_keywords("$buffer");
 688 minibuffer.prototype.read_hinted_element = function () {
 689     keywords(arguments);
 690     var buf = arguments.$buffer;
 691     var s = new hints_minibuffer_state(this, (yield CONTINUATION), buf, forward_keywords(arguments));
 692     this.push_state(s);
 693     var result = yield SUSPEND;
 694     yield co_return(result);
 695 };
 696
 697 provide("hints");