DevTools: [CodeMirror] collapse single selection on esc key

Source/devtools/front_end/CodeMirrorTextEditor.js

 /*
  * Copyright (C) 2012 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 164 matching lines @@
     this._nestedUpdatesCounter = 0;
 
     this.element.addEventListener("focus", this._handleElementFocus.bind(this), false);
     this.element.addEventListener("keydown", this._handleKeyDown.bind(this), true);
     this.element.addEventListener("keydown", this._handlePostKeyDown.bind(this), false);
     this.element.tabIndex = 0;
 
     this._setupWhitespaceHighlight();
 }
 
-/** @typedef {{canceled: boolean, from: CodeMirror.Pos, to: CodeMirror.Pos, text: string, origin: string, cancel: function()}} */
+/** @typedef {{canceled: boolean, from: !CodeMirror.Pos, to: !CodeMirror.Pos, text: string, origin: string, cancel: function()}} */
 WebInspector.CodeMirrorTextEditor.BeforeChangeObject;
 
-/** @typedef {{from: CodeMirror.Pos, to: CodeMirror.Pos, origin: string, text: !Array.<string>, removed: !Array.<string>}} */
+/** @typedef {{from: !CodeMirror.Pos, to: !CodeMirror.Pos, origin: string, text: !Array.<string>, removed: !Array.<string>}} */
 WebInspector.CodeMirrorTextEditor.ChangeObject;
 
 WebInspector.CodeMirrorTextEditor.maxHighlightLength = 1000;
 
 /**
  * @param {!CodeMirror} codeMirror
  */
 WebInspector.CodeMirrorTextEditor.autocompleteCommand = function(codeMirror)
 {
     codeMirror._codeMirrorTextEditor._autocompleteController.autocomplete();
@@ skipping 58 matching lines @@
 
 CodeMirror.commands.redoAndReveal = function(codemirror)
 {
     var scrollInfo = codemirror.getScrollInfo();
     codemirror.execCommand("redo");
     var cursor = codemirror.getCursor("start");
     codemirror._codeMirrorTextEditor._innerRevealLine(cursor.line, scrollInfo);
     codemirror._codeMirrorTextEditor._autocompleteController.finishAutocomplete();
 }
 
 CodeMirror.commands.dismissMultipleSelections = function(codemirror)

[pfeldman, 2014/04/14 13:00:34]

Annotate?

 {
-    if (codemirror.getSelections().length <= 1)
-        return CodeMirror.Pass;
-    var range = codemirror.listSelections()[0];
-    codemirror.setSelection(range.anchor, range.head, {scroll: false});
-    codemirror._codeMirrorTextEditor._revealLine(range.anchor.line);
+    var selections = codemirror.listSelections();
+    var selection = selections[0];
+    if (selections.length === 1) {
+        if (WebInspector.CodeMirrorUtils.toRange(selection.anchor, selection.head).isEmpty())
+            return CodeMirror.Pass;
+        codemirror.setSelection(selection.anchor, selection.anchor, {scroll: false});
+        codemirror._codeMirrorTextEditor._revealLine(selection.anchor.line);
+        return;
+    }
+
+    codemirror.setSelection(selection.anchor, selection.head, {scroll: false});
+    codemirror._codeMirrorTextEditor._revealLine(selection.anchor.line);
 }
 
 WebInspector.CodeMirrorTextEditor.LongLineModeLineLengthThreshold = 2000;
 WebInspector.CodeMirrorTextEditor.MaximumNumberOfWhitespacesPerSingleSpan = 16;
 WebInspector.CodeMirrorTextEditor.MaxEditableTextSize = 1024 * 1024 * 10;
 
 WebInspector.CodeMirrorTextEditor.prototype = {
     _enableBracketMatchingIfNeeded: function()
     {
         this._codeMirror.setOption("autoCloseBrackets", WebInspector.settings.textEditorBracketMatching.get() ? { explode: false } : false);
@@ skipping 195 matching lines @@
     coordinatesToCursorPosition: function(x, y)
     {
         var element = document.elementFromPoint(x, y);
         if (!element || !element.isSelfOrDescendant(this._codeMirror.getWrapperElement()))
             return null;
         var gutterBox = this._codeMirror.getGutterElement().boxInWindow();
         if (x >= gutterBox.x && x <= gutterBox.x + gutterBox.width &&
             y >= gutterBox.y && y <= gutterBox.y + gutterBox.height)
             return null;
         var coords = this._codeMirror.coordsChar({left: x, top: y});
-        return this._toRange(coords, coords);
+        return WebInspector.CodeMirrorUtils.toRange(coords, coords);
     },
 
     /**
      * @param {number} lineNumber
      * @param {number} column
      * @return {?{startColumn: number, endColumn: number, type: string}}
      */
     tokenAtTextPosition: function(lineNumber, column)
     {
         if (lineNumber < 0 || lineNumber >= this._codeMirror.lineCount())
             return null;
         var token = this._codeMirror.getTokenAt(new CodeMirror.Pos(lineNumber, (column || 0) + 1));
         if (!token || !token.type)
             return null;
         return {
             startColumn: token.start,
             endColumn: token.end - 1,
             type: token.type
         };
     },
 
     /**
      * @param {!WebInspector.TextRange} textRange
      * @return {string}
      */
     copyRange: function(textRange)
     {
-        var pos = this._toPos(textRange.normalize());
+        var pos = WebInspector.CodeMirrorUtils.toPos(textRange.normalize());
         return this._codeMirror.getRange(pos.start, pos.end);
     },
 
     /**
      * @return {boolean}
      */
     isClean: function()
     {
         return this._codeMirror.isClean();
     },
@@ skipping 111 matching lines @@
     },
 
     /**
      * @param {!WebInspector.TextRange} range
      * @param {string} cssClass
      * @return {!Object}
      */
     highlightRange: function(range, cssClass)
     {
         cssClass = "CodeMirror-persist-highlight " + cssClass;
-        var pos = this._toPos(range);
+        var pos = WebInspector.CodeMirrorUtils.toPos(range);
         ++pos.end.ch;
         return this._codeMirror.markText(pos.start, pos.end, {
             className: cssClass,
             startStyle: cssClass + "-start",
             endStyle: cssClass + "-end"
         });
     },
 
     /**
      * @return {!Element}
@@ skipping 226 matching lines @@
         this._resizeEditor();
     },
 
     /**
      * @param {!WebInspector.TextRange} range
      * @param {string} text
      * @return {!WebInspector.TextRange}
      */
     editRange: function(range, text)
     {
-        var pos = this._toPos(range);
+        var pos = WebInspector.CodeMirrorUtils.toPos(range);
         this._codeMirror.replaceRange(text, pos.start, pos.end);
-        var newRange = this._toRange(pos.start, this._codeMirror.posFromIndex(this._codeMirror.indexFromPos(pos.start) + text.length));
+        var newRange = WebInspector.CodeMirrorUtils.toRange(pos.start, this._codeMirror.posFromIndex(this._codeMirror.indexFromPos(pos.start) + text.length));
         this._delegate.onTextChanged(range, newRange);
         if (WebInspector.settings.textEditorAutoDetectIndent.get())
             this._updateEditorIndentation();
         return newRange;
     },
 
     /**
      * @param {number} lineNumber
      * @param {number} column
      * @param {function(string):boolean} isWordChar
@@ skipping 13 matching lines @@
             ++wordEnd;
         return new WebInspector.TextRange(lineNumber, wordStart, lineNumber, wordEnd);
     },
 
     /**
      * @param {!WebInspector.CodeMirrorTextEditor.ChangeObject} changeObject
      * @return {{oldRange: !WebInspector.TextRange, newRange: !WebInspector.TextRange}}
      */
     _changeObjectToEditOperation: function(changeObject)
     {
-        var oldRange = this._toRange(changeObject.from, changeObject.to);
+        var oldRange = WebInspector.CodeMirrorUtils.toRange(changeObject.from, changeObject.to);
         var newRange = oldRange.clone();
         var linesAdded = changeObject.text.length;
         if (linesAdded === 0) {
             newRange.endLine = newRange.startLine;
             newRange.endColumn = newRange.startColumn;
         } else if (linesAdded === 1) {
             newRange.endLine = newRange.startLine;
             newRange.endColumn = newRange.startColumn + changeObject.text[0].length;
         } else {
             newRange.endLine = newRange.startLine + linesAdded - 1;
@@ skipping 29 matching lines @@
             var editInfo = this._changeObjectToEditOperation(changeObject);
             if (!this._muteTextChangedEvent)
                 this._delegate.onTextChanged(editInfo.oldRange, editInfo.newRange);
         }
     },
 
     _cursorActivity: function()
     {
         var start = this._codeMirror.getCursor("anchor");
         var end = this._codeMirror.getCursor("head");
-        this._delegate.selectionChanged(this._toRange(start, end));
+        this._delegate.selectionChanged(WebInspector.CodeMirrorUtils.toRange(start, end));
         if (!this._tokenHighlighter.highlightedRegex())
             this._codeMirror.operation(this._tokenHighlighter.highlightSelectedTokens.bind(this._tokenHighlighter));
     },
 
     /**
      * @param {!CodeMirror} codeMirror
      * @param {{ranges: !Array.<{head: !CodeMirror.Pos, anchor: !CodeMirror.Pos}>}} selection
      */
     _beforeSelectionChange: function(codeMirror, selection)
     {
         this._selectNextOccurrenceController.selectionWillChange();
         if (!this._isHandlingMouseDownEvent)
             return;
         if (!selection.ranges.length)
             return;
         var primarySelection = selection.ranges[0];
-        this._reportJump(this.selection(), this._toRange(primarySelection.anchor, primarySelection.head));
+        this._reportJump(this.selection(), WebInspector.CodeMirrorUtils.toRange(primarySelection.anchor, primarySelection.head));
     },
 
     /**
      * @param {?WebInspector.TextRange} from
      * @param {?WebInspector.TextRange} to
      */
     _reportJump: function(from, to)
     {
         if (from && to && from.equal(to))
             return;
@@ skipping 41 matching lines @@
     },
 
     /**
      * @return {!WebInspector.TextRange}
      */
     selection: function()
     {
         var start = this._codeMirror.getCursor("anchor");
         var end = this._codeMirror.getCursor("head");
 
-        return this._toRange(start, end);
+        return WebInspector.CodeMirrorUtils.toRange(start, end);
     },
 
     /**
      * @return {!Array.<!WebInspector.TextRange>}
      */
     selections: function()
     {
         var selectionList = this._codeMirror.listSelections();
         var result = [];
         for (var i = 0; i < selectionList.length; ++i) {
             var selection = selectionList[i];
-            result.push(this._toRange(selection.anchor, selection.head));
+            result.push(WebInspector.CodeMirrorUtils.toRange(selection.anchor, selection.head));
         }
         return result;
     },
 
     /**
      * @return {?WebInspector.TextRange}
      */
     lastSelection: function()
     {
         return this._lastSelection;
     },
 
     /**
      * @param {!WebInspector.TextRange} textRange
      */
     setSelection: function(textRange)
     {
         this._lastSelection = textRange;
-        var pos = this._toPos(textRange);
+        var pos = WebInspector.CodeMirrorUtils.toPos(textRange);
         this._codeMirror.setSelection(pos.start, pos.end);
     },
 
     /**
      * @param {!Array.<!WebInspector.TextRange>} ranges
      * @param {number=} primarySelectionIndex
      */
     setSelections: function(ranges, primarySelectionIndex)
     {
         var selections = [];
         for (var i = 0; i < ranges.length; ++i) {
-            var selection = this._toPos(ranges[i]);
+            var selection = WebInspector.CodeMirrorUtils.toPos(ranges[i]);
             selections.push({
                 anchor: selection.start,
                 head: selection.end
             });
         }
         primarySelectionIndex = primarySelectionIndex || 0;
         this._codeMirror.setSelections(selections, primarySelectionIndex, { scroll: false });
     },
 
     /**
@@ skipping 32 matching lines @@
         return this._codeMirror.getValue().replace(/\n/g, this._lineSeparator);
     },
 
     /**
      * @return {!WebInspector.TextRange}
      */
     range: function()
     {
         var lineCount = this.linesCount;
         var lastLine = this._codeMirror.getLine(lineCount - 1);
-        return this._toRange(new CodeMirror.Pos(0, 0), new CodeMirror.Pos(lineCount - 1, lastLine.length));
+        return WebInspector.CodeMirrorUtils.toRange(new CodeMirror.Pos(0, 0), new CodeMirror.Pos(lineCount - 1, lastLine.length));
     },
 
     /**
      * @param {number} lineNumber
      * @return {string}
      */
     line: function(lineNumber)
     {
         return this._codeMirror.getLine(lineNumber);
     },
@@ skipping 40 matching lines @@
     removeAttribute: function(line, name)
     {
         if (line < 0 || line >= this._codeMirror.lineCount())
             return;
         var handle = this._codeMirror.getLineHandle(line);
         if (handle && handle.attributes)
             delete handle.attributes[name];
     },
 
     /**
-     * @param {!WebInspector.TextRange} range
-     * @return {!{start: !CodeMirror.Pos, end: !CodeMirror.Pos}}
-     */
-    _toPos: function(range)
-    {
-        return {
-            start: new CodeMirror.Pos(range.startLine, range.startColumn),
-            end: new CodeMirror.Pos(range.endLine, range.endColumn)
-        }
-    },
-
-    _toRange: function(start, end)
-    {
-        return new WebInspector.TextRange(start.line, start.ch, end.line, end.ch);
-    },
-
-    /**
      * @param {number} lineNumber
      * @param {number} columnNumber
      * @return {!WebInspector.TextEditorPositionHandle}
      */
     textEditorPositionHandle: function(lineNumber, columnNumber)
     {
         return new WebInspector.CodeMirrorPositionHandle(this._codeMirror, new CodeMirror.Pos(lineNumber, columnNumber));
     },
 
     __proto__: WebInspector.VBox.prototype
@@ skipping 69 matching lines @@
             this._codeMirror.addLineClass(selectionStart.line, "wrap", "cm-line-with-selection");
         if (this._highlightRegex === oldRegex) {
             // Do not re-add overlay mode if regex did not change for better performance.
             if (this._highlightDescriptor)
                 this._highlightDescriptor.selectionStart = selectionStart;
         } else {
             this._removeHighlight();
             this._setHighlighter(this._searchHighlighter.bind(this, this._highlightRegex), selectionStart);
         }
         if (this._highlightRange) {
-            var pos = WebInspector.CodeMirrorTextEditor.prototype._toPos(this._highlightRange);
+            var pos = WebInspector.CodeMirrorUtils.toPos(this._highlightRange);
             this._searchResultMarker = this._codeMirror.markText(pos.start, pos.end, {className: "cm-column-with-selection"});
         }
     },
 
     /**
      * @return {!RegExp|undefined}
      */
     highlightedRegex: function()
     {
         return this._highlightRegex;
@@ skipping 801 matching lines @@
     var backgroundColorRule = backgroundColor ? ".CodeMirror .CodeMirror-selected { background-color: " + backgroundColor + ";}" : "";
     var foregroundColor = InspectorFrontendHost.getSelectionForegroundColor();
     var foregroundColorRule = foregroundColor ? ".CodeMirror .CodeMirror-selectedtext:not(.CodeMirror-persist-highlight) { color: " + foregroundColor + "!important;}" : "";
     if (!foregroundColorRule && !backgroundColorRule)
         return;
 
     var style = document.createElement("style");
     style.textContent = backgroundColorRule + foregroundColorRule;
     document.head.appendChild(style);
 })();