diff --git a/main.js b/main.js new file mode 100644 index 0000000..a1119f0 --- /dev/null +++ b/main.js @@ -0,0 +1,1122 @@ +/* +THIS IS A GENERATED/BUNDLED FILE BY ESBUILD +if you want to view the source, please visit the github repository of this plugin +*/ + +var __defProp = Object.defineProperty; +var __getOwnPropDesc = Object.getOwnPropertyDescriptor; +var __getOwnPropNames = Object.getOwnPropertyNames; +var __hasOwnProp = Object.prototype.hasOwnProperty; +var __export = (target, all) => { + for (var name in all) + __defProp(target, name, { get: all[name], enumerable: true }); +}; +var __copyProps = (to, from, except, desc) => { + if (from && typeof from === "object" || typeof from === "function") { + for (let key of __getOwnPropNames(from)) + if (!__hasOwnProp.call(to, key) && key !== except) + __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable }); + } + return to; +}; +var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod); + +// main.ts +var main_exports = {}; +__export(main_exports, { + default: () => ObsidianProgressBars +}); +module.exports = __toCommonJS(main_exports); +var import_obsidian = require("obsidian"); +var DEFAULT_SETTINGS = { + /* Progress Bar Settings */ + APB_title: "Progress", + APB_widthToggle: true, + APB_width: 190, + APB_height: 8, + APB_progressBarPercentage: 83, + APB_total: 100, + APB_endcapToggle: true, + APB_marksToggle: true, + APB_marksColor: "#000000", + APB_marksLightColor: "#ffffff", + APB_marksWidth: 3, + /* Text Settings */ + APB_titleToggle: true, + APB_titleColor: "#8fa0ba", + APB_titleLightColor: "#44546f", + APB_percentageToggle: true, + APB_percentageColor: "#c1d7f9", + APB_percentageLightColor: "#6d85ad", + APB_fractionToggle: true, + APB_fractionColor: "#8fa0ba", + APB_fractionLightColor: "#576a8a", + APB_completedToggle: true, + APB_completedColor: "#c1d7f9", + APB_completedLightColor: "#44546f", + /* Container Settings */ + APB_borderToggle: true, + APB_colorBorder: "#474f62", + APB_colorLightBorder: "#ced0d6", + APB_backgroundToggle: true, + APB_colorBackground: "#242a35", + APB_colorLightBackground: "#f1f2f4", + /* Progress Bar Color Settings */ + APB_colornumber: "option5", + APB_color1: "#2978ef", + APB_color2: "#8ec822", + APB_color3: "#dfaa22", + APB_color4: "#c84922", + APB_color5: "#dd4a86", + APB_color1Light: "#278378", + APB_color2Light: "#2baab9", + APB_color3Light: "#4a32e2", + APB_color4Light: "#7c328e", + APB_color5Light: "#c11e49", + APB_colorBarCompleted: "#576178", + APB_colorLightBarCompleted: "#fcfcfd", + APB_colorBarBackground: "#3b4252", + APB_colorLightBarBackground: "#d9dde2", + /* Additional Settings */ + APB_progressBarChange: true +}; +var ObsidianProgressBars = class extends import_obsidian.Plugin { + async onload() { + console.log("loading APB plugin"); + await this.loadSettings(); + this.addSettingTab(new ObsidianProgressBarsSettingTab(this.app, this)); + this.app.workspace.onLayoutReady(this.initializeProgressBars.bind(this)); + } + initializeProgressBars() { + this.registerMarkdownCodeBlockProcessor("obsidian-apb", (source, el, ctx) => { + const rows = source.trim().split("\n"); + el.empty(); + rows.forEach((row, index) => { + console.log("Processing line " + (index + 1), row); + const match = row.match(/^(.+):\s*(\d+)\/(\d+)$/); + if (!match) { + console.error("Invalid format for advanced progress bar block:", row); + const APB_errorContainer = document.createElement("div"); + APB_errorContainer.addClass("error-container"); + const APB_errorMessage = document.createElement("div"); + APB_errorMessage.addClass("error-text-container"); + APB_errorMessage.createEl("span", { text: "APB_ Error: Invalid block format" }); + APB_errorContainer.appendChild(APB_errorMessage); + el.appendChild(APB_errorContainer); + return; + } + const label = match[1]; + const current = parseInt(match[2], 10); + const total = parseInt(match[3], 10); + if (current > total && total !== 0) { + console.error("Invalid value for advanced progress bar block:", row); + const APB_errorContainer = document.createElement("div"); + APB_errorContainer.addClass("error-container"); + const APB_errorMessage = document.createElement("div"); + APB_errorMessage.addClass("error-text-container"); + APB_errorMessage.createEl("span", { text: "APB_ Error: Value is too large" }); + APB_errorContainer.appendChild(APB_errorMessage); + el.appendChild(APB_errorContainer); + return; + } + if (isNaN(current) || isNaN(total) || total === 0) { + console.error("Invalid advanced progress bar values:", row); + const APB_errorContainer = document.createElement("div"); + APB_errorContainer.addClass("error-container"); + const APB_errorMessage = document.createElement("div"); + APB_errorMessage.addClass("error-text-container"); + APB_errorMessage.createEl("span", { text: "APB_ Error: Invalid number" }); + APB_errorContainer.appendChild(APB_errorMessage); + el.appendChild(APB_errorContainer); + return; + } + const percentage = current / total * 100; + const clampedPercentage = Math.min(Math.max(Math.round(percentage), 0), 100); + const APB_container = document.createElement("div"); + APB_container.addClass("progressBar-container"); + if (this.settings.APB_borderToggle) { + APB_container.style.border = "1px solid ${this.settings.APB_colorBorder}"; + } else { + APB_container.style.border = "0px"; + } + if (this.settings.APB_backgroundToggle) { + APB_container.style.background = this.settings.APB_colorBackground; + } else { + APB_container.style.background = "transparent"; + } + const APB_textContainer = document.createElement("div"); + APB_textContainer.addClass("progressBar-text-container"); + const APB_backgroundToggle = document.createElement("div"); + APB_backgroundToggle.addClass("progressBar-background"); + APB_backgroundToggle.style.background = this.settings.APB_colorBarBackground; + const APB_title = document.createElement("div"); + APB_title.addClass("progressBar-title"); + if (this.settings.APB_titleToggle) { + APB_title.createEl("span", { text: label }); + APB_title.style.color = this.settings.APB_titleColor; + } + const APB_percentage = document.createElement("div"); + APB_percentage.addClass("progressBar-percentage"); + if (this.settings.APB_percentageToggle) { + APB_percentage.createEl("span", { text: clampedPercentage + "%" }); + APB_percentage.style.color = this.settings.APB_percentageColor; + } + const APB_value = document.createElement("div"); + APB_value.addClass("progressBar-value"); + if (this.settings.APB_fractionToggle) { + APB_value.createEl("span", { text: "(" + current + "/" + total + ")" }); + APB_value.style.color = this.settings.APB_fractionColor; + } + const APB_completed = document.createElement("div"); + APB_completed.addClass("progressBar-completed"); + if (this.settings.APB_completedToggle) { + APB_completed.createEl("span", { text: "" }); + APB_completed.style.color = this.settings.APB_percentageColor; + } + const APB = document.createElement("div"); + APB.addClass("progressBar"); + const progressBarwidth = this.settings.APB_width; + let numericWidth = parseInt(progressBarwidth.toString(), 10); + if (this.settings.APB_widthToggle) { + APB_container.style.width = "100%"; + APB_backgroundToggle.style.width = "100%"; + APB.style.width = `${clampedPercentage}%`; + } else { + APB_backgroundToggle.style.width = `${progressBarwidth}px`; + APB_container.style.width = `${numericWidth + 10}px`; + APB.style.width = `${numericWidth / 100 * clampedPercentage}px`; + } + APB.style.height = `${this.settings.APB_height}px`; + setEndCaps(APB_backgroundToggle, APB, this.settings.APB_endcapToggle); + APB_backgroundToggle.appendChild(APB); + const marks = document.createElement("div"); + marks.addClass("marks"); + const numberOfSections = parseInt(this.settings.APB_colornumber.replace(/\D/g, "")); + if (clampedPercentage !== 100) { + APB_backgroundToggle.appendChild(marks); + if (this.settings.APB_marksToggle) { + for (let i = 1; i <= numberOfSections - 1; i++) { + const mark = document.createElement("div"); + mark.addClass("mark"); + mark.style.left = `${i * (100 / numberOfSections)}%`; + marks.appendChild(mark); + const dpr = window.devicePixelRatio || 1; + const adjustedBorderWidth = this.settings.APB_marksWidth / dpr; + const rgbaColor = hexToRgba(this.settings.APB_marksColor, 0.5); + mark.style.borderLeft = adjustedBorderWidth + "px solid " + rgbaColor; + } + } + } + APB.appendChild(APB_completed); + for (let i = 1; i <= numberOfSections; i++) { + let sectionsize = `${i * (100 / numberOfSections)}%`; + const markLeftValue = parseFloat(sectionsize); + if (clampedPercentage <= markLeftValue && this.settings.APB_progressBarChange) { + APB.style.backgroundColor = String(this.settings[`APB_color${i}`]); + if (clampedPercentage == 100) { + APB.style.backgroundColor = this.settings.APB_colorBarCompleted; + if (this.settings.APB_completedToggle) { + APB_completed.textContent = "COMPLETED"; + } + } + this.settings.APB_progressBarChange = false; + this.saveSettings(); + } + } + this.settings.APB_progressBarChange = true; + APB_container.appendChild(APB_textContainer); + if (this.settings.APB_titleToggle) { + APB_textContainer.appendChild(APB_title); + } + if (this.settings.APB_percentageToggle) { + APB_textContainer.appendChild(APB_percentage); + } + if (this.settings.APB_fractionToggle) { + APB_textContainer.appendChild(APB_value); + } + APB_container.appendChild(APB_backgroundToggle); + el.appendChild(APB_container); + }); + }); + this.addCommand({ + id: "paste-code-block", + name: "Paste Code Block", + editorCallback: async (editor, view) => { + editor.focus(); + if (!editor) { + new import_obsidian.Notice("No active editor found!"); + return; + } + const valueFromPercentageOfTotal = Math.floor(this.settings.APB_total / 100 * this.settings.APB_progressBarPercentage); + const codeBlockText = `\`\`\`obsidian-apb +${this.settings.APB_title}: ${valueFromPercentageOfTotal}/${this.settings.APB_total} +\`\`\``; + const cursor = editor.getCursor(); + editor.replaceRange(codeBlockText, cursor); + const lines = codeBlockText.split("\n"); + const newCursor = { + line: cursor.line + lines.length - 1, + ch: lines[lines.length - 1].length + // Length of the last line + }; + setTimeout(() => { + editor.setCursor(newCursor); + editor.refresh(); + }, 0); + } + }); + } + async loadSettings() { + this.settings = Object.assign({}, DEFAULT_SETTINGS, await this.loadData()); + } + async saveSettings() { + await this.saveData(this.settings); + } + async onunload() { + console.log("Cleaning up resources when plugin unloads..."); + const copyButton = document.querySelector("button"); + if (copyButton) { + console.log("Found the copyButton in the DOM."); + copyButton.removeEventListener("click", this.copyButtonListener); + console.log("Event listener removed."); + } else { + console.log("No copyButton found in the DOM."); + } + } +}; +var ObsidianProgressBarsSettingTab = class extends import_obsidian.PluginSettingTab { + constructor(app, plugin) { + super(app, plugin); + this.plugin = plugin; + } + async display() { + const { containerEl } = this; + containerEl.empty(); + containerEl.createEl("h3", { text: "Advanced Progress Bars" }); + const paragraph = containerEl.createEl("p", { text: "If you find value in this plugin and would like to support us, please consider using our " }); + paragraph.createEl("a", { + href: "https://ko-fi.com/cactuzhead", + text: "ko-fi", + cls: "custom-link" + }); + const container = containerEl.createEl("div"); + container.addClass("custom-container"); + container.appendChild(paragraph); + const koFiLink = container.createEl("a"); + koFiLink.href = "https://ko-fi.com/cactuzhead"; + koFiLink.target = "_blank"; + const koFiImage = koFiLink.createEl("img"); + koFiImage.setAttribute("src", "https://storage.ko-fi.com/cdn/fullLogoKofi.png"); + koFiImage.setAttribute("alt", "Support us on Ko-fi"); + koFiImage.style.width = "100px"; + koFiImage.style.height = "auto"; + koFiLink.style.display = "inline-block"; + koFiLink.style.marginLeft = "10px"; + new import_obsidian.Setting(containerEl).setName("Usage Example Code Block").setDesc(createFragment((frag) => { + frag.appendText("Use this code block and edit the "); + const customElement = frag.createEl("span"); + customElement.setText("Title: Value/Total"); + customElement.classList.add("highlight-text"); + frag.appendText(" as needed."); + frag.createEl("br"); + frag.appendText("If you require more than one bar, simply create additional "); + const customElement2 = frag.createEl("span"); + customElement2.setText("Title: Value/Total"); + customElement2.classList.add("highlight-text"); + frag.appendText(" lines within the code block."); + frag.createEl("br"); + frag.appendText("Note: "); + const customElement3 = frag.createEl("span"); + customElement3.setText("Total"); + customElement3.classList.add("highlight-text"); + frag.appendText(" does not need to be 100."); + frag.createEl("br"); + frag.appendText("Visit "); + frag.createEl("a", { + href: "https://cactuzhead.github.io/Advanced-Progress-Bars/", + text: "cactuzhead", + cls: "custom-link" + }); + frag.appendText(" for more detailed information."); + })).addTextArea((textArea) => { + const valueFromPercentageOfTotal2 = Math.floor(this.plugin.settings.APB_total / 100 * this.plugin.settings.APB_progressBarPercentage); + textArea.setValue(`\`\`\`obsidian-apb +${this.plugin.settings.APB_title}: ${valueFromPercentageOfTotal2}/${this.plugin.settings.APB_total} +\`\`\``); + textArea.inputEl.style.height = "80px"; + textArea.inputEl.style.width = "200px"; + textArea.inputEl.style.resize = "none"; + const container2 = textArea.inputEl.parentElement; + if (container2) { + const copyButton = containerEl.createEl("button", { text: "Copy to Clipboard" }); + this.copyButtonListener = (event) => { + navigator.clipboard.writeText(textArea.inputEl.value).then(() => { + new import_obsidian.Notice("Content copied to clipboard!"); + }).catch((err) => { + new import_obsidian.Notice("Failed to copy content: " + err); + }); + }; + copyButton.addEventListener("click", this.copyButtonListener); + copyButton.style.marginTop = "10px"; + copyButton.style.display = "block"; + container2.style.display = "flex"; + container2.style.flexDirection = "column"; + } else { + console.error("Unable to find the parent container for the textarea"); + } + }); + containerEl.createEl("h4", { text: "Light & Dark" }); + new import_obsidian.Setting(containerEl).setName("Apply all Light & Dark color defaults").setDesc(createFragment((frag) => { + frag.appendText("These two options "); + frag.createEl("span", { + text: "(Light & Dark)", + cls: "highlight-text" + }); + frag.appendText(" will change ALL the color settings below to their respective defaults. (All other settings will remain unchanged)."); + frag.createEl("br"); + frag.appendText(" Note: once selected, all previous colors will be lost forever and can not be retrieved."); + })).addButton((button) => button.setIcon("sun").setTooltip("Reset to Light default").onClick(() => { + this.plugin.settings.APB_marksColor = DEFAULT_SETTINGS.APB_marksLightColor; + this.plugin.settings.APB_titleColor = DEFAULT_SETTINGS.APB_titleLightColor; + this.plugin.settings.APB_percentageColor = DEFAULT_SETTINGS.APB_percentageLightColor; + this.plugin.settings.APB_fractionColor = DEFAULT_SETTINGS.APB_fractionLightColor; + this.plugin.settings.APB_colorBorder = DEFAULT_SETTINGS.APB_colorLightBorder; + this.plugin.settings.APB_colorBackground = DEFAULT_SETTINGS.APB_colorLightBackground; + this.plugin.settings.APB_colorBarCompleted = DEFAULT_SETTINGS.APB_colorLightBarCompleted; + this.plugin.settings.APB_colorBarBackground = DEFAULT_SETTINGS.APB_colorLightBarBackground; + this.plugin.settings.APB_completedColor = DEFAULT_SETTINGS.APB_completedLightColor; + this.plugin.settings.APB_color1 = DEFAULT_SETTINGS.APB_color1Light; + this.plugin.settings.APB_color2 = DEFAULT_SETTINGS.APB_color2Light; + this.plugin.settings.APB_color3 = DEFAULT_SETTINGS.APB_color3Light; + this.plugin.settings.APB_color4 = DEFAULT_SETTINGS.APB_color4Light; + this.plugin.settings.APB_color5 = DEFAULT_SETTINGS.APB_color5Light; + this.plugin.saveSettings(); + this.display(); + })).addButton( + (button) => button.setIcon("moon").setTooltip("Reset to Dark default").onClick(() => { + this.plugin.settings.APB_marksColor = DEFAULT_SETTINGS.APB_marksColor; + this.plugin.settings.APB_colorBorder = DEFAULT_SETTINGS.APB_colorBorder; + this.plugin.settings.APB_titleColor = DEFAULT_SETTINGS.APB_titleColor; + this.plugin.settings.APB_percentageColor = DEFAULT_SETTINGS.APB_percentageColor; + this.plugin.settings.APB_fractionColor = DEFAULT_SETTINGS.APB_fractionColor; + this.plugin.settings.APB_colorBorder = DEFAULT_SETTINGS.APB_colorBorder; + this.plugin.settings.APB_colorBackground = DEFAULT_SETTINGS.APB_colorBackground; + this.plugin.settings.APB_colorBarCompleted = DEFAULT_SETTINGS.APB_colorBarCompleted; + this.plugin.settings.APB_colorBarBackground = DEFAULT_SETTINGS.APB_colorBarBackground; + this.plugin.settings.APB_completedColor = DEFAULT_SETTINGS.APB_completedColor; + this.plugin.settings.APB_color1 = DEFAULT_SETTINGS.APB_color1; + this.plugin.settings.APB_color2 = DEFAULT_SETTINGS.APB_color2; + this.plugin.settings.APB_color3 = DEFAULT_SETTINGS.APB_color3; + this.plugin.settings.APB_color4 = DEFAULT_SETTINGS.APB_color4; + this.plugin.settings.APB_color5 = DEFAULT_SETTINGS.APB_color5; + this.plugin.saveSettings(); + this.display(); + }) + ); + containerEl.createEl("h4", { text: "Demonstration Progress Bar" }); + new import_obsidian.Setting(containerEl).setDesc("Any changes you make to this settings page will be instantly reflected in the demonstration progress bar below. Use it as a guide when making your decisions."); + const progressBarContainer = containerEl.createEl("div"); + progressBarContainer.addClass("progressBar-container"); + if (this.plugin.settings.APB_borderToggle) { + progressBarContainer.style.border = "1px solid" + this.plugin.settings.APB_colorBorder; + } else { + progressBarContainer.style.border = "0px"; + } + if (this.plugin.settings.APB_backgroundToggle) { + progressBarContainer.style.background = this.plugin.settings.APB_colorBackground; + } else { + progressBarContainer.style.background = "transparent"; + } + const progressBarTextContainer = containerEl.createEl("div"); + progressBarTextContainer.addClass("progressBar-text-container"); + const progressBarBackground = containerEl.createEl("div"); + progressBarBackground.addClass("progressBar-background"); + progressBarBackground.style.background = this.plugin.settings.APB_colorBarBackground; + const progressBarTitle = containerEl.createEl("div"); + progressBarTitle.addClass("progressBar-title"); + if (this.plugin.settings.APB_titleToggle) { + progressBarTitle.createEl("span", { text: this.plugin.settings.APB_title }); + progressBarTitle.style.color = this.plugin.settings.APB_titleColor; + } + const progressBarPercentage = containerEl.createEl("div"); + progressBarPercentage.addClass("progressBar-percentage"); + if (this.plugin.settings.APB_percentageToggle) { + progressBarPercentage.createEl("span", { text: this.plugin.settings.APB_progressBarPercentage + "%" }); + progressBarPercentage.style.color = this.plugin.settings.APB_percentageColor; + } + const progressBarValue = containerEl.createEl("div"); + progressBarValue.addClass("progressBar-value"); + const valueFromPercentageOfTotal = Math.floor(this.plugin.settings.APB_total / 100 * this.plugin.settings.APB_progressBarPercentage); + if (this.plugin.settings.APB_fractionToggle) { + progressBarValue.createEl("span", { text: "(" + valueFromPercentageOfTotal + "/" + this.plugin.settings.APB_total + ")" }); + progressBarValue.style.color = this.plugin.settings.APB_fractionColor; + } + const completed = containerEl.createEl("div"); + completed.addClass("progressBar-completed"); + if (this.plugin.settings.APB_completedToggle) { + completed.style.color = this.plugin.settings.APB_completedColor; + if (this.plugin.settings.APB_progressBarPercentage == 100) { + completed.textContent = "COMPLETED"; + } + } + const progressbar = containerEl.createEl("div"); + progressbar.addClass("progressBar"); + const progressBarwidth = this.plugin.settings.APB_width; + let numericWidth = parseInt(progressBarwidth.toString(), 10); + const clampedPercentage = Math.min(Math.max(Math.round(this.plugin.settings.APB_progressBarPercentage), 0), 100); + if (this.plugin.settings.APB_widthToggle) { + progressBarContainer.style.width = "100%"; + progressBarBackground.style.width = "100%"; + progressbar.style.width = `${clampedPercentage}%`; + } else { + progressBarContainer.style.width = `${numericWidth}px`; + progressBarBackground.style.width = `${String(numericWidth - 12)}px`; + progressbar.style.width = `${(numericWidth - 12) / 100 * clampedPercentage}px`; + } + progressBarContainer.style.margin = "17px"; + progressbar.style.height = `${this.plugin.settings.APB_height}px`; + setEndCaps(progressBarBackground, progressbar, this.plugin.settings.APB_endcapToggle); + progressBarBackground.appendChild(progressbar); + progressbar.appendChild(completed); + const marks = containerEl.createEl("div"); + marks.addClass("marks"); + const numberOfSections = parseInt(this.plugin.settings.APB_colornumber.replace(/\D/g, "")); + if (this.plugin.settings.APB_progressBarPercentage !== 100) { + progressBarBackground.appendChild(marks); + if (this.plugin.settings.APB_marksToggle) { + for (let i = 1; i <= numberOfSections - 1; i++) { + const mark = containerEl.createEl("div"); + mark.addClass("mark"); + mark.style.left = `${i * (100 / numberOfSections)}%`; + marks.appendChild(mark); + const dpr = window.devicePixelRatio || 1; + const adjustedBorderWidth = this.plugin.settings.APB_marksWidth / dpr; + const rgbaColor = hexToRgba(this.plugin.settings.APB_marksColor, 0.5); + mark.style.borderLeft = adjustedBorderWidth + "px solid " + rgbaColor; + } + } + } + for (let i = 1; i <= numberOfSections; i++) { + let sectionsize = `${i * (100 / numberOfSections)}%`; + const progressBarPercentage2 = parseFloat(this.plugin.settings.APB_progressBarPercentage.toString()); + const markLeftValue = parseFloat(sectionsize); + if (progressBarPercentage2 <= markLeftValue && this.plugin.settings.APB_progressBarChange) { + progressbar.style.backgroundColor = String(this.plugin.settings[`APB_color${i}`]); + if (progressBarPercentage2 == 100) { + progressbar.style.backgroundColor = this.plugin.settings.APB_colorBarCompleted; + } + this.plugin.settings.APB_progressBarChange = false; + this.plugin.saveSettings(); + } + } + this.plugin.settings.APB_progressBarChange = true; + this.plugin.saveSettings(); + const progresstext = containerEl.createEl("p", { text: "This is a Demo Progress Bar." }); + const containerprogress = containerEl.createEl("div"); + containerprogress.addClass("custom-container"); + containerprogress.appendChild(progresstext); + progressBarContainer.appendChild(progressBarTextContainer); + if (this.plugin.settings.APB_titleToggle) { + progressBarTextContainer.appendChild(progressBarTitle); + } + if (this.plugin.settings.APB_percentageToggle) { + progressBarTextContainer.appendChild(progressBarPercentage); + } + if (this.plugin.settings.APB_fractionToggle) { + progressBarTextContainer.appendChild(progressBarValue); + } + containerprogress.appendChild(progressBarContainer); + progressBarContainer.appendChild(progressBarBackground); + containerEl.createEl("h4", { text: "Progress Bar" }); + new import_obsidian.Setting(containerEl).setName("Default title").setDesc(createFragment((frag) => { + frag.appendText("Set the default title of a new progress bar. If you change this, the "); + frag.createEl("span", { + text: "Title", + cls: "highlight-text" + }); + frag.appendText(" will be automatically changed in the example code block at the top of the settings for easy copy and pasting later on."); + })).addText((text) => { + let debounceTimeout; + text.setPlaceholder("Enter your title").setValue(this.plugin.settings.APB_title || "").onChange((value) => { + clearTimeout(debounceTimeout); + debounceTimeout = setTimeout(() => { + this.plugin.settings.APB_title = value; + this.plugin.settings.APB_progressBarChange = true; + this.plugin.saveSettings(); + this.display(); + }, 2e3); + }); + }).addButton( + (button) => button.setIcon("rotate-ccw").setTooltip("Reset to default").onClick(() => { + this.plugin.settings.APB_title = DEFAULT_SETTINGS.APB_title; + this.plugin.settings.APB_progressBarChange = true; + this.plugin.saveSettings(); + this.display(); + }) + ); + let timeoutId; + new import_obsidian.Setting(containerEl).setName("Default total").setDesc(createFragment((frag) => { + frag.appendText("Set the default "); + frag.createEl("span", { + text: "Total", + cls: "highlight-text" + }); + frag.appendText(" of a new progress bar. If you change this, the "); + frag.createEl("span", { + text: "Total", + cls: "highlight-text" + }); + frag.appendText(" will be automatically changed in the example code block above for easy copy and pasting later on."); + })).addText( + (text) => text.setPlaceholder("100").setValue(this.plugin.settings.APB_total !== void 0 ? String(this.plugin.settings.APB_total) : String(DEFAULT_SETTINGS.APB_total)).onChange((value) => { + clearTimeout(timeoutId); + timeoutId = setTimeout(() => { + var _a; + const parsedValue = parseInt(value, 10); + if (parsedValue >= 1 && (!isNaN(parsedValue) && parsedValue === parseFloat(value))) { + this.plugin.settings.APB_total = parsedValue; + this.plugin.saveSettings(); + this.display(); + } else { + text.setValue(String((_a = this.plugin.settings.APB_total) != null ? _a : DEFAULT_SETTINGS.APB_total)); + this.plugin.saveSettings(); + this.display(); + new import_obsidian.Notice("Please enter a value 1 or above."); + } + }, 1e3); + }).inputEl.classList.add("custom-textbox") + ).addButton( + (button) => button.setIcon("rotate-ccw").setTooltip("Reset to default").onClick(() => { + this.plugin.settings.APB_total = DEFAULT_SETTINGS.APB_total; + this.plugin.settings.APB_progressBarChange = true; + this.plugin.saveSettings(); + this.display(); + }) + ); + new import_obsidian.Setting(containerEl).setName("Progress percentage").setDesc(createFragment((frag) => { + frag.appendText("Set the percentage for the demonstration progress bar above. This will also update the "); + frag.createEl("span", { + text: "Value", + cls: "highlight-text" + }); + frag.appendText(" parameter in the Example Code at the top of the settings. Once you are satisfied with all other settings, you will likely want to set this back to 0."); + })).addSlider((slider) => { + var _a2; + var _a; + slider.setLimits(0, 100, 1).setDynamicTooltip().setValue((_a2 = this.plugin.settings.APB_progressBarPercentage) != null ? _a2 : DEFAULT_SETTINGS.APB_progressBarPercentage).onChange((value) => { + this.plugin.settings.APB_progressBarPercentage = value; + this.plugin.settings.APB_progressBarChange = true; + this.plugin.saveSettings(); + this.display(); + }); + }).addButton( + (button) => button.setIcon("rotate-ccw").setTooltip("Reset to default").onClick(() => { + this.plugin.settings.APB_progressBarPercentage = DEFAULT_SETTINGS.APB_progressBarPercentage; + this.plugin.settings.APB_progressBarChange = true; + this.plugin.saveSettings(); + this.display(); + }) + ); + new import_obsidian.Setting(containerEl).setName("Full width").setDesc(createFragment((frag) => { + frag.appendText("Toggle this on to set the progress bar to fill the entire width of its container. For a fixed width, toggle this off and use the "); + frag.createEl("span", { + text: "Width", + cls: "highlight-text" + }); + frag.appendText(" option that will appear below."); + })).addToggle((toggle) => toggle.setValue(this.plugin.settings.APB_widthToggle).onChange((value) => { + this.plugin.settings.APB_widthToggle = value; + this.plugin.saveSettings(); + this.display(); + })).addButton( + (button) => button.setIcon("rotate-ccw").setTooltip("Reset to default").onClick(() => { + this.plugin.settings.APB_widthToggle = DEFAULT_SETTINGS.APB_widthToggle; + this.plugin.saveSettings(); + this.display(); + }) + ); + if (!this.plugin.settings.APB_widthToggle) { + let timeoutId2; + new import_obsidian.Setting(containerEl).setName("Width").setDesc("Set the width of the progress bar container in pixels (minimum 100). Note: If you want it to span the full width, make sure to enable the toggle above.").addText( + (text) => text.setPlaceholder("200").setValue(this.plugin.settings.APB_width !== void 0 ? String(this.plugin.settings.APB_width) : String(DEFAULT_SETTINGS.APB_width)).onChange((value) => { + clearTimeout(timeoutId2); + timeoutId2 = setTimeout(() => { + var _a; + const parsedValue = parseInt(value, 10); + if (parsedValue >= 100 && (!isNaN(parsedValue) && parsedValue === parseFloat(value))) { + this.plugin.settings.APB_width = parsedValue; + this.plugin.saveSettings(); + this.display(); + } else { + text.setValue(String((_a = this.plugin.settings.APB_width) != null ? _a : DEFAULT_SETTINGS.APB_width)); + this.plugin.saveSettings(); + this.display(); + new import_obsidian.Notice("Please enter a value 100 or above."); + } + }, 1e3); + }).inputEl.classList.add("custom-textbox") + ).addButton( + (button) => button.setIcon("rotate-ccw").setTooltip("Reset to default").onClick(() => { + this.plugin.settings.APB_width = DEFAULT_SETTINGS.APB_width; + this.plugin.saveSettings(); + this.display(); + }) + ); + } + new import_obsidian.Setting(containerEl).setName("Height").setDesc("Set the height of the progress bar in pixels. (See demonstration progress bar above)").addSlider((slider) => { + var _a2; + var _a; + slider.setLimits(1, 15, 1).setDynamicTooltip().setValue((_a2 = this.plugin.settings.APB_height) != null ? _a2 : DEFAULT_SETTINGS.APB_height).onChange((value) => { + this.plugin.settings.APB_height = value; + setEndCaps(progressBarBackground, progressbar, this.plugin.settings.APB_endcapToggle); + this.plugin.settings.APB_progressBarChange = true; + this.plugin.saveSettings(); + this.display(); + }); + }).addButton( + (button) => button.setIcon("rotate-ccw").setTooltip("Reset to default").onClick(() => { + this.plugin.settings.APB_height = DEFAULT_SETTINGS.APB_height; + this.plugin.settings.APB_progressBarChange = true; + this.plugin.saveSettings(); + this.display(); + }) + ); + new import_obsidian.Setting(containerEl).setName("Round end caps").setDesc("When toggled, the progress bar will have either a round or square end cap. (See demonstration progress bar above)").addToggle((toggle) => toggle.setValue(this.plugin.settings.APB_endcapToggle).onChange((value) => { + this.plugin.settings.APB_endcapToggle = value; + setEndCaps(progressBarBackground, progressbar, this.plugin.settings.APB_endcapToggle); + this.plugin.saveSettings(); + })).addButton( + (button) => button.setIcon("rotate-ccw").setTooltip("Reset to default").onClick(() => { + this.plugin.settings.APB_endcapToggle = DEFAULT_SETTINGS.APB_endcapToggle; + this.plugin.saveSettings(); + this.display(); + }) + ); + containerEl.createEl("h4", { text: "Section Marks" }); + new import_obsidian.Setting(containerEl).setName("Section marks").setDesc(createFragment((frag) => { + frag.appendText("When toggled on, the progress bar will have vertical section marks equally spaced along its length. The number and spacing of these will change depending on how many colors your progress bar uses (see "); + frag.createEl("span", { + text: "Number of colors", + cls: "highlight-text" + }); + frag.appendText(" setting below). Note: if the bar reaches 100% or the bar has only one color, no marks will not be displayed. (See demonstration progress bar above)"); + })).addToggle((toggle) => toggle.setValue(this.plugin.settings.APB_marksToggle).onChange((value) => { + this.plugin.settings.APB_marksToggle = value; + this.plugin.saveSettings(); + this.display(); + })).addButton( + (button) => button.setIcon("rotate-ccw").setTooltip("Reset to default").onClick(() => { + this.plugin.settings.APB_marksToggle = DEFAULT_SETTINGS.APB_marksToggle; + this.plugin.saveSettings(); + this.display(); + }) + ); + new import_obsidian.Setting(containerEl).setName("Section Mark color").setDesc(createFragment((frag) => { + frag.appendText("Select the color of the section "); + frag.createEl("span", { + text: "Marks", + cls: "highlight-text" + }); + frag.appendText(". Note: The color will be set to 50% transparency, allowing the progress bar's color to blend and influence the final appearance."); + })).addColorPicker((PBcolorpicker0) => PBcolorpicker0.setValue(this.plugin.settings.APB_marksColor).onChange((value) => { + this.plugin.settings.APB_marksColor = value; + this.plugin.saveSettings(); + this.display(); + })).addButton((button) => button.setIcon("sun").setTooltip("Reset to Light default").onClick(() => { + this.plugin.settings.APB_marksColor = DEFAULT_SETTINGS.APB_marksLightColor; + this.plugin.saveSettings(); + this.display(); + })).addButton( + (button) => button.setIcon("moon").setTooltip("Reset to Dark default").onClick(() => { + this.plugin.settings.APB_marksColor = DEFAULT_SETTINGS.APB_marksColor; + this.plugin.saveSettings(); + this.display(); + }) + ); + if (this.plugin.settings.APB_marksToggle) { + new import_obsidian.Setting(containerEl).setName("Section mark width").setDesc("Set the width of the section mark lines on the progress bar from a range of 1 to 5 pixels. (See demonstration progress bar above)").addSlider((slider) => { + var _a2; + var _a; + slider.setLimits(1, 5, 1).setDynamicTooltip().setValue((_a2 = this.plugin.settings.APB_marksWidth) != null ? _a2 : DEFAULT_SETTINGS.APB_marksWidth).onChange((value) => { + this.plugin.settings.APB_marksWidth = value; + this.plugin.saveSettings(); + this.display(); + }); + }).addButton( + (button) => button.setIcon("rotate-ccw").setTooltip("Reset to default").onClick(() => { + this.plugin.settings.APB_marksWidth = DEFAULT_SETTINGS.APB_marksWidth; + this.plugin.saveSettings(); + this.display(); + }) + ); + } + containerEl.createEl("h4", { text: "Text" }); + new import_obsidian.Setting(containerEl).setName("Show title text").setDesc(createFragment((frag) => { + frag.appendText("When toggled on, the "); + frag.createEl("span", { + text: "Title", + cls: "highlight-text" + }); + frag.appendText(" text will be displayed above the progress bar. (See demonstration progress bar above)"); + })).addToggle((toggle) => toggle.setValue(this.plugin.settings.APB_titleToggle).onChange((value) => { + this.plugin.settings.APB_titleToggle = value; + this.plugin.saveSettings(); + this.display(); + })).addButton( + (button) => button.setIcon("rotate-ccw").setTooltip("Reset to default").onClick(() => { + this.plugin.settings.APB_titleToggle = DEFAULT_SETTINGS.APB_titleToggle; + this.plugin.saveSettings(); + this.display(); + }) + ); + new import_obsidian.Setting(containerEl).setName("Title text color").setDesc(createFragment((frag) => { + frag.appendText("Select the color of the "); + frag.createEl("span", { + text: "Title", + cls: "highlight-text" + }); + frag.appendText(" text."); + })).addColorPicker((PBcolorpicker0) => PBcolorpicker0.setValue(this.plugin.settings.APB_titleColor).onChange((value) => { + this.plugin.settings.APB_titleColor = value; + this.plugin.saveSettings(); + this.display(); + })).addButton((button) => button.setIcon("sun").setTooltip("Reset to Light default").onClick(() => { + this.plugin.settings.APB_titleColor = DEFAULT_SETTINGS.APB_titleLightColor; + this.plugin.saveSettings(); + this.display(); + })).addButton( + (button) => button.setIcon("moon").setTooltip("Reset to Dark default").onClick(() => { + this.plugin.settings.APB_titleColor = DEFAULT_SETTINGS.APB_titleColor; + this.plugin.saveSettings(); + this.display(); + }) + ); + new import_obsidian.Setting(containerEl).setName("Show percentage text").setDesc(createFragment((frag) => { + frag.appendText("When toggled on, the "); + frag.createEl("span", { + text: "Percentage", + cls: "highlight-text" + }); + frag.appendText(" text will be displayed above the progress bar. (See demonstration progress bar above)"); + })).addToggle((toggle) => toggle.setValue(this.plugin.settings.APB_percentageToggle).onChange((value) => { + this.plugin.settings.APB_percentageToggle = value; + this.plugin.saveSettings(); + this.display(); + })).addButton( + (button) => button.setIcon("rotate-ccw").setTooltip("Reset to default").onClick(() => { + this.plugin.settings.APB_percentageToggle = DEFAULT_SETTINGS.APB_percentageToggle; + this.plugin.saveSettings(); + this.display(); + }) + ); + new import_obsidian.Setting(containerEl).setName("Percentage text color").setDesc(createFragment((frag) => { + frag.appendText("Select the color of the "); + frag.createEl("span", { + text: "Percentage", + cls: "highlight-text" + }); + frag.appendText(" text."); + })).addColorPicker((PBcolorpicker0) => PBcolorpicker0.setValue(this.plugin.settings.APB_percentageColor).onChange((value) => { + this.plugin.settings.APB_percentageColor = value; + this.plugin.saveSettings(); + this.display(); + })).addButton((button) => button.setIcon("sun").setTooltip("Reset to Light default").onClick(() => { + this.plugin.settings.APB_percentageColor = DEFAULT_SETTINGS.APB_percentageLightColor; + this.plugin.saveSettings(); + this.display(); + })).addButton( + (button) => button.setIcon("moon").setTooltip("Reset to Dark default").onClick(() => { + this.plugin.settings.APB_percentageColor = DEFAULT_SETTINGS.APB_percentageColor; + this.plugin.saveSettings(); + this.display(); + }) + ); + new import_obsidian.Setting(containerEl).setName("Show fraction text (Value/Total)").setDesc(createFragment((frag) => { + frag.appendText("When toggled on, the fraction text "); + frag.createEl("span", { + text: "(Value/Total)", + cls: "highlight-text" + }); + frag.appendText(" will be displayed above the progress bar. (See demonstration progress bar above)"); + })).addToggle((toggle) => toggle.setValue(this.plugin.settings.APB_fractionToggle).onChange((value) => { + this.plugin.settings.APB_fractionToggle = value; + this.plugin.saveSettings(); + this.display(); + })).addButton( + (button) => button.setIcon("rotate-ccw").setTooltip("Reset to default").onClick(() => { + this.plugin.settings.APB_fractionToggle = DEFAULT_SETTINGS.APB_fractionToggle; + this.plugin.saveSettings(); + this.display(); + }) + ); + new import_obsidian.Setting(containerEl).setName("Fraction text color").setDesc(createFragment((frag) => { + frag.appendText("Select the color of the "); + frag.createEl("span", { + text: "Fraction", + cls: "highlight-text" + }); + frag.appendText(" text."); + })).addColorPicker((PBcolorpicker0) => PBcolorpicker0.setValue(this.plugin.settings.APB_fractionColor).onChange((value) => { + this.plugin.settings.APB_fractionColor = value; + this.plugin.saveSettings(); + this.display(); + })).addButton((button) => button.setIcon("sun").setTooltip("Reset to Light default").onClick(() => { + this.plugin.settings.APB_fractionColor = DEFAULT_SETTINGS.APB_fractionLightColor; + this.plugin.saveSettings(); + this.display(); + })).addButton( + (button) => button.setIcon("moon").setTooltip("Reset to Dark default").onClick(() => { + this.plugin.settings.APB_fractionColor = DEFAULT_SETTINGS.APB_fractionColor; + this.plugin.saveSettings(); + this.display(); + }) + ); + new import_obsidian.Setting(containerEl).setName("Show completed text").setDesc("When toggled on, the word COMPLETED will be displayed on the progress bar when it reaches 100%. (See demonstration progress bar above)").addToggle((toggle) => toggle.setValue(this.plugin.settings.APB_completedToggle).onChange((value) => { + this.plugin.settings.APB_completedToggle = value; + this.plugin.saveSettings(); + this.display(); + })).addButton( + (button) => button.setIcon("rotate-ccw").setTooltip("Reset to default").onClick(() => { + this.plugin.settings.APB_completedToggle = DEFAULT_SETTINGS.APB_completedToggle; + this.plugin.saveSettings(); + this.display(); + }) + ); + new import_obsidian.Setting(containerEl).setName("Completed text color").setDesc(createFragment((frag) => { + frag.appendText("Select the color of the "); + frag.createEl("span", { + text: "Completed", + cls: "highlight-text" + }); + frag.appendText(" text."); + })).addColorPicker((PBcolorpicker0) => PBcolorpicker0.setValue(this.plugin.settings.APB_completedColor).onChange((value) => { + this.plugin.settings.APB_completedColor = value; + this.plugin.saveSettings(); + this.display(); + })).addButton((button) => button.setIcon("sun").setTooltip("Reset to Light default").onClick(() => { + this.plugin.settings.APB_completedColor = DEFAULT_SETTINGS.APB_completedLightColor; + this.plugin.saveSettings(); + this.display(); + })).addButton( + (button) => button.setIcon("moon").setTooltip("Reset to Dark default").onClick(() => { + this.plugin.settings.APB_completedColor = DEFAULT_SETTINGS.APB_completedColor; + this.plugin.saveSettings(); + this.display(); + }) + ); + containerEl.createEl("h4", { text: "Progress Bar Container" }); + new import_obsidian.Setting(containerEl).setName("Border").setDesc("When toggled on, a border will be displayed around the progress bar container.").addToggle((toggle) => toggle.setValue(this.plugin.settings.APB_borderToggle).onChange((value) => { + this.plugin.settings.APB_borderToggle = value; + this.plugin.saveSettings(); + this.display(); + })).addButton( + (button) => button.setIcon("rotate-ccw").setTooltip("Reset to default").onClick(() => { + this.plugin.settings.APB_borderToggle = DEFAULT_SETTINGS.APB_borderToggle; + this.plugin.saveSettings(); + this.display(); + }) + ); + new import_obsidian.Setting(containerEl).setName("Border color").setDesc("Select the color of the border around the progress bar container.").addColorPicker((PBcolorpicker0) => PBcolorpicker0.setValue(this.plugin.settings.APB_colorBorder).onChange((value) => { + this.plugin.settings.APB_colorBorder = value; + this.plugin.saveSettings(); + this.display(); + })).addButton((button) => button.setIcon("sun").setTooltip("Reset to Light default").onClick(() => { + this.plugin.settings.APB_colorBorder = DEFAULT_SETTINGS.APB_colorLightBorder; + this.plugin.saveSettings(); + this.display(); + })).addButton( + (button) => button.setIcon("moon").setTooltip("Reset to Dark default").onClick(() => { + this.plugin.settings.APB_colorBorder = DEFAULT_SETTINGS.APB_colorBorder; + this.plugin.saveSettings(); + this.display(); + }) + ); + new import_obsidian.Setting(containerEl).setName("Background").setDesc("When toggled on, the background of the progress bar container will show.").addToggle((toggle) => toggle.setValue(this.plugin.settings.APB_backgroundToggle).onChange((value) => { + this.plugin.settings.APB_backgroundToggle = value; + this.plugin.saveSettings(); + this.display(); + })).addButton( + (button) => button.setIcon("rotate-ccw").setTooltip("Reset to default").onClick(() => { + this.plugin.settings.APB_backgroundToggle = DEFAULT_SETTINGS.APB_backgroundToggle; + this.plugin.saveSettings(); + this.display(); + }) + ); + new import_obsidian.Setting(containerEl).setName("Background color").setDesc("Select the background color of the progress bar container.").addColorPicker((PBcolorpicker0) => PBcolorpicker0.setValue(this.plugin.settings.APB_colorBackground).onChange((value) => { + this.plugin.settings.APB_colorBackground = value; + this.plugin.saveSettings(); + this.display(); + })).addButton((button) => button.setIcon("sun").setTooltip("Reset to Light default").onClick(() => { + this.plugin.settings.APB_colorBackground = DEFAULT_SETTINGS.APB_colorLightBackground; + this.plugin.saveSettings(); + this.display(); + })).addButton( + (button) => button.setIcon("moon").setTooltip("Reset to Dark default").onClick(() => { + this.plugin.settings.APB_colorBackground = DEFAULT_SETTINGS.APB_colorBackground; + this.plugin.saveSettings(); + this.display(); + }) + ); + containerEl.createEl("h4", { text: "Progress Bar Color" }); + new import_obsidian.Setting(this.containerEl).setName("Number of colors").setDesc("Select how many different colors you want the progress bar to use. Each color will be used for the entire bar depending on its percentage completed. (See demonstration progress bar above)").addDropdown((dropdown) => { + dropdown.addOptions({ + option1: "1 color", + option2: "2 colors", + option3: "3 colors", + option4: "4 colors", + option5: "5 colors" + }).setValue(this.plugin.settings.APB_colornumber).onChange((value) => { + this.plugin.settings.APB_colornumber = value; + this.plugin.settings.APB_progressBarChange = true; + this.plugin.saveSettings(); + this.display(); + }); + }).addButton( + (button) => button.setIcon("rotate-ccw").setTooltip("Reset to default").onClick(() => { + this.plugin.settings.APB_colornumber = DEFAULT_SETTINGS.APB_colornumber; + this.plugin.settings.APB_progressBarChange = true; + this.plugin.saveSettings(); + this.display(); + }) + ); + new import_obsidian.Setting(containerEl).setName("1st color").setDesc("This color will be used for the entire progrees bar if the percentage is within the first section.").addColorPicker( + (PBcolorpicker1) => PBcolorpicker1.setValue(this.plugin.settings.APB_color1).onChange((value) => { + this.plugin.settings.APB_color1 = value; + this.plugin.saveSettings(); + this.display(); + }) + ).addButton((button) => button.setIcon("sun").setTooltip("Reset to Light default").onClick(() => { + this.plugin.settings.APB_color1 = DEFAULT_SETTINGS.APB_color1Light; + this.plugin.saveSettings(); + this.display(); + })).addButton( + (button) => button.setIcon("moon").setTooltip("Reset to Dark default").onClick(() => { + this.plugin.settings.APB_color1 = DEFAULT_SETTINGS.APB_color1; + this.plugin.saveSettings(); + this.display(); + }) + ); + if (this.plugin.settings.APB_colornumber !== "option1") { + new import_obsidian.Setting(containerEl).setName("2nd color").setDesc("This color will be used for the entire progrees bar if the percentage is within the second section.").addColorPicker((PBcolorpicker2) => PBcolorpicker2.setValue(this.plugin.settings.APB_color2).onChange((value) => { + this.plugin.settings.APB_color2 = value; + this.plugin.saveSettings(); + this.display(); + })).addButton((button) => button.setIcon("sun").setTooltip("Reset to Light default").onClick(() => { + this.plugin.settings.APB_color2 = DEFAULT_SETTINGS.APB_color2Light; + this.plugin.saveSettings(); + this.display(); + })).addButton( + (button) => button.setIcon("moon").setTooltip("Reset to Dark default").onClick(() => { + this.plugin.settings.APB_color2 = DEFAULT_SETTINGS.APB_color2; + this.plugin.saveSettings(); + this.display(); + }) + ); + if (this.plugin.settings.APB_colornumber !== "option2") { + new import_obsidian.Setting(containerEl).setName("3rd color").setDesc("This color will be used for the entire progrees bar if the percentage is within the third section.").addColorPicker((PBcolorpicker3) => PBcolorpicker3.setValue(this.plugin.settings.APB_color3).onChange((value) => { + this.plugin.settings.APB_color3 = value; + this.plugin.saveSettings(); + this.display(); + })).addButton((button) => button.setIcon("sun").setTooltip("Reset to Light default").onClick(() => { + this.plugin.settings.APB_color3 = DEFAULT_SETTINGS.APB_color3Light; + this.plugin.saveSettings(); + this.display(); + })).addButton( + (button) => button.setIcon("moon").setTooltip("Reset to Dark default").onClick(() => { + this.plugin.settings.APB_color3 = DEFAULT_SETTINGS.APB_color3; + this.plugin.saveSettings(); + this.display(); + }) + ); + if (this.plugin.settings.APB_colornumber !== "option3") { + new import_obsidian.Setting(containerEl).setName("4th color").setDesc("This color will be used for the entire progrees bar if the percentage is within the fourth section.").addColorPicker((PBcolorpicker4) => PBcolorpicker4.setValue(this.plugin.settings.APB_color4).onChange((value) => { + this.plugin.settings.APB_color4 = value; + this.plugin.saveSettings(); + this.display(); + })).addButton((button) => button.setIcon("sun").setTooltip("Reset to Light default").onClick(() => { + this.plugin.settings.APB_color4 = DEFAULT_SETTINGS.APB_color4Light; + this.plugin.saveSettings(); + this.display(); + })).addButton( + (button) => button.setIcon("moon").setTooltip("Reset to Dark default").onClick(() => { + this.plugin.settings.APB_color4 = DEFAULT_SETTINGS.APB_color4; + this.plugin.saveSettings(); + this.display(); + }) + ); + if (this.plugin.settings.APB_colornumber !== "option4") { + new import_obsidian.Setting(containerEl).setName("5th color").setDesc("This color will be used for the entire progrees bar if the percentage is within the fifth section.").addColorPicker((PBcolorpicker5) => PBcolorpicker5.setValue(this.plugin.settings.APB_color5).onChange((value) => { + this.plugin.settings.APB_color5 = value; + this.plugin.saveSettings(); + this.display(); + })).addButton((button) => button.setIcon("sun").setTooltip("Reset to Light default").onClick(() => { + this.plugin.settings.APB_color5 = DEFAULT_SETTINGS.APB_color5Light; + this.plugin.saveSettings(); + this.display(); + })).addButton( + (button) => button.setIcon("moon").setTooltip("Reset to Dark default").onClick(() => { + this.plugin.settings.APB_color5 = DEFAULT_SETTINGS.APB_color5; + this.plugin.saveSettings(); + this.display(); + }) + ); + } + } + } + } + new import_obsidian.Setting(containerEl).setName("Completed color").setDesc("Select the color the entire progress bar will use when it reaches 100% completion.").addColorPicker((PBcolorpicker0) => PBcolorpicker0.setValue(this.plugin.settings.APB_colorBarCompleted).onChange((value) => { + this.plugin.settings.APB_colorBarCompleted = value; + this.plugin.saveSettings(); + this.display(); + })).addButton((button) => button.setIcon("sun").setTooltip("Reset to Light default").onClick(() => { + this.plugin.settings.APB_colorBarCompleted = DEFAULT_SETTINGS.APB_colorLightBarCompleted; + this.plugin.saveSettings(); + this.display(); + })).addButton( + (button) => button.setIcon("moon").setTooltip("Reset to Dark default").onClick(() => { + this.plugin.settings.APB_colorBarCompleted = DEFAULT_SETTINGS.APB_colorBarCompleted; + this.plugin.saveSettings(); + this.display(); + }) + ); + new import_obsidian.Setting(containerEl).setName("Bar background color").setDesc("This color will be used for the progress bar's background, representing the remaining percentage.").addColorPicker((PBcolorpicker0) => PBcolorpicker0.setValue(this.plugin.settings.APB_colorBarBackground).onChange((value) => { + this.plugin.settings.APB_colorBarBackground = value; + this.plugin.saveSettings(); + this.display(); + })).addButton((button) => button.setIcon("sun").setTooltip("Reset to Light default").onClick(() => { + this.plugin.settings.APB_colorBarBackground = DEFAULT_SETTINGS.APB_colorLightBarBackground; + this.plugin.saveSettings(); + this.display(); + })).addButton( + (button) => button.setIcon("moon").setTooltip("Reset to Dark default").onClick(() => { + this.plugin.settings.APB_colorBarBackground = DEFAULT_SETTINGS.APB_colorBarBackground; + this.plugin.saveSettings(); + this.display(); + }) + ); + } +}; +function setEndCaps(progressBarBackground, progressbar, endCap) { + if (progressBarBackground && progressbar) { + if (endCap) { + progressBarBackground.style.borderRadius = "7px"; + progressbar.style.borderRadius = "7px"; + } else { + progressBarBackground.style.borderRadius = "0px"; + progressbar.style.borderRadius = "0px"; + } + } else { + console.error("Elements are not defined"); + } +} +function hexToRgba(hex, alpha = 1) { + hex = hex.replace("#", ""); + if (hex.length === 3) { + hex = hex.split("").map((char) => char + char).join(""); + } + const r = parseInt(hex.slice(0, 2), 16); + const g = parseInt(hex.slice(2, 4), 16); + const b = parseInt(hex.slice(4, 6), 16); + return `rgba(${r}, ${g}, ${b}, ${alpha})`; +} +//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["main.ts"],
  "sourcesContent": ["import { App, Plugin, PluginSettingTab, Setting,  Notice  } from 'obsidian';\n\n// Populate settings with values\ninterface ObsidianProgressBarsSettings {\n\t/* Progress Bar Settings */\n\tAPB_title: string;\n\tAPB_widthToggle: boolean;\n\tAPB_width: number;\t\n\tAPB_height: number;\n\tAPB_progressBarPercentage: number;\n\tAPB_total: number;\n\tAPB_endcapToggle: boolean;\n\tAPB_marksToggle: boolean;\n\tAPB_marksColor: string;\n\tAPB_marksLightColor: string;\n\tAPB_marksWidth: number;\n\t/* Text Settings */\n\tAPB_titleToggle: boolean;\n\tAPB_titleColor: string;\n\tAPB_titleLightColor: string;\n\tAPB_percentageToggle: boolean;\n\tAPB_percentageColor: string;\n\tAPB_percentageLightColor: string;\n\tAPB_fractionToggle: boolean;\n\tAPB_fractionColor: string;\n\tAPB_fractionLightColor: string;\n\tAPB_completedToggle: boolean;\n\tAPB_completedColor: string;\n\tAPB_completedLightColor: string;\n\t/* Container Settings */\n\tAPB_borderToggle: boolean;\n\tAPB_colorBorder: string;\n\tAPB_colorLightBorder: string;\n\tAPB_backgroundToggle: boolean;\n\tAPB_colorBackground: string;\n\tAPB_colorLightBackground: string;\n\t/* Progress Bar Color Settings */\n\tAPB_colornumber: string;\n\tAPB_color1: string;\n\tAPB_color2: string;\n\tAPB_color3: string;\n\tAPB_color4: string;\n\tAPB_color5: string;\n\tAPB_color1Light: string;\n\tAPB_color2Light: string;\n\tAPB_color3Light: string;\n\tAPB_color4Light: string;\n\tAPB_color5Light: string;\n\tAPB_colorBarCompleted: string;\n\tAPB_colorLightBarCompleted: string;\n\tAPB_colorBarBackground: string;\n\tAPB_colorLightBarBackground: string;\n\t/* Additional Settings */\n\tAPB_progressBarChange: boolean;\n}\n\nconst DEFAULT_SETTINGS: Partial<ObsidianProgressBarsSettings> = {\n\t/* Progress Bar Settings */\n\tAPB_title: 'Progress',\n\tAPB_widthToggle: true,\n\tAPB_width: 190,\t\n\tAPB_height: 8,\n\tAPB_progressBarPercentage: 83,\n\tAPB_total: 100,\n\tAPB_endcapToggle: true,\n\tAPB_marksToggle: true,\n\tAPB_marksColor: '#000000',\n\tAPB_marksLightColor: '#ffffff',\n\tAPB_marksWidth: 3,\n\t/* Text Settings */\n\tAPB_titleToggle: true,\n\tAPB_titleColor: '#8fa0ba',\n\tAPB_titleLightColor: '#44546f',\n\tAPB_percentageToggle: true,\n\tAPB_percentageColor: '#c1d7f9',\n\tAPB_percentageLightColor: '#6d85ad',\n\tAPB_fractionToggle: true,\n\tAPB_fractionColor: '#8fa0ba',\n\tAPB_fractionLightColor: '#576a8a',\n\tAPB_completedToggle: true,\n\tAPB_completedColor: '#c1d7f9',\n\tAPB_completedLightColor: '#44546f',\n\t/* Container Settings */\n\tAPB_borderToggle: true,\n\tAPB_colorBorder: '#474f62',\n\tAPB_colorLightBorder: '#ced0d6',\n\tAPB_backgroundToggle: true,\n\tAPB_colorBackground: '#242a35',\n\tAPB_colorLightBackground: '#f1f2f4',\n\t/* Progress Bar Color Settings */\n\tAPB_colornumber: 'option5',\n\tAPB_color1: '#2978ef',\n\tAPB_color2: '#8ec822',\n\tAPB_color3: '#dfaa22',\n\tAPB_color4: '#c84922',\n\tAPB_color5: '#dd4a86',\n\tAPB_color1Light: '#278378',\n\tAPB_color2Light: '#2baab9',\n\tAPB_color3Light: '#4a32e2',\n\tAPB_color4Light: '#7c328e',\n\tAPB_color5Light: '#c11e49',\n\tAPB_colorBarCompleted: '#576178',\n\tAPB_colorLightBarCompleted: '#fcfcfd',\n\tAPB_colorBarBackground: '#3b4252',\n\tAPB_colorLightBarBackground: '#d9dde2',\n\t/* Additional Settings */\n\tAPB_progressBarChange: true,\n}\n// Loading and saving of settings\nexport default class ObsidianProgressBars extends Plugin {\n\tsettings: ObsidianProgressBarsSettings;\n  \n\tcopyButtonListener: (event: MouseEvent) => void;\n\n\tasync onload() {\n\t\tconsole.log('loading APB plugin')\n\t\tawait this.loadSettings();\n\t\n\t\tthis.addSettingTab(new ObsidianProgressBarsSettingTab(this.app, this));\n\t\n\t\t\n\t\tthis.app.workspace.onLayoutReady(this.initializeProgressBars.bind(this));\n\t}\n  \n\tinitializeProgressBars() {\n\t\tthis.registerMarkdownCodeBlockProcessor('obsidian-apb', (source, el, ctx) => {\n\n\t\t\t// Split the source string into rows\n\t\t\tconst rows = source.trim().split('\\n');\n\t\t\tel.empty(); // Clear the default rendering\n\n\t\t\t// Loop through each line and do something with it\n\t\t\trows.forEach((row, index) => {\n\t\t\t\tconsole.log('Processing line '+ (index + 1), row); \n\n\t\t\t\t// Use regex to extract the label and progress (Value/Total)\n\t\t\t\tconst match = row.match(/^(.+):\\s*(\\d+)\\/(\\d+)$/);\t\t\n\n\t\t\t\tif (!match) {\n\t\t\t\t\tconsole.error('Invalid format for advanced progress bar block:', row);\n\n\t\t\t\t\tconst APB_errorContainer = document.createElement('div');\n\t\t\t\t\tAPB_errorContainer.addClass('error-container');\n\t\t\t\t\t\n\t\t\t\t\tconst APB_errorMessage = document.createElement('div');\n\t\t\t\t\tAPB_errorMessage.addClass('error-text-container');\t\t\t\t\n\t\t\t\t\tAPB_errorMessage.createEl('span', { text: 'APB_ Error: Invalid block format' });\n\n\t\t\t\t\tAPB_errorContainer.appendChild(APB_errorMessage);\n\t\t\t\t\tel.appendChild(APB_errorContainer);\n\t\t\n\t\t\t\t\treturn;\n\t\t\t\t}\n\n\t\t\t\t// Extract label, current value, and total value from the match\n\t\t\t\tconst label = match[1];\n\t\t\t\tconst current = parseInt(match[2], 10);\n\t\t\t\tconst total = parseInt(match[3], 10);\n\n\t\t\t\t// Check if current value is too large or total is zero\n\t\t\t\tif (current > total && total !== 0) {\n\t\t\t\t\tconsole.error('Invalid value for advanced progress bar block:', row);\n\n\t\t\t\t\tconst APB_errorContainer = document.createElement('div');\n\t\t\t\t\tAPB_errorContainer.addClass('error-container');\n\n\t\t\t\t\tconst APB_errorMessage = document.createElement('div');\n\t\t\t\t\tAPB_errorMessage.addClass('error-text-container');\n\t\t\t\t\tAPB_errorMessage.createEl('span', { text: 'APB_ Error: Value is too large' });\n\n\t\t\t\t\tAPB_errorContainer.appendChild(APB_errorMessage);\n\t\t\t\t\tel.appendChild(APB_errorContainer);\n\n\t\t\t\t\treturn;\n\t\t\t\t}\n\t  \n\t\t\t\t// Check if parsing was successful and that total is not zero\n\t\t\t\tif (isNaN(current) || isNaN(total) || total === 0) {\n\t\t\t\t\tconsole.error('Invalid advanced progress bar values:', row);\t\n\n\t\t\t\t\tconst APB_errorContainer = document.createElement('div');\n\t\t\t\t\tAPB_errorContainer.addClass('error-container');\n\n\t\t\t\t\tconst APB_errorMessage = document.createElement('div');\n\t\t\t\t\tAPB_errorMessage.addClass('error-text-container');\n\t\t\t\t\tAPB_errorMessage.createEl('span', { text: 'APB_ Error: Invalid number' });\n\n\t\t\t\t\tAPB_errorContainer.appendChild(APB_errorMessage);\n\t\t\t\t\tel.appendChild(APB_errorContainer);\n\n\t\t\t\t\treturn;\n\t\t\t\t}\n\t  \n\t\t\t\t// Calculate the width percentage of the progress bar\n\t\t\t\tconst percentage = (current / total) * 100;\n\t\t\n\t\t\t\t// Ensure the width percentage is between 0 and 100\n\t\t\t\tconst clampedPercentage = Math.min(Math.max(Math.round(percentage), 0), 100);\n\t\t\n\t\t\t\tconst APB_container = document.createElement('div');\n\t\t\t\tAPB_container.addClass('progressBar-container');\n\n\t\t\t\tif (this.settings.APB_borderToggle) {\n\t\t\t\t\tAPB_container.style.border = '1px solid ${this.settings.APB_colorBorder}';\n\t\t\t\t} else {\n\t\t\t\t\tAPB_container.style.border = '0px';\n\t\t\t\t}\n\n\t\t\t\tif (this.settings.APB_backgroundToggle) {\n\t\t\t\t\tAPB_container.style.background = this.settings.APB_colorBackground;\n\t\t\t\t} else {\n\t\t\t\t\tAPB_container.style.background = 'transparent';\n\t\t\t\t}\n\n\t\t\t\t// APB_Text Container\n\t\t\t\tconst APB_textContainer = document.createElement('div');\n\t\t\t\tAPB_textContainer.addClass('progressBar-text-container');\n\n\t\t\t\t// APB_ BarBackground container\n\t\t\t\tconst APB_backgroundToggle = document.createElement('div');\n\t\t\t\tAPB_backgroundToggle.addClass('progressBar-background');\n\t\t\t\tAPB_backgroundToggle.style.background = this.settings.APB_colorBarBackground;\n\n\t\t\t\t// APB_Title\n\t\t\t\tconst APB_title = document.createElement('div');\n\t\t\t\tAPB_title.addClass('progressBar-title');\n\t\t\t\tif (this.settings.APB_titleToggle) {\n\t\t\t\t\tAPB_title.createEl('span', { text: label });\n\t\t\t\t\tAPB_title.style.color = this.settings.APB_titleColor;\n\t\t\t\t}\n\n\t\t\t\t// APB_Percentage\n\t\t\t\tconst APB_percentage = document.createElement('div');\n\t\t\t\tAPB_percentage.addClass('progressBar-percentage');\n\t\t\t\tif (this.settings.APB_percentageToggle) {\n\t\t\t\t\tAPB_percentage.createEl('span', { text: clampedPercentage+'%' });\n\t\t\t\t\tAPB_percentage.style.color = this.settings.APB_percentageColor;\n\t\t\t\t}\n\n\t\t\t\t// APB_Value\n\t\t\t\tconst APB_value = document.createElement('div');\n\t\t\t\tAPB_value.addClass('progressBar-value');\n\t\t\t\tif (this.settings.APB_fractionToggle) {\n\t\t\t\t\tAPB_value.createEl('span', { text: '('+current+'/'+total+')' });\n\t\t\t\t\tAPB_value.style.color = this.settings.APB_fractionColor;\n\t\t\t\t}\n\n\t\t\t\t// APB_Completed\n\t\t\t\tconst APB_completed = document.createElement('div');\n\t\t\t\tAPB_completed.addClass('progressBar-completed');\n\t\t\t\tif (this.settings.APB_completedToggle) {\n\t\t\t\t\tAPB_completed.createEl('span', { text: '' });\n\t\t\t\t\tAPB_completed.style.color = this.settings.APB_percentageColor;\n\t\t\t\t}\n\n\t\t\t\t// progressBar\n\t\t\t\tconst APB = document.createElement('div');\n\t\t\t\tAPB.addClass('progressBar');\n\n\t\t\t\tconst progressBarwidth: number = this.settings.APB_width;\n\t\t\t\tlet numericWidth = parseInt(progressBarwidth.toString(), 10);\n\n\t\t\t\tif (this.settings.APB_widthToggle) {\t\t\t\n\t\t\t\t\tAPB_container.style.width = '100%';\n\t\t\t\t\tAPB_backgroundToggle.style.width = '100%';\n\t\t\t\t\tAPB.style.width = `${clampedPercentage}%`;\n\t\t\t\t} else {\n\t\t\t\t\tAPB_backgroundToggle.style.width = `${progressBarwidth}px`;\n\t\t\t\t\tAPB_container.style.width = `${numericWidth + 10}px`;\n\t\t\t\t\tAPB.style.width = `${numericWidth / 100 * clampedPercentage}px`;\n\t\t\t\t}\n\t\t\t\t\t\t\t\t\n\t\t\t\tAPB.style.height = `${this.settings.APB_height}px`;\n\t\t\n\t\t\t\tsetEndCaps(APB_backgroundToggle, APB, this.settings.APB_endcapToggle);\n\t\t\t\tAPB_backgroundToggle.appendChild(APB);\n\t\t\n\t\t\t\tconst marks = document.createElement('div');\n\t\t\t\tmarks.addClass('marks');\t\t\t\n\t\t\n\t\t\t\tconst numberOfSections = parseInt(this.settings.APB_colornumber.replace(/\\D/g, ''));\n\n\t\t\t\t// create required number of section marks if NOT completed\n\t\t\t\tif (clampedPercentage !== 100) {\n\t\t\t\t\tAPB_backgroundToggle.appendChild(marks);\n\n\t\t\t\t\tif (this.settings.APB_marksToggle) {\t\t\t\n\t\t\t\t\t\tfor (let i = 1; i <= (numberOfSections - 1); i++) {\t\t\t\n\t\t\t\t\t\t\tconst mark = document.createElement('div');\n\t\t\t\t\t\t\tmark.addClass('mark');\n\t\t\t\t\t\t\tmark.style.left = `${(i * (100/numberOfSections))}%`;\n\t\t\t\t\t\t\tmarks.appendChild(mark);\t\t\t\t\t\t\t\t\t\t\t\n\t\t\t\t\t\t\n\t\t\t\t\t\t\tconst dpr = window.devicePixelRatio || 1; // Get the device pixel ratio\n\t\t\t\t\t\t\tconst adjustedBorderWidth = this.settings.APB_marksWidth / dpr; // use DPI to create correct pixel width \n\n\t\t\t\t\t\t\t\n\n\t\t\t\t\t\t\tconst rgbaColor = hexToRgba(this.settings.APB_marksColor, 0.5);\n\t\t\t\t\t\t\tmark.style.borderLeft = adjustedBorderWidth + 'px solid ' + rgbaColor;\t\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t\tAPB.appendChild(APB_completed);\n\n\t\t\t\t// loop to set correct progress bar color\n\t\t\t\tfor (let i = 1; i <= numberOfSections; i++) {\n\t\t\t\t\tlet sectionsize = `${(i * (100/numberOfSections))}%`;\n\t\t\t\t\t\n\t\t\t\t\tconst markLeftValue = parseFloat(sectionsize);\n\t\t\t\t\t\n\t\t\t\t\tif ((clampedPercentage <= markLeftValue) && this.settings.APB_progressBarChange) {\n\t\t\t\t\t\tAPB.style.backgroundColor = String(this.settings[`APB_color${i}` as keyof ObsidianProgressBarsSettings]);\n\t\n\t\t\t\t\t\tif (clampedPercentage == 100) {\n\t\t\t\t\t\t\tAPB.style.backgroundColor = this.settings.APB_colorBarCompleted;\n\t\t\t\t\t\t\tif (this.settings.APB_completedToggle) {\n\t\t\t\t\t\t\t\tAPB_completed.textContent ='COMPLETED';\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t\tthis.settings.APB_progressBarChange = false;\n\t\t\t\t\t\tthis.saveSettings();\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t\tthis.settings.APB_progressBarChange = true;\n\n\t\t\t\tAPB_container.appendChild(APB_textContainer);\n\t\t\t\t\tif (this.settings.APB_titleToggle) {\n\t\t\t\t\t\tAPB_textContainer.appendChild(APB_title);\n\t\t\t\t\t}\n\t\t\t\t\tif (this.settings.APB_percentageToggle) {\n\t\t\t\t\t\tAPB_textContainer.appendChild(APB_percentage);\n\t\t\t\t\t}\n\t\t\t\t\tif (this.settings.APB_fractionToggle) {\n\t\t\t\t\t\tAPB_textContainer.appendChild(APB_value);\n\t\t\t\t\t}\n\n\t\t\t\tAPB_container.appendChild(APB_backgroundToggle);\n\n\t\t\t\tel.appendChild(APB_container);\n\t\t  });\n\t\t});\n\n\t\t// Register a custom command to paste text\n        this.addCommand({\n            id: 'paste-code-block',\n            name: 'Paste Code Block',\n\n\t\t\teditorCallback: async (editor, view) => {\n\t\t\t\teditor.focus();\n\t\t\t\t// Ensure editor is valid\n\t\t\t\tif (!editor) {\n\t\t\t\t  new Notice(\"No active editor found!\");\n\t\t\t\t  return;\n\t\t\t\t}\n\t\t\t\t\n\t\t\t\t// Construct the code block text\n\t\t\t\tconst valueFromPercentageOfTotal = Math.floor((this.settings.APB_total/100) * this.settings.APB_progressBarPercentage);\n\t\t\t\tconst codeBlockText = `\\`\\`\\`obsidian-apb\\n${this.settings.APB_title}: ${valueFromPercentageOfTotal}/${this.settings.APB_total}\\n\\`\\`\\``;\n\t\t\n\t\t\t\t// Get the current cursor position\n\t\t\t\tconst cursor = editor.getCursor();\n\t\t\n\t\t\t\t// Insert the code block text at the cursor position\n\t\t\t\teditor.replaceRange(codeBlockText, cursor);\n\t\t\n\t\t\t\t// Calculate the new cursor position\n\t\t\t\tconst lines = codeBlockText.split('\\n');\n\t\t\t\tconst newCursor = {\n\t\t\t\t\tline: cursor.line + lines.length - 1,\n\t\t\t\t\tch: lines[lines.length - 1].length // Length of the last line\n\t\t\t\t};\n\n\t\t\t\t// Ensure the cursor moves after the insertion\n\t\t\t\tsetTimeout(() => {\n\t\t\t\t\teditor.setCursor(newCursor);\n\t\t\t\t\teditor.refresh();\n\t\t\t\t}, 0); // Zero-delay timeout ensures this runs after DOM updates\n\t\t\t},\n\t\t\t});\n\t\t}\n\n\tasync loadSettings() {\n\t  \tthis.settings = Object.assign({}, DEFAULT_SETTINGS, await this.loadData());\n\t}\n\n\tasync saveSettings() {\n\t  \tawait this.saveData(this.settings);\n\t}\n\n\tasync onunload(): Promise<void> {\n\t\t// Check this method is being triggered\n\t\tconsole.log('Cleaning up resources when plugin unloads...');\n\n\t\t// Check if the button still exists in the DOM\n\t\tconst copyButton = document.querySelector('button');\n\t\tif (copyButton) {\n\t\t\tconsole.log('Found the copyButton in the DOM.');\n\n\t\t\t// Remove the event listener to clean up resources\n\t\t\tcopyButton.removeEventListener('click', this.copyButtonListener);\n\t\t\tconsole.log('Event listener removed.');\n\t\t} else {\n\t\t\tconsole.log('No copyButton found in the DOM.');\n\t\t}\n\t}\n\n}\n\n// Create Settings Tab Content\nclass ObsidianProgressBarsSettingTab extends PluginSettingTab {\n\tplugin: ObsidianProgressBars;\n\n\t// Explicitly define the type of the event listener\n    private copyButtonListener: (event: MouseEvent) => void;\n\n\tconstructor(app: App, plugin: ObsidianProgressBars) {\n\t\tsuper(app, plugin);\n\t\tthis.plugin = plugin;\n\t}\n\n\tasync display(): Promise<void> {\n\t\tconst { containerEl } = this\n\t\tcontainerEl.empty();\n\n\t\tcontainerEl.createEl('h3', { text: 'Advanced Progress Bars' });\n\n\t\tconst paragraph = containerEl.createEl('p', { text: 'If you find value in this plugin and would like to support us, please consider using our ' });\n\n\t\tparagraph.createEl('a', {\n\t\t\thref: 'https://ko-fi.com/cactuzhead',\n\t\t\ttext: 'ko-fi',\n\t\t\tcls: 'custom-link'\n\t\t});\n\n\t\tconst container = containerEl.createEl('div');\n\t\tcontainer.addClass('custom-container');\n\t\tcontainer.appendChild(paragraph);\n\n\t\t// Create Ko-Fi link\n\t\tconst koFiLink = container.createEl('a');\n\t\tkoFiLink.href = 'https://ko-fi.com/cactuzhead';\n\t\tkoFiLink.target = '_blank';\n\n\t\t// Ko-Fi logo\n\t\tconst koFiImage = koFiLink.createEl('img');\n\t\tkoFiImage.setAttribute('src', 'https://storage.ko-fi.com/cdn/fullLogoKofi.png');\n\t\tkoFiImage.setAttribute('alt', 'Support us on Ko-fi');\n\n\t\t// Style the image link\n\t\tkoFiImage.style.width = '100px';\n\t\tkoFiImage.style.height = 'auto';\n\t\tkoFiLink.style.display = 'inline-block';\n\t\tkoFiLink.style.marginLeft = '10px';\n\n\t\t/************ Usage Example Code Block *************/\n\t\tnew Setting(containerEl)\n\t\t\t.setName('Usage Example Code Block')\n\t\t\t.setDesc(createFragment((frag) => {\n\t\t\tfrag.appendText('Use this code block and edit the ');\n\n\t\t\tconst customElement = frag.createEl('span');\n\t\t\tcustomElement.setText('Title: Value/Total');\n\t\t\tcustomElement.classList.add('highlight-text');\n\n\t\t\tfrag.appendText(' as needed.');\n\t\t\tfrag.createEl('br');\n\t\t\tfrag.appendText('If you require more than one bar, simply create additional ');\n\n\t\t\tconst customElement2 = frag.createEl('span');\n\t\t\tcustomElement2.setText('Title: Value/Total');\n\t\t\tcustomElement2.classList.add('highlight-text');\n\n\t\t\tfrag.appendText(' lines within the code block.');\n\t\t\tfrag.createEl('br');\n\t\t\tfrag.appendText('Note: ');\n\n\t\t\tconst customElement3 = frag.createEl('span');\n\t\t\tcustomElement3.setText('Total');\n\t\t\tcustomElement3.classList.add('highlight-text');\n\n\t\t\tfrag.appendText(' does not need to be 100.');\n\t\t\tfrag.createEl('br');\n\t\t\tfrag.appendText('Visit ');\n\n\t\t\tfrag.createEl('a', {\n\t\t\t\thref: 'https://cactuzhead.github.io/Advanced-Progress-Bars/',\n\t\t\t\ttext: 'cactuzhead',\n\t\t\t\tcls: 'custom-link'\n\t\t\t});\n\n\t\t\tfrag.appendText(' for more detailed information.');\n\t\t}))\n\n    .addTextArea((textArea) => {\n\t\tconst valueFromPercentageOfTotal = Math.floor((this.plugin.settings.APB_total/100) * this.plugin.settings.APB_progressBarPercentage);\n\t\ttextArea.setValue(`\\`\\`\\`obsidian-apb\\n${this.plugin.settings.APB_title}: ${valueFromPercentageOfTotal}/${this.plugin.settings.APB_total}\\n\\`\\`\\``);\n\n        textArea.inputEl.style.height = '80px';\n        textArea.inputEl.style.width = '200px';\n        textArea.inputEl.style.resize = 'none';\n\n\t\tconst container = textArea.inputEl.parentElement;\n\t\t// check container exists before appending the button\n\t\tif (container) {\n\t\t\t// Example for adding the copy button and text area to the settings\n\t\t\tconst copyButton = containerEl.createEl('button', { text: 'Copy to Clipboard' });\n\n\t\t\t// Store the click event listener in a class property\n\t\t\tthis.copyButtonListener = (event: MouseEvent) => {\n\t\t\t\tnavigator.clipboard.writeText(textArea.inputEl.value)\n\t\t\t\t\t.then(() => {\n\t\t\t\t\t\tnew Notice('Content copied to clipboard!');\n\t\t\t\t\t})\n\t\t\t\t\t.catch((err) => {\n\t\t\t\t\t\tnew Notice('Failed to copy content: ' + err);\n\t\t\t\t\t});\n\t\t\t};\n\n\t\t\t// Add the event listener to the button\n\t\t\tcopyButton.addEventListener('click', this.copyButtonListener);\n\n\t\t\tcopyButton.style.marginTop = '10px';\n\t\t\tcopyButton.style.display = 'block';\n\t\t\tcontainer.style.display = 'flex';\n        \tcontainer.style.flexDirection = 'column';\n\t} else {\n\t\t\tconsole.error('Unable to find the parent container for the textarea');\n\t\t}\n\t});\n\n\t/************ SECTION Light & Dark Settings *************/\n\t containerEl.createEl('h4', { text: 'Light & Dark' });\n\n\t/************ Light & Dark Quick Apply *************/\n\tnew Setting(containerEl)\n\t\t.setName('Apply all Light & Dark color defaults')\n\t\t.setDesc(createFragment((frag) => {\n            frag.appendText('These two options ');\n            frag.createEl('span', {\n                text: '(Light & Dark)',\n\t\t\t\tcls: 'highlight-text'\n            });\n            frag.appendText(' will change ALL the color settings below to their respective defaults. (All other settings will remain unchanged).');\n\t\t\tfrag.createEl('br');\n\t\t\tfrag.appendText(' Note: once selected, all previous colors will be lost forever and can not be retrieved.');\n\n\t\t}))\n\t\t\t.addButton((button) =>\n\t\t\tbutton.setIcon('sun').setTooltip('Reset to Light default')\t\n\t\t\t.onClick(() => {\t\t\t\t\n\t\t\t\tthis.plugin.settings.APB_marksColor = DEFAULT_SETTINGS.APB_marksLightColor as string;\n\t\t\t\tthis.plugin.settings.APB_titleColor = DEFAULT_SETTINGS.APB_titleLightColor as string;\n\t\t\t\tthis.plugin.settings.APB_percentageColor = DEFAULT_SETTINGS.APB_percentageLightColor as string;\n\t\t\t\tthis.plugin.settings.APB_fractionColor = DEFAULT_SETTINGS.APB_fractionLightColor as string;\n\t\t\t\tthis.plugin.settings.APB_colorBorder = DEFAULT_SETTINGS.APB_colorLightBorder as string;\n\t\t\t\tthis.plugin.settings.APB_colorBackground = DEFAULT_SETTINGS.APB_colorLightBackground as string;\n\t\t\t\tthis.plugin.settings.APB_colorBarCompleted = DEFAULT_SETTINGS.APB_colorLightBarCompleted as string;\n\t\t\t\tthis.plugin.settings.APB_colorBarBackground = DEFAULT_SETTINGS.APB_colorLightBarBackground as string;\n\t\t\t\tthis.plugin.settings.APB_completedColor = DEFAULT_SETTINGS.APB_completedLightColor as string;\n\n\t\t\t\tthis.plugin.settings.APB_color1 = DEFAULT_SETTINGS.APB_color1Light as string;\n\t\t\t\tthis.plugin.settings.APB_color2 = DEFAULT_SETTINGS.APB_color2Light as string;\n\t\t\t\tthis.plugin.settings.APB_color3 = DEFAULT_SETTINGS.APB_color3Light as string;\n\t\t\t\tthis.plugin.settings.APB_color4 = DEFAULT_SETTINGS.APB_color4Light as string;\n\t\t\t\tthis.plugin.settings.APB_color5 = DEFAULT_SETTINGS.APB_color5Light as string;\n\n\t\t\t\tthis.plugin.saveSettings();\n\t\t\t\tthis.display();\n\t\t\t}))\n\t\t.addButton((button) =>\n\t\t\tbutton.setIcon('moon').setTooltip('Reset to Dark default')\n\t\t\t.onClick(() => {\n\t\t\t\tthis.plugin.settings.APB_marksColor = DEFAULT_SETTINGS.APB_marksColor as string;\n\t\t\t\tthis.plugin.settings.APB_colorBorder = DEFAULT_SETTINGS.APB_colorBorder as string;\n\t\t\t\tthis.plugin.settings.APB_titleColor = DEFAULT_SETTINGS.APB_titleColor as string;\n\t\t\t\tthis.plugin.settings.APB_percentageColor = DEFAULT_SETTINGS.APB_percentageColor as string;\n\t\t\t\tthis.plugin.settings.APB_fractionColor = DEFAULT_SETTINGS.APB_fractionColor as string;\n\t\t\t\tthis.plugin.settings.APB_colorBorder = DEFAULT_SETTINGS.APB_colorBorder as string;\n\t\t\t\tthis.plugin.settings.APB_colorBackground = DEFAULT_SETTINGS.APB_colorBackground as string;\n\t\t\t\tthis.plugin.settings.APB_colorBarCompleted = DEFAULT_SETTINGS.APB_colorBarCompleted as string;\n\t\t\t\tthis.plugin.settings.APB_colorBarBackground = DEFAULT_SETTINGS.APB_colorBarBackground as string;\n\t\t\t\tthis.plugin.settings.APB_completedColor = DEFAULT_SETTINGS.APB_completedColor as string;\n\n\t\t\t\tthis.plugin.settings.APB_color1 = DEFAULT_SETTINGS.APB_color1 as string;\n\t\t\t\tthis.plugin.settings.APB_color2 = DEFAULT_SETTINGS.APB_color2 as string;\n\t\t\t\tthis.plugin.settings.APB_color3 = DEFAULT_SETTINGS.APB_color3 as string;\n\t\t\t\tthis.plugin.settings.APB_color4 = DEFAULT_SETTINGS.APB_color4 as string;\n\t\t\t\tthis.plugin.settings.APB_color5 = DEFAULT_SETTINGS.APB_color5 as string;\n\n\t\t\t\tthis.plugin.saveSettings();\n\t\t\t\tthis.display();\n\t\t\t})\n\t\t);\n\n\t/************ SECTION progress Progress Bar *************/\n\tcontainerEl.createEl('h4', { text: 'Demonstration Progress Bar' });\n\n\tnew Setting(containerEl)\n\t\t.setDesc('Any changes you make to this settings page will be instantly reflected in the demonstration progress bar below.  Use it as a guide when making your decisions.')\n\n\t\t/************ Demo Progress Bar *************/\n\t\tconst progressBarContainer = containerEl.createEl('div');\n\t\tprogressBarContainer.addClass('progressBar-container');\n\n\t\tif (this.plugin.settings.APB_borderToggle) {\n\t\t\tprogressBarContainer.style.border = '1px solid'+ this.plugin.settings.APB_colorBorder;\n\t\t} else {\n\t\t\tprogressBarContainer.style.border = '0px';\n\t\t}\n\n\t\tif (this.plugin.settings.APB_backgroundToggle) {\n\t\t\tprogressBarContainer.style.background = this.plugin.settings.APB_colorBackground;\n\t\t} else {\n\t\t\tprogressBarContainer.style.background = 'transparent';\n\t\t}\n\n\t\t// DemoBar Text Container\n\t\tconst progressBarTextContainer = containerEl.createEl('div');\n\t\tprogressBarTextContainer.addClass('progressBar-text-container');\n\n\t\t// DemoBar BarBackground container\n\t\tconst progressBarBackground = containerEl.createEl('div');\n\t\tprogressBarBackground.addClass('progressBar-background');\n\t\tprogressBarBackground.style.background = this.plugin.settings.APB_colorBarBackground;\n\n\t\t// DemoBar Title\n\t\tconst progressBarTitle = containerEl.createEl('div');\n\t\tprogressBarTitle.addClass('progressBar-title');\n\t\tif (this.plugin.settings.APB_titleToggle) {\n\t\t\tprogressBarTitle.createEl('span', { text: this.plugin.settings.APB_title });\n\t\t\tprogressBarTitle.style.color = this.plugin.settings.APB_titleColor;\n\t\t}\n\n\t\t// DemoBar Percentage\n\t\tconst progressBarPercentage = containerEl.createEl('div');\n\t\tprogressBarPercentage.addClass('progressBar-percentage');\n\t\tif (this.plugin.settings.APB_percentageToggle) {\n\t\t\tprogressBarPercentage.createEl('span', { text: this.plugin.settings.APB_progressBarPercentage+'%' });\n\t\t\tprogressBarPercentage.style.color = this.plugin.settings.APB_percentageColor;\n\t\t}\n\n\t\t// DemoBar Value\n\t\tconst progressBarValue = containerEl.createEl('div');\n\t\tprogressBarValue.addClass('progressBar-value');\n\t\tconst valueFromPercentageOfTotal = Math.floor((this.plugin.settings.APB_total/100) * this.plugin.settings.APB_progressBarPercentage);\n\t\tif (this.plugin.settings.APB_fractionToggle) {\n\t\t\tprogressBarValue.createEl('span', { text: '('+valueFromPercentageOfTotal+'/'+this.plugin.settings.APB_total+')' });\n\t\t\tprogressBarValue.style.color = this.plugin.settings.APB_fractionColor;\n\t\t}\n\n\t\t// DemoBar Completed\n\t\tconst completed = containerEl.createEl('div');\n\t\tcompleted.addClass('progressBar-completed');\n\t\tif (this.plugin.settings.APB_completedToggle) {\n\t\t\tcompleted.style.color = this.plugin.settings.APB_completedColor;\n\n\t\t\tif (this.plugin.settings.APB_progressBarPercentage == 100) {\n\t\t\t\tcompleted.textContent = 'COMPLETED';\n\t\t\t}\n\t\t}\n\n\t\t// DemoBar\n\t\tconst progressbar = containerEl.createEl('div');\n\t\tprogressbar.addClass('progressBar');\n\n\t\tconst progressBarwidth: number = this.plugin.settings.APB_width;\n\t\tlet numericWidth = parseInt(progressBarwidth.toString(), 10);\n\n\t\t// Ensure the width percentage is between 0 and 100\n\t\tconst clampedPercentage = Math.min(Math.max(Math.round(this.plugin.settings.APB_progressBarPercentage), 0), 100);\n\n\t\tif (this.plugin.settings.APB_widthToggle) {\n\t\t\tprogressBarContainer.style.width = '100%';\n\t\t\tprogressBarBackground.style.width = '100%';\n\t\t\tprogressbar.style.width = `${clampedPercentage}%`;\n\t\t} else {\n\t\t\tprogressBarContainer.style.width = `${numericWidth}px`;\n\t\t\tprogressBarBackground.style.width = `${String(numericWidth - 12)}px`; // -12 for 5px padding and for 1px border\n\t\t\tprogressbar.style.width = `${((numericWidth - 12) / 100 * clampedPercentage)}px`; // -12 for 5px padding and for 1px border\n\t\t}\n\n\t\tprogressBarContainer.style.margin = '17px';\n\n\t\tprogressbar.style.height = `${this.plugin.settings.APB_height}px`;\n\n\t\tsetEndCaps(progressBarBackground, progressbar, this.plugin.settings.APB_endcapToggle);\n\t\tprogressBarBackground.appendChild(progressbar);\n\n\t\tprogressbar.appendChild(completed);\n\n\t\tconst marks = containerEl.createEl('div');\n\t\tmarks.addClass('marks');\n\n\t\tconst numberOfSections = parseInt(this.plugin.settings.APB_colornumber.replace(/\\D/g, ''));\n\n\t\t// create required number of section marks if NOT completed\n\t\tif (this.plugin.settings.APB_progressBarPercentage !== 100) {\n\t\t\tprogressBarBackground.appendChild(marks);\n\n\t\t\tif (this.plugin.settings.APB_marksToggle) {\n\t\t\t\tfor (let i = 1; i <= (numberOfSections - 1); i++) {\n\t\t\t\t\tconst mark = containerEl.createEl('div');\n\t\t\t\t\tmark.addClass('mark');\n\t\t\t\t\tmark.style.left = `${(i * (100/numberOfSections))}%`;\n\t\t\t\t\tmarks.appendChild(mark);\n\n\t\t\t\t\tconst dpr = window.devicePixelRatio || 1; // Get the device pixel ratio\n\t\t\t\t\tconst adjustedBorderWidth = this.plugin.settings.APB_marksWidth / dpr; // use DPI to create correct pixel width\n\n\t\t\t\t\tconst rgbaColor = hexToRgba(this.plugin.settings.APB_marksColor, 0.5);\n\t\t\t\t\tmark.style.borderLeft = adjustedBorderWidth + 'px solid ' + rgbaColor;\t\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\t// loop to set correct progress bar color\n\t\tfor (let i = 1; i <= numberOfSections; i++) {\n\t\t\tlet sectionsize = `${(i * (100/numberOfSections))}%`;\n\n\t\t\tconst progressBarPercentage = parseFloat(this.plugin.settings.APB_progressBarPercentage.toString());\n\t\t\tconst markLeftValue = parseFloat(sectionsize);\n\n\t\t\tif ((progressBarPercentage <= markLeftValue) && this.plugin.settings.APB_progressBarChange) {\n\t\t\t\tprogressbar.style.backgroundColor = String(this.plugin.settings[`APB_color${i}` as keyof ObsidianProgressBarsSettings]);\n\t\t\t\tif (progressBarPercentage == 100) {\n\t\t\t\t\tprogressbar.style.backgroundColor = this.plugin.settings.APB_colorBarCompleted;\n\t\t\t\t}\n\t\t\t\tthis.plugin.settings.APB_progressBarChange = false;\n\t\t\t\tthis.plugin.saveSettings();\n\t\t\t}\n\t\t}\n\n\t\tthis.plugin.settings.APB_progressBarChange = true;\n\t\tthis.plugin.saveSettings();\n\n\t\tconst progresstext = containerEl.createEl('p', { text: 'This is a Demo Progress Bar.' });\n\n\t\t// Demo Container\n\t\tconst containerprogress = containerEl.createEl('div');\n\t\tcontainerprogress.addClass('custom-container');\n\t\tcontainerprogress.appendChild(progresstext);\n\n\t\tprogressBarContainer.appendChild(progressBarTextContainer);\n\t\t\tif (this.plugin.settings.APB_titleToggle) {\n\t\t\t\tprogressBarTextContainer.appendChild(progressBarTitle);\n\t\t\t}\n\t\t\tif (this.plugin.settings.APB_percentageToggle) {\n\t\t\t\tprogressBarTextContainer.appendChild(progressBarPercentage);\n\t\t\t}\n\t\t\tif (this.plugin.settings.APB_fractionToggle) {\n\t\t\t\tprogressBarTextContainer.appendChild(progressBarValue);\n\t\t\t}\n\n\t\tcontainerprogress.appendChild(progressBarContainer);\n\n\t\tprogressBarContainer.appendChild(progressBarBackground);\n\n\n\t/************ SECTION Progress Bar Appearance *************/\n\tcontainerEl.createEl('h4', { text: 'Progress Bar' });\n\n\t/************ Default Title *************/\n\tnew Setting(containerEl)\n\t\t.setName('Default title')\n\t\t.setDesc(createFragment((frag) => {\n            frag.appendText('Set the default title of a new progress bar. If you change this, the ');\n            frag.createEl('span', {\n                text: 'Title',\n\t\t\t\tcls: 'highlight-text'\n            });\n            frag.appendText(' will be automatically changed in the example code block at the top of the settings for easy copy and pasting later on.');\n        }))\n\t\t.addText(text => {\n\t\t\tlet debounceTimeout: ReturnType<typeof setTimeout>;\t\t\t\t\t\t\t\n\t\t\ttext\n\t\t\t.setPlaceholder('Enter your title')\n\t\t\t.setValue(this.plugin.settings.APB_title || '')\n\t\t\t.onChange((value) => {\n\t\t\t\tclearTimeout(debounceTimeout);\n\n\t\t\t\tdebounceTimeout = setTimeout(() => {\t\t\n\t\t\t\t\tthis.plugin.settings.APB_title = value;\n\t\t\t\t\tthis.plugin.settings.APB_progressBarChange = true;\n\t\t\t\t\tthis.plugin.saveSettings();\n\t\t\t\t\tthis.display();\n\t\t\t\t}, 2000);\n\t\t\t})\n\t\t})\n\t\t.addButton((button) =>\n\t\t\tbutton.setIcon('rotate-ccw').setTooltip('Reset to default')\n\t\t\t.onClick(() => {\n\t\t\t\tthis.plugin.settings.APB_title = DEFAULT_SETTINGS.APB_title as string;\n\t\t\t\tthis.plugin.settings.APB_progressBarChange = true;\n\t\t\t\tthis.plugin.saveSettings();\n\t\t\t\tthis.display();\n\t\t\t})\n\t\t);\n\n\t/************ Default Total *************/\n\tlet timeoutId: ReturnType<typeof setTimeout>;\n\tnew Setting(containerEl)\n\t.setName('Default total')\n\t.setDesc(createFragment((frag) => {\n\t\tfrag.appendText('Set the default ');\n\t\tfrag.createEl('span', {\n\t\t\ttext: 'Total',\n\t\t\tcls: 'highlight-text'\n\t\t});\n\t\tfrag.appendText(' of a new progress bar. If you change this, the ');\n\t\tfrag.createEl('span', {\n\t\t\ttext: 'Total',\n\t\t\tcls: 'highlight-text'\n\t\t});\n\t\tfrag.appendText(' will be automatically changed in the example code block above for easy copy and pasting later on.');\n\t}))\n\t.addText(text => text\n\t\t.setPlaceholder('100')\n\t\t.setValue (this.plugin.settings.APB_total !== undefined ? String(this.plugin.settings.APB_total) : String(DEFAULT_SETTINGS.APB_total))\n\t\t.onChange((value) => {\n\t\t\tclearTimeout(timeoutId);\n\t\t\ttimeoutId = setTimeout(() => {\n\t\t\t\tconst parsedValue = parseInt(value, 10);\n\n\t\t\t\tif (parsedValue >= 1 && (!isNaN(parsedValue) && parsedValue === parseFloat(value))) {\n\t\t\t\t\tthis.plugin.settings.APB_total = parsedValue;\n\t\t\t\t\tthis.plugin.saveSettings();\n\t\t\t\t\tthis.display();\n\t\t\t\t} else {\t\t\t\t\t\t\n\t\t\t\t\ttext.setValue(String(this.plugin.settings.APB_total ?? DEFAULT_SETTINGS.APB_total));\n\n\t\t\t\t\tthis.plugin.saveSettings();\n\t\t\t\t\tthis.display();\n\t\t\t\t\tnew Notice('Please enter a value 1 or above.');\n\t\t\t\t}\n\t\t\t}, 1000);\n\t\t})\n\t\t.inputEl.classList.add('custom-textbox')\n\t)\n\t.addButton((button) =>\n\t\tbutton.setIcon('rotate-ccw').setTooltip('Reset to default')\n\t\t.onClick(() => {\n\t\t\tthis.plugin.settings.APB_total = DEFAULT_SETTINGS.APB_total as number;\n\t\t\tthis.plugin.settings.APB_progressBarChange = true;\n\t\t\tthis.plugin.saveSettings();\n\t\t\tthis.display();\n\t\t})\n\t);\n\n\t/************ Progress Percentage *************/\n\tnew Setting(containerEl)\n\t\t.setName('Progress percentage')\n\t\t.setDesc(createFragment((frag) => {\n            frag.appendText('Set the percentage for the demonstration progress bar above. This will also update the ');\n            frag.createEl('span', {\n                text: 'Value',\n\t\t\t\tcls: 'highlight-text'\n            });\n            frag.appendText(' parameter in the Example Code at the top of the settings. Once you are satisfied with all other settings, you will likely want to set this back to 0.');\n        }))\n\t\t.addSlider((slider) => {\n\t\t\tvar _a;\n\t\t\tslider\n\t\t\t.setLimits(0, 100, 1)\n\t\t\t.setDynamicTooltip()\t\t\t\t\n\t\t\t.setValue(this.plugin.settings.APB_progressBarPercentage ?? DEFAULT_SETTINGS.APB_progressBarPercentage)\n\t\t\t.onChange((value) =>  {\n\t\t\t\tthis.plugin.settings.APB_progressBarPercentage = value;\n\t\t\t\tthis.plugin.settings.APB_progressBarChange = true;\n\t\t\t\tthis.plugin.saveSettings();\n\t\t\t\tthis.display();\t\t\t\t\t\t\t\n\t\t\t})\n\t\t})\t\t\t\n\t\t.addButton((button) =>\n\t\t\tbutton.setIcon('rotate-ccw').setTooltip('Reset to default')\n\t\t\t.onClick(() => {\t\t\t\t\t\n\t\t\t\tthis.plugin.settings.APB_progressBarPercentage = DEFAULT_SETTINGS.APB_progressBarPercentage as number;\n\t\t\t\tthis.plugin.settings.APB_progressBarChange = true;\n\t\t\t\tthis.plugin.saveSettings();\n\t\t\t\tthis.display();\n\t\t\t})\n\t\t);\n\n\t/************ Full Width *************/\n\tnew Setting(containerEl)\n\t\t.setName('Full width')\n\t\t.setDesc(createFragment((frag) => {\n            frag.appendText('Toggle this on to set the progress bar to fill the entire width of its container. For a fixed width, toggle this off and use the ');\n            frag.createEl('span', {\n                text: 'Width',\n\t\t\t\tcls: 'highlight-text'\n            });\n            frag.appendText(' option that will appear below.');\n        }))\n\t\t.addToggle((toggle) =>\n\t\t\ttoggle.setValue(this.plugin.settings.APB_widthToggle)\n\t\t\t.onChange((value) => {\n\t\t\t\tthis.plugin.settings.APB_widthToggle = value;\n\t\t\t\tthis.plugin.saveSettings();\n\t\t\t\tthis.display();\n\t\t\t}))\n\t\t.addButton((button) =>\n\t\t\tbutton.setIcon('rotate-ccw').setTooltip('Reset to default')\n\t\t\t.onClick(() => {\n\t\t\t\tthis.plugin.settings.APB_widthToggle = DEFAULT_SETTINGS.APB_widthToggle as boolean;\n\t\t\t\tthis.plugin.saveSettings();\n\t\t\t\tthis.display();\n\t\t\t})\n\t\t);\n\n\tif (!this.plugin.settings.APB_widthToggle) {\n\t\t/************ Width *************/\n\t\tlet timeoutId: ReturnType<typeof setTimeout>;\n\t\tnew Setting(containerEl)\n\t\t\t.setName('Width')\n\t\t\t.setDesc('Set the width of the progress bar container in pixels (minimum 100). Note: If you want it to span the full width, make sure to enable the toggle above.')\n\t\t\t.addText(text => text\n\t\t\t\t.setPlaceholder('200')\n\t\t\t\t.setValue (this.plugin.settings.APB_width !== undefined ? String(this.plugin.settings.APB_width) : String(DEFAULT_SETTINGS.APB_width))\n\t\t\t\t.onChange((value) => {\n\t\t\t\t\tclearTimeout(timeoutId);\n\t\t\t\t\ttimeoutId = setTimeout(() => {\n\t\t\t\t\t\tconst parsedValue = parseInt(value, 10);\n\n\t\t\t\t\t\tif (parsedValue >= 100 && (!isNaN(parsedValue) && parsedValue === parseFloat(value))) {\n\t\t\t\t\t\t\tthis.plugin.settings.APB_width = parsedValue;\n\t\t\t\t\t\t\tthis.plugin.saveSettings();\n\t\t\t\t\t\t\tthis.display();\n\t\t\t\t\t\t} else {\t\t\t\t\t\t\n\t\t\t\t\t\t\ttext.setValue(String(this.plugin.settings.APB_width ?? DEFAULT_SETTINGS.APB_width));\n\n\t\t\t\t\t\t\tthis.plugin.saveSettings();\n\t\t\t\t\t\t\tthis.display();\n\t\t\t\t\t\t\tnew Notice('Please enter a value 100 or above.');\n\t\t\t\t\t\t}\n\t\t\t\t\t}, 1000);\n\t\t\t\t})\n\t\t\t\t.inputEl.classList.add('custom-textbox')\n\t\t\t)\n\t\t\t.addButton((button) =>\n\t\t\t\tbutton.setIcon('rotate-ccw').setTooltip('Reset to default')\n\t\t\t\t.onClick(() => {\n\t\t\t\t\tthis.plugin.settings.APB_width = DEFAULT_SETTINGS.APB_width as number;\n\t\t\t\t\tthis.plugin.saveSettings();\n\t\t\t\t\tthis.display();\n\t\t\t\t})\n\t\t\t);\n\t}\n\n\t/************ Height *************/\n\tnew Setting(containerEl)\n\t\t.setName('Height')\n\t\t.setDesc('Set the height of the progress bar in pixels.  (See demonstration progress bar above)')\n\t\t.addSlider((slider) => {\n\t\t\tvar _a;\n\t\t\tslider\n\t\t\t\t.setLimits(1, 15, 1)\n\t\t\t\t.setDynamicTooltip()\t\t\t\t\n\t\t\t\t.setValue(this.plugin.settings.APB_height ?? DEFAULT_SETTINGS.APB_height)\n\t\t\t\t.onChange((value) =>  {\n\t\t\t\t\tthis.plugin.settings.APB_height = value;\n\t\t\t\t\tsetEndCaps(progressBarBackground, progressbar, this.plugin.settings.APB_endcapToggle); \n\t\t\t\t\tthis.plugin.settings.APB_progressBarChange = true;\n\t\t\t\t\tthis.plugin.saveSettings();\n\t\t\t\t\tthis.display();\t\t\t\t\n\t\t\t\t})\n\t\t\t})\n\t\t\t.addButton((button) =>\n\t\t\t\tbutton.setIcon('rotate-ccw').setTooltip('Reset to default')\n\t\t\t\t.onClick(() => {\n\t\t\t\t\tthis.plugin.settings.APB_height = DEFAULT_SETTINGS.APB_height as number;\n\t\t\t\t\tthis.plugin.settings.APB_progressBarChange = true;\n\t\t\t\t\tthis.plugin.saveSettings();\n\t\t\t\t\tthis.display();\t\t\t\t\t\n\t\t\t\t})\n\t\t\t);\n\t\t\t\n\t/************ End Caps *************/\n\tnew Setting(containerEl)\n\t\t.setName('Round end caps')\n\t\t.setDesc('When toggled, the progress bar will have either a round or square end cap.  (See demonstration progress bar above)')\n\t\t.addToggle((toggle) =>\n\t\t\t\ttoggle.setValue(this.plugin.settings.APB_endcapToggle)\n\t\t\t\t.onChange((value) => {\n\t\t\t\t\tthis.plugin.settings.APB_endcapToggle = value;\n\t\t\t\t\tsetEndCaps(progressBarBackground, progressbar, this.plugin.settings.APB_endcapToggle); \n\t\t\t\t\tthis.plugin.saveSettings();\n\t\t\t\t}))\n\t\t.addButton((button) =>\n\t\t\tbutton.setIcon('rotate-ccw').setTooltip('Reset to default')\n\t\t\t.onClick(() => {\n\t\t\t\tthis.plugin.settings.APB_endcapToggle = DEFAULT_SETTINGS.APB_endcapToggle as boolean;\n\t\t\t\tthis.plugin.saveSettings();\n\t\t\t\tthis.display();\n\t\t\t})\n\t\t);\n\n\t/************ SECTION Marks Settings *************/\n\tcontainerEl.createEl('h4', { text: 'Section Marks' });\n\n\t/************ Bar Section Marks *************/\n\tnew Setting(containerEl)\n\t\t.setName('Section marks')\n\t\t.setDesc(createFragment((frag) => {\n            frag.appendText('When toggled on, the progress bar will have vertical section marks equally spaced along its length.  The number and spacing of these will change depending on how many colors your progress bar uses (see ');\n            frag.createEl('span', {\n                text: 'Number of colors',\n\t\t\t\tcls: 'highlight-text'\n            });\n            frag.appendText(' setting below). Note: if the bar reaches 100% or the bar has only one color, no marks will not be displayed.  (See demonstration progress bar above)');\n        }))\n\t\t.addToggle((toggle) =>\n\t\t\t\ttoggle.setValue(this.plugin.settings.APB_marksToggle)\n\t\t\t\t.onChange((value) => {\n\t\t\t\t\tthis.plugin.settings.APB_marksToggle = value;\n\t\t\t\t\tthis.plugin.saveSettings();\n\t\t\t\t\tthis.display();\n\t\t\t\t}))\n\t\t.addButton((button) =>\n\t\t\tbutton.setIcon('rotate-ccw').setTooltip('Reset to default')\n\t\t\t.onClick(() => {\t\t\t\t\n\t\t\t\tthis.plugin.settings.APB_marksToggle = DEFAULT_SETTINGS.APB_marksToggle as boolean;\n\t\t\t\tthis.plugin.saveSettings();\n\t\t\t\tthis.display();\n\t\t\t})\n\t\t);\n\n\t/************ Section Mark Color *************/\n\tnew Setting(containerEl)\n\t.setName('Section Mark color')\n\t.setDesc(createFragment((frag) => {\n\t\tfrag.appendText('Select the color of the section ');\n\t\tfrag.createEl('span', {\n\t\t\ttext: 'Marks',\n\t\t\tcls: 'highlight-text'\n\t\t});\n\t\tfrag.appendText('. Note: The color will be set to 50% transparency, allowing the progress bar\\'s color to blend and influence the final appearance.');\n\t}))\n\t.addColorPicker((PBcolorpicker0) =>\tPBcolorpicker0\n\t\t.setValue(this.plugin.settings.APB_marksColor).onChange((value) => {\n\t\t\tthis.plugin.settings.APB_marksColor = value;\n\t\t\tthis.plugin.saveSettings();\n\t\t\tthis.display();\n\t\t}))\n\t\t.addButton((button) =>\n\t\t\tbutton.setIcon('sun').setTooltip('Reset to Light default')\n\t\t\t.onClick(() => {\n\t\t\t\tthis.plugin.settings.APB_marksColor = DEFAULT_SETTINGS.APB_marksLightColor as string;\n\t\t\t\tthis.plugin.saveSettings();\n\t\t\t\tthis.display();\n\t\t\t}))\n\t\t.addButton((button) =>\n\t\t\tbutton.setIcon('moon').setTooltip('Reset to Dark default')\n\t\t\t.onClick(() => {\n\t\t\t\tthis.plugin.settings.APB_marksColor = DEFAULT_SETTINGS.APB_marksColor as string;\n\t\t\t\tthis.plugin.saveSettings();\n\t\t\t\tthis.display();\n\t\t\t})\n\t\t);\n\n\t/************ Bar Section Mark Width *************/\n\tif (this.plugin.settings.APB_marksToggle) {\n\t\tnew Setting(containerEl)\n\t\t.setName('Section mark width')\n\t\t.setDesc('Set the width of the section mark lines on the progress bar from a range of 1 to 5 pixels.  (See demonstration progress bar above)')\n\t\t.addSlider((slider) => {\n\t\t\tvar _a;\n\t\t\tslider\n\t\t\t\t.setLimits(1, 5, 1)\n\t\t\t\t.setDynamicTooltip()\t\t\t\t\n\t\t\t\t.setValue(this.plugin.settings.APB_marksWidth ?? DEFAULT_SETTINGS.APB_marksWidth)\n\t\t\t\t.onChange((value) =>  {\n\t\t\t\t\tthis.plugin.settings.APB_marksWidth = value;\n\t\t\t\t\tthis.plugin.saveSettings();\n\t\t\t\t\tthis.display();\t\t\t\t\t\t\t\n\t\t\t\t})\n\t\t\t})\t\t\t\n\t\t\t.addButton((button) =>\n\t\t\t\tbutton.setIcon('rotate-ccw').setTooltip('Reset to default')\n\t\t\t\t.onClick(() => {\t\t\t\t\t\n\t\t\t\t\tthis.plugin.settings.APB_marksWidth = DEFAULT_SETTINGS.APB_marksWidth as number;\n\t\t\t\t\tthis.plugin.saveSettings();\n\t\t\t\t\tthis.display();\n\t\t\t\t})\n\t\t\t);\n\t\t}\n\n\t/************ SECTION Text Settings *************/\n\tcontainerEl.createEl('h4', { text: 'Text' });\n\n\t/************ Show Title *************/\n\tnew Setting(containerEl)\n\t\t.setName('Show title text')\n\t\t.setDesc(createFragment((frag) => {\n            frag.appendText('When toggled on, the ');\n            frag.createEl('span', {\n                text: 'Title',\n\t\t\t\tcls: 'highlight-text'\n            });\n            frag.appendText(' text will be displayed above the progress bar.  (See demonstration progress bar above)');\n        }))\n\t\t.addToggle((toggle) =>\n\t\t\t\ttoggle.setValue(this.plugin.settings.APB_titleToggle)\n\t\t\t\t.onChange((value) => {\n\t\t\t\t\tthis.plugin.settings.APB_titleToggle = value;\n\t\t\t\t\tthis.plugin.saveSettings();\n\t\t\t\t\tthis.display();\n\t\t\t\t}))\n\t\t.addButton((button) =>\n\t\t\tbutton.setIcon('rotate-ccw').setTooltip('Reset to default')\n\t\t\t.onClick(() => {\n\t\t\t\tthis.plugin.settings.APB_titleToggle = DEFAULT_SETTINGS.APB_titleToggle as boolean;\n\t\t\t\tthis.plugin.saveSettings();\n\t\t\t\tthis.display();\n\t\t\t})\n\t\t);\n\n\t/************ Title Color *************/\n\tnew Setting(containerEl)\n\t\t.setName('Title text color')\n\t\t.setDesc(createFragment((frag) => {\n            frag.appendText('Select the color of the ');\n            frag.createEl('span', {\n                text: 'Title',\n\t\t\t\tcls: 'highlight-text'\n            });\n            frag.appendText(' text.');\n        }))\n\t\t.addColorPicker((PBcolorpicker0) =>\tPBcolorpicker0\n\t\t\t.setValue(this.plugin.settings.APB_titleColor).onChange((value) => {\n\t\t\t\tthis.plugin.settings.APB_titleColor = value;\n\t\t\t\tthis.plugin.saveSettings();\n\t\t\t\tthis.display();\n\t\t\t}))\n\t\t\t.addButton((button) =>\n\t\t\t\tbutton.setIcon('sun').setTooltip('Reset to Light default')\n\t\t\t\t.onClick(() => {\n\t\t\t\t\tthis.plugin.settings.APB_titleColor = DEFAULT_SETTINGS.APB_titleLightColor as string;\n\t\t\t\t\tthis.plugin.saveSettings();\n\t\t\t\t\tthis.display();\n\t\t\t\t}))\n\t\t\t.addButton((button) =>\n\t\t\t\tbutton.setIcon('moon').setTooltip('Reset to Dark default')\n\t\t\t\t.onClick(() => {\n\t\t\t\t\tthis.plugin.settings.APB_titleColor = DEFAULT_SETTINGS.APB_titleColor as string;\n\t\t\t\t\tthis.plugin.saveSettings();\n\t\t\t\t\tthis.display();\n\t\t\t\t})\n\t\t\t);\n\n\t/************ Show Percentage *************/\n\tnew Setting(containerEl)\n\t\t.setName('Show percentage text')\n\t\t.setDesc(createFragment((frag) => {\n            frag.appendText('When toggled on, the ');\n            frag.createEl('span', {\n                text: 'Percentage',\n\t\t\t\tcls: 'highlight-text'\n            });\n            frag.appendText(' text will be displayed above the progress bar.  (See demonstration progress bar above)');\n        }))\n\t\t.addToggle((toggle) =>\n\t\t\t\ttoggle.setValue(this.plugin.settings.APB_percentageToggle)\n\t\t\t\t.onChange((value) => {\n\t\t\t\t\tthis.plugin.settings.APB_percentageToggle = value;\n\t\t\t\t\tthis.plugin.saveSettings();\n\t\t\t\t\tthis.display();\n\t\t\t\t}))\n\t\t.addButton((button) =>\n\t\t\tbutton.setIcon('rotate-ccw').setTooltip('Reset to default')\n\t\t\t.onClick(() => {\n\t\t\t\tthis.plugin.settings.APB_percentageToggle = DEFAULT_SETTINGS.APB_percentageToggle as boolean;\n\t\t\t\tthis.plugin.saveSettings();\n\t\t\t\tthis.display();\n\t\t\t})\n\t\t);\n\n\t/************ Percentage Color *************/\n\tnew Setting(containerEl)\n\t\t.setName('Percentage text color')\n\t\t.setDesc(createFragment((frag) => {\n            frag.appendText('Select the color of the ');\n            frag.createEl('span', {\n                text: 'Percentage',\n\t\t\t\tcls: 'highlight-text'\n            });\n            frag.appendText(' text.');\n        }))\n\t\t.addColorPicker((PBcolorpicker0) =>\tPBcolorpicker0\n\t\t\t.setValue(this.plugin.settings.APB_percentageColor).onChange((value) => {\n\t\t\t\tthis.plugin.settings.APB_percentageColor = value;\n\t\t\t\tthis.plugin.saveSettings();\n\t\t\t\tthis.display();\n\t\t\t}))\n\t\t.addButton((button) =>\n\t\t\tbutton.setIcon('sun').setTooltip('Reset to Light default')\n\t\t\t.onClick(() => {\n\t\t\t\tthis.plugin.settings.APB_percentageColor = DEFAULT_SETTINGS.APB_percentageLightColor as string;\n\t\t\t\tthis.plugin.saveSettings();\n\t\t\t\tthis.display();\n\t\t\t}))\n\t\t.addButton((button) =>\n\t\t\tbutton.setIcon('moon').setTooltip('Reset to Dark default')\n\t\t\t.onClick(() => {\n\t\t\t\tthis.plugin.settings.APB_percentageColor = DEFAULT_SETTINGS.APB_percentageColor as string;\n\t\t\t\tthis.plugin.saveSettings();\n\t\t\t\tthis.display();\n\t\t\t})\n\t\t);\n\n\t/************ Show Fraction *************/\n\tnew Setting(containerEl)\n\t\t.setName('Show fraction text (Value/Total)')\n\t\t.setDesc(createFragment((frag) => {\n            frag.appendText('When toggled on, the fraction text ');\n            frag.createEl('span', {\n                text: '(Value/Total)',\n\t\t\t\tcls: 'highlight-text'\n            });\n            frag.appendText(' will be displayed above the progress bar.  (See demonstration progress bar above)');\n        }))\n\t\t.addToggle((toggle) =>\n\t\t\t\ttoggle.setValue(this.plugin.settings.APB_fractionToggle)\n\t\t\t\t.onChange((value) => {\n\t\t\t\t\tthis.plugin.settings.APB_fractionToggle = value;\n\t\t\t\t\tthis.plugin.saveSettings();\n\t\t\t\t\tthis.display();\n\t\t\t\t}))\n\t\t.addButton((button) =>\n\t\t\tbutton.setIcon('rotate-ccw').setTooltip('Reset to default')\n\t\t\t.onClick(() => {\n\t\t\t\tthis.plugin.settings.APB_fractionToggle = DEFAULT_SETTINGS.APB_fractionToggle as boolean;\n\t\t\t\tthis.plugin.saveSettings();\n\t\t\t\tthis.display();\n\t\t\t})\n\t\t);\n\n\t/************ Fraction Color *************/\n\tnew Setting(containerEl)\n\t\t.setName('Fraction text color')\n\t\t.setDesc(createFragment((frag) => {\n            frag.appendText('Select the color of the ');\n            frag.createEl('span', {\n                text: 'Fraction',\n\t\t\t\tcls: 'highlight-text'\n            });\n            frag.appendText(' text.');\n        }))\n\t\t.addColorPicker((PBcolorpicker0) =>\tPBcolorpicker0\n\t\t\t.setValue(this.plugin.settings.APB_fractionColor).onChange((value) => {\n\t\t\t\tthis.plugin.settings.APB_fractionColor = value;\n\t\t\t\tthis.plugin.saveSettings();\n\t\t\t\tthis.display();\n\t\t\t}))\n\t\t\t.addButton((button) =>\n\t\t\t\tbutton.setIcon('sun').setTooltip('Reset to Light default')\n\t\t\t\t.onClick(() => {\n\t\t\t\t\tthis.plugin.settings.APB_fractionColor = DEFAULT_SETTINGS.APB_fractionLightColor as string;\n\t\t\t\t\tthis.plugin.saveSettings();\n\t\t\t\t\tthis.display();\n\t\t\t\t}))\n\t\t\t.addButton((button) =>\n\t\t\t\tbutton.setIcon('moon').setTooltip('Reset to Dark default')\n\t\t\t\t.onClick(() => {\n\t\t\t\t\tthis.plugin.settings.APB_fractionColor = DEFAULT_SETTINGS.APB_fractionColor as string;\n\t\t\t\t\tthis.plugin.saveSettings();\n\t\t\t\t\tthis.display();\n\t\t\t\t})\n\t\t\t);\n\n\t/************ Show Completed *************/\n\tnew Setting(containerEl)\n\t.setName('Show completed text')\n\t.setDesc('When toggled on, the word COMPLETED will be displayed on the progress bar when it reaches 100%.  (See demonstration progress bar above)')\n\t.addToggle((toggle) =>\n\t\t\ttoggle.setValue(this.plugin.settings.APB_completedToggle)\n\t\t\t.onChange((value) => {\n\t\t\t\tthis.plugin.settings.APB_completedToggle = value;\n\t\t\t\tthis.plugin.saveSettings();\n\t\t\t\tthis.display();\n\t\t\t}))\n\t.addButton((button) =>\n\t\tbutton.setIcon('rotate-ccw').setTooltip('Reset to default')\n\t\t.onClick(() => {\n\t\t\tthis.plugin.settings.APB_completedToggle = DEFAULT_SETTINGS.APB_completedToggle as boolean;\n\t\t\tthis.plugin.saveSettings();\n\t\t\tthis.display();\n\t\t})\n\t);\n\n\t/************ Completed Color *************/\n\tnew Setting(containerEl)\n\t.setName('Completed text color')\n\t.setDesc(createFragment((frag) => {\n\t\tfrag.appendText('Select the color of the ');\n\t\tfrag.createEl('span', {\n\t\t\ttext: 'Completed',\n\t\t\tcls: 'highlight-text'\n\t\t});\n\t\tfrag.appendText(' text.');\n\t}))\n\t.addColorPicker((PBcolorpicker0) =>\tPBcolorpicker0\n\t\t.setValue(this.plugin.settings.APB_completedColor).onChange((value) => {\n\t\t\tthis.plugin.settings.APB_completedColor = value;\n\t\t\tthis.plugin.saveSettings();\n\t\t\tthis.display();\n\t\t}))\n\t\t.addButton((button) =>\n\t\t\tbutton.setIcon('sun').setTooltip('Reset to Light default')\n\t\t\t.onClick(() => {\n\t\t\t\tthis.plugin.settings.APB_completedColor = DEFAULT_SETTINGS.APB_completedLightColor as string;\n\t\t\t\tthis.plugin.saveSettings();\n\t\t\t\tthis.display();\n\t\t\t}))\n\t\t.addButton((button) =>\n\t\t\tbutton.setIcon('moon').setTooltip('Reset to Dark default')\n\t\t\t.onClick(() => {\n\t\t\t\tthis.plugin.settings.APB_completedColor = DEFAULT_SETTINGS.APB_completedColor as string;\n\t\t\t\tthis.plugin.saveSettings();\n\t\t\t\tthis.display();\n\t\t\t})\n\t\t);\n\n\n\t/************ SECTION Border & Background *************/\t\n\tcontainerEl.createEl('h4', { text: 'Progress Bar Container' });\n\n\t/************ Border *************/\n\tnew Setting(containerEl)\n\t\t.setName('Border')\n\t\t.setDesc('When toggled on, a border will be displayed around the progress bar container.')\n\t\t.addToggle((toggle) =>\n\t\t\t\ttoggle.setValue(this.plugin.settings.APB_borderToggle)\n\t\t\t\t.onChange((value) => {\n\t\t\t\t\tthis.plugin.settings.APB_borderToggle = value;\n\t\t\t\t\tthis.plugin.saveSettings();\n\t\t\t\t\tthis.display();\n\t\t\t\t}))\n\t\t.addButton((button) =>\n\t\t\tbutton.setIcon('rotate-ccw').setTooltip('Reset to default')\n\t\t\t.onClick(() => {\n\t\t\t\tthis.plugin.settings.APB_borderToggle = DEFAULT_SETTINGS.APB_borderToggle as boolean;\n\t\t\t\tthis.plugin.saveSettings();\n\t\t\t\tthis.display();\n\t\t\t})\n\t\t);\n\n\t/************ Border Color *************/\n\tnew Setting(containerEl)\n\t\t.setName('Border color')\n\t\t.setDesc('Select the color of the border around the progress bar container.')\n\t\t.addColorPicker((PBcolorpicker0) =>\tPBcolorpicker0\n\t\t\t.setValue(this.plugin.settings.APB_colorBorder).onChange((value) => {\n\t\t\t\tthis.plugin.settings.APB_colorBorder = value;\n\t\t\t\tthis.plugin.saveSettings();\n\t\t\t\tthis.display();\n\t\t\t}))\n\t\t.addButton((button) =>\n\t\t\tbutton.setIcon('sun').setTooltip('Reset to Light default')\n\t\t\t.onClick(() => {\n\t\t\t\tthis.plugin.settings.APB_colorBorder = DEFAULT_SETTINGS.APB_colorLightBorder as string;\n\t\t\t\tthis.plugin.saveSettings();\n\t\t\t\tthis.display();\n\t\t\t}))\n\t\t.addButton((button) =>\n\t\t\tbutton.setIcon('moon').setTooltip('Reset to Dark default')\n\t\t\t.onClick(() => {\n\t\t\t\tthis.plugin.settings.APB_colorBorder = DEFAULT_SETTINGS.APB_colorBorder as string;\n\t\t\t\tthis.plugin.saveSettings();\n\t\t\t\tthis.display();\n\t\t\t})\n\t\t);\n\n\t/************ Background *************/\n\tnew Setting(containerEl)\n\t\t.setName('Background')\n\t\t.setDesc('When toggled on, the background of the progress bar container will show.')\n\t\t.addToggle((toggle) =>\n\t\t\t\ttoggle.setValue(this.plugin.settings.APB_backgroundToggle)\n\t\t\t\t.onChange((value) => {\n\t\t\t\t\tthis.plugin.settings.APB_backgroundToggle = value;\n\t\t\t\t\tthis.plugin.saveSettings();\n\t\t\t\t\tthis.display();\n\t\t\t\t}))\n\t\t.addButton((button) =>\n\t\t\tbutton.setIcon('rotate-ccw').setTooltip('Reset to default')\n\t\t\t.onClick(() => {\n\t\t\t\tthis.plugin.settings.APB_backgroundToggle = DEFAULT_SETTINGS.APB_backgroundToggle as boolean;\n\t\t\t\tthis.plugin.saveSettings();\n\t\t\t\tthis.display();\n\t\t\t})\n\t\t);\n\n\t/************ Background Color *************/\n\tnew Setting(containerEl)\n\t\t.setName('Background color')\n\t\t.setDesc('Select the background color of the progress bar container.')\n\t\t.addColorPicker((PBcolorpicker0) =>\tPBcolorpicker0\n\t\t\t.setValue(this.plugin.settings.APB_colorBackground).onChange((value) => {\n\t\t\t\tthis.plugin.settings.APB_colorBackground = value;\n\t\t\t\tthis.plugin.saveSettings();\n\t\t\t\tthis.display();\n\t\t\t}))\n\t\t.addButton((button) =>\n\t\t\tbutton.setIcon('sun').setTooltip('Reset to Light default')\n\t\t\t.onClick(() => {\n\t\t\t\tthis.plugin.settings.APB_colorBackground = DEFAULT_SETTINGS.APB_colorLightBackground as string;\n\t\t\t\tthis.plugin.saveSettings();\n\t\t\t\tthis.display();\n\t\t\t}))\n\t\t.addButton((button) =>\n\t\t\tbutton.setIcon('moon').setTooltip('Reset to Dark default')\n\t\t\t.onClick(() => {\n\t\t\t\tthis.plugin.settings.APB_colorBackground = DEFAULT_SETTINGS.APB_colorBackground as string;\n\t\t\t\tthis.plugin.saveSettings();\n\t\t\t\tthis.display();\n\t\t\t})\n\t\t);\n\t\t\n\t/************ SECTION Progress Bar Color Options *************/\n\tcontainerEl.createEl('h4', { text: 'Progress Bar Color' });\n\n\t/************ Number of Colors Dropdown *************/\n\tnew Setting(this.containerEl)\n\t\t.setName('Number of colors')\n\t\t.setDesc('Select how many different colors you want the progress bar to use.  Each color will be used for the entire bar depending on its percentage completed.  (See demonstration progress bar above)')\n\t\t.addDropdown((dropdown) => {\n\t\t\tdropdown\n\t\t\t\t.addOptions({\n\t\t\t\t\toption1: '1 color',\n\t\t\t\t\toption2: '2 colors',\n\t\t\t\t\toption3: '3 colors',\n\t\t\t\t\toption4: '4 colors',\n\t\t\t\t\toption5: '5 colors'\n\t\t\t\t})\n\t\t\t\t.setValue(this.plugin.settings.APB_colornumber)\n\t\t\t\t.onChange((value) => {\n\t\t\t\t\tthis.plugin.settings.APB_colornumber = value;\n\t\t\t\t\tthis.plugin.settings.APB_progressBarChange = true;\n\t\t\t\t\tthis.plugin.saveSettings();\n\t\t\t\t\tthis.display();\n\t\t\t\t});\n\t\t})\n\t\t.addButton((button) =>\n\t\t\tbutton.setIcon('rotate-ccw').setTooltip('Reset to default')\n\t\t\t.onClick(() => {\n\t\t\t\tthis.plugin.settings.APB_colornumber = DEFAULT_SETTINGS.APB_colornumber as string;\n\t\t\t\tthis.plugin.settings.APB_progressBarChange = true;\n\t\t\t\tthis.plugin.saveSettings();\n\t\t\t\tthis.display();\n\t\t\t})\n\t\t);\n\n\t/************ 1st Color *************/\n\tnew Setting(containerEl)\n\t\t.setName('1st color')\n\t\t.setDesc('This color will be used for the entire progrees bar if the percentage is within the first section.')\n\t\t.addColorPicker((PBcolorpicker1) =>\tPBcolorpicker1\n\t\t\t.setValue(this.plugin.settings.APB_color1).onChange((value) => {\n\t\t\t\tthis.plugin.settings.APB_color1 = value;\n\t\t\t\tthis.plugin.saveSettings();\n\t\t\t\tthis.display();\n\t\t\t})\n\t\t)\n\t\t.addButton((button) =>\n\t\t\tbutton.setIcon('sun').setTooltip('Reset to Light default')\n\t\t\t.onClick(() => {\n\t\t\t\tthis.plugin.settings.APB_color1 = DEFAULT_SETTINGS.APB_color1Light as string;\n\t\t\t\tthis.plugin.saveSettings();\n\t\t\t\tthis.display();\n\t\t\t}))\n\t\t.addButton((button) =>\n\t\t\tbutton.setIcon('moon').setTooltip('Reset to Dark default')\n\t\t\t.onClick(() => {\n\t\t\t\tthis.plugin.settings.APB_color1 = DEFAULT_SETTINGS.APB_color1 as string;\n\t\t\t\tthis.plugin.saveSettings();\n\t\t\t\tthis.display();\n\t\t\t})\n\t\t);\n\n\tif (this.plugin.settings.APB_colornumber !== 'option1') {\n\t\t/************ 2nd Color *************/\n\t\tnew Setting(containerEl)\n\t\t\t.setName('2nd color')\n\t\t\t.setDesc('This color will be used for the entire progrees bar if the percentage is within the second section.')\n\t\t\t.addColorPicker((PBcolorpicker2) =>\tPBcolorpicker2\n\t\t\t\t.setValue(this.plugin.settings.APB_color2).onChange((value) => {\n\t\t\t\t\tthis.plugin.settings.APB_color2 = value;\n\t\t\t\t\tthis.plugin.saveSettings();\n\t\t\t\t\tthis.display();\n\t\t\t\t}))\n\t\t\t.addButton((button) =>\n\t\t\t\tbutton.setIcon('sun').setTooltip('Reset to Light default')\n\t\t\t\t.onClick(() => {\n\t\t\t\t\tthis.plugin.settings.APB_color2 = DEFAULT_SETTINGS.APB_color2Light as string;\n\t\t\t\t\tthis.plugin.saveSettings();\n\t\t\t\t\tthis.display();\n\t\t\t\t}))\n\t\t\t.addButton((button) =>\n\t\t\t\tbutton.setIcon('moon').setTooltip('Reset to Dark default')\n\t\t\t\t.onClick(() => {\n\t\t\t\t\tthis.plugin.settings.APB_color2 = DEFAULT_SETTINGS.APB_color2 as string;\n\t\t\t\t\tthis.plugin.saveSettings();\n\t\t\t\t\tthis.display();\n\t\t\t\t})\n\t\t\t);\n\n\t\tif (this.plugin.settings.APB_colornumber !== 'option2') {\n\t\t\t/************ 3rd Color *************/\n\t\t\tnew Setting(containerEl)\n\t\t\t\t.setName('3rd color')\n\t\t\t\t.setDesc('This color will be used for the entire progrees bar if the percentage is within the third section.')\n\t\t\t\t.addColorPicker((PBcolorpicker3) =>\tPBcolorpicker3\n\t\t\t\t\t.setValue(this.plugin.settings.APB_color3).onChange((value) => {\n\t\t\t\t\t\tthis.plugin.settings.APB_color3 = value;\n\t\t\t\t\t\tthis.plugin.saveSettings();\n\t\t\t\t\t\tthis.display();\n\t\t\t\t\t}))\n\t\t\t\t.addButton((button) =>\n\t\t\t\t\tbutton.setIcon('sun').setTooltip('Reset to Light default')\n\t\t\t\t\t.onClick(() => {\n\t\t\t\t\t\tthis.plugin.settings.APB_color3 = DEFAULT_SETTINGS.APB_color3Light as string;\n\t\t\t\t\t\tthis.plugin.saveSettings();\n\t\t\t\t\t\tthis.display();\n\t\t\t\t\t}))\n\t\t\t\t.addButton((button) =>\n\t\t\t\t\tbutton.setIcon('moon').setTooltip('Reset to Dark default')\n\t\t\t\t\t.onClick(() => {\n\t\t\t\t\t\tthis.plugin.settings.APB_color3 = DEFAULT_SETTINGS.APB_color3 as string;\n\t\t\t\t\t\tthis.plugin.saveSettings();\n\t\t\t\t\t\tthis.display();\n\t\t\t\t\t})\n\t\t\t\t);\n\t\n\t\t\tif (this.plugin.settings.APB_colornumber !== 'option3') {\n\t\t\t\t/************ 4th Color *************/\n\t\t\t\tnew Setting(containerEl)\n\t\t\t\t\t.setName('4th color')\n\t\t\t\t\t.setDesc('This color will be used for the entire progrees bar if the percentage is within the fourth section.')\n\t\t\t\t\t.addColorPicker((PBcolorpicker4) =>\tPBcolorpicker4\n\t\t\t\t\t\t.setValue(this.plugin.settings.APB_color4).onChange((value) => {\n\t\t\t\t\t\t\tthis.plugin.settings.APB_color4 = value;\n\t\t\t\t\t\t\tthis.plugin.saveSettings();\n\t\t\t\t\t\t\tthis.display();\n\t\t\t\t\t\t}))\n\t\t\t\t\t.addButton((button) =>\n\t\t\t\t\t\tbutton.setIcon('sun').setTooltip('Reset to Light default')\n\t\t\t\t\t\t.onClick(() => {\n\t\t\t\t\t\t\tthis.plugin.settings.APB_color4 = DEFAULT_SETTINGS.APB_color4Light as string;\n\t\t\t\t\t\t\tthis.plugin.saveSettings();\n\t\t\t\t\t\t\tthis.display();\n\t\t\t\t\t\t}))\n\t\t\t\t\t.addButton((button) =>\n\t\t\t\t\t\tbutton.setIcon('moon').setTooltip('Reset to Dark default')\n\t\t\t\t\t\t.onClick(() => {\n\t\t\t\t\t\t\tthis.plugin.settings.APB_color4 = DEFAULT_SETTINGS.APB_color4 as string;\n\t\t\t\t\t\t\tthis.plugin.saveSettings();\n\t\t\t\t\t\t\tthis.display();\n\t\t\t\t\t\t})\n\t\t\t\t\t);\n\n\t\t\t\tif (this.plugin.settings.APB_colornumber !== 'option4') {\n\t\t\t\t\t/************ 5th Color *************/\n\t\t\t\t\tnew Setting(containerEl)\n\t\t\t\t\t\t.setName('5th color')\n\t\t\t\t\t\t.setDesc('This color will be used for the entire progrees bar if the percentage is within the fifth section.')\n\t\t\t\t\t\t.addColorPicker((PBcolorpicker5) =>\tPBcolorpicker5\n\t\t\t\t\t\t\t.setValue(this.plugin.settings.APB_color5).onChange((value) => {\n\t\t\t\t\t\t\t\tthis.plugin.settings.APB_color5 = value;\n\t\t\t\t\t\t\t\tthis.plugin.saveSettings();\n\t\t\t\t\t\t\t\tthis.display();\n\t\t\t\t\t\t\t}))\n\t\t\t\t\t\t.addButton((button) =>\n\t\t\t\t\t\t\tbutton.setIcon('sun').setTooltip('Reset to Light default')\n\t\t\t\t\t\t\t.onClick(() => {\n\t\t\t\t\t\t\t\tthis.plugin.settings.APB_color5 = DEFAULT_SETTINGS.APB_color5Light as string;\n\t\t\t\t\t\t\t\tthis.plugin.saveSettings();\n\t\t\t\t\t\t\t\tthis.display();\n\t\t\t\t\t\t\t}))\n\t\t\t\t\t\t.addButton((button) =>\n\t\t\t\t\t\t\tbutton.setIcon('moon').setTooltip('Reset to Dark default')\n\t\t\t\t\t\t\t.onClick(() => {\n\t\t\t\t\t\t\t\tthis.plugin.settings.APB_color5 = DEFAULT_SETTINGS.APB_color5 as string;\n\t\t\t\t\t\t\t\tthis.plugin.saveSettings();\n\t\t\t\t\t\t\t\tthis.display();\n\t\t\t\t\t\t\t})\n\t\t\t\t\t\t);\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t/************ Completed Color *************/\n\tnew Setting(containerEl)\n\t\t.setName('Completed color')\n\t\t.setDesc('Select the color the entire progress bar will use when it reaches 100% completion.')\n\t\t.addColorPicker((PBcolorpicker0) =>\tPBcolorpicker0\n\t\t\t.setValue(this.plugin.settings.APB_colorBarCompleted).onChange((value) => {\n\t\t\t\tthis.plugin.settings.APB_colorBarCompleted = value;\n\t\t\t\tthis.plugin.saveSettings();\n\t\t\t\tthis.display();\n\t\t\t}))\n\t\t\t.addButton((button) =>\n\t\t\t\tbutton.setIcon('sun').setTooltip('Reset to Light default')\n\t\t\t\t.onClick(() => {\n\t\t\t\t\tthis.plugin.settings.APB_colorBarCompleted = DEFAULT_SETTINGS.APB_colorLightBarCompleted as string;\n\t\t\t\t\tthis.plugin.saveSettings();\n\t\t\t\t\tthis.display();\n\t\t\t\t}))\n\t\t\t.addButton((button) =>\n\t\t\t\tbutton.setIcon('moon').setTooltip('Reset to Dark default')\n\t\t\t\t.onClick(() => {\n\t\t\t\t\tthis.plugin.settings.APB_colorBarCompleted = DEFAULT_SETTINGS.APB_colorBarCompleted as string;\n\t\t\t\t\tthis.plugin.saveSettings();\n\t\t\t\t\tthis.display();\n\t\t\t\t})\n\t\t\t);\n\n\t/************ Bar Background Color *************/\n\tnew Setting(containerEl)\n\t\t.setName('Bar background color')\n\t\t.setDesc('This color will be used for the progress bar\\'s background, representing the remaining percentage.')\n\t\t.addColorPicker((PBcolorpicker0) =>\tPBcolorpicker0\n\t\t\t.setValue(this.plugin.settings.APB_colorBarBackground).onChange((value) => {\n\t\t\t\tthis.plugin.settings.APB_colorBarBackground = value;\n\t\t\t\tthis.plugin.saveSettings();\n\t\t\t\tthis.display();\n\t\t\t}))\n\t\t.addButton((button) =>\n\t\t\tbutton.setIcon('sun').setTooltip('Reset to Light default')\n\t\t\t.onClick(() => {\n\t\t\t\tthis.plugin.settings.APB_colorBarBackground = DEFAULT_SETTINGS.APB_colorLightBarBackground as string;\n\t\t\t\tthis.plugin.saveSettings();\n\t\t\t\tthis.display();\n\t\t\t}))\n\t\t.addButton((button) =>\n\t\t\tbutton.setIcon('moon').setTooltip('Reset to Dark default')\n\t\t\t.onClick(() => {\n\t\t\t\tthis.plugin.settings.APB_colorBarBackground = DEFAULT_SETTINGS.APB_colorBarBackground as string;\n\t\t\t\tthis.plugin.saveSettings();\n\t\t\t\tthis.display();\n\t\t\t})\n\t\t);\n    }\n}\n\n/************ setEndCaps Function *************/\nfunction setEndCaps(progressBarBackground: HTMLElement | null, progressbar: HTMLElement | null, endCap: boolean) {\n\tif (progressBarBackground && progressbar) {\n\t\tif (endCap) {\n\t\t\tprogressBarBackground.style.borderRadius = '7px';\n\t\t\tprogressbar.style.borderRadius = '7px';\n\t\t} else {\n\t\t\tprogressBarBackground.style.borderRadius = '0px';\n\t\t\tprogressbar.style.borderRadius = '0px';\n\t\t}\n\t} else {\n\t\tconsole.error('Elements are not defined');\n\t}\n}\n\nfunction hexToRgba(hex: string, alpha: number = 1): string {\n    hex = hex.replace('#', '');\n\n    // If hex is 3 characters, expand to 6 (e.g., #F00 => #FF0000)\n    if (hex.length === 3) {\n        hex = hex.split('').map(char => char + char).join('');\n    }\n\n    // Convert hex to RGB values\n    const r = parseInt(hex.slice(0, 2), 16);\n    const g = parseInt(hex.slice(2, 4), 16);\n    const b = parseInt(hex.slice(4, 6), 16);\n\n    // Return the RGBA string\n    return `rgba(${r}, ${g}, ${b}, ${alpha})`;\n}"],
  "mappings": "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",
  "names": ["valueFromPercentageOfTotal", "container", "progressBarPercentage", "_a", "timeoutId"]
}
 diff --git a/manifest.json b/manifest.json new file mode 100644 index 0000000..d36b8d3 --- /dev/null +++ b/manifest.json @@ -0,0 +1,17 @@ +{ + "id": "obsidian-advanced-progress-bars", + "name": "Advanced Progress Bars", + "version": "1.0.1", + "minAppVersion": "0.15.0", + "description": "Progress bars that can change color depending on completion value - fully customizable.", + "author": "cactuzhead", + "authorUrl": "https://cactuzhead.com", + "fundingUrl": "https://ko-fi.com/cactuzhead", + "isDesktopOnly": false, + "commands": [ + { + "id": "paste-code-block", + "name": "Paste Code Block" + } + ] +} diff --git a/styles.css b/styles.css new file mode 100644 index 0000000..2139fef --- /dev/null +++ b/styles.css @@ -0,0 +1,154 @@ +:root { + color-scheme: light dark; +} + +h3, .markdown-rendered h3 { + color: #a3be8c; +} + +h4, .markdown-rendered h4 { + color: #689DED; +} + +.highlight-text { + color: light-dark(#ec7e83, #71d1c4); +} + +.custom-textbox { + width: 60px; +} + +.custom-container { + align-Items: center; + border-Radius: 7px; + border: 1px solid #689ded; + display: flex; + justify-Content: space-between; + margin: 0px; +} + +.custom-container img { + padding-right: 1em; +} + +.custom-container p { + color: #8fa0ba; + flex: 1 1 auto; + min-width: 10px; + overflow: hidden; + padding-left: 1em; + white-space: wrap; + width: 160px; +} + +.progressBar-container { + border-radius: 7px; + display: flex; + flex-flow: row wrap; + margin-top: 7px; + overflow: hidden; + padding: 5px; + position: relative; + width: 100%; +} + +.progressBar-text-container { + align-items: center; + box-sizing: border-box; + display: flex; + flex-flow: row nowrap; + font-family: Arial, Helvetica, sans-serif; + font-size: 0.75rem; + justify-content: space-between; + overflow: hidden; + padding: 0 0 0.3em 0; + width: 100%; +} + +.progressBar-title { + color: #8fa0ba; + flex: 1 1 0; + min-width: 10px; + overflow: hidden; + padding: 0 0.3em; + text-overflow: ellipsis; + white-space: nowrap; + width: 10px; +} + +.progressBar-percentage { + color: #c1d7f9; + flex: 0 0 auto; + padding: 0 0 0 0.3em; + text-align: right; +} + +.progressBar-value { + color: #8fa0ba; + flex: 0 0 auto; + padding: 0 0.3em; + text-align: right; +} + +.progressBar-completed { + color: #c1d7f9; + font-size: 0.75em; + font-weight: 500; + overflow: hidden; + padding: 0 0 0 0.3em; + text-align: center; + text-overflow: ellipsis; + white-space: nowrap; + width: 100%; +} + +.progressBar-background { + display: flex; + flex-flow: row nowrap; + position: relative; +} + +.progressBar { + display: flex; + justify-Content: space-between; + margin: 0px; + align-Items: center; +} + +.marks { + height: 100%; + left: 0; + pointer-events: none; + position: absolute; + top: 0; + width: 100%; + } + +.mark { + height: 100%; + position: absolute; + top: 0; + z-index: 1; + } + +.error-container { + background:#912f3c; + border-radius: 7px; + display: flex; + flex-flow: row wrap; + overflow: hidden; + padding: 5px; + position: relative; +} + +.error-text-container { + align-items: center; + color:#ffffff; + display: flex; + flex-flow: row nowrap; + font-family: Arial, Helvetica, sans-serif; + font-size: 0.75rem; + justify-content: space-between; + padding: 0.3em; + width: 100%; +} \ No newline at end of file