EditorPluginBase.qml

Go to the documentation of this file.

import QtQuick 2.7
import QtQuick.Controls 1.4
import QtQuick.Layouts 1.1
import QtGraphicalEffects 1.0
import QtQuick.Dialogs 1.2
import Helpers 1.0
import Utils 1.0

Item {

    property var filenameHelper: FilenameHelper

    property var targetModel
    property var commandCallback
    property var editorDescription
    property var dialogManager

    
    signal execute()

    
    property var getPropertyDescriptions: function(component) {

        if(!component) {
            console.log("Component is null");
            console.trace()
        }
        else if (!component.base_properties) {
            console.log("Component dosn't contains a property set");
            console.trace()
        }
        else if (!component.base_properties.property_set_description) {
            console.log("Component dosn't contains a property set description");
            console.trace()
        }
        else {
            return component.base_properties.property_set_description.property_descriptions;
        }
    }

    property var getProperties: function(component) {

        if(!component) {
            console.log("Component is null");
            console.trace()
        }
        else if (!component.base_properties) {
            console.log("Component dosn't contains a property set");
            console.trace()
        }
        else {
            return component.base_properties.properties;
        }
    }

    function findService(name) {
        var result = null
        Utils.each(modelmanager.system.services, function(service) {
            if(service.name === name) {
                result = service
            }
        })
        return result;
    }

    function findProperty(component, name) {
        var properties = getProperties(component)
        var result = null

        Utils.each(properties, function(prop) {
            if (prop.name === name) {
                result = prop
            }
        })
        return result
    }

    function findPropertyDescription(component, name) {
        var propertyDescs = getPropertyDescriptions(component)
        var result = null

        Utils.each(propertyDescs, function(prop) {
            if (prop.name === name) {
                result = prop
            }
        })
        return result
    }

    function createProperty(component, name, value, type, link) {
        var description = findPropertyDescription(component, name)

        if (link === undefined) {
            link = ""
        }

        if(!description) {   
            if (type !== undefined) {
                commandCallback(function(options) {
                    return component.base_properties.createDynamicProperty(name, value, type, link, options)
                })
                return
            }
            else {
                console.error("Could not find Plugindescription for property " + name)
            }
        }

        commandCallback(function(options) {            
            return component.base_properties.createProperty(description, value, link, options)
        })
    }

    function setProperty(component, name, value) {
        console.assert(commandCallback, "Command callback not found")
        console.assert(component, "Component not set")

        var property = findProperty(component, name)
        if(property) {
            commandCallback(function(options) {
                return property.changeValue(value, options)
            })
        }
        else {
            createProperty(component, name, value)
        }
    }

    function getPropertyValue(component, name) {
        console.assert(component, "Component not set")

        const property = findProperty(component, name)
        if(property) {
            return property.value
        }

        const description = findPropertyDescription(component, name)
        if(description) {
            return description.value
        }
        
        console.error("Property not found")
        return ""
    }

    function findInputPin(name) {
        let result = null
        Utils.each(targetModel.input_pins, function(pin) {
            if (pin.name === name) {
                result = pin
            }
        })
        return result
    }

    function createInputPin(name) {
        const pin = findInputPin(name)
        if(!pin) {
            commandCallback(function(options) {
                return targetModel.addInputPin(name, options)
            })
        }
    }

    function listInputPins() {
        let names = []
        Utils.each(targetModel.input_pins, function(pin) {
            names.push(pin.name)
        })
        return names
    }

    function removeInputPin(pin) {
        commandCallback(function(options) {
            return targetModel.removeInputPin(pin, options)
        })
    }

    function findOutputPin(name) {
        let result = null
        Utils.each(targetModel.output_pins, function(pin) {
            if (pin.name === name) {
                result = pin
            }
        })
        return result
    }

    function createOutputPin(name) {
        const pin = findOutputPin(name)
        if(!pin) {
            commandCallback(function(options) {
                return targetModel.addOutputPin(name, options)
            })
        }
    }

    function listOutputPins() {
        let names = []
        Utils.each(targetModel.output_pins, function(pin) {
            names.push(pin.name)
        })
        return names
    }

    function removeOutputPin(pin) {
        commandCallback(function(options) {
            return targetModel.removeOutputPin(pin, options)
        })
    }

    function listRunner()
    {
        let names = []
        Utils.each(targetModel.runners, function(runner) {
            names.push(runner.name)
        })
        return names
    }

    function findRunner(runnerName) {
        let result = null
        Utils.each(targetModel.runners, function(runner) {
            if (runner.name === runnerName) {
                result = runner
            }
        })
        return result
    }

    function createRunner(name) {
        const runner = findRunner(name)
        if(!runner) {
            commandCallback(function(options) {
                return targetModel.addRunner(name, options)
            })
        }
    }

    function removeRunner(runner) {
        commandCallback(function(options) {
            return targetModel.removeRunner(runner, options)
        })
    }

    function resolveAndGetAbsoluteUrl(path, basePath) {
        if(!basePath){
            basePath = "."
        }
        return editorDescription.GetAbsoluteUrl(path, basePath)
    }

    function getPropertyFile() {
        return targetModel.base_properties.getPropertyFileUrl()
    }

    function launch(command, args, workingDirectory) {
        return editorDescription.Launch(command, args, workingDirectory)
    }

    function parseJsonResult(result)
    {
        console.log("result: " + result)
        var regex = /json_result:([\s\S]*):end/i

        var match = regex.exec(result);
        if(match.length < 2) {
            throw "Couldn't find Json string"
        }

        var json_result = match[1]
        json_result = json_result.replace(/(\r\n|\n|\r)/gm,"")

        console.log("json_result: " + json_result)

        return JSON.parse(json_result)
    }

    function forEach(array, callback) {
        Utils.each(array, callback)
    }

    function removeFromArray(array, callback) {
        var newArray = []
        forEach(array, function(item) {
           if(!callback(item))
           {
               newArray.push(item)
           }
        });
        return newArray
    }

    function contains(array, value, compare_callback) {
        var found = false;
        forEach(array, function(item) {
            if(compare_callback && compare_callback(item, value)) {
                found = true
            }
            else if(item === value) {
                found = true
            }
        })
        return found;
    }

    Component.onCompleted: {
        execute()
    }
}