Example #1
0
void
Profile::Load(const ProfileMap &map, TaskBehaviour &settings)
{
  Load(map, settings.glide);

  map.Get(ProfileKeys::AATTimeMargin, settings.optimise_targets_margin);
  map.Get(ProfileKeys::AutoMc, settings.auto_mc);
  map.GetEnum(ProfileKeys::AutoMcMode, settings.auto_mc_mode);

  unsigned Temp;
  if (map.Get(ProfileKeys::RiskGamma, Temp))
    settings.risk_gamma = fixed(Temp) / 10;

  if (map.Get(ProfileKeys::SafetyMacCready, Temp))
    settings.safety_mc = fixed(Temp) / 10;

  map.Get(ProfileKeys::SafetyAltitudeArrival, settings.safety_height_arrival);
  map.GetEnum(ProfileKeys::TaskType, settings.task_type_default);
  Load(map, settings.start_margins);

  Load(map, settings.sector_defaults);
  Load(map, settings.ordered_defaults);

  map.GetEnum(ProfileKeys::AbortTaskMode, settings.abort_task_mode);

  Load(map, settings.route_planner);
}
Example #2
0
void
Profile::Load(const ProfileMap &map, DialogSettings &settings)
{
  map.GetEnum(ProfileKeys::AppTextInputStyle, settings.text_input_style);
  map.GetEnum(ProfileKeys::AppDialogTabStyle, settings.tab_style);
  map.Get(ProfileKeys::UserLevel, settings.expert);
}
Example #3
0
void
Profile::Load(const ProfileMap &map, UISettings &settings)
{
  Load(map, settings.display);

  map.Get(ProfileKeys::MenuTimeout, settings.menu_timeout);

#ifndef GNAV
  map.Get(ProfileKeys::UIScale, settings.scale);
  if (settings.scale < 50 || settings.scale > 200)
    settings.scale = 100;
#endif

  map.Get(ProfileKeys::EnableTAGauge, settings.enable_thermal_assistant_gauge);

  map.Get(ProfileKeys::AirspaceWarningDialog, settings.enable_airspace_warning_dialog);

  map.GetEnum(ProfileKeys::AppStatusMessageAlignment, settings.popup_message_position);

  map.GetEnum(ProfileKeys::HapticFeedback, settings.haptic_feedback);

  Load(map, settings.format);
  Load(map, settings.map);
  Load(map, settings.info_boxes);
  Load(map, settings.vario);
  Load(map, settings.traffic);
  Load(map, settings.pages);
  Load(map, settings.dialog);
  Load(map, settings.sound);
}
Example #4
0
void
Profile::Load(const ProfileMap &map, TrailSettings &settings)
{
  map.Get(ProfileKeys::TrailDrift, settings.wind_drift_enabled);
  map.Get(ProfileKeys::SnailWidthScale, settings.scaling_enabled);
  map.GetEnum(ProfileKeys::SnailType, settings.type);
  map.GetEnum(ProfileKeys::SnailTrail, settings.length);
}
Example #5
0
void
Profile::Load(const ProfileMap &map, SectorDefaults &settings)
{
  map.GetEnum(ProfileKeys::StartType, settings.start_type);
  map.Get(ProfileKeys::StartRadius, settings.start_radius);
  map.GetEnum(ProfileKeys::TurnpointType, settings.turnpoint_type);
  map.Get(ProfileKeys::TurnpointRadius, settings.turnpoint_radius);
  map.GetEnum(ProfileKeys::FinishType, settings.finish_type);
  map.Get(ProfileKeys::FinishRadius, settings.finish_radius);
}
Example #6
0
void
Profile::Load(const ProfileMap &map, FeaturesSettings &settings)
{
  map.GetEnum(ProfileKeys::FinalGlideTerrain, settings.final_glide_terrain);
  map.Get(ProfileKeys::BlockSTF, settings.block_stf_enabled);
  map.Get(ProfileKeys::EnableNavBaroAltitude, settings.nav_baro_altitude_enabled);
}
Example #7
0
void
Profile::Load(const ProfileMap &map, ComputerSettings &settings)
{
  Load(map, settings.wind);
  Load(map, settings.polar);
  Load(map, settings.team_code);
  Load(map, settings.voice);
  Load(map, settings.poi);
  Load(map, settings.features);
  Load(map, settings.airspace);
  Load(map, settings.circling);
  Load(map, settings.wave);

  map.GetEnum(ProfileKeys::AverEffTime, settings.average_eff_time);

  map.Get(ProfileKeys::SetSystemTimeFromGPS, settings.set_system_time_from_gps);

  LoadUTCOffset(map, settings.utc_offset);

  Load(map, settings.task);
  Load(map, settings.contest);
  Load(map, settings.logger);

#ifdef HAVE_TRACKING
  Load(map, settings.tracking);
#endif

  Load(map, settings.weather);
}
Example #8
0
void
Profile::Load(const ProfileMap &map, StartConstraints &constraints)
{
  map.GetEnum(ProfileKeys::StartHeightRef, constraints.max_height_ref);
  map.Get(ProfileKeys::StartMaxHeight, constraints.max_height);
  map.Get(ProfileKeys::StartMaxSpeed, constraints.max_speed);
}
Example #9
0
static void
Load(const ProfileMap &map, FAITriangleSettings &settings)
{
  FAITriangleSettings::Threshold threshold;
  if (map.GetEnum(ProfileKeys::FAITriangleThreshold, threshold) &&
      unsigned(threshold) < unsigned(FAITriangleSettings::Threshold::MAX))
    settings.threshold = threshold;
}
Example #10
0
void
Profile::Load(const ProfileMap &map, AirspaceRendererSettings &settings)
{
  map.GetEnum(ProfileKeys::AirspaceLabelSelection, settings.label_selection);
  map.Get(ProfileKeys::AirspaceBlackOutline, settings.black_outline);
  map.GetEnum(ProfileKeys::AltMode, settings.altitude_mode);
  map.Get(ProfileKeys::ClipAlt, settings.clip_altitude);

#if defined(HAVE_HATCHED_BRUSH) && defined(HAVE_ALPHA_BLEND)
  map.Get(ProfileKeys::AirspaceTransparency, settings.transparency);
#endif

  map.GetEnum(ProfileKeys::AirspaceFillMode, settings.fill_mode);

  for (unsigned i = 0; i < AIRSPACECLASSCOUNT; i++)
    Load(map, i, settings.classes[i]);
}
Example #11
0
void
Profile::Load(const ProfileMap &map, TrafficSettings &settings)
{
  map.Get(ProfileKeys::EnableFLARMGauge, settings.enable_gauge);
  map.Get(ProfileKeys::AutoCloseFlarmDialog, settings.auto_close_dialog);
  map.Get(ProfileKeys::FlarmAutoZoom, settings.auto_zoom);
  map.Get(ProfileKeys::FlarmNorthUp, settings.north_up);
  map.GetEnum(ProfileKeys::FlarmLocation, settings.gauge_location);
}
Example #12
0
static bool
GetPressureUnit(const ProfileMap &map, const char *key, Unit &value)
{
  Unit tmp;
  if (!map.GetEnum(key, tmp) || !ValidPressureUnit(tmp))
    return false;

  value = tmp;
  return true;
}
Example #13
0
void
Profile::Load(const ProfileMap &map, ContestSettings &settings)
{
  if (map.GetEnum(ProfileKeys::OLCRules, settings.contest)) {
    /* handle out-dated Sprint rule in profile */
    if (settings.contest == Contest::OLC_SPRINT)
      settings.contest = Contest::OLC_LEAGUE;
  }

  map.Get(ProfileKeys::PredictContest, settings.predict);
}
Example #14
0
void
Profile::Load(const ProfileMap &map, TrackingSettings &settings)
{
#ifdef HAVE_LIVETRACK24
  map.Get(ProfileKeys::TrackingInterval, settings.interval);
  map.GetEnum(ProfileKeys::TrackingVehicleType, settings.vehicleType);
  map.Get(ProfileKeys::TrackingVehicleName, settings.vehicle_name);
#endif
#ifdef HAVE_SKYLINES_TRACKING
  Load(map, settings.skylines);
#endif
#ifdef HAVE_LIVETRACK24
  Load(map, settings.livetrack24);
#endif
}
Example #15
0
static bool
GetSpeedUnit(const ProfileMap &map, const char *key, const char *legacy_key,
             Unit &value_r)
{
  Unit tmp;
  if (!map.GetEnum(key, tmp))
    /* migrate from XCSoar <= 6.2 profile */
    return GetLegacySpeedUnit(map, legacy_key, value_r);

  if (!ValidSpeedUnit(tmp))
    return false;

  value_r = tmp;
  return true;
}
Example #16
0
void
Profile::Load(const ProfileMap &map, LoggerSettings &settings)
{
  map.Get(ProfileKeys::LoggerTimeStepCruise, settings.time_step_cruise);
  map.Get(ProfileKeys::LoggerTimeStepCircling, settings.time_step_circling);

  if (!map.GetEnum(ProfileKeys::AutoLogger, settings.auto_logger)) {
    // Legacy
    bool disable_auto_logger;
    if (map.Get(ProfileKeys::DisableAutoLogger, disable_auto_logger))
      settings.auto_logger =
          disable_auto_logger ? LoggerSettings::AutoLogger::OFF :
                                LoggerSettings::AutoLogger::ON;
  }

  map.Get(ProfileKeys::LoggerID, settings.logger_id);
  map.Get(ProfileKeys::PilotName, settings.pilot_name);
  map.Get(ProfileKeys::EnableFlightLogger, settings.enable_flight_logger);
  map.Get(ProfileKeys::EnableNMEALogger, settings.enable_nmea_logger);
}
Example #17
0
void
Profile::Load(const ProfileMap &map,
              unsigned i, AirspaceClassRendererSettings &settings)
{
  char name[64];

  MakeAirspaceSettingName(name, "AirspaceDisplay", i);
  if (!map.Get(name, settings.display)) {
    // Load setting from legacy key-value pair
    MakeAirspaceSettingName(name, "AirspaceMode", i);

    unsigned value;
    if (map.Get(name, value))
      settings.display = (value & 0x1) != 0;
  }

#ifdef HAVE_HATCHED_BRUSH
  MakeAirspaceSettingName(name, "Brush", i);
  map.Get(name, settings.brush);
  if (settings.brush >= ARRAY_SIZE(AirspaceLook::brushes))
    settings.brush = 0;
#endif

  MakeAirspaceSettingName(name, "AirspaceBorderColor", i);
  if (!map.GetColor(name, settings.border_color))
    GetAirspaceColor(map, i, settings.border_color);

  MakeAirspaceSettingName(name, "AirspaceFillColor", i);
  if (!map.GetColor(name, settings.fill_color))
    GetAirspaceColor(map, i, settings.fill_color);

  MakeAirspaceSettingName(name, "AirspaceBorderWidth", i);
  map.Get(name, settings.border_width);

  MakeAirspaceSettingName(name, "AirspaceFillMode", i);
  map.GetEnum(name, settings.fill_mode);
}
Example #18
0
void
Profile::Load(const ProfileMap &map, DisplaySettings &settings)
{
  map.Get(ProfileKeys::AutoBlank, settings.enable_auto_blank);
  map.GetEnum(ProfileKeys::MapOrientation, settings.orientation);
}
Example #19
0
void
Profile::GetDeviceConfig(const ProfileMap &map, unsigned n,
                         DeviceConfig &config)
{
  char buffer[64];

  bool have_port_type = ReadPortType(map, n, config.port_type);

  MakeDeviceSettingName(buffer, "Port", n, "BluetoothMAC");
  map.Get(buffer, config.bluetooth_mac);

  MakeDeviceSettingName(buffer, "Port", n, "IOIOUartID");
  map.Get(buffer, config.ioio_uart_id);

  MakeDeviceSettingName(buffer, "Port", n, "IPAddress");
  if (!map.Get(buffer, config.ip_address))
    config.ip_address.clear();

  MakeDeviceSettingName(buffer, "Port", n, "TCPPort");
  if (!map.Get(buffer, config.tcp_port))
    config.tcp_port = 4353;

  config.path.clear();
  if ((!have_port_type ||
       config.port_type == DeviceConfig::PortType::SERIAL) &&
      !LoadPath(map, config, n) && LoadPortIndex(map, config, n))
    config.port_type = DeviceConfig::PortType::SERIAL;

  MakeDeviceSettingName(buffer, "Port", n, "BaudRate");
  if (!map.Get(buffer, config.baud_rate)) {
    /* XCSoar before 6.2 used to store a "speed index", not the real
       baud rate - try to import the old settings */

    static constexpr unsigned speed_index_table[] = {
      1200,
      2400,
      4800,
      9600,
      19200,
      38400,
      57600,
      115200
    };

    MakeDeviceSettingName(buffer, "Speed", n, "Index");
    unsigned speed_index;
    if (map.Get(buffer, speed_index) &&
        speed_index < ARRAY_SIZE(speed_index_table))
      config.baud_rate = speed_index_table[speed_index];
  }

  MakeDeviceSettingName(buffer, "Port", n, "BulkBaudRate");
  if (!map.Get(buffer, config.bulk_baud_rate))
    config.bulk_baud_rate = 0;

  strcpy(buffer, "DeviceA");
  buffer[strlen(buffer) - 1] += n;
  map.Get(buffer, config.driver_name);

  MakeDeviceSettingName(buffer, "Port", n, "Enabled");
  map.Get(buffer, config.enabled);

  MakeDeviceSettingName(buffer, "Port", n, "SyncFromDevice");
  map.Get(buffer, config.sync_from_device);

  MakeDeviceSettingName(buffer, "Port", n, "SyncToDevice");
  map.Get(buffer, config.sync_to_device);

  MakeDeviceSettingName(buffer, "Port", n, "K6Bt");
  map.Get(buffer, config.k6bt);

  MakeDeviceSettingName(buffer, "Port", n, "I2C_Bus");
  map.Get(buffer, config.i2c_bus);

  MakeDeviceSettingName(buffer, "Port", n, "I2C_Addr");
  map.Get(buffer, config.i2c_addr);

  MakeDeviceSettingName(buffer, "Port", n, "PressureUse");
  map.GetEnum(buffer, config.press_use);

  MakeDeviceSettingName(buffer, "Port", n, "SensorOffset");
  map.Get(buffer, config.sensor_offset);

  MakeDeviceSettingName(buffer, "Port", n, "SensorFactor");
  map.Get(buffer, config.sensor_factor);

  MakeDeviceSettingName(buffer, "Port", n, "UseSecondDevice");
  map.Get(buffer, config.use_second_device);

  MakeDeviceSettingName(buffer, "Port", n, "SecondDevice");
  map.Get(buffer, config.driver2_name);
}
Example #20
0
void
Profile::Load(const ProfileMap &map, MapSettings &settings)
{
  map.Get(ProfileKeys::CircleZoom, settings.circle_zoom_enabled);
  map.Get(ProfileKeys::MaxAutoZoomDistance, settings.max_auto_zoom_distance);
  map.Get(ProfileKeys::DrawTopography, settings.topography_enabled);

  LoadTerrainRendererSettings(map, settings.terrain);

  map.GetEnum(ProfileKeys::AircraftSymbol, settings.aircraft_symbol);

  map.Get(ProfileKeys::DetourCostMarker, settings.detour_cost_markers_enabled);
  map.GetEnum(ProfileKeys::DisplayTrackBearing, settings.display_ground_track);
  map.Get(ProfileKeys::AutoZoom, settings.auto_zoom_enabled);

  map.GetEnum(ProfileKeys::WindArrowStyle, settings.wind_arrow_style);

  settings.waypoint.LoadFromProfile();

  Load(map, settings.airspace);

  map.Get(ProfileKeys::GliderScreenPosition, settings.glider_screen_position);

  bool orientation_found = false;

  unsigned Temp = (unsigned)MapOrientation::NORTH_UP;
  if (map.Get(ProfileKeys::OrientationCircling, Temp)) {
    orientation_found = true;

    if (IsValidMapOrientation(Temp))
      settings.circling_orientation = (MapOrientation)Temp;
  }

  Temp = (unsigned)MapOrientation::NORTH_UP;
  if (map.Get(ProfileKeys::OrientationCruise, Temp)) {
    orientation_found = true;

    if (IsValidMapOrientation(Temp))
      settings.cruise_orientation = (MapOrientation)Temp;
  }

  if (!orientation_found) {
    Temp = 1;
    map.Get(ProfileKeys::DisplayUpValue, Temp);
    switch (Temp) {
    case 0:
      settings.cruise_orientation = MapOrientation::TRACK_UP;
      settings.circling_orientation = MapOrientation::TRACK_UP;
      break;
    case 1:
      settings.cruise_orientation = MapOrientation::NORTH_UP;
      settings.circling_orientation = MapOrientation::NORTH_UP;
      break;
    case 2:
      settings.cruise_orientation = MapOrientation::TRACK_UP;
      settings.circling_orientation = MapOrientation::NORTH_UP;
      break;
    case 3:
      settings.cruise_orientation = MapOrientation::TRACK_UP;
      settings.circling_orientation = MapOrientation::TARGET_UP;
      break;
    case 4:
      settings.cruise_orientation = MapOrientation::NORTH_UP;
      settings.circling_orientation = MapOrientation::TRACK_UP;
      break;
    }
  }

  fixed tmp;
  if (map.Get(ProfileKeys::ClimbMapScale, tmp))
    settings.circling_scale = Clamp(tmp / 10000, fixed(0.0003), fixed(10));

  if (map.Get(ProfileKeys::CruiseMapScale, tmp))
    settings.cruise_scale = Clamp(tmp / 10000, fixed(0.0003), fixed(10));

  map.GetEnum(ProfileKeys::MapShiftBias, settings.map_shift_bias);
  map.Get(ProfileKeys::EnableFLARMMap, settings.show_flarm_on_map);

  map.Get(ProfileKeys::EnableThermalProfile, settings.show_thermal_profile);
  map.Get(ProfileKeys::EnableFinalGlideBarMC0,
          settings.final_glide_bar_mc0_enabled);
  map.GetEnum(ProfileKeys::FinalGlideBarDisplayMode,
              settings.final_glide_bar_display_mode);
  map.Get(ProfileKeys::ShowFAITriangleAreas,
          settings.show_fai_triangle_areas);
  ::Load(map, settings.fai_triangle_settings);

  map.Get(ProfileKeys::EnableVarioBar,
          settings.vario_bar_enabled);

  Load(map, settings.trail);
  Load(map, settings.item_list);
}
Example #21
0
void
Profile::Load(const ProfileMap &map, FinishConstraints &constraints)
{
  map.GetEnum(ProfileKeys::FinishHeightRef, constraints.min_height_ref);
  map.Get(ProfileKeys::FinishMinHeight, constraints.min_height);
}
Example #22
0
void
Profile::Load(const ProfileMap &map, FormatSettings &settings)
{
  map.GetEnum(ProfileKeys::LatLonUnits, settings.coordinate_format);
  LoadUnits(map, settings.units);
}