void
NanoConfigWidget::Prepare(ContainerWindow &parent, const PixelRect &rc)
{
RequestAllSettings(device);
static constexpr StaticEnumChoice baud_list[] = {
{ 2400, _T("2400"), NULL },
{ 4800, _T("4800"), NULL },
{ 9600, _T("9600"), NULL },
{ 19200, _T("19200"), NULL },
{ 38400, _T("38400"), NULL },
{ 57600, _T("57600"), NULL },
{ 115200, _T("115200"), NULL },
{ 0 }
};
AddEnum(_("Baud rate"), NULL, baud_list,
WaitUnsignedValue(device, "BAUDRATE", 115200));
AddBoolean(_("Auto off"), NULL,
WaitBoolValue(device, "AUTOOFF", false));
AddBoolean(_("Auto finish flight"), NULL,
WaitBoolValue(device, "OFFFIN", true));
AddBoolean(_("Always run"), NULL,
WaitBoolValue(device, "ALWRUN", false));
AddBoolean(_("Enable NMEA"), NULL,
WaitBoolValue(device, "NMEA", true));
AddInteger(_("Recording interval"), NULL,
_T("%d s"), _T("%d"), 1, 60, 1,
WaitUnsignedValue(device, "RECINT", 1));
}
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
FontEditWidget::Prepare(ContainerWindow &parent, const PixelRect &rc)
{
RowFormWidget::Prepare(parent, rc);
#ifdef USE_GDI
WndProperty *wp = AddEnum(_("Font face"), NULL, this);
{
DataFieldEnum &df = *(DataFieldEnum *)wp->GetDataField();
df.addEnumText(_T("Tahoma"));
df.addEnumText(_T("TahomaBD"));
df.addEnumText(_T("DejaVu Sans Condensed"));
}
#else
/* we cannot obtain a list of fonts on SDL/OpenGL currently */
#endif
AddInteger(_("Height"), NULL, _T("%d"), _T("%d"), 1, 200, 1, 0, this);
AddBoolean(_("Bold"), NULL, false, this);
AddBoolean(_("Italic"), NULL, false, this);
PixelRect preview_rc { 0, 0, Layout::Scale(250), Layout::Scale(100) };
LargeTextWindowStyle preview_style;
preview_style.Border();
LargeTextWindow *preview = new LargeTextWindow();
preview->Create((ContainerWindow &)GetWindow(), preview_rc, preview_style);
Add(preview);
Load();
}
void Create() {
AddEnum(_("Airbrake locked"), nullptr, airbrake_state_list, false);
AddEnum(_("Flaps"), nullptr, flap_position_list, 0);
AddBoolean(_("Gear down"), nullptr, false);
AddBoolean(_("Acknowledge"), nullptr, false);
AddBoolean(_("Repeat"), nullptr, false);
AddBoolean(_("Speed command"), nullptr, false);
}
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
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
FLARMConfigWidget::Prepare(ContainerWindow &parent, const PixelRect &rc)
{
RequestAllSettings(device);
baud = GetUnsignedValue(device, "BAUD", 2);
priv = GetUnsignedValue(device, "PRIV", 0);
thre = GetUnsignedValue(device, "THRE", 2);
range = GetUnsignedValue(device, "RANGE", 3000);
acft = GetUnsignedValue(device, "ACFT", 0);
log_int = GetUnsignedValue(device, "LOGINT", 2);
notrack = GetUnsignedValue(device, "NOTRACK", 0);
static constexpr StaticEnumChoice baud_list[] = {
{ 0, _T("4800"), NULL },
{ 1, _T("9600"), NULL },
{ 2, _T("19200"), NULL },
{ 4, _T("38400"), NULL },
{ 5, _T("57600"), NULL },
{ 0 }
};
AddEnum(_("Baud rate"), NULL, baud_list, baud);
AddBoolean(_("Stealth mode"), NULL, priv == 1);
AddInteger(_("Threshold"), NULL, _T("%d m/s"), _T("%d"), 1, 10, 1, thre);
AddInteger(_("Range"), NULL, _T("%d m"), _T("%d"), 2000, 25500, 250, range);
static constexpr StaticEnumChoice acft_list[] = {
{ (unsigned)FlarmTraffic::AircraftType::UNKNOWN, N_("Unkown") },
{ (unsigned)FlarmTraffic::AircraftType::GLIDER, N_("Glider") },
{ (unsigned)FlarmTraffic::AircraftType::TOW_PLANE, N_("Tow plane") },
{ (unsigned)FlarmTraffic::AircraftType::HELICOPTER, N_("Helicopter") },
{ (unsigned)FlarmTraffic::AircraftType::PARACHUTE, N_("Parachute") },
{ (unsigned)FlarmTraffic::AircraftType::DROP_PLANE, N_("Drop plane") },
{ (unsigned)FlarmTraffic::AircraftType::HANG_GLIDER, N_("Hang glider") },
{ (unsigned)FlarmTraffic::AircraftType::PARA_GLIDER, N_("Paraglider") },
{ (unsigned)FlarmTraffic::AircraftType::POWERED_AIRCRAFT,
N_("Powered aircraft") },
{ (unsigned)FlarmTraffic::AircraftType::JET_AIRCRAFT, N_("Jet aircraft") },
{ (unsigned)FlarmTraffic::AircraftType::FLYING_SAUCER,
N_("Flying saucer") },
{ (unsigned)FlarmTraffic::AircraftType::BALLOON, N_("Balloon") },
{ (unsigned)FlarmTraffic::AircraftType::AIRSHIP, N_("Airship") },
{ (unsigned)FlarmTraffic::AircraftType::UAV,
N_("Unmanned aerial vehicle") },
{ (unsigned)FlarmTraffic::AircraftType::STATIC_OBJECT,
N_("Static object") },
{ 0 }
};
AddEnum(_("Type"), NULL, acft_list, acft);
AddInteger(_("Logger interval"), NULL, _T("%d s"), _T("%d"),
1, 8, 1, log_int);
AddBoolean(_("No tracking mode"), NULL, notrack == 1);
}
void
TrackingConfigPanel::Prepare(ContainerWindow &parent, const PixelRect &rc)
{
const TrackingSettings &settings =
CommonInterface::GetComputerSettings().tracking;
RowFormWidget::Prepare(parent, rc);
#ifdef HAVE_SKYLINES_TRACKING
AddBoolean(_T("SkyLines"), NULL, settings.skylines.enabled, this);
AddTime(_("Tracking Interval"), NULL, 5, 1200, 5,
settings.skylines.interval);
#ifdef HAVE_SKYLINES_TRACKING_HANDLER
AddBoolean(_("Track friends"),
_("Download the position of your friends live from the SkyLines server."),
settings.skylines.traffic_enabled, this);
#endif
StaticString<64> buffer;
if (settings.skylines.key != 0)
buffer.UnsafeFormat(_T("%llX"), (unsigned long long)settings.skylines.key);
else
buffer.clear();
AddText(_T("Key"), NULL, buffer);
#endif
#if defined(HAVE_SKYLINES_TRACKING) && defined(HAVE_LIVETRACK24)
AddSpacer();
#endif
#ifdef HAVE_LIVETRACK24
AddBoolean(_T("LiveTrack24"), _T(""), settings.livetrack24.enabled, this);
AddTime(_("Tracking Interval"), _T(""), 5, 3600, 5, settings.interval);
AddEnum(_("Vehicle Type"), _("Type of vehicle used."), vehicle_type_list,
(unsigned) settings.vehicleType);
WndProperty *edit = AddEnum(_("Server"), _T(""), server_list, 0);
((DataFieldEnum *)edit->GetDataField())->Set(settings.livetrack24.server);
edit->RefreshDisplay();
AddText(_("Username"), _T(""), settings.livetrack24.username);
AddPassword(_("Password"), _T(""), settings.livetrack24.password);
#endif
#ifdef HAVE_SKYLINES_TRACKING
SetSkyLinesEnabled(settings.skylines.enabled);
#endif
#ifdef HAVE_LIVETRACK24
SetEnabled(settings.livetrack24.enabled);
#endif
}
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"), nullptr,
tabdialog_style_list, (unsigned)ui_settings.dialog.tab_style);
AddEnum(_("Message display"), nullptr,
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);
#ifdef KOBO
AddBoolean(_("Show Menubutton"), _("Show the Menubutton"),
ui_settings.show_menu_button);
SetExpertRow(ShowMenuButton);
#endif
}
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 GeneratorTest()
{
char* string;
JsonObject* root = CreateJsonObject();
JsonObject* element = CreateJsonObject();
JsonArray* array = CreateJsonArray();
AddInteger(array, 0);
AddReal(array, 0.0);
AddBoolean(array, FALSE);
AddObject(array, element);
AddString(array, "element");
AddNull(array);
PutNull(root, "0");
PutInteger(root, "Year", 1970);
PutInteger(root, "Month", 3);
PutInteger(root, "Date", 18);
PutArray(root, "Array", array);
PutBoolean(root, "Proposition", TRUE);
PutString(root, "Text", "Hello World");
PutReal(root, "Pi", 3.14159265358979323846264338327950288419716939937510582097494459230781640);
string = ToString(root);
printf("%s", string);
printf("\r\n");
EXPECT_EQUAL_STRING("{\"0\":null,\"Year\":1970,\"Month\":3,\"Date\":18,\"Array\":[0,0.000000,false,{},\"element\",null],\"Proposition\":true,\"Text\":\"Hello World\",\"Pi\":3.141593}", string);
free(string);
ClearJsonObject(root);
ClearJsonArray(array);
string = ToString(root);
EXPECT_EQUAL_STRING("{}", string);
free(string);
}
void
VegaParametersWidget::AddParameter(const StaticParameter &p)
{
assert(p.label != NULL);
const TCHAR *label = gettext(p.label);
const TCHAR *help = p.help != NULL ? gettext(p.help) : NULL;
switch (p.type) {
case DataField::Type::BOOLEAN:
assert(p.choices == NULL);
assert(p.format == NULL);
AddBoolean(p.name, label, help);
break;
case DataField::Type::INTEGER:
assert(p.choices == NULL);
assert(p.format != NULL);
AddInteger(p.name, label, help, p.min_value, p.max_value, p.format);
break;
case DataField::Type::ENUM:
assert(p.choices != NULL);
assert(p.format == NULL);
AddEnum(p.name, label, help, p.choices);
break;
default:
gcc_unreachable();
assert(false);
}
}
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 AnimaMappedValues::SetBoolean(const AnimaString& propertyName, bool value)
{
AnimaString pName = _uniqueName + propertyName;
if (_booleansMap.find(pName) == _booleansMap.end())
AddBoolean(propertyName, value);
else
_booleansMap[pName] = value;
}
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
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
LayoutConfigPanel::Prepare(ContainerWindow &parent, const PixelRect &rc)
{
const UISettings &ui_settings = CommonInterface::GetUISettings();
RowFormWidget::Prepare(parent, rc);
AddEnum(_("Display orientation"), NULL,
display_orientation_list, (unsigned)ui_settings.display.orientation);
SetRowVisible(DisplayOrientation, Display::RotateSupported());
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"), NULL, 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, ui_settings.popup_message_position);
SetExpertRow(AppStatusMessageAlignment);
AddEnum(_("Dialog size"), NULL,
dialog_style_list, ui_settings.dialog.dialog_style);
SetExpertRow(DialogStyle);
AddBoolean(_("Inverse InfoBoxes"), _("If true, the InfoBoxes are white on black, otherwise black on white."),
ui_settings.info_boxes.inverse);
SetExpertRow(AppInverseInfoBox);
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);
AddEnum(_("InfoBox border"), NULL, infobox_border_list, ui_settings.info_boxes.border_style);
SetExpertRow(AppInfoBoxBorder);
}
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
MapDisplayConfigPanel::Prepare(ContainerWindow &parent, const PixelRect &rc)
{
instance = this;
RowFormWidget::Prepare(parent, rc);
const MapSettings &settings_map = CommonInterface::GetMapSettings();
AddEnum(_("Cruise orientation"),
_("Determines how the screen is rotated with the glider"),
orientation_list,
settings_map.cruise_orientation,
OnShiftTypeData);
AddEnum(_("Circling orientation"),
_("Determines how the screen is rotated with the glider while circling"),
orientation_list,
settings_map.cruise_orientation,
OnShiftTypeData);
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,
settings_map.map_shift_bias,
OnShiftTypeData);
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);
AddFloat(_("Max. auto zoom distance"),
_("The upper limit for auto zoom distance."),
_T("%.0f %s"), _T("%.0f"), fixed(20), fixed(250), fixed(10), false,
ugDistance, settings_map.max_auto_zoom_distance);
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
VoiceSettingsPanel::Prepare(ContainerWindow &parent, const PixelRect &rc)
{
const VoiceSettings &settings = CommonInterface::GetComputerSettings().voice;
AddBoolean(_("Climb rate"),
_("Enable voice read-back of the average climb rate when circling."),
settings.voice_climb_rate_enabled);
AddBoolean(_("Terrain"),
_("Enable warnings for final glide through terrain."),
settings.voice_terrain_enabled);
AddBoolean(_("Waypoint distance"),
_("Enable voice read-back of the distance to next waypoint when in cruise mode."),
settings.voice_waypoint_distance_enabled);
AddBoolean(_("Task altitude difference"),
_("Enable voice read-back of height above/below final glide when in final glide."),
settings.voice_task_altitude_difference_enabled);
AddBoolean(_("MacCready"),
_("Enable voice read-back of MacReady setting after it is adjusted."),
settings.voice_mac_cready_enabled);
AddBoolean(_("New waypoint"),
_("Enable voice announcement that the task waypoint has changed."),
settings.voice_new_waypoint_enabled);
AddBoolean(_("In sector"),
_("Enable voice announcement that the glider is within the task observation sector."),
settings.voice_in_sector_enabled);
AddBoolean(_("Airspace"),
_("Enable voice warnings for airspace incursions."),
settings.voice_airspace_enabled);
}
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
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
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
WindSettingsPanel::Prepare(ContainerWindow &parent, const PixelRect &rc)
{
RowFormWidget::Prepare(parent, rc);
const WindSettings &settings = CommonInterface::GetComputerSettings().wind;
const MapSettings &map_settings = CommonInterface::GetMapSettings();
static constexpr StaticEnumChoice auto_wind_list[] = {
{ AUTOWIND_NONE, N_("Manual"),
N_("When the algorithm is switched off, the pilot is responsible for setting the wind estimate.") },
{ AUTOWIND_CIRCLING, N_("Circling"),
N_("Requires only a GPS source.") },
{ AUTOWIND_ZIGZAG, N_("ZigZag"),
N_("Requires GPS and an intelligent vario with airspeed output.") },
{ AUTOWIND_CIRCLING | AUTOWIND_ZIGZAG, N_("Both"),
N_("Use ZigZag and circling.") },
{ 0 }
};
AddEnum(_("Auto wind"),
_("This allows switching on or off the automatic wind algorithm."),
auto_wind_list, settings.GetLegacyAutoWindMode());
if (edit_trail_drift)
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."),
map_settings.trail.wind_drift_enabled);
else
AddDummy();
if (edit_manual_wind) {
SpeedVector manual_wind = CommonInterface::Calculated().GetWindOrZero();
AddReadOnly(_("Source"));
WndProperty *wp =
AddFloat(_("Speed"), _("Manual adjustment of wind speed."),
_T("%.0f %s"), _T("%.0f"),
fixed(0),
Units::ToUserWindSpeed(Units::ToSysUnit(fixed(200),
Unit::KILOMETER_PER_HOUR)),
fixed(1), false,
Units::ToUserWindSpeed(manual_wind.norm),
this);
DataFieldFloat &df = *(DataFieldFloat *)wp->GetDataField();
df.SetUnits(Units::GetWindSpeedName());
wp->RefreshDisplay();
wp = AddAngle(_("Direction"), _("Manual adjustment of wind direction."),
manual_wind.bearing, 5u, false,
this);
manual_modified = false;
}
if (clear_manual_button)
AddButton(_("Clear"), *this, CLEAR_MANUAL);
UpdateVector();
}
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
GlideComputerConfigPanel::Prepare(ContainerWindow &parent, const PixelRect &rc)
{
const ComputerSettings &settings_computer = XCSoarInterface::GetComputerSettings();
RowFormWidget::Prepare(parent, rc);
static gcc_constexpr_data StaticEnumChoice auto_wind_list[] = {
{ AUTOWIND_NONE, N_("Manual"),
N_("When the algorithm is switched off, the pilot is responsible for setting the wind estimate.") },
{ AUTOWIND_CIRCLING, N_("Circling"),
N_("Requires only a GPS source.") },
{ AUTOWIND_ZIGZAG, N_("ZigZag"),
N_("Requires GPS and an intelligent vario with airspeed output.") },
{ AUTOWIND_CIRCLING | AUTOWIND_ZIGZAG, N_("Both"),
N_("Use ZigZag and circling.") },
{ 0 }
};
AddEnum(_("Auto wind"),
_("This allows switching on or off the automatic wind algorithm."),
auto_wind_list, settings_computer.auto_wind_mode);
AddBoolean(_("External wind"),
_("If enabled, then the wind vector received from external devices overrides "
"XCSoar's internal wind calculation."),
settings_computer.use_external_wind);
static gcc_constexpr_data StaticEnumChoice auto_mc_list[] = {
{ TaskBehaviour::AUTOMC_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.") },
{ TaskBehaviour::AUTOMC_CLIMBAVERAGE, N_("Trending average climb"),
N_("Sets MC to the trending average climb rate based on all climbs.") },
{ TaskBehaviour::AUTOMC_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, settings_computer.task.auto_mc_mode);
// TODO All below is for the Expert
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.block_stf_enabled);
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.nav_baro_altitude_enabled);
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);
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);
}
void
WindSettingsPanel::Prepare(ContainerWindow &parent, const PixelRect &rc)
{
RowFormWidget::Prepare(parent, rc);
const NMEAInfo &basic = CommonInterface::Basic();
const WindSettings &settings = CommonInterface::GetComputerSettings().wind;
const MapSettings &map_settings = CommonInterface::GetMapSettings();
static gcc_constexpr_data StaticEnumChoice auto_wind_list[] = {
{ AUTOWIND_NONE, N_("Manual"),
N_("When the algorithm is switched off, the pilot is responsible for setting the wind estimate.") },
{ AUTOWIND_CIRCLING, N_("Circling"),
N_("Requires only a GPS source.") },
{ AUTOWIND_ZIGZAG, N_("ZigZag"),
N_("Requires GPS and an intelligent vario with airspeed output.") },
{ AUTOWIND_CIRCLING | AUTOWIND_ZIGZAG, N_("Both"),
N_("Use ZigZag and circling.") },
{ 0 }
};
AddEnum(_("Auto wind"),
_("This allows switching on or off the automatic wind algorithm."),
auto_wind_list, settings.GetLegacyAutoWindMode());
AddBoolean(_("External wind"),
_("If enabled, then the wind vector received from external devices overrides "
"XCSoar's internal wind calculation."),
settings.use_external_wind);
AddBoolean(_("Trail drift"),
_("Determines whether the snail trail is drifted with the wind "
"when displayed in circling mode."),
map_settings.trail_drift_enabled);
if (edit_manual_wind) {
external_wind = settings.use_external_wind &&
basic.external_wind_available;
SpeedVector manual_wind = CommonInterface::Calculated().GetWindOrZero();
WndProperty *wp =
AddFloat(_("Speed"), _("Manual adjustment of wind speed."),
_T("%.0f %s"), _T("%.0f"),
fixed_zero,
Units::ToUserWindSpeed(Units::ToSysUnit(fixed(200),
Unit::KILOMETER_PER_HOUR)),
fixed_one, false,
Units::ToUserWindSpeed(manual_wind.norm));
wp->SetEnabled(!external_wind);
DataFieldFloat &df = *(DataFieldFloat *)wp->GetDataField();
df.SetUnits(Units::GetWindSpeedName());
wp->RefreshDisplay();
wp = AddFloat(_("Direction"), _("Manual adjustment of wind direction."),
_T("%.0f°"), _T("%.0f"),
fixed_zero, fixed(355), fixed(5), false,
manual_wind.bearing.Degrees());
wp->SetEnabled(!external_wind);
}
}
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 */
}