| /* |
| * Copyright (C) 2013, 2015-2016 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. |
| */ |
| |
| WI.TimelineOverview = class TimelineOverview extends WI.View |
| { |
| constructor(timelineRecording) |
| { |
| super(); |
| |
| console.assert(timelineRecording instanceof WI.TimelineRecording); |
| |
| this._timelinesViewModeSettings = this._createViewModeSettings(WI.TimelineOverview.ViewMode.Timelines, WI.TimelineOverview.MinimumDurationPerPixel, WI.TimelineOverview.MaximumDurationPerPixel, 0.01, 0, 15); |
| this._instrumentTypes = WI.TimelineManager.availableTimelineTypes(); |
| |
| if (WI.FPSInstrument.supported()) { |
| let minimumDurationPerPixel = 1 / WI.TimelineRecordFrame.MaximumWidthPixels; |
| let maximumDurationPerPixel = 1 / WI.TimelineRecordFrame.MinimumWidthPixels; |
| this._renderingFramesViewModeSettings = this._createViewModeSettings(WI.TimelineOverview.ViewMode.RenderingFrames, minimumDurationPerPixel, maximumDurationPerPixel, minimumDurationPerPixel, 0, 100); |
| } |
| |
| this._recording = timelineRecording; |
| this._recording.addEventListener(WI.TimelineRecording.Event.InstrumentAdded, this._instrumentAdded, this); |
| this._recording.addEventListener(WI.TimelineRecording.Event.InstrumentRemoved, this._instrumentRemoved, this); |
| this._recording.addEventListener(WI.TimelineRecording.Event.MarkerAdded, this._markerAdded, this); |
| this._recording.addEventListener(WI.TimelineRecording.Event.Reset, this._recordingReset, this); |
| |
| this.element.classList.add("timeline-overview"); |
| this._updateWheelAndGestureHandlers(); |
| |
| this._graphsContainerView = new WI.View; |
| this._graphsContainerView.element.classList.add("graphs-container"); |
| this._graphsContainerView.element.addEventListener("click", this._handleGraphsContainerClick.bind(this)); |
| this.addSubview(this._graphsContainerView); |
| |
| this._selectedTimelineRecord = null; |
| this._overviewGraphsByTypeMap = new Map; |
| |
| this._editInstrumentsButton = new WI.ActivateButtonNavigationItem("toggle-edit-instruments", WI.UIString("Edit configuration"), WI.UIString("Save configuration")); |
| this._editInstrumentsButton.addEventListener(WI.ButtonNavigationItem.Event.Clicked, this._toggleEditingInstruments, this); |
| this._editingInstruments = false; |
| this._updateEditInstrumentsButton(); |
| |
| let instrumentsNavigationBar = new WI.NavigationBar; |
| instrumentsNavigationBar.element.classList.add("timelines"); |
| instrumentsNavigationBar.addNavigationItem(new WI.FlexibleSpaceNavigationItem); |
| instrumentsNavigationBar.addNavigationItem(this._editInstrumentsButton); |
| this.addSubview(instrumentsNavigationBar); |
| |
| this._timelinesTreeOutline = new WI.TreeOutline; |
| this._timelinesTreeOutline.element.classList.add("timelines"); |
| this._timelinesTreeOutline.disclosureButtons = false; |
| this._timelinesTreeOutline.large = true; |
| this._timelinesTreeOutline.addEventListener(WI.TreeOutline.Event.SelectionDidChange, this._timelinesTreeSelectionDidChange, this); |
| this.element.appendChild(this._timelinesTreeOutline.element); |
| |
| this._treeElementsByTypeMap = new Map; |
| |
| this._timelineRuler = new WI.TimelineRuler; |
| this._timelineRuler.allowsClippedLabels = true; |
| this._timelineRuler.allowsTimeRangeSelection = true; |
| this._timelineRuler.element.addEventListener("mousedown", this._timelineRulerMouseDown.bind(this)); |
| this._timelineRuler.element.addEventListener("click", this._timelineRulerMouseClicked.bind(this)); |
| this._timelineRuler.addEventListener(WI.TimelineRuler.Event.TimeRangeSelectionChanged, this._timeRangeSelectionChanged, this); |
| this.addSubview(this._timelineRuler); |
| |
| this._stoppingTimeMarker = null; |
| this._currentTimeMarker = new WI.TimelineMarker(0, WI.TimelineMarker.Type.CurrentTime); |
| this._timelineRuler.addMarker(this._currentTimeMarker); |
| |
| this._scrollContainerElement = document.createElement("div"); |
| this._scrollContainerElement.classList.add("scroll-container"); |
| this._scrollContainerElement.addEventListener("scroll", this._handleScrollEvent.bind(this)); |
| this.element.appendChild(this._scrollContainerElement); |
| |
| this._scrollWidthSizer = document.createElement("div"); |
| this._scrollWidthSizer.classList.add("scroll-width-sizer"); |
| this._scrollContainerElement.appendChild(this._scrollWidthSizer); |
| |
| this._startTime = 0; |
| this._currentTime = 0; |
| this._revealCurrentTime = false; |
| this._endTime = 0; |
| this._pixelAlignDuration = false; |
| this._mouseWheelDelta = 0; |
| this._cachedScrollContainerWidth = NaN; |
| this._timelineRulerSelectionChanged = false; |
| this._viewMode = WI.TimelineOverview.ViewMode.Timelines; |
| this._selectedTimeline = null; |
| |
| for (let instrument of this._recording.instruments) |
| this._instrumentAdded(instrument); |
| |
| if (!WI.timelineManager.isCapturingPageReload()) |
| this._resetSelection(); |
| |
| this._viewModeDidChange(); |
| |
| WI.timelineManager.addEventListener(WI.TimelineManager.Event.CapturingStateChanged, this._handleTimelineCapturingStateChanged, this); |
| WI.timelineManager.addEventListener(WI.TimelineManager.Event.RecordingImported, this._recordingImported, this); |
| } |
| |
| // Import / Export |
| |
| exportData() |
| { |
| let json = { |
| secondsPerPixel: this.secondsPerPixel, |
| scrollStartTime: this.scrollStartTime, |
| selectionStartTime: this.selectionStartTime, |
| selectionDuration: this.selectionDuration, |
| }; |
| |
| if (this._selectedTimeline) |
| json.selectedTimelineType = this._selectedTimeline.type; |
| |
| return json; |
| } |
| |
| // Public |
| |
| get selectedTimeline() |
| { |
| return this._selectedTimeline; |
| } |
| |
| set selectedTimeline(x) |
| { |
| if (this._editingInstruments) |
| return; |
| |
| if (this._selectedTimeline === x) |
| return; |
| |
| this._selectedTimeline = x; |
| if (this._selectedTimeline) { |
| let treeElement = this._treeElementsByTypeMap.get(this._selectedTimeline.type); |
| console.assert(treeElement, "Missing tree element for timeline", this._selectedTimeline); |
| |
| let omitFocus = true; |
| let wasSelectedByUser = false; |
| treeElement.select(omitFocus, wasSelectedByUser); |
| } else if (this._timelinesTreeOutline.selectedTreeElement) |
| this._timelinesTreeOutline.selectedTreeElement.deselect(); |
| } |
| |
| get editingInstruments() |
| { |
| return this._editingInstruments; |
| } |
| |
| get viewMode() |
| { |
| return this._viewMode; |
| } |
| |
| set viewMode(x) |
| { |
| if (this._editingInstruments) |
| return; |
| |
| if (this._viewMode === x) |
| return; |
| |
| this._viewMode = x; |
| this._viewModeDidChange(); |
| } |
| |
| get startTime() |
| { |
| return this._startTime; |
| } |
| |
| set startTime(x) |
| { |
| x = x || 0; |
| |
| if (this._startTime === x) |
| return; |
| |
| if (this._viewMode !== WI.TimelineOverview.ViewMode.RenderingFrames) { |
| let selectionOffset = this.selectionStartTime - this._startTime; |
| this.selectionStartTime = selectionOffset + x; |
| } |
| |
| this._startTime = x; |
| |
| this.needsLayout(); |
| } |
| |
| get currentTime() |
| { |
| return this._currentTime; |
| } |
| |
| set currentTime(x) |
| { |
| x = x || 0; |
| |
| if (this._currentTime === x) |
| return; |
| |
| this._currentTime = x; |
| this._revealCurrentTime = true; |
| |
| this.needsLayout(); |
| } |
| |
| get secondsPerPixel() |
| { |
| return this._currentSettings.durationPerPixelSetting.value; |
| } |
| |
| set secondsPerPixel(x) |
| { |
| x = Math.min(this._currentSettings.maximumDurationPerPixel, Math.max(this._currentSettings.minimumDurationPerPixel, x)); |
| |
| if (this.secondsPerPixel === x) |
| return; |
| |
| if (this._pixelAlignDuration) { |
| x = 1 / Math.round(1 / x); |
| if (this.secondsPerPixel === x) |
| return; |
| } |
| |
| this._currentSettings.durationPerPixelSetting.value = x; |
| |
| this.needsLayout(); |
| } |
| |
| get pixelAlignDuration() |
| { |
| return this._pixelAlignDuration; |
| } |
| |
| set pixelAlignDuration(x) |
| { |
| if (this._pixelAlignDuration === x) |
| return; |
| |
| this._mouseWheelDelta = 0; |
| this._pixelAlignDuration = x; |
| if (this._pixelAlignDuration) |
| this.secondsPerPixel = 1 / Math.round(1 / this.secondsPerPixel); |
| } |
| |
| get endTime() |
| { |
| return this._endTime; |
| } |
| |
| set endTime(x) |
| { |
| x = x || 0; |
| |
| if (this._endTime === x) |
| return; |
| |
| this._endTime = x; |
| |
| this.needsLayout(); |
| } |
| |
| get scrollStartTime() |
| { |
| return this._currentSettings.scrollStartTime; |
| } |
| |
| set scrollStartTime(x) |
| { |
| x = x || 0; |
| |
| if (this.scrollStartTime === x) |
| return; |
| |
| this._currentSettings.scrollStartTime = x; |
| |
| this.needsLayout(); |
| } |
| |
| get scrollContainerWidth() |
| { |
| return this._cachedScrollContainerWidth; |
| } |
| |
| get visibleDuration() |
| { |
| if (isNaN(this._cachedScrollContainerWidth)) { |
| this._cachedScrollContainerWidth = this._scrollContainerElement.offsetWidth; |
| if (!this._cachedScrollContainerWidth) |
| this._cachedScrollContainerWidth = NaN; |
| } |
| |
| return this._cachedScrollContainerWidth * this.secondsPerPixel; |
| } |
| |
| get selectionStartTime() |
| { |
| return this._timelineRuler.selectionStartTime; |
| } |
| |
| set selectionStartTime(x) |
| { |
| x = x || 0; |
| |
| if (this._timelineRuler.selectionStartTime === x) |
| return; |
| |
| let selectionDuration = this.selectionDuration; |
| this._timelineRuler.selectionStartTime = x; |
| this._timelineRuler.selectionEndTime = x + selectionDuration; |
| } |
| |
| get selectionDuration() |
| { |
| return this._timelineRuler.selectionEndTime - this._timelineRuler.selectionStartTime; |
| } |
| |
| set selectionDuration(x) |
| { |
| x = Math.max(this._timelineRuler.minimumSelectionDuration, x); |
| |
| this._timelineRuler.selectionEndTime = this._timelineRuler.selectionStartTime + x; |
| } |
| |
| get height() |
| { |
| let height = 0; |
| for (let overviewGraph of this._overviewGraphsByTypeMap.values()) { |
| if (overviewGraph.visible) |
| height += overviewGraph.height; |
| } |
| return height; |
| } |
| |
| get visible() |
| { |
| return this._visible; |
| } |
| |
| shown() |
| { |
| this._visible = true; |
| |
| for (let [type, overviewGraph] of this._overviewGraphsByTypeMap) { |
| if (this._canShowTimelineType(type)) |
| overviewGraph.shown(); |
| } |
| |
| this.updateLayout(WI.View.LayoutReason.Resize); |
| } |
| |
| hidden() |
| { |
| this._visible = false; |
| |
| for (let overviewGraph of this._overviewGraphsByTypeMap.values()) |
| overviewGraph.hidden(); |
| |
| this.hideScanner(); |
| } |
| |
| closed() |
| { |
| WI.timelineManager.removeEventListener(null, null, this); |
| |
| super.closed(); |
| } |
| |
| reset() |
| { |
| this._selectedTimelineRecord = null; |
| for (let overviewGraph of this._overviewGraphsByTypeMap.values()) |
| overviewGraph.reset(); |
| |
| this._mouseWheelDelta = 0; |
| |
| this._resetSelection(); |
| } |
| |
| revealMarker(marker) |
| { |
| this.scrollStartTime = marker.time - (this.visibleDuration / 2); |
| } |
| |
| recordWasFiltered(timeline, record, filtered) |
| { |
| let overviewGraph = this._overviewGraphsByTypeMap.get(timeline.type); |
| console.assert(overviewGraph, "Missing overview graph for timeline type " + timeline.type); |
| if (!overviewGraph) |
| return; |
| |
| console.assert(overviewGraph.visible, "Record filtered in hidden overview graph", record); |
| |
| overviewGraph.recordWasFiltered(record, filtered); |
| } |
| |
| selectRecord(timeline, record) |
| { |
| let overviewGraph = this._overviewGraphsByTypeMap.get(timeline.type); |
| console.assert(overviewGraph, "Missing overview graph for timeline type " + timeline.type); |
| if (!overviewGraph) |
| return; |
| |
| console.assert(overviewGraph.visible, "Record selected in hidden overview graph", record); |
| |
| overviewGraph.selectedRecord = record; |
| } |
| |
| showScanner(time) |
| { |
| this._timelineRuler.showScanner(time); |
| } |
| |
| hideScanner() |
| { |
| this._timelineRuler.hideScanner(); |
| } |
| |
| updateLayoutIfNeeded(layoutReason) |
| { |
| if (this.layoutPending) { |
| super.updateLayoutIfNeeded(layoutReason); |
| return; |
| } |
| |
| this._timelineRuler.updateLayoutIfNeeded(layoutReason); |
| |
| for (let overviewGraph of this._overviewGraphsByTypeMap.values()) { |
| if (overviewGraph.visible) |
| overviewGraph.updateLayoutIfNeeded(layoutReason); |
| } |
| } |
| |
| discontinuitiesInTimeRange(startTime, endTime) |
| { |
| return this._recording.discontinuitiesInTimeRange(startTime, endTime); |
| } |
| |
| // Protected |
| |
| get timelineRuler() |
| { |
| return this._timelineRuler; |
| } |
| |
| layout() |
| { |
| let startTime = this._startTime; |
| let endTime = this._endTime; |
| let currentTime = this._currentTime; |
| if (this._viewMode === WI.TimelineOverview.ViewMode.RenderingFrames) { |
| let renderingFramesTimeline = this._recording.timelines.get(WI.TimelineRecord.Type.RenderingFrame); |
| console.assert(renderingFramesTimeline, "Recoring missing rendering frames timeline"); |
| |
| startTime = 0; |
| endTime = renderingFramesTimeline.records.length; |
| currentTime = endTime; |
| } |
| |
| // Calculate the required width based on the duration and seconds per pixel. |
| let duration = endTime - startTime; |
| let newWidth = Math.ceil(duration / this.secondsPerPixel); |
| |
| // Update all relevant elements to the new required width. |
| this._updateElementWidth(this._scrollWidthSizer, newWidth); |
| |
| this._currentTimeMarker.time = currentTime; |
| |
| if (this._revealCurrentTime) { |
| this.revealMarker(this._currentTimeMarker); |
| this._revealCurrentTime = false; |
| } |
| |
| const visibleDuration = this.visibleDuration; |
| |
| // Clamp the scroll start time to match what the scroll bar would allow. |
| let scrollStartTime = Math.min(this.scrollStartTime, endTime - visibleDuration); |
| scrollStartTime = Math.max(startTime, scrollStartTime); |
| |
| this._timelineRuler.zeroTime = startTime; |
| this._timelineRuler.startTime = scrollStartTime; |
| this._timelineRuler.secondsPerPixel = this.secondsPerPixel; |
| |
| if (!this._dontUpdateScrollLeft) { |
| this._ignoreNextScrollEvent = true; |
| let scrollLeft = Math.ceil((scrollStartTime - startTime) / this.secondsPerPixel); |
| if (scrollLeft) |
| this._scrollContainerElement.scrollLeft = scrollLeft; |
| } |
| |
| for (let overviewGraph of this._overviewGraphsByTypeMap.values()) { |
| if (!overviewGraph.visible) |
| continue; |
| |
| overviewGraph.zeroTime = startTime; |
| overviewGraph.startTime = scrollStartTime; |
| overviewGraph.currentTime = currentTime; |
| overviewGraph.endTime = scrollStartTime + visibleDuration; |
| } |
| } |
| |
| sizeDidChange() |
| { |
| this._cachedScrollContainerWidth = NaN; |
| } |
| |
| // Private |
| |
| _updateElementWidth(element, newWidth) |
| { |
| var currentWidth = parseInt(element.style.width); |
| if (currentWidth !== newWidth) |
| element.style.width = newWidth + "px"; |
| } |
| |
| _handleScrollEvent(event) |
| { |
| if (this._ignoreNextScrollEvent) { |
| this._ignoreNextScrollEvent = false; |
| return; |
| } |
| |
| this._dontUpdateScrollLeft = true; |
| |
| let scrollOffset = this._scrollContainerElement.scrollLeft; |
| if (WI.resolvedLayoutDirection() === WI.LayoutDirection.RTL) |
| this.scrollStartTime = this._startTime - (scrollOffset * this.secondsPerPixel); |
| else |
| this.scrollStartTime = this._startTime + (scrollOffset * this.secondsPerPixel); |
| |
| // Force layout so we can update with the scroll position synchronously. |
| this.updateLayoutIfNeeded(); |
| |
| this._dontUpdateScrollLeft = false; |
| |
| this.element.classList.toggle("has-scrollbar", this._scrollContainerElement.clientHeight <= 1); |
| } |
| |
| _handleWheelEvent(event) |
| { |
| // Ignore cloned events that come our way, we already handled the original. |
| if (event.__cloned) |
| return; |
| |
| // Ignore wheel events while handing gestures. |
| if (this._handlingGesture) |
| return; |
| |
| // Require twice the vertical delta to overcome horizontal scrolling. This prevents most |
| // cases of inadvertent zooming for slightly diagonal scrolls. |
| if (Math.abs(event.deltaX) >= Math.abs(event.deltaY) * 0.5) { |
| // Clone the event to dispatch it on the scroll container. Mark it as cloned so we don't get into a loop. |
| let newWheelEvent = new event.constructor(event.type, event); |
| newWheelEvent.__cloned = true; |
| |
| this._scrollContainerElement.dispatchEvent(newWheelEvent); |
| return; |
| } |
| |
| // Remember the mouse position in time. |
| let mouseOffset = event.pageX - this._graphsContainerView.element.totalOffsetLeft; |
| let mousePositionTime = this._currentSettings.scrollStartTime + (mouseOffset * this.secondsPerPixel); |
| let deviceDirection = event.webkitDirectionInvertedFromDevice ? 1 : -1; |
| let delta = event.deltaY * (this.secondsPerPixel / WI.TimelineOverview.ScrollDeltaDenominator) * deviceDirection; |
| |
| // Reset accumulated wheel delta when direction changes. |
| if (this._pixelAlignDuration && (delta < 0 && this._mouseWheelDelta >= 0 || delta >= 0 && this._mouseWheelDelta < 0)) |
| this._mouseWheelDelta = 0; |
| |
| let previousDurationPerPixel = this.secondsPerPixel; |
| this._mouseWheelDelta += delta; |
| this.secondsPerPixel += this._mouseWheelDelta; |
| |
| if (this.secondsPerPixel === this._currentSettings.minimumDurationPerPixel && delta < 0 || this.secondsPerPixel === this._currentSettings.maximumDurationPerPixel && delta >= 0) |
| this._mouseWheelDelta = 0; |
| else |
| this._mouseWheelDelta = previousDurationPerPixel + this._mouseWheelDelta - this.secondsPerPixel; |
| |
| // Center the zoom around the mouse based on the remembered mouse position time. |
| this.scrollStartTime = mousePositionTime - (mouseOffset * this.secondsPerPixel); |
| |
| this.element.classList.toggle("has-scrollbar", this._scrollContainerElement.clientHeight <= 1); |
| |
| event.preventDefault(); |
| event.stopPropagation(); |
| } |
| |
| _handleGestureStart(event) |
| { |
| if (this._handlingGesture) { |
| // FIXME: <https://webkit.org/b/151068> [Mac] Unexpected gesturestart events when already handling gesture |
| return; |
| } |
| |
| let mouseOffset = event.pageX - this._graphsContainerView.element.totalOffsetLeft; |
| let mousePositionTime = this._currentSettings.scrollStartTime + (mouseOffset * this.secondsPerPixel); |
| |
| this._handlingGesture = true; |
| this._gestureStartStartTime = mousePositionTime; |
| this._gestureStartDurationPerPixel = this.secondsPerPixel; |
| |
| this.element.classList.toggle("has-scrollbar", this._scrollContainerElement.clientHeight <= 1); |
| |
| event.preventDefault(); |
| event.stopPropagation(); |
| } |
| |
| _handleGestureChange(event) |
| { |
| // Cap zooming out at 5x. |
| let scale = Math.max(1 / 5, event.scale); |
| |
| let mouseOffset = event.pageX - this._graphsContainerView.element.totalOffsetLeft; |
| let newSecondsPerPixel = this._gestureStartDurationPerPixel / scale; |
| |
| this.secondsPerPixel = newSecondsPerPixel; |
| this.scrollStartTime = this._gestureStartStartTime - (mouseOffset * this.secondsPerPixel); |
| |
| event.preventDefault(); |
| event.stopPropagation(); |
| } |
| |
| _handleGestureEnd(event) |
| { |
| this._handlingGesture = false; |
| this._gestureStartStartTime = NaN; |
| this._gestureStartDurationPerPixel = NaN; |
| } |
| |
| _instrumentAdded(instrumentOrEvent) |
| { |
| let instrument = instrumentOrEvent instanceof WI.Instrument ? instrumentOrEvent : instrumentOrEvent.data.instrument; |
| console.assert(instrument instanceof WI.Instrument, instrument); |
| |
| let timeline = this._recording.timelineForInstrument(instrument); |
| console.assert(!this._overviewGraphsByTypeMap.has(timeline.type), timeline); |
| console.assert(!this._treeElementsByTypeMap.has(timeline.type), timeline); |
| |
| let treeElement = new WI.TimelineTreeElement(timeline); |
| let insertionIndex = insertionIndexForObjectInListSortedByFunction(treeElement, this._timelinesTreeOutline.children, this._compareTimelineTreeElements.bind(this)); |
| this._timelinesTreeOutline.insertChild(treeElement, insertionIndex); |
| this._treeElementsByTypeMap.set(timeline.type, treeElement); |
| |
| let overviewGraph = WI.TimelineOverviewGraph.createForTimeline(timeline, this); |
| overviewGraph.addEventListener(WI.TimelineOverviewGraph.Event.RecordSelected, this._handleOverviewGraphRecordSelected, this); |
| this._overviewGraphsByTypeMap.set(timeline.type, overviewGraph); |
| this._graphsContainerView.insertSubviewBefore(overviewGraph, this._graphsContainerView.subviews[insertionIndex]); |
| |
| treeElement.element.style.height = overviewGraph.height + "px"; |
| |
| if (!this._canShowTimelineType(timeline.type)) { |
| overviewGraph.hidden(); |
| treeElement.hidden = true; |
| } |
| |
| this.needsLayout(); |
| } |
| |
| _instrumentRemoved(event) |
| { |
| let instrument = event.data.instrument; |
| console.assert(instrument instanceof WI.Instrument, instrument); |
| |
| let timeline = this._recording.timelineForInstrument(instrument); |
| let overviewGraph = this._overviewGraphsByTypeMap.get(timeline.type); |
| console.assert(overviewGraph, "Missing overview graph for timeline type", timeline.type); |
| |
| let treeElement = this._treeElementsByTypeMap.get(timeline.type); |
| let shouldSuppressOnDeselect = false; |
| let shouldSuppressSelectSibling = true; |
| this._timelinesTreeOutline.removeChild(treeElement, shouldSuppressOnDeselect, shouldSuppressSelectSibling); |
| |
| overviewGraph.removeEventListener(WI.TimelineOverviewGraph.Event.RecordSelected, this._handleOverviewGraphRecordSelected, this); |
| this._graphsContainerView.removeSubview(overviewGraph); |
| |
| this._overviewGraphsByTypeMap.delete(timeline.type); |
| this._treeElementsByTypeMap.delete(timeline.type); |
| } |
| |
| _markerAdded(event) |
| { |
| this._timelineRuler.addMarker(event.data.marker); |
| } |
| |
| _handleGraphsContainerClick(event) |
| { |
| // Set when a WI.TimelineRecordBar receives the "click" first and is about to be selected. |
| if (event.__timelineRecordClickEventHandled) |
| return; |
| |
| this._recordSelected(null, null); |
| } |
| |
| _timelineRulerMouseDown(event) |
| { |
| this._timelineRulerSelectionChanged = false; |
| } |
| |
| _timelineRulerMouseClicked(event) |
| { |
| if (this._timelineRulerSelectionChanged) |
| return; |
| |
| for (let overviewGraph of this._overviewGraphsByTypeMap.values()) { |
| if (!overviewGraph.visible) |
| continue; |
| |
| let graphRect = overviewGraph.element.getBoundingClientRect(); |
| if (!(event.pageX >= graphRect.left && event.pageX <= graphRect.right && event.pageY >= graphRect.top && event.pageY <= graphRect.bottom)) |
| continue; |
| |
| // Clone the event to dispatch it on the overview graph element. |
| let newClickEvent = new event.constructor(event.type, event); |
| overviewGraph.element.dispatchEvent(newClickEvent); |
| return; |
| } |
| } |
| |
| _timeRangeSelectionChanged(event) |
| { |
| this._timelineRulerSelectionChanged = true; |
| |
| let startTime = this._viewMode === WI.TimelineOverview.ViewMode.Timelines ? this._startTime : 0; |
| this._currentSettings.selectionStartValueSetting.value = this.selectionStartTime - startTime; |
| this._currentSettings.selectionDurationSetting.value = this.selectionDuration; |
| |
| this.dispatchEventToListeners(WI.TimelineOverview.Event.TimeRangeSelectionChanged); |
| } |
| |
| _handleOverviewGraphRecordSelected(event) |
| { |
| let {record, recordBar} = event.data; |
| |
| // Ignore deselection events, as they are handled by the newly selected record's timeline. |
| if (!record) |
| return; |
| |
| this._recordSelected(record, recordBar); |
| } |
| |
| _recordSelected(record, recordBar) |
| { |
| if (record === this._selectedTimelineRecord) |
| return; |
| |
| if (this._selectedTimelineRecord && (!record || this._selectedTimelineRecord.type !== record.type)) { |
| let timelineOverviewGraph = this._overviewGraphsByTypeMap.get(this._selectedTimelineRecord.type); |
| console.assert(timelineOverviewGraph); |
| if (timelineOverviewGraph) |
| timelineOverviewGraph.selectedRecord = null; |
| } |
| |
| this._selectedTimelineRecord = record; |
| |
| if (this._selectedTimelineRecord) { |
| let firstRecord = this._selectedTimelineRecord; |
| let lastRecord = this._selectedTimelineRecord; |
| if (recordBar) { |
| firstRecord = recordBar.records[0]; |
| lastRecord = recordBar.records.lastValue; |
| } |
| |
| let startTime = firstRecord instanceof WI.RenderingFrameTimelineRecord ? firstRecord.frameIndex : firstRecord.startTime; |
| let endTime = lastRecord instanceof WI.RenderingFrameTimelineRecord ? lastRecord.frameIndex : lastRecord.endTime; |
| if (startTime < this.selectionStartTime || (endTime > this.selectionStartTime + this.selectionDuration) || firstRecord instanceof WI.CPUTimelineRecord) { |
| let selectionPadding = this.secondsPerPixel * 10; |
| this.selectionStartTime = startTime - selectionPadding; |
| this.selectionDuration = endTime - startTime + (selectionPadding * 2); |
| } |
| } |
| |
| this.dispatchEventToListeners(WI.TimelineOverview.Event.RecordSelected, {record: this._selectedTimelineRecord}); |
| } |
| |
| _resetSelection() |
| { |
| function reset(settings) |
| { |
| settings.durationPerPixelSetting.reset(); |
| settings.selectionStartValueSetting.reset(); |
| settings.selectionDurationSetting.reset(); |
| } |
| |
| reset(this._timelinesViewModeSettings); |
| if (this._renderingFramesViewModeSettings) |
| reset(this._renderingFramesViewModeSettings); |
| |
| this.secondsPerPixel = this._currentSettings.durationPerPixelSetting.value; |
| this.selectionStartTime = this._currentSettings.selectionStartValueSetting.value; |
| this.selectionDuration = this._currentSettings.selectionDurationSetting.value; |
| } |
| |
| _recordingReset(event) |
| { |
| this._timelineRuler.clearMarkers(); |
| |
| this._timelineRuler.addMarker(this._currentTimeMarker); |
| |
| if (this._stoppingTimeMarker) { |
| this._stoppingTimeMarker.time = -1; // Hide the marker. |
| this._timelineRuler.addMarker(this._stoppingTimeMarker); |
| } |
| } |
| |
| _canShowTimelineType(type) |
| { |
| let timelineViewMode = WI.TimelineOverview.ViewMode.Timelines; |
| if (type === WI.TimelineRecord.Type.RenderingFrame) |
| timelineViewMode = WI.TimelineOverview.ViewMode.RenderingFrames; |
| |
| return timelineViewMode === this._viewMode; |
| } |
| |
| _viewModeDidChange() |
| { |
| let startTime = 0; |
| let isRenderingFramesMode = this._viewMode === WI.TimelineOverview.ViewMode.RenderingFrames; |
| if (isRenderingFramesMode) { |
| this._timelineRuler.minimumSelectionDuration = 1; |
| this._timelineRuler.snapInterval = 1; |
| this._timelineRuler.formatLabelCallback = (value) => value.maxDecimals(0).toLocaleString(); |
| } else { |
| this._timelineRuler.minimumSelectionDuration = 0.01; |
| this._timelineRuler.snapInterval = NaN; |
| this._timelineRuler.formatLabelCallback = null; |
| |
| startTime = this._startTime; |
| } |
| |
| this.pixelAlignDuration = isRenderingFramesMode; |
| this.selectionStartTime = this._currentSettings.selectionStartValueSetting.value + startTime; |
| this.selectionDuration = this._currentSettings.selectionDurationSetting.value; |
| |
| for (let [type, overviewGraph] of this._overviewGraphsByTypeMap) { |
| let treeElement = this._treeElementsByTypeMap.get(type); |
| console.assert(treeElement, "Missing tree element for timeline type", type); |
| |
| treeElement.hidden = !this._canShowTimelineType(type); |
| if (treeElement.hidden) |
| overviewGraph.hidden(); |
| else |
| overviewGraph.shown(); |
| } |
| |
| this.element.classList.toggle("frames", isRenderingFramesMode); |
| |
| this.updateLayout(WI.View.LayoutReason.Resize); |
| } |
| |
| _createViewModeSettings(viewMode, minimumDurationPerPixel, maximumDurationPerPixel, durationPerPixel, selectionStartValue, selectionDuration) |
| { |
| durationPerPixel = Math.min(maximumDurationPerPixel, Math.max(minimumDurationPerPixel, durationPerPixel)); |
| |
| let durationPerPixelSetting = new WI.Setting(viewMode + "-duration-per-pixel", durationPerPixel); |
| let selectionStartValueSetting = new WI.Setting(viewMode + "-selection-start-value", selectionStartValue); |
| let selectionDurationSetting = new WI.Setting(viewMode + "-selection-duration", selectionDuration); |
| |
| return { |
| scrollStartTime: 0, |
| minimumDurationPerPixel, |
| maximumDurationPerPixel, |
| durationPerPixelSetting, |
| selectionStartValueSetting, |
| selectionDurationSetting |
| }; |
| } |
| |
| get _currentSettings() |
| { |
| return this._viewMode === WI.TimelineOverview.ViewMode.Timelines ? this._timelinesViewModeSettings : this._renderingFramesViewModeSettings; |
| } |
| |
| _timelinesTreeSelectionDidChange(event) |
| { |
| let timeline = null; |
| let selectedTreeElement = this._timelinesTreeOutline.selectedTreeElement; |
| if (selectedTreeElement) { |
| timeline = selectedTreeElement.representedObject; |
| console.assert(timeline instanceof WI.Timeline, timeline); |
| console.assert(this._recording.timelines.get(timeline.type) === timeline, timeline); |
| |
| for (let [type, overviewGraph] of this._overviewGraphsByTypeMap) |
| overviewGraph.selected = type === timeline.type; |
| } |
| |
| this._selectedTimeline = timeline; |
| this.dispatchEventToListeners(WI.TimelineOverview.Event.TimelineSelected); |
| } |
| |
| _toggleEditingInstruments(event) |
| { |
| if (this._editingInstruments) |
| this._stopEditingInstruments(); |
| else |
| this._startEditingInstruments(); |
| } |
| |
| _editingInstrumentsDidChange() |
| { |
| this.element.classList.toggle(WI.TimelineOverview.EditInstrumentsStyleClassName, this._editingInstruments); |
| this._timelineRuler.enabled = !this._editingInstruments; |
| |
| this._updateWheelAndGestureHandlers(); |
| this._updateEditInstrumentsButton(); |
| |
| this.dispatchEventToListeners(WI.TimelineOverview.Event.EditingInstrumentsDidChange); |
| } |
| |
| _updateEditInstrumentsButton() |
| { |
| let newLabel = this._editingInstruments ? WI.UIString("Done") : WI.UIString("Edit"); |
| this._editInstrumentsButton.label = newLabel; |
| this._editInstrumentsButton.activated = this._editingInstruments; |
| this._editInstrumentsButton.enabled = !WI.timelineManager.isCapturing(); |
| } |
| |
| _updateWheelAndGestureHandlers() |
| { |
| if (this._editingInstruments) { |
| this.element.removeEventListener("wheel", this._handleWheelEventListener); |
| this.element.removeEventListener("gesturestart", this._handleGestureStartEventListener); |
| this.element.removeEventListener("gesturechange", this._handleGestureChangeEventListener); |
| this.element.removeEventListener("gestureend", this._handleGestureEndEventListener); |
| this._handleWheelEventListener = null; |
| this._handleGestureStartEventListener = null; |
| this._handleGestureChangeEventListener = null; |
| this._handleGestureEndEventListener = null; |
| } else { |
| this._handleWheelEventListener = this._handleWheelEvent.bind(this); |
| this._handleGestureStartEventListener = this._handleGestureStart.bind(this); |
| this._handleGestureChangeEventListener = this._handleGestureChange.bind(this); |
| this._handleGestureEndEventListener = this._handleGestureEnd.bind(this); |
| this.element.addEventListener("wheel", this._handleWheelEventListener); |
| this.element.addEventListener("gesturestart", this._handleGestureStartEventListener); |
| this.element.addEventListener("gesturechange", this._handleGestureChangeEventListener); |
| this.element.addEventListener("gestureend", this._handleGestureEndEventListener); |
| } |
| } |
| |
| _startEditingInstruments() |
| { |
| console.assert(this._viewMode === WI.TimelineOverview.ViewMode.Timelines); |
| |
| if (this._editingInstruments) |
| return; |
| |
| this._editingInstruments = true; |
| |
| for (let type of this._instrumentTypes) { |
| let treeElement = this._treeElementsByTypeMap.get(type); |
| if (!treeElement) { |
| let timeline = this._recording.timelines.get(type); |
| console.assert(timeline, "Missing timeline for type " + type); |
| |
| const placeholder = true; |
| treeElement = new WI.TimelineTreeElement(timeline, placeholder); |
| |
| let insertionIndex = insertionIndexForObjectInListSortedByFunction(treeElement, this._timelinesTreeOutline.children, this._compareTimelineTreeElements.bind(this)); |
| this._timelinesTreeOutline.insertChild(treeElement, insertionIndex); |
| |
| let placeholderGraph = new WI.View; |
| placeholderGraph.element.classList.add("timeline-overview-graph"); |
| treeElement[WI.TimelineOverview.PlaceholderOverviewGraph] = placeholderGraph; |
| this._graphsContainerView.insertSubviewBefore(placeholderGraph, this._graphsContainerView.subviews[insertionIndex]); |
| } |
| |
| treeElement.editing = true; |
| treeElement.addEventListener(WI.TimelineTreeElement.Event.EnabledDidChange, this._timelineTreeElementEnabledDidChange, this); |
| } |
| |
| this._editingInstrumentsDidChange(); |
| } |
| |
| _stopEditingInstruments() |
| { |
| if (!this._editingInstruments) |
| return; |
| |
| this._editingInstruments = false; |
| |
| let instruments = this._recording.instruments; |
| for (let treeElement of this._treeElementsByTypeMap.values()) { |
| if (treeElement.status.checked) { |
| treeElement.editing = false; |
| treeElement.removeEventListener(WI.TimelineTreeElement.Event.EnabledDidChange, this._timelineTreeElementEnabledDidChange, this); |
| continue; |
| } |
| |
| let timelineInstrument = instruments.find((instrument) => instrument.timelineRecordType === treeElement.representedObject.type); |
| this._recording.removeInstrument(timelineInstrument); |
| } |
| |
| let placeholderTreeElements = this._timelinesTreeOutline.children.filter((treeElement) => treeElement.placeholder); |
| for (let treeElement of placeholderTreeElements) { |
| this._timelinesTreeOutline.removeChild(treeElement); |
| |
| let placeholderGraph = treeElement[WI.TimelineOverview.PlaceholderOverviewGraph]; |
| console.assert(placeholderGraph); |
| this._graphsContainerView.removeSubview(placeholderGraph); |
| |
| if (treeElement.status.checked) { |
| let instrument = WI.Instrument.createForTimelineType(treeElement.representedObject.type); |
| this._recording.addInstrument(instrument); |
| } |
| } |
| |
| let instrumentTypes = instruments.map((instrument) => instrument.timelineRecordType); |
| WI.timelineManager.enabledTimelineTypes = instrumentTypes; |
| |
| this._editingInstrumentsDidChange(); |
| } |
| |
| _handleTimelineCapturingStateChanged(event) |
| { |
| switch (WI.timelineManager.capturingState) { |
| case WI.TimelineManager.CapturingState.Starting: |
| if (this._stoppingTimeMarker) |
| this._stoppingTimeMarker.time = -1; // Hide the marker when capturing resumes. |
| break; |
| |
| case WI.TimelineManager.CapturingState.Active: |
| this._editInstrumentsButton.enabled = false; |
| this._stopEditingInstruments(); |
| break; |
| |
| case WI.TimelineManager.CapturingState.Stopping: |
| if (!this._stoppingTimeMarker) { |
| this._stoppingTimeMarker = new WI.TimelineMarker(this._currentTime, WI.TimelineMarker.Type.StoppingTime); |
| this._timelineRuler.addMarker(this._stoppingTimeMarker); |
| } else |
| this._stoppingTimeMarker.time = this._currentTime; |
| break; |
| |
| case WI.TimelineManager.CapturingState.Inactive: |
| this._editInstrumentsButton.enabled = true; |
| break; |
| } |
| } |
| |
| _recordingImported(event) |
| { |
| let {overviewData} = event.data; |
| |
| if (overviewData.secondsPerPixel !== undefined) |
| this.secondsPerPixel = overviewData.secondsPerPixel; |
| if (overviewData.scrollStartTime !== undefined) |
| this.scrollStartTime = overviewData.scrollStartTime; |
| if (overviewData.selectionStartTime !== undefined) |
| this.selectionStartTime = overviewData.selectionStartTime; |
| if (overviewData.selectionDuration !== undefined) { |
| if (overviewData.selectionDuration === Number.MAX_VALUE) |
| this._timelineRuler.selectEntireRange(); |
| else |
| this.selectionDuration = overviewData.selectionDuration; |
| } |
| if (overviewData.selectedTimelineType !== undefined) { |
| let timeline = this._recording.timelineForRecordType(overviewData.selectedTimelineType); |
| if (timeline) |
| this.selectedTimeline = timeline; |
| } |
| } |
| |
| _compareTimelineTreeElements(a, b) |
| { |
| let aTimelineType = a.representedObject.type; |
| let bTimelineType = b.representedObject.type; |
| |
| // Always sort the Rendering Frames timeline last. |
| if (aTimelineType === WI.TimelineRecord.Type.RenderingFrame) |
| return 1; |
| if (bTimelineType === WI.TimelineRecord.Type.RenderingFrame) |
| return -1; |
| |
| if (a.placeholder !== b.placeholder) |
| return a.placeholder ? 1 : -1; |
| |
| let aTimelineIndex = this._instrumentTypes.indexOf(aTimelineType); |
| let bTimelineIndex = this._instrumentTypes.indexOf(bTimelineType); |
| return aTimelineIndex - bTimelineIndex; |
| } |
| |
| _timelineTreeElementEnabledDidChange(event) |
| { |
| let enabled = this._timelinesTreeOutline.children.some((treeElement) => { |
| let timelineType = treeElement.representedObject.type; |
| return this._canShowTimelineType(timelineType) && treeElement.status.checked; |
| }); |
| |
| this._editInstrumentsButton.enabled = enabled; |
| } |
| }; |
| |
| WI.TimelineOverview.PlaceholderOverviewGraph = Symbol("placeholder-overview-graph"); |
| |
| WI.TimelineOverview.ScrollDeltaDenominator = 500; |
| WI.TimelineOverview.EditInstrumentsStyleClassName = "edit-instruments"; |
| WI.TimelineOverview.MinimumDurationPerPixel = 0.0001; |
| WI.TimelineOverview.MaximumDurationPerPixel = 60; |
| |
| WI.TimelineOverview.ViewMode = { |
| Timelines: "timeline-overview-view-mode-timelines", |
| RenderingFrames: "timeline-overview-view-mode-rendering-frames" |
| }; |
| |
| WI.TimelineOverview.Event = { |
| EditingInstrumentsDidChange: "editing-instruments-did-change", |
| RecordSelected: "timeline-overview-record-selected", |
| TimelineSelected: "timeline-overview-timeline-selected", |
| TimeRangeSelectionChanged: "timeline-overview-time-range-selection-changed" |
| }; |
