// Copyright (C) 2026 Zaher Salman // SPDX-License-Identifier: GPL-3.0-or-later // JSROOT-backed floating plot windows for the muSRFlow web application. // This file is intentionally browser-only. The Electron path keeps using the // native musrview window for now. if (typeof window.MusrfitJSRootURL === "undefined") { window.MusrfitJSRootURL = "https://root.cern/js/latest/modules/main.mjs"; } if (typeof window.MusrfitRootModulePromise === "undefined") { window.MusrfitRootModulePromise = null; } let webRootPlotWindowSequence = 0; // Load JSROOT only when a ROOT plot is actually opened. Keeping one shared // promise avoids repeated module downloads when several floating windows exist. function loadMusrfitJSRoot() { if (!window.MusrfitRootModulePromise) { window.MusrfitRootModulePromise = import(window.MusrfitJSRootURL); } return window.MusrfitRootModulePromise; } // musrview names each serialized ROOT canvas fMainCanvas;1, where // follows the numbered output filename, e.g. run_0.root -> fMainCanvas0;1. // Convert the CGI response into explicit {url, item} pairs. If the CGI did not // return an item name, derive the usual musrview canvas name from the filename. function normalizeMusrfitRootPlotSpecs(rootUrls, rootItems) { let urls = Array.isArray(rootUrls) ? rootUrls : []; let items = Array.isArray(rootItems) ? rootItems : []; return urls.filter(function(rootUrl) { return typeof rootUrl === "string" && rootUrl !== ""; }).map(function(rootUrl, index) { let cleanUrl = String(rootUrl || "").split("?")[0]; let fileName = cleanUrl.substring(cleanUrl.lastIndexOf("/") + 1); let match = fileName.match(/_(\d+)(?:_F)?\.root$/); let defaultItem = match ? "fMainCanvas" + match[1] + ";1" : "fMainCanvas0;1"; return { url: rootUrl, item: items[index] || defaultItem }; }); } // Accept both the current multi-plot response and the older single-url shape. // This keeps the browser side tolerant while CGI deployments are upgraded. The // web platform adapter also consults this helper after rt_alias / msr2data // requests, so it stays a shared top-level function. function musrfitRootUrlsFromResponse(response) { if (!response) { return []; } if (Array.isArray(response.root_urls)) { return response.root_urls.filter(function(rootUrl) { return typeof rootUrl === "string" && rootUrl !== ""; }); } if (typeof response.root_url === "string" && response.root_url !== "") { return [response.root_url]; } return []; } // Arrange minimized plot windows in compact columns at the top-right corner so // they do not cover the status bar or drift off-screen after browser resizing. function layoutMusrfitRootWindows() { let minimizedWindows = document.querySelectorAll( '.web-plot-window[data-plot-state="minimized"]' ); let topPosition = 12; let rightPosition = 12; let columnWidth = 0; let bottomLimit = Math.max(120, window.innerHeight - 56); for (let windowIndex = 0; windowIndex < minimizedWindows.length; windowIndex++) { let minimizedWindow = minimizedWindows[windowIndex]; if (topPosition + minimizedWindow.offsetHeight > bottomLimit && topPosition > 12) { rightPosition += columnWidth + 8; topPosition = 12; columnWidth = 0; } minimizedWindow.style.left = "auto"; minimizedWindow.style.right = rightPosition + "px"; minimizedWindow.style.top = topPosition + "px"; topPosition += minimizedWindow.offsetHeight + 8; columnWidth = Math.max(columnWidth, minimizedWindow.offsetWidth); } } // Bind the global resize handler once even if this file is accidentally loaded // more than once by a development page. if (!window.MusrfitRootLayoutBound && typeof window.addEventListener === "function") { window.addEventListener("resize", layoutMusrfitRootWindows); window.MusrfitRootLayoutBound = true; } // Time-bound an async operation so a JA-root/JSROOT fetch that never settles // degrades to a visible error instead of leaving "Loading ROOT canvas..." up // forever on an empty pane. Returns the promise's value when it wins the race // and throws a TimeoutError describing the step when the deadline passes. // Overridable so tests (and deployments tuning latency) can set a short budget. if (typeof window.MusrfitRootFetchTimeoutMs === "undefined") { window.MusrfitRootFetchTimeoutMs = 60000; } function musrfitRootTimeoutMs() { let configured = Number(window.MusrfitRootFetchTimeoutMs); return Number.isFinite(configured) && configured > 0 ? configured : 60000; } function withMusrfitRootTimeout(promise, step, url) { return new Promise(function(resolve, reject) { let settled = false; let timer = setTimeout(function() { if (settled) { return; } settled = true; let timeoutError = new Error(step + " timed out after " + Math.round(musrfitRootTimeoutMs() / 1000) + "s: " + url); timeoutError.name = "TimeoutError"; reject(timeoutError); }, musrfitRootTimeoutMs()); Promise.resolve(promise).then(function(value) { if (settled) { return; } settled = true; clearTimeout(timer); resolve(value); }, function(error) { if (settled) { return; } settled = true; clearTimeout(timer); reject(error); }); }); } // JSROOT may expose a ROOT TList either directly as an array or via .arr. function musrfitRootCollectionArray(collection) { if (Array.isArray(collection)) { return collection; } if (collection && Array.isArray(collection.arr)) { return collection.arr; } return []; } // ROOT keeps an option array beside TList contents. When filtering primitives, // keep both arrays aligned so JSROOT sees a valid collection afterwards. function filterMusrfitRootCollection(collection, keepItem) { let items = musrfitRootCollectionArray(collection); if (!collection || !items.length) { return []; } if (Array.isArray(collection)) { let kept = items.filter(keepItem); collection.splice(0, collection.length, ...kept); return collection; } let options = Array.isArray(collection.opt) ? collection.opt : null; let keptItems = []; let keptOptions = []; for (let index = 0; index < items.length; index++) { if (!keepItem(items[index], index)) { continue; } keptItems.push(items[index]); if (options) { keptOptions.push(options[index]); } } collection.arr = keptItems; if (options) { collection.opt = keptOptions; } return keptItems; } // ROOT font 13 is a Times/FreeSerif family that blends well with LaTeX output. // Precision 2 keeps the text scalable when the JSROOT window is resized. const MUSRFIT_ROOT_LATEX_FONT = 132; const MUSRFIT_ROOT_SCALE_FONT_SIZE = 0.034; const MUSRFIT_ROOT_AXIS_LABEL_FONT_SIZE = 0.040; const MUSRFIT_ROOT_LEGEND_FONT_SIZE = 0.028; const MUSRFIT_ROOT_LEGEND_ROW_HEIGHT = 0.045; const MUSRFIT_ROOT_LEGEND_PADDING = 0.04; const MUSRFIT_ROOT_LEGEND_MAX_HEIGHT = 0.80; // ROOT stores CenterTitle as bit 12 in TAxis::fBits. Setting it directly keeps // the transformation independent of JSROOT painter internals. const MUSRFIT_ROOT_CENTER_TITLE_BIT = 1 << 12; // Axis-bearing ROOT objects can be nested inside pads or a multigraph frame. // Walk only the small set of container fields used by musrview/JSROOT rather // than traversing graph data arrays. function styleMusrfitRootAxes(object, visited = new WeakSet()) { if (!object || typeof object !== "object" || visited.has(object)) { return; } visited.add(object); ["fXaxis", "fYaxis"].forEach(function(axisName) { let axis = object[axisName]; if (!axis || typeof axis !== "object") { return; } axis.fLabelFont = MUSRFIT_ROOT_LATEX_FONT; axis.fTitleFont = MUSRFIT_ROOT_LATEX_FONT; axis.fLabelSize = MUSRFIT_ROOT_SCALE_FONT_SIZE; axis.fTitleSize = MUSRFIT_ROOT_AXIS_LABEL_FONT_SIZE; axis.fBits = (Number.isFinite(axis.fBits) ? axis.fBits : 0) | MUSRFIT_ROOT_CENTER_TITLE_BIT; }); if (object.fHistogram) { styleMusrfitRootAxes(object.fHistogram, visited); } musrfitRootCollectionArray(object.fPrimitives).forEach(function(child) { styleMusrfitRootAxes(child, visited); }); } // Use the same serif font for the clean-view title, annotations and legend. // Text sizes are otherwise left unchanged so only the requested axis hierarchy // is altered. function styleMusrfitRootTextFonts(object, visited = new WeakSet()) { if (!object || typeof object !== "object" || visited.has(object)) { return; } visited.add(object); if (Object.prototype.hasOwnProperty.call(object, "fTextFont")) { object.fTextFont = MUSRFIT_ROOT_LATEX_FONT; } musrfitRootCollectionArray(object.fPrimitives).forEach(function(child) { styleMusrfitRootTextFonts(child, visited); }); musrfitRootCollectionArray(object.fLines).forEach(function(child) { styleMusrfitRootTextFonts(child, visited); }); } // Prefer normalized-device coordinates, with the plain ROOT coordinate as fallback. function musrfitRootCoordinate(object, ndcName, fallbackName) { if (object && Number.isFinite(object[ndcName])) { return object[ndcName]; } if (object && Number.isFinite(object[fallbackName])) { return object[fallbackName]; } return null; } // musrview writes labels as run,histograms,T=...,B=...,E=...,setup. Keep only // physical metadata in the clean view. If none are available, retain the run // identifier so multiple curves do not become anonymous. function cleanMusrfitRootLegendLabels(label) { let original = String(label || ""); let fields = original.split(","); let metadata = []; for (let fieldIndex = 0; fieldIndex < fields.length; fieldIndex++) { let field = fields[fieldIndex].trim(); let match = field.match(/^(T\d*|B|E)\s*=\s*(.+)$/i); if (!match) { continue; } let value = match[2].trim(); if (!value || value === "??") { continue; } // Add a readable space between a numeric value and its physical unit. let trimmedValue = String(value || "").trim(); let unitMatch = trimmedValue.match( /^([+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][+-]?\d+)?)\s*(K|G|T|keV|meV|eV)$/i); metadata.push(match[1] + "=" + (unitMatch ? unitMatch[1] + " " + unitMatch[2] : trimmedValue)); } if (metadata.length) { return metadata; } let runName = fields.length ? fields[0].trim() : ""; return [runName.replace(/^\+\+/, "")]; } // Keep the single-label helper for callers that only need a compact text form. function cleanMusrfitRootLegendLabel(label) { return cleanMusrfitRootLegendLabels(label).join(", "); } // Drop the fit-statistics header and reduce each run entry to T/B/E metadata. // Use separate rows while they fit in the side legend so T, B and E have the // same font size. If that would exceed the available height, fall back to one // compact metadata line per data set; positionMusrfitRootInfoLegend() then // reduces the font only if even those compact rows need more vertical space. function cleanMusrfitRootInfoLegend(legend) { if (!legend || !legend.fPrimitives) { return; } if (Object.prototype.hasOwnProperty.call(legend, "fHeader")) { legend.fHeader = ""; } let collection = legend.fPrimitives; let entries = musrfitRootCollectionArray(collection); let options = !Array.isArray(collection) && Array.isArray(collection.opt) ? collection.opt : null; let dataSets = []; for (let entryIndex = 0; entryIndex < entries.length; entryIndex++) { let entry = entries[entryIndex]; if (!entry) { continue; } let option = String(entry.fOption || "").toLowerCase(); let label = String(entry.fLabel || ""); if (option === "h" || label.toLowerCase().indexOf("musrfit:") === 0) { continue; } dataSets.push({ entry: entry, option: options ? options[entryIndex] : null, labels: cleanMusrfitRootLegendLabels(label) }); } let multiLineCount = dataSets.reduce(function(total, dataSet) { return total + dataSet.labels.length; }, 0); let multiLineHeight = MUSRFIT_ROOT_LEGEND_ROW_HEIGHT * multiLineCount + MUSRFIT_ROOT_LEGEND_PADDING; let compact = multiLineHeight >= MUSRFIT_ROOT_LEGEND_MAX_HEIGHT; let cleanEntries = []; let cleanOptions = []; dataSets.forEach(function(dataSet) { let labels = compact ? [dataSet.labels.join(", ")] : dataSet.labels; labels.forEach(function(label, labelIndex) { let cleanEntry = labelIndex === 0 ? dataSet.entry : Object.assign({}, dataSet.entry); cleanEntry.fLabel = label; if (labelIndex > 0) { // Continuation rows carry metadata only; the curve marker belongs // to the first row of the data set. cleanEntry.fOption = ""; if (Object.prototype.hasOwnProperty.call(cleanEntry, "fObject")) { cleanEntry.fObject = null; } } cleanEntries.push(cleanEntry); if (options) { cleanOptions.push(labelIndex === 0 ? dataSet.option : ""); } }); }); if (Array.isArray(collection)) { collection.splice(0, collection.length, ...cleanEntries); } else { collection.arr = cleanEntries; if (options) { collection.opt = cleanOptions; } } } // Move the cleaned metadata legend into the right column vacated by the // parameter/theory boxes. Keep the data pad geometry unchanged. function positionMusrfitRootInfoLegend(legend) { if (!legend) { return; } let lineCount = Math.max(1, musrfitRootCollectionArray(legend.fPrimitives).length); let y2 = 0.92; let requiredHeight = MUSRFIT_ROOT_LEGEND_ROW_HEIGHT * lineCount + MUSRFIT_ROOT_LEGEND_PADDING; let height = Math.min(MUSRFIT_ROOT_LEGEND_MAX_HEIGHT, Math.max(0.12, requiredHeight)); legend.fX1NDC = 0.76; legend.fX2NDC = 0.99; legend.fY1NDC = Math.max(0.11, y2 - height); legend.fY2NDC = y2; // The original bottom legend may use several columns; the side legend // should always remain a single column. legend.fNColumns = 1; // Keep the normal readable font while the rows and labels fit. Crowded // legends first collapse T/B/E to one line per data set; that line can be // substantially wider than the multiline form, so constrain the font by // both the available height and the available legend width. let rowSpace = Math.max(0.01, height - MUSRFIT_ROOT_LEGEND_PADDING); let neededRowSpace = MUSRFIT_ROOT_LEGEND_ROW_HEIGHT * lineCount; let heightScale = Math.min(1, rowSpace / neededRowSpace); let legendWidth = Math.max(0.01, legend.fX2NDC - legend.fX1NDC); let symbolMargin = Number.isFinite(legend.fMargin) ? legend.fMargin : 0.25; symbolMargin = Math.max(0.0, Math.min(0.45, symbolMargin)); let textWidth = legendWidth * (1.0 - symbolMargin) - 0.01; let longestLabel = musrfitRootCollectionArray(legend.fPrimitives).reduce( function(longest, entry) { let label = entry && entry.fLabel ? String(entry.fLabel) : ""; return Math.max(longest, label.length); }, 0); // Times-style legend text averages roughly half an em per character. This // deliberately errs slightly on the conservative side so compact labels do // not clip against the right edge of the legend. let estimatedWidth = longestLabel * MUSRFIT_ROOT_LEGEND_FONT_SIZE * 0.52; let widthScale = estimatedWidth > 0 ? Math.min(1, Math.max(0.1, textWidth / estimatedWidth)) : 1; legend.fTextSize = MUSRFIT_ROOT_LEGEND_FONT_SIZE * Math.min(heightScale, widthScale); } // Apply a presentation-only cleanup to the deserialized musrview canvas. The // ROOT file itself is never modified; toggling back simply rereads it. function cleanMusrfitRootCanvas(canvasObject) { if (!canvasObject || !canvasObject.fPrimitives) { return canvasObject; } let primitives = musrfitRootCollectionArray(canvasObject.fPrimitives); let dataPad = primitives.find(function(object) { return object && object._typename === "TPad" && object.fName === "dataTheoryPad"; }); if (!dataPad) { return canvasObject; } // Identify the full-width information legend at the bottom of the canvas. let infoLegend = primitives.find(function(object) { if (!object || object._typename !== "TLegend") { return false; } let lx1 = musrfitRootCoordinate(object, "fX1NDC", "fX1"); let lx2 = musrfitRootCoordinate(object, "fX2NDC", "fX2"); let ly1 = musrfitRootCoordinate(object, "fY1NDC", "fY1"); let ly2 = musrfitRootCoordinate(object, "fY2NDC", "fY2"); return lx1 !== null && lx2 !== null && ly1 !== null && ly2 !== null && lx1 <= 0.05 && lx2 >= 0.95 && ly1 <= 0.05 && ly2 <= 0.2; }); // Remove musrview's parameter/theory boxes: TPaveText objects in the right // column of the canvas. filterMusrfitRootCollection(canvasObject.fPrimitives, function(object) { if (!object || object._typename !== "TPaveText") { return true; } let rx1 = musrfitRootCoordinate(object, "fX1NDC", "fX1"); let rx2 = musrfitRootCoordinate(object, "fX2NDC", "fX2"); let ry1 = musrfitRootCoordinate(object, "fY1NDC", "fY1"); let ry2 = musrfitRootCoordinate(object, "fY2NDC", "fY2"); return !(rx1 !== null && rx2 !== null && ry1 !== null && ry2 !== null && rx1 >= 0.6 && rx2 >= 0.95 && ry1 >= 0.05 && ry2 <= 0.96); }); cleanMusrfitRootInfoLegend(infoLegend); positionMusrfitRootInfoLegend(infoLegend); // The bottom information strip is removed in clean mode, so use that space // for the data pad. Preserve its right edge and top edge. if (Number.isFinite(dataPad.fYlowNDC) && Number.isFinite(dataPad.fHNDC)) { dataPad.fHNDC += dataPad.fYlowNDC; dataPad.fYlowNDC = 0.0; } if (Number.isFinite(dataPad.fAbsYlowNDC) && Number.isFinite(dataPad.fAbsHNDC)) { dataPad.fAbsHNDC += dataPad.fAbsYlowNDC; dataPad.fAbsYlowNDC = 0.0; } styleMusrfitRootAxes(dataPad); styleMusrfitRootTextFonts(canvasObject); return canvasObject; } // Each redraw replaces canvas elements. Disconnect observers attached to the old // canvases first to avoid callbacks after a plot window is closed or reset. function disconnectMusrfitRootResizeObservers(container) { if (!container || !container.querySelectorAll) { return; } container.querySelectorAll(".web-root-canvas").forEach(function(canvas) { if (canvas.__musrfitRootResizeObserver) { canvas.__musrfitRootResizeObserver.disconnect(); canvas.__musrfitRootResizeObserver = null; } }); } // Renders are asynchronous (fetch + decode + draw). Rapid toggling of the // clean/original view can start several renders on the same container at once; // the newest render's replaceChildren() detaches the canvases the older in-flight // renders are still drawing into. Guard each container with a generation token so // a stale draw aborts instead of throwing "Could not draw ..." on a removed node. var musrfitRootContainerGeneration = new WeakMap(); // Return a token that strictly increases for every new render on `container`. function beginMusrfitRootRender(container) { let generation = musrfitRootContainerGeneration.get(container) || 0; generation += 1; musrfitRootContainerGeneration.set(container, generation); return generation; } // A render is stale when a newer render replaced it, or when the specific canvas // this draw targets has been detached from the document (e.g. window closed). function musrfitRootRenderIsStale(container, generation, canvas) { if (musrfitRootContainerGeneration.get(container) !== generation) { return true; } return !canvas || !canvas.isConnected; } // A decoded musrview canvas is a JSROOT tree; the individual objects carry // prototype methods (e.g. TestBit) that jsroot.draw relies on. Reusing the // decoded object across clean/original/reset redraws avoids a network // round-trip per toggle, the slow and flaky path on mobile. Every render draws // its own clone so the clean-view mutation never corrupts the cached pristine // copy. Only JSROOT's own clone preserves the object prototypes; JSON cloning // is a degraded fallback for environments without it. function musrfitRootCloneCanvas(canvasObject, jsroot) { if (canvasObject && typeof canvasObject !== "object") { return canvasObject; } if (jsroot && typeof jsroot.clone === "function") { try { return jsroot.clone(canvasObject); } catch (error) { // fall through to the structural copy } } try { return JSON.parse(JSON.stringify(canvasObject)); } catch (error) { return canvasObject; } } // Stable per-plot cache key independent of the cache-busting query string, so a // clean/original/reset redraw hits the same entry across render versions. function musrfitRootCacheKey(plotSpec) { let url = String(plotSpec && plotSpec.url || "").split("?")[0]; return url + "|" + String(plotSpec && plotSpec.item || ""); } // JSROOT does not automatically know that our floating dialog was resized by // CSS or by the user, so explicitly notify it when the canvas has real geometry. function resizeMusrfitRootCanvas(jsroot, canvas) { if (!jsroot || typeof jsroot.resize !== "function" || !canvas || !canvas.id) { return; } let bounds = canvas.getBoundingClientRect(); if (bounds.width <= 0 || bounds.height <= 0) { return; } jsroot.resize(canvas.id); } // Keep the ROOT canvas fitted to the floating window. requestAnimationFrame // coalesces rapid resize events while the user drags the dialog edge. function installMusrfitRootResizeObserver(jsroot, canvas) { if (typeof ResizeObserver !== "function" || !jsroot || typeof jsroot.resize !== "function" || !canvas) { return; } let resizeFrame = 0; let observer = new ResizeObserver(function() { if (resizeFrame) { return; } resizeFrame = window.requestAnimationFrame(function() { resizeFrame = 0; if (document.body.contains(canvas)) { resizeMusrfitRootCanvas(jsroot, canvas); } }); }); observer.observe(canvas); canvas.__musrfitRootResizeObserver = observer; } // Draw all ROOT canvases returned by musrview. Each PLOT block becomes one pane; // errors are shown beside the affected pane rather than failing the whole window. async function renderMusrfitRootPlots(container, plotSpecs, renderVersion, viewMode = "clean", decodeCache = null) { let renderToken = beginMusrfitRootRender(container); disconnectMusrfitRootResizeObservers(container); container.replaceChildren(); if (!plotSpecs.length) { let message = document.createElement("div"); message.className = "web-root-message"; message.textContent = "No ROOT plot files were returned."; container.appendChild(message); return; } let jsroot = null; try { jsroot = await withMusrfitRootTimeout( loadMusrfitJSRoot(), "Loading JSROOT", window.MusrfitJSRootURL); } catch (error) { let message = document.createElement("div"); message.className = "web-root-message web-root-error"; message.textContent = "Could not load JSROOT: " + (error && error.message ? error.message : String(error)); container.appendChild(message); return; } if (musrfitRootRenderIsStale(container, renderToken, container)) { return; } for (let plotIndex = 0; plotIndex < plotSpecs.length; plotIndex++) { let plotSpec = plotSpecs[plotIndex]; let pane = document.createElement("section"); let canvas = document.createElement("div"); let status = document.createElement("div"); let canvasId = "musrfitRootCanvas" + renderVersion + "_" + plotIndex; pane.className = "web-root-plot-pane"; canvas.className = "web-root-canvas"; canvas.id = canvasId; status.className = "web-root-message"; status.textContent = "Loading ROOT canvas..."; pane.appendChild(canvas); pane.appendChild(status); container.appendChild(pane); try { // musrview reuses predictable filenames inside the same job directory; // add a harmless query parameter so redraw/reset requests never show a // stale canvas. let file = await withMusrfitRootTimeout( jsroot.openFile(plotSpec.url + (plotSpec.url.indexOf("?") === -1 ? "?" : "&") + "musrflow_root=" + encodeURIComponent(renderVersion)), "Opening ROOT file", plotSpec.url); if (musrfitRootRenderIsStale(container, renderToken, canvas)) { return; } // Reuse a previously decoded canvas for clean/original/reset redraws // instead of re-fetching the ROOT file over the network on every toggle. // The cached copy is always pristine; each render draws its own clone so // clean-view mutation never leaks back into the cache (or the original). let cacheKey = decodeCache ? musrfitRootCacheKey(plotSpec) : ""; let drawObject; if (decodeCache) { let cached = decodeCache.get(cacheKey); if (cached) { drawObject = musrfitRootCloneCanvas(cached, jsroot); } else { let fileObject = await withMusrfitRootTimeout( file.readObject(plotSpec.item), "Decoding object " + plotSpec.item, plotSpec.url); if (musrfitRootRenderIsStale(container, renderToken, canvas)) { return; } drawObject = musrfitRootCloneCanvas(fileObject, jsroot); decodeCache.set(cacheKey, fileObject); } } else { drawObject = await withMusrfitRootTimeout( file.readObject(plotSpec.item), "Decoding object " + plotSpec.item, plotSpec.url); if (musrfitRootRenderIsStale(container, renderToken, canvas)) { return; } drawObject = musrfitRootCloneCanvas(drawObject, jsroot); } if (viewMode === "clean") { cleanMusrfitRootCanvas(drawObject); } let painter = await withMusrfitRootTimeout( jsroot.draw(canvasId, drawObject, ""), "Drawing ROOT canvas", plotSpec.url); if (musrfitRootRenderIsStale(container, renderToken, canvas)) { return; } // The normal JSROOT point tooltip contains file/object details and can // obscure a large fraction of a multi-run plot. Clean view suppresses // it; switching back with `c` restores the original ROOT behaviour. if (painter && typeof painter.setTooltipAllowed === "function") { painter.setTooltipAllowed(viewMode !== "clean"); } installMusrfitRootResizeObserver(jsroot, canvas); resizeMusrfitRootCanvas(jsroot, canvas); status.remove(); } catch (error) { if (musrfitRootRenderIsStale(container, renderToken, canvas)) { return; } status.className = "web-root-message web-root-error"; status.textContent = "Could not draw " + plotSpec.item + ": " + (error && error.message ? error.message : String(error)); let retry = document.createElement("button"); retry.type = "button"; retry.className = "web-root-retry"; retry.textContent = "Retry"; retry.title = "Try loading " + plotSpec.url + " again"; status.appendChild(document.createTextNode(" ")); status.appendChild(retry); retry.addEventListener("click", function() { renderMusrfitRootPlots(container, plotSpecs, renderVersion, viewMode); }); } } } // Create a non-modal floating JSROOT window for web plots. Electron deliberately // keeps using the native musrview window and does not call this function. function showWebRootPlotWindow(rootUrls, jobName = "", plotContext = {}) { let plotSpecs = normalizeMusrfitRootPlotSpecs(rootUrls, plotContext.rootItems || []); if (!plotSpecs.length) { return; } webRootPlotWindowSequence++; let plotWindow = document.createElement("dialog"); let plotHeader = document.createElement("div"); let plotMenuButton = document.createElement("button"); let plotActionMenu = document.createElement("div"); let plotDragHandle = document.createElement("div"); let plotControls = document.createElement("div"); let minimizeButton = document.createElement("button"); let maximizeButton = document.createElement("button"); let closeButton = document.createElement("button"); let plotContainer = document.createElement("div"); plotWindow.className = "web-plot-window web-root-window"; plotWindow.dataset.plotMode = "spectrum"; plotWindow.dataset.plotState = "normal"; plotWindow.setAttribute("aria-label", jobName ? "Plot: " + jobName : "musrview ROOT plot"); plotWindow.setAttribute("aria-modal", "false"); plotWindow.tabIndex = -1; plotHeader.className = "web-plot-header web-root-plot-header"; plotMenuButton.type = "button"; plotMenuButton.className = "web-plot-menu-button"; plotMenuButton.innerHTML = "☰"; plotMenuButton.title = "Plot actions"; plotMenuButton.setAttribute("aria-label", "Plot actions"); plotMenuButton.setAttribute("aria-haspopup", "menu"); plotMenuButton.setAttribute("aria-expanded", "false"); plotActionMenu.className = "web-plot-action-menu"; plotActionMenu.setAttribute("role", "menu"); plotActionMenu.hidden = true; plotDragHandle.className = "web-plot-drag-handle"; plotControls.className = "web-plot-controls"; minimizeButton.type = "button"; minimizeButton.innerHTML = "−"; minimizeButton.title = "Minimize plot"; minimizeButton.setAttribute("aria-label", "Minimize plot"); maximizeButton.type = "button"; maximizeButton.innerHTML = "□"; maximizeButton.title = "Maximize plot"; maximizeButton.setAttribute("aria-label", "Maximize plot"); closeButton.type = "button"; closeButton.innerHTML = "×"; closeButton.title = "Close plot"; closeButton.setAttribute("aria-label", "Close plot"); plotContainer.className = "web-root-plots"; plotControls.appendChild(minimizeButton); plotControls.appendChild(maximizeButton); plotControls.appendChild(closeButton); plotHeader.appendChild(plotMenuButton); plotHeader.appendChild(plotActionMenu); plotHeader.appendChild(plotDragHandle); plotHeader.appendChild(plotControls); plotWindow.appendChild(plotHeader); plotWindow.appendChild(plotContainer); let initialSpecs = plotSpecs.slice(); let currentSpecs = initialSpecs.slice(); let renderVersion = Date.now().toString(36) + "-" + webRootPlotWindowSequence; let rootPlotRequestInProgress = false; let isFFT = false; let isAveraged = false; let rootViewMode = "clean"; let averageActionButton = null; plotWindow.dataset.plotView = rootViewMode; plotWindow.dataset.plotMode = "spectrum"; plotWindow.dataset.plotAverage = "off"; // Cache ROOT plot specs and decoded objects per (spectrum/FFT × average) view // so toggles can restore previously fetched views without another server round-trip. let rootSpecCache = { "spectrum:n": initialSpecs.slice() }; let rootDecodeCaches = { "spectrum:n": new Map() }; function rootViewKey(fft, averaged) { return (fft ? "fft" : "spectrum") + ":" + (averaged ? "y" : "n"); } function currentDecodeCache() { let key = rootViewKey(isFFT, isAveraged); if (!rootDecodeCaches[key]) { rootDecodeCaches[key] = new Map(); } return rootDecodeCaches[key]; } function updateAverageActionState() { if (!averageActionButton) { return; } averageActionButton.textContent = isAveraged ? "Average view (on)" : "Average view"; averageActionButton.setAttribute("aria-pressed", isAveraged ? "true" : "false"); averageActionButton.title = isAveraged ? "Show non-averaged data/Fourier view (a)" : "Show averaged data/Fourier view (a)"; } function applyRootPlotView(fft, averaged, specs, statusMessage) { let key = rootViewKey(fft, averaged); isFFT = fft; isAveraged = averaged; currentSpecs = specs.slice(); plotWindow.dataset.plotMode = fft ? "fft" : "spectrum"; plotWindow.dataset.plotAverage = averaged ? "on" : "off"; if (!rootDecodeCaches[key]) { rootDecodeCaches[key] = new Map(); } let versionTag = (fft ? "fft" : "spectrum") + (averaged ? "-avg" : "") + "-" + webRootPlotWindowSequence; let version = Date.now().toString(36) + "-" + versionTag; renderMusrfitRootPlots(plotContainer, currentSpecs, version, rootViewMode, rootDecodeCaches[key]); updateAverageActionState(); if (statusMessage && typeof updateJobStatus === "function") { updateJobStatus(statusMessage); } } // Redrawing the same ROOT object is the most robust unzoom/reset operation: // it avoids depending on JSROOT painter internals while preserving the file. function rerenderCurrentRootPlots(statusMessage) { if (!currentSpecs.length) { return; } let resetVersion = Date.now().toString(36) + "-reset-" + webRootPlotWindowSequence; renderMusrfitRootPlots(plotContainer, currentSpecs, resetVersion, rootViewMode, currentDecodeCache()); if (statusMessage && typeof updateJobStatus === "function") { updateJobStatus({ message: statusMessage }); } } // Spectrum/FFT and averaged/non-averaged views are generated by musrview on // the server, like the existing FFT toggle. Cache fetched specs per view. async function setRootPlotView(fft, averaged) { if (rootPlotRequestInProgress || (fft === isFFT && averaged === isAveraged)) { return; } let key = rootViewKey(fft, averaged); if (rootSpecCache[key]) { let message = fft ? (averaged ? "Averaged FFT ROOT plot restored" : "FFT ROOT plot restored") : (averaged ? "Averaged ROOT plot restored" : "Original ROOT plot restored"); applyRootPlotView(fft, averaged, rootSpecCache[key], { message: message, plotPath: rootSpecCache[key][0].url }); return; } if (!plotContext.msrPath || typeof postToMusrfitCGI !== "function") { return; } rootPlotRequestInProgress = true; let requestLabel = (averaged ? "averaged " : "") + (fft ? "FFT " : "") + "ROOT plot"; if (typeof updateJobStatus === "function") { updateJobStatus({ state: "Running musrview", message: "Generating " + requestLabel, finishedAt: "", exitCode: "" }); } let request = await postToMusrfitCGI({ action: "run", fn: plotContext.msrPath, use_msr2data: 0, runs: plotContext.runs || "", template_name: "", base_run: "", fftv: fft ? "y" : "n", avgv: averaged ? "y" : "n", plot_only: 1, plot_refresh: 1 }); let response = request.payload; let rootUrls = musrfitRootUrlsFromResponse(response); let specs = normalizeMusrfitRootPlotSpecs(rootUrls, response && Array.isArray(response.root_items) ? response.root_items : []); if (response && response.command_log && typeof appendJobLog === "function") { appendJobLog(response.command_log.trim()); } if (!request.ok || !response || !response.ok || !specs.length) { let errorMessage = request.error || (response ? response.message : "Plot request failed"); if (response && response.stderr) { errorMessage += "\n" + response.stderr.trim(); } if (typeof finishJobStatus === "function") { finishJobStatus(0, response && response.code !== undefined ? response.code : 1, errorMessage); } rootPlotRequestInProgress = false; return; } rootSpecCache[key] = specs.slice(); rootDecodeCaches[key] = new Map(); applyRootPlotView(fft, averaged, rootSpecCache[key], { plotPath: specs[0].url }); if (typeof finishJobStatus === "function") { finishJobStatus(1, response.code !== undefined ? response.code : 0, response.message || (requestLabel.charAt(0).toUpperCase() + requestLabel.slice(1) + " completed")); } rootPlotRequestInProgress = false; } async function toggleMusrfitRootFFT() { await setRootPlotView(!isFFT, isAveraged); } async function toggleMusrfitRootAverage() { if (!plotContext.msrPath) { return; } await setRootPlotView(isFFT, !isAveraged); } renderMusrfitRootPlots(plotContainer, initialSpecs, renderVersion, rootViewMode, currentDecodeCache()); updateAverageActionState(); // Build one action, e.g. a menu button, for a plot action. Toggle/stateful // actions report their current result through updateJobStatus. function rootPlotActionButton(label, title, onClick) { let button = document.createElement("button"); button.type = "button"; button.className = "web-plot-action"; button.textContent = label; button.setAttribute("role", "menuitem"); button.tabIndex = -1; if (title) { button.title = title; } button.addEventListener("click", function() { plotActionMenu.hidden = true; plotMenuButton.setAttribute("aria-expanded", "false"); onClick(); }); return button; } let fftActionButton = null; if (plotContext.msrPath) { // FFT and average views are server-side musrview work, so they are only // offered when the plot knows the .msr behind it. fftActionButton = rootPlotActionButton("FFT", "Toggle Fourier power spectrum (f)", function() { toggleMusrfitRootFFT(); }); plotActionMenu.appendChild(fftActionButton); averageActionButton = rootPlotActionButton("Average view", "Show averaged data/Fourier view (a)", function() { toggleMusrfitRootAverage(); }); averageActionButton.setAttribute("aria-pressed", "false"); plotActionMenu.appendChild(averageActionButton); } plotActionMenu.appendChild(rootPlotActionButton( "Clean / Original view", "alternate between the compact clean view and the full ROOT view", function() { rootViewMode = rootViewMode === "clean" ? "original" : "clean"; plotWindow.dataset.plotView = rootViewMode; rerenderCurrentRootPlots(rootViewMode === "clean" ? "Clean ROOT plot view" : "Original ROOT plot view"); } )); plotActionMenu.appendChild(rootPlotActionButton( "Reset view", "redraw the current plot to undo pan and zoom (u)", function() { rerenderCurrentRootPlots("ROOT plot view reset"); } )); updateAverageActionState(); function toggleRootPlotActionMenu(forceOpen) { let open = forceOpen !== undefined ? Boolean(forceOpen) : plotActionMenu.hidden; plotActionMenu.hidden = !open; plotMenuButton.setAttribute("aria-expanded", open ? "true" : "false"); } plotMenuButton.addEventListener("click", function(event) { event.stopPropagation(); toggleRootPlotActionMenu(); }); // Close the action menu when interacting anywhere else in the window. plotWindow.addEventListener("pointerdown", function(event) { if (!plotActionMenu.hidden && event.target !== plotMenuButton && !plotActionMenu.contains(event.target)) { toggleRootPlotActionMenu(false); } }); // Minimal musrview-like shortcuts for the focused ROOT plot window. plotWindow.addEventListener("keydown", function(event) { // Plot shortcuts should not steal keystrokes from inputs, selects, or // editable regions that may appear in future plot controls. let target = event.target; let targetTagName = target && target.tagName ? target.tagName.toLowerCase() : ""; let editableTarget = target && (target.isContentEditable || targetTagName === "input" || targetTagName === "textarea" || targetTagName === "select"); if (event.altKey || event.ctrlKey || event.metaKey || editableTarget) { return; } let shortcut = event.key.length === 1 ? event.key.toLowerCase() : event.key; if (shortcut === "f") { if (plotContext.msrPath) { event.preventDefault(); toggleMusrfitRootFFT(); } } else if (shortcut === "c") { event.preventDefault(); rootViewMode = rootViewMode === "clean" ? "original" : "clean"; plotWindow.dataset.plotView = rootViewMode; rerenderCurrentRootPlots(rootViewMode === "clean" ? "Clean ROOT plot view" : "Original ROOT plot view"); } else if (shortcut === "a") { if (plotContext.msrPath) { event.preventDefault(); toggleMusrfitRootAverage(); } } else if (shortcut === "u") { event.preventDefault(); rerenderCurrentRootPlots("ROOT plot view reset"); } else if (shortcut === "q" || shortcut === "Escape") { event.preventDefault(); plotWindow.close(); } }); let normalBounds = null; let stateBeforeMinimize = "normal"; // Store the last normal bounds so minimize/maximize/restore are reversible. minimizeButton.addEventListener("click", function() { if (plotWindow.dataset.plotState === "minimized") { plotWindow.dataset.plotState = stateBeforeMinimize; minimizeButton.innerHTML = "−"; minimizeButton.title = "Minimize plot"; minimizeButton.setAttribute("aria-label", "Minimize plot"); if (stateBeforeMinimize === "maximized") { plotWindow.style.left = "12px"; plotWindow.style.right = "auto"; plotWindow.style.top = "12px"; plotWindow.style.width = "calc(100vw - 24px)"; plotWindow.style.height = "calc(100vh - var(--mu-status-height) - 36px)"; } else if (normalBounds) { plotWindow.style.left = normalBounds.left + "px"; plotWindow.style.right = "auto"; plotWindow.style.top = normalBounds.top + "px"; plotWindow.style.width = normalBounds.width + "px"; plotWindow.style.height = normalBounds.height + "px"; } layoutMusrfitRootWindows(); return; } if (plotWindow.dataset.plotState === "normal") { let bounds = plotWindow.getBoundingClientRect(); normalBounds = { left: bounds.left, top: bounds.top, width: bounds.width, height: bounds.height }; } stateBeforeMinimize = plotWindow.dataset.plotState; plotWindow.dataset.plotState = "minimized"; minimizeButton.innerHTML = "⧉"; minimizeButton.title = "Restore plot"; minimizeButton.setAttribute("aria-label", "Restore plot"); plotWindow.style.width = ""; plotWindow.style.height = ""; layoutMusrfitRootWindows(); }); maximizeButton.addEventListener("click", function() { if (plotWindow.dataset.plotState === "maximized") { plotWindow.dataset.plotState = "normal"; maximizeButton.innerHTML = "□"; maximizeButton.title = "Maximize plot"; maximizeButton.setAttribute("aria-label", "Maximize plot"); if (normalBounds) { plotWindow.style.left = normalBounds.left + "px"; plotWindow.style.right = "auto"; plotWindow.style.top = normalBounds.top + "px"; plotWindow.style.width = normalBounds.width + "px"; plotWindow.style.height = normalBounds.height + "px"; } return; } if (plotWindow.dataset.plotState === "normal") { let bounds = plotWindow.getBoundingClientRect(); normalBounds = { left: bounds.left, top: bounds.top, width: bounds.width, height: bounds.height }; } plotWindow.dataset.plotState = "maximized"; minimizeButton.innerHTML = "−"; minimizeButton.title = "Minimize plot"; minimizeButton.setAttribute("aria-label", "Minimize plot"); maximizeButton.innerHTML = "⧉"; maximizeButton.title = "Restore plot size"; maximizeButton.setAttribute("aria-label", "Restore plot size"); plotWindow.style.left = "12px"; plotWindow.style.right = "auto"; plotWindow.style.top = "12px"; plotWindow.style.width = "calc(100vw - 24px)"; plotWindow.style.height = "calc(100vh - var(--mu-status-height) - 36px)"; layoutMusrfitRootWindows(); }); closeButton.addEventListener("click", function() { plotWindow.close(); }); plotWindow.addEventListener("close", function() { disconnectMusrfitRootResizeObservers(plotContainer); plotWindow.remove(); layoutMusrfitRootWindows(); }); // Bring the active plot above older plot windows before handling shortcuts or // drag operations. plotWindow.addEventListener("pointerdown", function() { bringMusrfitFloatingWindowToFront(plotWindow); try { plotWindow.focus({ preventScroll: true }); } catch (error) { plotWindow.focus(); } }); let dragPosition = null; // The blank header is intentionally only a drag handle plus window controls. plotHeader.addEventListener("pointerdown", function(event) { if (plotWindow.dataset.plotState !== "normal" || plotControls.contains(event.target) || plotMenuButton.contains(event.target) || plotActionMenu.contains(event.target)) { return; } let bounds = plotWindow.getBoundingClientRect(); dragPosition = { pointerX: event.clientX, pointerY: event.clientY, windowX: bounds.left, windowY: bounds.top }; plotHeader.setPointerCapture(event.pointerId); event.preventDefault(); }); plotHeader.addEventListener("pointermove", function(event) { if (!dragPosition) { return; } let maximumX = Math.max(0, window.innerWidth - plotWindow.offsetWidth); let maximumY = Math.max(0, window.innerHeight - plotHeader.offsetHeight); let nextX = dragPosition.windowX + event.clientX - dragPosition.pointerX; let nextY = dragPosition.windowY + event.clientY - dragPosition.pointerY; plotWindow.style.left = Math.min(maximumX, Math.max(0, nextX)) + "px"; plotWindow.style.top = Math.min(maximumY, Math.max(0, nextY)) + "px"; }); plotHeader.addEventListener("pointerup", function(event) { dragPosition = null; plotHeader.releasePointerCapture(event.pointerId); }); document.body.appendChild(plotWindow); plotWindow.show(); bringMusrfitFloatingWindowToFront(plotWindow); try { plotWindow.focus({ preventScroll: true }); } catch (error) { plotWindow.focus(); } // Stagger several open plots slightly so their controls remain reachable. let cascadeOffset = ((webRootPlotWindowSequence - 1) % 6) * 24; let initialX = window.innerWidth - plotWindow.offsetWidth - 12 - cascadeOffset; plotWindow.style.left = Math.max(12, initialX) + "px"; plotWindow.style.top = 12 + cascadeOffset + "px"; }