ground/gcs/src/share/qml/pfd/Panels.qml

   1 /*
   2  * Copyright (C) 2016 The LibrePilot Project
   3  * Contact: http://www.librepilot.org
   4  *
   5  * This file is part of LibrePilot GCS.
   6  *
   7  * LibrePilot GCS is free software: you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License as published by
   9  * the Free Software Foundation, either version 3 of the License, or
  10  * (at your option) any later version.
  11  *
  12  * LibrePilot GCS is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with LibrePilot GCS.  If not, see <http://www.gnu.org/licenses/>.
  19  */
  20 import QtQuick 2.0
  21
  22 import "../js/common.js" as Utils
  23 import "../js/uav.js" as UAV
  24
  25 Item {
  26     id: panels
  27     property variant sceneSize
  28
  29     //
  30     // Panel functions
  31     //
  32
  33     property bool show_panels: false
  34     property bool display_rc: false
  35     property bool display_bat: false
  36     property bool display_oplm: false
  37     property bool display_sys: false
  38
  39     function close_panels(){
  40         if (show_panels == true)
  41             show_panels = false;
  42         else
  43             show_panels = true;
  44     }
  45
  46     function hide_display_rcinput(){
  47         show_panels = true;
  48         display_oplm = false
  49         display_bat = false
  50         rc_input_bg.z = 10
  51         battery_bg.z = -1
  52         oplm_bg.z = -1
  53         system_bg.z = -1
  54     }
  55
  56     function hide_display_battery(){
  57         show_panels = true;
  58         display_oplm = false
  59         display_bat = true
  60         rc_input_bg.z = 10
  61         battery_bg.z = 20
  62         oplm_bg.z = -1
  63         system_bg.z = -1
  64     }
  65
  66     function hide_display_oplink(){
  67         show_panels = true;
  68         display_oplm = true
  69         display_bat = false
  70         rc_input_bg.z = 10
  71         battery_bg.z = 20
  72         oplm_bg.z = 30
  73         system_bg.z = -1
  74     }
  75
  76     function hide_display_system(){
  77         show_panels = true;
  78         display_oplm = false
  79         display_bat = false
  80         rc_input_bg.z = 10
  81         battery_bg.z = 20
  82         oplm_bg.z = 30
  83         system_bg.z = 40
  84     }
  85
  86     property real smeter_angle
  87
  88     // Needed to get correctly int8 value, reset value (-127) on disconnect
  89     property int oplm0_db: (telemetry_link == 1) ? opLinkStatus.pairSignalStrengths0 : -127
  90     property int oplm1_db: (telemetry_link == 1) ? opLinkStatus.pairSignalStrengths1 : -127
  91     property int oplm2_db: (telemetry_link == 1) ? opLinkStatus.pairSignalStrengths2 : -127
  92     property int oplm3_db: (telemetry_link == 1) ? opLinkStatus.pairSignalStrengths3 : -127
  93
  94     property real telemetry_sum
  95     property real telemetry_sum_old
  96     property bool telemetry_link
  97
  98     // Hack : check if telemetry is active. Works with real link and log replay
  99
 100     function telemetry_check() {
 101        telemetry_sum = opLinkStatus.rxRate + opLinkStatus.txRate
 102
 103        if (telemetry_sum != telemetry_sum_old || UAV.isOplmConnected()) {
 104            telemetry_link = 1
 105        } else {
 106            telemetry_link = 0
 107        }
 108        telemetry_sum_old = telemetry_sum
 109     }
 110
 111     Timer {
 112          id: telemetry_activity
 113          interval: 1200; running: true; repeat: true
 114          onTriggered: telemetry_check()
 115     }
 116
 117     // Filtering for S-meter. Smeter range -127dB <--> -13dB = S9+60dB
 118
 119     Timer {
 120          id: smeter_filter0
 121          interval: 100; running: true; repeat: true
 122          onTriggered: smeter_angle = (0.90 * smeter_angle) + (0.1 * (oplm0_db + 13))
 123     }
 124
 125     Timer {
 126          id: smeter_filter1
 127          interval: 100; repeat: true
 128          onTriggered: smeter_angle = (0.90 * smeter_angle) + (0.1 * (oplm1_db + 13))
 129     }
 130
 131     Timer {
 132          id: smeter_filter2
 133          interval: 100; repeat: true
 134          onTriggered: smeter_angle = (0.90 * smeter_angle) + (0.1 * (oplm2_db + 13))
 135      }
 136
 137     Timer {
 138          id: smeter_filter3
 139          interval: 100; repeat: true
 140          onTriggered: smeter_angle = (0.90 * smeter_angle) + (0.1 * (oplm3_db + 13))
 141     }
 142
 143     property int smeter_filter
 144     property variant oplm_pair_id : opLinkStatus.pairIDs0
 145
 146     function select_oplm(index){
 147          smeter_filter0.running = false;
 148          smeter_filter1.running = false;
 149          smeter_filter2.running = false;
 150          smeter_filter3.running = false;
 151
 152          switch(index) {
 153             case 0:
 154                 smeter_filter0.running = true;
 155                 smeter_filter = 0;
 156                 oplm_pair_id = opLinkStatus.pairIDs0
 157                 break;
 158             case 1:
 159                 smeter_filter1.running = true;
 160                 smeter_filter = 1;
 161                 oplm_pair_id = opLinkStatus.pairIDs1
 162                 break;
 163             case 2:
 164                 smeter_filter2.running = true;
 165                 smeter_filter = 2;
 166                 oplm_pair_id = opLinkStatus.pairIDs2
 167                 break;
 168             case 3:
 169                 smeter_filter3.running = true;
 170                 smeter_filter = 3;
 171                 oplm_pair_id = opLinkStatus.pairIDs3
 172                 break;
 173          }
 174      }
 175
 176     // End Functions
 177     //
 178     // Start Drawing
 179
 180     //
 181     // Animation properties
 182     //
 183
 184     property double offset_value: close_bg.width * 0.85
 185
 186     property int anim_type: Easing.OutExpo
 187     property int anim_duration: 1600
 188
 189     //
 190     // Close - Open panel
 191     //
 192
 193     SvgElementImage {
 194         id: close_bg
 195         elementName: "close-bg"
 196         sceneSize: panels.sceneSize
 197         y: Math.floor(scaledBounds.y * sceneItem.height)
 198
 199
 200         states: State {
 201              name: "fading"
 202              when: show_panels == true
 203              PropertyChanges { target: close_bg; x: Math.floor(scaledBounds.x * sceneItem.width) + offset_value; }
 204         }
 205
 206         transitions: Transition {
 207             SequentialAnimation {
 208                 id: close_anim
 209                 PropertyAnimation { property: "x"; easing.type: anim_type; duration: anim_duration }
 210             }
 211         }
 212     }
 213
 214     SvgElementImage {
 215         id: panel_open_icon
 216         elementName: "panel-open-icon"
 217         sceneSize: panels.sceneSize
 218         y: Math.floor(scaledBounds.y * sceneItem.height)
 219         z: close_bg.z + 1
 220         opacity: show_panels == true ? 0 : 1
 221
 222         states: State {
 223              name: "fading"
 224              when: show_panels == true
 225              PropertyChanges { target: panel_open_icon; x: Math.floor(scaledBounds.x * sceneItem.width) + offset_value; }
 226              PropertyChanges { target: panel_open_icon; opacity: 0; }
 227         }
 228
 229         transitions: Transition {
 230             SequentialAnimation {
 231                 PropertyAnimation { property: "x"; easing.type: anim_type; duration: anim_duration }
 232                 PropertyAnimation { property: "opacity"; duration: 500; }
 233             }
 234         }
 235     }
 236
 237     SvgElementImage {
 238         id: close_mousearea
 239         elementName: "close-panel-mousearea"
 240         sceneSize: panels.sceneSize
 241         y: Math.floor(scaledBounds.y * sceneItem.height)
 242         z: close_bg.z + 100
 243
 244         TooltipArea {
 245             text: show_panels == true ? "Close panels" : "Open panels"
 246         }
 247
 248         MouseArea {
 249              id: hidedisp_close;
 250              anchors.fill: parent;
 251              cursorShape: Qt.PointingHandCursor
 252              onClicked: close_panels()
 253         }
 254
 255         states: State {
 256              name: "fading"
 257              when: show_panels == true
 258              PropertyChanges { target: close_mousearea; x: Math.floor(scaledBounds.x * sceneItem.width) + offset_value; }
 259         }
 260
 261         transitions: Transition {
 262             SequentialAnimation {
 263                 PropertyAnimation { property: "x"; easing.type: anim_type; duration: anim_duration }
 264             }
 265         }
 266     }
 267
 268     //
 269     // Rc-Input panel
 270     //
 271
 272     SvgElementImage {
 273         id: rc_input_bg
 274         elementName: "rc-input-bg"
 275         sceneSize: panels.sceneSize
 276         y: Math.floor(scaledBounds.y * sceneItem.height)
 277         z: 10
 278
 279         states: State {
 280              name: "fading"
 281              when: show_panels == true
 282              PropertyChanges { target: rc_input_bg; x: Math.floor(scaledBounds.x * sceneItem.width) + offset_value; }
 283         }
 284
 285         transitions: Transition {
 286             SequentialAnimation {
 287                 PropertyAnimation { property: "x"; easing.type: anim_type; duration: anim_duration }
 288             }
 289         }
 290     }
 291
 292     SvgElementImage {
 293         id: rc_input_labels
 294         elementName: "rc-input-labels"
 295         sceneSize: panels.sceneSize
 296         y: Math.floor(scaledBounds.y * sceneItem.height)
 297         z: rc_input_bg.z + 1
 298
 299         states: State {
 300              name: "fading"
 301              when: show_panels == true
 302              PropertyChanges { target: rc_input_labels; x: Math.floor(scaledBounds.x * sceneItem.width) + offset_value; }
 303         }
 304
 305         transitions: Transition {
 306             SequentialAnimation {
 307                 PropertyAnimation { property: "x"; easing.type: anim_type; duration: anim_duration }
 308             }
 309         }
 310     }
 311
 312     SvgElementImage {
 313         id: rc_input_mousearea
 314         elementName: "rc-input-panel-mousearea"
 315         sceneSize: panels.sceneSize
 316         y: Math.floor(scaledBounds.y * sceneItem.height)
 317         z: rc_input_bg.z + 1
 318
 319         TooltipArea {
 320             text: "RC panel"
 321         }
 322
 323         MouseArea {
 324              id: hidedisp_rcinput;
 325              anchors.fill: parent;
 326              cursorShape: Qt.PointingHandCursor
 327              onClicked: hide_display_rcinput()
 328         }
 329
 330         states: State {
 331              name: "fading"
 332              when: show_panels == true
 333              PropertyChanges { target: rc_input_mousearea; x: Math.floor(scaledBounds.x * sceneItem.width) + offset_value; }
 334         }
 335
 336         transitions: Transition {
 337             SequentialAnimation {
 338                 PropertyAnimation { property: "x"; easing.type: anim_type; duration: anim_duration }
 339             }
 340         }
 341     }
 342
 343     SvgElementImage {
 344         id: rc_throttle
 345         elementName: "rc-throttle"
 346         sceneSize: panels.sceneSize
 347         z: rc_input_bg.z+2
 348
 349         width: scaledBounds.width * sceneItem.width
 350         height: (scaledBounds.height * sceneItem.height) * (manualControlCommand.throttle)
 351
 352         x: scaledBounds.x * sceneItem.width
 353         y: (scaledBounds.y * sceneItem.height) - rc_throttle.height + (scaledBounds.height * sceneItem.height)
 354
 355         smooth: true
 356
 357         states: State {
 358              name: "fading"
 359              when: show_panels == true
 360              PropertyChanges { target: rc_throttle; x: Math.floor(scaledBounds.x * sceneItem.width) + offset_value; }
 361         }
 362
 363         transitions: Transition {
 364             SequentialAnimation {
 365                 PropertyAnimation { property: "x"; easing.type: anim_type; duration: anim_duration }
 366             }
 367         }
 368     }
 369
 370     SvgElementImage {
 371         id: rc_stick
 372         elementName: "rc-stick"
 373         sceneSize: panels.sceneSize
 374         z: rc_input_bg.z+3
 375
 376         width: scaledBounds.width * sceneItem.width
 377         height: scaledBounds.height * sceneItem.height
 378
 379         y: (scaledBounds.y * sceneItem.height) + (manualControlCommand.pitch * rc_stick.width * 2.5)
 380
 381         smooth: true
 382
 383         //rotate it around his center
 384         transform: Rotation {
 385             angle: manualControlCommand.yaw * 90
 386             origin.y : rc_stick.height / 2
 387             origin.x : rc_stick.width / 2
 388         }
 389
 390         states: State {
 391              name: "fading"
 392              when: show_panels == true
 393              PropertyChanges { target: rc_stick; x: Math.floor(scaledBounds.x * sceneItem.width) + (manualControlCommand.roll * rc_stick.width * 2.5) + offset_value; }
 394         }
 395
 396         transitions: Transition {
 397             SequentialAnimation {
 398                 PropertyAnimation { property: "x"; easing.type: anim_type; duration: anim_duration }
 399             }
 400         }
 401     }
 402
 403     //
 404     // Battery panel
 405     //
 406
 407     SvgElementImage {
 408         id: battery_bg
 409         elementName: "battery-bg"
 410         sceneSize: panels.sceneSize
 411         y: Math.floor(scaledBounds.y * sceneItem.height)
 412         z: 20
 413
 414         states: State {
 415              name: "fading"
 416              when: show_panels == true
 417              PropertyChanges { target: battery_bg; x: Math.floor(scaledBounds.x * sceneItem.width) + offset_value; }
 418         }
 419
 420         transitions: Transition {
 421             SequentialAnimation {
 422                 PropertyAnimation { property: "x"; easing.type: anim_type; duration: anim_duration }
 423             }
 424         }
 425     }
 426
 427     SvgElementPositionItem {
 428         id: battery_volt
 429         sceneSize: panels.sceneSize
 430         elementName: "battery-volt-text"
 431         z: battery_bg.z + 1
 432
 433         width: scaledBounds.width * sceneItem.width
 434         height: scaledBounds.height * sceneItem.height
 435         y: scaledBounds.y * sceneItem.height
 436
 437         states: State {
 438              name: "fading"
 439              when: show_panels == true
 440              PropertyChanges { target: battery_volt; x: Math.floor(scaledBounds.x * sceneItem.width) + offset_value; }
 441         }
 442
 443         transitions: Transition {
 444             SequentialAnimation {
 445                 PropertyAnimation { property: "x"; easing.type: anim_type; duration: anim_duration }
 446             }
 447         }
 448
 449         Rectangle {
 450             anchors.fill: parent
 451             color: UAV.batteryAlarmColor()
 452             border.color: "white"
 453             border.width: battery_volt.width * 0.01
 454             radius: border.width * 4
 455
 456             Text {
 457                text: UAV.batteryVoltage()
 458                anchors.centerIn: parent
 459                color: "white"
 460                font {
 461                    family: pt_bold.name
 462                    pixelSize: Math.floor(parent.height * 0.6)
 463                }
 464             }
 465         }
 466     }
 467
 468     SvgElementPositionItem {
 469         id: battery_amp
 470         sceneSize: panels.sceneSize
 471         elementName: "battery-amp-text"
 472         z: battery_bg.z+2
 473
 474         width: scaledBounds.width * sceneItem.width
 475         height: scaledBounds.height * sceneItem.height
 476         y: scaledBounds.y * sceneItem.height
 477
 478         states: State {
 479              name: "fading"
 480              when: show_panels == true
 481              PropertyChanges { target: battery_amp; x: Math.floor(scaledBounds.x * sceneItem.width) + offset_value; }
 482         }
 483
 484         transitions: Transition {
 485             SequentialAnimation {
 486                 PropertyAnimation { property: "x"; easing.type: anim_type; duration: anim_duration }
 487             }
 488         }
 489
 490         Rectangle {
 491             anchors.fill: parent
 492             color: UAV.batteryAlarmColor()
 493             border.color: "white"
 494             border.width: battery_volt.width * 0.01
 495             radius: border.width * 4
 496
 497             Text {
 498                text: UAV.batteryCurrent()
 499                anchors.centerIn: parent
 500                color: "white"
 501                font {
 502                    family: pt_bold.name
 503                    pixelSize: Math.floor(parent.height * 0.6)
 504                }
 505             }
 506         }
 507     }
 508
 509     SvgElementPositionItem {
 510         id: battery_milliamp
 511         sceneSize: panels.sceneSize
 512         elementName: "battery-milliamp-text"
 513         z: battery_bg.z+3
 514
 515         width: scaledBounds.width * sceneItem.width
 516         height: scaledBounds.height * sceneItem.height
 517         y: scaledBounds.y * sceneItem.height
 518
 519         states: State {
 520              name: "fading"
 521              when: show_panels == true
 522              PropertyChanges { target: battery_milliamp; x: Math.floor(scaledBounds.x * sceneItem.width) + offset_value; }
 523         }
 524
 525         transitions: Transition {
 526             SequentialAnimation {
 527                 PropertyAnimation { property: "x"; easing.type: anim_type; duration: anim_duration }
 528             }
 529         }
 530
 531         Rectangle {
 532             anchors.fill: parent
 533
 534             TooltipArea {
 535                text: "Reset consumed energy"
 536                visible: display_bat == true ? 1 : 0
 537             }
 538
 539             MouseArea {
 540                id: reset_panel_consumed_energy_mouseArea;
 541                anchors.fill: parent;
 542                cursorShape: Qt.PointingHandCursor;
 543                visible: display_bat == true ? 1 : 0
 544                onClicked: pfdContext.resetConsumedEnergy();
 545             }
 546
 547             // Alarm based on estimatedFlightTime < 120s orange, < 60s red
 548             color: UAV.estimatedTimeAlarmColor()
 549
 550             border.color: "white"
 551             border.width: battery_volt.width * 0.01
 552             radius: border.width * 4
 553
 554             Text {
 555                text: UAV.batteryConsumedEnergy()
 556                anchors.centerIn: parent
 557                color: "white"
 558                font {
 559                    family: pt_bold.name
 560                    pixelSize: Math.floor(parent.height * 0.6)
 561                }
 562             }
 563         }
 564     }
 565
 566     SvgElementPositionItem {
 567         id: battery_estimated_flight_time
 568         sceneSize: panels.sceneSize
 569         elementName: "battery-estimated-flight-time"
 570         z: battery_bg.z+4
 571
 572         width: scaledBounds.width * sceneItem.width
 573         height: scaledBounds.height * sceneItem.height
 574         y: scaledBounds.y * sceneItem.height
 575
 576         states: State {
 577              name: "fading"
 578              when: show_panels == true
 579              PropertyChanges { target: battery_estimated_flight_time; x: Math.floor(scaledBounds.x * sceneItem.width) + offset_value; }
 580         }
 581
 582         transitions: Transition {
 583             SequentialAnimation {
 584                 PropertyAnimation { property: "x"; easing.type: anim_type; duration: anim_duration }
 585             }
 586         }
 587
 588         Rectangle {
 589             anchors.fill: parent
 590
 591             TooltipArea {
 592                text: "Reset consumed energy"
 593                visible: display_bat == true ? 1 : 0
 594             }
 595
 596             MouseArea {
 597                id: reset_panel_consumed_energy_mouseArea2;
 598                anchors.fill: parent;
 599                cursorShape: Qt.PointingHandCursor;
 600                visible: display_bat == true ? 1 : 0
 601                onClicked: pfdContext.resetConsumedEnergy();
 602             }
 603
 604             // Alarm based on estimatedFlightTime < 120s orange, < 60s red
 605             color: UAV.estimatedTimeAlarmColor()
 606
 607             border.color: "white"
 608             border.width: battery_volt.width * 0.01
 609             radius: border.width * 4
 610
 611             Text {
 612                text: Utils.formatFlightTime(UAV.estimatedFlightTimeValue())
 613                anchors.centerIn: parent
 614                color: "white"
 615                font {
 616                    family: pt_bold.name
 617                    pixelSize: Math.floor(parent.height * 0.6)
 618                }
 619             }
 620         }
 621     }
 622
 623     SvgElementImage {
 624         id: battery_labels
 625         elementName: "battery-labels"
 626         sceneSize: panels.sceneSize
 627         y: Math.floor(scaledBounds.y * sceneItem.height)
 628         z: battery_bg.z+5
 629
 630         states: State {
 631              name: "fading"
 632              when: show_panels == true
 633              PropertyChanges { target: battery_labels; x: Math.floor(scaledBounds.x * sceneItem.width) + offset_value; }
 634         }
 635
 636         transitions: Transition {
 637             SequentialAnimation {
 638                 PropertyAnimation { property: "x"; easing.type: anim_type; duration: anim_duration }
 639             }
 640         }
 641     }
 642
 643     SvgElementImage {
 644         id: battery_mousearea
 645         elementName: "battery-panel-mousearea"
 646         sceneSize: panels.sceneSize
 647         y: Math.floor(scaledBounds.y * sceneItem.height)
 648         z: battery_bg.z+6
 649
 650         TooltipArea {
 651             text: "Battery panel"
 652         }
 653
 654         MouseArea {
 655              id: hidedisp_battery;
 656              anchors.fill: parent;
 657              cursorShape: Qt.PointingHandCursor
 658              onClicked: hide_display_battery()
 659         }
 660
 661         states: State {
 662              name: "fading"
 663              when: show_panels == true
 664              PropertyChanges { target: battery_mousearea; x: Math.floor(scaledBounds.x * sceneItem.width) + offset_value; }
 665         }
 666
 667         transitions: Transition {
 668             SequentialAnimation {
 669                 PropertyAnimation { property: "x"; easing.type: anim_type; duration: anim_duration }
 670             }
 671         }
 672     }
 673
 674     //
 675     // OPLM panel
 676     //
 677
 678     SvgElementImage {
 679         id: oplm_bg
 680         elementName: "oplm-bg"
 681         sceneSize: panels.sceneSize
 682         y: Math.floor(scaledBounds.y * sceneItem.height)
 683         z: 30
 684
 685         states: State {
 686              name: "fading"
 687              when: show_panels == true
 688              PropertyChanges { target: oplm_bg; x: Math.floor(scaledBounds.x * sceneItem.width) + offset_value; }
 689         }
 690
 691         transitions: Transition {
 692             SequentialAnimation {
 693                 PropertyAnimation { property: "x"; easing.type: anim_type; duration: anim_duration }
 694             }
 695         }
 696     }
 697
 698     SvgElementImage {
 699         id: smeter_bg
 700         elementName: "smeter-bg"
 701         sceneSize: panels.sceneSize
 702         y: Math.floor(scaledBounds.y * sceneItem.height)
 703         z: oplm_bg.z + 1
 704
 705         states: State {
 706              name: "fading"
 707              when: show_panels == true
 708              PropertyChanges { target: smeter_bg; x: Math.floor(scaledBounds.x * sceneItem.width) + offset_value; }
 709         }
 710
 711         transitions: Transition {
 712             SequentialAnimation {
 713                 PropertyAnimation { property: "x"; easing.type: anim_type; duration: anim_duration }
 714             }
 715         }
 716     }
 717
 718     SvgElementImage {
 719         id: smeter_scale
 720         elementName: "smeter-scale"
 721         sceneSize: panels.sceneSize
 722         y: Math.floor(scaledBounds.y * sceneItem.height)
 723         z: oplm_bg.z + 2
 724
 725         states: State {
 726              name: "fading"
 727              when: show_panels == true
 728              PropertyChanges { target: smeter_scale; x: Math.floor(scaledBounds.x * sceneItem.width) + offset_value; }
 729         }
 730
 731         transitions: Transition {
 732             SequentialAnimation {
 733                 PropertyAnimation { property: "x"; easing.type: anim_type; duration: anim_duration }
 734             }
 735         }
 736     }
 737
 738     SvgElementImage {
 739         id: smeter_needle
 740         elementName: "smeter-needle"
 741         sceneSize: panels.sceneSize
 742         y: Math.floor(scaledBounds.y * sceneItem.height)
 743         z: oplm_bg.z + 3
 744
 745         states: State {
 746              name: "fading"
 747              when: show_panels == true
 748              PropertyChanges { target: smeter_needle; x: Math.floor(scaledBounds.x * sceneItem.width) + offset_value; }
 749         }
 750
 751         transitions: Transition {
 752             SequentialAnimation {
 753                 PropertyAnimation { property: "x"; easing.type: anim_type; duration: anim_duration }
 754             }
 755         }
 756
 757         transform: Rotation {
 758             angle: smeter_angle.toFixed(1)
 759             origin.y : smeter_needle.height
 760         }
 761     }
 762
 763     SvgElementImage {
 764         id: smeter_mask
 765         elementName: "smeter-mask"
 766         sceneSize: panels.sceneSize
 767         //y: Math.floor(scaledBounds.y * sceneItem.height)
 768         width: smeter_scale.width * 1.09
 769         //anchors.horizontalCenter: smeter_scale
 770
 771         z: oplm_bg.z + 4
 772
 773         states: State {
 774              name: "fading"
 775              when: show_panels == true
 776              PropertyChanges { target: smeter_mask; x: Math.floor(scaledBounds.x * sceneItem.width) + offset_value; }
 777         }
 778
 779         transitions: Transition {
 780             SequentialAnimation {
 781                 PropertyAnimation { property: "x"; easing.type: anim_type; duration: anim_duration }
 782             }
 783         }
 784     }
 785
 786     SvgElementImage {
 787         id: oplm_button_bg
 788         elementName: "oplm-button-bg"
 789         sceneSize: panels.sceneSize
 790         y: Math.floor(scaledBounds.y * sceneItem.height)
 791         width: smeter_mask.width
 792
 793         z: oplm_bg.z + 5
 794
 795         states: State {
 796              name: "fading"
 797              when: show_panels == true
 798              PropertyChanges { target: oplm_button_bg; x: Math.floor(scaledBounds.x * sceneItem.width) + offset_value; }
 799         }
 800
 801         transitions: Transition {
 802             SequentialAnimation {
 803                 PropertyAnimation { property: "x"; easing.type: anim_type; duration: anim_duration }
 804             }
 805         }
 806     }
 807
 808     Repeater {
 809         model: 4
 810
 811         SvgElementImage {
 812             z: oplm_bg.z + 5
 813             property variant idButton_oplm: "oplm_button_" + index
 814             property variant idButton_oplm_mousearea: "oplm_button_mousearea" + index
 815             property variant button_color: "button"+index+"_color"
 816
 817             id: idButton_oplm
 818
 819             elementName: "oplm-button-" + index
 820             sceneSize: panels.sceneSize
 821
 822             Rectangle {
 823                 anchors.fill: parent
 824                 border.color: "red"
 825                 border.width: parent.width * 0.04
 826                 radius: border.width*3
 827                 color: "transparent"
 828                 opacity: smeter_filter == index ? 0.5 : 0
 829             }
 830
 831             MouseArea {
 832                  id: idButton_oplm_mousearea;
 833                  anchors.fill: parent;
 834                  cursorShape: Qt.PointingHandCursor;
 835                  visible: display_oplm == true ? 1 : 0
 836                  onClicked: select_oplm(index)
 837             }
 838
 839             states: State {
 840                  name: "fading"
 841                  when: show_panels == true
 842                  PropertyChanges { target: idButton_oplm; x: Math.floor(scaledBounds.x * sceneItem.width) + offset_value; }
 843             }
 844
 845             transitions: Transition {
 846                 SequentialAnimation {
 847                     PropertyAnimation { property: "x"; easing.type: anim_type; duration: anim_duration }
 848                 }
 849             }
 850         }
 851     }
 852
 853     SvgElementImage {
 854         id: oplm_id_label
 855         elementName: "oplm-id-label"
 856         sceneSize: panels.sceneSize
 857         y: Math.floor(scaledBounds.y * sceneItem.height)
 858         z: oplm_bg.z + 6
 859
 860         states: State {
 861              name: "fading"
 862              when: show_panels == true
 863              PropertyChanges { target: oplm_id_label; x: Math.floor(scaledBounds.x * sceneItem.width) + offset_value; }
 864         }
 865
 866         transitions: Transition {
 867             SequentialAnimation {
 868                 PropertyAnimation { property: "x"; easing.type: anim_type; duration: anim_duration }
 869             }
 870         }
 871     }
 872
 873     SvgElementPositionItem {
 874         id: oplm_id_text
 875         sceneSize: panels.sceneSize
 876         elementName: "oplm-id-text"
 877         z: oplm_bg.z + 7
 878
 879         width: scaledBounds.width * sceneItem.width
 880         height: scaledBounds.height * sceneItem.height
 881         y: scaledBounds.y * sceneItem.height
 882
 883         states: State {
 884              name: "fading"
 885              when: show_panels == true
 886              PropertyChanges { target: oplm_id_text; x: Math.floor(scaledBounds.x * sceneItem.width) + offset_value; }
 887         }
 888
 889         transitions: Transition {
 890             SequentialAnimation {
 891                 PropertyAnimation { property: "x"; easing.type: anim_type; duration: anim_duration }
 892             }
 893         }
 894
 895         Text {
 896              text: oplm_pair_id > 0 ? oplm_pair_id.toString(16) : "--  --  --  --"
 897              anchors.centerIn: parent
 898              color: "white"
 899              font {
 900                  family: pt_bold.name
 901                  pixelSize: Math.floor(parent.height * 1.4)
 902                  weight: Font.DemiBold
 903                  capitalization: Font.AllUppercase
 904              }
 905         }
 906     }
 907
 908     SvgElementImage {
 909         id: rx_quality_label
 910         elementName: "rx-quality-label"
 911         sceneSize: panels.sceneSize
 912         y: Math.floor(scaledBounds.y * sceneItem.height)
 913         z: oplm_bg.z + 8
 914
 915         states: State {
 916              name: "fading"
 917              when: show_panels == true
 918              PropertyChanges { target: rx_quality_label; x: Math.floor(scaledBounds.x * sceneItem.width) + offset_value; }
 919         }
 920
 921         transitions: Transition {
 922             SequentialAnimation {
 923                 PropertyAnimation { property: "x"; easing.type: anim_type; duration: anim_duration }
 924             }
 925         }
 926     }
 927
 928     SvgElementPositionItem {
 929         id: rx_quality_text
 930         sceneSize: panels.sceneSize
 931         elementName: "rx-quality-text"
 932         z: oplm_bg.z + 9
 933
 934         width: scaledBounds.width * sceneItem.width
 935         height: scaledBounds.height * sceneItem.height
 936         y: scaledBounds.y * sceneItem.height
 937
 938         states: State {
 939              name: "fading"
 940              when: show_panels == true
 941              PropertyChanges { target: rx_quality_text; x: Math.floor(scaledBounds.x * sceneItem.width) + offset_value; }
 942         }
 943
 944         transitions: Transition {
 945             SequentialAnimation {
 946                 PropertyAnimation { property: "x"; easing.type: anim_type; duration: anim_duration }
 947             }
 948         }
 949
 950         Text {
 951              text: UAV.receiverQuality()
 952              anchors.right: parent.right
 953              color: "white"
 954              font {
 955                  family: pt_bold.name
 956                  pixelSize: Math.floor(parent.height * 1.4)
 957                  weight: Font.DemiBold
 958              }
 959         }
 960     }
 961
 962     SvgElementImage {
 963         id: cnx_state_label
 964         elementName: "cnx-state-label"
 965         sceneSize: panels.sceneSize
 966         y: Math.floor(scaledBounds.y * sceneItem.height)
 967         z: oplm_bg.z + 8
 968
 969         states: State {
 970              name: "fading"
 971              when: show_panels == true
 972              PropertyChanges { target: cnx_state_label; x: Math.floor(scaledBounds.x * sceneItem.width) + offset_value; }
 973         }
 974
 975         transitions: Transition {
 976             SequentialAnimation {
 977                 PropertyAnimation { property: "x"; easing.type: anim_type; duration: anim_duration }
 978             }
 979         }
 980     }
 981
 982     SvgElementPositionItem {
 983         id: cnx_state_text
 984         sceneSize: panels.sceneSize
 985         elementName: "cnx-state-text"
 986         z: oplm_bg.z + 9
 987
 988         width: scaledBounds.width * sceneItem.width
 989         height: scaledBounds.height * sceneItem.height
 990         y: scaledBounds.y * sceneItem.height
 991
 992         states: State {
 993              name: "fading"
 994              when: show_panels == true
 995              PropertyChanges { target: cnx_state_text; x: Math.floor(scaledBounds.x * sceneItem.width) + offset_value; }
 996         }
 997
 998         transitions: Transition {
 999             SequentialAnimation {
1000                 PropertyAnimation { property: "x"; easing.type: anim_type; duration: anim_duration }
1001             }
1002         }
1003
1004         Text {
1005              text: UAV.oplmLinkState()
1006              anchors.right: parent.right
1007              color: "white"
1008              font {
1009                  family: pt_bold.name
1010                  pixelSize: Math.floor(parent.height * 1.4)
1011                  weight: Font.DemiBold
1012              }
1013         }
1014     }
1015
1016     SvgElementImage {
1017         id: oplm_mousearea
1018         elementName: "oplm-panel-mousearea"
1019         sceneSize: panels.sceneSize
1020         y: Math.floor(scaledBounds.y * sceneItem.height)
1021         z: oplm_bg.z
1022
1023         TooltipArea {
1024             text: "Link panel"
1025         }
1026
1027         MouseArea {
1028              id: hidedisp_oplm;
1029              anchors.fill: parent;
1030              cursorShape: Qt.PointingHandCursor
1031              onClicked: hide_display_oplink()
1032         }
1033
1034         states: State {
1035              name: "fading"
1036              when: show_panels == true
1037              PropertyChanges { target: oplm_mousearea; x: Math.floor(scaledBounds.x * sceneItem.width) + offset_value; }
1038         }
1039
1040         transitions: Transition {
1041             SequentialAnimation {
1042                 PropertyAnimation { property: "x"; easing.type: anim_type; duration: anim_duration }
1043             }
1044         }
1045     }
1046
1047     //
1048     // System panel
1049     //
1050
1051     SvgElementImage {
1052         id: system_bg
1053         elementName: "system-bg"
1054         sceneSize: panels.sceneSize
1055         y: scaledBounds.y * sceneItem.height
1056         z: 40
1057
1058         states: State {
1059              name: "fading"
1060              when: show_panels == true
1061              PropertyChanges { target: system_bg; x: Math.floor(scaledBounds.x * sceneItem.width) + offset_value; }
1062         }
1063
1064         transitions: Transition {
1065             SequentialAnimation {
1066                 PropertyAnimation { property: "x"; easing.type: anim_type; duration: anim_duration }
1067             }
1068         }
1069     }
1070
1071     SvgElementPositionItem {
1072         id: system_frametype
1073         elementName: "system-frame-type"
1074         sceneSize: panels.sceneSize
1075         y: scaledBounds.y * sceneItem.height
1076         z: system_bg.z + 1
1077
1078         states: State {
1079              name: "fading"
1080              when: show_panels == true
1081              PropertyChanges { target: system_frametype; x: Math.floor(scaledBounds.x * sceneItem.width) + offset_value; }
1082         }
1083
1084         transitions: Transition {
1085             SequentialAnimation {
1086                 PropertyAnimation { property: "x"; easing.type: anim_type; duration: anim_duration }
1087             }
1088         }
1089
1090         Text {
1091              text: UAV.frameType()
1092              anchors.right: parent.right
1093              color: "white"
1094              font {
1095                  family: pt_bold.name
1096                  pixelSize: Math.floor(parent.height * 1.4)
1097                  weight: Font.DemiBold
1098              }
1099         }
1100     }
1101
1102     SvgElementPositionItem {
1103         id: system_cpuloadtemp
1104         elementName: "system-cpu-load-temp"
1105         sceneSize: panels.sceneSize
1106         y: scaledBounds.y * sceneItem.height
1107         z: system_bg.z + 1
1108
1109         states: State {
1110              name: "fading"
1111              when: show_panels == true
1112              PropertyChanges { target: system_cpuloadtemp; x: Math.floor(scaledBounds.x * sceneItem.width) + offset_value; }
1113         }
1114
1115         transitions: Transition {
1116             SequentialAnimation {
1117                 PropertyAnimation { property: "x"; easing.type: anim_type; duration: anim_duration }
1118             }
1119         }
1120
1121         Text {
1122              // CC3D: Only display Cpu load, no temperature available.
1123              text: UAV.cpuLoad() + "%" + [UAV.isCC3D() ? "" : " | " + UAV.cpuTemp() + "°C"]
1124              anchors.right: parent.right
1125              color: "white"
1126              font {
1127                  family: pt_bold.name
1128                  pixelSize: Math.floor(parent.height * 1.4)
1129                  weight: Font.DemiBold
1130              }
1131         }
1132     }
1133
1134     SvgElementPositionItem {
1135         id: system_memfree
1136         elementName: "system-mem-free"
1137         sceneSize: panels.sceneSize
1138         y: scaledBounds.y * sceneItem.height
1139         z: system_bg.z + 1
1140
1141         states: State {
1142              name: "fading"
1143              when: show_panels == true
1144              PropertyChanges { target: system_memfree; x: Math.floor(scaledBounds.x * sceneItem.width) + offset_value; }
1145         }
1146
1147         transitions: Transition {
1148             SequentialAnimation {
1149                 PropertyAnimation { property: "x"; easing.type: anim_type; duration: anim_duration }
1150             }
1151         }
1152
1153         Text {
1154              text: UAV.freeMemory()
1155              anchors.right: parent.right
1156              color: "white"
1157              font {
1158                  family: pt_bold.name
1159                  pixelSize: Math.floor(parent.height * 1.4)
1160                  weight: Font.DemiBold
1161              }
1162         }
1163     }
1164
1165     SvgElementPositionItem {
1166         id: system_fusion_algo
1167         elementName: "system-attitude-estimation-algo"
1168         sceneSize: panels.sceneSize
1169         y: scaledBounds.y * sceneItem.height
1170         z: system_bg.z + 1
1171
1172         states: State {
1173              name: "fading"
1174              when: show_panels == true
1175              PropertyChanges { target: system_fusion_algo; x: Math.floor(scaledBounds.x * sceneItem.width) + offset_value; }
1176         }
1177
1178         transitions: Transition {
1179             SequentialAnimation {
1180                 PropertyAnimation { property: "x"; easing.type: anim_type; duration: anim_duration }
1181             }
1182         }
1183
1184         Text {
1185              text: UAV.fusionAlgorithm()
1186              anchors.right: parent.right
1187              color: "white"
1188              font {
1189                  family: pt_bold.name
1190                  pixelSize: Math.floor(parent.height * 1.35)
1191                  weight: Font.DemiBold
1192              }
1193         }
1194     }
1195
1196     SvgElementPositionItem {
1197         id: system_mag_used
1198         elementName: "system-mag-used"
1199         sceneSize: panels.sceneSize
1200         y: scaledBounds.y * sceneItem.height
1201         z: system_bg.z + 1
1202
1203         states: State {
1204              name: "fading"
1205              when: show_panels == true
1206              PropertyChanges { target: system_mag_used; x: Math.floor(scaledBounds.x * sceneItem.width) + offset_value; }
1207         }
1208
1209         transitions: Transition {
1210             SequentialAnimation {
1211                 PropertyAnimation { property: "x"; easing.type: anim_type; duration: anim_duration }
1212             }
1213         }
1214
1215         Text {
1216              text: UAV.magSourceName()
1217              anchors.right: parent.right
1218              color: "white"
1219              font {
1220                  family: pt_bold.name
1221                  pixelSize: Math.floor(parent.height * 1.4)
1222                  weight: Font.DemiBold
1223              }
1224         }
1225     }
1226
1227     SvgElementPositionItem {
1228         id: system_gpstype
1229         elementName: "system-gps-type"
1230         sceneSize: panels.sceneSize
1231         y: scaledBounds.y * sceneItem.height
1232         z: system_bg.z + 1
1233
1234         states: State {
1235              name: "fading"
1236              when: show_panels == true
1237              PropertyChanges { target: system_gpstype; x: Math.floor(scaledBounds.x * sceneItem.width) + offset_value; }
1238         }
1239
1240         transitions: Transition {
1241             SequentialAnimation {
1242                 PropertyAnimation { property: "x"; easing.type: anim_type; duration: anim_duration }
1243             }
1244         }
1245
1246         Text {
1247              text: UAV.gpsSensorType()
1248              anchors.right: parent.right
1249              color: "white"
1250              font {
1251                  family: pt_bold.name
1252                  pixelSize: Math.floor(parent.height * 1.4)
1253                  weight: Font.DemiBold
1254              }
1255         }
1256     }
1257
1258     SvgElementImage {
1259         id: system_mousearea
1260         elementName: "system-panel-mousearea"
1261         sceneSize: panels.sceneSize
1262         y: Math.floor(scaledBounds.y * sceneItem.height)
1263         z: system_bg.z + 1
1264
1265         TooltipArea {
1266             text: "System panel"
1267         }
1268
1269         MouseArea {
1270              id: hidedisp_system;
1271              anchors.fill: parent;
1272              cursorShape: Qt.PointingHandCursor
1273              onClicked: hide_display_system()
1274         }
1275
1276         states: State {
1277              name: "fading"
1278              when: show_panels == true
1279              PropertyChanges { target: system_mousearea; x: Math.floor(scaledBounds.x * sceneItem.width) + offset_value; }
1280         }
1281
1282         transitions: Transition {
1283             SequentialAnimation {
1284                 PropertyAnimation { property: "x"; easing.type: anim_type; duration: anim_duration }
1285             }
1286         }
1287     }
1288 }