Ad5001/LogarithmPlotter
Ad5001/LogarithmPlotter
1
0
Fork 0
Code Issues 6 Pull requests Projects Releases Wiki Activity

Initial commit, pushing everything done so far

Browse source
This commit is contained in:
Adsooi 2020-12-22 01:01:36 +01:00
commit 08d52fa371
15 changed files with 4325 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

66
qml/AppMenuBar.qml Normal file
View file

@ -0,0 +1,66 @@
/**
* Logarithm Graph Creator - Create graphs with logarithm scales.
* Copyright (C) 2020 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 QtQuick 2.12
import QtQuick.Controls 2.12
MenuBar {
Menu {
title: qsTr("&File")
Action {
text: qsTr("&Load...")
shortcut: StandardKey.Open
onTriggered: settings.load()
icon.name: 'fileopen'
}
Action {
text: qsTr("&Save")
shortcut: StandardKey.Save
onTriggered: settings.save()
icon.name: 'filesave'
}
Action {
text: qsTr("Save &As...")
shortcut: StandardKey.SaveAs
onTriggered: settings.saveAs()
icon.name: 'filesaveas'
}
MenuSeparator { }
Action {
text: qsTr("&Quit")
shortcut: StandardKey.Quit
onTriggered: Qt.quit()
icon.name: 'application-exit'
}
}
Menu {
title: qsTr("&Edit")
Action {
text: qsTr("&Copy diagram")
shortcut: StandardKey.Copy
onTriggered: root.copyDiagramToClipboard()
icon.name: 'editcopy'
}
}
Menu {
title: qsTr("&Help")
Action { text: qsTr("&About") }
}
}

53
qml/ComboBoxSetting.qml Normal file
View file

@ -0,0 +1,53 @@
/**
* Logarithm Graph Creator - Create graphs with logarithm scales.
* Copyright (C) 2020 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 QtQuick 2.12
import QtQuick.Controls 2.12
Item {
id: control
height: 30
signal activated(int newIndex)
property var model: []
property string label: ''
property alias currentIndex: combox.currentIndex
Text {
id: labelItem
height: 30
anchors.top: parent.top
verticalAlignment: TextInput.AlignVCenter
color: sysPalette.windowText
text: " "+ control.label +": "
}
ComboBox {
id: combox
height: 30
anchors.left: labelItem.right
anchors.leftMargin: 5
width: control.width - labelItem.width
model: control.model
currentIndex: model.indexOf(defValue)
onActivated: function(newIndex) {
control.activated(newIndex)
}
}
}

32
qml/FileDialog.qml Normal file
View file

@ -0,0 +1,32 @@
/**
* Logarithm Graph Creator - Create graphs with logarithm scales.
* Copyright (C) 2020 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 QtQuick.Dialogs 1.3 as D
D.FileDialog {
id: fileDialog
property bool exportMode: false
title: exportMode ? "Export Logarithmic Graph file" : "Import Logarithmic Graph file"
nameFilters: ["Logarithmic Graph JSON Data (*.json)", "All files (*)"]
folder: shortcuts.documents
selectExisting: !exportMode
}

169
qml/LogGraph.qml Normal file
View file

@ -0,0 +1,169 @@
/**
* Logarithm Graph Creator - Create graphs with logarithm scales.
* Copyright (C) 2020 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 QtQml 2.12
import QtQuick.Controls 2.12
import QtQuick.Layouts 1.15
import QtQuick 2.12
import "js/objects.js" as Objects
ApplicationWindow {
id: root
visible: true
width: 1000
height: 500
color: sysPalette.window
title: "Logarithmic Graph Creator " + (settings.saveFilename != "" ? " - " + settings.saveFilename : "")
SystemPalette { id: sysPalette; colorGroup: SystemPalette.Active }
SystemPalette { id: sysPaletteIn; colorGroup: SystemPalette.Disabled }
menuBar: AppMenuBar {}
Drawer {
id: sidebar
width: 290
height: parent.height
y: root.menuBar.height
readonly property bool inPortrait: root.width < root.height
modal: inPortrait
interactive: inPortrait
position: inPortrait ? 0 : 1
visible: !inPortrait
Rectangle {
id: topSeparator
color: sysPaletteIn.dark
width: parent.width
height: 2
}
TabBar {
id: sidebarSelector
width: parent.width
anchors.top: topSeparator.bottom
TabButton {
text: qsTr("Settings")
}
TabButton {
text: qsTr("Objects")
}
}
StackLayout {
width: parent.width
currentIndex: sidebarSelector.currentIndex
anchors.top: sidebarSelector.bottom
height: parent.height - sidebarSelector.height
Settings {
id: settings
onChanged: drawCanvas.requestPaint()
onCopyToClipboard: root.copyDiagramToClipboard()
onSaveDiagram: root.saveDiagram(filename)
onLoadDiagram: root.loadDiagram(filename)
}
ObjectLists {
id: objectLists
onChanged: drawCanvas.requestPaint()
}
}
}
LogGraphCanvas {
id: drawCanvas
anchors.top: parent.top
anchors.left: sidebar.right
height: parent.height
width: parent.width - sidebar.position*sidebar.width
x: sidebar.position*sidebar.width
xmin: settings.xmin
ymax: settings.ymax
xzoom: settings.xzoom
yzoom: settings.yzoom
xlabel: settings.xaxislabel
ylabel: settings.yaxislabel
yaxisstep: settings.yaxisstep
onPaint: {
var ctx = getContext("2d");
}
}
function saveDiagram(filename) {
var objs = {}
Object.keys(Objects.currentObjects).forEach(function(objType){
objs[objType] = []
Objects.currentObjects[objType].forEach(function(obj){
objs[objType].push(obj.export())
})
})
Helper.write(filename, JSON.stringify({
"xzoom": settings.xzoom,
"yzoom": settings.yzoom,
"xmin": settings.xmin,
"ymax": settings.ymax,
"yaxisstep": settings.yaxisstep,
"xlabel": settings.xaxislabel,
"ylabel": settings.yaxislabel,
"width": root.width,
"height": root.height,
"objects": objs,
"type": "bodediagramv1"
}))
}
function loadDiagram(filename) {
var data = JSON.parse(Helper.load(filename))
if(Object.keys(data).indexOf("type") != -1 && data["type"] == "bodediagramv1") {
settings.xzoom = data["xzoom"]
settings.yzoom = data["yzoom"]
settings.xmin = data["xmin"]
settings.ymax = data["ymax"]
settings.yaxisstep = data["yaxisstep"]
settings.xaxislabel = data["xlabel"]
settings.yaxislabel = data["ylabel"]
root.height = data["height"]
root.width = data["width"]
Object.keys(data['objects']).forEach(function(objType){
Objects.currentObjects[objType] = []
data['objects'][objType].forEach(function(objData){
var obj = new Objects.drawableTypes[objType](...objData)
Objects.currentObjects[objType].push(obj)
})
})
// Refreshing sidebar
Object.keys(objectLists.listViews).forEach(function(type){
objectLists.listViews[type].model = Objects.currentObjects[type]
})
drawCanvas.requestPaint()
}
}
function copyDiagramToClipboard() {
var file = Helper.gettmpfile()
drawCanvas.save(file)
Helper.copyImageToClipboard()
}
}

173
qml/LogGraphCanvas.qml Normal file
View file

@ -0,0 +1,173 @@
/**
* Logarithm Graph Creator - Create graphs with logarithm scales.
* Copyright (C) 2020 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 QtQuick 2.12
import "js/objects.js" as Objects
import "js/utils.js" as Utils
Canvas {
id: canvas
anchors.top: separator.bottom
anchors.left: parent.left
height: parent.height - 90
width: parent.width
property double xmin: 0
property double ymax: 0
property int xzoom: 10
property int yzoom: 10
property double yaxisstep: 3
property string xlabel: ""
property string ylabel: ""
onPaint: {
//console.log('Redrawing')
var ctx = getContext("2d");
reset(ctx)
drawGrille(ctx)
drawAxises(ctx)
Object.keys(Objects.currentObjects).forEach(function(objType){
Objects.currentObjects[objType].forEach(function(obj){
if(obj.visible) obj.draw(canvas, ctx)
})
})
drawLabels(ctx)
}
function reset(ctx){
// Reset
ctx.fillStyle = "#FFFFFF"
ctx.strokeStyle = "#000000"
ctx.font = "12px sans-serif"
ctx.fillRect(0,0,width,height)
}
// Drawing the log based graph
function drawGrille(ctx) {
ctx.strokeStyle = "#AAAAAA"
for(var xpow = -10; xpow <= 10; xpow++) {
for(var xmulti = 1; xmulti < 10; xmulti++) {
drawXLine(ctx, Math.pow(10, xpow)*xmulti)
}
}
for(var y = -Math.round(100/yaxisstep)*yaxisstep; y < canvas.ymax; y+=yaxisstep) {
drawYLine(ctx, y)
}
}
function drawAxises(ctx) {
ctx.strokeStyle = "#000000"
drawXLine(ctx, 1)
drawYLine(ctx, 0)
var axisypx = x2px(1) // X coordinate of Y axis
var axisxpx = y2px(0) // Y coordinate of X axis
// Drawing arrows
drawLine(ctx, axisypx, 0, axisypx-10, 10)
drawLine(ctx, axisypx, 0, axisypx+10, 10)
drawLine(ctx, canvas.canvasSize.width, axisxpx, canvas.canvasSize.width-10, axisxpx-10)
drawLine(ctx, canvas.canvasSize.width, axisxpx, canvas.canvasSize.width-10, axisxpx+10)
}
function drawLabels(ctx) {
var axisypx = x2px(1) // X coordinate of Y axis
var axisxpx = y2px(0) // Y coordinate of X axis
// Labels
ctx.fillStyle = "#000000"
ctx.font = "16px sans-serif"
ctx.fillText(canvas.ylabel, axisypx+5, 24)
var textSize = ctx.measureText(canvas.xlabel).width
ctx.fillText(canvas.xlabel, canvas.canvasSize.width-14-textSize, axisxpx-5)
// Axis graduation labels
ctx.font = "14px sans-serif"
for(var xpow = -10; xpow <= 10; xpow+=1) {
var textSize = ctx.measureText("10"+Utils.textsup(xpow)).width
if(xpow != 0)
drawVisibleText(ctx, "10"+Utils.textsup(xpow), x2px(Math.pow(10,xpow))-textSize/2, axisxpx+12+(6*(y==0)))
}
for(var y = -Math.round(100/yaxisstep)*yaxisstep; y < canvas.ymax; y+=yaxisstep) {
var textSize = ctx.measureText(y).width
drawVisibleText(ctx, y, axisypx-3-textSize, y2px(y)+6+(6*(y==0)))
}
ctx.fillStyle = "#FFFFFF"
}
function drawXLine(ctx, x) {
if(visible(x, canvas.ymax)) {
drawLine(ctx, x2px(x), 0, x2px(x), canvas.canvasSize.height)
}
}
function drawYLine(ctx, y) {
if(visible(canvas.xmin, y)) {
drawLine(ctx, 0, y2px(y), canvas.canvasSize.width, y2px(y))
}
}
function drawVisibleText(ctx, text, x, y, lineHeight = 14) {
if(x > 0 && x < canvas.canvasSize.width && y > 0 && y < canvas.canvasSize.height) {
text.toString().split("\n").forEach(function(txt, i){
ctx.fillText(txt, x, y+(lineHeight*i))
})
}
}
// Method to calculate multiline string dimensions
function measureText(ctx, text, lineHeight=14) {
var theight = 0
var twidth = 0
text.split("\n").forEach(function(txt, i){
theight += lineHeight
if(ctx.measureText(txt).width > twidth) twidth = ctx.measureText(txt).width
})
return {'width': twidth, 'height': theight}
}
// Converts x coordinate to it's relative position on the canvas.
function x2px(x) {
var logxmin = Math.log(canvas.xmin)
return (Math.log(x)-logxmin)*canvas.xzoom
}
// Converts y coordinate to it's relative position on the canvas.
// Y is NOT ln based.
function y2px(y) {
return (canvas.ymax-y)*canvas.yzoom
}
// Reverse functions
function px2x(px) {
return Math.exp(px/canvas.xzoom+Math.log(canvas.xmin))
}
function px2y(px) {
return -(px/canvas.yzoom-canvas.ymax)
}
// Checks whether a point is visible or not.
function visible(x, y) {
return (x2px(x) >= 0 && x2px(x) <= canvas.canvasSize.width) && (y2px(y) >= 0 && y2px(y) <= canvas.canvasSize.height)
}
// Draws a line from a (x1, y1) to (x2, y2)
function drawLine(ctx, x1, y1, x2, y2) {
ctx.beginPath();
ctx.moveTo(x1, y1);
ctx.lineTo(x2, y2);
ctx.stroke();
}
}

290
qml/ObjectLists.qml Normal file
View file

@ -0,0 +1,290 @@
/**
* Logarithm Graph Creator - Create graphs with logarithm scales.
* Copyright (C) 2020 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 QtQuick 2.12
import QtQuick.Dialogs 1.3 as D
import QtQuick.Controls 2.12
import "js/objects.js" as Objects
import "js/mathlib.js" as MathLib
ListView {
id: objectListList
signal changed()
property var listViews: {'':''} // Needs to be initialized or will be undefined -_-
model: Object.keys(Objects.drawableTypes)
implicitHeight: contentItem.childrenRect.height
delegate: ListView {
id: objTypeList
property string objType: objectListList.model[index]
model: Objects.currentObjects[objType]
width: objectListList.width
implicitHeight: contentItem.childrenRect.height
visible: model.length > 0
Component.onCompleted: objectListList.listViews[objType] = objTypeList // Listing in order to be refreshed
header: Text {
verticalAlignment: TextInput.AlignVCenter
color: sysPalette.windowText
text: objectListList.model[index] + "s:"
font.pixelSize: 20
}
delegate: Item {
id: controlRow
property var obj: Objects.currentObjects[objType][index]
height: 40
width: objTypeList.width
CheckBox {
id: visibilityCheckBox
checked: Objects.currentObjects[objType][index].visible
onClicked: {
Objects.currentObjects[objType][index].visible = !Objects.currentObjects[objType][index].visible
objectListList.changed()
controlRow.obj = Objects.currentObjects[objType][index]
}
ToolTip.visible: hovered
ToolTip.text: checked ? `Hide ${objType} ${obj.name}` : `Show ${objType} ${obj.name}`
}
Text {
id: objDescription
anchors.left: visibilityCheckBox.right
height: parent.height
verticalAlignment: TextInput.AlignVCenter
text: obj.getReadableString()
font.pixelSize: 16
color: sysPalette.windowText
MouseArea {
anchors.fill: parent
onClicked: {
console.log('Showing', objType, index, Objects.currentObjects[objType])
objEditor.obj = Objects.currentObjects[objType][index]
objEditor.objType = objType
objEditor.objIndex = index
objEditor.editingRow = controlRow
objEditor.open()
}
}
}
Rectangle {
anchors.right: parent.right
anchors.rightMargin: 5
color: obj.color
width: parent.height - 10
height: width
radius: Math.min(width, height)
border.width: 2
border.color: sysPalette.windowText
MouseArea {
anchors.fill: parent
onClicked: pickColor.open()
}
}
D.ColorDialog {
id: pickColor
color: obj.color
title: `Pick new color for ${objType} ${obj.name}`
onAccepted: {
Objects.currentObjects[objType][index].color = color
objectListList.changed()
controlRow.obj = Objects.currentObjects[objType][index]
}
}
}
}
// Object editor
D.Dialog {
id: objEditor
property string objType: 'Point'
property int objIndex: 0
property var editingRow: QtObject{}
property var obj: Objects.currentObjects[objType][objIndex]
title: `Logarithmic Graph Creator`
width: 300
height: 400
Text {
id: dlgTitle
anchors.left: parent.left
anchors.top: parent.top
verticalAlignment: TextInput.AlignVCenter
text: `Edit properties of ${objEditor.objType} ${objEditor.obj.name}`
font.pixelSize: 20
color: sysPalette.windowText
}
Column {
id: dlgProperties
anchors.top: dlgTitle.bottom
width: objEditor.width - 40
//height: 30*Math.max(1, Math.ceil(7 / columns))
//columns: Math.floor(width / settingWidth)
spacing: 10
TextSetting {
id: nameProperty
height: 30
label: "Name"
min: 1
width: dlgProperties.width
defValue: objEditor.obj.name
onChanged: function(newValue) {
Objects.currentObjects[objEditor.objType][objEditor.objIndex].name = newValue
// TODO Resolve dependencies
objEditor.obj = Objects.currentObjects[objEditor.objType][objEditor.objIndex]
objEditor.editingRow.obj = Objects.currentObjects[objEditor.objType][objEditor.objIndex]
objectListList.changed()
}
}
ComboBoxSetting {
id: labelContentProperty
height: 30
width: dlgProperties.width
label: "Label content"
model: ["null", "name", "name + value"]
currentIndex: model.indexOf(objEditor.obj.labelContent)
onActivated: function(newIndex) {
Objects.currentObjects[objEditor.objType][objEditor.objIndex].labelContent = model[newIndex]
objEditor.obj = Objects.currentObjects[objEditor.objType][objEditor.objIndex]
objEditor.editingRow.obj = Objects.currentObjects[objEditor.objType][objEditor.objIndex]
objectListList.changed()
}
}
// Dynamic properties
Repeater {
property var objProps: Objects.drawableTypes[objEditor.objType].properties()
model: Array.from(Object.keys(objProps), prop => [prop, objProps[prop]]) // Converted to 2-dimentional array.
Item {
height: 30
width: dlgProperties.width
property string label: modelData[0].charAt(0).toUpperCase() + modelData[0].slice(1).replace(/([A-Z])/g," $1");
TextSetting {
id: customPropText
height: 30
width: parent.width
label: parent.label
min: 1
isDouble: modelData[1] == 'number'
visible: ['Expression', 'Domain', 'string', 'number'].indexOf(modelData[1]) >= 0
defValue: visible ? {
'Expression': function(){return objEditor.obj[modelData[0]].toEditableString()},
'Domain': function(){return objEditor.obj[modelData[0]].toString()},
'string': function(){return objEditor.obj[modelData[0]]},
'number': function(){return objEditor.obj[modelData[0]]}
}[modelData[1]]() : ""
onChanged: function(newValue) {
Objects.currentObjects[objEditor.objType][objEditor.objIndex][modelData[0]] = {
'Expression': function(){return new MathLib.Expression(newValue)},
'Domain': function(){return MathLib.parseDomain(newValue)},
'string': function(){return newValue},
'number': function(){return parseFloat(newValue)}
}[modelData[1]]()
// TODO Resolve dependencies
objEditor.obj = Objects.currentObjects[objEditor.objType][objEditor.objIndex]
objEditor.editingRow.obj = Objects.currentObjects[objEditor.objType][objEditor.objIndex]
objectListList.changed()
}
Component.onCompleted: {
//console.log(modelData[0], objEditor.obj[modelData[0]],modelData[1], defValue)
}
}
ComboBoxSetting {
id: customPropCombo
height: 30
width: dlgProperties.width
label: parent.label
model: visible ? modelData[1] : []
visible: Array.isArray(modelData[1])
currentIndex: model.indexOf(objEditor.obj[modelData[0]])
onActivated: function(newIndex) {
// Setting object property.
Objects.currentObjects[objEditor.objType][objEditor.objIndex][modelData[0]] = model[newIndex]
// Refreshing
objEditor.obj = Objects.currentObjects[objEditor.objType][objEditor.objIndex]
objEditor.editingRow.obj = Objects.currentObjects[objEditor.objType][objEditor.objIndex]
objectListList.changed()
}
}
}
}
}
}
footer: Column {
id: createRow
width: parent.width
Text {
id: createTitle
verticalAlignment: TextInput.AlignVCenter
text: '+ Create new:'
font.pixelSize: 20
color: sysPalette.windowText
}
Repeater {
model: Object.keys(Objects.drawableTypes)
Button {
id: createBtn
text: modelData
width: createRow.width
flat: false
contentItem: Text {
text: createBtn.text
font.pixelSize: 20
opacity: enabled ? 1.0 : 0.3
color: sysPalette.windowText
horizontalAlignment: Text.AlignHCenter
verticalAlignment: Text.AlignVCenter
}
onClicked: {
var newobj = new Objects.drawableTypes[modelData]()
if(Object.keys(Objects.currentObjects).indexOf(modelData) == -1)
Objects.currentObjects[modelData] = []
Objects.currentObjects[modelData].push(newobj)
objectListList.changed()
console.log(objectListList, objectListList.listViews)
objectListList.listViews[modelData].model = Objects.currentObjects[modelData]
}
}
}
}
}

209
qml/Settings.qml Normal file
View file

@ -0,0 +1,209 @@
/**
* Logarithm Graph Creator - Create graphs with logarithm scales.
* Copyright (C) 2020 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 QtQuick.Controls 2.12
import QtQuick 2.12
Grid {
id: root
height: 30*Math.max(1, Math.ceil(7 / columns))
columns: Math.floor(width / settingWidth)
spacing: 10
signal changed()
signal copyToClipboard()
signal saveDiagram(string filename)
signal loadDiagram(string filename)
property int settingWidth: 135
property int xzoom: 100
property int yzoom: 10
property double xmin: 5/10
property double ymax: 25
property int yaxisstep: 4
property string xaxislabel: "ω (rad/s)"
property string yaxislabel: "Gain G (dB)"
property string saveFilename: ""
FileDialog {
id: fdiag
onAccepted: {
var filePath = fileUrl.toString().substr(7)
root.saveFilename = filePath
console.log(filePath)
if(exportMode) {
root.saveDiagram(filePath)
} else {
root.loadDiagram(filePath)
}
}
}
// Line 1
// Zoom
TextSetting {
id: zoomX
height: 30
isInt: true
label: "X Zoom"
min: 1
width: root.settingWidth
defValue: root.xzoom
onChanged: function(newValue) {
root.xzoom = newValue
root.changed()
}
}
TextSetting {
id: zoomY
height: 30
isInt: true
label: "Y Zoom"
width: root.settingWidth
defValue: root.yzoom
onChanged: function(newValue) {
root.yzoom = newValue
root.changed()
}
}
// Positioning the graph
TextSetting {
id: minX
height: 30
isDouble: true
min: 0
label: "Min X"
width: root.settingWidth
defValue: root.xmin
onChanged: function(newValue) {
root.xmin = newValue
root.changed()
}
}
TextSetting {
id: maxY
height: 30
isDouble: true
label: "Max Y"
width: root.settingWidth
defValue: root.ymax
onChanged: function(newValue) {
root.ymax = newValue
root.changed()
}
}
TextSetting {
id: yAxisStep
height: 30
isInt: true
label: "Y Axis Step"
width: root.settingWidth
defValue: root.yaxisstep
onChanged: function(newValue) {
root.yaxisstep = newValue
root.changed()
}
}
Button {
id: copyToClipboard
height: 30
width: root.settingWidth
text: "Copy to clipboard"
icon.name: 'editcopy'
onClicked: root.copyToClipboard()
}
TextSetting {
id: xAxisLabel
height: 30
label: "X Label"
width: root.settingWidth
defValue: root.xaxislabel
onChanged: function(newValue) {
root.xaxislabel = newValue
root.changed()
}
}
TextSetting {
id: yAxisLabel
height: 30
label: "Y Label"
width: root.settingWidth
defValue: root.yaxislabel
onChanged: function(newValue) {
root.yaxislabel = newValue
root.changed()
}
}
Button {
id: saveDiagram
height: 30
width: root.settingWidth
text: "Save diagram"
icon.name: 'filesave'
onClicked: save()
}
Button {
id: saveDiagramAs
height: 30
width: root.settingWidth
text: "Save diagram as"
icon.name: 'filesaveas'
onClicked: saveAs()
}
Button {
id: loadDiagram
height: 30
width: root.settingWidth
text: "Load diagram"
icon.name: 'fileopen'
onClicked: load()
}
CheckBox {
id: modePhaseCheck
height: 30
width: root.settingWidth
text: "Mode phase"
property var refresh: checked ? root.changed() : root.changed()
}
function save() {
if(root.saveFilename == "") {
fdiag.exportMode = true
fdiag.open()
} else {
root.saveDiagram(root.saveFilename)
}
}
function saveAs() {
fdiag.exportMode = true
fdiag.open()
}
function load() {
fdiag.exportMode = false
fdiag.open()
}
}

78
qml/TextSetting.qml Normal file
View file

@ -0,0 +1,78 @@
/**
* Logarithm Graph Creator - Create graphs with logarithm scales.
* Copyright (C) 2020 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 QtQuick.Controls 2.12
import QtQuick 2.12
Item {
id: control
height: 30
signal changed(string newValue)
property bool isInt: false
property bool isDouble: false
property double min: 1
property string label
property string defValue
Item {
anchors.centerIn: parent
width: labelItem.width + input.width
height: Math.max(labelItem.height, input.height)
Text {
id: labelItem
height: 30
anchors.top: parent.top
verticalAlignment: TextInput.AlignVCenter
color: sysPalette.windowText
text: " "+ control.label +": "
}
TextInput {
id: input
anchors.top: parent.top
anchors.left: labelItem.right
anchors.leftMargin: 5
width: control.width - labelItem.width
height: 30
verticalAlignment: TextInput.AlignVCenter
horizontalAlignment: TextInput.AlignHCenter
color: sysPalette.windowText
focus: true
text: control.defValue
selectByMouse: true
onEditingFinished: {
var value = text
if(control.isInt) value = Math.max(control.min,parseInt(value).toString()=="NaN"?control.min:parseInt(value))
if(control.isDouble) value = Math.max(control.min,parseFloat(value).toString()=="NaN"?control.min:parseFloat(value))
if(value != "") control.changed(value)
}
}
Rectangle {
color: sysPalette.windowText
anchors.left: input.left
anchors.right: input.right
anchors.bottom: input.bottom
height: 2
}
}
}

1837
qml/js/expr-eval.js Normal file
View file

File diff suppressed because it is too large Load diff

274
qml/js/mathlib.js Normal file
View file

@ -0,0 +1,274 @@
/**
* Logarithm Graph Creator - Create graphs with logarithm scales.
* Copyright (C) 2020 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/>.
*/
.pragma library
.import "expr-eval.js" as ExprEval
const parser = new ExprEval.Parser()
class Expression {
constructor(expr) {
this.expr = expr
this.calc = parser.parse(expr).simplify()
this.replacements = [
['pi', 'π'],
['inf', '∞'],
['Infinity', '∞'],
[' * ', '×'],
['0×', '0'],
['1×', '1'],
['2×', '2'],
['3×', '3'],
['4×', '4'],
['5×', '5'],
['6×', '6'],
['7×', '7'],
['8×', '8'],
['9×', '9'],
[')×', ')'],
['×(', '('],
]
}
isConstant() {
return this.expr.indexOf("x") == -1
}
evaluate(x = 0) {
return this.calc.evaluate({
"x": x,
"pi": Math.PI,
"π": Math.PI,
"inf": Infinity,
"Infinity": Infinity,
"∞": Infinity,
"e": Math.E
})
}
toEditableString() {
return this.calc.toString()
}
toString() {
var str = this.calc.toString()
if(str[0] == "(") str = str.substr(1)
if(str[str.length - 1] == ")") str = str.substr(0, str.length - 1)
this.replacements.forEach(function(replacement){
str = str.replace(replacement[0], replacement[1])
})
return str
}
}
// Domains
class EmptySet {
constructor() {}
includes(x) { return false }
toString() { return "∅" }
static import(frm) { return new EmptySet() }
}
class Domain {
constructor(begin, end, openBegin, openEnd) {
if(typeof begin == 'number' || typeof begin == 'string') begin = new Expression(begin.toString())
this.begin = begin
if(typeof end == 'number' || typeof end == 'string') end = new Expression(end.toString())
this.end = end
this.openBegin = openBegin
this.openEnd = openEnd
this.displayName = (openBegin ? "]" : "[") + begin.toString() + ";" + end.toString() + (openEnd ? "[" : "]")
}
includes(x) {
return ((this.openBegin && x > this.begin.evaluate()) || (!this.openBegin && x >= this.begin.evaluate())) &&
((this.openEnd && x < this.end.evaluate()) || (!this.openEnd && x <= this.end.evaluate()))
}
toString() {
return this.displayName
}
static importFrom(frm) {
switch(frm.trim().toUpperCase()) {
case "R":
case "ℝ":
return Domain.R
break;
case "RE":
case "R*":
case "ℝ*":
return Domain.RE
break;
case "RP":
case "R+":
case "ℝ⁺":
return Domain.RP
break;
case "RM":
case "R-":
case "ℝ⁻":
return Domain.RM
break;
case "RPE":
case "REP":
case "R+*":
case "R*+":
case "ℝ*⁺":
case "ℝ⁺*":
return Domain.RPE
break;
case "RME":
case "REM":
case "R-*":
case "R*-":
case "ℝ⁻*":
case "ℝ*⁻":
return Domain.RME
break;
default:
var openBegin = frm.trim().charAt(0) == "]"
var openEnd = frm.trim().charAt(frm.length -1) == "["
var [begin, end] = frm.substr(1, frm.length-2).split(";")
console.log(frm, begin, end, openBegin, openEnd)
return new Domain(begin.trim(), end.trim(), openBegin, openEnd)
break;
}
}
}
Domain.R = new Domain(-Infinity,Infinity,true,true)
Domain.R.displayName = "ℝ"
Domain.RP = new Domain(0,Infinity,true,false)
Domain.RP.displayName = "ℝ⁺"
Domain.RM = new Domain(-Infinity,0,true,false)
Domain.RM.displayName = "ℝ⁻"
Domain.RPE = new Domain(0,Infinity,true,true)
Domain.RPE.displayName = "ℝ⁺*"
Domain.RME = new Domain(-Infinity,0,true,true)
Domain.RME.displayName = "ℝ⁻*"
class DomainSet {
constructor(values) {
var newVals = []
values.forEach(function(value){
newVals.push(new Expression(value.toString()))
})
this.values = newVals
}
includes(x) {
var xcomputed = new Expression(x.toString()).evaluate()
var found = false
this.values.forEach(function(value){
if(xcomputed == value.evaluate()) {
found = true
return
}
})
return found
}
toString() {
return "{" + this.values.join(";") + "}"
}
static importFrom(frm) {
return new DomainSet(frm.substr(1, frm.length-2).split(";"))
}
}
class UnionDomain {
constructor(dom1, dom2) {
this.dom1 = dom1
this.dom2 = dom2
}
includes(x) {
return this.dom1.includes(x) || this.dom2.includes(x)
}
toString() {
return this.dom1.toString() + " ∪ " + this.dom2.toString()
}
static importFrom(frm) {
var domains = frm.trim().split("∪")
if(domains.length == 1) domains = frm.trim().split("U") // Fallback
return new UnionDomain(parseDomain(domains[0].trim()), parseDomain(domains[1].trim()))
}
}
class IntersectionDomain {
constructor(dom1, dom2) {
this.dom1 = dom1
this.dom2 = dom2
}
includes(x) {
return this.dom1.includes(x) && this.dom2.includes(x)
}
toString() {
return this.dom1.toString() + " ∩ " + this.dom2.toString()
}
static importFrom(frm) {
var domains = frm.trim().split("∩")
return new IntersectionDomain(parseDomain(domains[0].trim()), parseDomain(domains[1].trim()))
}
}
class MinusDomain {
constructor(dom1, dom2) {
this.dom1 = dom1
this.dom2 = dom2
}
includes(x) {
return this.dom1.includes(x) && !this.dom2.includes(x)
}
toString() {
return this.dom1.toString() + "∖" + this.dom2.toString()
}
static importFrom(frm) {
var domains = frm.trim().split("∖")
if(domains.length == 1) domains = frm.trim().split("\\") // Fallback
return new MinusDomain(parseDomain(domains[0].trim()), parseDomain(domains[1].trim()))
}
}
Domain.RE = new MinusDomain("R", "{0}")
Domain.RE.displayName = "ℝ*"
function parseDomain(domain) {
if(domain.indexOf("U") >= 0 || domain.indexOf("∪") >= 0) return UnionDomain.importFrom(domain)
if(domain.indexOf("∩") >= 0) return IntersectionDomain.importFrom(domain)
if(domain.indexOf("∖") >= 0 || domain.indexOf("\\") >= 0) return MinusDomain.importFrom(domain)
if(domain.charAt(0) == "{" && domain.charAt(domain.length -1) == "}") return DomainSet.importFrom(domain)
if(domain.indexOf("]") >= 0 || domain.indexOf("]") >= 0) return Domain.importFrom(domain)
if(domain.toUpperCase().indexOf("R") >= 0 || domain.indexOf("ℝ") >= 0) return Domain.importFrom(domain)
return new EmptySet()
}

