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()
    }
}