| const { TouchBarScrubber } = require("electron"); |
| |
| // Default range: 0 to 300s, shared between both views |
| var RANGE_LEFT_INIT = 0; |
| var RANGE_RIGHT_INIT = 300; |
| |
| // Global timeline start |
| var g_StartingSec = undefined; |
| |
| function ShouldShowDebugInfo() { |
| if (g_cb_debug_info.checked) return true; |
| else return false; |
| } |
| |
| function GetHistoryHistogram() { |
| return HistoryHistogram; |
| } |
| |
| function RenderHistogramForImageData(ctx, key) { |
| let PAD = 1, // To make up for the extra stroke width |
| PAD2 = 2; // To preserve some space at both ends of the histogram |
| |
| let cumDensity0 = 0, cumDensity1 = 0; |
| |
| // Left normalized index Left value Right normalized index, Right value |
| let threshEntry = [[undefined, undefined], [undefined, undefined]]; |
| const x = 0, y = 0, w = HISTOGRAM_W, h = HISTOGRAM_H; |
| let hist = GetHistoryHistogram()[key]; |
| if (hist == undefined) return; |
| |
| let buckets = hist[2]; |
| let dw = w * 1.0 / buckets.length; |
| let maxCount = 0, totalCount = 0; |
| for (let i = 0; i < buckets.length; i++) { |
| if (maxCount < buckets[i]) { |
| maxCount = buckets[i]; |
| } |
| totalCount += buckets[i]; |
| } |
| ctx.fillStyle = '#FFF'; |
| ctx.fillRect(x, y, w, h); |
| |
| ctx.strokeStyle = '#AAA'; |
| ctx.fillStyle = '#000'; |
| ctx.lineWidth = 1; |
| ctx.strokeRect(x + PAD, y + PAD, w - 2 * PAD, h - 2 * PAD); |
| for (let i = 0; i < buckets.length; i++) { |
| const bucketsLen = buckets.length; |
| if (buckets[i] > 0) { |
| let dx0 = x + PAD2 + (w - 2 * PAD2) * 1.0 * i / buckets.length, |
| dx1 = x + PAD2 + (w - 2 * PAD2) * 1.0 * (i + 1) / buckets.length, |
| dy0 = y + h - h * 1.0 * buckets[i] / maxCount, dy1 = y + h; |
| let delta_density = buckets[i] / totalCount; |
| cumDensity0 = cumDensity1; |
| cumDensity1 += delta_density; |
| |
| // Write thresholds |
| if (cumDensity0 < HISTOGRAM_LEFT_TAIL_WIDTH && |
| cumDensity1 >= HISTOGRAM_LEFT_TAIL_WIDTH) { |
| threshEntry[0][0] = i / buckets.length; |
| threshEntry[0][1] = hist[0] + (hist[1] - hist[0]) / bucketsLen * i; |
| } |
| if (cumDensity0 < 1 - HISTOGRAM_RIGHT_TAIL_WIDTH && |
| cumDensity1 >= 1 - HISTOGRAM_RIGHT_TAIL_WIDTH) { |
| threshEntry[1][0] = (i - 1) / buckets.length; |
| threshEntry[1][1] = |
| hist[0] + (hist[1] - hist[0]) / bucketsLen * (i - 1); |
| } |
| |
| ctx.fillRect(dx0, dy0, dx1 - dx0, dy1 - dy0); |
| } |
| } |
| |
| // Mark the threshold regions |
| ctx.fillStyle = 'rgba(0,255,0,0.1)'; |
| let dx = x + PAD2; |
| dw = (w - 2 * PAD2) * 1.0 * threshEntry[0][0]; |
| ctx.fillRect(dx, y, dw, h); |
| |
| ctx.fillStyle = 'rgba(255,0,0,0.1)'; |
| ctx.beginPath(); |
| dx = x + PAD2 + (w - 2 * PAD2) * 1.0 * threshEntry[1][0]; |
| dw = (w - 2 * PAD2) * 1.0 * (1 - threshEntry[1][0]); |
| ctx.fillRect(dx, y, dw, h); |
| |
| IsCanvasDirty = true; |
| return [ctx.getImageData(x, y, w, h), threshEntry]; |
| } |
| |
| function RenderHistogram(ctx, key, xMid, yMid) { |
| if (GetHistoryHistogram()[key] == undefined) { |
| return; |
| } |
| if (IpmiVizHistogramImageData[key] == undefined) { |
| return; |
| } |
| let hist = GetHistoryHistogram()[key]; |
| ctx.putImageData( |
| IpmiVizHistogramImageData[key], xMid - HISTOGRAM_W / 2, |
| yMid - HISTOGRAM_H / 2); |
| |
| let ub = ''; // Upper bound label |
| ctx.textAlign = 'left'; |
| ctx.fillStyle = '#000'; |
| if (hist[1] > 1000) { |
| ub = (hist[1] / 1000.0).toFixed(1) + 'ms'; |
| } else { |
| ub = hist[1].toFixed(1) + 'us'; |
| } |
| ctx.fillText(ub, xMid + HISTOGRAM_W / 2, yMid); |
| |
| let lb = ''; // Lower bound label |
| if (hist[0] > 1000) { |
| lb = (hist[0] / 1000.0).toFixed(1) + 'ms'; |
| } else { |
| lb = hist[0].toFixed(1) + 'us'; |
| } |
| ctx.textAlign = 'right'; |
| ctx.textBaseline = 'middle'; |
| ctx.fillText(lb, xMid - HISTOGRAM_W / 2, yMid); |
| } |
| |
| // A TimelineView contains data that has already gone through |
| // the Layout step and is ready for showing |
| class TimelineView { |
| constructor() { |
| this.Intervals = []; |
| this.Titles = []; // { "header":true|false, "title":string, "intervals_idxes":[int] } |
| this.Heights = []; // Visual height for each line |
| this.HeaderCollapsed = {}; |
| this.TitleProperties = []; // [Visual height, Is Header] |
| this.LowerBoundTime = RANGE_LEFT_INIT; |
| this.UpperBoundTime = RANGE_RIGHT_INIT; |
| this.LowerBoundTimeTarget = this.LowerBoundTime; |
| this.UpperBoundTimeTarget = this.UpperBoundTime; |
| this.LastTimeLowerBound = 0; |
| this.LastTimeUpperBound = 0; |
| this.IsCanvasDirty = true; |
| this.IsHighlightDirty = true; |
| this.IsAnimating = false; |
| this.IpmiVizHistogramImageData = {}; |
| this.IpmiVizHistHighlighted = {}; |
| this.HighlightedRequests = []; |
| this.Canvas = undefined; |
| this.TitleDispLengthLimit = 32; // display this many chars for title |
| this.IsTimeDistributionEnabled = false; |
| this.AccentColor = '#000'; |
| this.CurrentFileName = ''; |
| this.VisualLineStartIdx = 0; |
| |
| // For connecting to the data model |
| this.GroupBy = []; |
| this.GroupByStr = ''; |
| |
| // For keyboard navigation |
| this.CurrDeltaX = 0; |
| this.CurrDeltaZoom = 0; |
| this.CurrShiftFlag = false; |
| this.MouseState = { |
| hovered: true, |
| pressed: false, |
| x: 0, |
| y: 0, |
| hoveredVisibleLineIndex: -999, |
| hoveredSide: undefined, // 'left', 'right', 'scroll', 'timeline' |
| drag_begin_title_start_idx: undefined, |
| drag_begin_y: undefined, |
| IsDraggingScrollBar: function() { |
| return (this.drag_begin_y != undefined); |
| }, |
| EndDragScrollBar: function() { |
| this.drag_begin_y = undefined; |
| this.drag_begin_title_start_idx = undefined; |
| }, |
| IsHoveredOverHorizontalScrollbar: function() { |
| if (this.hoveredSide == "top_horizontal_scrollbar") return true; |
| else if (this.hoveredSide == "bottom_horizontal_scrollbar") return true; |
| else return false; |
| } |
| }; |
| this.ScrollBarState = { |
| y0: undefined, |
| y1: undefined, |
| }; |
| this.HighlightedRegion = {t0: -999, t1: -999}; |
| |
| // The linked view will move and zoom with this view |
| this.linked_views = []; |
| } |
| |
| // Performs layout operation, move overlapping intervals to different |
| // lines |
| LayoutForOverlappingIntervals() { |
| this.Heights = []; |
| const MAX_STACK = 10; // Stack level limit: 10, arbitrarily chosen |
| |
| for (let i=0; i<this.Titles.length; i++) { |
| let last_x = {}; |
| let ymax = 0; |
| |
| const title_data = this.Titles[i]; |
| |
| const intervals_idxes = title_data.intervals_idxes; |
| |
| // TODO: What happens if there are > 1 |
| if (title_data.header == false) { |
| const line = this.Intervals[intervals_idxes[0]]; |
| |
| for (let j=0; j<line.length; j++) { |
| const entry = line[j]; |
| let y = 0; |
| for (; y<MAX_STACK; y++) { |
| if (!(y in last_x)) { break; } |
| if (last_x[y] <= entry[0]) { |
| break; |
| } |
| } |
| |
| const end_time = entry[1]; |
| if (end_time != undefined && !isNaN(end_time)) { |
| last_x[y] = end_time; |
| } else { |
| last_x[y] = entry[0]; |
| } |
| entry[4] = y; |
| ymax = Math.max(y, ymax); |
| } |
| } else if (intervals_idxes.length == 0) { |
| // Don't do anything, set height to 1 |
| } |
| this.Heights.push(ymax+1); |
| } |
| } |
| |
| TotalVisualHeight() { |
| let ret = 0; |
| this.Heights.forEach((h) => { |
| ret += h; |
| }) |
| return ret; |
| } |
| |
| // Returns [Index, Offset] |
| VisualLineIndexToDataLineIndex(x) { |
| if (this.Heights.length < 1) return undefined; |
| let lb = 0, ub = this.Heights[0]-1; |
| for (let i=0; i<this.Heights.length; i++) { |
| ub = lb + this.Heights[i] - 1; |
| if (lb <= x && ub >= x) { |
| return [i, x-lb]; |
| } |
| lb = ub+1; |
| } |
| return undefined; |
| } |
| |
| IsEmpty() { |
| return (this.Intervals.length < 1); |
| } |
| |
| GetTitleWidthLimit() { |
| if (this.IsTimeDistributionEnabled == true) { |
| return 32; |
| } else { |
| return 64; |
| } |
| } |
| |
| ToLines(t, limit) { |
| let ret = []; |
| for (let i = 0; i < t.length; i += limit) { |
| let j = Math.min(i + limit, t.length); |
| ret.push(t.substr(i, j)); |
| } |
| return ret; |
| } |
| |
| Zoom(dz, mid = undefined, iter = 1) { |
| if (this.CurrShiftFlag) dz *= 2; |
| if (dz != 0) { |
| if (mid == undefined) { |
| mid = (this.LowerBoundTime + this.UpperBoundTime) / 2; |
| } |
| this.LowerBoundTime = mid - (mid - this.LowerBoundTime) * (1 - dz); |
| this.UpperBoundTime = mid + (this.UpperBoundTime - mid) * (1 - dz); |
| this.IsCanvasDirty = true; |
| this.IsAnimating = false; |
| } |
| |
| if (iter > 0) { |
| this.linked_views.forEach(function(v) { |
| v.Zoom(dz, mid, iter - 1); |
| }); |
| } |
| } |
| |
| BeginZoomAnimation(dz, mid = undefined, iter = 1) { |
| if (mid == undefined) { |
| mid = (this.LowerBoundTime + this.UpperBoundTime) / 2; |
| } |
| this.LowerBoundTimeTarget = mid - (mid - this.LowerBoundTime) * (1 - dz); |
| this.UpperBoundTimeTarget = mid + (this.UpperBoundTime - mid) * (1 - dz); |
| this.IsCanvasDirty = true; |
| this.IsAnimating = true; |
| |
| if (iter > 0) { |
| this.linked_views.forEach(function(v) { |
| v.BeginZoomAnimation(dz, mid, iter - 1); |
| }); |
| } |
| } |
| |
| BeginPanScreenAnimaton(delta_screens, iter = 1) { |
| let deltat = (this.UpperBoundTime - this.LowerBoundTime) * delta_screens; |
| this.BeginSetBoundaryAnimation( |
| this.LowerBoundTime + deltat, this.UpperBoundTime + deltat); |
| |
| if (iter > 0) { |
| this.linked_views.forEach(function(v) { |
| v.BeginPanScreenAnimaton(delta_screens, iter - 1); |
| }); |
| } |
| } |
| |
| BeginSetBoundaryAnimation(lt, rt, iter = 1) { |
| this.IsAnimating = true; |
| this.LowerBoundTimeTarget = lt; |
| this.UpperBoundTimeTarget = rt; |
| |
| if (iter > 0) { |
| this.linked_views.forEach(function(v) { |
| v.BeginSetBoundaryAnimation(lt, rt, iter - 1); |
| }); |
| } |
| } |
| |
| BeginWarpToRequestAnimation(req, iter = 1) { |
| let mid_new = (req[0] + req[1]) / 2; |
| let mid = (this.LowerBoundTime + this.UpperBoundTime) / 2; |
| let lt = this.LowerBoundTime + (mid_new - mid); |
| let rt = this.UpperBoundTime + (mid_new - mid); |
| this.BeginSetBoundaryAnimation(lt, rt, 0); |
| |
| this.linked_views.forEach(function(v) { |
| v.BeginSetBoundaryAnimation(lt, rt, 0); |
| }); |
| } |
| |
| UpdateAnimation() { |
| const EPS = 1e-3; |
| if (Math.abs(this.LowerBoundTime - this.LowerBoundTimeTarget) < EPS && |
| Math.abs(this.UpperBoundTime - this.UpperBoundTimeTarget) < EPS) { |
| this.LowerBoundTime = this.LowerBoundTimeTarget; |
| this.UpperBoundTime = this.UpperBoundTimeTarget; |
| this.IsAnimating = false; |
| } |
| if (this.IsAnimating) { |
| let t = 0.80; |
| this.LowerBoundTime = |
| this.LowerBoundTime * t + this.LowerBoundTimeTarget * (1 - t); |
| this.UpperBoundTime = |
| this.UpperBoundTime * t + this.UpperBoundTimeTarget * (1 - t); |
| this.IsCanvasDirty = true; |
| } |
| } |
| |
| IsHighlighted() { |
| return ( |
| this.HighlightedRegion.t0 != -999 && this.HighlightedRegion.t1 != -999); |
| } |
| |
| RenderHistogram(ctx, key, xMid, yMid) { |
| if (GetHistoryHistogram()[key] == undefined) { |
| return; |
| } |
| if (this.IpmiVizHistogramImageData[key] == undefined) { |
| return; |
| } |
| let hist = GetHistoryHistogram()[key]; |
| ctx.putImageData( |
| this.IpmiVizHistogramImageData[key], xMid - HISTOGRAM_W / 2, |
| yMid - HISTOGRAM_H / 2); |
| |
| let ub = ''; // Upper bound label |
| ctx.textAlign = 'left'; |
| ctx.fillStyle = '#000'; |
| if (hist[1] > 1000) { |
| ub = (hist[1] / 1000.0).toFixed(1) + 'ms'; |
| } else { |
| ub = hist[1].toFixed(1) + 'us'; |
| } |
| ctx.fillText(ub, xMid + HISTOGRAM_W / 2, yMid); |
| |
| let lb = ''; // Lower bound label |
| if (hist[0] > 1000) { |
| lb = (hist[0] / 1000.0).toFixed(1) + 'ms'; |
| } else { |
| lb = hist[0].toFixed(1) + 'us'; |
| } |
| ctx.textAlign = 'right'; |
| ctx.textBaseline = 'middle'; |
| ctx.fillText(lb, xMid - HISTOGRAM_W / 2, yMid); |
| } |
| |
| IsMouseOverTimeline() { |
| return this.MouseState.x > LEFT_MARGIN; |
| } |
| |
| MouseXToTimestamp(x) { |
| let ret = (x - LEFT_MARGIN) / (RIGHT_MARGIN - LEFT_MARGIN) * |
| (this.UpperBoundTime - this.LowerBoundTime) + |
| this.LowerBoundTime; |
| ret = Math.max(ret, this.LowerBoundTime); |
| ret = Math.min(ret, this.UpperBoundTime); |
| return ret; |
| } |
| |
| Unhighlight() { |
| this.HighlightedRegion.t0 = -999; |
| this.HighlightedRegion.t1 = -999; |
| } |
| |
| OnMouseMove() { |
| // Drag gestures |
| if (this.MouseState.pressed == true) { |
| const h = this.MouseState.hoveredSide; |
| if (h == 'timeline') { |
| // Update highlighted area |
| this.HighlightedRegion.t1 = |
| this.MouseXToTimestamp(this.MouseState.x); |
| } |
| } |
| |
| const PAD = 2; |
| if (this.MouseState.x < LEFT_MARGIN) |
| this.MouseState.hovered = false; |
| else if (this.MouseState.x > RIGHT_MARGIN) |
| this.MouseState.hovered = false; |
| else |
| this.MouseState.hovered = true; |
| |
| this.IsCanvasDirty = true; |
| let lineIndex = |
| Math.floor((this.MouseState.y - YBEGIN + TEXT_Y0) / LINE_SPACING); |
| |
| if (this.MouseState.x <= 0 || |
| this.MouseState.x >= RIGHT_MARGIN) { |
| lineIndex = undefined; |
| } |
| |
| const old_hoveredSide = this.MouseState.hoveredSide; |
| |
| // Left/right overflow markers or time axis drag |
| this.MouseState.hoveredVisibleLineIndex = -999; |
| if (this.MouseState.hoveredSide != "scrollbar" && |
| this.MouseState.pressed == false) { |
| if (lineIndex != undefined) { |
| this.MouseState.hoveredVisibleLineIndex = lineIndex; |
| |
| let should_hide_cursor = false; // Should we hide the vertical cursor for linked views? |
| |
| if (this.MouseState.x <= PAD + LINE_SPACING / 2 + LEFT_MARGIN && |
| this.MouseState.x >= PAD + LEFT_MARGIN) { |
| this.MouseState.hoveredSide = 'left'; |
| this.IsCanvasDirty = true; |
| } else if ( |
| this.MouseState.x <= RIGHT_MARGIN - PAD && |
| this.MouseState.x >= RIGHT_MARGIN - PAD - LINE_SPACING / 2) { |
| this.MouseState.hoveredSide = 'right'; |
| this.IsCanvasDirty = true; |
| } else if (this.MouseState.x >= PAD + LEFT_MARGIN && |
| this.MouseState.y <= TOP_HORIZONTAL_SCROLLBAR_HEIGHT && |
| this.MouseState.y > 0) { |
| this.MouseState.hoveredVisibleLineIndex = undefined; |
| this.MouseState.hoveredSide = 'top_horizontal_scrollbar'; |
| } else if (this.MouseState.x >= PAD + LEFT_MARGIN && |
| this.MouseState.y >= this.Canvas.height - BOTTOM_HORIZONTAL_SCROLLBAR_HEIGHT && |
| this.MouseState.y <= this.Canvas.height) { |
| this.MouseState.hoveredVisibleLineIndex = undefined; |
| this.MouseState.hoveredSide = 'bottom_horizontal_scrollbar'; |
| } else { |
| this.MouseState.hoveredSide = undefined; |
| } |
| } |
| } |
| |
| // During a dragging session |
| if (this.MouseState.pressed == true) { |
| |
| if (this.MouseState.hoveredSide == "top_horizontal_scrollbar" || |
| this.MouseState.hoveredSide == "bottom_horizontal_scrollbar") { |
| const sec_per_px = (this.MouseState.begin_UpperBoundTime - this.MouseState.begin_LowerBoundTime) / (RIGHT_MARGIN - LEFT_MARGIN); |
| const pan_secs = (this.MouseState.x - this.MouseState.begin_drag_x) * sec_per_px; |
| |
| const new_lb = this.MouseState.begin_LowerBoundTime - pan_secs; |
| const new_ub = this.MouseState.begin_UpperBoundTime - pan_secs; |
| this.LowerBoundTime = new_lb; |
| this.UpperBoundTime = new_ub; |
| |
| // Sync to all other views |
| this.linked_views.forEach((v) => { |
| v.LowerBoundTime = new_lb; v.UpperBoundTime = new_ub; |
| }) |
| } |
| |
| const tvh = this.TotalVisualHeight(); |
| if (this.MouseState.hoveredSide == 'scrollbar') { |
| const diff_y = this.MouseState.y - this.MouseState.drag_begin_y; |
| const diff_title_idx = tvh * diff_y / this.Canvas.height; |
| let new_title_start_idx = this.MouseState.drag_begin_title_start_idx + parseInt(diff_title_idx); |
| if (new_title_start_idx < 0) { new_title_start_idx = 0; } |
| else if (new_title_start_idx >= tvh) { |
| new_title_start_idx = tvh - 1; |
| } |
| this.VisualLineStartIdx = new_title_start_idx; |
| } |
| } |
| } |
| |
| OnMouseLeave() { |
| // When dragging the scroll bar, allow mouse to temporarily leave the element since we only |
| // care about delta Y |
| if (this.MouseState.hoveredSide == 'scrollbar') { |
| |
| } else { |
| this.MouseState.hovered = false; |
| this.MouseState.hoveredSide = undefined; |
| this.IsCanvasDirty = true; |
| this.MouseState.hoveredVisibleLineIndex = undefined; |
| this.MouseState.y = undefined; |
| this.MouseState.x = undefined; |
| } |
| } |
| |
| // Assume event.button is zero (left mouse button) |
| OnMouseDown(iter = 1) { |
| // If hovering over an overflowing triangle, warp to the nearest overflowed |
| // request on that line |
| if (this.MouseState.hoveredVisibleLineIndex >= 0 && |
| this.MouseState.hoveredVisibleLineIndex < this.Intervals.length && |
| this.MouseState.hoveredSide != undefined) { |
| const x = this.VisualLineIndexToDataLineIndex(this.MouseState.hoveredVisibleLineIndex); |
| if (x == undefined) return; |
| const line = this.Intervals[x[0]]; |
| if (this.MouseState.hoveredSide == 'left') { |
| for (let i = line.length - 1; i >= 0; i--) { |
| if (line[i][1] <= this.LowerBoundTime) { |
| this.BeginWarpToRequestAnimation(line[i]); |
| // TODO: pass timeline X to linked view |
| break; |
| } |
| } |
| } else if (this.MouseState.hoveredSide == 'right') { |
| for (let i = 0; i < line.length; i++) { |
| if (line[i][0] >= this.UpperBoundTime) { |
| // TODO: pass timeline X to linked view |
| this.BeginWarpToRequestAnimation(line[i]); |
| break; |
| } |
| } |
| } |
| } |
| |
| let tx = this.MouseXToTimestamp(this.MouseState.x); |
| let t0 = Math.min(this.HighlightedRegion.t0, this.HighlightedRegion.t1), |
| t1 = Math.max(this.HighlightedRegion.t0, this.HighlightedRegion.t1); |
| if (this.MouseState.x > LEFT_MARGIN) { |
| |
| // If clicking on the horizontal scroll bar, start panning the viewport |
| if (this.MouseState.hoveredSide == "top_horizontal_scrollbar" || |
| this.MouseState.hoveredSide == "bottom_horizontal_scrollbar") { |
| this.MouseState.pressed = true; |
| this.MouseState.begin_drag_x = this.MouseState.x; |
| this.MouseState.begin_LowerBoundTime = this.LowerBoundTime; |
| this.MouseState.begin_UpperBoundTime = this.UpperBoundTime; |
| } else if (tx >= t0 && tx <= t1) { |
| // If clicking inside highlighted area, zoom around the area |
| this.BeginSetBoundaryAnimation(t0, t1); |
| this.Unhighlight(); |
| this.IsCanvasDirty = true; |
| |
| this.linked_views.forEach(function(v) { |
| v.BeginSetBoundaryAnimation(t0, t1, 0); |
| v.Unhighlight(); |
| v.IsCanvasDirty = false; |
| }); |
| } else { // If in the timeline area, start a new dragging action |
| this.MouseState.hoveredSide = 'timeline'; |
| this.MouseState.pressed = true; |
| this.HighlightedRegion.t0 = this.MouseXToTimestamp(this.MouseState.x); |
| this.HighlightedRegion.t1 = this.HighlightedRegion.t0; |
| this.IsCanvasDirty = true; |
| } |
| } else if (this.MouseState.x < SCROLL_BAR_WIDTH) { // Todo: draagging the scroll bar |
| const THRESH = 4; |
| if (this.MouseState.y >= this.ScrollBarState.y0 - THRESH && |
| this.MouseState.y <= this.ScrollBarState.y1 + THRESH) { |
| this.MouseState.pressed = true; |
| this.MouseState.drag_begin_y = this.MouseState.y; |
| this.MouseState.drag_begin_title_start_idx = this.VisualLineStartIdx; |
| this.MouseState.hoveredSide = 'scrollbar'; |
| } |
| } |
| |
| // Collapse or expand a "header" |
| if (this.MouseState.x < LEFT_MARGIN && |
| this.MouseState.hoveredVisibleLineIndex != undefined) { |
| const x = this.VisualLineIndexToDataLineIndex(this.VisualLineStartIdx + this.MouseState.hoveredVisibleLineIndex); |
| if (x != undefined) { |
| const tidx = x[0]; |
| if (this.Titles[tidx] != undefined && this.Titles[tidx].header == true) { |
| |
| // Currently, only DBus pane supports column headers, so we can hard-code the DBus re-group function (rather than to figure out which pane we're in) |
| this.HeaderCollapsed[this.Titles[tidx].title] = !(this.HeaderCollapsed[this.Titles[tidx].title]); |
| OnGroupByConditionChanged_DBus(); |
| } |
| } |
| } |
| } |
| |
| // Assume event.button == 0 (left mouse button) |
| OnMouseUp() { |
| this.MouseState.EndDragScrollBar(); |
| this.MouseState.pressed = false; |
| this.IsCanvasDirty = true; |
| this.UnhighlightIfEmpty(); |
| this.IsHighlightDirty = true; |
| this.MouseState.hoveredSide = undefined; |
| |
| // If highlighted area changed, update the info panel |
| UpdateHighlightedMessagesInfoPanel(); |
| } |
| |
| UnhighlightIfEmpty() { |
| if (this.HighlightedRegion.t0 == this.HighlightedRegion.t1) { |
| this.Unhighlight(); |
| this.IsCanvasDirty = true; |
| return true; |
| } else |
| return false; |
| } |
| |
| OnMouseWheel(event) { |
| event.preventDefault(); |
| const v = this; |
| |
| let is_mouse_on_horizontal_scrollbar = false; |
| if (this.MouseState.y > 0 && this.MouseState.y < TOP_HORIZONTAL_SCROLLBAR_HEIGHT) |
| is_mouse_on_horizontal_scrollbar = true; |
| if (this.MouseState.y > this.Canvas.height - BOTTOM_HORIZONTAL_SCROLLBAR_HEIGHT && |
| this.MouseState.y < this.Canvas.height) |
| is_mouse_on_horizontal_scrollbar = true; |
| |
| if (/*v.IsMouseOverTimeline()*/ is_mouse_on_horizontal_scrollbar) { |
| let dz = 0; |
| if (event.deltaY > 0) { // Scroll down, zoom out |
| dz = -0.3; |
| } else if (event.deltaY < 0) { // Scroll up, zoom in |
| dz = 0.3; |
| } |
| v.Zoom(dz, v.MouseXToTimestamp(v.MouseState.x)); |
| } else { |
| if (event.deltaY > 0) { |
| v.ScrollY(1); |
| } else if (event.deltaY < 0) { |
| v.ScrollY(-1); |
| } |
| } |
| } |
| |
| ScrollY(delta) { |
| this.VisualLineStartIdx += delta; |
| if (this.VisualLineStartIdx < 0) { |
| this.VisualLineStartIdx = 0; |
| } else if (this.VisualLineStartIdx >= this.TotalVisualHeight()) { |
| this.VisualLineStartIdx = this.TotalVisualHeight() - 1; |
| } |
| } |
| |
| // This function is called in Render to draw a line of Intervals. |
| // It is made into its own function for brevity in Render(). |
| // It depends on too much context so it doesn't look very clean though |
| do_RenderIntervals(ctx, intervals_j, j, dy0, dy1, |
| data_line_idx, visual_line_offset_within_data_line, |
| isAggregateSelection, |
| vars, |
| is_in_viewport) { |
| // To reduce the number of draw calls while preserve the accuracy in |
| // the visual presentation, combine rectangles that are within 1 pixel |
| // into one |
| let last_dx_begin = LEFT_MARGIN; |
| let last_dx_end = LEFT_MARGIN; |
| |
| for (let i = 0; i < intervals_j.length; i++) { |
| let lb = intervals_j[i][0], ub = intervals_j[i][1]; |
| const yoffset = intervals_j[i][4]; |
| if (yoffset != visual_line_offset_within_data_line) |
| continue; |
| if (lb > ub) |
| continue; // Unmatched (only enter & no exit timestamp) |
| |
| let isHighlighted = false; |
| let durationUsec = |
| (intervals_j[i][1] - intervals_j[i][0]) * 1000000; |
| let lbub = [lb, ub]; |
| if (this.IsHighlighted()) { |
| if (IsIntersected(lbub, vars.highlightedInterval)) { |
| vars.numIntersected++; |
| isHighlighted = true; |
| vars.currHighlightedReqs.push(intervals_j[i][2]); // TODO: change the name to avoid confusion with HighlightedMessages |
| } |
| } |
| |
| if (ub < this.LowerBoundTime) { |
| vars.numOverflowEntriesToTheLeft++; |
| continue; |
| } |
| if (lb > this.UpperBoundTime) { |
| vars.numOverflowEntriesToTheRight++; |
| continue; |
| } |
| // Failed request |
| if (ub == undefined && lb < this.UpperBoundTime) { |
| vars.numOverflowEntriesToTheLeft++; |
| continue; |
| } |
| |
| let dx0 = MapXCoord( |
| lb, LEFT_MARGIN, RIGHT_MARGIN, this.LowerBoundTime, |
| this.UpperBoundTime), |
| dx1 = MapXCoord( |
| ub, LEFT_MARGIN, RIGHT_MARGIN, this.LowerBoundTime, |
| this.UpperBoundTime); |
| |
| dx0 = Math.max(dx0, LEFT_MARGIN); |
| dx1 = Math.min(dx1, RIGHT_MARGIN); |
| let dw = Math.max(0, dx1 - dx0); |
| |
| if (isHighlighted && is_in_viewport) { |
| ctx.fillStyle = 'rgba(128,128,255,0.5)'; |
| ctx.fillRect(dx0, dy0, dw, dy1 - dy0); |
| } |
| |
| let isCurrentReqHovered = false; |
| // Intersect with mouse using pixel coordinates |
| |
| // When the mouse position is within 4 pixels distance from an entry, consider |
| // the mouse to be over that entry and show the information popup |
| const X_TOLERANCE = 4; |
| |
| if (vars.theHoveredReq == undefined && |
| IsIntersectedPixelCoords( |
| [dx0 - X_TOLERANCE, dx0 + dw + X_TOLERANCE], |
| [this.MouseState.x, this.MouseState.x]) && |
| IsIntersectedPixelCoords( |
| [dy0, dy1], [this.MouseState.y, this.MouseState.y])) { |
| ctx.fillStyle = 'rgba(255,255,0,0.5)'; |
| if (is_in_viewport) ctx.fillRect(dx0, dy0, dw, dy1 - dy0); |
| vars.theHoveredReq = intervals_j[i][2]; |
| vars.theHoveredInterval = intervals_j[i]; |
| isCurrentReqHovered = true; |
| } |
| |
| ctx.lineWidth = 0.5; |
| |
| |
| // If this request is taking too long/is quick enough, use red/green |
| let entry = HistogramThresholds[this.Titles[data_line_idx].title]; |
| |
| let isError = false; |
| if (intervals_j[i][3] == 'error') { |
| isError = true; |
| } |
| |
| if (entry != undefined) { |
| if (entry[0][1] != undefined && durationUsec < entry[0][1]) { |
| ctx.strokeStyle = '#0F0'; |
| } else if ( |
| entry[1][1] != undefined && durationUsec > entry[1][1]) { |
| ctx.strokeStyle = '#A00'; |
| } else { |
| ctx.strokeStyle = '#000'; |
| } |
| } else { |
| ctx.strokeStyle = '#000'; |
| } |
| |
| const duration = intervals_j[i][1] - intervals_j[i][0]; |
| if (!isNaN(duration)) { |
| if (is_in_viewport) { |
| if (isError) { |
| ctx.fillStyle = 'rgba(192, 128, 128, 0.8)'; |
| ctx.fillRect(dx0, dy0, dw, dy1 - dy0); |
| ctx.strokeStyle = 'rgba(192, 128, 128, 1)'; |
| } else { |
| ctx.fillStyle = undefined; |
| ctx.strokeStyle = '#000'; |
| } |
| } |
| |
| // This keeps track of the current "cluster" of requests |
| // that might visually overlap (i.e less than 1 pixel wide). |
| // This can greatly reduce overdraw and keep render time under |
| // a reasonable bound. |
| if (!ShouldShowDebugInfo()) { |
| if (dx0+dw - last_dx_begin > 1 || |
| i == intervals_j.length - 1) { |
| if (is_in_viewport) { |
| ctx.strokeRect(last_dx_begin, dy0, |
| /*dx0+dw-last_dx_begin*/ |
| last_dx_end - last_dx_begin, // At least 1 pixel wide |
| dy1-dy0); |
| } |
| last_dx_begin = dx0; |
| } |
| } else { |
| if (is_in_viewport) { |
| ctx.strokeRect(dx0, dy0, dw, dy1 - dy0); |
| } |
| } |
| last_dx_end = dx0 + dw; |
| this.numVisibleRequests++; |
| } else { |
| // This entry has only a beginning and not an end |
| // perhaps the original method call did not return |
| if (is_in_viewport) { |
| if (isCurrentReqHovered) { |
| ctx.fillStyle = 'rgba(192, 192, 0, 0.8)'; |
| } else { |
| ctx.fillStyle = 'rgba(255, 128, 128, 0.8)'; |
| } |
| ctx.beginPath(); |
| ctx.arc(dx0, (dy0 + dy1) / 2, HISTOGRAM_H * 0.17, 0, 2 * Math.PI); |
| ctx.fill(); |
| } |
| } |
| |
| |
| // Affects whether this req will be reflected in the aggregate info |
| // section |
| if ((isAggregateSelection == false) || |
| (isAggregateSelection == true && isHighlighted == true)) { |
| if (!isNaN(duration)) { |
| vars.numVisibleRequestsCurrLine++; |
| vars.totalSecsCurrLine += duration; |
| } else { |
| vars.numFailedRequestsCurrLine++; |
| } |
| |
| // If a histogram exists for Titles[j], process the highlighted |
| // histogram buckets |
| if (GetHistoryHistogram()[this.Titles[data_line_idx].title] != undefined) { |
| let histogramEntry = GetHistoryHistogram()[this.Titles[data_line_idx].title]; |
| let bucketInterval = (histogramEntry[1] - histogramEntry[0]) / |
| histogramEntry[2].length; |
| let bucketIndex = |
| Math.floor( |
| (durationUsec - histogramEntry[0]) / bucketInterval) / |
| histogramEntry[2].length; |
| |
| if (this.IpmiVizHistHighlighted[this.Titles[data_line_idx].title] == undefined) { |
| this.IpmiVizHistHighlighted[this.Titles[data_line_idx].title] = new Set(); |
| } |
| let entry = this.IpmiVizHistHighlighted[this.Titles[data_line_idx].title]; |
| entry.add(bucketIndex); |
| } |
| } |
| } // end for (i=0 to interval_j.length-1) |
| |
| if (!ShouldShowDebugInfo()) { |
| ctx.strokeRect(last_dx_begin, dy0, |
| /*dx0+dw-last_dx_begin*/ |
| last_dx_end - last_dx_begin, // At least 1 pixel wide |
| dy1-dy0); |
| } |
| } |
| |
| // For the header: |
| do_RenderHeader(ctx, header, j, dy0, dy1, |
| data_line_idx, visual_line_offset_within_data_line, |
| isAggregateSelection, |
| vars, is_in_viewport) { |
| |
| const dy = (dy0+dy1) / 2; |
| ctx.fillStyle = "rgba(192,192,255, 1)"; |
| |
| ctx.strokeStyle = "rgba(192,192,255, 1)" |
| |
| const title_text = header.title + " (" + header.intervals_idxes.length + ")"; |
| let skip_render = false; |
| |
| ctx.save(); |
| |
| if (this.HeaderCollapsed[header.title] == false) { // Expanded |
| const x0 = LEFT_MARGIN - LINE_HEIGHT; |
| if (is_in_viewport) { |
| ctx.fillRect(0, dy-LINE_HEIGHT/2, x0, LINE_HEIGHT); |
| |
| ctx.beginPath(); |
| ctx.moveTo(x0, dy0); |
| ctx.lineTo(x0, dy1); |
| ctx.lineTo(x0 + LINE_HEIGHT, dy1); |
| ctx.fill(); |
| ctx.closePath(); |
| |
| ctx.beginPath(); |
| ctx.lineWidth = 1.5; |
| ctx.moveTo(0, dy1); |
| ctx.lineTo(RIGHT_MARGIN, dy1); |
| ctx.stroke(); |
| ctx.closePath(); |
| |
| ctx.fillStyle = '#003'; |
| ctx.textBaseline = 'center'; |
| ctx.textAlign = 'right'; |
| ctx.fillText(title_text, LEFT_MARGIN - LINE_HEIGHT, dy); |
| } |
| |
| // Don't draw the timelines so visual clutter is reduced |
| skip_render = true; |
| } else { |
| const x0 = LEFT_MARGIN - LINE_HEIGHT / 2; |
| if (is_in_viewport) { |
| ctx.fillRect(0, dy-LINE_HEIGHT/2, x0, LINE_HEIGHT); |
| |
| ctx.beginPath(); |
| ctx.lineWidth = 1.5; |
| ctx.moveTo(x0, dy0); |
| ctx.lineTo(x0 + LINE_HEIGHT/2, dy); |
| ctx.lineTo(x0, dy1); |
| ctx.closePath(); |
| ctx.fill(); |
| |
| /* |
| ctx.beginPath(); |
| ctx.moveTo(0, dy); |
| ctx.lineTo(RIGHT_MARGIN, dy); |
| ctx.stroke(); |
| ctx.closePath(); |
| */ |
| |
| ctx.fillStyle = '#003'; |
| ctx.textBaseline = 'center'; |
| ctx.textAlign = 'right'; |
| ctx.fillText(title_text, LEFT_MARGIN - LINE_HEIGHT, dy); |
| } |
| } |
| |
| ctx.fillStyle = "rgba(160,120,255,0.8)"; |
| |
| ctx.restore(); |
| |
| // Draw the merged intervals |
| // Similar to drawing the actual messages in do_Render(), but no collision detection against the mouse, and no hovering tooltip processing involved |
| const merged_intervals = header.merged_intervals; |
| let dxx0 = undefined, dxx1 = undefined; |
| for (let i=0; i<merged_intervals.length; i++) { |
| const lb = merged_intervals[i][0], ub = merged_intervals[i][1], weight = merged_intervals[i][2]; |
| let duration = ub-lb; |
| let duration_usec = duration * 1000000; |
| const lbub = [lb, ub]; |
| |
| let isHighlighted = false; |
| if (this.IsHighlighted()) { |
| if (IsIntersected(lbub, vars.highlightedInterval)) { |
| vars.numIntersected += weight; |
| isHighlighted = true; |
| } |
| } |
| |
| if (ub < this.LowerBoundTime) continue; |
| if (lb > this.UpperBoundTime) continue; |
| |
| // Render only if collapsed |
| if (!skip_render) { |
| let dx0 = MapXCoord( |
| lb, LEFT_MARGIN, RIGHT_MARGIN, this.LowerBoundTime, |
| this.UpperBoundTime), |
| dx1 = MapXCoord( |
| ub, LEFT_MARGIN, RIGHT_MARGIN, this.LowerBoundTime, |
| this.UpperBoundTime); |
| dx0 = Math.max(dx0, LEFT_MARGIN); |
| dx1 = Math.min(dx1, RIGHT_MARGIN); |
| let dw = Math.max(1, dx1 - dx0); // At least 1 pixel wide during rendering |
| |
| // Draw this interval |
| //ctx.fillRect(dx0, dy0, dw, dy1-dy0); |
| if (dxx0 == undefined || dxx1 == undefined) { |
| dxx0 = dx0; |
| } |
| |
| const MERGE_THRESH = 0.5; // Pixels |
| |
| let should_draw = true; |
| if (dxx1 == undefined || dx0 < dxx1 + MERGE_THRESH) should_draw = false; |
| if (i == merged_intervals.length - 1) { |
| should_draw = true; |
| dxx1 = dx1 + MERGE_THRESH; |
| } |
| |
| if (should_draw) { |
| //console.log(dxx0 + ", " + dy0 + ", " + (dx1-dxx0) + ", " + LINE_HEIGHT); |
| if (is_in_viewport) { |
| ctx.fillRect(dxx0, dy0, dxx1-dxx0, LINE_HEIGHT); |
| } |
| dxx0 = undefined; dxx1 = undefined; |
| } else { |
| // merge |
| dxx1 = dx1 + MERGE_THRESH; |
| } |
| } |
| |
| if ((isAggregateSelection == false) || |
| (isAggregateSelection == true && isHighlighted == true)) { |
| vars.totalSecsCurrLine += duration; |
| vars.numVisibleRequestsCurrLine += weight; |
| } |
| } |
| } |
| |
| Render(ctx) { |
| // Wait for initialization |
| if (this.Canvas == undefined) return; |
| |
| // Update |
| let toFixedPrecision = 2; |
| const extent = this.UpperBoundTime - this.LowerBoundTime; |
| { |
| if (extent < 0.1) { |
| toFixedPrecision = 4; |
| } else if (extent < 1) { |
| toFixedPrecision = 3; |
| } |
| } |
| |
| let dx = this.CurrDeltaX; |
| if (dx != 0) { |
| if (this.CurrShiftFlag) dx *= 5; |
| this.LowerBoundTime += dx * extent; |
| this.UpperBoundTime += dx * extent; |
| this.IsCanvasDirty = true; |
| } |
| |
| // Hovered interval for display |
| let theHoveredReq = undefined; |
| let theHoveredInterval = undefined; |
| let currHighlightedReqs = []; |
| |
| let dz = this.CurrDeltaZoom; |
| this.Zoom(dz); |
| this.UpdateAnimation(); |
| |
| this.LastTimeLowerBound = this.LowerBoundTime; |
| this.LastTimeUpperBound = this.UpperBoundTime; |
| |
| if (this.IsCanvasDirty) { |
| this.IsCanvasDirty = false; |
| // Shorthand for HighlightedRegion.t{0,1} |
| let t0 = undefined, t1 = undefined; |
| |
| // Highlight |
| let highlightedInterval = []; |
| let numIntersected = |
| 0; // How many requests intersect with highlighted area |
| if (this.IsHighlighted()) { |
| t0 = Math.min(this.HighlightedRegion.t0, this.HighlightedRegion.t1); |
| t1 = Math.max(this.HighlightedRegion.t0, this.HighlightedRegion.t1); |
| highlightedInterval = [t0, t1]; |
| } |
| this.IpmiVizHistHighlighted = {}; |
| |
| const width = this.Canvas.width; |
| const height = this.Canvas.height; |
| |
| ctx.globalCompositeOperation = 'source-over'; |
| ctx.clearRect(0, 0, width, height); |
| ctx.strokeStyle = '#000'; |
| ctx.fillStyle = '#000'; |
| ctx.lineWidth = 1; |
| |
| ctx.font = '12px Monospace'; |
| |
| // Highlight current line |
| if (this.MouseState.hoveredVisibleLineIndex != undefined) { |
| const hv_lidx = this.MouseState.hoveredVisibleLineIndex + this.VisualLineStartIdx; |
| if (hv_lidx >= 0 && |
| hv_lidx < this.Titles.length) { |
| ctx.fillStyle = 'rgba(32,32,32,0.2)'; |
| let dy = YBEGIN + LINE_SPACING * this.MouseState.hoveredVisibleLineIndex - |
| LINE_SPACING / 2; |
| ctx.fillRect(0, dy, RIGHT_MARGIN, LINE_SPACING); |
| } |
| } |
| |
| // Draw highlighted background over time labels when the mouse is hovering over |
| // the time axis |
| ctx.fillStyle = "#FF9"; |
| if (this.MouseState.hoveredSide == "top_horizontal_scrollbar") { |
| ctx.fillRect(LEFT_MARGIN, 0, RIGHT_MARGIN-LEFT_MARGIN, TOP_HORIZONTAL_SCROLLBAR_HEIGHT); |
| } else if (this.MouseState.hoveredSide == "bottom_horizontal_scrollbar") { |
| ctx.fillRect(LEFT_MARGIN, height-BOTTOM_HORIZONTAL_SCROLLBAR_HEIGHT, RIGHT_MARGIN-LEFT_MARGIN, BOTTOM_HORIZONTAL_SCROLLBAR_HEIGHT); |
| } |
| |
| ctx.fillStyle = '#000'; |
| // Time marks at the beginning & end of the visible range |
| ctx.textBaseline = 'bottom'; |
| ctx.textAlign = 'left'; |
| ctx.fillText( |
| '' + this.LowerBoundTime.toFixed(toFixedPrecision) + 's', |
| LEFT_MARGIN + 3, height); |
| ctx.textAlign = 'end'; |
| ctx.fillText( |
| '' + this.UpperBoundTime.toFixed(toFixedPrecision) + 's', |
| RIGHT_MARGIN - 3, height); |
| |
| ctx.textBaseline = 'top'; |
| ctx.textAlign = 'left'; |
| ctx.fillText( |
| '' + this.LowerBoundTime.toFixed(toFixedPrecision) + 's', |
| LEFT_MARGIN + 3, TEXT_Y0); |
| ctx.textAlign = 'right'; |
| ctx.fillText( |
| '' + this.UpperBoundTime.toFixed(toFixedPrecision) + 's', |
| RIGHT_MARGIN - 3, TEXT_Y0); |
| |
| let y = YBEGIN; |
| let numVisibleRequests = 0; |
| |
| ctx.beginPath(); |
| ctx.moveTo(LEFT_MARGIN, 0); |
| ctx.lineTo(LEFT_MARGIN, height); |
| ctx.stroke(); |
| |
| ctx.beginPath(); |
| ctx.moveTo(RIGHT_MARGIN, 0); |
| ctx.lineTo(RIGHT_MARGIN, height); |
| ctx.stroke(); |
| |
| // Column Titles |
| ctx.fillStyle = '#000'; |
| let columnTitle = '(All requests)'; |
| if (this.GroupByStr.length > 0) { |
| columnTitle = this.GroupByStr; |
| } |
| ctx.textAlign = 'right'; |
| ctx.textBaseline = 'top'; |
| // Split into lines |
| { |
| let lines = this.ToLines(columnTitle, this.TitleDispLengthLimit) |
| for (let i = 0; i < lines.length; i++) { |
| ctx.fillText(lines[i], LEFT_MARGIN - 3, 3 + i * LINE_HEIGHT); |
| } |
| } |
| |
| if (this.IsTimeDistributionEnabled) { |
| // "Histogram" title |
| ctx.fillStyle = '#000'; |
| ctx.textBaseline = 'top'; |
| ctx.textAlign = 'center'; |
| ctx.fillText('Time Distribution', HISTOGRAM_X, TEXT_Y0); |
| |
| ctx.textAlign = 'right' |
| ctx.fillText('In dataset /', HISTOGRAM_X, TEXT_Y0 + LINE_SPACING - 2); |
| |
| ctx.fillStyle = '#00F'; |
| |
| ctx.textAlign = 'left' |
| if (this.IsHighlighted()) { |
| ctx.fillText( |
| ' In selection', HISTOGRAM_X, TEXT_Y0 + LINE_SPACING - 2); |
| } |
| else { |
| ctx.fillText(' In viewport', HISTOGRAM_X, TEXT_Y0 + LINE_SPACING - 2); |
| } |
| } |
| |
| ctx.fillStyle = '#000'; |
| |
| // Time Axis Breaks |
| const breakWidths = [ |
| 86400, 10800, 3600, 1800, 1200, 600, 300, 120, |
| 60, 30, 10, 5, 2, 1, 0.5, 0.2, |
| 0.1, 0.05, 0.02, 0.01, 0.005, 0.002, 0.001, 0.0005, |
| 0.0002, 0.0001, 0.00005, 0.00002, 0.00001 |
| ]; |
| const BreakDrawLimit = 1000; // Only draw up to this many grid lines |
| |
| let bidx = 0; |
| while (bidx < breakWidths.length && |
| breakWidths[bidx] > this.UpperBoundTime - this.LowerBoundTime) { |
| bidx++; |
| } |
| let breakWidth = breakWidths[bidx + 1]; |
| if (bidx < breakWidths.length) { |
| let t2 = 0; // Cannot name as "t0" otherwise clash |
| bidx = 0; |
| while (bidx < breakWidths.length) { |
| while (t2 + breakWidths[bidx] < this.LowerBoundTime) { |
| t2 += breakWidths[bidx]; |
| } |
| if (t2 + breakWidths[bidx] >= this.LowerBoundTime && |
| t2 + breakWidths[bidx] <= this.UpperBoundTime) { |
| break; |
| } |
| bidx++; |
| } |
| let draw_count = 0; |
| if (bidx < breakWidths.length) { |
| for (; t2 < this.UpperBoundTime; t2 += breakWidth) { |
| if (t2 > this.LowerBoundTime) { |
| ctx.beginPath(); |
| let dx = MapXCoord( |
| t2, LEFT_MARGIN, RIGHT_MARGIN, this.LowerBoundTime, |
| this.UpperBoundTime); |
| ctx.strokeStyle = '#C0C0C0'; |
| ctx.moveTo(dx, 0); |
| ctx.lineTo(dx, height); |
| ctx.stroke(); |
| ctx.closePath(); |
| ctx.fillStyle = '#C0C0C0'; |
| |
| ctx.textAlign = 'left'; |
| ctx.textBaseline = 'bottom'; |
| let label2 = t2.toFixed(toFixedPrecision) + 's'; |
| let w = ctx.measureText(label2).width; |
| if (dx + w > RIGHT_MARGIN) ctx.textAlign = 'right'; |
| ctx.fillText(label2, dx, height); |
| |
| ctx.textBaseline = 'top'; |
| ctx.fillText(label2, dx, TEXT_Y0); |
| |
| draw_count++; |
| if (draw_count > BreakDrawLimit) break; |
| } |
| } |
| } |
| } |
| |
| // Whether we aggregate selected requests or visible requests |
| let isAggregateSelection = false; |
| if (this.IsHighlighted()) isAggregateSelection = true; |
| let numVisibleRequestsPerLine = {}; // DataLineIndex -> Count |
| let numFailedRequestsPerLine = {}; |
| let totalSecondsPerLine = {}; |
| |
| // Range of Titles that were displayed |
| let title_start_idx = this.VisualLineStartIdx, title_end_idx = title_start_idx; |
| |
| const tvh = this.TotalVisualHeight(); |
| |
| // This is used to handle Intervals that have overlapping entries |
| let last_data_line_idx = -999;//this.VisualLineIndexToDataLineIndex(this.VisualLineStartIdx); |
| |
| // 'j' denotes a line index; if the viewport starts from the middle of an overlapping series of |
| // lines, 'j' will be rewinded to the first one in the series to make the counts correct. |
| let j0 = this.VisualLineStartIdx; |
| while (j0 > 0 && this.VisualLineIndexToDataLineIndex(j0)[1] > 0) { j0--; } |
| |
| // If should_render is false, we're counting the entries outisde the viewport |
| // If should_render is true, do the rendering |
| let should_render = false; |
| |
| // 'j' then iterates over the "visual rows" that need to be displayed. |
| // A "visual row" might be one of: |
| // 1. a "header" line |
| // 2. an actual row of data (in the Intervals variable) |
| |
| // 'j' needs to go PAST the viewport if the last row is overlapping and spans beyond the viewport. |
| for (let j = j0; j < tvh; j++) { |
| |
| if (j >= this.VisualLineStartIdx) { should_render = true; } |
| if (y > height) { should_render = false; } |
| |
| const tmp = this.VisualLineIndexToDataLineIndex(j); |
| if (tmp == undefined) break; |
| const data_line_idx = tmp[0]; |
| const visual_line_offset_within_data_line = tmp[1]; |
| |
| const should_render_title = (data_line_idx != last_data_line_idx) || |
| (j == this.VisualLineStartIdx); // The first visible line should always be drawn |
| last_data_line_idx = data_line_idx; |
| |
| if (should_render_title && data_line_idx != -999 && should_render) { // Only draw line title and histogram per data line index not visual line index |
| ctx.textBaseline = 'middle'; |
| ctx.textAlign = 'right'; |
| let desc_width = 0; |
| if (NetFnCmdToDescription[this.Titles[data_line_idx].title] != undefined) { |
| let desc = ' (' + NetFnCmdToDescription[this.Titles[data_line_idx].title] + ')'; |
| desc_width = ctx.measureText(desc).width; |
| ctx.fillStyle = '#888'; // Grey |
| ctx.fillText(desc, LEFT_MARGIN - 3, y); |
| } |
| |
| |
| // Plot histogram |
| if (this.IsTimeDistributionEnabled == true) { |
| const t = this.Titles[data_line_idx].title; |
| if (GetHistoryHistogram()[t] != undefined) { |
| if (this.IpmiVizHistogramImageData[t] == undefined) { |
| let tmp = RenderHistogramForImageData(ctx, t); |
| this.IpmiVizHistogramImageData[t] = tmp[0]; |
| HistogramThresholds[t] = tmp[1]; |
| } |
| this.RenderHistogram(ctx, t, HISTOGRAM_X, y); |
| ctx.textAlignment = 'right'; |
| } else { |
| } |
| } |
| |
| // If is HEADER: do not draw here, darw in do_RenderHeader() |
| if (this.Titles[data_line_idx].header == false) { |
| ctx.textAlignment = 'right'; |
| ctx.textBaseline = 'middle'; |
| ctx.fillStyle = '#000000'; // Revert to Black |
| ctx.strokeStyle = '#000000'; |
| let tj_draw = this.Titles[data_line_idx].title; |
| const title_disp_length_limit = this.GetTitleWidthLimit(); |
| if (tj_draw != undefined && tj_draw.length > title_disp_length_limit) { |
| tj_draw = tj_draw.substr(0, title_disp_length_limit) + '...' |
| } |
| ctx.fillText(tj_draw, LEFT_MARGIN - 3 - desc_width, y); |
| } |
| } else if (should_render_title && data_line_idx == -999) { |
| continue; |
| } |
| |
| let numOverflowEntriesToTheLeft = 0; // #entries below the lower bound |
| let numOverflowEntriesToTheRight = |
| 0; // #entries beyond the upper bound |
| let numVisibleRequestsCurrLine = 0; // #entries visible |
| let totalSecsCurrLine = 0; // Total duration in seconds |
| let numFailedRequestsCurrLine = 0; |
| |
| const intervals_idxes = this.Titles[data_line_idx].intervals_idxes; |
| |
| let intervals_j = undefined; |
| if (intervals_idxes.length == 1) { |
| intervals_j = this.Intervals[intervals_idxes[0]]; |
| } |
| |
| // Draw the contents in the set of intervals |
| // The drawing method depends on whether this data line is a header or not |
| |
| // Save the context for reference for the rendering routines |
| let vars = { |
| "theHoveredReq": theHoveredReq, |
| "theHoveredInterval": theHoveredInterval, |
| "numIntersected": numIntersected, |
| "numOverflowEntriesToTheLeft": numOverflowEntriesToTheLeft, |
| "numOverflowEntriesToTheRight": numOverflowEntriesToTheRight, |
| "currHighlightedReqs": currHighlightedReqs, |
| "totalSecondsPerLine": totalSecondsPerLine, |
| "highlightedInterval": highlightedInterval, |
| "numVisibleRequestsCurrLine": numVisibleRequestsCurrLine, |
| "totalSecsCurrLine": totalSecsCurrLine, |
| } // Emulate a reference |
| |
| let dy0 = y - LINE_HEIGHT / 2, dy1 = y + LINE_HEIGHT / 2; |
| if (this.Titles[data_line_idx].header == false) { |
| if (intervals_j != undefined) { |
| this.do_RenderIntervals(ctx, intervals_j, j, dy0, dy1, |
| data_line_idx, visual_line_offset_within_data_line, isAggregateSelection, vars, should_render); |
| } |
| } else { |
| this.do_RenderHeader(ctx, this.Titles[data_line_idx], |
| j, dy0, dy1, |
| data_line_idx, visual_line_offset_within_data_line, isAggregateSelection, vars, should_render); |
| } |
| |
| // Update the context variables with updated values |
| theHoveredReq = vars.theHoveredReq; |
| theHoveredInterval = vars.theHoveredInterval; |
| numIntersected = vars.numIntersected; |
| numOverflowEntriesToTheLeft = vars.numOverflowEntriesToTheLeft; |
| numOverflowEntriesToTheRight = vars.numOverflowEntriesToTheRight; |
| currHighlightedReqs = vars.currHighlightedReqs; |
| totalSecondsPerLine = vars.totalSecondsPerLine; |
| highlightedInterval = vars.highlightedInterval; |
| numVisibleRequestsCurrLine = vars.numVisibleRequestsCurrLine; |
| totalSecsCurrLine = vars.totalSecsCurrLine; |
| |
| // Triangle markers for entries outside of the viewport |
| { |
| const PAD = 2, H = LINE_SPACING; |
| if (this.MouseState.hoveredVisibleLineIndex + this.VisualLineStartIdx == data_line_idx && |
| this.MouseState.hoveredSide == 'left') { |
| ctx.fillStyle = '#0000FF'; |
| } else { |
| ctx.fillStyle = 'rgba(128,128,0,0.5)'; |
| } |
| if (numOverflowEntriesToTheLeft > 0) { |
| ctx.beginPath(); |
| ctx.moveTo(LEFT_MARGIN + PAD + H / 2, y - H / 2); |
| ctx.lineTo(LEFT_MARGIN + PAD, y); |
| ctx.lineTo(LEFT_MARGIN + PAD + H / 2, y + H / 2); |
| ctx.closePath(); |
| ctx.fill(); |
| ctx.textAlign = 'left'; |
| ctx.textBaseline = 'center'; |
| ctx.fillText( |
| '+' + numOverflowEntriesToTheLeft, |
| LEFT_MARGIN + 2 * PAD + H / 2, y); |
| } |
| |
| if (this.MouseState.hoveredVisibleLineIndex + this.VisualLineStartIdx == j && |
| this.MouseState.hoveredSide == 'right') { |
| ctx.fillStyle = '#0000FF'; |
| } else { |
| ctx.fillStyle = 'rgba(128,128,0,0.5)'; |
| } |
| if (numOverflowEntriesToTheRight > 0) { |
| ctx.beginPath(); |
| ctx.moveTo(RIGHT_MARGIN - PAD - H / 2, y - H / 2); |
| ctx.lineTo(RIGHT_MARGIN - PAD, y); |
| ctx.lineTo(RIGHT_MARGIN - PAD - H / 2, y + H / 2); |
| ctx.closePath(); |
| ctx.fill(); |
| ctx.textAlign = 'right'; |
| ctx.fillText( |
| '+' + numOverflowEntriesToTheRight, |
| RIGHT_MARGIN - 2 * PAD - H / 2, y); |
| } |
| } |
| |
| if (should_render) |
| y = y + LINE_SPACING; |
| |
| // Should aggregate. |
| if (!(data_line_idx in numVisibleRequestsPerLine)) { numVisibleRequestsPerLine[data_line_idx] = 0; } |
| numVisibleRequestsPerLine[data_line_idx] += numVisibleRequestsCurrLine; |
| |
| if (!(data_line_idx in numFailedRequestsPerLine)) { numFailedRequestsPerLine[data_line_idx] = 0; } |
| numFailedRequestsPerLine[data_line_idx] += numFailedRequestsCurrLine; |
| |
| if (!(data_line_idx in totalSecondsPerLine)) { totalSecondsPerLine[data_line_idx] = 0; } |
| totalSecondsPerLine[data_line_idx] += totalSecsCurrLine; |
| |
| title_end_idx = j; |
| |
| if (y > height) { |
| // Make sure we don't miss the entry count of the rows beyond the viewport |
| if (visual_line_offset_within_data_line == 0) { |
| break; |
| } |
| } |
| } |
| |
| { |
| let nbreaks = this.TotalVisualHeight(); |
| // Draw a scroll bar on the left |
| if (!(title_start_idx == 0 && title_end_idx == nbreaks - 1)) { |
| |
| const y0 = title_start_idx * height / nbreaks; |
| const y1 = (1 + title_end_idx) * height / nbreaks; |
| |
| let highlighted = false; |
| const THRESH = 8; |
| if (this.MouseState.IsDraggingScrollBar()) { |
| highlighted = true; |
| } |
| this.ScrollBarState.highlighted = highlighted; |
| |
| // If not dragging, let title_start_idx drive y0 and y1, else let the |
| // user's input drive y0 and y1 and title_start_idx |
| if (!this.MouseState.IsDraggingScrollBar()) { |
| this.ScrollBarState.y0 = y0; |
| this.ScrollBarState.y1 = y1; |
| } |
| |
| if (highlighted) { |
| ctx.fillStyle = "#FF3"; |
| } else { |
| ctx.fillStyle = this.AccentColor; |
| } |
| ctx.fillRect(0, y0, SCROLL_BAR_WIDTH, y1 - y0); |
| |
| } else { |
| this.ScrollBarState.y0 = undefined; |
| this.ScrollBarState.y1 = undefined; |
| this.ScrollBarState.highlighted = false; |
| } |
| } |
| |
| // Draw highlighted sections for the histograms |
| if (this.IsTimeDistributionEnabled) { |
| y = YBEGIN; |
| for (let j = this.TitleStartIdx; j < this.Intervals.length; j++) { |
| if (this.IpmiVizHistHighlighted[this.Titles[data_line_idx].title] != undefined) { |
| let entry = HistogramThresholds[this.Titles[data_line_idx].title]; |
| const theSet = |
| Array.from(this.IpmiVizHistHighlighted[this.Titles[data_line_idx].title]); |
| for (let i = 0; i < theSet.length; i++) { |
| bidx = theSet[i]; |
| if (entry != undefined) { |
| if (bidx < entry[0][0]) { |
| if (bidx < 0) { |
| bidx = 0; |
| } |
| ctx.fillStyle = 'rgba(0, 255, 0, 0.3)'; |
| } else if (bidx > entry[1][0]) { |
| if (bidx > 1) { |
| bidx = 1; |
| } |
| ctx.fillStyle = 'rgba(255,0,0,0.3)'; |
| } else { |
| ctx.fillStyle = 'rgba(0,0,255,0.3)'; |
| } |
| } else { |
| ctx.fillStyle = 'rgba(0,0,255,0.3)'; |
| } |
| const dx = HISTOGRAM_X - HISTOGRAM_W / 2 + HISTOGRAM_W * bidx; |
| |
| const r = HISTOGRAM_H * 0.17; |
| ctx.beginPath(); |
| ctx.ellipse(dx, y, r, r, 0, 0, 3.14159 * 2); |
| ctx.fill(); |
| } |
| } |
| y += LINE_SPACING; |
| } |
| } |
| |
| // Render number of visible requests versus totals |
| ctx.textAlign = 'left'; |
| ctx.textBaseline = 'top'; |
| let totalOccs = 0, totalSecs = 0; |
| if (this.IsHighlighted()) { |
| ctx.fillStyle = '#00F'; |
| ctx.fillText('# / time', 3, TEXT_Y0); |
| ctx.fillText('in selection', 3, TEXT_Y0 + LINE_SPACING - 2); |
| } else { |
| ctx.fillStyle = '#000'; |
| ctx.fillText('# / time', 3, TEXT_Y0); |
| ctx.fillText('in viewport', 3, TEXT_Y0 + LINE_SPACING - 2); |
| } |
| |
| let timeDesc = ''; |
| ctx.textBaseline = 'middle'; |
| last_data_line_idx = -999; |
| |
| for (let j = this.VisualLineStartIdx, i = 0; |
| j < tvh && (YBEGIN + i*LINE_SPACING)<height; j++, i++) { |
| const x = this.VisualLineIndexToDataLineIndex(j); |
| if (x == undefined) break; |
| const data_line_idx = x[0]; |
| if (data_line_idx == undefined) break; |
| if (data_line_idx != last_data_line_idx) { |
| let y1 = YBEGIN + LINE_SPACING * (i); |
| let totalSeconds = totalSecondsPerLine[data_line_idx]; |
| if (totalSeconds < 1) { |
| timeDesc = (totalSeconds * 1000.0).toFixed(toFixedPrecision) + 'ms'; |
| } else if (totalSeconds != undefined) { |
| timeDesc = totalSeconds.toFixed(toFixedPrecision) + 's'; |
| } else { |
| timeDesc = "???" |
| } |
| |
| const n0 = numVisibleRequestsPerLine[data_line_idx]; |
| const n1 = numFailedRequestsPerLine[data_line_idx]; |
| let txt = ''; |
| if (n1 > 0) { |
| txt = '' + n0 + '+' + n1 + ' / ' + timeDesc; |
| } else { |
| txt = '' + n0 + ' / ' + timeDesc; |
| } |
| |
| const tw = ctx.measureText(txt).width; |
| const PAD = 8; |
| |
| ctx.fillStyle = '#000'; |
| ctx.fillText(txt, 3, y1); |
| totalOccs += numVisibleRequestsPerLine[data_line_idx]; |
| totalSecs += totalSeconds; |
| } |
| last_data_line_idx = data_line_idx; |
| } |
| |
| // This does not get displayed correctly, so disabling for now |
| //timeDesc = ''; |
| //if (totalSecs < 1) { |
| // timeDesc = '' + (totalSecs * 1000).toFixed(toFixedPrecision) + 'ms'; |
| //} else { |
| // timeDesc = '' + totalSecs.toFixed(toFixedPrecision) + 's'; |
| //} |
| |
| //ctx.fillText('Sum:', 3, y + 2 * LINE_SPACING); |
| //ctx.fillText('' + totalOccs + ' / ' + timeDesc, 3, y + 3 * LINE_SPACING); |
| |
| // Update highlighted requests |
| if (this.IsHighlightDirty) { |
| this.HighlightedRequests = currHighlightedReqs; |
| this.IsHighlightDirty = false; |
| |
| // Todo: This callback will be different for the DBus pane |
| OnHighlightedChanged(HighlightedRequests); |
| } |
| |
| // Render highlight statistics |
| if (this.IsHighlighted()) { |
| ctx.fillStyle = 'rgba(128,128,255,0.5)'; |
| let x0 = MapXCoord( |
| t0, LEFT_MARGIN, RIGHT_MARGIN, this.LowerBoundTime, |
| this.UpperBoundTime); |
| let x1 = MapXCoord( |
| t1, LEFT_MARGIN, RIGHT_MARGIN, this.LowerBoundTime, |
| this.UpperBoundTime); |
| ctx.fillRect(x0, 0, x1 - x0, height); |
| |
| let label0 = '' + t0.toFixed(toFixedPrecision) + 's'; |
| let label1 = '' + t1.toFixed(toFixedPrecision) + 's'; |
| let width0 = ctx.measureText(label0).width; |
| let width1 = ctx.measureText(label1).width; |
| let dispWidth = x1 - x0; |
| // Draw time marks outside or inside? |
| ctx.fillStyle = '#0000FF'; |
| ctx.textBaseline = 'top'; |
| if (dispWidth > width0 + width1) { |
| ctx.textAlign = 'left'; |
| ctx.fillText(label0, x0, LINE_SPACING + TEXT_Y0); |
| ctx.textAlign = 'right'; |
| ctx.fillText(label1, x1, LINE_SPACING + TEXT_Y0); |
| } else { |
| ctx.textAlign = 'right'; |
| ctx.fillText(label0, x0, LINE_SPACING + TEXT_Y0); |
| ctx.textAlign = 'left'; |
| ctx.fillText(label1, x1, LINE_SPACING + TEXT_Y0); |
| } |
| |
| // This was calculated earlier |
| ctx.textAlign = 'center'; |
| label1 = 'Duration: ' + (t1 - t0).toFixed(toFixedPrecision) + 's'; |
| ctx.fillText(label1, (x0 + x1) / 2, height - LINE_SPACING * 2); |
| } |
| |
| // Hovering cursor |
| // Only draw when the mouse is not over any hotizontal scroll bar |
| let should_hide_cursor = false; |
| |
| if (this.MouseState.hoveredSide == "top_horizontal_scrollbar" || |
| this.MouseState.hoveredSide == "bottom_horizontal_scrollbar") { |
| should_hide_cursor = true; |
| } |
| this.linked_views.forEach((v) => { |
| if (v.MouseState.hoveredSide == "top_horizontal_scrollbar" || |
| v.MouseState.hoveredSide == "bottom_horizontal_scrollbar") { |
| should_hide_cursor = true; |
| } |
| }) |
| |
| if (this.MouseState.hovered == true && |
| this.MouseState.hoveredSide == undefined && |
| should_hide_cursor == false) { |
| ctx.beginPath(); |
| ctx.strokeStyle = '#0000FF'; |
| ctx.lineWidth = 1; |
| if (this.IsHighlighted()) { |
| ctx.moveTo(this.MouseState.x, 0); |
| ctx.lineTo(this.MouseState.x, height); |
| } else { |
| ctx.moveTo(this.MouseState.x, LINE_SPACING * 2); |
| ctx.lineTo(this.MouseState.x, height - LINE_SPACING * 2); |
| } |
| ctx.stroke(); |
| |
| if (this.IsHighlighted() == false) { |
| let dispWidth = this.MouseState.x - LEFT_MARGIN; |
| let label = '' + |
| this.MouseXToTimestamp(this.MouseState.x) |
| .toFixed(toFixedPrecision) + |
| 's'; |
| let width0 = ctx.measureText(label).width; |
| ctx.fillStyle = '#0000FF'; |
| ctx.textBaseline = 'bottom'; |
| ctx.textAlign = 'center'; |
| ctx.fillText(label, this.MouseState.x, height - LINE_SPACING); |
| ctx.textBaseline = 'top'; |
| ctx.fillText(label, this.MouseState.x, LINE_SPACING + TEXT_Y0); |
| } |
| } |
| |
| // Tooltip box next to hovered entry |
| if (theHoveredReq !== undefined) { |
| this.RenderToolTip( |
| ctx, theHoveredReq, theHoveredInterval, toFixedPrecision, height); |
| } |
| } // End IsCanvasDirty |
| } |
| |
| // Returns list of highlighted messages. |
| // Format: [ Title, [Message] ] |
| HighlightedMessages() { |
| let ret = []; |
| if (this.HighlightedRegion.t0 == -999 || this.HighlightedRegion.t1 == -999) { return ret; } |
| const lb = Math.min(this.HighlightedRegion.t0, this.HighlightedRegion.t1); |
| const ub = Math.max(this.HighlightedRegion.t0, this.HighlightedRegion.t1); |
| for (let i=0; i<this.Titles.length; i++) { |
| const title = this.Titles[i]; |
| if (title.header == true) continue; // Do not include headers. TODO: Allow rectangular selection |
| |
| const line = [ title.title, [] ]; |
| const interval_idx = title.intervals_idxes[0]; |
| const intervals_i = this.Intervals[interval_idx]; |
| for (let j=0; j<intervals_i.length; j++) { |
| const m = intervals_i[j]; |
| if (!(m[0] > ub || m[1] < lb)) { |
| line[1].push(m); |
| } |
| } |
| if (line[1].length > 0) { |
| ret.push(line); |
| } |
| } |
| return ret; |
| } |
| }; |
| |
| // The extended classes have their own way of drawing popups for hovered entries |
| class IPMITimelineView extends TimelineView { |
| RenderToolTip( |
| ctx, theHoveredReq, theHoveredInterval, toFixedPrecision, height) { |
| if (theHoveredReq == undefined) { |
| return; |
| } |
| const PAD = 2, DELTA_Y = 14; |
| |
| let labels = []; |
| let netFn = theHoveredReq[0]; |
| let cmd = theHoveredReq[1]; |
| let t0 = theHoveredInterval[0]; |
| let t1 = theHoveredInterval[1]; |
| |
| labels.push('Netfn and CMD : (' + netFn + ', ' + cmd + ')'); |
| let key = netFn + ', ' + cmd; |
| |
| if (NetFnCmdToDescription[key] != undefined) { |
| labels.push('Description : ' + NetFnCmdToDescription[key]); |
| } |
| |
| if (theHoveredReq.offset != undefined) { |
| labels.push('Offset : ' + theHoveredReq.offset); |
| } |
| |
| let req = theHoveredReq[4]; |
| labels.push('Request Data : ' + req.length + ' bytes'); |
| if (req.length > 0) { |
| labels.push('Hex : ' + ToHexString(req, '', ' ')); |
| labels.push('ASCII : ' + ToASCIIString(req)); |
| } |
| let resp = theHoveredReq[5]; |
| labels.push('Response Data : ' + theHoveredReq[5].length + ' bytes'); |
| if (resp.length > 0) { |
| labels.push('Hex : ' + ToHexString(resp, '', ' ')); |
| labels.push('ASCII : ' + ToASCIIString(resp)); |
| } |
| labels.push('Start : ' + t0.toFixed(toFixedPrecision) + 's'); |
| labels.push('End : ' + t1.toFixed(toFixedPrecision) + 's'); |
| labels.push('Duration : ' + ((t1 - t0) * 1000).toFixed(3) + 'ms'); |
| |
| |
| let w = 1, h = LINE_SPACING * labels.length + 2 * PAD; |
| for (let i = 0; i < labels.length; i++) { |
| w = Math.max(w, ctx.measureText(labels[i]).width); |
| } |
| let dy = this.MouseState.y + DELTA_Y; |
| if (dy + h > height) { |
| dy = height - h; |
| } |
| let dx = this.MouseState.x; |
| if (RIGHT_MARGIN - dx < w) dx -= (w + 2 * PAD); |
| |
| ctx.fillStyle = 'rgba(0,0,0,0.5)'; |
| ctx.fillRect(dx, dy, w + 2 * PAD, h); |
| |
| ctx.textAlign = 'left'; |
| ctx.textBaseline = 'middle'; |
| ctx.fillStyle = '#FFFFFF'; |
| for (let i = 0; i < labels.length; i++) { |
| ctx.fillText( |
| labels[i], dx + PAD, dy + PAD + i * LINE_SPACING + LINE_SPACING / 2); |
| } |
| } |
| }; |
| |
| class DBusTimelineView extends TimelineView { |
| RenderToolTip( |
| ctx, theHoveredReq, theHoveredInterval, toFixedPrecision, height) { |
| if (theHoveredReq == undefined) { |
| return; |
| } |
| const PAD = 2, DELTA_Y = 14; |
| |
| let labels = []; |
| let msg_type = theHoveredReq[0]; |
| let serial = theHoveredReq[2]; |
| let sender = theHoveredReq[3]; |
| let destination = theHoveredReq[4]; |
| let path = theHoveredReq[5]; |
| let iface = theHoveredReq[6]; |
| let member = theHoveredReq[7]; |
| |
| let t0 = theHoveredInterval[0]; |
| let t1 = theHoveredInterval[1]; |
| |
| labels.push('Message type: ' + msg_type); |
| labels.push('Serial : ' + serial); |
| labels.push('Sender : ' + sender); |
| labels.push('Destination : ' + destination); |
| labels.push('Path : ' + path); |
| labels.push('Interface : ' + iface); |
| labels.push('Member : ' + member); |
| |
| let w = 1, h = LINE_SPACING * labels.length + 2 * PAD; |
| for (let i = 0; i < labels.length; i++) { |
| w = Math.max(w, ctx.measureText(labels[i]).width); |
| } |
| let dy = this.MouseState.y + DELTA_Y; |
| if (dy + h > height) { |
| dy = height - h; |
| } |
| let dx = this.MouseState.x; |
| if (RIGHT_MARGIN - dx < w) dx -= (w + 2 * PAD); |
| |
| ctx.fillStyle = 'rgba(0,0,0,0.5)'; |
| ctx.fillRect(dx, dy, w + 2 * PAD, h); |
| |
| ctx.textAlign = 'left'; |
| ctx.textBaseline = 'middle'; |
| ctx.fillStyle = '#FFFFFF'; |
| for (let i = 0; i < labels.length; i++) { |
| ctx.fillText( |
| labels[i], dx + PAD, dy + PAD + i * LINE_SPACING + LINE_SPACING / 2); |
| } |
| } |
| }; |
| |
| class BoostASIOHandlerTimelineView extends TimelineView { |
| RenderToolTip( |
| ctx, theHoveredReq, theHoveredInterval, toFixedPrecision, height) { |
| if (theHoveredReq == undefined) { |
| return; |
| } |
| const PAD = 2, DELTA_Y = 14; |
| |
| let labels = []; |
| let create_time = theHoveredReq[2]; |
| let enter_time = theHoveredReq[3]; |
| let exit_time = theHoveredReq[4]; |
| let desc = theHoveredReq[5]; |
| |
| let t0 = theHoveredInterval[0]; |
| let t1 = theHoveredInterval[1]; |
| |
| labels.push('Creation time: ' + create_time); |
| labels.push('Entry time : ' + enter_time); |
| labels.push('Exit time : ' + exit_time); |
| labels.push('Creation->Entry : ' + (enter_time - create_time)); |
| labels.push('Entry->Exit : ' + (exit_time - enter_time)); |
| labels.push('Description : ' + desc); |
| |
| let w = 1, h = LINE_SPACING * labels.length + 2 * PAD; |
| for (let i = 0; i < labels.length; i++) { |
| w = Math.max(w, ctx.measureText(labels[i]).width); |
| } |
| let dy = this.MouseState.y + DELTA_Y; |
| if (dy + h > height) { |
| dy = height - h; |
| } |
| let dx = this.MouseState.x; |
| if (RIGHT_MARGIN - dx < w) dx -= (w + 2 * PAD); |
| |
| ctx.fillStyle = 'rgba(0,0,0,0.5)'; |
| ctx.fillRect(dx, dy, w + 2 * PAD, h); |
| |
| ctx.textAlign = 'left'; |
| ctx.textBaseline = 'middle'; |
| ctx.fillStyle = '#FFFFFF'; |
| for (let i = 0; i < labels.length; i++) { |
| ctx.fillText( |
| labels[i], dx + PAD, dy + PAD + i * LINE_SPACING + LINE_SPACING / 2); |
| } |
| } |
| } |