webkitgtk-2.16.5HEADwebkitgtk-2.16.5master

1 files changed, 618 insertions, 0 deletions

diff --git a/Source/WebInspectorUI/UserInterface/Controllers/CodeMirrorTokenTrackingController.js b/Source/WebInspectorUI/UserInterface/Controllers/CodeMirrorTokenTrackingController.js
new file mode 100644
index 000000000..4d4fdac99
--- /dev/null
+++ b/Source/WebInspectorUI/UserInterface/Controllers/CodeMirrorTokenTrackingController.js
@@ -0,0 +1,618 @@
+/*
+ * Copyright (C) 2013 Apple 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:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
+ * THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+WebInspector.CodeMirrorTokenTrackingController = class CodeMirrorTokenTrackingController extends WebInspector.Object
+{
+    constructor(codeMirror, delegate)
+    {
+        super();
+
+        console.assert(codeMirror);
+
+        this._codeMirror = codeMirror;
+        this._delegate = delegate || null;
+        this._mode = WebInspector.CodeMirrorTokenTrackingController.Mode.None;
+
+        this._mouseOverDelayDuration = 0;
+        this._mouseOutReleaseDelayDuration = 0;
+        this._classNameForHighlightedRange = null;
+
+        this._enabled = false;
+        this._tracking = false;
+        this._previousTokenInfo = null;
+        this._hoveredMarker = null;
+
+        const hidePopover = this._hidePopover.bind(this);
+
+        this._codeMirror.addKeyMap({
+            "Cmd-Enter": this._handleCommandEnterKey.bind(this),
+            "Esc": hidePopover
+        });
+
+        this._codeMirror.on("cursorActivity", hidePopover);
+    }
+
+    // Public
+
+    get delegate()
+    {
+        return this._delegate;
+    }
+
+    set delegate(x)
+    {
+        this._delegate = x;
+    }
+
+    get enabled()
+    {
+        return this._enabled;
+    }
+
+    set enabled(enabled)
+    {
+        if (this._enabled === enabled)
+            return;
+
+        this._enabled = enabled;
+
+        var wrapper = this._codeMirror.getWrapperElement();
+        if (enabled) {
+            wrapper.addEventListener("mouseenter", this);
+            wrapper.addEventListener("mouseleave", this);
+            this._updateHoveredTokenInfo({left: WebInspector.mouseCoords.x, top: WebInspector.mouseCoords.y});
+            this._startTracking();
+        } else {
+            wrapper.removeEventListener("mouseenter", this);
+            wrapper.removeEventListener("mouseleave", this);
+            this._stopTracking();
+        }
+    }
+
+    get mode()
+    {
+        return this._mode;
+    }
+
+    set mode(mode)
+    {
+        var oldMode = this._mode;
+
+        this._mode = mode || WebInspector.CodeMirrorTokenTrackingController.Mode.None;
+
+        if (oldMode !== this._mode && this._tracking && this._previousTokenInfo)
+            this._processNewHoveredToken(this._previousTokenInfo);
+    }
+
+    get mouseOverDelayDuration()
+    {
+        return this._mouseOverDelayDuration;
+    }
+
+    set mouseOverDelayDuration(x)
+    {
+        console.assert(x >= 0);
+        this._mouseOverDelayDuration = Math.max(x, 0);
+    }
+
+    get mouseOutReleaseDelayDuration()
+    {
+        return this._mouseOutReleaseDelayDuration;
+    }
+
+    set mouseOutReleaseDelayDuration(x)
+    {
+        console.assert(x >= 0);
+        this._mouseOutReleaseDelayDuration = Math.max(x, 0);
+    }
+
+    get classNameForHighlightedRange()
+    {
+        return this._classNameForHighlightedRange;
+    }
+
+    set classNameForHighlightedRange(x)
+    {
+        this._classNameForHighlightedRange = x || null;
+    }
+
+    get candidate()
+    {
+        return this._candidate;
+    }
+
+    get hoveredMarker()
+    {
+        return this._hoveredMarker;
+    }
+
+    set hoveredMarker(hoveredMarker)
+    {
+        this._hoveredMarker = hoveredMarker;
+    }
+
+    highlightLastHoveredRange()
+    {
+        if (this._candidate)
+            this.highlightRange(this._candidate.hoveredTokenRange);
+    }
+
+    highlightRange(range)
+    {
+        // Nothing to do if we're trying to highlight the same range.
+        if (this._codeMirrorMarkedText && this._codeMirrorMarkedText.className === this._classNameForHighlightedRange) {
+            var highlightedRange = this._codeMirrorMarkedText.find();
+            if (!highlightedRange)
+                return;
+            if (WebInspector.compareCodeMirrorPositions(highlightedRange.from, range.start) === 0 &&
+                WebInspector.compareCodeMirrorPositions(highlightedRange.to, range.end) === 0)
+                return;
+        }
+
+        this.removeHighlightedRange();
+
+        var className = this._classNameForHighlightedRange || "";
+        this._codeMirrorMarkedText = this._codeMirror.markText(range.start, range.end, {className});
+
+        window.addEventListener("mousemove", this, true);
+    }
+
+    removeHighlightedRange()
+    {
+        if (!this._codeMirrorMarkedText)
+            return;
+
+        this._codeMirrorMarkedText.clear();
+        this._codeMirrorMarkedText = null;
+
+        window.removeEventListener("mousemove", this, true);
+    }
+
+    // Private
+
+    _startTracking()
+    {
+        if (this._tracking)
+            return;
+
+        this._tracking = true;
+
+        var wrapper = this._codeMirror.getWrapperElement();
+        wrapper.addEventListener("mousemove", this, true);
+        wrapper.addEventListener("mouseout", this, false);
+        wrapper.addEventListener("mousedown", this, false);
+        wrapper.addEventListener("mouseup", this, false);
+        window.addEventListener("blur", this, true);
+    }
+
+    _stopTracking()
+    {
+        if (!this._tracking)
+            return;
+
+        this._tracking = false;
+        this._candidate = null;
+
+        var wrapper = this._codeMirror.getWrapperElement();
+        wrapper.removeEventListener("mousemove", this, true);
+        wrapper.removeEventListener("mouseout", this, false);
+        wrapper.removeEventListener("mousedown", this, false);
+        wrapper.removeEventListener("mouseup", this, false);
+        window.removeEventListener("blur", this, true);
+        window.removeEventListener("mousemove", this, true);
+
+        this._resetTrackingStates();
+    }
+
+    handleEvent(event)
+    {
+        switch (event.type) {
+        case "mouseenter":
+            this._mouseEntered(event);
+            break;
+        case "mouseleave":
+            this._mouseLeft(event);
+            break;
+        case "mousemove":
+            if (event.currentTarget === window)
+                this._mouseMovedWithMarkedText(event);
+            else
+                this._mouseMovedOverEditor(event);
+            break;
+        case "mouseout":
+            // Only deal with a mouseout event that has the editor wrapper as the target.
+            if (!event.currentTarget.contains(event.relatedTarget))
+                this._mouseMovedOutOfEditor(event);
+            break;
+        case "mousedown":
+            this._mouseButtonWasPressedOverEditor(event);
+            break;
+        case "mouseup":
+            this._mouseButtonWasReleasedOverEditor(event);
+            break;
+        case "blur":
+            this._windowLostFocus(event);
+            break;
+        }
+    }
+
+    _handleCommandEnterKey(codeMirror)
+    {
+        const tokenInfo = this._getTokenInfoForPosition(codeMirror.getCursor("head"));
+        tokenInfo.triggeredBy = WebInspector.CodeMirrorTokenTrackingController.TriggeredBy.Keyboard;
+        this._processNewHoveredToken(tokenInfo);
+    }
+
+    _hidePopover()
+    {
+        if (!this._candidate)
+            return CodeMirror.Pass;
+
+        if (this._delegate && typeof this._delegate.tokenTrackingControllerHighlightedRangeReleased === "function") {
+            const forceHidePopover = true;
+            this._delegate.tokenTrackingControllerHighlightedRangeReleased(this, forceHidePopover);
+        }
+    }
+
+    _mouseEntered(event)
+    {
+        if (!this._tracking)
+            this._startTracking();
+    }
+
+    _mouseLeft(event)
+    {
+        this._stopTracking();
+    }
+
+    _mouseMovedWithMarkedText(event)
+    {
+        if (this._candidate && this._candidate.triggeredBy === WebInspector.CodeMirrorTokenTrackingController.TriggeredBy.Keyboard)
+            return;
+
+        var shouldRelease = !event.target.classList.contains(this._classNameForHighlightedRange);
+        if (shouldRelease && this._delegate && typeof this._delegate.tokenTrackingControllerCanReleaseHighlightedRange === "function")
+            shouldRelease = this._delegate.tokenTrackingControllerCanReleaseHighlightedRange(this, event.target);
+
+        if (shouldRelease) {
+            if (!this._markedTextMouseoutTimer)
+                this._markedTextMouseoutTimer = setTimeout(this._markedTextIsNoLongerHovered.bind(this), this._mouseOutReleaseDelayDuration);
+            return;
+        }
+
+        if (this._markedTextMouseoutTimer)
+            clearTimeout(this._markedTextMouseoutTimer);
+
+        this._markedTextMouseoutTimer = 0;
+    }
+
+    _markedTextIsNoLongerHovered()
+    {
+        if (this._delegate && typeof this._delegate.tokenTrackingControllerHighlightedRangeReleased === "function")
+            this._delegate.tokenTrackingControllerHighlightedRangeReleased(this);
+
+        this._markedTextMouseoutTimer = 0;
+    }
+
+    _mouseMovedOverEditor(event)
+    {
+        this._updateHoveredTokenInfo({left: event.pageX, top: event.pageY});
+    }
+
+    _updateHoveredTokenInfo(mouseCoords)
+    {
+        // Get the position in the text and the token at that position.
+        var position = this._codeMirror.coordsChar(mouseCoords);
+        var token = this._codeMirror.getTokenAt(position);
+
+        if (!token || !token.type || !token.string) {
+            if (this._hoveredMarker && this._delegate && typeof this._delegate.tokenTrackingControllerMouseOutOfHoveredMarker === "function") {
+                if (!this._codeMirror.findMarksAt(position).includes(this._hoveredMarker.codeMirrorTextMarker))
+                    this._delegate.tokenTrackingControllerMouseOutOfHoveredMarker(this, this._hoveredMarker);
+            }
+
+            this._resetTrackingStates();
+            return;
+        }
+
+        // Stop right here if we're hovering the same token as we were last time.
+        if (this._previousTokenInfo &&
+            this._previousTokenInfo.position.line === position.line &&
+            this._previousTokenInfo.token.start === token.start &&
+            this._previousTokenInfo.token.end === token.end)
+            return;
+
+        // We have a new hovered token.
+        var tokenInfo = this._previousTokenInfo = this._getTokenInfoForPosition(position);
+
+        if (/\bmeta\b/.test(token.type)) {
+            let nextTokenPosition = Object.shallowCopy(position);
+            nextTokenPosition.ch = tokenInfo.token.end + 1;
+
+            let nextToken = this._codeMirror.getTokenAt(nextTokenPosition);
+            if (nextToken && nextToken.type && !/\bmeta\b/.test(nextToken.type)) {
+                console.assert(tokenInfo.token.end === nextToken.start);
+
+                tokenInfo.token.type = nextToken.type;
+                tokenInfo.token.string = tokenInfo.token.string + nextToken.string;
+                tokenInfo.token.end = nextToken.end;
+            }
+        } else {
+            let previousTokenPosition = Object.shallowCopy(position);
+            previousTokenPosition.ch = tokenInfo.token.start - 1;
+
+            let previousToken = this._codeMirror.getTokenAt(previousTokenPosition);
+            if (previousToken && previousToken.type && /\bmeta\b/.test(previousToken.type)) {
+                console.assert(tokenInfo.token.start === previousToken.end);
+
+                tokenInfo.token.string = previousToken.string + tokenInfo.token.string;
+                tokenInfo.token.start = previousToken.start;
+            }
+        }
+
+        if (this._tokenHoverTimer)
+            clearTimeout(this._tokenHoverTimer);
+
+        this._tokenHoverTimer = 0;
+
+        if (this._codeMirrorMarkedText || !this._mouseOverDelayDuration)
+            this._processNewHoveredToken(tokenInfo);
+        else
+            this._tokenHoverTimer = setTimeout(this._processNewHoveredToken.bind(this, tokenInfo), this._mouseOverDelayDuration);
+    }
+
+    _getTokenInfoForPosition(position)
+    {
+        var token = this._codeMirror.getTokenAt(position);
+        var innerMode = CodeMirror.innerMode(this._codeMirror.getMode(), token.state);
+        var codeMirrorModeName = innerMode.mode.alternateName || innerMode.mode.name;
+        return {
+            token,
+            position,
+            innerMode,
+            modeName: codeMirrorModeName
+        };
+    }
+
+    _mouseMovedOutOfEditor(event)
+    {
+        if (this._tokenHoverTimer)
+            clearTimeout(this._tokenHoverTimer);
+
+        this._tokenHoverTimer = 0;
+        this._previousTokenInfo = null;
+        this._selectionMayBeInProgress = false;
+    }
+
+    _mouseButtonWasPressedOverEditor(event)
+    {
+        this._selectionMayBeInProgress = true;
+    }
+
+    _mouseButtonWasReleasedOverEditor(event)
+    {
+        this._selectionMayBeInProgress = false;
+        this._mouseMovedOverEditor(event);
+
+        if (this._codeMirrorMarkedText && this._previousTokenInfo) {
+            var position = this._codeMirror.coordsChar({left: event.pageX, top: event.pageY});
+            var marks = this._codeMirror.findMarksAt(position);
+            for (var i = 0; i < marks.length; ++i) {
+                if (marks[i] === this._codeMirrorMarkedText) {
+                    if (this._delegate && typeof this._delegate.tokenTrackingControllerHighlightedRangeWasClicked === "function")
+                        this._delegate.tokenTrackingControllerHighlightedRangeWasClicked(this);
+
+                    break;
+                }
+            }
+        }
+    }
+
+    _windowLostFocus(event)
+    {
+        this._resetTrackingStates();
+    }
+
+    _processNewHoveredToken(tokenInfo)
+    {
+        console.assert(tokenInfo);
+
+        if (this._selectionMayBeInProgress)
+            return;
+
+        this._candidate = null;
+
+        switch (this._mode) {
+        case WebInspector.CodeMirrorTokenTrackingController.Mode.NonSymbolTokens:
+            this._candidate = this._processNonSymbolToken(tokenInfo);
+            break;
+        case WebInspector.CodeMirrorTokenTrackingController.Mode.JavaScriptExpression:
+        case WebInspector.CodeMirrorTokenTrackingController.Mode.JavaScriptTypeInformation:
+            this._candidate = this._processJavaScriptExpression(tokenInfo);
+            break;
+        case WebInspector.CodeMirrorTokenTrackingController.Mode.MarkedTokens:
+            this._candidate = this._processMarkedToken(tokenInfo);
+            break;
+        }
+
+        if (!this._candidate)
+            return;
+
+        this._candidate.triggeredBy = tokenInfo.triggeredBy;
+
+        if (this._markedTextMouseoutTimer)
+            clearTimeout(this._markedTextMouseoutTimer);
+
+        this._markedTextMouseoutTimer = 0;
+
+        if (this._delegate && typeof this._delegate.tokenTrackingControllerNewHighlightCandidate === "function")
+            this._delegate.tokenTrackingControllerNewHighlightCandidate(this, this._candidate);
+    }
+
+    _processNonSymbolToken(tokenInfo)
+    {
+        // Ignore any symbol tokens.
+        var type = tokenInfo.token.type;
+        if (!type)
+            return null;
+
+        var startPosition = {line: tokenInfo.position.line, ch: tokenInfo.token.start};
+        var endPosition = {line: tokenInfo.position.line, ch: tokenInfo.token.end};
+
+        return {
+            hoveredToken: tokenInfo.token,
+            hoveredTokenRange: {start: startPosition, end: endPosition},
+        };
+    }
+
+    _processJavaScriptExpression(tokenInfo)
+    {
+        // Only valid within JavaScript.
+        if (tokenInfo.modeName !== "javascript")
+            return null;
+
+        var startPosition = {line: tokenInfo.position.line, ch: tokenInfo.token.start};
+        var endPosition = {line: tokenInfo.position.line, ch: tokenInfo.token.end};
+
+        function tokenIsInRange(token, range)
+        {
+            return token.line >= range.start.line && token.ch >= range.start.ch &&
+                   token.line <= range.end.line && token.ch <= range.end.ch;
+        }
+
+        // If the hovered token is within a selection, use the selection as our expression.
+        if (this._codeMirror.somethingSelected()) {
+            var selectionRange = {
+                start: this._codeMirror.getCursor("start"),
+                end: this._codeMirror.getCursor("end")
+            };
+
+            if (tokenIsInRange(startPosition, selectionRange) || tokenIsInRange(endPosition, selectionRange)) {
+                return {
+                    hoveredToken: tokenInfo.token,
+                    hoveredTokenRange: selectionRange,
+                    expression: this._codeMirror.getSelection(),
+                    expressionRange: selectionRange,
+                };
+            }
+        }
+
+        // We only handle vars, definitions, properties, and the keyword 'this'.
+        var type = tokenInfo.token.type;
+        var isProperty = type.indexOf("property") !== -1;
+        var isKeyword = type.indexOf("keyword") !== -1;
+        if (!isProperty && !isKeyword && type.indexOf("variable") === -1 && type.indexOf("def") === -1)
+            return null;
+
+        // Not object literal property names, but yes if an object literal shorthand property, which is a variable.
+        let state = tokenInfo.innerMode.state;
+        if (isProperty && state.lexical && state.lexical.type === "}") {
+            // Peek ahead to see if the next token is "}" or ",". If it is, we are a shorthand and therefore a variable.
+            let shorthand = false;
+            let mode = tokenInfo.innerMode.mode;
+            let position = {line: tokenInfo.position.line, ch: tokenInfo.token.end};
+            WebInspector.walkTokens(this._codeMirror, mode, position, function(tokenType, string) {
+                if (tokenType)
+                    return false;
+                if (string === "(")
+                    return false;
+                if (string === "," || string === "}") {
+                    shorthand = true;
+                    return false;
+                }
+                return true;
+            });
+
+            if (!shorthand)
+                return null;
+        }
+
+        // Only the "this" keyword.
+        if (isKeyword && tokenInfo.token.string !== "this")
+            return null;
+
+        // Work out the full hovered expression.
+        var expression = tokenInfo.token.string;
+        var expressionStartPosition = {line: tokenInfo.position.line, ch: tokenInfo.token.start};
+        while (true) {
+            var token = this._codeMirror.getTokenAt(expressionStartPosition);
+            if (!token)
+                break;
+
+            var isDot = !token.type && token.string === ".";
+            var isExpression = token.type && token.type.includes("m-javascript");
+            if (!isDot && !isExpression)
+                break;
+
+            // Disallow operators. We want the hovered expression to be just a single operand.
+            // Also, some operators can modify values, such as pre-increment and assignment operators.
+            if (isExpression && token.type.includes("operator"))
+                break;
+
+            expression = token.string + expression;
+            expressionStartPosition.ch = token.start;
+        }
+
+        // Return the candidate for this token and expression.
+        return {
+            hoveredToken: tokenInfo.token,
+            hoveredTokenRange: {start: startPosition, end: endPosition},
+            expression,
+            expressionRange: {start: expressionStartPosition, end: endPosition},
+        };
+    }
+
+    _processMarkedToken(tokenInfo)
+    {
+        return this._processNonSymbolToken(tokenInfo);
+    }
+
+    _resetTrackingStates()
+    {
+        if (this._tokenHoverTimer)
+            clearTimeout(this._tokenHoverTimer);
+
+        this._tokenHoverTimer = 0;
+
+        this._selectionMayBeInProgress = false;
+        this._previousTokenInfo = null;
+        this.removeHighlightedRange();
+    }
+};
+
+WebInspector.CodeMirrorTokenTrackingController.JumpToSymbolHighlightStyleClassName = "jump-to-symbol-highlight";
+
+WebInspector.CodeMirrorTokenTrackingController.Mode = {
+    None: "none",
+    NonSymbolTokens: "non-symbol-tokens",
+    JavaScriptExpression: "javascript-expression",
+    JavaScriptTypeInformation: "javascript-type-information",
+    MarkedTokens: "marked-tokens"
+};
+
+WebInspector.CodeMirrorTokenTrackingController.TriggeredBy = {
+    Keyboard: "keyboard",
+    Hover: "hover"
+};