235
qml/js/objects.js Normal file
View file

@ -0,0 +1,235 @@
/**
* Logarithm Graph Creator - Create graphs with logarithm scales.
* Copyright (C) 2020 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/>.
*/
.pragma library
.import "utils.js" as Utils
.import "mathlib.js" as MathLib
function getNewName(allowedLetters, category) {
if(Object.keys(currentObjects).indexOf(category) == -1) return allowedLetters[0]
var newid = currentObjects[category].length
var letter = allowedLetters[newid % allowedLetters.length]
var num = Math.round((newid - (newid % allowedLetters.length)) / allowedLetters.length)
return letter + (num > 0 ? Utils.textsup(num) : '')
}
class DrawableObject {
static type(){return 'Unknown'}
static properties() {return {}}
constructor(name, visible = true, color = null, labelContent = 'name + value') {
if(color == null) color = this.getRandomColor()
this.type = 'Unknown'
this.name = name
this.visible = visible
this.color = color
this.labelContent = labelContent // "null", "name", "name + value"
this.requiredBy = []
}
getRandomColor() {
var x = '0123456789ABCDEF';
var color = '#';
for (var i = 0; i < 6; i++) {
color += x[Math.floor(Math.random() * 16)];
}
return color;
}
getReadableString() {
return `${this.name} = Unknown`
}
getLabel() {
switch(this.labelContent) {
case 'name':
return this.name
case 'name + value':
return this.getReadableString()
case 'null':
return ''
}
}
export() {
return [this.name, this.visible, this.color.toString(), this.labelContent]
}
draw(canvas, ctx) {}
}
class Point extends DrawableObject {
static type(){return 'Point'}
static properties() {return {
'x': 'Expression',
'y': 'Expression',
'labelPos': ['top', 'bottom', 'left', 'right'],
'pointStyle': ['dot', 'diagonal cross', 'vertical cross'],
}}
constructor(name = null, visible = true, color = null, labelContent = 'name + value',
x = 1, y = 0, labelPos = 'top', pointStyle = 'dot') {
if(name == null) name = getNewName('ABCDEFJKLMNOPQRSTUVW', 'Point')
super(name, visible, color, labelContent)
this.type = 'Point'
if(typeof x == 'number' || typeof x == 'string') x = new MathLib.Expression(x.toString())
this.x = x
if(typeof y == 'number' || typeof y == 'string') y = new MathLib.Expression(y.toString())
this.y = y
this.labelPos = labelPos
this.pointStyle = pointStyle
}
getReadableString() {
return `${this.name} = (${this.x}, ${this.y})`
}
export() {
return [this.name, this.visible, this.color.toString(), this.labelContent, this.x.toEditableString(), this.y.toEditableString(), this.labelPos, this.pointStyle]
}
draw(canvas, ctx) {
var [canvasX, canvasY] = [canvas.x2px(this.x.evaluate()), canvas.y2px(this.y.evaluate())]
var pointSize = 8
switch(this.pointStyle) {
case 'dot':
ctx.fillStyle = this.color
ctx.beginPath();
ctx.ellipse(canvasX-pointSize/2, canvasY-pointSize/2, pointSize, pointSize)
ctx.fill();
break;
case 'diagonal cross':
ctx.strokeStyle = this.color
canvas.drawLine(ctx, canvasX-pointSize/2, canvasY-pointSize/2, canvasX+pointSize/2, canvasY+pointSize/2)
canvas.drawLine(ctx, canvasX-pointSize/2, canvasY+pointSize/2, canvasX-pointSize/2, canvasY+pointSize/2)
break;
case 'vertical cross':
ctx.strokeStyle = this.color
canvas.drawLine(ctx, canvasX, canvasY-pointSize/2, canvasX, canvasY+pointSize/2)
canvas.drawLine(ctx, canvasX-pointSize/2, canvasY, canvasX+pointSize/2, canvasY)
break;
}
var text = this.getLabel()
ctx.font = "14px sans-serif"
var textSize = ctx.measureText(text).width
ctx.fillStyle = this.color
switch(this.labelPos) {
case 'top':
canvas.drawVisibleText(ctx, text, canvasX-textSize/2, canvasY-16)
break;
case 'bottom':
canvas.drawVisibleText(ctx, text, canvasX-textSize/2, canvasY+16)
break;
case 'left':
canvas.drawVisibleText(ctx, text, canvasX-textSize-10, canvasY+4)
break;
case 'right':
canvas.drawVisibleText(ctx, text, canvasX+10, canvasY+4)
break;
}
}
}
class Function extends DrawableObject {
static type(){return 'Function'}
static properties() {return {
'expression': 'Expression',
'inDomain': 'Domain',
'outDomain': 'Domain',
'labelPos': ['above', 'below'],
'displayMode': ['application', 'function'],
'labelX': 'number'
}}
constructor(name = null, visible = true, color = null, labelContent = 'name + value',
expression = 'x', inDomain = 'RPE', outDomain = 'R', displayMode = 'application', labelPos = 'above', labelX = 1) {
if(name == null) name = getNewName('fghjqlmnopqrstuvwabcde', 'Function')
super(name, visible, color, labelContent)
if(typeof expression == 'number' || typeof expression == 'string') expression = new MathLib.Expression(expression.toString())
this.expression = expression
if(typeof inDomain == 'string') inDomain = MathLib.parseDomain(inDomain)
this.inDomain = inDomain
if(typeof outDomain == 'string') outDomain = MathLib.parseDomain(outDomain)
this.outDomain = outDomain
this.displayMode = displayMode
this.labelPos = labelPos
this.labelX = labelX
}
getReadableString() {
if(this.displayMode == 'application') {
return `${this.name}: ${this.inDomain} ⸺˃ ${this.outDomain}\n x ⸺˃ ${this.expression.toString()}`
} else {
return `${this.name}(x) = ${this.expression.toString()}`
}
}
export() {
return [this.name, this.visible, this.color.toString(), this.labelContent,
this.expression.toEditableString(), this.inDomain.toString(), this.outDomain.toString(),
this.displayMode, this.labelPos, this.labelX]
}
draw(canvas, ctx) {
ctx.strokeStyle = this.color
ctx.fillStyle = this.color
// Drawing small traits every 2px
var pxprecision = 2
var previousX = canvas.px2x(0)
var previousY = this.expression.evaluate(previousX)
for(var px = pxprecision; px < canvas.canvasSize.width; px += pxprecision) {
var currentX = canvas.px2x(px)
var currentY = this.expression.evaluate(currentX)
if(this.inDomain.includes(currentX) && this.inDomain.includes(previousX) &&
this.outDomain.includes(currentY) && this.outDomain.includes(previousY) &&
Math.abs(previousY-currentY)<100) { // 100 per 2px is a lot (probably inf to inf issue)
canvas.drawLine(ctx, canvas.x2px(previousX), canvas.y2px(previousY), canvas.x2px(currentX), canvas.y2px(currentY))
}
previousX = currentX
previousY = currentY
}
// Label
var text = this.getLabel()
ctx.font = "14px sans-serif"
var textSize = canvas.measureText(ctx, text)
ctx.fillStyle = this.color
var posX = canvas.x2px(this.labelX)
var posY = canvas.y2px(this.expression.evaluate(this.labelX))
switch(this.labelPos) {
case 'above':
canvas.drawVisibleText(ctx, text, posX-textSize.width/2, posY-textSize.height)
break;
case 'below':
canvas.drawVisibleText(ctx, text, posX-textSize.width/2, posY+textSize.height)
break;
}
}
}
const drawableTypes = {
'Point': Point,
'Function': Function
}
var currentObjects = {}

