The Tor Browser: comparison browser/devtools/sourceeditor/autocomplete.js

comparison: browser/devtools/sourceeditor/autocomplete.js

browser/devtools/sourceeditor/autocomplete.js

branch: TOR_BUG_9701
changeset 15: b8a032363ba2

equal deleted inserted replaced

--1:000000000000
+:21fbb250e75e
+/* vim:set ts=2 sw=2 sts=2 et tw=80:
+* This Source Code Form is subject to the terms of the Mozilla Public
+* License, v. 2.0. If a copy of the MPL was not distributed with this
+* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+const cssAutoCompleter = require("devtools/sourceeditor/css-autocompleter");
+const { AutocompletePopup } = require("devtools/shared/autocomplete-popup");
+const privates = new WeakMap();
+/**
+* Prepares an editor instance for autocompletion, setting up the popup and the
+* CSS completer instance.
+*/
+function setupAutoCompletion(ctx, walker) {
+let { cm, ed, Editor } = ctx;
+let win = ed.container.contentWindow.wrappedJSObject;
+let completer = null;
+if (ed.config.mode == Editor.modes.css)
+completer = new cssAutoCompleter({walker: walker});
+let popup = new AutocompletePopup(win.parent.document, {
+position: "after_start",
+fixedWidth: true,
+theme: "auto",
+autoSelect: true
+});
+let cycle = (reverse) => {
+if (popup && popup.isOpen) {
+cycleSuggestions(ed, reverse == true);
+return;
+}
+return win.CodeMirror.Pass;
+};
+let keyMap = {
+"Tab": cycle,
+"Down": cycle,
+"Shift-Tab": cycle.bind(this, true),
+"Up": cycle.bind(this, true),
+"Enter": () => {
+if (popup && popup.isOpen) {
+if (!privates.get(ed).suggestionInsertedOnce) {
+privates.get(ed).insertingSuggestion = true;
+let {label, preLabel, text} = popup.getItemAtIndex(0);
+let cur = ed.getCursor();
+ed.replaceText(text.slice(preLabel.length), cur, cur);
+}
+popup.hidePopup();
+// This event is used in tests
+ed.emit("popup-hidden");
+return;
+}
+return win.CodeMirror.Pass;
+}
+};
+keyMap[Editor.accel("Space")] = cm => autoComplete(ctx);
+cm.addKeyMap(keyMap);
+cm.on("keydown", (cm, e) => onEditorKeypress(ctx, e));
+ed.on("change", () => autoComplete(ctx));
+ed.on("destroy", () => {
+cm.off("keydown", (cm, e) => onEditorKeypress(ctx, e));
+ed.off("change", () => autoComplete(ctx));
+popup.destroy();
+popup = null;
+completer = null;
+});
+privates.set(ed, {
+popup: popup,
+completer: completer,
+insertingSuggestion: false,
+suggestionInsertedOnce: false
+});
+}
+/**
+* Provides suggestions to autocomplete the current token/word being typed.
+*/
+function autoComplete({ ed, cm }) {
+let private = privates.get(ed);
+let { completer, popup } = private;
+if (!completer || private.insertingSuggestion || private.doNotAutocomplete) {
+private.insertingSuggestion = false;
+return;
+}
+let cur = ed.getCursor();
+completer.complete(cm.getRange({line: 0, ch: 0}, cur), cur)
+.then(suggestions => {
+if (!suggestions || !suggestions.length || suggestions[0].preLabel == null) {
+private.suggestionInsertedOnce = false;
+popup.hidePopup();
+ed.emit("after-suggest");
+return;
+}
+// The cursor is at the end of the currently entered part of the token, like
+// "backgr|" but we need to open the popup at the beginning of the character
+// "b". Thus we need to calculate the width of the entered part of the token
+// ("backgr" here). 4 comes from the popup's left padding.
+let cursorElement = cm.display.cursorDiv.querySelector(".CodeMirror-cursor");
+let left = suggestions[0].preLabel.length * cm.defaultCharWidth() + 4;
+popup.hidePopup();
+popup.setItems(suggestions);
+popup.openPopup(cursorElement, -1 * left, 0);
+private.suggestionInsertedOnce = false;
+// This event is used in tests.
+ed.emit("after-suggest");
+});
+}
+/**
+* Cycles through provided suggestions by the popup in a top to bottom manner
+* when `reverse` is not true. Opposite otherwise.
+*/
+function cycleSuggestions(ed, reverse) {
+let private = privates.get(ed);
+let { popup, completer } = private;
+let cur = ed.getCursor();
+private.insertingSuggestion = true;
+if (!private.suggestionInsertedOnce) {
+private.suggestionInsertedOnce = true;
+let firstItem;
+if (reverse) {
+firstItem = popup.getItemAtIndex(popup.itemCount - 1);
+popup.selectPreviousItem();
+} else {
+firstItem = popup.getItemAtIndex(0);
+if (firstItem.label == firstItem.preLabel && popup.itemCount > 1) {
+firstItem = popup.getItemAtIndex(1);
+popup.selectNextItem();
+}
+}
+if (popup.itemCount == 1)
+popup.hidePopup();
+ed.replaceText(firstItem.text.slice(firstItem.preLabel.length), cur, cur);
+} else {
+let fromCur = {
+line: cur.line,
+ch  : cur.ch - popup.selectedItem.text.length
+};
+if (reverse)
+popup.selectPreviousItem();
+else
+popup.selectNextItem();
+ed.replaceText(popup.selectedItem.text, fromCur, cur);
+}
+// This event is used in tests.
+ed.emit("suggestion-entered");
+}
+/**
+* onkeydown handler for the editor instance to prevent autocompleting on some
+* keypresses.
+*/
+function onEditorKeypress({ ed, Editor }, event) {
+let private = privates.get(ed);
+// Do not try to autocomplete with multiple selections.
+if (ed.hasMultipleSelections()) {
+private.doNotAutocomplete = true;
+private.popup.hidePopup();
+return;
+}
+if ((event.ctrlKey || event.metaKey) && event.keyCode == event.DOM_VK_SPACE) {
+// When Ctrl/Cmd + Space is pressed, two simultaneous keypresses are emitted
+// first one for just the Ctrl/Cmd and second one for combo. The first one
+// leave the private.doNotAutocomplete as true, so we have to make it false
+private.doNotAutocomplete = false;
+return;
+}
+if (event.ctrlKey || event.metaKey || event.altKey) {
+private.doNotAutocomplete = true;
+private.popup.hidePopup();
+return;
+}
+switch (event.keyCode) {
+case event.DOM_VK_RETURN:
+private.doNotAutocomplete = true;
+break;
+case event.DOM_VK_ESCAPE:
+if (private.popup.isOpen)
+event.preventDefault();
+case event.DOM_VK_LEFT:
+case event.DOM_VK_RIGHT:
+case event.DOM_VK_HOME:
+case event.DOM_VK_END:
+private.doNotAutocomplete = true;
+private.popup.hidePopup();
+break;
+case event.DOM_VK_BACK_SPACE:
+case event.DOM_VK_DELETE:
+if (ed.config.mode == Editor.modes.css)
+private.completer.invalidateCache(ed.getCursor().line)
+private.doNotAutocomplete = true;
+private.popup.hidePopup();
+break;
+default:
+private.doNotAutocomplete = false;
+}
+}
+/**
+* Returns the private popup. This method is used by tests to test the feature.
+*/
+function getPopup({ ed }) {
+return privates.get(ed).popup;
+}
+/**
+* Returns contextual information about the token covered by the caret if the
+* implementation of completer supports it.
+*/
+function getInfoAt({ ed }, caret) {
+let completer = privates.get(ed).completer;
+if (completer && completer.getInfoAt)
+return completer.getInfoAt(ed.getText(), caret);
+return null;
+}
+// Export functions
+module.exports.setupAutoCompletion = setupAutoCompletion;
+module.exports.getAutocompletionPopup = getPopup;
+module.exports.getInfoAt = getInfoAt;