MeasurementItemEditor.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
    height:     visible ? (editorColumn.height + (_margin * 2)) : 0
    width:      availableWidth
    color:      qgcPal.windowShadeDark
    radius:     _radius

    // The following properties must be available up the hierarchy chain
    //property real   availableWidth    ///< Width for control
    //property var    missionItem       ///< Mission Item for editor

    property real   _margin:            ScreenTools.defaultFontPixelWidth / 2

    property var    _generator: 	  	missionItem.generator
    property var 	_generatorEditor: 	undefined

    QGCPalette { id: qgcPal; colorGroupEnabled: true }

    Component.onCompleted: {
        _addGeneratorEditor()
    }
    Component.onDestruction: {
        _destroyGeneratorEditor()
    }

    on_GeneratorChanged: {
        _destroyGeneratorEditor()
        _addGeneratorEditor()
    }

    Column {
        id:                 editorColumn
        anchors.margins:    _margin
        anchors.top:        parent.top
        anchors.left:       parent.left
        anchors.right:      parent.right
        spacing:            _margin

        SectionHeader {
            id:     generalHeader
            text:   qsTr("General")
        }


        GridLayout {
            id: generalGrid
            anchors.left:   parent.left
            anchors.right:  parent.right
            columnSpacing:  _margin
            rowSpacing:     _margin
            columns:        2
            visible:        generalHeader.checked

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

            QGCCheckBox {
                id:                 relAlt
                text:               qsTr("Relative altitude")
                checked:            missionItem.cameraCalc.distanceToSurfaceRelative
                enabled:            missionItem.cameraCalc.isManualCamera && !missionItem.followTerrain
                visible:            QGroundControl.corePlugin.options.showMissionAbsoluteAltitude || (!missionItem.cameraCalc.distanceToSurfaceRelative && !missionItem.followTerrain)
                onClicked:          missionItem.cameraCalc.distanceToSurfaceRelative = checked
                Layout.fillWidth:   true
                Layout.columnSpan:  2

                Connections {
                    target: missionItem.cameraCalc
                    onDistanceToSurfaceRelativeChanged: relAlt.checked = missionItem.cameraCalc.distanceToSurfaceRelative
                }
            }

            QGCLabel {
                text: qsTr("Generator Type")
                Layout.columnSpan: 2
            }

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

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

                onActivated: {
                    missionItem.switchToGenerator(index)
                }
            }

            QGCLabel {
                text: qsTr("Variant")
                Layout.columnSpan: 2
            }

            GridLayout{
                Layout.columnSpan: 2

                columnSpacing:  _margin
                rowSpacing:     _margin
                columns:        6

                Repeater{
                    id: variantRepeater

                    property var fact: missionItem.variant
                    property int variant: fact.value
                    property var names: missionItem.variantNames
                    property int len: missionItem.variantNames.length

                    model: len
                    delegate: QGCRadioButton {
                        checked: index === variantRepeater.variant
                        text:  variantRepeater.names[index] ? variantRepeater.names[index]: ""

                        onCheckedChanged: {
                            if (checked){
                                missionItem.variant.value = index
                            }
                            checked = Qt.binding(function(){ return index === variantRepeater.variant})
                        }
                    }
                }
            }
        }

        // Generator Editor
        SectionHeader {
            id:     transectsHeader
            text:   qsTr("Generator")
        }

        Column{
            id:generatorEditorParent
            visible: transectsHeader.checked
        }

        Column{
            anchors.left:   parent.left
            anchors.right:  parent.right
            spacing:        _margin

            BusyIndicator{
                id: indicator
                anchors.horizontalCenter: parent.horizontalCenter
                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
                }
            }
        }
    } // Column

    function _addGeneratorEditor(){
        if (_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,
                            })
            }
        }
    }

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