gva.h

Go to the documentation of this file.

//
// Copyright (c) 2023, DefenceX PTY LTD
//
// This file is part of the VivoeX project developed by DefenceX.
//
// Licensed under the Attribution-NonCommercial 4.0 International (CC BY-NC 4.0)
// License. See the LICENSE file in the project root for full license details.
//
 
#ifndef HMICORE_GVA_H_
#define HMICORE_GVA_H_
 
#include <array>
#include <string>
 
namespace gva {
 
 
static const uint32_t kMinimumHeight = 480;
static const uint32_t kMinimumWidth = 640;
 
 
enum class LocationEnum { kLocationFormatLongLat = 0, kLocationFormatMgrs };
enum class ScreenMode { kModeMaintenance = 0, kModeOperational, kModeBlackout };
enum class LabelModeEnum { kLabelAll, kLabelStatusOnly, kLabelMinimal };
enum class LabelStates {
  kLabelHidden,
  kLabelDisabled,
  kLabelEnabled,
  kLabelEnabledSelected,
  kLabelEnabledSelectedChanging
};
enum class LineType {
  kLineSolid,
  kLineDotted,
  kLineDashed,
  kLineDashedMedium,
  kLineDashedLarge,
};
enum class GvaKeyEnum {
  kKeyUnknown = 0,
  kKeySituationalAwareness,
  kKeyWeapon,
  kKeyDefensiveSystems,
  kKeySystems,
  kKeyDriver,
  kKeySpecialToRole,
  kKeyCommunications,
  kKeyBattlefieldManagementSystem,
  kKeyF1,
  kKeyF2,
  kKeyF3,
  kKeyF4,
  kKeyF5,
  kKeyF6,
  kKeyF7,
  kKeyF8,
  kKeyF9,
  kKeyF10,
  kKeyF11,
  kKeyF12,
  kKeyF13,
  kKeyF14,
  kKeyF15,
  kKeyF16,
  kKeyF17,
  kKeyF18,
  kKeyF19,
  kKeyF20,
  kKeyF21,
  kKeyF22,
  kKeyBlackout,
  kKeyPower,
  KKeyBrightnessUp,
  kKeyBrightnessDown,
  // These are fake keys that only exist in the software (emulated world)
  kKeyEscape,
  kKeyFullscreen,
  kKeyPlus,
  kKeyMinus,
  kKeyUpArrow,
  kKeyDownArrow,
  kKeyLeftArrow,
  kKeyRightArrow,
  kKeyGreaterThan,
  kKeyLessThen,
  kKeyKeyboard,
  kKeyPreviousLabel,
  kKeyNextLabel,
  kKeyKeyboard_0,
  kKeyKeyboard_1,
  kKeyKeyboard_2,
  kKeyKeyboard_3,
  kKeyKeyboard_4,
  kKeyKeyboard_5,
  kKeyKeyboard_6,
  kKeyKeyboard_7,
  kKeyKeyboard_8,
  kKeyKeyboard_9,
};
enum class GvaStatusTypes { kGvaSuccess = 0, kGvaError, kGvaNetworkError, kGvaDdsError, kGvaXmlError, kGvaRtpError };
enum class EventEnumType {
  kNoEvent = 0,
  kKeyEventPressed,
  kKeyEventReleased,
  kTouchEvent,
  kDdsEvent,
  kResizeEvent,
  kRedrawEvent,
  kWidgetUpdate
};
 
enum class SurfaceType {
  kSurfaceNone = 0,
  kSurfaceBlackout,
  kSurfaceFile,
  kSurfaceVideo,
  kSurfaceRgb24,
  kSurfaceCairo
};
 
enum class GvaFunctionEnum {
  kSituationalAwareness = 0,
  kWeapon,
  kDefensiveSystems,
  kSystems,
  kDriver,
  KSpecialToRole,
  kCommunications,
  kBattlefieldManagementSystem,
  kAlarmsX
};
enum class GvaAlarmType { kAlarmWarnings, kAlarmCaution, kAlarmAdvisory };
enum class GvaFunctionGroupEnum {
  kTop,
  kBottom,
  kLeft,
  kRight,
  kAlarmTable,
  kKeyboard,
  kAlarmsIndicator,
  kObjectBoxes
};
 
 
class StateBase {
 public:
  bool IsActive(const LabelStates* state) const {
    return ((*state != LabelStates::kLabelDisabled) && (*state != LabelStates::kLabelHidden));
  }
 
  void StateEnabledSelectedChanging(LabelStates* state) const {
    if ((*state != LabelStates::kLabelDisabled) && (*state != LabelStates::kLabelHidden)) {
      *state = LabelStates::kLabelEnabledSelectedChanging;
    }
  }
 
  void StateEnabledSelected(LabelStates* state) const {
    if ((*state != LabelStates::kLabelDisabled) && (*state != LabelStates::kLabelHidden)) {
      *state = LabelStates::kLabelEnabledSelected;
    }
  }
 
