void
OrderedTaskPointLabel(TaskPointType type, const TCHAR *name,
unsigned index, TCHAR* buffer)
{
switch (type) {
case TaskPointType::START:
StringFormatUnsafe(buffer, _T("S: %s"), name);
break;
case TaskPointType::AST:
StringFormatUnsafe(buffer, _T("T%d: %s"), index, name);
break;
case TaskPointType::AAT:
StringFormatUnsafe(buffer, _T("A%d: %s"), index, name);
break;
case TaskPointType::FINISH:
StringFormatUnsafe(buffer, _T("F: %s"), name);
break;
default:
break;
}
}
void
AirspaceFormatter::FormatAltitudeShort(TCHAR *buffer,
const AirspaceAltitude &altitude)
{
switch (altitude.reference) {
case AltitudeReference::AGL:
if (!positive(altitude.altitude_above_terrain))
_tcscpy(buffer, _T("GND"));
else
StringFormatUnsafe(buffer, _T("%d %s AGL"),
iround(Units::ToUserAltitude(altitude.altitude_above_terrain)),
Units::GetAltitudeName());
break;
case AltitudeReference::STD:
StringFormatUnsafe(buffer, _T("FL%d"), iround(altitude.flight_level));
break;
case AltitudeReference::MSL:
StringFormatUnsafe(buffer, _T("%d %s"),
iround(Units::ToUserAltitude(altitude.altitude)),
Units::GetAltitudeName());
break;
case AltitudeReference::NONE:
*buffer = _T('\0');
break;
}
}
void
OrderedTaskSummary(const OrderedTask *task, TCHAR *text, bool linebreaks)
{
const TaskStats &stats = task->GetStats();
TCHAR summary_shape[100];
bool FAIShape = TaskSummaryShape(task, summary_shape);
if (FAIShape || task->GetFactoryType() == TaskFactoryType::FAI_GENERAL) {
if (!task->GetFactory().ValidateFAIOZs()) {
_tcscat(summary_shape, _T("/ "));
_tcscat(summary_shape, getTaskValidationErrors(
task->GetFactory().GetValidationErrors()));
}
}
TCHAR linebreak[3];
if (linebreaks) {
linebreak[0] = '\n';
linebreak[1] = 0;
} else {
linebreak[0] = ',';
linebreak[1] = ' ';
linebreak[2] = 0;
}
if (!task->TaskSize()) {
StringFormatUnsafe(text, _("Task is empty (%s)"),
OrderedTaskFactoryName(task->GetFactoryType()));
} else {
if (task->HasTargets())
StringFormatUnsafe(text, _T("%s%s%.0f %s%s%s %.0f %s%s%s %.0f %s (%s)"),
summary_shape,
linebreak,
(double)Units::ToUserDistance(stats.distance_nominal),
Units::GetDistanceName(),
linebreak,
_("max."),
(double)Units::ToUserDistance(stats.distance_max),
Units::GetDistanceName(),
linebreak,
_("min."),
(double)Units::ToUserDistance(stats.distance_min),
Units::GetDistanceName(),
OrderedTaskFactoryName(task->GetFactoryType()));
else
StringFormatUnsafe(text, _T("%s%s%s %.0f %s (%s)"),
summary_shape,
linebreak,
_("dist."),
(double)Units::ToUserDistance(stats.distance_nominal),
Units::GetDistanceName(),
OrderedTaskFactoryName(task->GetFactoryType()));
}
}
void
FormatTemperature(TCHAR *buffer, fixed value, Unit unit,
bool include_unit)
{
value = Units::ToUserUnit(value, unit);
if (include_unit)
StringFormatUnsafe(buffer, _T("%.0f %s"),
(double)value, Units::GetUnitName(unit));
else
StringFormatUnsafe(buffer, _T("%.0f"), (double)value);
}
void
FormatDistance(TCHAR *buffer, fixed value, Unit unit,
bool include_unit, int precision)
{
value = Units::ToUserUnit(value, unit);
if (include_unit)
StringFormatUnsafe(buffer, _T("%.*f %s"), precision, (double)value,
Units::GetUnitName(unit));
else
StringFormatUnsafe(buffer, _T("%.*f"), precision, (double)value);
}
void
FormatSpeed(TCHAR *buffer,
fixed value, const Unit unit, bool include_unit, bool precision)
{
value = Units::ToUserUnit(value, unit);
const int prec = precision && value < fixed(100);
if (include_unit)
StringFormatUnsafe(buffer, _T("%.*f %s"), prec, (double)value,
Units::GetUnitName(unit));
else
StringFormatUnsafe(buffer, _T("%.*f"), prec, (double)value);
}
void
FormatPressure(TCHAR *buffer, AtmosphericPressure pressure,
Unit unit, bool include_unit)
{
auto _pressure = Units::ToUserUnit(pressure.GetHectoPascal(), unit);
if (include_unit)
StringFormatUnsafe(buffer, GetPressureFormat(unit, include_unit),
(double)_pressure,
Units::GetUnitName(unit));
else
StringFormatUnsafe(buffer, GetPressureFormat(unit, include_unit),
(double)_pressure);
}
static void
FormatInteger(TCHAR *buffer,
const fixed value, const Unit unit, bool include_unit,
bool include_sign)
{
const auto uvalue = Units::ToUserUnit(value, unit);
const int ivalue = iround(uvalue);
if (include_unit)
StringFormatUnsafe(buffer, include_sign ? _T("%+d %s") : _T("%d %s"),
ivalue, Units::GetUnitName(unit));
else
StringFormatUnsafe(buffer, include_sign ? _T("%+d") : _T("%d"), ivalue);
}
void
FormatVerticalSpeed(TCHAR *buffer, fixed value, Unit unit,
bool include_unit, bool include_sign)
{
value = Units::ToUserUnit(value, unit);
if (include_unit)
StringFormatUnsafe(buffer,
GetVerticalSpeedFormat(unit, include_unit, include_sign),
(double)value, Units::GetUnitName(unit));
else
StringFormatUnsafe(buffer,
GetVerticalSpeedFormat(unit, include_unit, include_sign),
(double)value);
}
Unit
FormatSmallDistance(TCHAR *buffer, fixed value, Unit unit,
bool include_unit, int precision)
{
unit = GetSmallerDistanceUnit(unit);
value = Units::ToUserUnit(value, unit);
if (include_unit)
StringFormatUnsafe(buffer, _T("%.*f %s"), precision, (double)value,
Units::GetUnitName(unit));
else
StringFormatUnsafe(buffer, _T("%.*f"), precision, (double)value);
return unit;
}
void
AltairProDevice::PutTurnPoint(const TCHAR *propertyName,
const Waypoint *waypoint,
OperationEnvironment &env)
{
TCHAR Name[DECELWPNAMESIZE];
TCHAR Buffer[DECELWPSIZE*2];
int DegLat, DegLon;
double tmp, MinLat, MinLon;
char NoS, EoW;
if (waypoint != nullptr) {
CopyString(Name, waypoint->name.c_str(), ARRAY_SIZE(Name));
tmp = (double)waypoint->location.latitude.Degrees();
if(tmp < 0) {
NoS = 'S';
tmp *= -1;
} else NoS = 'N';
DegLat = (int)tmp;
MinLat = tmp - DegLat;
MinLat *= 60;
MinLat *= 1000;
tmp = (double)waypoint->location.longitude.Degrees();
if (tmp < 0) {
EoW = 'W';
tmp *= -1;
} else EoW = 'E';
DegLon = (int)tmp;
MinLon = tmp - DegLon;
MinLon *= 60;
MinLon *= 1000;
} else {
Name[0] = '\0';
DegLat = 0;
MinLat = 0;
DegLon = 0;
MinLon = 0;
NoS = 'N';
EoW = 'E';
}
StringFormatUnsafe(Buffer, _T("PDVSC,S,%s,%02d%05.0f%c%03d%05.0f%c%s"),
propertyName,
DegLat, MinLat, NoS, DegLon, MinLon, EoW, Name);
PropertySetGet(Buffer, ARRAY_SIZE(Buffer), env);
}
void
DataFieldTime::AppendComboValue(ComboList &combo_list, int value) const
{
TCHAR buffer[128], buffer2[32];
FormatTimespanSmart(buffer, value, max_tokens);
StringFormatUnsafe(buffer2, _T("%d"), value);
combo_list.Append(value, buffer2, buffer);
}
gcc_pure
static const TCHAR *
GetHeadingString(TCHAR *buffer)
{
TCHAR heading[32];
FormatBearing(heading, ARRAY_SIZE(heading),
CommonInterface::Basic().attitude.heading);
StringFormatUnsafe(buffer, _T("%s (%s)"), _("Heading"), heading);
return buffer;
}
void
AirspaceFormatter::FormatAltitude(TCHAR *buffer,
const AirspaceAltitude &altitude)
{
FormatAltitudeShort(buffer, altitude);
if ((altitude.reference == AltitudeReference::MSL ||
altitude.reference == AltitudeReference::AGL) &&
Units::GetUserAltitudeUnit() == Unit::METER)
/* additionally show airspace altitude in feet, because aviation
charts usually print altitudes in feet */
StringFormatUnsafe(buffer + _tcslen(buffer), _T(" (%d %s)"),
iround(Units::ToUserUnit(altitude.altitude, Unit::FEET)),
Units::GetUnitName(Unit::FEET));
if (altitude.reference != AltitudeReference::MSL &&
positive(altitude.altitude))
StringFormatUnsafe(buffer + _tcslen(buffer), _T(" %d %s"),
iround(Units::ToUserAltitude(altitude.altitude)),
Units::GetAltitudeName());
}
void
ClimbChartCaption(TCHAR *sTmp,
const FlightStatistics &fs)
{
ScopeLock lock(fs.mutex);
if (fs.thermal_average.IsEmpty()) {
sTmp[0] = _T('\0');
} else if (fs.thermal_average.GetCount() == 1) {
StringFormatUnsafe(sTmp, _T("%s:\r\n %3.1f %s"),
_("Avg. climb"),
(double)Units::ToUserVSpeed(fixed(fs.thermal_average.GetAverageY())),
Units::GetVerticalSpeedName());
} else {
StringFormatUnsafe(sTmp, _T("%s:\r\n %3.1f %s\r\n\r\n%s:\r\n %3.2f %s"),
_("Avg. climb"),
(double)Units::ToUserVSpeed(fixed(fs.thermal_average.GetAverageY())),
Units::GetVerticalSpeedName(),
_("Climb trend"),
(double)Units::ToUserVSpeed(fixed(fs.thermal_average.GetGradient())),
Units::GetVerticalSpeedName());
}
}
void
BarographCaption(TCHAR *sTmp, const FlightStatistics &fs)
{
ScopeLock lock(fs.mutex);
if (!fs.altitude_ceiling.HasResult()) {
sTmp[0] = _T('\0');
} else if (fs.altitude_ceiling.GetCount() < 4) {
StringFormatUnsafe(sTmp, _T("%s:\r\n %.0f-%.0f %s"),
_("Working band"),
(double)Units::ToUserAltitude(fs.altitude_base.GetAverageY()),
(double)Units::ToUserAltitude(fs.altitude_ceiling.GetAverageY()),
Units::GetAltitudeName());
} else {
StringFormatUnsafe(sTmp, _T("%s:\r\n %.0f-%.0f %s\r\n\r\n%s:\r\n %.0f %s/hr"),
_("Working band"),
(double)Units::ToUserAltitude(fs.altitude_base.GetAverageY()),
(double)Units::ToUserAltitude(fs.altitude_ceiling.GetAverageY()),
Units::GetAltitudeName(),
_("Ceiling trend"),
(double)Units::ToUserAltitude(fs.altitude_ceiling.GetGradient()),
Units::GetAltitudeName());
}
}
static TCHAR *
GetDirectionData(TCHAR *buffer, size_t size, int direction_filter_index)
{
if (direction_filter_index == 0)
_tcscpy(buffer, _T("*"));
else if (direction_filter_index == 1) {
TCHAR bearing[8];
FormatBearing(bearing, ARRAY_SIZE(bearing), last_heading);
StringFormatUnsafe(buffer, _T("HDG(%s)"), bearing);
} else
FormatBearing(buffer, size, direction_filter_items[direction_filter_index]);
return buffer;
}
static void
Draw(Canvas &canvas, const PixelRect rc,
const LocationMapItem &item,
const TwoTextRowsRenderer &row_renderer)
{
TCHAR info_buffer[256];
if (item.vector.IsValid())
StringFormatUnsafe(info_buffer, _T("%s: %s, %s: %s"),
_("Distance"),
FormatUserDistanceSmart(item.vector.distance).c_str(),
_("Direction"),
FormatBearing(item.vector.bearing).c_str());
else
StringFormatUnsafe(info_buffer, _T("%s: %s, %s: %s"),
_("Distance"), _T("???"), _("Direction"), _T("???"));
row_renderer.DrawFirstRow(canvas, rc, info_buffer);
StringFormatUnsafe(info_buffer, _T("%s: %s"), _("Elevation"),
item.HasElevation()
? FormatUserAltitude(item.elevation).c_str()
: _T("???"));
row_renderer.DrawSecondRow(canvas, rc, info_buffer);
}
/**
*
* @param task
* @param text
* @return True if FAI shape
*/
static bool
TaskSummaryShape(const OrderedTask *task, TCHAR *text)
{
bool FAIShape = false;
switch (task->TaskSize()) {
case 0:
text[0] = '\0';
break;
case 1:
_tcscpy(text, _("Unknown"));
break;
case 2:
_tcscpy(text, _("Goal"));
FAIShape = true;
break;
case 3:
if (task->GetFactory().IsClosed()) {
_tcscpy(text, _("Out and return"));
FAIShape = true;
}
else
_tcscpy(text, _("Two legs"));
break;
case 4:
if (!task->GetFactory().IsUnique() ||!task->GetFactory().IsClosed())
_tcscpy(text, _("Three legs"));
else if (FAITriangleValidator::Validate(*task)) {
_tcscpy(text, _("FAI triangle"));
FAIShape = true;
}
else
_tcscpy(text, _("non-FAI triangle"));
break;
default:
StringFormatUnsafe(text, _("%d legs"), task->TaskSize() - 1);
break;
}
return FAIShape;
}
static void
FillDistanceEnum(DataFieldEnum &df)
{
df.AddChoice(0, _T("*"));
static constexpr unsigned distances[] = {
25, 50, 75, 100, 150, 250, 500, 1000
};
TCHAR buffer[64];
const TCHAR *unit = Units::GetDistanceName();
for (unsigned i = 0; i < ARRAY_SIZE(distances); ++i) {
StringFormatUnsafe(buffer, _T("%u %s"), distances[i], unit);
df.AddChoice(distances[i], buffer);
}
df.Set(0u);
}
static void
FillAndroidIOIOPorts(DataFieldEnum &df, const DeviceConfig &config)
{
#if defined(ANDROID)
df.EnableItemHelp(true);
TCHAR tempID[4];
TCHAR tempName[15];
for (unsigned i = 0; i < AndroidIOIOUartPort::getNumberUarts(); i++) {
StringFormatUnsafe(tempID, _T("%u"), i);
StringFormat(tempName, sizeof(tempName), _T("IOIO Uart %u"), i);
unsigned id = AddPort(df, DeviceConfig::PortType::IOIOUART,
tempID, tempName,
AndroidIOIOUartPort::getPortHelp(i));
if (config.port_type == DeviceConfig::PortType::IOIOUART &&
config.ioio_uart_id == i)
df.Set(id);
}
#endif
}
void
RenderTaskLegs(ChartRenderer &chart,
const TaskManager &task_manager,
const NMEAInfo& basic,
const DerivedInfo& calculated,
const double y)
{
const TaskStats &task_stats = calculated.ordered_task_stats;
if (!task_stats.start.task_started)
return;
TCHAR sTmp[5];
const OrderedTask &task = task_manager.GetOrderedTask();
for (unsigned i = 0, n = task.TaskSize(); i < n; ++i) {
const OrderedTaskPoint &tp = task.GetTaskPoint(i);
if (!IsTaskLegVisible(tp))
continue;
auto x = tp.GetEnteredState().time - calculated.flight.takeoff_time;
if (x >= 0) {
x /= 3600;
if (y>=0) {
if (i==0) {
chart.DrawBlankRectangle(chart.GetXMin(), chart.GetYMin(),
x, chart.GetYMax());
} else if (i+1 == task.TaskSize()) {
chart.DrawBlankRectangle(x, chart.GetYMin(),
chart.GetXMax(), chart.GetYMax());
}
chart.DrawLine(x, chart.GetYMin(), x, chart.GetYMax(),
ChartLook::STYLE_GRIDZERO);
}
if (y>=0) {
StringFormatUnsafe(sTmp, _T("%d"), i);
chart.DrawLabel(sTmp, x, chart.GetYMax()*y + chart.GetYMin()*(1-y));
}
}
}
}
void FormatLabel(TCHAR *buffer, size_t buffer_size,
const Waypoint &way_point,
WaypointRenderer::Reachability reachable,
const ReachResult &reach) const {
FormatTitle(buffer, buffer_size - 20, way_point);
if (!way_point.IsLandable() && !way_point.flags.watched)
return;
if (settings.arrival_height_display == WaypointRendererSettings::ArrivalHeightDisplay::REQUIRED_GR) {
if (!basic.location_available || !basic.NavAltitudeAvailable())
return;
const auto safety_height = task_behaviour.safety_height_arrival;
const auto target_altitude = way_point.elevation + safety_height;
const auto delta_h = basic.nav_altitude - target_altitude;
if (delta_h <= 0)
/* no L/D if below waypoint */
return;
const auto distance = basic.location.DistanceS(way_point.location);
const auto gr = distance / delta_h;
if (!GradientValid(gr))
return;
size_t length = _tcslen(buffer);
if (length > 0)
buffer[length++] = _T(':');
StringFormatUnsafe(buffer + length, _T("%.1f"), (double) gr);
return;
}
if (reachable == WaypointRenderer::Invalid)
return;
if (!reach.IsReachableDirect() && !way_point.flags.watched)
return;
if (settings.arrival_height_display == WaypointRendererSettings::ArrivalHeightDisplay::NONE)
return;
size_t length = _tcslen(buffer);
int uah_glide = (int)Units::ToUserAltitude(reach.direct);
int uah_terrain = (int)Units::ToUserAltitude(reach.terrain);
if (settings.arrival_height_display == WaypointRendererSettings::ArrivalHeightDisplay::TERRAIN) {
if (reach.IsReachableTerrain()) {
if (length > 0)
buffer[length++] = _T(':');
StringFormatUnsafe(buffer + length, _T("%d%s"),
uah_terrain, altitude_unit);
}
return;
}
if (length > 0)
buffer[length++] = _T(':');
if (settings.arrival_height_display == WaypointRendererSettings::ArrivalHeightDisplay::GLIDE_AND_TERRAIN &&
reach.IsReachableDirect() && reach.IsReachableTerrain() &&
reach.IsDeltaConsiderable()) {
StringFormatUnsafe(buffer + length, _T("%d/%d%s"), uah_glide,
uah_terrain, altitude_unit);
return;
}
StringFormatUnsafe(buffer + length, _T("%d%s"), uah_glide, altitude_unit);
}
void
AnalysisWidget::Update()
{
TCHAR sTmp[1000];
const ComputerSettings &settings_computer = blackboard.GetComputerSettings();
const DerivedInfo &calculated = blackboard.Calculated();
switch (page) {
case AnalysisPage::BAROGRAPH:
StringFormatUnsafe(sTmp, _T("%s: %s"), _("Analysis"),
_("Barograph"));
dialog.SetCaption(sTmp);
BarographCaption(sTmp, glide_computer.GetFlightStats());
info.SetText(sTmp);
SetCalcCaption(_("Settings"));
break;
case AnalysisPage::CLIMB:
StringFormatUnsafe(sTmp, _T("%s: %s"), _("Analysis"),
_("Climb"));
dialog.SetCaption(sTmp);
ClimbChartCaption(sTmp, glide_computer.GetFlightStats());
info.SetText(sTmp);
SetCalcCaption(_("Task Calc"));
break;
case AnalysisPage::THERMAL_BAND:
StringFormatUnsafe(sTmp, _T("%s: %s"), _("Analysis"),
_("Thermal Band"));
dialog.SetCaption(sTmp);
ClimbChartCaption(sTmp, glide_computer.GetFlightStats());
info.SetText(sTmp);
SetCalcCaption(_T(""));
break;
case AnalysisPage::WIND:
StringFormatUnsafe(sTmp, _T("%s: %s"), _("Analysis"),
_("Wind at Altitude"));
dialog.SetCaption(sTmp);
info.SetText(_T(""));
SetCalcCaption(_("Set Wind"));
break;
case AnalysisPage::POLAR:
StringFormatUnsafe(sTmp, _T("%s: %s (%s %d kg)"), _("Analysis"),
_("Glide Polar"), _("Mass"),
(int)settings_computer.polar.glide_polar_task.GetTotalMass());
dialog.SetCaption(sTmp);
GlidePolarCaption(sTmp, settings_computer.polar.glide_polar_task);
info.SetText(sTmp);
SetCalcCaption(_("Settings"));
break;
case AnalysisPage::TEMPTRACE:
StringFormatUnsafe(sTmp, _T("%s: %s"), _("Analysis"),
_("Temp Trace"));
dialog.SetCaption(sTmp);
TemperatureChartCaption(sTmp, glide_computer.GetCuSonde());
info.SetText(sTmp);
SetCalcCaption(_("Settings"));
break;
case AnalysisPage::TASK_SPEED:
StringFormatUnsafe(sTmp, _T("%s: %s"), _("Analysis"),
_("Task Speed"));
dialog.SetCaption(sTmp);
info.SetText(_T(""));
SetCalcCaption(_("Task Calc"));
break;
case AnalysisPage::TASK:
StringFormatUnsafe(sTmp, _T("%s: %s"), _("Analysis"),
_("Task"));
dialog.SetCaption(sTmp);
FlightStatisticsRenderer::CaptionTask(sTmp, calculated);
info.SetText(sTmp);
SetCalcCaption(_("Task calc"));
break;
case AnalysisPage::OLC:
StringFormatUnsafe(sTmp, _T("%s: %s"), _("Analysis"),
ContestToString(settings_computer.contest.contest));
dialog.SetCaption(sTmp);
SetCalcCaption(_T(""));
FlightStatisticsRenderer::CaptionOLC(sTmp, settings_computer.contest,
calculated);
info.SetText(sTmp);
break;
case AnalysisPage::AIRSPACE:
StringFormatUnsafe(sTmp, _T("%s: %s"), _("Analysis"),
_("Airspace"));
dialog.SetCaption(sTmp);
info.SetText(_T(""));
SetCalcCaption(_("Warnings"));
break;
case AnalysisPage::COUNT:
gcc_unreachable();
}
if (page == AnalysisPage::AIRSPACE)
chart.UpdateCrossSection(blackboard.Basic(), calculated,
settings_computer.task.glide,
settings_computer.polar.glide_polar_task,
blackboard.GetMapSettings());
chart.Invalidate();
}
const TCHAR *
DataFieldTime::GetAsString() const
{
StringFormatUnsafe(string_buffer, _T("%d"), value);
return string_buffer;
}
void UnsafeFormat(const T *fmt, Args&&... args) {
StringFormatUnsafe(data, fmt, args...);
}
/**
* Updates all the dialogs fields.
* Should be called on dialog opening as it closes the dialog when the
* target does not exist.
*/
void
FlarmTrafficDetailsWidget::Update()
{
TCHAR tmp[200], tmp_id[7];
const TCHAR *value;
// Set the dialog caption
StringFormatUnsafe(tmp, _T("%s (%s)"),
_("FLARM Traffic Details"), target_id.Format(tmp_id));
dialog.SetCaption(tmp);
// Try to find the target in the FLARMnet database
/// @todo: make this code a little more usable
const FlarmNetRecord *record = FlarmDetails::LookupRecord(target_id);
if (record) {
// Fill the pilot name field
SetText(PILOT, record->pilot);
// Fill the frequency field
if (!StringIsEmpty(record->frequency))
value = UnsafeBuildString(tmp, record->frequency.c_str(), _T(" MHz"));
else
value = _T("--");
SetText(RADIO, value);
// Fill the home airfield field
SetText(AIRPORT, record->airfield);
// Fill the plane type field
SetText(PLANE, record->plane_type);
} else {
// Fill the pilot name field
SetText(PILOT, _T("--"));
// Fill the frequency field
SetText(RADIO, _T("--"));
// Fill the home airfield field
SetText(AIRPORT, _T("--"));
// Fill the plane type field
const FlarmTraffic* target =
CommonInterface::Basic().flarm.traffic.FindTraffic(target_id);
const TCHAR* actype;
if (target == nullptr ||
(actype = FlarmTraffic::GetTypeString(target->type)) == nullptr)
actype = _T("--");
SetText(PLANE, actype);
}
// Fill the callsign field (+ registration)
// note: don't use target->Name here since it is not updated
// yet if it was changed
const TCHAR* cs = FlarmDetails::LookupCallsign(target_id);
if (cs != nullptr && cs[0] != 0) {
StringBuilder<TCHAR> builder(tmp, ARRAY_SIZE(tmp));
builder.Append(cs);
if (record)
builder.Append(_T(" ("), record->registration.c_str(), _T(")"));
value = tmp;
} else
value = _T("--");
SetText(CALLSIGN, value);
// Update the frequently changing fields too
UpdateChanging(CommonInterface::Basic());
}
void
OrderedTaskPointRadiusLabel(const ObservationZonePoint &ozp, TCHAR* buffer)
{
switch (ozp.GetShape()) {
case ObservationZone::Shape::FAI_SECTOR:
_tcscpy(buffer, _("FAI quadrant"));
return;
case ObservationZone::Shape::SECTOR:
case ObservationZone::Shape::ANNULAR_SECTOR:
StringFormatUnsafe(buffer,_T("%s - %s: %.1f%s"), _("Sector"), _("Radius"),
(double)Units::ToUserDistance(((const SectorZone &)ozp).GetRadius()),
Units::GetDistanceName());
return;
case ObservationZone::Shape::LINE:
StringFormatUnsafe(buffer,_T("%s - %s: %.1f%s"), _("Line"), _("Gate width"),
(double)Units::ToUserDistance(((const LineSectorZone &)ozp).GetLength()),
Units::GetDistanceName());
return;
case ObservationZone::Shape::CYLINDER:
StringFormatUnsafe(buffer,_T("%s - %s: %.1f%s"), _("Cylinder"), _("Radius"),
(double)Units::ToUserDistance(((const CylinderZone &)ozp).GetRadius()),
Units::GetDistanceName());
return;
case ObservationZone::Shape::MAT_CYLINDER:
_tcscpy(buffer, _("MAT cylinder"));
return;
case ObservationZone::Shape::CUSTOM_KEYHOLE:
StringFormatUnsafe(buffer,_T("%s - %s: %.1f%s"), _("Keyhole"), _("Radius"),
(double)Units::ToUserDistance(((const KeyholeZone &)ozp).GetRadius()),
Units::GetDistanceName());
return;
case ObservationZone::Shape::DAEC_KEYHOLE:
_tcscpy(buffer, _("DAeC Keyhole"));
return;
case ObservationZone::Shape::BGAFIXEDCOURSE:
_tcscpy(buffer, _("BGA Fixed Course"));
return;
case ObservationZone::Shape::BGAENHANCEDOPTION:
_tcscpy(buffer, _("BGA Enhanced Option"));
return;
case ObservationZone::Shape::BGA_START:
_tcscpy(buffer, _("BGA Start Sector"));
return;
case ObservationZone::Shape::SYMMETRIC_QUADRANT:
_tcscpy(buffer, _("Symmetric quadrant"));
return;
}
gcc_unreachable();
assert(false);
}
bool
AltairProDevice::DeclareInternal(const struct Declaration &declaration,
OperationEnvironment &env)
{
TCHAR Buffer[256];
StringFormatUnsafe(Buffer, _T("PDVSC,S,Pilot,%s"),
declaration.pilot_name.c_str());
if (!PropertySetGet(Buffer, ARRAY_SIZE(Buffer), env))
return false;
StringFormatUnsafe(Buffer, _T("PDVSC,S,GliderID,%s"),
declaration.aircraft_registration.c_str());
if (!PropertySetGet(Buffer, ARRAY_SIZE(Buffer), env))
return false;
StringFormatUnsafe(Buffer, _T("PDVSC,S,GliderType,%s"),
declaration.aircraft_type.c_str());
if (!PropertySetGet(Buffer, ARRAY_SIZE(Buffer), env))
return false;
/* TODO currently not supported by XCSOAR
* Pilot2
* CompetitionID
* CompetitionClass
* ObserverID
* DeclDescription
* DeclFlightDate
*/
if (declaration.Size() > 1) {
PutTurnPoint(_T("DeclTakeoff"), nullptr, env);
PutTurnPoint(_T("DeclLanding"), nullptr, env);
PutTurnPoint(_T("DeclStart"), &declaration.GetFirstWaypoint(), env);
PutTurnPoint(_T("DeclFinish"), &declaration.GetLastWaypoint(), env);
for (unsigned int index=1; index <= 10; index++) {
TCHAR TurnPointPropertyName[32];
StringFormatUnsafe(TurnPointPropertyName, _T("DeclTurnPoint%d"), index);
if (index < declaration.Size() - 1) {
PutTurnPoint(TurnPointPropertyName, &declaration.GetWaypoint(index),
env);
} else {
PutTurnPoint(TurnPointPropertyName, nullptr, env);
}
}
}
UnsafeCopyString(Buffer, _T("PDVSC,S,DeclAction,DECLARE"));
if (!PropertySetGet(Buffer, ARRAY_SIZE(Buffer), env))
return false;
if (StringIsEqual(&Buffer[9], _T("LOCKED")))
// FAILED! try to declare a task on a airborn recorder
return false;
// Buffer holds the declaration ticket.
// but no one is intresting in that
// eg "2010-11-21 13:01:43 (1)"
return true;
}
