PlanView.qml

Go to the documentation of this file.

import QtQuick
import QtQuick.Controls
import QtQuick.Dialogs
import QtLocation
import QtPositioning
import QtQuick.Layouts
import QtQuick.Window
 
import QGroundControl
import QGroundControl.FlightMap
import QGroundControl.Controls
import QGroundControl.FactControls
import QGroundControl.FlyView
 
Item {
    id: _root
 
    readonly property int   _decimalPlaces: 8
    readonly property real  _margin: ScreenTools.defaultFontPixelHeight * 0.5
    readonly property real  _toolsMargin: ScreenTools.defaultFontPixelWidth * 0.75
    readonly property real  _rightPanelWidth: Math.min(width / 3, ScreenTools.defaultFontPixelWidth * 30)
 
    property var    _planMasterController: planMasterController
    property var    _missionController: _planMasterController.missionController
    property var    _geoFenceController: _planMasterController.geoFenceController
    property var    _rallyPointController: _planMasterController.rallyPointController
    property var    _visualItems: _missionController.visualItems
    property bool   _singleComplexItem: _missionController.complexMissionItemNames.length === 1
    property int    _editingLayer: _layerMission
    property var    _appSettings: QGroundControl.settingsManager.appSettings
    property var    _planViewSettings: QGroundControl.settingsManager.planViewSettings
    property bool   _promptForPlanUsageShowing: false
    property bool   _addROIOnClick: false
    property bool   _addWaypointOnClick: false
 
    readonly property int _layerMission: 1
    readonly property int _layerFence: 2
    readonly property int _layerRally: 3
 
    onVisibleChanged: {
        if(visible) {
            editorMap.zoomLevel = QGroundControl.flightMapZoom
            editorMap.center    = QGroundControl.flightMapPosition
        }
    }
 
    function mapCenter() {
        var coordinate = editorMap.center
        coordinate.latitude  = coordinate.latitude.toFixed(_decimalPlaces)
        coordinate.longitude = coordinate.longitude.toFixed(_decimalPlaces)
        coordinate.altitude  = coordinate.altitude.toFixed(_decimalPlaces)
        return coordinate
    }
 
    MapFitFunctions {
        id: mapFitFunctions  // The name for this id cannot be changed without breaking references outside of this code. Beware!
        map: editorMap
        usePlannedHomePosition: true
        planMasterController: _planMasterController
    }
 
    PlanMasterController {
        id: planMasterController
        flyView: false
 
        Component.onCompleted: {
            _planMasterController.start()
            _missionController.setCurrentPlanViewSeqNum(0, true)
        }
 
        onPromptForPlanUsageOnVehicleChange: {
            if (!_promptForPlanUsageShowing) {
                _promptForPlanUsageShowing = true
                promptForPlanUsageOnVehicleChangePopupFactory.open()
            }
        }
 
        function waitingOnIncompleteDataMessage(save) {
            var saveOrUpload = save ? qsTr("Save") : qsTr("Upload")
            QGroundControl.showMessageDialog(_root, qsTr("Unable to %1").arg(saveOrUpload), qsTr("Plan has incomplete items. Complete all items and %1 again.").arg(saveOrUpload))
        }
 
        function waitingOnTerrainDataMessage(save) {
            var saveOrUpload = save ? qsTr("Save") : qsTr("Upload")
            QGroundControl.showMessageDialog(_root, qsTr("Unable to %1").arg(saveOrUpload), qsTr("Plan is waiting on terrain data from server for correct altitude values."))
        }
 
        function checkReadyForSaveUpload(save) {
            if (readyForSaveState() == VisualMissionItem.NotReadyForSaveData) {
                waitingOnIncompleteDataMessage(save)
                return false
            } else if (readyForSaveState() == VisualMissionItem.NotReadyForSaveTerrain) {
                waitingOnTerrainDataMessage(save)
                return false
            }
            return true
        }
 
        function upload() {
            if (!checkReadyForSaveUpload(false /* save */)) {
                return
            }
            switch (_missionController.sendToVehiclePreCheck()) {
                case MissionController.SendToVehiclePreCheckStateOk: sendToVehicle()
                    break
                case MissionController.SendToVehiclePreCheckStateActiveMission: QGroundControl.showMessageDialog(_root, qsTr("Send To Vehicle"), qsTr("Current mission must be paused prior to uploading a new Plan"))
                    break
                case MissionController.SendToVehiclePreCheckStateFirwmareVehicleMismatch: QGroundControl.showMessageDialog(_root, qsTr("Plan Upload"),
                                                 qsTr("This Plan was created for a different firmware or vehicle type than the firmware/vehicle type of vehicle you are uploading to. " +
                                                      "This can lead to errors or incorrect behavior. " +
                                                      "It is recommended to recreate the Plan for the correct firmware/vehicle type.\n\n" +
                                                      "Click 'Ok' to upload the Plan anyway."),
                                                 Dialog.Ok | Dialog.Cancel,
                                                 function() { _planMasterController.sendToVehicle() })
                    break
            }
        }
 
        function loadFromSelectedFile() {
            fileDialog.title =          qsTr("Select Plan File")
            fileDialog.planFiles =      true
            fileDialog.nameFilters =    _planMasterController.loadNameFilters
            fileDialog.openForLoad()
        }
 
        function saveToSelectedFile() {
            if (!checkReadyForSaveUpload(true /* save */)) {
                return
            }
            fileDialog.title =          qsTr("Save Plan")
            fileDialog.planFiles =      true
            fileDialog.nameFilters =    _planMasterController.saveNameFilters
            fileDialog.openForSave()
        }
 
        function fitViewportToItems() {
            mapFitFunctions.fitMapViewportToMissionItems()
        }
 
        function saveKmlToSelectedFile() {
            if (!checkReadyForSaveUpload(true /* save */)) {
                return
            }
            fileDialog.title =          qsTr("Save KML")
            fileDialog.planFiles =      false
            fileDialog.nameFilters =    ShapeFileHelper.fileDialogKMLFilters
            fileDialog.openForSave()
        }
    }
 
    Connections {
        target: _missionController
 
        function onNewItemsFromVehicle() {
            if (_visualItems && _visualItems.count !== 1) {
                mapFitFunctions.fitMapViewportToMissionItems()
            }
            _missionController.setCurrentPlanViewSeqNum(0, true)
        }
    }
 
    function insertSimpleItemAfterCurrent(coordinate) {
        var nextIndex = _missionController.currentPlanViewVIIndex + 1
        _missionController.insertSimpleMissionItem(coordinate, nextIndex, true /* makeCurrentItem */)
    }
 
    function insertROIAfterCurrent(coordinate) {
        var nextIndex = _missionController.currentPlanViewVIIndex + 1
        _missionController.insertROIMissionItem(coordinate, nextIndex, true /* makeCurrentItem */)
    }
 
    function insertCancelROIAfterCurrent() {
        var nextIndex = _missionController.currentPlanViewVIIndex + 1
        _missionController.insertCancelROIMissionItem(nextIndex, true /* makeCurrentItem */)
    }
 
    function insertComplexItemAfterCurrent(complexItemName) {
        var nextIndex = _missionController.currentPlanViewVIIndex + 1
        _missionController.insertComplexMissionItem(complexItemName, mapCenter(), nextIndex, true /* makeCurrentItem */)
    }
 
    function insertTakeoffItemAfterCurrent() {
        var nextIndex = _missionController.currentPlanViewVIIndex + 1
        _missionController.insertTakeoffItem(mapCenter(), nextIndex, true /* makeCurrentItem */)
    }
 
    function insertLandItemAfterCurrent() {
        var nextIndex = _missionController.currentPlanViewVIIndex + 1
        _missionController.insertLandItem(mapCenter(), nextIndex, true /* makeCurrentItem */)
    }
 
    QGCFileDialog {
        id: fileDialog
        folder: _appSettings ? _appSettings.missionSavePath : ""
 
        property bool planFiles: true    ///< true: working with plan files, false: working with kml file
 
        onAcceptedForSave: (file) => {
            if (planFiles) {
                if (_planMasterController.saveToFile(file)) {
                    close()
                }
            } else {
                _planMasterController.saveToKml(file)
                close()
            }
        }
 
        onAcceptedForLoad: (file) => {
            _planMasterController.loadFromFile(file)
            _planMasterController.fitViewportToItems()
            _missionController.setCurrentPlanViewSeqNum(0, true)
            close()
        }
    }
 
    PlanViewToolBar {
        id: planToolBar
        planMasterController: _planMasterController
        showRallyPointsHelp: _editingLayer === _layerRally
    }
 
    Item {
        id: mainPlanViewArea
        anchors.left: parent.left
        anchors.right: parent.right
        anchors.top: planToolBar.bottom
        anchors.bottom: parent.bottom
 
        FlightMap {
            id: editorMap
            anchors.fill: parent
            mapName: "MissionEditor"
            allowGCSLocationCenter: true
            allowVehicleLocationCenter: true
            planView: true
 
            zoomLevel: QGroundControl.flightMapZoom
            center: QGroundControl.flightMapPosition
 
            // This is the center rectangle of the map which is not obscured by tools
            property rect centerViewport: Qt.rect(_leftToolWidth + _margin,  _margin, editorMap.width - _leftToolWidth - _rightToolWidth - (_margin * 2), (missionStatus.visible ? missionStatus.y : height - _margin) - _margin)
 
            property real _leftToolWidth: toolStrip.x + toolStrip.width
            property real _rightToolWidth: rightPanel.width + rightPanel.anchors.rightMargin
            property real _nonInteractiveOpacity: 0.5
 
            // Initial map position duplicates Fly view position
            Component.onCompleted: editorMap.center = QGroundControl.flightMapPosition
 
            onZoomLevelChanged: {
                QGroundControl.flightMapZoom = editorMap.zoomLevel
            }
            onCenterChanged: {
                QGroundControl.flightMapPosition = editorMap.center
            }
 
            onMapClicked: (mouse) => {
                // Take focus to close any previous editing
                editorMap.focus = true
 
                // Collapse layer switcher on any map click
                layerSwitcher.expanded = false
                collapseTimer.stop()
 
                if (!mainWindow.allowViewSwitch()) {
                    return
                }
                var coordinate = editorMap.toCoordinate(Qt.point(mouse.x, mouse.y), false /* clipToViewPort */)
                coordinate.latitude = coordinate.latitude.toFixed(_decimalPlaces)
                coordinate.longitude = coordinate.longitude.toFixed(_decimalPlaces)
                coordinate.altitude = coordinate.altitude.toFixed(_decimalPlaces)
 
                switch (_editingLayer) {
                case _layerMission:
                    if (_addROIOnClick) {
                        _addROIOnClick = false
                        if (_missionController.isROIActive) {
                            var pos = Qt.point(mouse.x, mouse.y)
                            // For some strange reason using mainWindow in mapToItem doesn't work, so we use globals.parent instead which also gets us mainWindow
                            pos = editorMap.mapToItem(globals.parent, pos)
                            var dropPanel = insertOrCancelROIDropPanelComponent.createObject(mainWindow, { mapClickCoord: coordinate, clickRect: Qt.rect(pos.x, pos.y, 0, 0) })
                            dropPanel.open()
                        } else {
                            insertROIAfterCurrent(coordinate)
                        }
                    } else if (_addWaypointOnClick) {
                        insertSimpleItemAfterCurrent(coordinate)
                    }
                    break
                case _layerRally:
                    if (_rallyPointController.supported) {
                        _rallyPointController.addPoint(coordinate)
                    }
                    break
                }
            }
 
            // Add the mission item visuals to the map
            Repeater {
                model: _missionController.visualItems
                delegate: MissionItemMapVisual {
                    map: editorMap
                    opacity: _editingLayer == _layerMission ? 1 : editorMap._nonInteractiveOpacity
                    interactive: _editingLayer == _layerMission
                    vehicle: _planMasterController.controllerVehicle
                    onClicked: (sequenceNumber) => { _missionController.setCurrentPlanViewSeqNum(sequenceNumber, false) }
                }
            }
 
            // Add lines between waypoints
            MissionLineView {
                showSpecialVisual: _missionController.isROIBeginCurrentItem
                model: _missionController.simpleFlightPathSegments
                opacity: _editingLayer == _layerMission ? 1 : editorMap._nonInteractiveOpacity
            }
 
            // Direction arrows in waypoint lines
            MapItemView {
                model: _editingLayer == _layerMission ? _missionController.directionArrows : undefined
 
                delegate: MapLineArrow {
                    fromCoord: object ? object.coordinate1 : undefined
                    toCoord: object ? object.coordinate2 : undefined
                    arrowPosition: 3
                    z: QGroundControl.zOrderWaypointLines + 1
                }
            }
 
            // UI for splitting the current segment
            MapQuickItem {
                id: splitSegmentItem
                anchorPoint.x: sourceItem.width / 2
                anchorPoint.y: sourceItem.height / 2
                z: QGroundControl.zOrderWaypointLines + 1
                visible: _editingLayer == _layerMission
 
                sourceItem: SplitIndicator {
                    onClicked: _missionController.insertSimpleMissionItem(splitSegmentItem.coordinate,
                                                                           _missionController.currentPlanViewVIIndex,
                                                                           true /* makeCurrentItem */)
                }
 
                function _updateSplitCoord() {
                    if (_missionController.splitSegment) {
                        var distance = _missionController.splitSegment.coordinate1.distanceTo(_missionController.splitSegment.coordinate2)
                        var azimuth = _missionController.splitSegment.coordinate1.azimuthTo(_missionController.splitSegment.coordinate2)
                        splitSegmentItem.coordinate = _missionController.splitSegment.coordinate1.atDistanceAndAzimuth(distance / 2, azimuth)
                    } else {
                        coordinate = QtPositioning.coordinate()
                    }
                }
 
                Connections {
                    target: _missionController
                    function onSplitSegmentChanged()  { splitSegmentItem._updateSplitCoord() }
                }
 
                Connections {
                    target: _missionController.splitSegment
                    function onCoordinate1Changed()   { splitSegmentItem._updateSplitCoord() }
                    function onCoordinate2Changed()   { splitSegmentItem._updateSplitCoord() }
                }
            }
 
            // Add the vehicles to the map
            MapItemView {
                model: QGroundControl.multiVehicleManager.vehicles
                delegate: VehicleMapItem {
                    vehicle: object
                    coordinate: object.coordinate
                    map: editorMap
                    size: ScreenTools.defaultFontPixelHeight * 3
                    z: QGroundControl.zOrderMapItems - 1
                }
            }
 
            GeoFenceMapVisuals {
                map: editorMap
                myGeoFenceController: _geoFenceController
                interactive: _editingLayer == _layerFence
                homePosition: _missionController.plannedHomePosition
                planView: true
                opacity: _editingLayer != _layerFence ? editorMap._nonInteractiveOpacity : 1
            }
 
            RallyPointMapVisuals {
                map: editorMap
                myRallyPointController: _rallyPointController
                interactive: _editingLayer == _layerRally
                planView: true
                opacity: _editingLayer != _layerRally ? editorMap._nonInteractiveOpacity : 1
            }
 
        }
 
        //-----------------------------------------------------------
        // Left tool strip
        ToolStrip {
            id: toolStrip
            anchors.margins: _toolsMargin
            anchors.left: parent.left
            anchors.top: parent.top
            z: QGroundControl.zOrderWidgets
            maxHeight: parent.height - toolStrip.y
            visible: _editingLayer == _layerMission
 
            property bool _isMissionLayer: _editingLayer == _layerMission
 
            Binding {
                target: waypointButton
                property: "checked"
                value: _addWaypointOnClick
            }
 
            Binding {
                target: roiButton
                property: "checked"
                value: _addROIOnClick
            }
 
            ToolStripActionList {
                id: toolStripActionList
                model: [
                    ToolStripAction {
                        text: qsTr("Takeoff")
                        iconSource: "/res/takeoff.svg"
                        enabled: _missionController.isInsertTakeoffValid
                        visible: toolStrip._isMissionLayer && !_planMasterController.controllerVehicle.rover
                        onTriggered: {
                            insertTakeoffItemAfterCurrent()
                        }
                    },
                    ToolStripAction {
                        text: _singleComplexItem ? _missionController.complexMissionItemNames[0] : qsTr("Pattern")
                        iconSource: "/qmlimages/MapDrawShape.svg"
                        enabled: _missionController.flyThroughCommandsAllowed
                        visible: toolStrip._isMissionLayer
                        dropPanelComponent: _singleComplexItem ? undefined : patternDropPanel
                        onTriggered: {
                            if (_singleComplexItem) {
                                insertComplexItemAfterCurrent(_missionController.complexMissionItemNames[0])
                            }
                        }
                    },
                    ToolStripAction {
                        id: waypointButton
                        text: qsTr("Waypoint")
                        iconSource: "/res/waypoint.svg"
                        visible: toolStrip._isMissionLayer
                        checkable: true
                        onTriggered: { _addWaypointOnClick = !_addWaypointOnClick; if (_addWaypointOnClick) _addROIOnClick = false }
                    },
                    ToolStripAction {
                        id: roiButton
                        text: qsTr("ROI")
                        iconSource: "/qmlimages/roi.svg"
                        visible: toolStrip._isMissionLayer && _planMasterController.controllerVehicle.supports.roiMode
                        checkable: true
                        onTriggered: { _addROIOnClick = !_addROIOnClick; if (_addROIOnClick) _addWaypointOnClick = false }
                    },
                    ToolStripAction {
                        text: _planMasterController.controllerVehicle.multiRotor
                                    ? qsTr("Return")
                                    : _missionController.isInsertLandValid && _missionController.hasLandItem
                                      ? qsTr("Alt Land")
                                      : qsTr("Land")
                        iconSource: "/res/rtl.svg"
                        enabled: _missionController.isInsertLandValid
                        visible: toolStrip._isMissionLayer
                        onTriggered: {
                            insertLandItemAfterCurrent()
                        }
                    },
                    ToolStripAction {
                        text: qsTr("Stats")
                        iconSource: "/res/chevron-double-right.svg"
                        visible: missionStatus.hidden && QGroundControl.corePlugin.options.showMissionStatus
                        onTriggered: missionStatus.showMissionStatus()
                    }
                ]
            }
 
            model: toolStripActionList.model
        }
 
        MapScale {
            anchors.margins: _toolsMargin
            anchors.left: toolStrip.right
            anchors.top: parent.top
            mapControl: editorMap
            autoHide: true
        }
 
        PlanViewRightPanel {
            id: rightPanel
            anchors.top: parent.top
            anchors.bottom: parent.bottom
            anchors.right: parent.right
            width: _rightPanelWidth
            planMasterController: _planMasterController
            editorMap: editorMap
            onEditingLayerChangeRequested: (layer) => _editingLayer = layer
        }
 
        // Layer switching icons — only active icon visible; click to expand choices leftward
        Item {
            id:                     layerSwitcher
            anchors.right:          rightPanel.left
            anchors.rightMargin:    _toolsMargin
            anchors.top:            parent.top
            anchors.topMargin:      _toolsMargin
            width:                  layerRow.width
            height:                 _layerButtonSize
            z:                      QGroundControl.zOrderWidgets
 
            property bool   expanded: false
            property real   _layerButtonSize: ScreenTools.defaultFontPixelHeight * 2.0
            property real   _spacing: ScreenTools.defaultFontPixelHeight * 0.25
 
            readonly property var _layers: [
                { layer: _layerMission, icon: "/res/waypoint.svg",      nodeType: "missionGroup" },
                { layer: _layerFence,   icon: "/res/GeoFence.svg",      nodeType: "fenceGroup" },
                { layer: _layerRally,   icon: "/res/RallyPoint.svg",    nodeType: "rallyGroup" }
            ]
 
            Timer {
                id: collapseTimer
                interval: 5000
                onTriggered: layerSwitcher.expanded = false
            }
 
            function toggle() {
                expanded = !expanded
                if (expanded) {
                    collapseTimer.restart()
                } else {
                    collapseTimer.stop()
                }
            }
 
            function choose(nodeType) {
                expanded = false
                collapseTimer.stop()
                rightPanel.selectLayer(nodeType)
            }
 
            // Row laid out right-to-left: active icon on the right, choices expand left
            Row {
                id:             layerRow
                anchors.right:  parent.right
                spacing:        layerSwitcher._spacing
                layoutDirection: Qt.RightToLeft
 
                // Active layer button (always visible)
                Rectangle {
                    width:  layerSwitcher._layerButtonSize
                    height: width
                    radius: ScreenTools.defaultBorderRadius
                    color:  QGroundControl.globalPalette.buttonHighlight
 
                    QGCColoredImage {
                        anchors.centerIn:   parent
                        width:              parent.width * 0.6
                        height:             width
                        source:             layerSwitcher._layers.find(l => l.layer === _editingLayer)?.icon ?? "/res/waypoint.svg"
                        color:              QGroundControl.globalPalette.buttonHighlightText
                    }
 
                    QGCMouseArea {
                        anchors.fill: parent
                        onClicked:    layerSwitcher.toggle()
                    }
                }
 
                // Choice buttons (only layers that are NOT the current one)
                Repeater {
                    model: layerSwitcher._layers.filter(l => l.layer !== _editingLayer)
 
                    Rectangle {
                        required property var modelData
                        width:   layerSwitcher._layerButtonSize
                        height:  width
                        radius:  ScreenTools.defaultBorderRadius
                        color:   QGroundControl.globalPalette.button
                        visible: opacity > 0
                        opacity: layerSwitcher.expanded ? 1 : 0
 
                        Behavior on opacity { NumberAnimation { duration: 150 } }
 
                        QGCColoredImage {
                            anchors.centerIn:   parent
                            width:              parent.width * 0.6
                            height:             width
                            source:             modelData.icon
                            color:              QGroundControl.globalPalette.buttonText
                        }
 
                        QGCMouseArea {
                            anchors.fill: parent
                            onClicked:    layerSwitcher.choose(modelData.nodeType)
                        }
                    }
                }
            }
        }
 
        RowLayout {
            id: missionStatus
            anchors.margins: _toolsMargin
            anchors.left: _calcLeftAnchor()
            anchors.right: rightPanel.left
            anchors.bottom: parent.bottom
            spacing: 0
            visible: !hidden && _editingLayer == _layerMission && QGroundControl.corePlugin.options.showMissionStatus
 
            readonly property bool hidden: _planViewSettings.showMissionItemStatus.rawValue ? false : true
 
            function showMissionStatus() {
                _planViewSettings.showMissionItemStatus.rawValue = true
            }
 
            function _calcLeftAnchor() {
                let bottomOfToolStrip = toolStrip.y + toolStrip.height
                let largestStatsHeight = Math.max(terrainStatus.height, missionStats.height)
                if (bottomOfToolStrip + largestStatsHeight > parent.height - missionStatus.anchors.margins) {
                    return toolStrip.right
                }
                return parent.left
            }
 
            function _toggleMissionStatusVisibility() {
                _planViewSettings.showMissionItemStatus.rawValue = _planViewSettings.showMissionItemStatus.rawValue ? false : true
            }
 
            ColumnLayout {
                id: missionStatsButtonLayout
                Layout.alignment: Qt.AlignBottom
                spacing: 0
 
                property real _buttonImplicitWidth: ScreenTools.defaultFontPixelHeight * 1.5
                property real _buttonImageMargins: _buttonImplicitWidth * 0.15
 
                Rectangle {
                    id: terrainButton
                    implicitWidth: missionStatsButtonLayout._buttonImplicitWidth
                    implicitHeight: implicitWidth
                    color: checked ? QGroundControl.globalPalette.buttonHighlight : QGroundControl.globalPalette.button
 
                    property bool checked: true
 
                    QGCColoredImage {
                        anchors.margins: missionStatsButtonLayout._buttonImageMargins
                        anchors.fill: parent
                        source: "/res/terrain.svg"
                        color: parent.checked ? QGroundControl.globalPalette.buttonHighlightText : QGroundControl.globalPalette.buttonText
                    }
 
                    QGCMouseArea {
                        anchors.fill: parent
                        onClicked: {
                            terrainButton.checked = true
                            missionStatsButton.checked = false
                        }
                    }
                }
 
                Rectangle {
                    id: missionStatsButton
                    implicitWidth: missionStatsButtonLayout._buttonImplicitWidth
                    implicitHeight: implicitWidth
                    color: checked ? QGroundControl.globalPalette.buttonHighlight : QGroundControl.globalPalette.button
 
                    property bool checked: false
 
                    QGCColoredImage {
                        anchors.margins: missionStatsButtonLayout._buttonImageMargins
                        anchors.fill: parent
                        source: "/res/sliders.svg"
                        color: parent.checked ? QGroundControl.globalPalette.buttonHighlightText : QGroundControl.globalPalette.buttonText
                    }
 
                    QGCMouseArea {
                        anchors.fill: parent
                        onClicked: {
                            missionStatsButton.checked = true
                            terrainButton.checked = false
                        }
                    }
                }
 
                Rectangle {
                    id: bottomStatusOpenCloseButton
                    implicitWidth: missionStatsButtonLayout._buttonImplicitWidth
                    implicitHeight: implicitWidth
                    color: QGroundControl.globalPalette.button
 
                    QGCColoredImage {
                        anchors.margins: missionStatsButtonLayout._buttonImageMargins
                        anchors.fill: parent
                        source: "/res/chevron-double-left.svg"
                        color: QGroundControl.globalPalette.buttonText
                    }
 
                    QGCMouseArea {
                        anchors.fill: parent
                        onClicked: missionStatus._toggleMissionStatusVisibility()
                    }
                }
            }
 
            TerrainStatus {
                id: terrainStatus
                Layout.alignment: Qt.AlignBottom
                Layout.fillWidth: true
                height: ScreenTools.defaultFontPixelHeight * 7
                missionController: _missionController
                visible: terrainButton.checked
                onSetCurrentSeqNum: _missionController.setCurrentPlanViewSeqNum(seqNum, true)
            }
 
            MissionStats {
                id: missionStats
                Layout.alignment: Qt.AlignBottom
                Layout.fillWidth: true
                visible: missionStatsButton.checked
                planMasterController: _root._planMasterController
            }
        }
    }
 
        //- ToolStrip ToolStripDropPanel Components
 
    Component {
        id: patternDropPanel
 
        ColumnLayout {
            spacing: ScreenTools.defaultFontPixelWidth * 0.5
 
            QGCLabel { text: qsTr("Create complex pattern:") }
 
            Repeater {
                model: _missionController.complexMissionItemNames
 
                QGCButton {
                    text: modelData
                    Layout.fillWidth: true
 
                    onClicked: {
                        insertComplexItemAfterCurrent(modelData)
                        dropPanel.hide()
                    }
                }
            }
        } // Column
    }
 
    QGCPopupDialogFactory {
        id: promptForPlanUsageOnVehicleChangePopupFactory
 
        dialogComponent: promptForPlanUsageOnVehicleChangePopupComponent
    }
 
    Component {
        id: promptForPlanUsageOnVehicleChangePopupComponent
        QGCPopupDialog {
            title: _planMasterController.managerVehicle.isOfflineEditingVehicle ? qsTr("Plan View - Vehicle Disconnected") : qsTr("Plan View - Vehicle Changed")
            buttons: Dialog.NoButton
 
            ColumnLayout {
                QGCLabel {
                    Layout.maximumWidth: parent.width
                    wrapMode: QGCLabel.WordWrap
                    text: _planMasterController.managerVehicle.isOfflineEditingVehicle ?
                                                qsTr("The vehicle associated with the plan in the Plan View is no longer available. What would you like to do with that plan?") : qsTr("The plan being worked on in the Plan View is not from the current vehicle. What would you like to do with that plan?")
                }
 
                QGCButton {
                    Layout.fillWidth: true
                    text: (_planMasterController.dirtyForSave) ?
                                            (_planMasterController.managerVehicle.isOfflineEditingVehicle ?
                                                 qsTr("Discard Unsaved Changes") : qsTr("Discard Unsaved Changes, Load New Plan From Vehicle")) : qsTr("Load New Plan From Vehicle")
                    onClicked: {
                        _planMasterController.showPlanFromManagerVehicle()
                        _promptForPlanUsageShowing = false
                        close();
                    }
                }
 
                QGCButton {
                    Layout.fillWidth: true
                    text: _planMasterController.managerVehicle.isOfflineEditingVehicle ?
                                            qsTr("Keep Current Plan") : qsTr("Keep Current Plan, Don't Update From Vehicle")
                    onClicked: {
                        _promptForPlanUsageShowing = false
                        close()
                    }
                }
            }
        }
    }
 
    Component {
        id: insertOrCancelROIDropPanelComponent
 
        DropPanel {
            id: insertOrCancelROIDropPanel
            onClosed: destroy()
 
            property var mapClickCoord
 
            sourceComponent: Component {
                ColumnLayout {
                    spacing: ScreenTools.defaultFontPixelWidth / 2
 
                    QGCButton {
                        Layout.fillWidth: true
                        text: qsTr("Insert ROI")
 
                        onClicked: {
                            insertOrCancelROIDropPanel.close()
                            insertROIAfterCurrent(mapClickCoord)
                        }
                    }
 
                    QGCButton {
                        Layout.fillWidth: true
                        text: qsTr("Insert Cancel ROI")
 
                        onClicked: {
                            insertOrCancelROIDropPanel.close()
                            insertCancelROIAfterCurrent()
                        }
                    }
                }
            }
        }
    }
}