void
LoggerConfigPanel::Prepare(ContainerWindow &parent, const PixelRect &rc)
{
const ComputerSettings &settings_computer = CommonInterface::GetComputerSettings();
const LoggerSettings &logger = settings_computer.logger;
RowFormWidget::Prepare(parent, rc);
AddTime(_("Time step cruise"),
_("This is the time interval between logged points when not circling."),
1, 30, 1, logger.time_step_cruise);
SetExpertRow(LoggerTimeStepCruise);
AddTime(_("Time step circling"),
_("This is the time interval between logged points when circling."),
1, 30, 1, logger.time_step_circling);
SetExpertRow(LoggerTimeStepCircling);
AddEnum(_("Auto. logger"),
_("Enables the automatic starting and stopping of logger on takeoff and landing "
"respectively. Disable when flying paragliders."),
auto_logger_list, (unsigned)logger.auto_logger);
SetExpertRow(DisableAutoLogger);
AddBoolean(_("NMEA logger"),
_("Enable the NMEA logger on startup? If this option is disabled, "
"the NMEA logger can still be started manually."),
logger.enable_nmea_logger);
SetExpertRow(EnableNMEALogger);
AddBoolean(_("Log book"), _("Logs each start and landing."),
logger.enable_flight_logger);
SetExpertRow(EnableFlightLogger);
}
void
GlideComputerConfigPanel::Prepare(ContainerWindow &parent, const PixelRect &rc)
{
const ComputerSettings &settings_computer = XCSoarInterface::GetComputerSettings();
RowFormWidget::Prepare(parent, rc);
static gcc_constexpr_data StaticEnumChoice auto_mc_list[] = {
{ (unsigned)TaskBehaviour::AutoMCMode::FINALGLIDE, N_("Final glide"),
N_("Adjusts MC for fastest arrival. For OLC sprint tasks, the MacCready is adjusted in "
"order to cover the greatest distance in the remaining time and reach the finish height.") },
{ (unsigned)TaskBehaviour::AutoMCMode::CLIMBAVERAGE, N_("Trending average climb"),
N_("Sets MC to the trending average climb rate based on all climbs.") },
{ (unsigned)TaskBehaviour::AutoMCMode::BOTH, N_("Both"),
N_("Uses trending average during task, then fastest arrival when in final glide mode.") },
{ 0 }
};
AddEnum(_("Auto MC mode"),
_("This option defines which auto MacCready algorithm is used."),
auto_mc_list, (unsigned)settings_computer.task.auto_mc_mode);
AddBoolean(_("Block speed to fly"),
_("If enabled, the command speed in cruise is set to the MacCready speed to fly in "
"no vertical air-mass movement. If disabled, the command speed in cruise is set "
"to the dolphin speed to fly, equivalent to the MacCready speed with vertical "
"air-mass movement."),
settings_computer.features.block_stf_enabled);
SetExpertRow(BlockSTF);
AddBoolean(_("Nav. by baro altitude"),
_("When enabled and if connected to a barometric altimeter, barometric altitude is "
"used for all navigation functions. Otherwise GPS altitude is used."),
settings_computer.features.nav_baro_altitude_enabled);
SetExpertRow(EnableNavBaroAltitude);
AddBoolean(_("Flap forces cruise"),
_("When Vega variometer is connected and this option is true, the positive flap "
"setting switches the flight mode between circling and cruise."),
settings_computer.external_trigger_cruise_enabled);
SetExpertRow(EnableExternalTriggerCruise);
static gcc_constexpr_data StaticEnumChoice aver_eff_list[] = {
{ ae15seconds, _T("15 s"), N_("Preferred period for paragliders.") },
{ ae30seconds, _T("30 s") },
{ ae60seconds, _T("60 s") },
{ ae90seconds, _T("90 s"), N_("Preferred period for gliders.") },
{ ae2minutes, _T("2 min") },
{ ae3minutes, _T("3 min") },
{ 0 }
};
AddEnum(_("L/D average period"),
_("Here you can decide on how many seconds of flight this calculation must be done. "
"Normally for gliders a good value is 90-120 seconds, and for paragliders 15 seconds."),
aver_eff_list, settings_computer.average_eff_time);
SetExpertRow(AverEffTime);
}
void
MapDisplayConfigPanel::Prepare(ContainerWindow &parent, const PixelRect &rc)
{
RowFormWidget::Prepare(parent, rc);
const MapSettings &settings_map = CommonInterface::GetMapSettings();
const PageSettings &page_settings = CommonInterface::GetUISettings().pages;
AddEnum(_("Cruise orientation"),
_("Determines how the screen is rotated with the glider"),
orientation_list,
(unsigned)settings_map.cruise_orientation,
this);
AddEnum(_("Circling orientation"),
_("Determines how the screen is rotated with the glider while circling"),
orientation_list,
(unsigned)settings_map.circling_orientation,
this);
AddBoolean(_("Circling zoom"),
_("If enabled, then the map will zoom in automatically when entering circling mode and zoom out automatically when leaving circling mode."),
settings_map.circle_zoom_enabled);
AddEnum(_("Map shift reference"),
_("Determines what is used to shift the glider from the map center"),
shift_bias_list,
(unsigned)settings_map.map_shift_bias,
this);
SetExpertRow(MAP_SHIFT_BIAS);
AddInteger(_("Glider position offset"),
_("Defines the location of the glider drawn on the screen in percent from the screen edge."),
_T("%d %%"), _T("%d"), 10, 50, 5,
settings_map.glider_screen_position);
SetExpertRow(GliderScreenPosition);
AddFloat(_("Max. auto zoom distance"),
_("The upper limit for auto zoom distance."),
_T("%.0f %s"), _T("%.0f"), fixed(20), fixed(250), fixed(10), false,
UnitGroup::DISTANCE, settings_map.max_auto_zoom_distance);
SetExpertRow(MaxAutoZoomDistance);
AddBoolean(_("Distinct page zoom"),
_("Maintain one map zoom level on each page."),
page_settings.distinct_zoom);
SetExpertRow(PAGES_DISTINCT_ZOOM);
UpdateVisibilities();
}
void
GaugesConfigPanel::Prepare(ContainerWindow &parent, const PixelRect &rc)
{
const UISettings &ui_settings = CommonInterface::GetUISettings();
const MapSettings &map_settings = CommonInterface::GetMapSettings();
RowFormWidget::Prepare(parent, rc);
AddBoolean(_("FLARM radar"),
_("This enables the display of the FLARM radar gauge. The track bearing of the target relative to the track bearing of the aircraft is displayed as an arrow head, and a triangle pointing up or down shows the relative altitude of the target relative to you. In all modes, the color of the target indicates the threat level."),
ui_settings.traffic.enable_gauge);
AddBoolean(_("Auto close FLARM"),
_("Setting this to \"On\" will automatically close the FLARM dialog if there is no traffic. \"Off\" will keep the dialog open even without current traffic."),
ui_settings.traffic.auto_close_dialog);
SetExpertRow(AutoCloseFlarmDialog);
AddBoolean(_("Thermal assistant"),
_("This enables the display of the thermal assistant gauge."),
ui_settings.enable_thermal_assistant_gauge);
AddBoolean(_("Thermal band"),
_("This enables the display of the thermal profile (climb band) display on the map."),
map_settings.show_thermal_profile);
AddEnum(_("Final glide bar"),
_("If set to \"On\" the final glide will always be shown, if set to \"Auto\" it will be shown when approaching the final glide possibility."),
final_glide_bar_display_mode_list,
(unsigned)map_settings.final_glide_bar_display_mode,
this);
SetExpertRow(FinalGlideBarDisplayModeControl);
AddBoolean(_("Final glide bar MC0"),
_("If set to ON the final glide bar will show a second arrow indicating the required height "
"to reach the final waypoint at MC zero."),
map_settings.final_glide_bar_mc0_enabled);
SetExpertRow(EnableFinalGlideBarMC0);
SetRowVisible(EnableFinalGlideBarMC0,
map_settings.final_glide_bar_display_mode !=
FinalGlideBarDisplayMode::OFF);
AddBoolean(_("Vario bar"),
_("If set to ON the vario bar will be shown"),
map_settings.vario_bar_enabled);
SetExpertRow(EnableVarioBar);
}
void
TimeConfigPanel::Prepare(ContainerWindow &parent, const PixelRect &rc)
{
RowFormWidget::Prepare(parent, rc);
const ComputerSettings &settings_computer = XCSoarInterface::GetComputerSettings();
int utc_offset = settings_computer.utc_offset;
AddTime(_("UTC offset"),
_("The UTC offset field allows the UTC local time offset to be specified. The local "
"time is displayed below in order to make it easier to verify the correct offset "
"has been entered."),
-13 * 60 * 60, 13 * 60 * 60, 30 * 60, utc_offset, 2, this);
Add(_("Local time"), 0, true);
SetLocalTime(utc_offset);
AddBoolean(_("Use GPS time"),
_("If enabled sets the clock of the computer to the GPS time once a fix "
"is set. This is only necessary if your computer does not have a "
"real-time clock with battery backup or your computer frequently runs "
"out of battery power or otherwise loses time."),
settings_computer.set_system_time_from_gps);
SetExpertRow(SystemTimeFromGPS);
}
void
LayoutConfigPanel::Prepare(ContainerWindow &parent, const PixelRect &rc)
{
const UISettings &ui_settings = CommonInterface::GetUISettings();
RowFormWidget::Prepare(parent, rc);
if (Display::RotateSupported())
AddEnum(_("Display orientation"), _("Rotate the display on devices that support it."),
display_orientation_list, (unsigned)ui_settings.display.orientation);
else
AddDummy();
AddEnum(_("InfoBox geometry"),
_("A list of possible InfoBox layouts. Do some trials to find the best for your screen size."),
info_box_geometry_list, (unsigned)ui_settings.info_boxes.geometry);
AddEnum(_("FLARM display"), _("Choose a location for the FLARM display."),
flarm_display_location_list,
(unsigned)ui_settings.traffic.gauge_location);
SetExpertRow(AppFlarmLocation);
AddEnum(_("Tab dialog style"), NULL,
tabdialog_style_list, (unsigned)ui_settings.dialog.tab_style);
AddEnum(_("Message display"), NULL,
popup_msg_position_list,
(unsigned)ui_settings.popup_message_position);
SetExpertRow(AppStatusMessageAlignment);
AddBoolean(_("Inverse InfoBoxes"), _("If true, the InfoBoxes are white on black, otherwise black on white."),
ui_settings.info_boxes.inverse);
SetExpertRow(AppInverseInfoBox);
if (HasColors()) {
AddBoolean(_("Colored InfoBoxes"),
_("If true, certain InfoBoxes will have coloured text. For example, the active waypoint "
"InfoBox will be blue when the glider is above final glide."),
ui_settings.info_boxes.use_colors);
SetExpertRow(AppInfoBoxColors);
} else
AddDummy();
AddEnum(_("InfoBox border"), nullptr, infobox_border_list,
unsigned(ui_settings.info_boxes.border_style));
SetExpertRow(AppInfoBoxBorder);
}
void
SiteConfigPanel::Prepare(ContainerWindow &parent, const PixelRect &rc)
{
WndProperty *wp = Add(_T(""), 0, true);
wp->SetText(GetPrimaryDataPath().c_str());
wp->SetEnabled(false);
AddFile(_("Map database"),
_("The name of the file (.xcm) containing terrain, topography, and optionally "
"waypoints, their details and airspaces."),
ProfileKeys::MapFile, _T("*.xcm\0*.lkm\0"), FileType::MAP);
AddFile(_("Waypoints"),
_("Primary waypoints file. Supported file types are Cambridge/WinPilot files (.dat), "
"Zander files (.wpz) or SeeYou files (.cup)."),
ProfileKeys::WaypointFile, WAYPOINT_FILE_PATTERNS,
FileType::WAYPOINT);
AddFile(_("More waypoints"),
_("Secondary waypoints file. This may be used to add waypoints for a competition."),
ProfileKeys::AdditionalWaypointFile, WAYPOINT_FILE_PATTERNS,
FileType::WAYPOINT);
SetExpertRow(AdditionalWaypointFile);
AddFile(_("Watched waypoints"),
_("Waypoint file containing special waypoints for which additional computations like "
"calculation of arrival height in map display always takes place. Useful for "
"waypoints like known reliable thermal sources (e.g. powerplants) or mountain passes."),
ProfileKeys::WatchedWaypointFile, WAYPOINT_FILE_PATTERNS,
FileType::WAYPOINT);
SetExpertRow(WatchedWaypointFile);
AddFile(_("Airspaces"), _("The file name of the primary airspace file."),
ProfileKeys::AirspaceFile, _T("*.txt\0*.air\0*.sua\0"),
FileType::AIRSPACE);
AddFile(_("More airspaces"), _("The file name of the secondary airspace file."),
ProfileKeys::AdditionalAirspaceFile, _T("*.txt\0*.air\0*.sua\0"),
FileType::AIRSPACE);
SetExpertRow(AdditionalAirspaceFile);
AddFile(_("Waypoint details"),
_("The file may contain extracts from enroute supplements or other contributed "
"information about individual waypoints and airfields."),
ProfileKeys::AirfieldFile, _T("*.txt\0"));
SetExpertRow(AirfieldFile);
}
void
SymbolsConfigPanel::Prepare(ContainerWindow &parent, const PixelRect &rc)
{
const MapSettings &settings_map = CommonInterface::GetMapSettings();
AddEnum(_("Ground track"),
_("Display the ground track as a grey line on the map."),
ground_track_mode_list, (unsigned)settings_map.display_ground_track);
AddBoolean(_("FLARM traffic"), _("This enables the display of FLARM traffic on the map window."),
settings_map.show_flarm_on_map);
AddEnum(_("Trail length"),
_("Determines whether and how long a snail trail is drawn behind the glider."),
trail_length_list,
(unsigned)settings_map.trail.length, this);
SetExpertRow(TRAIL_LENGTH);
AddBoolean(_("Trail drift"),
_("Determines whether the snail trail is drifted with the wind when displayed in "
"circling mode. Switched Off, "
"the snail trail stays uncompensated for wind drift."),
settings_map.trail.wind_drift_enabled);
SetExpertRow(TRAIL_DRIFT);
AddEnum(_("Trail type"),
_("Sets the type of the snail trail display."), trail_type_list, (int)settings_map.trail.type);
SetExpertRow(TRAIL_TYPE);
AddBoolean(_("Trail scaled"),
_("If set to ON the snail trail width is scaled according to the vario signal."),
settings_map.trail.scaling_enabled);
SetExpertRow(TRAIL_WIDTH);
AddBoolean(_("Detour cost markers"),
_("If the aircraft heading deviates from the current waypoint, markers are displayed "
"at points ahead of the aircraft. The value of each marker is the extra distance "
"required to reach that point as a percentage of straight-line distance to the waypoint."),
settings_map.detour_cost_markers_enabled);
SetExpertRow(ENABLE_DETOUR_COST_MARKERS);
AddEnum(_("Aircraft symbol"), NULL, aircraft_symbol_list,
(unsigned)settings_map.aircraft_symbol);
SetExpertRow(AIRCRAFT_SYMBOL);
AddEnum(_("Wind arrow"), _("Determines the way the wind arrow is drawn on the map."),
wind_arrow_list, (unsigned)settings_map.wind_arrow_style);
SetExpertRow(WIND_ARROW_STYLE);
AddBoolean(_("FAI triangle areas"),
_("Show FAI triangle areas on the map."),
settings_map.show_fai_triangle_areas);
SetExpertRow(SHOW_FAI_TRIANGLE_AREAS);
ShowTrailControls(settings_map.trail.length != TrailSettings::Length::OFF);
}
void
LoggerConfigPanel::Prepare(ContainerWindow &parent, const PixelRect &rc)
{
const ComputerSettings &settings_computer = CommonInterface::GetComputerSettings();
const LoggerSettings &logger = settings_computer.logger;
const Plane &plane = settings_computer.plane;
RowFormWidget::Prepare(parent, rc);
AddTime(_("Time step cruise"),
_("This is the time interval between logged points when not circling."),
1, 30, 1, logger.time_step_cruise);
SetExpertRow(LoggerTimeStepCruise);
AddTime(_("Time step circling"),
_("This is the time interval between logged points when circling."),
1, 30, 1, logger.time_step_circling);
SetExpertRow(LoggerTimeStepCircling);
AddText(_("Pilot name"), NULL, logger.pilot_name);
AddText(_("Aircraft type"), NULL, plane.type);
AddText(_("Aircraft reg."), NULL, plane.registration);
AddText(_("Competition ID"), NULL, plane.competition_id);
AddText(_("Logger ID"), NULL, logger.logger_id);
AddBoolean(_("Short file name"),
_("This determines whether the logger uses the short IGC file name or the "
"long IGC file name. Example short name (81HXABC1.IGC), long name "
"(2008-01-18-XXX-ABC-01.IGC)."),
logger.short_name);
SetExpertRow(LoggerShortName);
AddEnum(_("Auto. logger"),
_("Enables the automatic starting and stopping of logger on takeoff and landing "
"respectively. Disable when flying paragliders."),
auto_logger_list, (unsigned)logger.auto_logger);
SetExpertRow(DisableAutoLogger);
AddBoolean(_("Log book"), _("Logs each start and landing."),
logger.enable_flight_logger);
SetExpertRow(EnableFlightLogger);
}
void
AudioVarioConfigPanel::Prepare(ContainerWindow &parent, const PixelRect &rc)
{
RowFormWidget::Prepare(parent, rc);
if (!AudioVarioGlue::HaveAudioVario())
return;
const auto &settings = CommonInterface::GetUISettings().sound.vario;
AddBoolean(_("Audio vario"),
_("Emulate the sound of an electronic vario."),
settings.enabled);
AddInteger(_("Volume"), NULL, _T("%u %%"), _T("%u"),
0, 100, 1, settings.volume);
AddBoolean(_("Enable Deadband"),
_("Mute the audio output in when the current lift is in a certain "
"range around zero"), settings.dead_band_enabled);
AddSpacer();
SetExpertRow(SPACER);
AddInteger(_("Min. Frequency"),
_("The tone frequency that is played at maximum sink rate."),
_T("%u Hz"), _T("%u"),
50, 3000, 50, settings.min_frequency);
SetExpertRow(MIN_FREQUENCY);
AddInteger(_("Zero Frequency"),
_("The tone frequency that is played at zero climb rate."),
_T("%u Hz"), _T("%u"),
50, 3000, 50, settings.zero_frequency);
SetExpertRow(ZERO_FREQUENCY);
AddInteger(_("Max. Frequency"),
_("The tone frequency that is played at maximum climb rate."),
_T("%u Hz"), _T("%u"),
50, 3000, 50, settings.max_frequency);
SetExpertRow(MAX_FREQUENCY);
}
void
SiteConfigPanel::Prepare(ContainerWindow &parent, const PixelRect &rc)
{
buttonWaypoints = ((WndButton *)ConfigPanel::GetForm().FindByName(_T("cmdWaypoints")));
assert (buttonWaypoints);
buttonWaypoints->SetOnClickNotify(OnWaypoints);
WndProperty *wp = Add(_T(""), 0, true);
wp->SetText(GetPrimaryDataPath());
wp->SetEnabled(false);
AddFileReader(_("Map database"),
_("The name of the file (.xcm) containing terrain, topography, and optionally "
"waypoints, their details and airspaces."),
szProfileMapFile, _T("*.xcm\0*.lkm\0"));
AddFileReader(_("Waypoints"),
_("Primary waypoints file. Supported file types are Cambridge/WinPilot files (.dat), "
"Zander files (.wpz) or SeeYou files (.cup)."),
szProfileWaypointFile, _T("*.dat\0*.xcw\0*.cup\0*.wpz\0*.wpt\0"));
AddFileReader(_("More waypoints"),
_("Secondary waypoints file. This may be used to add waypoints for a competition."),
szProfileAdditionalWaypointFile, _T("*.dat\0*.xcw\0*.cup\0*.wpz\0*.wpt\0"));
SetExpertRow(AdditionalWaypointFile);
AddFileReader(_("Watched waypoints"),
_("Waypoint file containing special waypoints for which additional computations like "
"calculation of arrival height in map display always takes place. Useful for "
"waypoints like known reliable thermal sources (e.g. powerplants) or mountain passes."),
szProfileWatchedWaypointFile, _T("*.dat\0*.xcw\0*.cup\0*.wpz\0*.wpt\0"));
SetExpertRow(WatchedWaypointFile);
AddFileReader(_("Airspaces"), _("The file name of the primary airspace file."),
szProfileAirspaceFile, _T("*.txt\0*.air\0*.sua\0"));
AddFileReader(_("More airspaces"), _("The file name of the secondary airspace file."),
szProfileAdditionalAirspaceFile, _T("*.txt\0*.air\0*.sua\0"));
SetExpertRow(AdditionalAirspaceFile);
AddFileReader(_("Terrain file"), _("The name of the file containing digital elevation terrain data."),
szProfileTerrainFile, _T("*.jp2\0"));
SetExpertRow(TerrainFile);
AddFileReader(_("Topography file"), _("Specifies the file defining the topographical features."),
szProfileTopographyFile, _T("*.tpl\0"));
SetExpertRow(TopographyFile);
AddFileReader(_("Waypoint details"),
_("The file may contain extracts from enroute supplements or other contributed "
"information about individual waypoints and airfields."),
szProfileAirfieldFile, _T("*.txt\0"));
SetExpertRow(AirfieldFile);
}
void
SymbolsConfigPanel::Prepare(ContainerWindow &parent, const PixelRect &rc)
{
const MapSettings &settings_map = CommonInterface::GetMapSettings();
AddEnum(_("Track bearing"),
_("Display the track bearing (ground track projection) on the map."),
track_bearing_mode_list, settings_map.display_track_bearing);
AddBoolean(_("FLARM traffic"), _("This enables the display of FLARM traffic on the map window."),
settings_map.show_flarm_on_map);
AddEnum(_("Trail length"), NULL, trail_length_list,
(unsigned)settings_map.trail.length, this);
SetExpertRow(Trail);
AddBoolean(_("Trail drift"),
_("Determines whether the snail trail is drifted with the wind when displayed in "
"circling mode."),
settings_map.trail.wind_drift_enabled);
SetExpertRow(TrailDrift);
AddEnum(_("Trail type"), NULL, trail_type_list, (int)settings_map.trail.type);
SetExpertRow(SnailType);
AddBoolean(_("Trail scaled"),
_("If set to ON the snail trail width is scaled according to the vario signal."),
settings_map.trail.scaling_enabled);
SetExpertRow(SnailWidthScale);
AddBoolean(_("Detour cost markers"),
_("If the aircraft heading deviates from the current waypoint, markers are displayed "
"at points ahead of the aircraft. The value of each marker is the extra distance "
"required to reach that point as a percentage of straight-line distance to the waypoint."),
settings_map.detour_cost_markers_enabled);
SetExpertRow(DetourCostMarker);
AddEnum(_("Aircraft symbol"), NULL, aircraft_symbol_list, settings_map.aircraft_symbol);
SetExpertRow(AircraftSymbol);
AddEnum(_("Wind arrow"), _("Determines the way the wind arrow is drawn on the map."),
wind_arrow_list, settings_map.wind_arrow_style);
SetExpertRow(WindArrowStyle);
ShowTrailControls(settings_map.trail.length != TrailSettings::Length::OFF);
}
void
InfoBoxesConfigPanel::Prepare(ContainerWindow &parent, const PixelRect &rc)
{
const InfoBoxSettings &settings = CommonInterface::GetUISettings().info_boxes;
RowFormWidget::Prepare(parent, rc);
for (unsigned i = 0; i < InfoBoxSettings::MAX_PANELS; i++) {
const InfoBoxSettings::Panel &data = settings.panels[i];
AddButton(gettext(data.name), *this, i);
if (i>2)
SetExpertRow(i);
}
AddBoolean(_("Use final glide mode"),
_("Controls whether the \"final glide\" InfoBox mode should be used on \"auto\" pages."),
settings.use_final_glide);
}
void
VarioConfigPanel::Prepare(ContainerWindow &parent, const PixelRect &rc)
{
const VarioSettings &settings = CommonInterface::GetUISettings().vario;
RowFormWidget::Prepare(parent, rc);
AddBoolean(_("Speed arrows"),
_("Whether to show speed command arrows on the vario gauge. When shown, in cruise mode, "
"arrows point up to command slow down; arrows point down to command speed up."),
settings.show_speed_to_fly);
SetExpertRow(AppGaugeVarioSpeedToFly);
AddBoolean(_("Show average"),
_("Whether to show the average climb rate. In cruise mode, this switches to showing the "
"average netto airmass rate."),
settings.show_average);
SetExpertRow(AppGaugeVarioAvgText);
AddBoolean(_("Show MacReady"), _("Whether to show the MacCready setting."), settings.show_mc);
SetExpertRow(AppGaugeVarioMc);
AddBoolean(_("Show bugs"), _("Whether to show the bugs percentage."), settings.show_bugs);
SetExpertRow(AppGaugeVarioBugs);
AddBoolean(_("Show ballast"), _("Whether to show the ballast percentage."), settings.show_ballast);
SetExpertRow(AppGaugeVarioBallast);
AddBoolean(_("Show gross"), _("Whether to show the gross climb rate."), settings.show_gross);
SetExpertRow(AppGaugeVarioGross);
AddBoolean(_("Averager needle"),
_("If true, the vario gauge will display a hollow averager needle. During cruise, this "
"needle displays the average netto value. During circling, this needle displays the "
"average gross value."),
settings.show_average_needle);
SetExpertRow(AppAveNeedle);
}
void
AudioVarioConfigPanel::Prepare(ContainerWindow &parent, const PixelRect &rc)
{
RowFormWidget::Prepare(parent, rc);
if (!AudioVarioGlue::HaveAudioVario())
return;
const auto &settings = CommonInterface::GetUISettings().sound.vario;
AddBoolean(_("Audio vario"),
_("Emulate the sound of an electronic vario."),
settings.enabled);
AddInteger(_("Volume"), nullptr, _T("%u %%"), _T("%u"),
0, 100, 1, settings.volume);
AddBoolean(_("Enable Deadband"),
_("Mute the audio output in when the current lift is in a certain "
"range around zero"), settings.dead_band_enabled);
AddSpacer();
SetExpertRow(SPACER);
AddInteger(_("Min. Frequency"),
_("The tone frequency that is played at maximum sink rate."),
_T("%u Hz"), _T("%u"),
50, 3000, 50, settings.min_frequency);
SetExpertRow(MIN_FREQUENCY);
AddInteger(_("Zero Frequency"),
_("The tone frequency that is played at zero climb rate."),
_T("%u Hz"), _T("%u"),
50, 3000, 50, settings.zero_frequency);
SetExpertRow(ZERO_FREQUENCY);
AddInteger(_("Max. Frequency"),
_("The tone frequency that is played at maximum climb rate."),
_T("%u Hz"), _T("%u"),
50, 3000, 50, settings.max_frequency);
SetExpertRow(MAX_FREQUENCY);
AddSpacer();
SetExpertRow(SPACER2);
AddFloat(_("Deadband min. lift"),
_("Below this lift threshold the vario will start to play sounds if the 'Deadband' feature is enabled."),
_T("%.1f %s"), _T("%.1f"),
Units::ToUserVSpeed(-5), 0,
GetUserVerticalSpeedStep(), false, UnitGroup::VERTICAL_SPEED,
settings.min_dead);
SetExpertRow(DEAD_BAND_MIN);
DataFieldFloat &db_min = (DataFieldFloat &)GetDataField(DEAD_BAND_MIN);
db_min.SetFormat(GetUserVerticalSpeedFormat(false, true));
AddFloat(_("Deadband max. lift"),
_("Above this lift threshold the vario will start to play sounds if the 'Deadband' feature is enabled."),
_T("%.1f %s"), _T("%.1f"),
0, Units::ToUserVSpeed(2),
GetUserVerticalSpeedStep(), false, UnitGroup::VERTICAL_SPEED,
settings.max_dead);
SetExpertRow(DEAD_BAND_MAX);
DataFieldFloat &db_max = (DataFieldFloat &)GetDataField(DEAD_BAND_MAX);
db_max.SetFormat(GetUserVerticalSpeedFormat(false, true));
}
void
InterfaceConfigPanel::Prepare(ContainerWindow &parent, const PixelRect &rc)
{
const UISettings &settings = CommonInterface::GetUISettings();
RowFormWidget::Prepare(parent, rc);
buttonFonts = ConfigPanel::GetExtraButton(1);
assert(buttonFonts);
#ifdef HAVE_BLANK
AddBoolean(_("Auto. blank"),
_("This determines whether to blank the display after a long period of inactivity "
"when operating on internal battery power."),
settings.display.enable_auto_blank);
#endif
AddFileReader(_("Events"),
_("The Input Events file defines the menu system and how XCSoar responds to "
"button presses and events from external devices."),
ProfileKeys::InputFile, _T("*.xci\0"));
SetExpertRow(InputFile);
#ifndef HAVE_NATIVE_GETTEXT
WndProperty *wp;
wp = AddEnum(_("Language"),
_("The language options selects translations for English texts to other "
"languages. Select English for a native interface or Automatic to localise "
"XCSoar according to the system settings."));
if (wp != NULL) {
DataFieldEnum &df = *(DataFieldEnum *)wp->GetDataField();
df.addEnumText(_("Automatic"));
df.addEnumText(_T("English"));
#ifdef HAVE_BUILTIN_LANGUAGES
for (const BuiltinLanguage *l = language_table;
l->resource != NULL; ++l) {
StaticString<100> display_string;
display_string.Format(_T("%s (%s)"), l->name, l->resource);
df.addEnumText(l->resource, display_string);
}
#endif
LanguageFileVisitor lfv(df);
VisitDataFiles(_T("*.mo"), lfv);
df.Sort(2);
TCHAR value[MAX_PATH];
if (!Profile::GetPath(ProfileKeys::LanguageFile, value))
value[0] = _T('\0');
if (StringIsEqual(value, _T("none")))
df.Set(1);
else if (!StringIsEmpty(value) && !StringIsEqual(value, _T("auto"))) {
const TCHAR *base = BaseName(value);
if (base != NULL)
df.Set(base);
}
wp->RefreshDisplay();
}
#endif /* !HAVE_NATIVE_GETTEXT */
AddFileReader(_("Status message"),
_("The status file can be used to define sounds to be played when certain "
"events occur, and how long various status messages will appear on screen."),
ProfileKeys::StatusFile, _T("*.xcs\0"));
SetExpertRow(StatusFile);
AddTime(_("Menu timeout"),
_("This determines how long menus will appear on screen if the user does not make any button "
"presses or interacts with the computer."),
1, 60, 1, settings.menu_timeout / 2);
SetExpertRow(MenuTimeout);
#ifdef HAVE_VIBRATOR
static constexpr StaticEnumChoice haptic_feedback_list[] = {
{ (unsigned)UISettings::HapticFeedback::DEFAULT, N_("OS settings") },
{ (unsigned)UISettings::HapticFeedback::OFF, N_("Off") },
{ (unsigned)UISettings::HapticFeedback::ON, N_("On") },
{ 0 }
};
wp = AddEnum(_("Haptic feedback"),
_("Determines if haptic feedback like vibration is used."),
haptic_feedback_list, (unsigned)settings.haptic_feedback);
SetExpertRow(HapticFeedback);
#endif /* HAVE_VIBRATOR */
}
void
TaskRulesConfigPanel::Prepare(ContainerWindow &parent, const PixelRect &rc)
{
const ComputerSettings &settings_computer = CommonInterface::GetComputerSettings();
const TaskBehaviour &task_behaviour = settings_computer.task;
const ContestSettings &contest_settings = settings_computer.contest;
RowFormWidget::Prepare(parent, rc);
AddFloat(_("Start max. speed"), _("Maximum speed allowed in start observation zone. Set to 0 for no limit."),
_T("%.0f %s"), _T("%.0f"), fixed(0), fixed(300), fixed(5), false, UnitGroup::HORIZONTAL_SPEED,
task_behaviour.ordered_defaults.start_constraints.max_speed);
SetExpertRow(StartMaxSpeed);
AddFloat(_("Start max. speed margin"),
_("Maximum speed above maximum start speed to tolerate. Set to 0 for no tolerance."),
_T("%.0f %s"), _T("%.0f"), fixed(0), fixed(300), fixed(5), false, UnitGroup::HORIZONTAL_SPEED,
task_behaviour.start_margins.max_speed_margin);
SetExpertRow(StartMaxSpeedMargin);
AddSpacer();
SetExpertRow(spacer_1);
AddFloat(_("Start max. height"),
_("Maximum height based on start height reference (AGL or MSL) while starting the task. "
"Set to 0 for no limit."),
_T("%.0f %s"), _T("%.0f"), fixed(0), fixed(10000), fixed(50), false, UnitGroup::ALTITUDE,
fixed(task_behaviour.ordered_defaults.start_constraints.max_height));
SetExpertRow(StartMaxHeight);
AddFloat(_("Start max. height margin"),
_("Maximum height above maximum start height to tolerate. Set to 0 for no tolerance."),
_T("%.0f %s"), _T("%.0f"), fixed(0), fixed(10000), fixed(50), false, UnitGroup::ALTITUDE,
fixed(task_behaviour.start_margins.max_height_margin));
SetExpertRow(StartMaxHeightMargin);
static constexpr StaticEnumChoice altitude_reference_list[] = {
{ (unsigned)AltitudeReference::AGL, N_("AGL"),
N_("Reference is altitude above mean sea level."), },
{ (unsigned)AltitudeReference::MSL, N_("MSL"),
N_("Reference is the height above the task point."), },
{ 0 }
};
AddEnum(_("Start height ref."),
_("Reference used for start max height rule."),
altitude_reference_list,
(unsigned)task_behaviour.ordered_defaults.start_constraints.max_height_ref);
SetExpertRow(StartHeightRef);
AddSpacer();
SetExpertRow(spacer_2);
AddFloat(_("Finish min. height"),
_("Minimum height based on finish height reference (AGL or MSL) while finishing the task. "
"Set to 0 for no limit."),
_T("%.0f %s"), _T("%.0f"), fixed(0), fixed(10000), fixed(50), false, UnitGroup::ALTITUDE,
fixed(task_behaviour.ordered_defaults.finish_constraints.min_height));
SetExpertRow(FinishMinHeight);
AddEnum(_("Finish height ref."),
_("Reference used for finish min height rule."),
altitude_reference_list,
(unsigned)task_behaviour.ordered_defaults.finish_constraints.min_height_ref);
SetExpertRow(FinishHeightRef);
AddSpacer();
SetExpertRow(spacer_3);
const StaticEnumChoice contests_list[] = {
{ (unsigned)Contest::OLC_FAI, ContestToString(Contest::OLC_FAI),
N_("Conforms to FAI triangle rules. Three turns and common start and finish. No leg less than 28% "
"of total except for tasks longer than 500km: No leg less than 25% or larger than 45%.") },
{ (unsigned)Contest::OLC_CLASSIC, ContestToString(Contest::OLC_CLASSIC),
N_("Up to seven points including start and finish, finish height must not be lower than "
"start height less 1000 meters.") },
{ (unsigned)Contest::OLC_LEAGUE, ContestToString(Contest::OLC_LEAGUE),
N_("The most recent contest with Sprint task rules.") },
{ (unsigned)Contest::OLC_PLUS, ContestToString(Contest::OLC_PLUS),
N_("A combination of Classic and FAI rules. 30% of the FAI score are added to the Classic score.") },
{ (unsigned)Contest::DMST, ContestToString(Contest::DMST),
/* German competition, no translation */
_T("Deutsche Meisterschaft im Streckensegelflug.") },
{ (unsigned)Contest::XCONTEST, ContestToString(Contest::XCONTEST),
_T("tbd.") },
{ (unsigned)Contest::DHV_XC, ContestToString(Contest::DHV_XC),
_T("tbd.") },
{ (unsigned)Contest::SIS_AT, ContestToString(Contest::SIS_AT),
_T("tbd.") },
{ (unsigned)Contest::NET_COUPE, ContestToString(Contest::NET_COUPE),
N_("The FFVV NetCoupe \"libre\" competiton.") },
{ 0 }
};
AddEnum(_("On-Line Contest"),
_("Select the rules used for calculating optimal points for the On-Line Contest. "
"The implementation conforms to the official release 2010, Sept.23."),
contests_list, (unsigned)contest_settings.contest);
AddBoolean(_("Predict Contest"),
_("If enabled, then the next task point is included in the "
"score calculation, assuming that you will reach it."),
contest_settings.predict);
}
void
TaskDefaultsConfigPanel::Prepare(ContainerWindow &parent, const PixelRect &rc)
{
WndProperty *wp;
const ComputerSettings &settings_computer = XCSoarInterface::GetComputerSettings();
const TaskBehaviour &task_behaviour = settings_computer.task;
OrderedTask temptask(task_behaviour);
temptask.SetFactory(TaskFactoryType::RACING);
RowFormWidget::Prepare(parent, rc);
wp = AddEnum(_("Start point"),
_("Default start type for new tasks you create."),
this);
if (wp) {
const auto point_types = temptask.GetFactory().GetValidStartTypes();
DataFieldEnum* dfe = (DataFieldEnum*)wp->GetDataField();
dfe->EnableItemHelp(true);
for (auto i = point_types.begin(), end = point_types.end();
i != end; ++i) {
const AbstractTaskFactory::LegalPointType type = *i;
dfe->addEnumText(OrderedTaskPointName(type), (unsigned)type,
OrderedTaskPointDescription(type));
if (type == task_behaviour.sector_defaults.start_type)
dfe->Set((unsigned)type);
}
wp->RefreshDisplay();
}
AddFloat(Caption_GateWidth, _("Default radius or gate width of the start zone for new tasks."),
_T("%.1f %s"), _T("%.1f"), fixed(0.1), fixed(100), fixed(1.0), true, UnitGroup::DISTANCE,
task_behaviour.sector_defaults.start_radius);
AddSpacer();
wp = AddEnum(_("Finish point"),
_("Default finish type for new tasks you create."),
this);
if (wp) {
const auto point_types = temptask.GetFactory().GetValidFinishTypes();
DataFieldEnum* dfe = (DataFieldEnum*)wp->GetDataField();
dfe->EnableItemHelp(true);
for (auto i = point_types.begin(), end = point_types.end();
i != end; ++i) {
const AbstractTaskFactory::LegalPointType type = *i;
dfe->addEnumText(OrderedTaskPointName(type), (unsigned)type,
OrderedTaskPointDescription(type));
if (type == task_behaviour.sector_defaults.finish_type)
dfe->Set((unsigned)type);
}
wp->RefreshDisplay();
}
AddFloat(Caption_GateWidth, _("Default radius or gate width of the finish zone in new tasks."),
_T("%.1f %s"), _T("%.1f"), fixed(0.1), fixed(100), fixed(1.0), true, UnitGroup::DISTANCE,
task_behaviour.sector_defaults.finish_radius);
AddSpacer();
wp = AddEnum(_("Turn point"), _("Default turn point type for new tasks you create."));
if (wp) {
const auto point_types = temptask.GetFactory().GetValidIntermediateTypes();
DataFieldEnum* dfe = (DataFieldEnum*)wp->GetDataField();
dfe->EnableItemHelp(true);
for (auto i = point_types.begin(), end = point_types.end();
i != end; ++i) {
const AbstractTaskFactory::LegalPointType type = *i;
dfe->addEnumText(OrderedTaskPointName(type), (unsigned)type,
OrderedTaskPointDescription(type));
if (type == task_behaviour.sector_defaults.turnpoint_type) {
dfe->Set((unsigned)type);
}
}
wp->RefreshDisplay();
}
AddFloat(Caption_Radius, _("Default radius of turnpoint cylinders and sectors in new tasks."),
_T("%.1f %s"), _T("%.1f"), fixed(0.1), fixed(100), fixed(1.0), true, UnitGroup::DISTANCE,
task_behaviour.sector_defaults.turnpoint_radius);
AddSpacer();
wp = AddEnum(_("Task"), _("Default task type for new tasks you create."));
if (wp) {
const std::vector<TaskFactoryType> factory_types =
temptask.GetFactoryTypes();
DataFieldEnum* dfe = (DataFieldEnum*)wp->GetDataField();
dfe->EnableItemHelp(true);
for (unsigned i = 0; i < factory_types.size(); i++) {
dfe->addEnumText(OrderedTaskFactoryName(factory_types[i]),
(unsigned)factory_types[i], OrderedTaskFactoryDescription(
factory_types[i]));
if (factory_types[i] == task_behaviour.task_type_default)
dfe->Set((unsigned)factory_types[i]);
}
wp->RefreshDisplay();
}
AddTime(_("AAT min. time"), _("Default AAT min. time for new AAT tasks."),
60, 10 * 60 * 60, 60, (unsigned)task_behaviour.ordered_defaults.aat_min_time);
AddTime(_("Optimisation margin"),
_("Safety margin for AAT task optimisation. Optimisation "
"seeks to complete the task at the minimum time plus this margin time."),
0, 30 * 60, 60, (unsigned)task_behaviour.optimise_targets_margin);
SetExpertRow(AATTimeMargin);
SetStartLabel();
SetFinishLabel();
}
void
TaskRulesConfigPanel::Prepare(ContainerWindow &parent, const PixelRect &rc)
{
const ComputerSettings &settings_computer = XCSoarInterface::GetComputerSettings();
const TaskBehaviour &task_behaviour = settings_computer.task;
RowFormWidget::Prepare(parent, rc);
AddFloat(_("Start max. speed"), _("Maximum speed allowed in start observation zone. Set to 0 for no limit."),
_T("%.0f %s"), _T("%.0f"), fixed(0), fixed(300), fixed(5), false, UnitGroup::HORIZONTAL_SPEED,
task_behaviour.ordered_defaults.start_max_speed);
SetExpertRow(StartMaxSpeed);
AddFloat(_("Start max. speed margin"),
_("Maximum speed above maximum start speed to tolerate. Set to 0 for no tolerance."),
_T("%.0f %s"), _T("%.0f"), fixed(0), fixed(300), fixed(5), false, UnitGroup::HORIZONTAL_SPEED,
task_behaviour.start_max_speed_margin);
SetExpertRow(StartMaxSpeedMargin);
AddSpacer();
SetExpertRow(spacer_1);
AddFloat(_("Start max. height"),
_("Maximum height based on start height reference (AGL or MSL) while starting the task. "
"Set to 0 for no limit."),
_T("%.0f %s"), _T("%.0f"), fixed(0), fixed(10000), fixed(50), false, UnitGroup::ALTITUDE,
fixed(task_behaviour.ordered_defaults.start_max_height));
SetExpertRow(StartMaxHeight);
AddFloat(_("Start max. height margin"),
_("Maximum height above maximum start height to tolerate. Set to 0 for no tolerance."),
_T("%.0f %s"), _T("%.0f"), fixed(0), fixed(10000), fixed(50), false, UnitGroup::ALTITUDE,
fixed(task_behaviour.start_max_height_margin));
SetExpertRow(StartMaxHeightMargin);
static constexpr StaticEnumChoice start_max_height_ref_list[] = {
{ (unsigned)HeightReferenceType::AGL, N_("AGL"), N_("Reference AGL for start maximum height rule (above start point).") },
{ (unsigned)HeightReferenceType::MSL, N_("MSL"), N_("Reference MSL for start maximum height rule (above sea level).") },
{ 0 }
};
AddEnum(_("Start height ref."), NULL, start_max_height_ref_list,
(unsigned)task_behaviour.ordered_defaults.start_max_height_ref);
SetExpertRow(StartHeightRef);
AddSpacer();
SetExpertRow(spacer_2);
AddFloat(_("Finish min. height"),
_("Minimum height based on finish height reference (AGL or MSL) while finishing the task. "
"Set to 0 for no limit."),
_T("%.0f %s"), _T("%.0f"), fixed(0), fixed(10000), fixed(50), false, UnitGroup::ALTITUDE,
fixed(task_behaviour.ordered_defaults.finish_min_height));
SetExpertRow(FinishMinHeight);
static constexpr StaticEnumChoice finish_min_height_ref_list[] = {
{ (unsigned)HeightReferenceType::AGL, N_("AGL"), N_("Reference AGL for finish minimum height rule (above finish point).") },
{ (unsigned)HeightReferenceType::MSL, N_("MSL"), N_("Reference MSL for finish minimum height rule (above sea level).") },
{ 0 }
};
AddEnum(_("Finish height ref."), NULL, finish_min_height_ref_list,
(unsigned)task_behaviour.ordered_defaults.finish_min_height_ref);
SetExpertRow(FinishHeightRef);
AddSpacer();
SetExpertRow(spacer_3);
const StaticEnumChoice contests_list[] = {
{ OLC_FAI, ContestToString(OLC_FAI),
N_("Conforms to FAI triangle rules. Three turns and common start and finish. No leg less than 28% "
"of total except for tasks longer than 500km: No leg less than 25% or larger than 45%.") },
{ OLC_Classic, ContestToString(OLC_Classic),
N_("Up to seven points including start and finish, finish height must not be lower than "
"start height less 1000 meters.") },
{ OLC_League, ContestToString(OLC_League),
N_("The most recent contest with Sprint task rules.") },
{ OLC_Plus, ContestToString(OLC_Plus),
N_("A combination of Classic and FAI rules. 30% of the FAI score are added to the Classic score.") },
{ OLC_XContest, ContestToString(OLC_XContest), _T("tbd.") },
{ OLC_DHVXC, ContestToString(OLC_DHVXC), _T("tbd.") },
{ OLC_SISAT, ContestToString(OLC_SISAT), _T("tbd.") },
{ OLC_NetCoupe, ContestToString(OLC_NetCoupe), N_("The FFVV NetCoupe \"libre\" competiton.") },
{ 0 }
};
AddEnum(_("On-Line Contest"),
_("Select the rules used for calculating optimal points for the On-Line Contest. "
"The implementation conforms to the official release 2010, Sept.23."),
contests_list, task_behaviour.contest);
AddBoolean(_("Predict Contest"),
_("If enabled, then the next task point is included in the "
"score calculation, assuming that you will reach it."),
task_behaviour.predict_contest);
}
void
AirspaceConfigPanel::Prepare(ContainerWindow &parent, const PixelRect &rc)
{
const AirspaceComputerSettings &computer =
CommonInterface::GetComputerSettings().airspace;
const AirspaceRendererSettings &renderer =
CommonInterface::GetMapSettings().airspace;
RowFormWidget::Prepare(parent, rc);
AddEnum(_("Airspace display"),
_("Controls filtering of airspace for display and warnings. The airspace filter button also allows filtering of display and warnings independently for each airspace class."),
as_display_list, (unsigned)renderer.altitude_mode, this);
AddFloat(_("Clip altitude"),
_("For clip airspace mode, this is the altitude below which airspace is displayed."),
_T("%.0f %s"), _T("%.0f"), fixed(0), fixed(20000), fixed(100), false, UnitGroup::ALTITUDE, fixed(renderer.clip_altitude));
AddFloat(_("Margin"),
_("For auto and all below airspace mode, this is the altitude above/below which airspace is included."),
_T("%.0f %s"), _T("%.0f"), fixed(0), fixed(10000), fixed(100), false, UnitGroup::ALTITUDE, fixed(computer.warnings.altitude_warning_margin));
AddBoolean(_("Warnings"), _("Enable/disable all airspace warnings."),
computer.enable_warnings, this);
AddTime(_("Warning time"),
_("This is the time before an airspace incursion is estimated at which the system will warn the pilot."),
10, 1000, 5, computer.warnings.warning_time);
SetExpertRow(WarningTime);
AddTime(_("Acknowledge time"),
_("This is the time period in which an acknowledged airspace warning will not be repeated."),
10, 1000, 5, computer.warnings.acknowledgement_time);
SetExpertRow(AcknowledgeTime);
AddBoolean(_("Use black outline"),
_("Draw a black outline around each airspace rather than the airspace color."),
renderer.black_outline);
SetExpertRow(UseBlackOutline);
AddEnum(_("Airspace fill mode"),
_("Specifies the mode for filling the airspace area."),
as_fill_mode_list, (unsigned)renderer.fill_mode);
SetExpertRow(AirspaceFillMode);
#if !defined(ENABLE_OPENGL) && defined(HAVE_ALPHA_BLEND)
if (AlphaBlendAvailable()) {
AddBoolean(_("Airspace transparency"), _("If enabled, then airspaces are filled transparently."),
renderer.transparency);
SetExpertRow(AirspaceTransparency);
}
#endif
buttonColors = ConfigPanel::GetExtraButton(1);
assert(buttonColors != NULL);
buttonMode = ConfigPanel::GetExtraButton(2);
assert(buttonMode != NULL);
ShowDisplayControls(renderer.altitude_mode); // TODO make this work the first time
ShowWarningControls(computer.enable_warnings);
}
void
InterfaceConfigPanel::Prepare(ContainerWindow &parent, const PixelRect &rc)
{
const UISettings &settings = CommonInterface::GetUISettings();
RowFormWidget::Prepare(parent, rc);
buttonFonts = ConfigPanel::GetExtraButton(1);
assert(buttonFonts);
#ifdef HAVE_BLANK
AddBoolean(_("Auto. blank"),
_("This determines whether to blank the display after a long period of inactivity "
"when operating on internal battery power."),
settings.display.enable_auto_blank);
#endif
AddFileReader(_("Events"),
_("The Input Events file defines the menu system and how XCSoar responds to "
"button presses and events from external devices."),
szProfileInputFile, _T("*.xci\0"));
SetExpertRow(InputFile);
#ifndef HAVE_NATIVE_GETTEXT
WndProperty *wp;
wp = AddEnum(_("Language"),
_("The language options selects translations for English texts to other "
"languages. Select English for a native interface or Automatic to localise "
"XCSoar according to the system settings."));
if (wp != NULL) {
DataFieldEnum &df = *(DataFieldEnum *)wp->GetDataField();
df.addEnumText(_("Automatic"));
df.addEnumText(_("English"));
#ifdef HAVE_BUILTIN_LANGUAGES
for (const struct builtin_language *l = language_table;
l->resource != NULL; ++l)
df.addEnumText(l->resource);
#endif
LanguageFileVisitor lfv(df);
VisitDataFiles(_T("*.mo"), lfv);
df.Sort(2);
TCHAR value[MAX_PATH];
if (!Profile::GetPath(szProfileLanguageFile, value))
value[0] = _T('\0');
if (_tcscmp(value, _T("none")) == 0)
df.Set(1);
else if (!StringIsEmpty(value) && _tcscmp(value, _T("auto")) != 0) {
const TCHAR *base = BaseName(value);
if (base != NULL)
df.SetAsString(base);
}
wp->RefreshDisplay();
}
#endif /* !HAVE_NATIVE_GETTEXT */
AddFileReader(_("Status message"),
_("The status file can be used to define sounds to be played when certain "
"events occur, and how long various status messages will appear on screen."),
szProfileStatusFile, _T("*.xcs\0"));
SetExpertRow(StatusFile);
AddTime(_("Menu timeout"),
_("This determines how long menus will appear on screen if the user does not make any button "
"presses or interacts with the computer."),
1, 60, 1, settings.menu_timeout / 2);
SetExpertRow(MenuTimeout);
static gcc_constexpr_data StaticEnumChoice text_input_list[] = {
{ (unsigned)DialogSettings::TextInputStyle::Default, N_("Default") },
{ (unsigned)DialogSettings::TextInputStyle::Keyboard, N_("Keyboard") },
{ (unsigned)DialogSettings::TextInputStyle::HighScore,
N_("HighScore Style") },
{ 0 }
};
AddEnum(_("Text input style"),
_("Determines how the user is prompted for text input (filename, teamcode etc.)"),
text_input_list, (unsigned)settings.dialog.text_input_style);
SetExpertRow(TextInput);
/* on-screen keyboard doesn't work without a pointing device
(mouse or touch screen), hide the option on Altair */
SetRowVisible(TextInput, HasPointer());
#ifdef HAVE_VIBRATOR
static gcc_constexpr_data StaticEnumChoice haptic_feedback_list[] = {
{ (unsigned) UISettings::HapticFeedback::Default, N_("OS settings") },
{ (unsigned) UISettings::HapticFeedback::Off, N_("Off") },
{ (unsigned) UISettings::HapticFeedback::On, N_("On") },
{ 0 }
};
wp = AddEnum(_("Haptic feedback"),
_("Determines if haptic feedback like vibration is used."),
haptic_feedback_list, (unsigned)settings.haptic_feedback);
SetExpertRow(HapticFeedback);
#endif /* HAVE_VIBRATOR */
}
void
DeviceEditWidget::Prepare(ContainerWindow &parent, const PixelRect &rc)
{
instance = this;
RowFormWidget::Prepare(parent, rc);
DataFieldEnum *port_df = new DataFieldEnum(OnDataField);
port_df->SetDetachGUI(true);
FillPorts(*port_df, config);
Add(_("Port"), NULL, port_df);
DataFieldEnum *baud_rate_df = new DataFieldEnum(NULL);
FillBaudRates(*baud_rate_df);
baud_rate_df->Set(config.baud_rate);
Add(_("Baudrate"), NULL, baud_rate_df);
DataFieldEnum *bulk_baud_rate_df = new DataFieldEnum(NULL);
bulk_baud_rate_df->addEnumText(_T("Default"), 0u);
FillBaudRates(*bulk_baud_rate_df);
bulk_baud_rate_df->Set(config.bulk_baud_rate);
Add(_("Bulk baud rate"),
_("The baud rate used for bulk transfers, such as task declaration or flight download."),
bulk_baud_rate_df);
DataFieldEnum *tcp_port_df = new DataFieldEnum(NULL);
FillTCPPorts(*tcp_port_df);
tcp_port_df->Set(config.tcp_port);
Add(_("TCP Port"), NULL, tcp_port_df);
DataFieldEnum *driver_df = new DataFieldEnum(OnDataField);
driver_df->SetDetachGUI(true);
const TCHAR *driver_name;
for (unsigned i = 0; (driver_name = GetDriverNameByIndex(i)) != NULL; i++)
driver_df->addEnumText(driver_name, GetDriverDisplayNameByIndex(i));
driver_df->Sort(1);
driver_df->SetAsString(config.driver_name);
Add(_("Driver"), NULL, driver_df);
AddBoolean(_("Sync. from device"),
_("This option lets you configure if XCSoar should use settings "
"like the MacCready value, bugs and ballast from the device."),
config.sync_from_device);
SetExpertRow(SyncFromDevice);
AddBoolean(_("Sync. to device"),
_("This option lets you configure if XCSoar should send settings "
"like the MacCready value, bugs and ballast to the device."),
config.sync_to_device);
SetExpertRow(SyncToDevice);
AddBoolean(_("Ignore checksum"),
_("If your GPS device outputs invalid NMEA checksums, this will "
"allow it's data to be used anyway."),
config.ignore_checksum);
SetExpertRow(IgnoreCheckSum);
port_df->SetDetachGUI(false);
driver_df->SetDetachGUI(false);
UpdateVisibilities();
}
void
TerrainDisplayConfigPanel::Prepare(ContainerWindow &parent, const PixelRect &rc)
{
instance = this;
RowFormWidget::Prepare(parent, rc);
const MapSettings &settings_map = CommonInterface::GetMapSettings();
const TerrainRendererSettings &terrain = settings_map.terrain;
AddBoolean(_("Terrain display"),
_("Draw a digital elevation terrain on the map."),
terrain.enable);
GetDataField(EnableTerrain).SetListener(this);
AddBoolean(_("Topography display"),
_("Draw topographical features (roads, rivers, lakes etc.) on the map."),
settings_map.topography_enabled);
static constexpr StaticEnumChoice terrain_ramp_list[] = {
{ 0, N_("Low lands"), },
{ 1, N_("Mountainous"), },
{ 2, N_("Imhof 7"), },
{ 3, N_("Imhof 4"), },
{ 4, N_("Imhof 12"), },
{ 5, N_("Imhof Atlas"), },
{ 6, N_("ICAO"), },
{ 7, N_("Grey"), },
{ 0 }
};
AddEnum(_("Terrain colors"),
_("Defines the color ramp used in terrain rendering."),
terrain_ramp_list, terrain.ramp);
GetDataField(TerrainColors).SetListener(this);
static constexpr StaticEnumChoice slope_shading_list[] = {
{ (unsigned)SlopeShading::OFF, N_("Off"), },
{ (unsigned)SlopeShading::FIXED, N_("Fixed"), },
{ (unsigned)SlopeShading::SUN, N_("Sun"), },
{ (unsigned)SlopeShading::WIND, N_("Wind"), },
{ 0 }
};
AddEnum(_("Slope shading"),
_("The terrain can be shaded among slopes to indicate either wind direction, sun position or a fixed shading from north-east."),
slope_shading_list, (unsigned)terrain.slope_shading);
GetDataField(TerrainSlopeShading).SetListener(this);
SetExpertRow(TerrainSlopeShading);
AddInteger(_("Terrain contrast"),
_("Defines the amount of Phong shading in the terrain rendering. Use large values to emphasise terrain slope, smaller values if flying in steep mountains."),
_T("%d %%"), _T("%d %%"), 0, 100, 5,
ByteToPercent(terrain.contrast));
GetDataField(TerrainContrast).SetListener(this);
SetExpertRow(TerrainContrast);
AddInteger(_("Terrain brightness"),
_("Defines the brightness (whiteness) of the terrain rendering. This controls the average illumination of the terrain."),
_T("%d %%"), _T("%d %%"), 0, 100, 5,
ByteToPercent(terrain.brightness));
GetDataField(TerrainBrightness).SetListener(this);
SetExpertRow(TerrainBrightness);
if (::terrain != NULL) {
WindowStyle style;
style.Border();
AddRemaining(new WndOwnerDrawFrame(*(ContainerWindow *)GetWindow(),
{0, 0, 100, 100},
style,
::OnPreviewPaint));
}
terrain_settings = terrain;
ShowTerrainControls();
}
void
AirspaceConfigPanel::Prepare(ContainerWindow &parent, const PixelRect &rc)
{
const AirspaceComputerSettings &computer =
CommonInterface::GetComputerSettings().airspace;
const AirspaceRendererSettings &renderer =
CommonInterface::GetMapSettings().airspace;
const UISettings &ui_settings =
CommonInterface::GetUISettings();
RowFormWidget::Prepare(parent, rc);
AddEnum(_("Airspace display"),
_("Controls filtering of airspace for display and warnings. The airspace filter button also allows filtering of display and warnings independently for each airspace class."),
as_display_list, (unsigned)renderer.altitude_mode, this);
AddEnum(_("Label visibility"),
_("Determines what labels are displayed."),
as_label_selection_list, (unsigned)renderer.label_selection);
SetExpertRow(AirspaceLabelSelection);
AddFloat(_("Clip altitude"),
_("For clip airspace mode, this is the altitude below which airspace is displayed."),
_T("%.0f %s"), _T("%.0f"), fixed(0), fixed(20000), fixed(100), false, UnitGroup::ALTITUDE, fixed(renderer.clip_altitude));
AddFloat(_("Margin"),
_("For auto and all below airspace mode, this is the altitude above/below which airspace is included."),
_T("%.0f %s"), _T("%.0f"), fixed(0), fixed(10000), fixed(100), false, UnitGroup::ALTITUDE, fixed(computer.warnings.altitude_warning_margin));
AddBoolean(_("Warnings"), _("Enable/disable all airspace warnings."),
computer.enable_warnings, this);
AddBoolean(_("Warnings dialog"),
_("Enable/disable displaying airspaces warnings dialog."),
ui_settings.enable_airspace_warning_dialog, this);
SetExpertRow(WarningDialog);
AddTime(_("Warning time"),
_("This is the time before an airspace incursion is estimated at which the system will warn the pilot."),
10, 1000, 5, computer.warnings.warning_time);
SetExpertRow(WarningTime);
AddBoolean(_("Repetitive sound"),
_("Enable/disable repetitive warning sound when airspaces warnings dialog is displayed."),
computer.warnings.repetitive_sound, this);
SetExpertRow(RepetitiveSound);
AddTime(_("Acknowledge time"),
_("This is the time period in which an acknowledged airspace warning will not be repeated."),
10, 1000, 5, computer.warnings.acknowledgement_time);
SetExpertRow(AcknowledgeTime);
AddBoolean(_("Use black outline"),
_("Draw a black outline around each airspace rather than the airspace color."),
renderer.black_outline);
SetExpertRow(UseBlackOutline);
AddEnum(_("Airspace fill mode"),
_("Specifies the mode for filling the airspace area."),
as_fill_mode_list, (unsigned)renderer.fill_mode);
SetExpertRow(AirspaceFillMode);
#if defined(HAVE_HATCHED_BRUSH) && defined(HAVE_ALPHA_BLEND)
AddBoolean(_("Airspace transparency"), _("If enabled, then airspaces are filled transparently."),
renderer.transparency);
SetExpertRow(AirspaceTransparency);
#endif
ShowDisplayControls(renderer.altitude_mode); // TODO make this work the first time
ShowWarningControls(computer.enable_warnings);
}
void
TaskRulesConfigPanel::Prepare(ContainerWindow &parent, const PixelRect &rc)
{
const ComputerSettings &settings_computer = CommonInterface::GetComputerSettings();
const TaskBehaviour &task_behaviour = settings_computer.task;
RowFormWidget::Prepare(parent, rc);
AddFloat(_("Start max. speed"), _("Maximum speed allowed in start observation zone. Set to 0 for no limit."),
_T("%.0f %s"), _T("%.0f"), fixed(0), fixed(300), fixed(5), false, UnitGroup::HORIZONTAL_SPEED,
task_behaviour.ordered_defaults.start_constraints.max_speed);
SetExpertRow(StartMaxSpeed);
AddFloat(_("Start max. speed margin"),
_("Maximum speed above maximum start speed to tolerate. Set to 0 for no tolerance."),
_T("%.0f %s"), _T("%.0f"), fixed(0), fixed(300), fixed(5), false, UnitGroup::HORIZONTAL_SPEED,
task_behaviour.start_margins.max_speed_margin);
SetExpertRow(StartMaxSpeedMargin);
AddSpacer();
SetExpertRow(spacer_1);
AddFloat(_("Start max. height"),
_("Maximum height based on start height reference (AGL or MSL) while starting the task. "
"Set to 0 for no limit."),
_T("%.0f %s"), _T("%.0f"), fixed(0), fixed(10000), fixed(50), false, UnitGroup::ALTITUDE,
fixed(task_behaviour.ordered_defaults.start_constraints.max_height));
SetExpertRow(StartMaxHeight);
AddFloat(_("Start max. height margin"),
_("Maximum height above maximum start height to tolerate. Set to 0 for no tolerance."),
_T("%.0f %s"), _T("%.0f"), fixed(0), fixed(10000), fixed(50), false, UnitGroup::ALTITUDE,
fixed(task_behaviour.start_margins.max_height_margin));
SetExpertRow(StartMaxHeightMargin);
static constexpr StaticEnumChoice altitude_reference_list[] = {
{ (unsigned)AltitudeReference::AGL, N_("AGL"),
N_("Reference is altitude above mean sea level."), },
{ (unsigned)AltitudeReference::MSL, N_("MSL"),
N_("Reference is the height above the task point."), },
{ 0 }
};
AddEnum(_("Start height ref."),
_("Reference used for start max height rule."),
altitude_reference_list,
(unsigned)task_behaviour.ordered_defaults.start_constraints.max_height_ref);
SetExpertRow(StartHeightRef);
AddSpacer();
SetExpertRow(spacer_2);
AddFloat(_("Finish min. height"),
_("Minimum height based on finish height reference (AGL or MSL) while finishing the task. "
"Set to 0 for no limit."),
_T("%.0f %s"), _T("%.0f"), fixed(0), fixed(10000), fixed(50), false, UnitGroup::ALTITUDE,
fixed(task_behaviour.ordered_defaults.finish_constraints.min_height));
SetExpertRow(FinishMinHeight);
AddEnum(_("Finish height ref."),
_("Reference used for finish min height rule."),
altitude_reference_list,
(unsigned)task_behaviour.ordered_defaults.finish_constraints.min_height_ref);
SetExpertRow(FinishHeightRef);
}
void
SafetyFactorsConfigPanel::Prepare(ContainerWindow &parent, const PixelRect &rc)
{
RowFormWidget::Prepare(parent, rc);
const ComputerSettings &settings_computer = CommonInterface::GetComputerSettings();
const TaskBehaviour &task_behaviour = settings_computer.task;
AddFloat(_("Arrival height"),
_("The height above terrain that the glider should arrive at for a safe landing."),
_T("%.0f %s"), _T("%.0f"),
fixed(0), fixed(10000), fixed(100), false,
UnitGroup::ALTITUDE, task_behaviour.safety_height_arrival);
AddFloat(_("Terrain height"),
_("The height above terrain that the glider must clear during final glide."),
_T("%.0f %s"), _T("%.0f"),
fixed(0), fixed(10000), fixed(100), false,
UnitGroup::ALTITUDE, task_behaviour.route_planner.safety_height_terrain);
static constexpr StaticEnumChoice abort_task_mode_list[] = {
{ (unsigned)AbortTaskMode::SIMPLE, N_("Simple"),
N_("The alternates will only be sorted by waypoint type (airport/outlanding field) and arrival height.") },
{ (unsigned)AbortTaskMode::TASK, N_("Task"),
N_("The sorting will also take the current task direction into account.") },
{ (unsigned)AbortTaskMode::HOME, N_("Home"),
N_("The sorting will try to find landing options in the current direction to the configured home waypoint.") },
{ 0 }
};
AddEnum(_("Alternates mode"),
_("Determines sorting of alternates in the alternates dialog and in abort mode."),
abort_task_mode_list, (unsigned)task_behaviour.abort_task_mode);
AddFloat(_("Polar degradation"), /* xgettext:no-c-format */
_("A permanent polar degradation. "
"0% means no degradation, "
"50% indicates the glider's sink rate is doubled."),
_T("%.0f %%"), _T("%.0f"),
fixed(0), fixed(50), fixed(1), false,
(fixed(1) - settings_computer.polar.degradation_factor) * 100);
SetExpertRow(PolarDegradation);
AddBoolean(_("Auto bugs"), /* xgettext:no-c-format */
_("If enabled, adds 1% to the bugs setting after each full hour while flying."),
settings_computer.polar.auto_bugs);
SetExpertRow(AutoBugs);
AddFloat(_("Safety MC"),
_("The MacCready setting used, when safety MC is enabled for reach calculations, in task abort mode and for determining arrival altitude at airfields."),
_T("%.1f %s"), _T("%.1f"),
fixed(0), Units::ToUserVSpeed(fixed(10)), GetUserVerticalSpeedStep(),
false, UnitGroup::VERTICAL_SPEED, task_behaviour.safety_mc);
SetExpertRow(SafetyMC);
DataFieldFloat &safety_mc = (DataFieldFloat &)GetDataField(SafetyMC);
safety_mc.SetFormat(GetUserVerticalSpeedFormat(false, false));
AddFloat(_("STF risk factor"),
_("The STF risk factor reduces the MacCready setting used to calculate speed to fly as the glider gets low, in order to compensate for risk. Set to 0.0 for no compensation, 1.0 scales MC linearly with current height (with reference to height of the maximum climb). If considered, 0.3 is recommended."),
_T("%.1f %s"), _T("%.1f"),
fixed(0), fixed(1), fixed(0.1), false,
task_behaviour.risk_gamma);
SetExpertRow(RiskFactor);
}
void
RouteConfigPanel::Prepare(ContainerWindow &parent, const PixelRect &rc)
{
const ComputerSettings &settings_computer = CommonInterface::GetComputerSettings();
const RoutePlannerConfig &route_planner = settings_computer.task.route_planner;
RowFormWidget::Prepare(parent, rc);
static constexpr StaticEnumChoice route_mode_list[] = {
{ (unsigned)RoutePlannerConfig::Mode::NONE, N_("None"),
N_("Neither airspace nor terrain is used for route planning.") },
{ (unsigned)RoutePlannerConfig::Mode::TERRAIN, N_("Terrain"),
N_("Routes will avoid terrain.") },
{ (unsigned)RoutePlannerConfig::Mode::AIRSPACE, N_("Airspace"),
N_("Routes will avoid airspace.") },
{ (unsigned)RoutePlannerConfig::Mode::BOTH, N_("Both"),
N_("Routes will avoid airspace and terrain.") },
{ 0 }
};
AddEnum(_("Route mode"), NULL, route_mode_list,
(unsigned)route_planner.mode, this);
AddBoolean(_("Route climb"),
_("When enabled and MC is positive, route planning allows climbs between the aircraft "
"location and destination."),
route_planner.allow_climb);
SetExpertRow(RoutePlannerAllowClimb);
AddBoolean(_("Route ceiling"),
_("When enabled, route planning climbs are limited to ceiling defined by greater of "
"current aircraft altitude plus 500 m and the thermal ceiling. If disabled, "
"climbs are unlimited."),
route_planner.use_ceiling);
SetExpertRow(RoutePlannerUseCeiling);
static constexpr StaticEnumChoice turning_reach_list[] = {
{ (unsigned)RoutePlannerConfig::ReachMode::OFF, N_("Off"),
N_("Reach calculations disabled.") },
{ (unsigned)RoutePlannerConfig::ReachMode::STRAIGHT, N_("Straight"),
N_("The reach is from straight line paths from the glider.") },
{ (unsigned)RoutePlannerConfig::ReachMode::TURNING, N_("Turning"),
N_("The reach is calculated allowing turns around terrain obstacles.") },
{ 0 }
};
AddSpacer(); // Spacer
AddEnum(_("Reach mode"),
_("How calculations are performed of the reach of the glider with respect to terrain."),
turning_reach_list, (unsigned)route_planner.reach_calc_mode,
this);
static constexpr StaticEnumChoice final_glide_terrain_list[] = {
{ (unsigned)FeaturesSettings::FinalGlideTerrain::OFF, N_("Off"),
N_("Disables the reach display.") },
{ (unsigned)FeaturesSettings::FinalGlideTerrain::LINE, N_("Line"),
N_("Draws a dashed line at the glide reach.") },
{ (unsigned)FeaturesSettings::FinalGlideTerrain::SHADE, N_("Shade"),
N_("Shades terrain outside glide reach.") },
{ 0 }
};
AddEnum(_("Reach display"), NULL, final_glide_terrain_list,
(unsigned)settings_computer.features.final_glide_terrain);
static constexpr StaticEnumChoice reach_polar_list[] = {
{ (unsigned)RoutePlannerConfig::Polar::TASK, N_("Task"),
N_("Uses task glide polar.") },
{ (unsigned)RoutePlannerConfig::Polar::SAFETY, N_("Safety MC"),
N_("Uses safety MacCready value") },
{ 0 }
};
AddEnum(_("Reach polar"),
_("This determines the glide performance used in reach, landable arrival, abort and alternate calculations."),
reach_polar_list, (unsigned)route_planner.reach_polar_mode);
SetExpertRow(ReachPolarMode);
ShowRouteControls(route_planner.mode != RoutePlannerConfig::Mode::NONE);
ShowReachControls(route_planner.reach_calc_mode != RoutePlannerConfig::ReachMode::OFF);
}
void
WaypointDisplayConfigPanel::Prepare(ContainerWindow &parent, const PixelRect &rc)
{
const WaypointRendererSettings &settings = CommonInterface::GetMapSettings().waypoint;
RowFormWidget::Prepare(parent, rc);
static constexpr StaticEnumChoice wp_labels_list[] = {
{ (unsigned)WaypointRendererSettings::DisplayTextType::NAME,
N_("Full name"),
N_("The full name of each waypoint is displayed.") },
{ (unsigned)WaypointRendererSettings::DisplayTextType::FIRST_WORD,
N_("First word of name"),
N_("The first word of the waypoint name is displayed.") },
{ (unsigned)WaypointRendererSettings::DisplayTextType::FIRST_THREE,
N_("First 3 letters"),
N_("The first 3 letters of the waypoint name are displayed.") },
{ (unsigned)WaypointRendererSettings::DisplayTextType::FIRST_FIVE,
N_("First 5 letters"),
N_("The first 5 letters of the waypoint name are displayed.") },
{ (unsigned)WaypointRendererSettings::DisplayTextType::NONE,
N_("None"), N_("No waypoint name is displayed.") },
{ 0 }
};
AddEnum(_("Label format"), _("Determines how labels are displayed with each waypoint"),
wp_labels_list, (unsigned)settings.display_text_type);
static constexpr StaticEnumChoice wp_arrival_list[] = {
{ (unsigned)WaypointRendererSettings::ArrivalHeightDisplay::NONE,
N_("None"),
N_("No arrival height is displayed.") },
{ (unsigned)WaypointRendererSettings::ArrivalHeightDisplay::GLIDE,
N_("Straight glide"),
N_("Straight glide arrival height (no terrain is considered).") },
{ (unsigned)WaypointRendererSettings::ArrivalHeightDisplay::TERRAIN,
N_("Terrain avoidance glide"),
N_("Arrival height considering terrain avoidance. "
"Requires \"Reach mode: Turning\" in \"Glide Computer > Route\" settings.") },
{ (unsigned)WaypointRendererSettings::ArrivalHeightDisplay::GLIDE_AND_TERRAIN,
N_("Straight & terrain glide"),
N_("Both arrival heights are displayed. "
"Requires \"Reach mode: Turning\" in \"Glide Computer > Route\" settings.") },
{ (unsigned)WaypointRendererSettings::ArrivalHeightDisplay::REQUIRED_GR,
N_("Required glide ratio") },
{ 0 }
};
AddEnum(_("Arrival height"), _("Determines how arrival height is displayed in waypoint labels"),
wp_arrival_list, (unsigned)settings.arrival_height_display);
SetExpertRow(WaypointArrivalHeightDisplay);
static constexpr StaticEnumChoice wp_label_list[] = {
{ (unsigned)LabelShape::ROUNDED_BLACK, N_("Rounded rectangle"), nullptr },
{ (unsigned)LabelShape::OUTLINED_INVERTED, N_("Outlined"), nullptr },
{ 0 }
};
AddEnum(_("Label style"), nullptr, wp_label_list,
(unsigned)settings.landable_render_mode);
SetExpertRow(WaypointLabelStyle);
static constexpr StaticEnumChoice wp_selection_list[] = {
{ (unsigned)WaypointRendererSettings::LabelSelection::ALL,
N_("All"), N_("All labels will be displayed.") },
{ (unsigned)WaypointRendererSettings::LabelSelection::TASK_AND_AIRFIELD,
N_("Task waypoints & airfields"),
N_("All waypoints part of a task and all airfields will be displayed.") },
{ (unsigned)WaypointRendererSettings::LabelSelection::TASK_AND_LANDABLE,
N_("Task waypoints & landables"),
N_("All waypoints part of a task and all landables will be displayed.") },
{ (unsigned)WaypointRendererSettings::LabelSelection::TASK,
N_("Task waypoints"),
N_("All waypoints part of a task will be displayed.") },
{ (unsigned)WaypointRendererSettings::LabelSelection::NONE,
N_("None"), N_("No labels will be displayed.") },
{ 0 }
};
AddEnum(_("Label visibility"),
_("Determines what labels are displayed."),
wp_selection_list, (unsigned)settings.label_selection);
SetExpertRow(WaypointLabelSelection);
static constexpr StaticEnumChoice wp_style_list[] = {
{ (unsigned)WaypointRendererSettings::LandableStyle::PURPLE_CIRCLE,
N_("Purple circle"),
N_("Airports and outlanding fields are displayed as purple circles. If the waypoint is "
"reachable a bigger green circle is added behind the purple one. If the waypoint is "
"blocked by a mountain the green circle will be red instead.") },
{ (unsigned)WaypointRendererSettings::LandableStyle::BW,
N_("B/W"),
N_("Airports and outlanding fields are displayed in white/grey. If the waypoint is "
"reachable the color is changed to green. If the waypoint is blocked by a mountain "
"the color is changed to red instead.") },
{ (unsigned)WaypointRendererSettings::LandableStyle::TRAFFIC_LIGHTS,
N_("Traffic lights"),
N_("Airports and outlanding fields are displayed in the colors of a traffic light. "
"Green if reachable, Orange if blocked by mountain and red if not reachable at all.") },
{ 0 }
};
AddEnum(_("Landable symbols"),
_("Three styles are available: Purple circles (WinPilot style), a high "
"contrast (monochrome) style, or orange. The rendering differs for landable "
"field and airport. All styles mark the waypoints within reach green."),
wp_style_list, (unsigned)settings.landable_style);
AddBoolean(_("Detailed landables"),
_("[Off] Display fixed icons for landables.\n"
"[On] Show landables with variable information like runway length and heading."),
settings.vector_landable_rendering, this);
SetExpertRow(AppUseSWLandablesRendering);
AddInteger(_("Landable size"),
_("A percentage to select the size landables are displayed on the map."),
_T("%u %%"), _T("%u"), 50, 200, 10, settings.landable_rendering_scale);
SetExpertRow(AppLandableRenderingScale);
AddBoolean(_("Scale runway length"),
_("[Off] Display fixed length for runways.\n"
"[On] Scale displayed runway length based on real length."),
settings.scale_runway_length);
SetExpertRow(AppScaleRunwayLength);
UpdateVisibilities();
}
void
DeviceEditWidget::Prepare(ContainerWindow &parent, const PixelRect &rc)
{
RowFormWidget::Prepare(parent, rc);
DataFieldEnum *port_df = new DataFieldEnum(this);
FillPorts(*port_df, config);
auto *port_control = Add(_("Port"), NULL, port_df);
port_control->SetEditCallback(EditPortCallback);
DataFieldEnum *baud_rate_df = new DataFieldEnum(this);
FillBaudRates(*baud_rate_df);
baud_rate_df->Set(config.baud_rate);
Add(_("Baud rate"), NULL, baud_rate_df);
DataFieldEnum *bulk_baud_rate_df = new DataFieldEnum(this);
bulk_baud_rate_df->addEnumText(_T("Default"), 0u);
FillBaudRates(*bulk_baud_rate_df);
bulk_baud_rate_df->Set(config.bulk_baud_rate);
Add(_("Bulk baud rate"),
_("The baud rate used for bulk transfers, such as task declaration or flight download."),
bulk_baud_rate_df);
DataFieldString *ip_address_df = new DataFieldString(_T(""), this);
ip_address_df->Set(config.ip_address);
Add(_("IP Address"), NULL, ip_address_df);
DataFieldEnum *tcp_port_df = new DataFieldEnum(this);
FillTCPPorts(*tcp_port_df);
tcp_port_df->Set(config.tcp_port);
Add(_("TCP Port"), NULL, tcp_port_df);
DataFieldEnum *i2c_bus_df = new DataFieldEnum(this);
FillI2CBus(*i2c_bus_df);
i2c_bus_df->Set(config.i2c_bus);
Add(_("I2C Bus"), _("Select the description or bus number that matches your configuration."),
i2c_bus_df);
DataFieldEnum *i2c_addr_df = new DataFieldEnum(this);
FillI2CAddr(*i2c_addr_df);
i2c_addr_df->Set(config.i2c_addr);
Add(_("I2C Addr"), _("The i2c address that matches your configuration."
"This field is not used when your selection in the I2C Bus field is not an i2c bus number. "
"In case you do not understand the previous sentence you may assume that this field is not used."),
i2c_addr_df);
DataFieldEnum *press_df = new DataFieldEnum(this);
FillPress(*press_df);
press_df->Set((unsigned)config.press_use);
Add(_("Pressure use"), _("Select the purpose of this pressure sensor. "
"This sensor measures some pressure. Here you tell the system "
"what pressure this is and what its should be used for."),
press_df);
DataFieldEnum *driver_df = new DataFieldEnum(this);
const struct DeviceRegister *driver;
for (unsigned i = 0; (driver = GetDriverByIndex(i)) != NULL; i++)
driver_df->addEnumText(driver->name, driver->display_name);
driver_df->Sort(1);
driver_df->Set(config.driver_name);
Add(_("Driver"), NULL, driver_df);
AddBoolean(_("Sync. from device"),
_("This option lets you configure if XCSoar should use settings "
"like the MacCready value, bugs and ballast from the device."),
config.sync_from_device, this);
SetExpertRow(SyncFromDevice);
AddBoolean(_("Sync. to device"),
_("This option lets you configure if XCSoar should send settings "
"like the MacCready value, bugs and ballast to the device."),
config.sync_to_device, this);
SetExpertRow(SyncToDevice);
AddBoolean(_T("K6Bt"),
_("Enable this if you use a K6Bt to connect the device."),
config.k6bt, this);
SetExpertRow(K6Bt);
UpdateVisibilities();
}
void
UnitsConfigPanel::Prepare(ContainerWindow &parent, const PixelRect &rc)
{
const UnitSetting &config = CommonInterface::GetUISettings().format.units;
const CoordinateFormat coordinate_format =
CommonInterface::GetUISettings().format.coordinate_format;
RowFormWidget::Prepare(parent, rc);
WndProperty *wp = AddEnum(_("Preset"), _("Load a set of units."));
DataFieldEnum &df = *(DataFieldEnum *)wp->GetDataField();
df.addEnumText(_("Custom"), (unsigned)0, _("My individual set of units."));
unsigned len = Units::Store::Count();
for (unsigned i = 0; i < len; i++)
df.addEnumText(Units::Store::GetName(i), i+1);
LoadValueEnum(UnitsPreset, Units::Store::EqualsPresetUnits(config));
wp->GetDataField()->SetListener(this);
AddSpacer();
SetExpertRow(spacer_1);
static constexpr StaticEnumChoice units_speed_list[] = {
{ (unsigned)Unit::STATUTE_MILES_PER_HOUR, _T("mph") },
{ (unsigned)Unit::KNOTS, N_("knots") },
{ (unsigned)Unit::KILOMETER_PER_HOUR, _T("km/h") },
{ 0 }
};
AddEnum(_("Aircraft/Wind speed"),
_("Units used for airspeed and ground speed. "
"A separate unit is available for task speeds."),
units_speed_list,
(unsigned int)config.speed_unit, this);
SetExpertRow(UnitsSpeed);
static constexpr StaticEnumChoice units_distance_list[] = {
{ (unsigned)Unit::STATUTE_MILES, _T("sm") },
{ (unsigned)Unit::NAUTICAL_MILES, _T("nm") },
{ (unsigned)Unit::KILOMETER, _T("km") },
{ 0 }
};
AddEnum(_("Distance"),
_("Units used for horizontal distances e.g. "
"range to waypoint, distance to go."),
units_distance_list,
(unsigned)config.distance_unit, this);
SetExpertRow(UnitsDistance);
static constexpr StaticEnumChoice units_lift_list[] = {
{ (unsigned)Unit::KNOTS, N_("knots") },
{ (unsigned)Unit::METER_PER_SECOND, _T("m/s") },
{ (unsigned)Unit::FEET_PER_MINUTE, _T("ft/min") },
{ 0 }
};
AddEnum(_("Lift"), _("Units used for vertical speeds (variometer)."),
units_lift_list,
(unsigned)config.vertical_speed_unit, this);
SetExpertRow(UnitsLift);
static constexpr StaticEnumChoice units_altitude_list[] = {
{ (unsigned)Unit::FEET, N_("foot") },
{ (unsigned)Unit::METER, N_("meter") },
{ 0 }
};
AddEnum(_("Altitude"), _("Units used for altitude and heights."),
units_altitude_list,
(unsigned)config.altitude_unit, this);
SetExpertRow(UnitsAltitude);
static constexpr StaticEnumChoice units_temperature_list[] = {
{ (unsigned)Unit::DEGREES_CELCIUS, _T(DEG "C") },
{ (unsigned)Unit::DEGREES_FAHRENHEIT, _T(DEG "F") },
{ 0 }
};
AddEnum(_("Temperature"), _("Units used for temperature."),
units_temperature_list,
(unsigned)config.temperature_unit, this);
SetExpertRow(UnitsTemperature);
static constexpr StaticEnumChoice units_taskspeed_list[] = {
{ (unsigned)Unit::STATUTE_MILES_PER_HOUR, _T("mph") },
{ (unsigned)Unit::KNOTS, N_("knots") },
{ (unsigned)Unit::KILOMETER_PER_HOUR, _T("km/h") },
{ 0 }
};
AddEnum(_("Task speed"), _("Units used for task speeds."),
units_taskspeed_list,
(unsigned)config.task_speed_unit, this);
SetExpertRow(UnitsTaskSpeed);
static constexpr StaticEnumChoice pressure_labels_list[] = {
{ (unsigned)Unit::HECTOPASCAL, _T("hPa") },
{ (unsigned)Unit::MILLIBAR, _T("mb") },
{ (unsigned)Unit::INCH_MERCURY, _T("inHg") },
{ 0 }
};
AddEnum(_("Pressure"), _("Units used for pressures."),
pressure_labels_list,
(unsigned)config.pressure_unit, this);
SetExpertRow(UnitsPressure);
AddSpacer();
SetExpertRow(spacer_2);
static constexpr StaticEnumChoice units_lat_lon_list[] = {
{ (unsigned)CoordinateFormat::DDMMSS, _T("DDMMSS") },
{ (unsigned)CoordinateFormat::DDMMSS_S, _T("DDMMSS.s") },
{ (unsigned)CoordinateFormat::DDMM_MMM, _T("DDMM.mmm") },
{ (unsigned)CoordinateFormat::DD_DDDDD, _T("DD.ddddd") },
{ (unsigned)CoordinateFormat::UTM, _T("UTM") },
{ 0 }
};
AddEnum(_("Lat./Lon."), _("Units used for latitude and longitude."),
units_lat_lon_list,
(unsigned)coordinate_format);
SetExpertRow(UnitsLatLon);
}