  void ResetEnabled(LabelStates* state) const {
    if ((*state == LabelStates::kLabelEnabledSelected) || (*state == LabelStates::kLabelEnabledSelectedChanging)) {
      *state = LabelStates::kLabelEnabled;
    }
  }
 
  void ResetEnabledSelected(LabelStates* state) const {
    if (*state == LabelStates::kLabelEnabledSelected) {
      *state = LabelStates::kLabelEnabled;
    }
  }
 
  void ResetEnabledSelectedChanging(LabelStates* state) const {
    if (*state == LabelStates::kLabelEnabledSelectedChanging) {
      *state = LabelStates::kLabelEnabled;
    }
  }
};
 
class FunctionSelect : public StateBase {
 public:
  bool visible;
 
  struct Labels {
    LabelStates state;
  };
  std::array<Labels, 8> labels;
 
  void SetEnabledEnabledChanging(int index) { StateEnabledSelectedChanging(&labels[index].state); }
 
  void SetEnabled(int index) {
    ResetAllEnabled();
    StateEnabledSelected(&labels[index].state);
  }
 
  void ResetAllEnabled() {
    for (auto& label : labels) {
      ResetEnabled(&label.state);
    }
  }
 
  void ResetAllEnabledSelected() {
    visible = true;
    for (auto& label : labels) {
      ResetEnabledSelected(&label.state);
    }
  }
 
  void ResetAllEnabledSelectedChanging() {
    for (auto& label : labels) {
      ResetEnabledSelectedChanging(&label.state);
    }
  }
};
 
struct FunctionKeys : public StateBase {
  bool visible;
  struct Labels {
    LabelStates state;
    bool toggleActive;
    bool toggleOn;
    std::string text;
    std::string toggleText1;
    std::string toggleText2;
  };
  std::array<Labels, 6> labels;
 
  bool Active(int index) { return IsActive(&labels[index].state); }
 
  void SetEnabledEnabledChanging(int index) { StateEnabledSelectedChanging(&labels[index].state); }
 
  void SetEnabled(int index) {
    ResetAllEnabled();
    StateEnabledSelected(&labels[index].state);
  }
 
  void ResetAllEnabled() {
    for (auto& label : labels) {
      ResetEnabled(&label.state);
    }
  }
 
  void ResetAllEnabledSelected() {
    visible = true;
    for (auto& label : labels) {
      ResetEnabledSelected(&label.state);
    }
  }
 
  void ResetAllEnabledSelectedChanging() {
    for (auto& label : labels) {
      ResetEnabledSelectedChanging(&label.state);
    }
  }
};
 
class CommonTaskKeys : public StateBase {
 public:
  bool visible_;
  struct Labels {
    LabelStates state_;
    std::string text_;
  };
  std::array<CommonTaskKeys::Labels, 8> labels_;
 
  void SetEnabledEnabledChanging(int index) {
    ResetAllEnabledSelected();
    StateEnabledSelectedChanging(&labels_[index].state_);
  }
 
  void SetDisabled(int index) { labels_[index].state_ = LabelStates::kLabelDisabled; }
 
  void ForceEnabledSelected(int index) { labels_[index].state_ = LabelStates::kLabelEnabled; }
 
  void SetEnabledSelected(int index) {
    ResetAllEnabled();
    StateEnabledSelected(&labels_[index].state_);
  }
 
  void ResetAllEnabled() {
    for (auto& label : labels_) {
      ResetEnabled(&label.state_);
    }
  }
 
  void ResetAllEnabledSelected() {
    for (auto& label : labels_) {
      ResetEnabledSelected(&label.state_);
    }
  }
 
  void ResetAllEnabledSelectedChanging() {
    for (auto& label : labels_) {
      ResetEnabledSelectedChanging(&label.state_);
    }
  }
};
 
struct LocationType {
  LocationEnum locationFormat;
  float lat;
  float lon;
};
 
struct ColourType {
  uint32_t red = 0;
  uint32_t green = 0;
  uint32_t blue = 0;
};
 
struct PointType {
  int32_t x = 0;
  int32_t y = 0;
};
 
struct ResolutionType {
  uint32_t width = 0;
  uint32_t height = 0;
  uint32_t depth = 0;
};
 
struct RgbUnpackedType {
  uint32_t r = 0;
  uint32_t g = 0;
  uint32_t b = 0;
};
 
struct TouchType {
  int x = 0;
  int y = 0;
};
 
struct KeyType {
  GvaKeyEnum key = GvaKeyEnum::kKeyUnknown;
  LabelStates label_state = LabelStates::kLabelHidden;
};
 
class EventGvaType {
 public:
  EventGvaType() = default;
 
  EventGvaType(int x, int y) {
    touch_.x = x;
    touch_.y = y;
    type_ = EventEnumType::kTouchEvent;
  }
 
  explicit EventGvaType(GvaKeyEnum key) : key_(key) { type_ = EventEnumType::kNoEvent; }
 
  EventEnumType type_;
  GvaKeyEnum key_ = GvaKeyEnum::kKeyUnknown;
  TouchType touch_;
  ResolutionType resize_;
};
 
}  // namespace gva
 
#endif  // HMICORE_GVA_H_