418 lines
15 KiB
JavaScript
418 lines
15 KiB
JavaScript
/**
|
|
* LogarithmPlotter - 2D plotter software to make BODE plots, sequences and distribution functions.
|
|
* Copyright (C) 2021-2024 Ad5001
|
|
*
|
|
* This program is free software: you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation, either version 3 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program. If not, see <https://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
import { getRandomColor } from "../utils.mjs"
|
|
import Objects from "../module/objects.mjs"
|
|
import Latex from "../module/latex.mjs"
|
|
import { ensureTypeSafety, serializesByPropertyType } from "../parameters.mjs"
|
|
|
|
// This file contains the default data to be imported from all other objects
|
|
|
|
/**
|
|
* Class to extend for every type of object that
|
|
* can be drawn on the canvas.
|
|
*/
|
|
export class DrawableObject {
|
|
/**
|
|
* Base name of the object. Needs to be constant over time.
|
|
* @return {string} Type of the object.
|
|
*/
|
|
static type() {
|
|
return "Unknown"
|
|
}
|
|
|
|
/**
|
|
* Translated name of the object to be shown to the user.
|
|
* @return {string}
|
|
*/
|
|
static displayType() {
|
|
return "Unknown"
|
|
}
|
|
|
|
/**
|
|
* Translated name of the object in plural form to be shown to the user.
|
|
* @return {string}
|
|
*/
|
|
static displayTypeMultiple() {
|
|
return "Unknowns"
|
|
}
|
|
|
|
/**
|
|
* True if this object can be created by the user, false if it can only
|
|
* be instantiated by other objects
|
|
* @return {boolean}
|
|
*/
|
|
static createable() {
|
|
return true
|
|
}
|
|
|
|
/**
|
|
* List of properties used in the Object Editor.
|
|
*
|
|
* Properties are set with key as property name and
|
|
* value as it's type name (e.g 'numbers', 'string'...),
|
|
* an Enum for enumerations, an ObjectType for DrawableObjects
|
|
* with a specific type, a List instance for lists, a
|
|
* Dictionary instance for dictionaries, an Expression for expressions...
|
|
*
|
|
* If the property is to be translated, the key should be passed
|
|
* through the QT_TRANSLATE_NOOP macro in that form:
|
|
* [QT_TRANSLATE_NOOP('prop','key')]
|
|
* Enums that are translated should be indexed in parameters.mjs and
|
|
* then be linked directly here.
|
|
*
|
|
* @return {Object.<string,string|Enum|List|ObjectType|Dictionary>}
|
|
*/
|
|
static properties() {
|
|
return {}
|
|
}
|
|
|
|
/**
|
|
* True if this object can be executed, so that an y value might be computed
|
|
* for an x value. Only ExecutableObjects have that property set to true.
|
|
* @return {boolean}
|
|
*/
|
|
static executable() {
|
|
return false
|
|
}
|
|
|
|
/**
|
|
* Imports the object from its serialized form.
|
|
* @return {DrawableObject}
|
|
*/
|
|
static import(name, visible, color, labelContent, ...args) {
|
|
let importedArgs = [name.toString(), visible === true, color.toString(), labelContent]
|
|
console.log("Importing", this.type(), name, args)
|
|
for(let [name, propType] of Object.entries(this.properties()))
|
|
if(!name.startsWith("comment")) {
|
|
importedArgs.push(ensureTypeSafety(propType, args[importedArgs.length - 4]))
|
|
}
|
|
return new this(...importedArgs)
|
|
}
|
|
|
|
/**
|
|
* Base constructor for the object.
|
|
* @param {string} name - Name of the object
|
|
* @param {boolean} visible - true if the object is visible, false otherwise.
|
|
* @param {color|string} color - Color of the object (can be string or QColor)
|
|
* @param {"null"|"name"|"name + value"} labelContent - One of 'null', 'name' or 'name + value' describing the content of the label.
|
|
* @constructor
|
|
*/
|
|
constructor(name, visible = true, color = null, labelContent = "name + value") {
|
|
if(color == null) color = getRandomColor()
|
|
this.type = this.constructor.type()
|
|
this.name = name
|
|
this.visible = visible
|
|
this.color = color
|
|
this.labelContent = labelContent // "null", "name", "name + value"
|
|
this.requiredBy = []
|
|
this.requires = []
|
|
}
|
|
|
|
/**
|
|
* Serializes the object in an array that can be JSON serialized.
|
|
* These parameters will be re-entered in the constructor when restored.
|
|
* @return {array}
|
|
*/
|
|
export() {
|
|
let exportList = [this.name, this.visible, this.color.toString(), this.labelContent]
|
|
for(let [name, propType] of Object.entries(this.constructor.properties()))
|
|
if(!name.startsWith("comment"))
|
|
exportList.push(serializesByPropertyType(propType, this[name]))
|
|
return exportList
|
|
}
|
|
|
|
/**
|
|
* String representing the object that will be displayed to the user.
|
|
* It allows for 2 lines and translated text, but it shouldn't be too long.
|
|
* @return {string}
|
|
*/
|
|
getReadableString() {
|
|
return `${this.name} = Unknown`
|
|
}
|
|
|
|
/**
|
|
* Latex markuped version of the readable string.
|
|
* Every non latin character should be passed as latex symbols and formulas
|
|
* should be in latex form.
|
|
* See ../latex.mjs for helper methods.
|
|
* @return {string}
|
|
*/
|
|
getLatexString() {
|
|
return this.getReadableString()
|
|
}
|
|
|
|
/**
|
|
* Readable string content of the label depending on the value of the latexContent.
|
|
* @return {string}
|
|
*/
|
|
getLabel() {
|
|
switch(this.labelContent) {
|
|
case "name":
|
|
return this.name
|
|
case "name + value":
|
|
return this.getReadableString()
|
|
case "null":
|
|
return ""
|
|
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Latex markup string content of the label depending on the value of the latexContent.
|
|
* Every non latin character should be passed as latex symbols and formulas
|
|
* should be in latex form.
|
|
* See ../latex.mjs for helper methods.
|
|
* @return {string}
|
|
*/
|
|
getLatexLabel() {
|
|
switch(this.labelContent) {
|
|
case "name":
|
|
return Latex.variable(this.name)
|
|
case "name + value":
|
|
return this.getLatexString()
|
|
case "null":
|
|
return ""
|
|
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Returns the recursive list of objects this one depends on.
|
|
* @return {array}
|
|
*/
|
|
getDependenciesList() {
|
|
let dependencies = this.requires.map(obj => obj)
|
|
for(let obj of this.requires)
|
|
dependencies = dependencies.concat(obj.getDependenciesList())
|
|
return dependencies
|
|
}
|
|
|
|
/**
|
|
* Callback method when one of the properties of the object is updated.
|
|
*/
|
|
update() {
|
|
// Refreshing dependencies.
|
|
for(let obj of this.requires)
|
|
obj.requiredBy = obj.requiredBy.filter(dep => dep !== this)
|
|
// Checking objects this one depends on
|
|
this.requires = []
|
|
let currentObjectsByName = Objects.currentObjectsByName
|
|
let properties = this.constructor.properties()
|
|
for(let property in properties)
|
|
if(typeof properties[property] == "object" && "type" in properties[property])
|
|
if(properties[property].type === "Expression" && this[property] != null) {
|
|
// Expressions with dependencies
|
|
for(let objName of this[property].requiredObjects()) {
|
|
if(objName in currentObjectsByName && !this.requires.includes(currentObjectsByName[objName])) {
|
|
this.requires.push(currentObjectsByName[objName])
|
|
currentObjectsByName[objName].requiredBy.push(this)
|
|
}
|
|
}
|
|
if(this[property].canBeCached && this[property].requiredObjects().length > 0)
|
|
// Recalculate
|
|
this[property].recache()
|
|
|
|
} else if(properties[property].type === "ObjectType" && this[property] != null) {
|
|
// Object dependency
|
|
this.requires.push(this[property])
|
|
this[property].requiredBy.push(this)
|
|
}
|
|
// Updating objects dependent on this one
|
|
for(let req of this.requiredBy)
|
|
req.update()
|
|
}
|
|
|
|
/**
|
|
* Callback method when the object is about to get deleted.
|
|
*/
|
|
delete() {
|
|
for(let toRemove of this.requiredBy) { // Normally, there should be none here, but better leave nothing just in case.
|
|
Objects.deleteObject(toRemove.name)
|
|
}
|
|
for(let toRemoveFrom of this.requires) {
|
|
toRemoveFrom.requiredBy = toRemoveFrom.requiredBy.filter(o => o !== this)
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Abstract method. Draw the object onto the canvas with the.
|
|
* @param {CanvasAPI} canvas
|
|
*/
|
|
draw(canvas) {
|
|
}
|
|
|
|
/**
|
|
* Applicates a drawFunction with two position arguments depending on
|
|
* both the posX and posY of where the label should be displayed,
|
|
* and the labelPosition which declares the label should be displayed
|
|
* relatively to that position.
|
|
*
|
|
* @param {string|Enum} labelPosition - Position of the label relative to the marked position
|
|
* @param {number} offset - Margin between the position and the object to be drawn
|
|
* @param {{width: number, height: number}} size - Size of the label item, containing two properties, "width" and "height"
|
|
* @param {number} posX - Component of the marked position on the x-axis
|
|
* @param {number} posY - Component of the marked position on the y-axis
|
|
* @param {function} drawFunction - Function with two arguments (x, y) that will be called to draw the label
|
|
*/
|
|
drawPositionDivergence(labelPosition, offset, size, posX, posY, drawFunction) {
|
|
switch(labelPosition) {
|
|
case "center":
|
|
drawFunction(posX - size.width / 2, posY - size.height / 2)
|
|
break
|
|
case "top":
|
|
case "above":
|
|
drawFunction(posX - size.width / 2, posY - size.height - offset)
|
|
break
|
|
case "bottom":
|
|
case "below":
|
|
drawFunction(posX - size.width / 2, posY + offset)
|
|
break
|
|
case "left":
|
|
drawFunction(posX - size.width - offset, posY - size.height / 2)
|
|
break
|
|
case "right":
|
|
drawFunction(posX + offset, posY - size.height / 2)
|
|
break
|
|
case "top-left":
|
|
case "above-left":
|
|
drawFunction(posX - size.width, posY - size.height - offset)
|
|
break
|
|
case "top-right":
|
|
case "above-right":
|
|
drawFunction(posX + offset, posY - size.height - offset)
|
|
break
|
|
case "bottom-left":
|
|
case "below-left":
|
|
drawFunction(posX - size.width - offset, posY + offset)
|
|
break
|
|
case "bottom-right":
|
|
case "below-right":
|
|
drawFunction(posX + offset, posY + offset)
|
|
break
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Automatically draw text (by default the label of the object on the canvas
|
|
* depending on user settings.
|
|
* This method takes into account both the posX and posY of where the label
|
|
* should be displayed, including the labelPosition relative to it.
|
|
* The text is get both through the getLatexFunction and getTextFunction
|
|
* depending on whether to use latex.
|
|
* Then, it's displayed using the drawFunctionLatex (x,y,imageData) and
|
|
* drawFunctionText (x,y,text) depending on whether to use latex.
|
|
*
|
|
* @param {CanvasAPI} canvas
|
|
* @param {string|Enum} labelPosition - Position of the label relative to the marked position
|
|
* @param {number} posX - Component of the marked position on the x-axis
|
|
* @param {number} posY - Component of the marked position on the y-axis
|
|
* @param {boolean} forceText - Force the rendering of the label as text
|
|
* @param {function|null} getLatexFunction - Function (no argument) to get the latex markup to be displayed
|
|
* @param {function|null} getTextFunction - Function (no argument) to get the text to be displayed
|
|
* @param {function|null} drawFunctionLatex - Function (x,y,imageData) to display the latex image
|
|
* @param {function|null} drawFunctionText - Function (x,y,text,textSize) to display the text
|
|
*/
|
|
drawLabel(canvas, labelPosition, posX, posY, forceText = false,
|
|
getLatexFunction = null, getTextFunction = null, drawFunctionLatex = null, drawFunctionText = null) {
|
|
// Default functions
|
|
if(getLatexFunction == null)
|
|
getLatexFunction = this.getLatexLabel.bind(this)
|
|
if(getTextFunction == null)
|
|
getTextFunction = this.getLabel.bind(this)
|
|
if(drawFunctionLatex == null)
|
|
drawFunctionLatex = (x, y, ltxImg) => canvas.drawVisibleImage(ltxImg.source, x, y, ltxImg.width, ltxImg.height)
|
|
if(drawFunctionText == null)
|
|
drawFunctionText = (x, y, text, textSize) => canvas.drawVisibleText(text, x, y + textSize.height) // Positioned from left bottom
|
|
// Drawing the label
|
|
if(!forceText && Latex.enabled) {
|
|
// With latex
|
|
let drawLblCb = ((ltxImg) => {
|
|
this.drawPositionDivergence(labelPosition, 8 + canvas.linewidth / 2, ltxImg, posX, posY, (x, y) => drawFunctionLatex(x, y, ltxImg))
|
|
})
|
|
let ltxLabel = getLatexFunction()
|
|
if(ltxLabel !== "")
|
|
canvas.renderLatexImage(ltxLabel, this.color, drawLblCb)
|
|
} else {
|
|
// Without latex
|
|
let text = getTextFunction()
|
|
canvas.font = `${canvas.textsize}px sans-serif`
|
|
let textSize = canvas.measureText(text)
|
|
this.drawPositionDivergence(labelPosition, 8 + canvas.linewidth / 2, textSize, posX, posY, (x, y) => drawFunctionText(x, y, text, textSize))
|
|
}
|
|
}
|
|
|
|
toString() {
|
|
return this.name
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
* Class to be extended for every object on which
|
|
* an y for a x can be computed with the execute function.
|
|
* If a value cannot be found during execute, it will
|
|
* return null. However, theses same x values will
|
|
* return false when passed to canExecute.
|
|
*/
|
|
export class ExecutableObject extends DrawableObject {
|
|
/**
|
|
* Returns the corresponding y value for an x value.
|
|
* If the object isn't defined on the given x, then
|
|
* this function will return null.
|
|
*
|
|
* @param {number} x
|
|
* @returns {number|null}
|
|
*/
|
|
execute(x = 1) {
|
|
return 0
|
|
}
|
|
|
|
/**
|
|
* Returns false if the object isn't defined on the given x, true otherwise.
|
|
*
|
|
* @param {number} x
|
|
* @returns {boolean}
|
|
*/
|
|
canExecute(x = 1) {
|
|
return true
|
|
}
|
|
|
|
/**
|
|
* Returns the simplified expression string for a given x.
|
|
*
|
|
* @param {number} x
|
|
* @returns {string|Expression}
|
|
*/
|
|
simplify(x = 1) {
|
|
return "0"
|
|
}
|
|
|
|
/**
|
|
* True if this object can be executed, so that an y value might be computed
|
|
* for an x value. Only ExecutableObjects have that property set to true.
|
|
* @return {boolean}
|
|
*/
|
|
static executable() {
|
|
return true
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|