118
qml/js/utils.js Normal file
View file

@ -0,0 +1,118 @@
/**
* Logarithm Graph Creator - Create graphs with logarithm scales.
* Copyright (C) 2020 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/>.
*/
var powerpos = {
"-": "⁻",
"0": "⁰",
"1": "¹",
"2": "²",
"3": "³",
"4": "⁴",
"5": "⁵",
"6": "⁶",
"7": "⁷",
"8": "⁸",
"9": "⁹",
"+": "⁺",
"=": "⁼",
"a": "ᵃ",
"b": "ᵇ",
"c": "ᶜ",
"d": "ᵈ",
"e": "ᵉ",
"f": "ᶠ",
"g": "ᵍ",
"h": "ʰ",
"i": "ⁱ",
"j": "ʲ",
"k": "ᵏ",
"l": "ˡ",
"m": "ᵐ",
"n": "ⁿ",
"o": "ᵒ",
"p": "ᵖ",
"r": "ʳ",
"s": "ˢ",
"t": "ᵗ",
"u": "ᵘ",
"v": "ᵛ",
"w": "ʷ",
"x": "ˣ",
"y": "ʸ",
"z": "ᶻ",
}
var indicepos = {
"-": "₋",
"0": "₀",
"1": "₁",
"2": "₂",
"3": "₃",
"4": "₄",
"5": "₅",
"6": "₆",
"7": "₇",
"8": "₈",
"9": "₉",
"+": "₊",
"=": "₌",
"a": "ₐ",
"e": "ₑ",
"h": "ₕ",
"i": "ᵢ",
"j": "ⱼ",
"k": "ₖ",
"l": "ₗ",
"m": "ₘ",
"n": "ₙ",
"o": "ₒ",
"p": "ₚ",
"r": "ᵣ",
"s": "ₛ",
"t": "ₜ",
"u": "ᵤ",
"v": "ᵥ",
"x": "ₓ",
}
// Put a text in sup position
function textsup(text) {
var ret = ""
text = text.toString()
for (var i = 0; i < text.length; i++) {
if(Object.keys(powerpos).indexOf(text[i]) >= 0) {
ret += powerpos[text[i]]
} else {
ret += text[i]
}
}
return ret
}
// Put a text in sub position
function textsub(text) {
var ret = ""
text = text.toString()
for (var i = 0; i < text.length; i++) {
if(Object.keys(indicepos).indexOf(text[i]) >= 0) {
ret += indicepos[text[i]]
} else {
ret += text[i]
}
}
return ret
}