| import { ProgressBarUIBase } from './progressBarUIBase.js';
|
| import { createStyleSheet, formatBytes } from './utils.js';
|
| export class MonitorUI extends ProgressBarUIBase {
|
| rootElement;
|
| monitorCPUElement;
|
| monitorRAMElement;
|
| monitorHDDElement;
|
| monitorGPUSettings;
|
| monitorVRAMSettings;
|
| monitorTemperatureSettings;
|
| currentRate;
|
| lastMonitor = 1;
|
| styleSheet;
|
| maxVRAMUsed = {};
|
| _disableSmooth = false;
|
| _numbersOnly = false;
|
| _numbersOnlySheet;
|
| _disableSmoothSheet;
|
| _pendingData = null;
|
| _rafId = 0;
|
| constructor(rootElement, monitorCPUElement, monitorRAMElement, monitorHDDElement, monitorGPUSettings, monitorVRAMSettings, monitorTemperatureSettings, currentRate, disableSmooth = false, numbersOnly = false) {
|
| super('crysmonitor-monitors-root', rootElement);
|
| this.rootElement = rootElement;
|
| this.monitorCPUElement = monitorCPUElement;
|
| this.monitorRAMElement = monitorRAMElement;
|
| this.monitorHDDElement = monitorHDDElement;
|
| this.monitorGPUSettings = monitorGPUSettings;
|
| this.monitorVRAMSettings = monitorVRAMSettings;
|
| this.monitorTemperatureSettings = monitorTemperatureSettings;
|
| this.currentRate = currentRate;
|
| this._disableSmooth = disableSmooth;
|
| this._numbersOnly = numbersOnly;
|
| this._numbersOnlySheet = createStyleSheet('crysmonitor-numbers-only');
|
| this._disableSmoothSheet = createStyleSheet('crysmonitor-disable-smooth');
|
| this.createDOM();
|
| this.styleSheet = createStyleSheet('crysmonitor-monitors-size');
|
|
|
| this._applyNumbersOnlyCSS();
|
| this._applyDisableSmoothCSS();
|
| }
|
| createDOM = () => {
|
| if (!this.rootElement) {
|
| throw Error('CrysMonitor: MonitorUI - Container not found');
|
| }
|
|
|
| this.rootElement.appendChild(this.createMonitor(this.monitorCPUElement));
|
| this.rootElement.appendChild(this.createMonitor(this.monitorRAMElement));
|
| this.rootElement.appendChild(this.createMonitor(this.monitorHDDElement));
|
| this.updateAllAnimationDuration(this.currentRate);
|
| };
|
| createDOMGPUMonitor = (monitorSettings) => {
|
| if (!(monitorSettings && this.rootElement)) {
|
| return;
|
| }
|
| this.rootElement.appendChild(this.createMonitor(monitorSettings));
|
| this.updateAllAnimationDuration(this.currentRate);
|
| };
|
| orderMonitors = () => {
|
| try {
|
|
|
| this.monitorCPUElement.htmlMonitorRef.style.order = '' + this.lastMonitor++;
|
|
|
| this.monitorRAMElement.htmlMonitorRef.style.order = '' + this.lastMonitor++;
|
|
|
| this.monitorGPUSettings.forEach((_monitorSettings, index) => {
|
|
|
| this.monitorGPUSettings[index].htmlMonitorRef.style.order = '' + this.lastMonitor++;
|
|
|
| this.monitorVRAMSettings[index].htmlMonitorRef.style.order = '' + this.lastMonitor++;
|
|
|
| this.monitorTemperatureSettings[index].htmlMonitorRef.style.order = '' + this.lastMonitor++;
|
| });
|
|
|
| this.monitorHDDElement.htmlMonitorRef.style.order = '' + this.lastMonitor++;
|
| }
|
| catch (error) {
|
| console.error('orderMonitors', error);
|
| }
|
| };
|
| updateDisplay = (data) => {
|
|
|
| this._pendingData = data;
|
| if (!this._rafId) {
|
| this._rafId = requestAnimationFrame(this._flushDisplay);
|
| }
|
| };
|
| _flushDisplay = () => {
|
| this._rafId = 0;
|
| const data = this._pendingData;
|
| if (!data)
|
| return;
|
|
|
|
|
| if (document.hidden)
|
| return;
|
| this._pendingData = null;
|
| this._doUpdateDisplay(data);
|
| };
|
| _doUpdateDisplay = (data) => {
|
| this.updateMonitor(this.monitorCPUElement, data.cpu_utilization);
|
| this.updateMonitor(this.monitorRAMElement, data.ram_used_percent, data.ram_used, data.ram_total);
|
| this.updateMonitor(this.monitorHDDElement, data.hdd_used_percent, data.hdd_used, data.hdd_total);
|
| if (data.gpus === undefined || data.gpus.length === 0) {
|
| console.warn('UpdateAllMonitors: no GPU data');
|
| return;
|
| }
|
| this.monitorGPUSettings.forEach((monitorSettings, index) => {
|
| if (data.gpus[index]) {
|
| const gpu = data.gpus[index];
|
| if (gpu === undefined) {
|
|
|
| return;
|
| }
|
| this.updateMonitor(monitorSettings, gpu.gpu_utilization);
|
| }
|
| else {
|
|
|
| }
|
| });
|
| this.monitorVRAMSettings.forEach((monitorSettings, index) => {
|
| if (data.gpus[index]) {
|
| const gpu = data.gpus[index];
|
| if (gpu === undefined) {
|
|
|
| return;
|
| }
|
| this.updateMonitor(monitorSettings, gpu.vram_used_percent, gpu.vram_used, gpu.vram_total);
|
| }
|
| else {
|
|
|
| }
|
| });
|
| this.monitorTemperatureSettings.forEach((monitorSettings, index) => {
|
| if (data.gpus[index]) {
|
| const gpu = data.gpus[index];
|
| if (gpu === undefined) {
|
|
|
| return;
|
| }
|
| this.updateMonitor(monitorSettings, gpu.gpu_temperature);
|
| if (!this._numbersOnly && monitorSettings.cssColorFinal && monitorSettings.htmlMonitorSliderRef) {
|
| const tempFloored = Math.floor(gpu.gpu_temperature);
|
| if (monitorSettings._lastTempColor !== tempFloored) {
|
| monitorSettings._lastTempColor = tempFloored;
|
| monitorSettings.htmlMonitorSliderRef.style.backgroundColor =
|
| `color-mix(in srgb, ${monitorSettings.cssColorFinal} ${tempFloored}%, ${monitorSettings.cssColor})`;
|
| }
|
| }
|
| }
|
| else {
|
|
|
| }
|
| });
|
| };
|
|
|
| updateMonitor = (monitorSettings, percent, used, total) => {
|
| if (!(monitorSettings.htmlMonitorSliderRef && monitorSettings.htmlMonitorLabelRef)) {
|
| return;
|
| }
|
| if (percent < 0) {
|
| return;
|
| }
|
| const flooredPercent = Math.floor(percent);
|
|
|
| if (monitorSettings._lastPercent === flooredPercent &&
|
| monitorSettings._lastUsed === used &&
|
| monitorSettings._lastTotal === total) {
|
| return;
|
| }
|
| monitorSettings._lastPercent = flooredPercent;
|
| monitorSettings._lastUsed = used;
|
| monitorSettings._lastTotal = total;
|
| const prefix = monitorSettings.monitorTitle ? monitorSettings.monitorTitle + ' - ' : '';
|
| let title = `${flooredPercent}${monitorSettings.symbol}`;
|
| let postfix = '';
|
|
|
| if (used !== undefined && total !== undefined) {
|
|
|
| const gpuIndex = parseInt(monitorSettings.monitorTitle?.split(':')[0] || '0');
|
|
|
| if (!this.maxVRAMUsed[gpuIndex] || this.maxVRAMUsed[gpuIndex] > total) {
|
| this.maxVRAMUsed[gpuIndex] = 0;
|
| }
|
|
|
| if (used > this.maxVRAMUsed[gpuIndex]) {
|
| this.maxVRAMUsed[gpuIndex] = used;
|
| }
|
| postfix = ` - ${formatBytes(used)} / ${formatBytes(total)}`;
|
|
|
| postfix += ` Max: ${formatBytes(this.maxVRAMUsed[gpuIndex])}`;
|
| }
|
| title = `${prefix}${title}${postfix}`;
|
| if (monitorSettings.htmlMonitorRef) {
|
| monitorSettings.htmlMonitorRef.title = title;
|
| }
|
| monitorSettings.htmlMonitorLabelRef.textContent = `${flooredPercent}${monitorSettings.symbol}`;
|
|
|
| if (!this._numbersOnly) {
|
| monitorSettings.htmlMonitorSliderRef.style.transform = `scaleX(${Math.min(flooredPercent / 100, 1).toFixed(4)})`;
|
| }
|
| };
|
| updateAllAnimationDuration = (value) => {
|
| this.currentRate = value;
|
| this.updatedAnimationDuration(this.monitorCPUElement, value);
|
| this.updatedAnimationDuration(this.monitorRAMElement, value);
|
| this.updatedAnimationDuration(this.monitorHDDElement, value);
|
| this.monitorGPUSettings.forEach((monitorSettings) => {
|
| monitorSettings && this.updatedAnimationDuration(monitorSettings, value);
|
| });
|
| this.monitorVRAMSettings.forEach((monitorSettings) => {
|
| monitorSettings && this.updatedAnimationDuration(monitorSettings, value);
|
| });
|
| this.monitorTemperatureSettings.forEach((monitorSettings) => {
|
| monitorSettings && this.updatedAnimationDuration(monitorSettings, value);
|
| });
|
| };
|
| updatedAnimationDuration = (monitorSettings, value) => {
|
| const slider = monitorSettings.htmlMonitorSliderRef;
|
| if (!slider) {
|
| return;
|
| }
|
|
|
|
|
| if (!this._disableSmooth) {
|
| slider.style.transition = `transform ${value.toFixed(1)}s linear`;
|
| }
|
| else {
|
| slider.style.transition = '';
|
| }
|
| };
|
| setDisableSmooth = (value) => {
|
| this._disableSmooth = value;
|
| this._applyDisableSmoothCSS();
|
| this.updateAllAnimationDuration(this.currentRate);
|
| };
|
| _applyDisableSmoothCSS = () => {
|
| if (this._disableSmooth) {
|
| this._disableSmoothSheet.innerText =
|
| '#crysmonitor-monitors-root .crysmonitor-slider { transition: none !important; }';
|
| }
|
| else {
|
| this._disableSmoothSheet.innerText = '';
|
| }
|
| };
|
| setNumbersOnly = (value) => {
|
| const wasNumbersOnly = this._numbersOnly;
|
| this._numbersOnly = value;
|
| this._applyNumbersOnlyCSS();
|
|
|
|
|
| if (wasNumbersOnly && !value) {
|
| this._invalidateMonitorCaches();
|
| }
|
| };
|
| _invalidateMonitorCaches = () => {
|
| const allSettings = [
|
| this.monitorCPUElement,
|
| this.monitorRAMElement,
|
| this.monitorHDDElement,
|
| ...this.monitorGPUSettings,
|
| ...this.monitorVRAMSettings,
|
| ...this.monitorTemperatureSettings,
|
| ];
|
| for (const s of allSettings) {
|
| if (s) {
|
| s._lastPercent = undefined;
|
| s._lastUsed = undefined;
|
| s._lastTotal = undefined;
|
| s._lastTempColor = undefined;
|
| }
|
| }
|
| };
|
| _applyNumbersOnlyCSS = () => {
|
| if (this._numbersOnly) {
|
| this._numbersOnlySheet.innerText =
|
| '#crysmonitor-monitors-root .crysmonitor-slider { display: none !important; }' +
|
| '#crysmonitor-monitors-root .crysmonitor-content { background-color: transparent !important; }';
|
| }
|
| else {
|
| this._numbersOnlySheet.innerText = '';
|
| }
|
| };
|
| createMonitor = (monitorSettings) => {
|
| if (!monitorSettings) {
|
|
|
| return document.createElement('div');
|
| }
|
| const htmlMain = document.createElement('div');
|
| htmlMain.classList.add(monitorSettings.id);
|
| htmlMain.classList.add('crysmonitor-monitor');
|
| monitorSettings.htmlMonitorRef = htmlMain;
|
| if (monitorSettings.title) {
|
| htmlMain.title = monitorSettings.title;
|
| }
|
| const htmlMonitorText = document.createElement('div');
|
| htmlMonitorText.classList.add('crysmonitor-text');
|
| htmlMonitorText.innerHTML = monitorSettings.label;
|
| htmlMain.append(htmlMonitorText);
|
| const htmlMonitorContent = document.createElement('div');
|
| htmlMonitorContent.classList.add('crysmonitor-content');
|
| htmlMain.append(htmlMonitorContent);
|
| const htmlMonitorSlider = document.createElement('div');
|
| htmlMonitorSlider.classList.add('crysmonitor-slider');
|
| if (monitorSettings.cssColorFinal) {
|
| htmlMonitorSlider.style.backgroundColor =
|
| `color-mix(in srgb, ${monitorSettings.cssColorFinal} 0%, ${monitorSettings.cssColor})`;
|
| }
|
| else {
|
| htmlMonitorSlider.style.backgroundColor = monitorSettings.cssColor;
|
| }
|
| monitorSettings.htmlMonitorSliderRef = htmlMonitorSlider;
|
| htmlMonitorContent.append(htmlMonitorSlider);
|
| const htmlMonitorLabel = document.createElement('div');
|
| htmlMonitorLabel.classList.add('crysmonitor-label');
|
| monitorSettings.htmlMonitorLabelRef = htmlMonitorLabel;
|
| htmlMonitorContent.append(htmlMonitorLabel);
|
| htmlMonitorLabel.textContent = '0%';
|
| return monitorSettings.htmlMonitorRef;
|
| };
|
| updateMonitorSize = (width, height) => {
|
|
|
| this.styleSheet.innerText = `#crysmonitor-monitors-root .crysmonitor-monitor .crysmonitor-content {height: ${height}px; width: ${width}px;}`;
|
| };
|
| showMonitor = (monitorSettings, value) => {
|
| if (monitorSettings.htmlMonitorRef) {
|
| monitorSettings.htmlMonitorRef.style.display = value ? 'flex' : 'none';
|
| }
|
| };
|
| }
|
|
|
