ParameterEditor.qml

import QtQuick 2.3
import QtQuick.Controls 1.2
import QtQuick.Controls.Styles 1.4
import QtQuick.Dialogs 1.2
import QtQuick.Extras 1.4
import QtQuick.Layouts 1.2

import QGroundControl 1.0
import QGroundControl.ScreenTools 1.0
import QGroundControl.Vehicle 1.0
import QGroundControl.Controls 1.0
import QGroundControl.FactSystem 1.0
import QGroundControl.FactControls 1.0
import QGroundControl.Palette 1.0
import QGroundControl.FlightMap 1.0

Rectangle {
    id: _root

    width: mainGrid.width
    height: mainGrid.height
    color: qgcPal.windowShadeDark

    property bool checked: true
    property var missionItem: undefined
    property int availableWidth: 300

    property real _margin: ScreenTools.defaultFontPixelWidth / 2
    property var _generator: missionItem.generator
    property var _generatorEditor: undefined

    Component.onCompleted: {
        console.assert(missionItem !== undefined,
                       "please set the missionItem property")
        _addGeneratorEditor()
    }

    Component.onDestruction: {
        _destroyGeneratorEditor()
    }

    on_GeneratorChanged: {
        _destroyGeneratorEditor()
        _addGeneratorEditor()
    }

    GridLayout {
        id: mainGrid

        columnSpacing: _margin
        rowSpacing: _margin
        columns: 2
        width: availableWidth

        SectionHeader {
            id: generalHeader
            Layout.fillWidth: true
            Layout.columnSpan: parent.columns
            Layout.maximumWidth: parent.width
            text: qsTr("General")
        }

        GridLayout {
            id: generalGrid
            Layout.fillWidth: true
            Layout.columnSpan: parent.columns
            Layout.maximumWidth: parent.width
            columnSpacing: _margin
            rowSpacing: _margin
            columns: 2
            visible: generalHeader.checked

            QGCLabel {
                text: qsTr("Altitude")
                Layout.fillWidth: true
            }
            FactTextField {
                fact: missionItem.altitude
                Layout.fillWidth: true
            }

            QGCLabel {
                text: qsTr("Variant")
                Layout.columnSpan: parent.columns
                visible: variantRepeater.len > 0
            }

            ExclusiveGroup {
                id: variantGroup
            }

            GridLayout {
                Layout.columnSpan: parent.columns
                Layout.maximumWidth: parent.width
                columns: 3

                columnSpacing: _margin
                rowSpacing: _margin

                Repeater {
                    id: variantRepeater

                    property var names: missionItem.variantNames
                    property int len: missionItem.variantNames.length

                    model: len
                    delegate: QGCRadioButton {
                        checked: index === variantIndex
                        text: variantRepeater.names[index] ? variantRepeater.names[index] : ""
                        Layout.fillWidth: true

                        property int variantIndex: missionItem.variantIndex.value

                        onVariantIndexChanged: {
                            if (variantIndex === index) {
                                checked = true
                            }
                        }

                        onCheckedChanged: {
                            if (checked && variantIndex !== index) {
                                missionItem.variantIndex.value = index
                            }
                        }
                    }
                } // variant repeater
            } // variant grid
        } // general grid

        // Generator Editor
        SectionHeader {
            id: generatorHeader
            Layout.fillWidth: true
            Layout.columnSpan: parent.columns
            text: qsTr("Generator")
        }

        GridLayout {
            Layout.fillWidth: true
            columnSpacing: _margin
            Layout.maximumWidth: parent.width
            Layout.columnSpan: parent.columns
            rowSpacing: _margin
            columns: 2
            visible: generatorHeader.checked

            QGCComboBox {
                property var names: missionItem.generatorNameList
                property int length: names.length

                enabled: _root.checked
                anchors.margins: ScreenTools.defaultFontPixelWidth
                currentIndex: missionItem.generatorIndex
                Layout.columnSpan: 2
                model: missionItem.generatorNameList

                onActivated: {
                    if (index != -1) {
                        missionItem.switchToGenerator(index)
                    }
                }
            }
        }

        ColumnLayout {
            id: generatorEditorParent
            Layout.fillWidth: true
            Layout.columnSpan: parent.columns
            Layout.maximumWidth: parent.width
            visible: generatorHeader.checked
        }

        QGCButton {
            text: qsTr("Reverse")
            onClicked: missionItem.reverseRoute()
            Layout.columnSpan: 2
            Layout.fillWidth: true
        }

        // bussy indicator
        ColumnLayout {
            Layout.fillWidth: true
            spacing: _margin
            Layout.maximumWidth: parent.width

            BusyIndicator {
                id: indicator

                property bool calculating: missionItem.calculating

                running: calculating
                visible: calculating || timer.running

                onCalculatingChanged: {
                    if (!calculating) {
                        // defer hiding
                        timer.restart()
                    }
                }

                Timer {
                    id: timer
                    interval: 1000
                    repeat: false
                    running: false
                }
            }
        } // indicator column
    } // GridLayout

    function _addGeneratorEditor() {
        if (_generator && _generator.editorQml && !_generatorEditor) {
            var component = Qt.createComponent(_generator.editorQml)
            if (component.status === Component.Error) {
                console.log("Error loading Qml: ", _generator.editorQml,
                            component.errorString())
            } else {
                _generatorEditor = component.createObject(
                            generatorEditorParent, {
                                "generator": _root._generator,
                                "availableWidth": generatorEditorParent.width
                            })
            }
        }
    }

    function _destroyGeneratorEditor() {
        if (_generatorEditor) {
            _generatorEditor.destroy()
            _generatorEditor = undefined
        }
    }
} // Rectangle