ui/src/frontend/panel_container.ts - third_party/perfetto - Git at Google

 // Copyright (C) 2018 The Android Open Source Project
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
 //
 //      http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.

 import m from 'mithril';
 import {findRef, toHTMLElement} from '../base/dom_utils';
 import {assertExists, assertFalse} from '../base/logging';
 import {
   PerfStats,
   PerfStatsContainer,
   runningStatStr,
 } from '../core/perf_stats';
 import {raf} from '../core/raf_scheduler';
 import {SimpleResizeObserver} from '../base/resize_observer';
 import {canvasClip} from '../base/canvas_utils';
 import {SELECTION_STROKE_COLOR, TRACK_SHELL_WIDTH} from './css_constants';
 import {Bounds2D, Size2D, VerticalBounds} from '../base/geom';
 import {VirtualCanvas} from './virtual_canvas';
 import {DisposableStack} from '../base/disposable_stack';
 import {TimeScale} from '../base/time_scale';
 import {TrackNode} from '../public/workspace';
 import {HTMLAttrs} from '../widgets/common';
 import {TraceImpl, TraceImplAttrs} from '../core/trace_impl';

 const CANVAS_OVERDRAW_PX = 100;

 export interface Panel {
   readonly kind: 'panel';
   render(): m.Children;
   readonly selectable: boolean;
   // TODO(stevegolton): Remove this - panel container should know nothing of
   // tracks!
   readonly trackNode?: TrackNode;
   renderCanvas(ctx: CanvasRenderingContext2D, size: Size2D): void;
   getSliceVerticalBounds?(depth: number): VerticalBounds | undefined;
 }

 export interface PanelGroup {
   readonly kind: 'group';
   readonly collapsed: boolean;
   readonly header?: Panel;
   readonly topOffsetPx: number;
   readonly sticky: boolean;
   readonly childPanels: PanelOrGroup[];
 }

 export type PanelOrGroup = Panel | PanelGroup;

 export interface PanelContainerAttrs extends TraceImplAttrs {
   panels: PanelOrGroup[];
   className?: string;
   selectedYRange: VerticalBounds | undefined;

   onPanelStackResize?: (width: number, height: number) => void;

   // Called after all panels have been rendered to the canvas, to give the
   // caller the opportunity to render an overlay on top of the panels.
   renderOverlay?(
     ctx: CanvasRenderingContext2D,
     size: Size2D,
     panels: ReadonlyArray<RenderedPanelInfo>,
   ): void;

   // Called before the panels are rendered
   renderUnderlay?(ctx: CanvasRenderingContext2D, size: Size2D): void;
 }

 interface PanelInfo {
   trackNode?: TrackNode; // Can be undefined for singleton panels.
   panel: Panel;
   height: number;
   width: number;
   clientX: number;
   clientY: number;
   absY: number;
 }

 export interface RenderedPanelInfo {
   panel: Panel;
   rect: Bounds2D;
 }

 export class PanelContainer
   implements m.ClassComponent<PanelContainerAttrs>, PerfStatsContainer
 {
   private readonly trace: TraceImpl;
   private attrs: PanelContainerAttrs;

   // Updated every render cycle in the view() hook
   private panelById = new Map<string, Panel>();

   // Updated every render cycle in the oncreate/onupdate hook
   private panelInfos: PanelInfo[] = [];

   private perfStatsEnabled = false;
   private panelPerfStats = new WeakMap<Panel, PerfStats>();
   private perfStats = {
     totalPanels: 0,
     panelsOnCanvas: 0,
     renderStats: new PerfStats(10),
   };

   private ctx?: CanvasRenderingContext2D;

   private readonly trash = new DisposableStack();

   private readonly OVERLAY_REF = 'overlay';
   private readonly PANEL_STACK_REF = 'panel-stack';

   constructor({attrs}: m.CVnode<PanelContainerAttrs>) {
     this.attrs = attrs;
     this.trace = attrs.trace;
     this.trash.use(raf.addCanvasRedrawCallback(() => this.renderCanvas()));
     this.trash.use(attrs.trace.perfDebugging.addContainer(this));
   }

   getPanelsInRegion(
     startX: number,
     endX: number,
     startY: number,
     endY: number,
   ): Panel[] {
     const minX = Math.min(startX, endX);
     const maxX = Math.max(startX, endX);
     const minY = Math.min(startY, endY);
     const maxY = Math.max(startY, endY);
     const panels: Panel[] = [];
     for (let i = 0; i < this.panelInfos.length; i++) {
       const pos = this.panelInfos[i];
       const realPosX = pos.clientX - TRACK_SHELL_WIDTH;
       if (
         realPosX + pos.width >= minX &&
         realPosX <= maxX &&
         pos.absY + pos.height >= minY &&
         pos.absY <= maxY &&
         pos.panel.selectable
       ) {
         panels.push(pos.panel);
       }
     }
     return panels;
   }

   // This finds the tracks covered by the in-progress area selection. When
   // editing areaY is not set, so this will not be used.
   handleAreaSelection() {
     const {selectedYRange} = this.attrs;
     const area = this.trace.timeline.selectedArea;
     if (
       area === undefined ||
       selectedYRange === undefined ||
       this.panelInfos.length === 0
     ) {
       return;
     }

     // TODO(stevegolton): We shouldn't know anything about visible time scale
     // right now, that's a job for our parent, but we can put one together so we
     // don't have to refactor this entire bit right now...

     const visibleTimeScale = new TimeScale(this.trace.timeline.visibleWindow, {
       left: 0,
       right: this.virtualCanvas!.size.width - TRACK_SHELL_WIDTH,
     });

     // The Y value is given from the top of the pan and zoom region, we want it
     // from the top of the panel container. The parent offset corrects that.
     const panels = this.getPanelsInRegion(
       visibleTimeScale.timeToPx(area.start),
       visibleTimeScale.timeToPx(area.end),
       selectedYRange.top,
       selectedYRange.bottom,
     );

     // Get the track ids from the panels.
     const trackUris: string[] = [];
     for (const panel of panels) {
       if (panel.trackNode) {
         if (panel.trackNode.isSummary) {
           const groupNode = panel.trackNode;
           // Select a track group and all child tracks if it is collapsed
           if (groupNode.collapsed) {
             for (const track of groupNode.flatTracks) {
               track.uri && trackUris.push(track.uri);
             }
           }
         } else {
           panel.trackNode.uri && trackUris.push(panel.trackNode.uri);
         }
       }
     }
     this.trace.timeline.selectArea(area.start, area.end, trackUris);
   }

   private virtualCanvas?: VirtualCanvas;

   oncreate(vnode: m.CVnodeDOM<PanelContainerAttrs>) {
     const {dom, attrs} = vnode;

     const overlayElement = toHTMLElement(
       assertExists(findRef(dom, this.OVERLAY_REF)),
     );

     const virtualCanvas = new VirtualCanvas(overlayElement, dom, {
       overdrawPx: CANVAS_OVERDRAW_PX,
     });
     this.trash.use(virtualCanvas);
     this.virtualCanvas = virtualCanvas;

     const ctx = virtualCanvas.canvasElement.getContext('2d');
     if (!ctx) {
       throw Error('Cannot create canvas context');
     }
     this.ctx = ctx;

     virtualCanvas.setCanvasResizeListener((canvas, width, height) => {
       const dpr = window.devicePixelRatio;
       canvas.width = width * dpr;
       canvas.height = height * dpr;
     });

     virtualCanvas.setLayoutShiftListener(() => {
       this.renderCanvas();
     });

     this.onupdate(vnode);

     const panelStackElement = toHTMLElement(
       assertExists(findRef(dom, this.PANEL_STACK_REF)),
     );

     // Listen for when the panel stack changes size
     this.trash.use(
       new SimpleResizeObserver(panelStackElement, () => {
         attrs.onPanelStackResize?.(
           panelStackElement.clientWidth,
           panelStackElement.clientHeight,
         );
       }),
     );
   }

   onremove() {
     this.trash.dispose();
   }

   renderPanel(node: Panel, panelId: string, htmlAttrs?: HTMLAttrs): m.Vnode {
     assertFalse(this.panelById.has(panelId));
     this.panelById.set(panelId, node);
     return m(
       `.pf-panel`,
       {...htmlAttrs, 'data-panel-id': panelId},
       node.render(),
     );
   }

   // Render a tree of panels into one vnode. Argument `path` is used to build
   // `key` attribute for intermediate tree vnodes: otherwise Mithril internals
   // will complain about keyed and non-keyed vnodes mixed together.
   renderTree(node: PanelOrGroup, panelId: string): m.Vnode {
     if (node.kind === 'group') {
       const style = {
         position: 'sticky',
         top: `${node.topOffsetPx}px`,
         zIndex: `${2000 - node.topOffsetPx}`,
       };
       return m(
         'div.pf-panel-group',
         node.header &&
           this.renderPanel(node.header, `${panelId}-header`, {
             style: !node.collapsed && node.sticky ? style : {},
           }),
         ...node.childPanels.map((child, index) =>
           this.renderTree(child, `${panelId}-${index}`),
         ),
       );
     }
     return this.renderPanel(node, panelId);
   }

   view({attrs}: m.CVnode<PanelContainerAttrs>) {
     this.attrs = attrs;
     this.panelById.clear();
     const children = attrs.panels.map((panel, index) =>
       this.renderTree(panel, `${index}`),
     );

     return m(
       '.pf-panel-container',
       {className: attrs.className},
       m(
         '.pf-panel-stack',
         {ref: this.PANEL_STACK_REF},
         m('.pf-overlay', {ref: this.OVERLAY_REF}),
         children,
       ),
     );
   }

   onupdate({dom}: m.CVnodeDOM<PanelContainerAttrs>) {
     this.readPanelRectsFromDom(dom);
   }

   private readPanelRectsFromDom(dom: Element): void {
     this.panelInfos = [];

     const panel = dom.querySelectorAll('.pf-panel');
     const panels = assertExists(findRef(dom, this.PANEL_STACK_REF));
     const {top} = panels.getBoundingClientRect();
     panel.forEach((panelElement) => {
       const panelHTMLElement = toHTMLElement(panelElement);
       const panelId = assertExists(panelHTMLElement.dataset.panelId);
       const panel = assertExists(this.panelById.get(panelId));

       // NOTE: the id can be undefined for singletons like overview timeline.
       const rect = panelElement.getBoundingClientRect();
       this.panelInfos.push({
         trackNode: panel.trackNode,
         height: rect.height,
         width: rect.width,
         clientX: rect.x,
         clientY: rect.y,
         absY: rect.y - top,
         panel,
       });
     });
   }

   private renderCanvas() {
     if (!this.ctx) return;
     if (!this.virtualCanvas) return;

     const ctx = this.ctx;
     const vc = this.virtualCanvas;
     const redrawStart = performance.now();

     ctx.resetTransform();
     ctx.clearRect(0, 0, ctx.canvas.width, ctx.canvas.height);

     const dpr = window.devicePixelRatio;
     ctx.scale(dpr, dpr);
     ctx.translate(-vc.canvasRect.left, -vc.canvasRect.top);

     this.handleAreaSelection();

     const totalRenderedPanels = this.renderPanels(ctx, vc);
     this.drawTopLayerOnCanvas(ctx, vc);

     // Collect performance as the last thing we do.
     const redrawDur = performance.now() - redrawStart;
     this.updatePerfStats(
       redrawDur,
       this.panelInfos.length,
       totalRenderedPanels,
     );
   }

   private renderPanels(
     ctx: CanvasRenderingContext2D,
     vc: VirtualCanvas,
   ): number {
     this.attrs.renderUnderlay?.(ctx, vc.size);

     let panelTop = 0;
     let totalOnCanvas = 0;

     const renderedPanels = Array<RenderedPanelInfo>();

     for (let i = 0; i < this.panelInfos.length; i++) {
       const {
         panel,
         width: panelWidth,
         height: panelHeight,
       } = this.panelInfos[i];

       const panelRect = {
         left: 0,
         top: panelTop,
         bottom: panelTop + panelHeight,
         right: panelWidth,
       };
       const panelSize = {width: panelWidth, height: panelHeight};

       if (vc.overlapsCanvas(panelRect)) {
         totalOnCanvas++;

         ctx.save();
         ctx.translate(0, panelTop);
         canvasClip(ctx, 0, 0, panelWidth, panelHeight);
         const beforeRender = performance.now();
         panel.renderCanvas(ctx, panelSize);
         this.updatePanelStats(
           i,
           panel,
           performance.now() - beforeRender,
           ctx,
           panelSize,
         );
         ctx.restore();
       }

       renderedPanels.push({
         panel,
         rect: {
           top: panelTop,
           bottom: panelTop + panelHeight,
           left: 0,
           right: panelWidth,
         },
       });

       panelTop += panelHeight;
     }

     this.attrs.renderOverlay?.(ctx, vc.size, renderedPanels);

     return totalOnCanvas;
   }

   // The panels each draw on the canvas but some details need to be drawn across
   // the whole canvas rather than per panel.
   private drawTopLayerOnCanvas(
     ctx: CanvasRenderingContext2D,
     vc: VirtualCanvas,
   ): void {
     const {selectedYRange} = this.attrs;
     const area = this.trace.timeline.selectedArea;
     if (area === undefined || selectedYRange === undefined) {
       return;
     }
     if (this.panelInfos.length === 0 || area.trackUris.length === 0) {
       return;
     }

     // Find the minY and maxY of the selected tracks in this panel container.
     let selectedTracksMinY = selectedYRange.top;
     let selectedTracksMaxY = selectedYRange.bottom;
     for (let i = 0; i < this.panelInfos.length; i++) {
       const trackUri = this.panelInfos[i].trackNode?.uri;
       if (trackUri && area.trackUris.includes(trackUri)) {
         selectedTracksMinY = Math.min(
           selectedTracksMinY,
           this.panelInfos[i].absY,
         );
         selectedTracksMaxY = Math.max(
           selectedTracksMaxY,
           this.panelInfos[i].absY + this.panelInfos[i].height,
         );
       }
     }

     // TODO(stevegolton): We shouldn't know anything about visible time scale
     // right now, that's a job for our parent, but we can put one together so we
     // don't have to refactor this entire bit right now...

     const visibleTimeScale = new TimeScale(this.trace.timeline.visibleWindow, {
       left: 0,
       right: vc.size.width - TRACK_SHELL_WIDTH,
     });

     const startX = visibleTimeScale.timeToPx(area.start);
     const endX = visibleTimeScale.timeToPx(area.end);
     ctx.save();
     ctx.strokeStyle = SELECTION_STROKE_COLOR;
     ctx.lineWidth = 1;

     ctx.translate(TRACK_SHELL_WIDTH, 0);

     // Clip off any drawing happening outside the bounds of the timeline area
     canvasClip(ctx, 0, 0, vc.size.width - TRACK_SHELL_WIDTH, vc.size.height);

     ctx.strokeRect(
       startX,
       selectedTracksMaxY,
       endX - startX,
       selectedTracksMinY - selectedTracksMaxY,
     );
     ctx.restore();
   }

   private updatePanelStats(
     panelIndex: number,
     panel: Panel,
     renderTime: number,
     ctx: CanvasRenderingContext2D,
     size: Size2D,
   ) {
     if (!this.perfStatsEnabled) return;
     let renderStats = this.panelPerfStats.get(panel);
     if (renderStats === undefined) {
       renderStats = new PerfStats();
       this.panelPerfStats.set(panel, renderStats);
     }
     renderStats.addValue(renderTime);

     // Draw a green box around the whole panel
     ctx.strokeStyle = 'rgba(69, 187, 73, 0.5)';
     const lineWidth = 1;
     ctx.lineWidth = lineWidth;
     ctx.strokeRect(
       lineWidth / 2,
       lineWidth / 2,
       size.width - lineWidth,
       size.height - lineWidth,
     );

     const statW = 300;
     ctx.fillStyle = 'hsl(97, 100%, 96%)';
     ctx.fillRect(size.width - statW, size.height - 20, statW, 20);
     ctx.fillStyle = 'hsla(122, 77%, 22%)';
     const statStr = `Panel ${panelIndex + 1} | ` + runningStatStr(renderStats);
     ctx.fillText(statStr, size.width - statW, size.height - 10);
   }

   private updatePerfStats(
     renderTime: number,
     totalPanels: number,
     panelsOnCanvas: number,
   ) {
     if (!this.perfStatsEnabled) return;
     this.perfStats.renderStats.addValue(renderTime);
     this.perfStats.totalPanels = totalPanels;
     this.perfStats.panelsOnCanvas = panelsOnCanvas;
   }

   setPerfStatsEnabled(enable: boolean): void {
     this.perfStatsEnabled = enable;
   }

   renderPerfStats() {
     return [
       m(
         'div',
         `${this.perfStats.totalPanels} panels, ` +
           `${this.perfStats.panelsOnCanvas} on canvas.`,
       ),
       m('div', runningStatStr(this.perfStats.renderStats)),
     ];
   }
 }
	// Copyright (C) 2018 The Android Open Source Project
	//
	// Licensed under the Apache License, Version 2.0 (the "License");
	// you may not use this file except in compliance with the License.
	// You may obtain a copy of the License at
	//
	// http://www.apache.org/licenses/LICENSE-2.0
	//
	// Unless required by applicable law or agreed to in writing, software
	// distributed under the License is distributed on an "AS IS" BASIS,
	// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	// See the License for the specific language governing permissions and
	// limitations under the License.

	import m from 'mithril';
	import {findRef, toHTMLElement} from '../base/dom_utils';
	import {assertExists, assertFalse} from '../base/logging';
	import {
	PerfStats,
	PerfStatsContainer,
	runningStatStr,
	} from '../core/perf_stats';
	import {raf} from '../core/raf_scheduler';
	import {SimpleResizeObserver} from '../base/resize_observer';
	import {canvasClip} from '../base/canvas_utils';
	import {SELECTION_STROKE_COLOR, TRACK_SHELL_WIDTH} from './css_constants';
	import {Bounds2D, Size2D, VerticalBounds} from '../base/geom';
	import {VirtualCanvas} from './virtual_canvas';
	import {DisposableStack} from '../base/disposable_stack';
	import {TimeScale} from '../base/time_scale';
	import {TrackNode} from '../public/workspace';
	import {HTMLAttrs} from '../widgets/common';
	import {TraceImpl, TraceImplAttrs} from '../core/trace_impl';

	const CANVAS_OVERDRAW_PX = 100;

	export interface Panel {
	readonly kind: 'panel';
	render(): m.Children;
	readonly selectable: boolean;
	// TODO(stevegolton): Remove this - panel container should know nothing of
	// tracks!
	readonly trackNode?: TrackNode;
	renderCanvas(ctx: CanvasRenderingContext2D, size: Size2D): void;
	getSliceVerticalBounds?(depth: number): VerticalBounds \| undefined;
	}

	export interface PanelGroup {
	readonly kind: 'group';
	readonly collapsed: boolean;
	readonly header?: Panel;
	readonly topOffsetPx: number;
	readonly sticky: boolean;
	readonly childPanels: PanelOrGroup[];
	}

	export type PanelOrGroup = Panel \| PanelGroup;

	export interface PanelContainerAttrs extends TraceImplAttrs {
	panels: PanelOrGroup[];
	className?: string;
	selectedYRange: VerticalBounds \| undefined;

	onPanelStackResize?: (width: number, height: number) => void;

	// Called after all panels have been rendered to the canvas, to give the
	// caller the opportunity to render an overlay on top of the panels.
	renderOverlay?(
	ctx: CanvasRenderingContext2D,
	size: Size2D,
	panels: ReadonlyArray<RenderedPanelInfo>,
	): void;

	// Called before the panels are rendered
	renderUnderlay?(ctx: CanvasRenderingContext2D, size: Size2D): void;
	}

	interface PanelInfo {
	trackNode?: TrackNode; // Can be undefined for singleton panels.
	panel: Panel;
	height: number;
	width: number;
	clientX: number;
	clientY: number;
	absY: number;
	}

	export interface RenderedPanelInfo {
	panel: Panel;
	rect: Bounds2D;
	}

	export class PanelContainer
	implements m.ClassComponent<PanelContainerAttrs>, PerfStatsContainer
	{
	private readonly trace: TraceImpl;
	private attrs: PanelContainerAttrs;

	// Updated every render cycle in the view() hook
	private panelById = new Map<string, Panel>();

	// Updated every render cycle in the oncreate/onupdate hook
	private panelInfos: PanelInfo[] = [];

	private perfStatsEnabled = false;
	private panelPerfStats = new WeakMap<Panel, PerfStats>();
	private perfStats = {
	totalPanels: 0,
	panelsOnCanvas: 0,
	renderStats: new PerfStats(10),
	};

	private ctx?: CanvasRenderingContext2D;

	private readonly trash = new DisposableStack();

	private readonly OVERLAY_REF = 'overlay';
	private readonly PANEL_STACK_REF = 'panel-stack';

	constructor({attrs}: m.CVnode<PanelContainerAttrs>) {
	this.attrs = attrs;
	this.trace = attrs.trace;
	this.trash.use(raf.addCanvasRedrawCallback(() => this.renderCanvas()));
	this.trash.use(attrs.trace.perfDebugging.addContainer(this));
	}

	getPanelsInRegion(
	startX: number,
	endX: number,
	startY: number,
	endY: number,
	): Panel[] {
	const minX = Math.min(startX, endX);
	const maxX = Math.max(startX, endX);
	const minY = Math.min(startY, endY);
	const maxY = Math.max(startY, endY);
	const panels: Panel[] = [];
	for (let i = 0; i < this.panelInfos.length; i++) {
	const pos = this.panelInfos[i];
	const realPosX = pos.clientX - TRACK_SHELL_WIDTH;
	if (
	realPosX + pos.width >= minX &&
	realPosX <= maxX &&
	pos.absY + pos.height >= minY &&
	pos.absY <= maxY &&
	pos.panel.selectable
	) {
	panels.push(pos.panel);
	}
	}
	return panels;
	}

	// This finds the tracks covered by the in-progress area selection. When
	// editing areaY is not set, so this will not be used.
	handleAreaSelection() {
	const {selectedYRange} = this.attrs;
	const area = this.trace.timeline.selectedArea;
	if (
	area === undefined \|\|
	selectedYRange === undefined \|\|
	this.panelInfos.length === 0
	) {
	return;
	}

	// TODO(stevegolton): We shouldn't know anything about visible time scale
	// right now, that's a job for our parent, but we can put one together so we
	// don't have to refactor this entire bit right now...

	const visibleTimeScale = new TimeScale(this.trace.timeline.visibleWindow, {
	left: 0,
	right: this.virtualCanvas!.size.width - TRACK_SHELL_WIDTH,
	});

	// The Y value is given from the top of the pan and zoom region, we want it
	// from the top of the panel container. The parent offset corrects that.
	const panels = this.getPanelsInRegion(
	visibleTimeScale.timeToPx(area.start),
	visibleTimeScale.timeToPx(area.end),
	selectedYRange.top,
	selectedYRange.bottom,
	);

	// Get the track ids from the panels.
	const trackUris: string[] = [];
	for (const panel of panels) {
	if (panel.trackNode) {
	if (panel.trackNode.isSummary) {
	const groupNode = panel.trackNode;
	// Select a track group and all child tracks if it is collapsed
	if (groupNode.collapsed) {
	for (const track of groupNode.flatTracks) {
	track.uri && trackUris.push(track.uri);
	}
	}
	} else {
	panel.trackNode.uri && trackUris.push(panel.trackNode.uri);
	}
	}
	}
	this.trace.timeline.selectArea(area.start, area.end, trackUris);
	}

	private virtualCanvas?: VirtualCanvas;

	oncreate(vnode: m.CVnodeDOM<PanelContainerAttrs>) {
	const {dom, attrs} = vnode;

	const overlayElement = toHTMLElement(
	assertExists(findRef(dom, this.OVERLAY_REF)),
	);

	const virtualCanvas = new VirtualCanvas(overlayElement, dom, {
	overdrawPx: CANVAS_OVERDRAW_PX,
	});
	this.trash.use(virtualCanvas);
	this.virtualCanvas = virtualCanvas;

	const ctx = virtualCanvas.canvasElement.getContext('2d');
	if (!ctx) {
	throw Error('Cannot create canvas context');
	}
	this.ctx = ctx;

	virtualCanvas.setCanvasResizeListener((canvas, width, height) => {
	const dpr = window.devicePixelRatio;
	canvas.width = width * dpr;
	canvas.height = height * dpr;
	});

	virtualCanvas.setLayoutShiftListener(() => {
	this.renderCanvas();
	});

	this.onupdate(vnode);

	const panelStackElement = toHTMLElement(
	assertExists(findRef(dom, this.PANEL_STACK_REF)),
	);

	// Listen for when the panel stack changes size
	this.trash.use(
	new SimpleResizeObserver(panelStackElement, () => {
	attrs.onPanelStackResize?.(
	panelStackElement.clientWidth,
	panelStackElement.clientHeight,
	);
	}),
	);
	}

	onremove() {
	this.trash.dispose();
	}

	renderPanel(node: Panel, panelId: string, htmlAttrs?: HTMLAttrs): m.Vnode {
	assertFalse(this.panelById.has(panelId));
	this.panelById.set(panelId, node);
	return m(
	`.pf-panel`,
	{...htmlAttrs, 'data-panel-id': panelId},
	node.render(),
	);
	}

	// Render a tree of panels into one vnode. Argument `path` is used to build
	// `key` attribute for intermediate tree vnodes: otherwise Mithril internals
	// will complain about keyed and non-keyed vnodes mixed together.
	renderTree(node: PanelOrGroup, panelId: string): m.Vnode {
	if (node.kind === 'group') {
	const style = {
	position: 'sticky',
	top: `${node.topOffsetPx}px`,
	zIndex: `${2000 - node.topOffsetPx}`,
	};
	return m(
	'div.pf-panel-group',
	node.header &&
	this.renderPanel(node.header, `${panelId}-header`, {
	style: !node.collapsed && node.sticky ? style : {},
	}),
	...node.childPanels.map((child, index) =>
	this.renderTree(child, `${panelId}-${index}`),
	),
	);
	}
	return this.renderPanel(node, panelId);
	}

	view({attrs}: m.CVnode<PanelContainerAttrs>) {
	this.attrs = attrs;
	this.panelById.clear();
	const children = attrs.panels.map((panel, index) =>
	this.renderTree(panel, `${index}`),
	);

	return m(
	'.pf-panel-container',
	{className: attrs.className},
	m(
	'.pf-panel-stack',
	{ref: this.PANEL_STACK_REF},
	m('.pf-overlay', {ref: this.OVERLAY_REF}),
	children,
	),
	);
	}

	onupdate({dom}: m.CVnodeDOM<PanelContainerAttrs>) {
	this.readPanelRectsFromDom(dom);
	}

	private readPanelRectsFromDom(dom: Element): void {
	this.panelInfos = [];

	const panel = dom.querySelectorAll('.pf-panel');
	const panels = assertExists(findRef(dom, this.PANEL_STACK_REF));
	const {top} = panels.getBoundingClientRect();
	panel.forEach((panelElement) => {
	const panelHTMLElement = toHTMLElement(panelElement);
	const panelId = assertExists(panelHTMLElement.dataset.panelId);
	const panel = assertExists(this.panelById.get(panelId));

	// NOTE: the id can be undefined for singletons like overview timeline.
	const rect = panelElement.getBoundingClientRect();
	this.panelInfos.push({
	trackNode: panel.trackNode,
	height: rect.height,
	width: rect.width,
	clientX: rect.x,
	clientY: rect.y,
	absY: rect.y - top,
	panel,
	});
	});
	}

	private renderCanvas() {
	if (!this.ctx) return;
	if (!this.virtualCanvas) return;

	const ctx = this.ctx;
	const vc = this.virtualCanvas;
	const redrawStart = performance.now();

	ctx.resetTransform();
	ctx.clearRect(0, 0, ctx.canvas.width, ctx.canvas.height);

	const dpr = window.devicePixelRatio;
	ctx.scale(dpr, dpr);
	ctx.translate(-vc.canvasRect.left, -vc.canvasRect.top);

	this.handleAreaSelection();

	const totalRenderedPanels = this.renderPanels(ctx, vc);
	this.drawTopLayerOnCanvas(ctx, vc);

	// Collect performance as the last thing we do.
	const redrawDur = performance.now() - redrawStart;
	this.updatePerfStats(
	redrawDur,
	this.panelInfos.length,
	totalRenderedPanels,
	);
	}

	private renderPanels(
	ctx: CanvasRenderingContext2D,
	vc: VirtualCanvas,
	): number {
	this.attrs.renderUnderlay?.(ctx, vc.size);

	let panelTop = 0;
	let totalOnCanvas = 0;

	const renderedPanels = Array<RenderedPanelInfo>();

	for (let i = 0; i < this.panelInfos.length; i++) {
	const {
	panel,
	width: panelWidth,
	height: panelHeight,
	} = this.panelInfos[i];

	const panelRect = {
	left: 0,
	top: panelTop,
	bottom: panelTop + panelHeight,
	right: panelWidth,
	};
	const panelSize = {width: panelWidth, height: panelHeight};

	if (vc.overlapsCanvas(panelRect)) {
	totalOnCanvas++;

	ctx.save();
	ctx.translate(0, panelTop);
	canvasClip(ctx, 0, 0, panelWidth, panelHeight);
	const beforeRender = performance.now();
	panel.renderCanvas(ctx, panelSize);
	this.updatePanelStats(
	i,
	panel,
	performance.now() - beforeRender,
	ctx,
	panelSize,
	);
	ctx.restore();
	}

	renderedPanels.push({
	panel,
	rect: {
	top: panelTop,
	bottom: panelTop + panelHeight,
	left: 0,
	right: panelWidth,
	},
	});

	panelTop += panelHeight;
	}

	this.attrs.renderOverlay?.(ctx, vc.size, renderedPanels);

	return totalOnCanvas;
	}

	// The panels each draw on the canvas but some details need to be drawn across
	// the whole canvas rather than per panel.
	private drawTopLayerOnCanvas(
	ctx: CanvasRenderingContext2D,
	vc: VirtualCanvas,
	): void {
	const {selectedYRange} = this.attrs;
	const area = this.trace.timeline.selectedArea;
	if (area === undefined \|\| selectedYRange === undefined) {
	return;
	}
	if (this.panelInfos.length === 0 \|\| area.trackUris.length === 0) {
	return;
	}

	// Find the minY and maxY of the selected tracks in this panel container.
	let selectedTracksMinY = selectedYRange.top;
	let selectedTracksMaxY = selectedYRange.bottom;
	for (let i = 0; i < this.panelInfos.length; i++) {
	const trackUri = this.panelInfos[i].trackNode?.uri;
	if (trackUri && area.trackUris.includes(trackUri)) {
	selectedTracksMinY = Math.min(
	selectedTracksMinY,
	this.panelInfos[i].absY,
	);
	selectedTracksMaxY = Math.max(
	selectedTracksMaxY,
	this.panelInfos[i].absY + this.panelInfos[i].height,
	);
	}
	}

	// TODO(stevegolton): We shouldn't know anything about visible time scale
	// right now, that's a job for our parent, but we can put one together so we
	// don't have to refactor this entire bit right now...

	const visibleTimeScale = new TimeScale(this.trace.timeline.visibleWindow, {
	left: 0,
	right: vc.size.width - TRACK_SHELL_WIDTH,
	});

	const startX = visibleTimeScale.timeToPx(area.start);
	const endX = visibleTimeScale.timeToPx(area.end);
	ctx.save();
	ctx.strokeStyle = SELECTION_STROKE_COLOR;
	ctx.lineWidth = 1;

	ctx.translate(TRACK_SHELL_WIDTH, 0);

	// Clip off any drawing happening outside the bounds of the timeline area
	canvasClip(ctx, 0, 0, vc.size.width - TRACK_SHELL_WIDTH, vc.size.height);

	ctx.strokeRect(
	startX,
	selectedTracksMaxY,
	endX - startX,
	selectedTracksMinY - selectedTracksMaxY,
	);
	ctx.restore();
	}

	private updatePanelStats(
	panelIndex: number,
	panel: Panel,
	renderTime: number,
	ctx: CanvasRenderingContext2D,
	size: Size2D,
	) {
	if (!this.perfStatsEnabled) return;
	let renderStats = this.panelPerfStats.get(panel);
	if (renderStats === undefined) {
	renderStats = new PerfStats();
	this.panelPerfStats.set(panel, renderStats);
	}
	renderStats.addValue(renderTime);

	// Draw a green box around the whole panel
	ctx.strokeStyle = 'rgba(69, 187, 73, 0.5)';
	const lineWidth = 1;
	ctx.lineWidth = lineWidth;
	ctx.strokeRect(
	lineWidth / 2,
	lineWidth / 2,
	size.width - lineWidth,
	size.height - lineWidth,
	);

	const statW = 300;
	ctx.fillStyle = 'hsl(97, 100%, 96%)';
	ctx.fillRect(size.width - statW, size.height - 20, statW, 20);
	ctx.fillStyle = 'hsla(122, 77%, 22%)';
	const statStr = `Panel ${panelIndex + 1} \| ` + runningStatStr(renderStats);
	ctx.fillText(statStr, size.width - statW, size.height - 10);
	}

	private updatePerfStats(
	renderTime: number,
	totalPanels: number,
	panelsOnCanvas: number,
	) {
	if (!this.perfStatsEnabled) return;
	this.perfStats.renderStats.addValue(renderTime);
	this.perfStats.totalPanels = totalPanels;
	this.perfStats.panelsOnCanvas = panelsOnCanvas;
	}

	setPerfStatsEnabled(enable: boolean): void {
	this.perfStatsEnabled = enable;
	}

	renderPerfStats() {
	return [
	m(
	'div',
	`${this.perfStats.totalPanels} panels, ` +
	`${this.perfStats.panelsOnCanvas} on canvas.`,
	),
	m('div', runningStatStr(this.perfStats.renderStats)),
	];
	}
	}