void
DataNode::SetAttribute(const TCHAR *name, fixed value)
{
StaticString<48> buf;
buf.UnsafeFormat(_T("%g"), (double)value);
SetAttribute(name, buf);
}
void
WritableDataNode::SetAttribute(const TCHAR *name, int value)
{
StaticString<24> buf;
buf.UnsafeFormat(_T("%d"), value);
SetAttribute(name, buf);
}
void
DataNode::SetAttribute(const TCHAR *name, unsigned value)
{
StaticString<24> buf;
buf.UnsafeFormat(_T("%d"), value);
SetAttribute(name, buf);
}
void
WifiListWidget::OnPaintItem(Canvas &canvas, const PixelRect rc,
unsigned idx)
{
const DialogLook &look = UIGlobals::GetDialogLook();
const auto &info = networks[idx];
const unsigned padding = Layout::GetTextPadding();
const unsigned x1 = rc.left + padding;
const unsigned y1 = rc.top + padding;
const unsigned y2 = y1 + look.text_font->GetHeight() + padding;
static char wifi_security[][20] = {
"WPA",
"WEP",
"Open",
};
canvas.Select(*look.text_font);
canvas.DrawText(x1, y1, info.ssid);
canvas.Select(*look.small_font);
canvas.DrawText(x1, y2, info.bssid);
const TCHAR *state = nullptr;
StaticString<40> state_buffer;
/* found the currently connected wifi network? */
if (StringIsEqual(info.bssid, status.bssid)) {
state = _("Connected");
/* look up ip address for eth0 */
const auto addr = IPv4Address::GetDeviceAddress("eth0");
if (addr.IsDefined()) { /* valid address? */
StaticString<40> addr_str;
if (addr.ToString(addr_str.buffer(), addr_str.MAX_SIZE) != nullptr) {
state_buffer.Format(_T("%s (%s)"), state, addr_str.c_str());
state = state_buffer;
}
}
}
else if (info.id >= 0)
state = info.signal_level >= 0
? _("Saved and visible")
: _("Saved, but not visible");
else if (info.signal_level >= 0)
state = _("Visible");
if (state != nullptr) {
unsigned width = canvas.CalcTextWidth(state);
canvas.DrawText(rc.right - padding - width, y1, state);
}
if (info.signal_level >= 0) {
StaticString<20> text;
text.UnsafeFormat(_T("%s %u"), wifi_security[info.security], info.signal_level);
unsigned width = canvas.CalcTextWidth(text);
canvas.DrawText(rc.right - padding - width, y2, text);
}
}
void
DataNode::SetAttribute(const TCHAR *name, bool &value)
{
StaticString<4> buf;
buf.UnsafeFormat(_T("%d"), (int)value);
SetAttribute(name, buf);
}
void
MapItemListBuilder::AddSkyLinesTraffic()
{
#ifdef HAVE_SKYLINES_TRACKING_HANDLER
const auto &data = tracking->GetSkyLinesData();
const ScopeLock protect(data.mutex);
StaticString<32> buffer;
for (const auto &i : data.traffic) {
if (list.full())
break;
if (i.second.location.IsValid() &&
location.DistanceS(i.second.location) < range) {
const uint32_t id = i.first;
auto name_i = data.user_names.find(id);
const TCHAR *name;
if (name_i == data.user_names.end()) {
/* no name found */
buffer.UnsafeFormat(_T("SkyLines %u"), (unsigned)id);
name = buffer;
} else
/* we know the name */
name = name_i->second.c_str();
list.append(new SkyLinesTrafficMapItem(id, i.second.time_of_day_ms,
i.second.altitude,
name));
}
}
#endif
}
void
ChartRenderer::DrawYLabel(const TCHAR *text, const TCHAR *unit)
{
assert(text != nullptr);
assert(unit != nullptr);
StaticString<64> buffer;
buffer.UnsafeFormat(_T("%s [%s]"), text, unit);
DrawYLabel(buffer);
}
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
WritableDataNode::SetAttribute(const TCHAR *name, RoughTime value)
{
if (!value.IsValid())
/* no-op */
return;
StaticString<8> buffer;
buffer.UnsafeFormat(_T("%02u:%02u"), value.GetHour(), value.GetMinute());
SetAttribute(name, buffer);
}
void
WifiListWidget::OnPaintItem(Canvas &canvas, const PixelRect rc,
unsigned idx)
{
const auto &info = networks[idx];
static char wifi_security[][20] = {
"WPA",
"WEP",
"Open",
};
row_renderer.DrawFirstRow(canvas, rc, info.ssid);
row_renderer.DrawSecondRow(canvas, rc, info.bssid);
const TCHAR *state = nullptr;
StaticString<40> state_buffer;
/* found the currently connected wifi network? */
if (StringIsEqual(info.bssid, status.bssid)) {
state = _("Connected");
/* look up ip address for eth0 */
const auto addr = IPv4Address::GetDeviceAddress("eth0");
if (addr.IsDefined()) { /* valid address? */
StaticString<40> addr_str;
if (addr.ToString(addr_str.buffer(), addr_str.capacity()) != nullptr) {
state_buffer.Format(_T("%s (%s)"), state, addr_str.c_str());
state = state_buffer;
}
}
}
else if (info.id >= 0)
state = info.signal_level >= 0
? _("Saved and visible")
: _("Saved, but not visible");
else if (info.signal_level >= 0)
state = _("Visible");
if (state != nullptr)
row_renderer.DrawRightFirstRow(canvas, rc, state);
if (info.signal_level >= 0) {
StaticString<20> text;
text.UnsafeFormat(_T("%s %u"), wifi_security[info.security], info.signal_level);
row_renderer.DrawRightSecondRow(canvas, rc, text);
}
}
static void
Draw(Canvas &canvas, PixelRect rc,
const SkyLinesTrafficMapItem &item,
const TwoTextRowsRenderer &row_renderer)
{
rc.right = row_renderer.DrawRightFirstRow(canvas, rc,
FormatUserAltitude(item.altitude));
row_renderer.DrawFirstRow(canvas, rc, item.name);
if (CommonInterface::Basic().time_available) {
StaticString<64> buffer;
buffer.UnsafeFormat(_("%u minutes ago"),
SinceInMinutes(CommonInterface::Basic().time,
item.time_of_day_ms));
row_renderer.DrawSecondRow(canvas, rc, buffer);
}
}
static void
SetPort(DataFieldEnum &df, const DeviceConfig &config)
{
switch (config.port_type) {
case DeviceConfig::PortType::DISABLED:
case DeviceConfig::PortType::AUTO:
case DeviceConfig::PortType::INTERNAL:
case DeviceConfig::PortType::DROIDSOAR_V2:
case DeviceConfig::PortType::NUNCHUCK:
case DeviceConfig::PortType::I2CPRESSURESENSOR:
case DeviceConfig::PortType::IOIOVOLTAGE:
case DeviceConfig::PortType::TCP_CLIENT:
case DeviceConfig::PortType::TCP_LISTENER:
case DeviceConfig::PortType::UDP_LISTENER:
case DeviceConfig::PortType::PTY:
case DeviceConfig::PortType::RFCOMM_SERVER:
break;
case DeviceConfig::PortType::SERIAL:
SetPort(df, config.port_type, config.path);
return;
case DeviceConfig::PortType::RFCOMM:
SetPort(df, config.port_type, config.bluetooth_mac);
return;
case DeviceConfig::PortType::IOIOUART:
StaticString<16> buffer;
buffer.UnsafeFormat(_T("%d"), config.ioio_uart_id);
df.Set(buffer);
return;
}
for (unsigned i = 0; port_types[i].label != NULL; i++) {
if (port_types[i].type == config.port_type) {
df.Set(port_types[i].label);
break;
}
}
}
static const RecordedFlightInfo *
ShowFlightList(const RecordedFlightList &flight_list)
{
// Prepare list of the flights for displaying
ComboList combo;
for (unsigned i = 0; i < flight_list.size(); ++i) {
const RecordedFlightInfo &flight = flight_list[i];
StaticString<64> buffer;
buffer.UnsafeFormat(_T("%04u/%02u/%02u %02u:%02u-%02u:%02u"),
flight.date.year, flight.date.month, flight.date.day,
flight.start_time.hour, flight.start_time.minute,
flight.end_time.hour, flight.end_time.minute);
combo.Append(i, buffer);
}
// Show list of the flights
int i = ComboPicker(_T("Choose a flight"),
combo, NULL, false);
return (i < 0) ? NULL : &flight_list[i];
}
static void
SetPort(DataFieldEnum &df, const DeviceConfig &config)
{
switch (config.port_type) {
case DeviceConfig::PortType::DISABLED:
case DeviceConfig::PortType::AUTO:
case DeviceConfig::PortType::INTERNAL:
case DeviceConfig::PortType::TCP_LISTENER:
break;
case DeviceConfig::PortType::SERIAL:
if (!df.Exists(config.path))
AddPort(df, config.port_type, config.path);
df.SetAsString(config.path);
return;
case DeviceConfig::PortType::RFCOMM:
if (!df.Exists(config.bluetooth_mac))
AddPort(df, DeviceConfig::PortType::RFCOMM, config.bluetooth_mac);
df.SetAsString(config.bluetooth_mac);
return;
case DeviceConfig::PortType::IOIOUART:
StaticString<16> buffer;
buffer.UnsafeFormat(_T("%d"), config.ioio_uart_id);
df.SetAsString(buffer);
return;
}
for (unsigned i = 0; port_types[i].label != NULL; i++) {
if (port_types[i].type == config.port_type) {
df.SetAsString(gettext(port_types[i].label));
break;
}
}
}
void
WaypointInfoWidget::Prepare(ContainerWindow &parent, const PixelRect &rc)
{
RowFormWidget::Prepare(parent, rc);
const MoreData &basic = CommonInterface::Basic();
const DerivedInfo &calculated = CommonInterface::Calculated();
const ComputerSettings &settings = CommonInterface::GetComputerSettings();
StaticString<64> buffer;
if (!waypoint.comment.empty())
AddMultiLine(waypoint.comment.c_str());
if (waypoint.radio_frequency.IsDefined() &&
waypoint.radio_frequency.Format(buffer.buffer(),
buffer.MAX_SIZE) != NULL) {
buffer += _T(" MHz");
AddReadOnly(_("Radio frequency"), NULL, buffer);
}
if (waypoint.runway.IsDirectionDefined())
buffer.UnsafeFormat(_T("%02u"), waypoint.runway.GetDirectionName());
else
buffer.clear();
if (waypoint.runway.IsLengthDefined()) {
if (!buffer.empty())
buffer += _T("; ");
TCHAR length_buffer[16];
FormatSmallUserDistance(length_buffer,
fixed(waypoint.runway.GetLength()));
buffer += length_buffer;
}
if (!buffer.empty())
AddReadOnly(_("Runway"), NULL, buffer);
if (FormatGeoPoint(waypoint.location,
buffer.buffer(), buffer.MAX_SIZE) != NULL)
AddReadOnly(_("Location"), NULL, buffer);
FormatUserAltitude(waypoint.elevation,
buffer.buffer(), buffer.MAX_SIZE);
AddReadOnly(_("Elevation"), NULL, buffer);
if (basic.time_available) {
const SunEphemeris::Result sun =
SunEphemeris::CalcSunTimes(waypoint.location, basic.date_time_utc,
fixed(GetUTCOffset()) / 3600);
const unsigned sunrisehours = (int)sun.time_of_sunrise;
const unsigned sunrisemins = (int)((sun.time_of_sunrise - fixed(sunrisehours)) * 60);
const unsigned sunset_hour = (int)sun.time_of_sunset;
const unsigned sunset_minute = (int)((sun.time_of_sunset - fixed(sunset_hour)) * 60);
buffer.UnsafeFormat(_T("%02u:%02u - %02u:%02u"), sunrisehours, sunrisemins, sunset_hour, sunset_minute);
AddReadOnly(_("Daylight time"), NULL, buffer);
}
if (basic.location_available) {
const GeoVector vector = basic.location.DistanceBearing(waypoint.location);
TCHAR distance_buffer[32];
FormatUserDistanceSmart(vector.distance, distance_buffer,
ARRAY_SIZE(distance_buffer));
FormatBearing(buffer.buffer(), buffer.MAX_SIZE,
vector.bearing, distance_buffer);
AddReadOnly(_("Bearing and Distance"), NULL, buffer);
}
if (basic.location_available && basic.NavAltitudeAvailable() &&
settings.polar.glide_polar_task.IsValid()) {
const GlideState glide_state(basic.location.DistanceBearing(waypoint.location),
waypoint.elevation + settings.task.safety_height_arrival,
basic.nav_altitude,
calculated.GetWindOrZero());
GlidePolar gp0 = settings.polar.glide_polar_task;
gp0.SetMC(fixed(0));
AddGlideResult(_("Alt. diff. MC 0"),
MacCready::Solve(settings.task.glide,
gp0, glide_state));
AddGlideResult(_("Alt. diff. MC safety"),
MacCready::Solve(settings.task.glide,
calculated.glide_polar_safety,
glide_state));
AddGlideResult(_("Alt. diff. MC current"),
MacCready::Solve(settings.task.glide,
settings.polar.glide_polar_task,
glide_state));
}
}
void
MapItemListRenderer::Draw(Canvas &canvas, const PixelRect rc,
const ArrivalAltitudeMapItem &item,
const DialogLook &dialog_look,
const FinalGlideBarLook &look)
{
const UPixelScalar line_height = rc.bottom - rc.top;
bool elevation_available =
!RasterBuffer::IsSpecial((short)item.elevation);
bool reach_relevant = item.reach.IsReachRelevant();
RoughAltitude arrival_altitude =
item.reach.terrain_valid == ReachResult::Validity::VALID
? item.reach.terrain
: item.reach.direct;
if (elevation_available)
arrival_altitude -= item.elevation;
bool reachable =
item.reach.terrain_valid != ReachResult::Validity::UNREACHABLE &&
arrival_altitude.IsPositive();
// Draw final glide arrow icon
RasterPoint pt = { (PixelScalar)(rc.left + line_height / 2),
(PixelScalar)(rc.top + line_height / 2) };
RasterPoint arrow[] = {
{ -7, -3 }, { 0, 4 }, { 7, -3 }
};
Angle arrow_angle = reachable ? Angle::HalfCircle() : Angle::Zero();
PolygonRotateShift(arrow, ARRAY_SIZE(arrow), pt.x, pt.y, arrow_angle, 100);
if (reachable) {
canvas.Select(look.brush_above);
canvas.Select(look.pen_above);
} else {
canvas.Select(look.brush_below);
canvas.Select(look.pen_below);
}
canvas.DrawPolygon(arrow, ARRAY_SIZE(arrow));
const Font &name_font = *dialog_look.list.font_bold;
const Font &small_font = *dialog_look.small_font;
PixelScalar left = rc.left + line_height + Layout::FastScale(2);
// Format title row
TCHAR altitude_buffer[32];
StaticString<256> buffer;
buffer.clear();
if (elevation_available) {
RoughAltitude relative_arrival_altitude =
item.reach.direct - item.elevation;
FormatRelativeUserAltitude(fixed((short)relative_arrival_altitude),
altitude_buffer, ARRAY_SIZE(altitude_buffer));
buffer.AppendFormat(_T("%s %s, "), altitude_buffer, _("AGL"));
}
FormatUserAltitude(fixed(item.reach.direct),
altitude_buffer, ARRAY_SIZE(altitude_buffer));
buffer.AppendFormat(_T("%s %s"), altitude_buffer, _("MSL"));
// Draw title row
canvas.Select(name_font);
canvas.DrawClippedText(left, rc.top + Layout::FastScale(2), rc, buffer);
// Format comment row
if (reach_relevant) {
buffer.Format(_T("%s: "), _("around terrain"));
if (elevation_available) {
RoughAltitude relative_arrival_altitude =
item.reach.terrain - item.elevation;
FormatRelativeUserAltitude(fixed((short)relative_arrival_altitude),
altitude_buffer, ARRAY_SIZE(altitude_buffer));
buffer.AppendFormat(_T("%s %s, "), altitude_buffer, _("AGL"));
}
FormatUserAltitude(fixed(item.reach.terrain),
altitude_buffer, ARRAY_SIZE(altitude_buffer));
buffer.AppendFormat(_T("%s %s, "), altitude_buffer, _("MSL"));
} else if (elevation_available &&
(int)item.reach.direct >= (int)item.elevation &&
item.reach.terrain_valid == ReachResult::Validity::UNREACHABLE) {
buffer.UnsafeFormat(_T("%s "), _("Unreachable due to terrain."));
} else {
buffer.clear();
}
buffer += _("Arrival altitude incl. safety height");
// Draw comment row
canvas.Select(small_font);
canvas.DrawClippedText(left,
rc.top + name_font.GetHeight() + Layout::FastScale(4),
rc, buffer);
}
void UnsafeFormatValue(const TCHAR *fmt, Args&&... args) {
value.UnsafeFormat(fmt, args...);
}
void UnsafeFormatComment(const TCHAR *fmt, Args&&... args) {
comment.UnsafeFormat(fmt, args...);
}
static void
Draw(Canvas &canvas, PixelRect rc,
const ArrivalAltitudeMapItem &item,
const TwoTextRowsRenderer &row_renderer,
const FinalGlideBarLook &look)
{
const unsigned line_height = rc.GetHeight();
bool reach_relevant = item.reach.IsReachRelevant();
int arrival_altitude =
item.reach.terrain_valid == ReachResult::Validity::VALID
? item.reach.terrain
: item.reach.direct;
if (item.HasElevation())
arrival_altitude -= item.elevation;
bool reachable =
item.reach.terrain_valid != ReachResult::Validity::UNREACHABLE &&
arrival_altitude >= 0;
// Draw final glide arrow icon
const PixelPoint pt(rc.left + line_height / 2, rc.top + line_height / 2);
BulkPixelPoint arrow[] = {
{ -7, -3 }, { 0, 4 }, { 7, -3 }
};
Angle arrow_angle = reachable ? Angle::HalfCircle() : Angle::Zero();
PolygonRotateShift(arrow, ARRAY_SIZE(arrow), pt, arrow_angle);
if (reachable) {
canvas.Select(look.brush_above);
canvas.Select(look.pen_above);
} else {
canvas.Select(look.brush_below);
canvas.Select(look.pen_below);
}
canvas.DrawPolygon(arrow, ARRAY_SIZE(arrow));
const unsigned text_padding = Layout::GetTextPadding();
rc.left += line_height + text_padding;
// Format title row
TCHAR altitude_buffer[32];
StaticString<256> buffer;
buffer.clear();
if (item.HasElevation()) {
int relative_arrival_altitude =
item.reach.direct - item.elevation;
FormatRelativeUserAltitude(relative_arrival_altitude,
altitude_buffer, ARRAY_SIZE(altitude_buffer));
buffer.AppendFormat(_T("%s %s, "), altitude_buffer, _("AGL"));
}
buffer.AppendFormat(_T("%s %s"),
FormatUserAltitude(item.reach.direct).c_str(),
_("MSL"));
// Draw title row
row_renderer.DrawFirstRow(canvas, rc, buffer);
// Format comment row
if (reach_relevant) {
buffer.Format(_T("%s: "), _("around terrain"));
if (item.HasElevation()) {
int relative_arrival_altitude =
item.reach.terrain - item.elevation;
FormatRelativeUserAltitude(relative_arrival_altitude,
altitude_buffer, ARRAY_SIZE(altitude_buffer));
buffer.AppendFormat(_T("%s %s, "), altitude_buffer, _("AGL"));
}
buffer.AppendFormat(_T("%s %s, "),
FormatUserAltitude(item.reach.terrain).c_str(),
_("MSL"));
} else if (item.HasElevation() &&
item.reach.direct >= item.elevation &&
item.reach.terrain_valid == ReachResult::Validity::UNREACHABLE) {
buffer.UnsafeFormat(_T("%s "), _("Unreachable due to terrain."));
} else {
buffer.clear();
}
buffer += _("Arrival altitude incl. safety height");
// Draw comment row
row_renderer.DrawSecondRow(canvas, rc, buffer);
}
void
TrafficListWidget::OnPaintItem(Canvas &canvas, PixelRect rc,
unsigned index)
{
assert(index < items.size());
Item &item = items[index];
assert(item.IsFlarm()
#ifdef HAVE_SKYLINES_TRACKING_HANDLER
|| item.IsSkyLines()
#endif
);
item.AutoLoad();
const FlarmNetRecord *record = item.record;
const TCHAR *callsign = item.callsign;
const DialogLook &look = UIGlobals::GetDialogLook();
const Font &name_font = *look.list.font_bold;
const Font &small_font = look.small_font;
const unsigned text_padding = Layout::GetTextPadding();
const unsigned frame_padding = text_padding / 2;
TCHAR tmp_id[10];
item.id.Format(tmp_id);
canvas.Select(name_font);
StaticString<256> tmp;
if (item.IsFlarm()) {
if (record != nullptr)
tmp.Format(_T("%s - %s - %s"),
callsign, record->registration.c_str(), tmp_id);
else if (callsign != nullptr)
tmp.Format(_T("%s - %s"), callsign, tmp_id);
else
tmp.Format(_T("%s"), tmp_id);
#ifdef HAVE_SKYLINES_TRACKING_HANDLER
} else if (item.IsSkyLines()) {
if (!item.name.empty())
tmp = item.name.c_str();
else
tmp.UnsafeFormat(_T("SkyLines %u"), item.skylines_id);
#endif
} else {
tmp = _T("?");
}
if (item.color != FlarmColor::NONE) {
const TrafficLook &traffic_look = UIGlobals::GetLook().traffic;
switch (item.color) {
case FlarmColor::NONE:
case FlarmColor::COUNT:
gcc_unreachable();
case FlarmColor::GREEN:
canvas.Select(traffic_look.team_pen_green);
break;
case FlarmColor::BLUE:
canvas.Select(traffic_look.team_pen_blue);
break;
case FlarmColor::YELLOW:
canvas.Select(traffic_look.team_pen_yellow);
break;
case FlarmColor::MAGENTA:
canvas.Select(traffic_look.team_pen_magenta);
break;
}
canvas.SelectHollowBrush();
const PixelSize size = canvas.CalcTextSize(tmp);
canvas.Rectangle(rc.left + row_renderer.GetX() - frame_padding,
rc.top + row_renderer.GetFirstY() - frame_padding,
rc.left + row_renderer.GetX() + size.cx + frame_padding,
rc.top + row_renderer.GetFirstY() + size.cy + frame_padding);
}
row_renderer.DrawFirstRow(canvas, rc, tmp);
canvas.Select(small_font);
/* draw bearing and distance on the right */
if (item.vector.IsValid()) {
row_renderer.DrawRightFirstRow(canvas, rc,
FormatUserDistanceSmart(item.vector.distance).c_str());
// Draw leg bearing
rc.right = row_renderer.DrawRightSecondRow(canvas, rc,
FormatBearing(item.vector.bearing).c_str());
}
if (record != nullptr) {
tmp.clear();
if (!record->pilot.empty())
tmp = record->pilot.c_str();
if (!record->plane_type.empty()) {
if (!tmp.empty())
tmp.append(_T(" - "));
tmp.append(record->plane_type);
}
if (!record->airfield.empty()) {
if (!tmp.empty())
tmp.append(_T(" - "));
tmp.append(record->airfield);
}
if (!tmp.empty())
row_renderer.DrawSecondRow(canvas, rc, tmp);
#ifdef HAVE_SKYLINES_TRACKING_HANDLER
} else if (item.IsSkyLines()) {
if (CommonInterface::Basic().time_available) {
tmp.UnsafeFormat(_("%u minutes ago"),
SinceInMinutes(CommonInterface::Basic().time,
item.time_of_day_ms));
} else
tmp.clear();
if (!item.near_name.empty())
tmp.AppendFormat(_T(" near %s (%s)"),
item.near_name.c_str(),
FormatUserDistanceSmart(item.near_distance).c_str());
if (!tmp.empty())
tmp.append(_T("; "));
tmp.append(FormatUserAltitude(item.altitude));
if (!tmp.empty())
row_renderer.DrawSecondRow(canvas, rc, tmp);
#endif
}
}
void
TrafficListWidget::OnPaintItem(Canvas &canvas, const PixelRect rc,
unsigned index)
{
assert(index < items.size());
Item &item = items[index];
assert(item.IsFlarm()
#ifdef HAVE_SKYLINES_TRACKING_HANDLER
|| item.IsSkyLines()
#endif
);
item.AutoLoad();
const FlarmNetRecord *record = item.record;
const TCHAR *callsign = item.callsign;
const DialogLook &look = UIGlobals::GetDialogLook();
const Font &name_font = *look.list.font_bold;
const Font &small_font = *look.small_font;
const unsigned text_padding = Layout::GetTextPadding();
const unsigned frame_padding = text_padding / 2;
TCHAR tmp_id[10];
item.id.Format(tmp_id);
canvas.Select(name_font);
StaticString<256> tmp;
if (item.IsFlarm()) {
if (record != NULL)
tmp.Format(_T("%s - %s - %s"),
callsign, record->registration.c_str(), tmp_id);
else if (callsign != NULL)
tmp.Format(_T("%s - %s"), callsign, tmp_id);
else
tmp.Format(_T("%s"), tmp_id);
#ifdef HAVE_SKYLINES_TRACKING_HANDLER
} else if (item.IsSkyLines()) {
tmp.UnsafeFormat(_T("SkyLines %u"), item.skylines_id);
#endif
} else {
tmp = _T("?");
}
const int name_x = rc.left + text_padding, name_y = rc.top + text_padding;
if (item.color != FlarmColor::NONE) {
const TrafficLook &traffic_look = UIGlobals::GetLook().traffic;
switch (item.color) {
case FlarmColor::NONE:
case FlarmColor::COUNT:
gcc_unreachable();
case FlarmColor::GREEN:
canvas.Select(traffic_look.team_pen_green);
break;
case FlarmColor::BLUE:
canvas.Select(traffic_look.team_pen_blue);
break;
case FlarmColor::YELLOW:
canvas.Select(traffic_look.team_pen_yellow);
break;
case FlarmColor::MAGENTA:
canvas.Select(traffic_look.team_pen_magenta);
break;
}
canvas.SelectHollowBrush();
const PixelSize size = canvas.CalcTextSize(tmp);
canvas.Rectangle(name_x - frame_padding,
name_y - frame_padding,
name_x + size.cx + frame_padding,
name_y + size.cy + frame_padding);
}
canvas.DrawText(name_x, name_y, tmp);
if (record != NULL) {
tmp.clear();
if (!record->pilot.empty())
tmp = record->pilot.c_str();
if (!record->plane_type.empty()) {
if (!tmp.empty())
tmp.append(_T(" - "));
tmp.append(record->plane_type);
}
if (!record->airfield.empty()) {
if (!tmp.empty())
tmp.append(_T(" - "));
tmp.append(record->airfield);
}
if (!tmp.empty()) {
canvas.Select(small_font);
canvas.DrawText(rc.left + text_padding,
rc.bottom - small_font.GetHeight() - text_padding,
tmp);
}
}
/* draw bearing and distance on the right */
if (item.vector.IsValid()) {
FormatUserDistanceSmart(item.vector.distance, tmp.buffer(), true);
unsigned width = canvas.CalcTextWidth(tmp.c_str());
canvas.DrawText(rc.right - text_padding - width,
name_y +
(name_font.GetHeight() - small_font.GetHeight()) / 2,
tmp.c_str());
// Draw leg bearing
FormatBearing(tmp.buffer(), tmp.MAX_SIZE, item.vector.bearing);
width = canvas.CalcTextWidth(tmp.c_str());
canvas.DrawText(rc.right - text_padding - width,
rc.bottom - small_font.GetHeight() - text_padding,
tmp.c_str());
}
}
void
WaypointInfoWidget::Prepare(ContainerWindow &parent, const PixelRect &rc)
{
RowFormWidget::Prepare(parent, rc);
const MoreData &basic = CommonInterface::Basic();
const DerivedInfo &calculated = CommonInterface::Calculated();
const ComputerSettings &settings = CommonInterface::GetComputerSettings();
StaticString<64> buffer;
if (!waypoint.comment.empty())
AddMultiLine(waypoint.comment.c_str());
if (waypoint.radio_frequency.IsDefined() &&
waypoint.radio_frequency.Format(buffer.buffer(),
buffer.MAX_SIZE) != nullptr) {
buffer += _T(" MHz");
AddReadOnly(_("Radio frequency"), nullptr, buffer);
}
if (waypoint.runway.IsDirectionDefined())
buffer.UnsafeFormat(_T("%02u"), waypoint.runway.GetDirectionName());
else
buffer.clear();
if (waypoint.runway.IsLengthDefined()) {
if (!buffer.empty())
buffer += _T("; ");
TCHAR length_buffer[16];
FormatSmallUserDistance(length_buffer,
fixed(waypoint.runway.GetLength()));
buffer += length_buffer;
}
if (!buffer.empty())
AddReadOnly(_("Runway"), nullptr, buffer);
if (FormatGeoPoint(waypoint.location,
buffer.buffer(), buffer.MAX_SIZE) != nullptr)
AddReadOnly(_("Location"), nullptr, buffer);
FormatUserAltitude(waypoint.elevation,
buffer.buffer(), buffer.MAX_SIZE);
AddReadOnly(_("Elevation"), nullptr, buffer);
if (basic.time_available && basic.date_time_utc.IsDatePlausible()) {
const SunEphemeris::Result sun =
SunEphemeris::CalcSunTimes(waypoint.location, basic.date_time_utc,
settings.utc_offset);
const BrokenTime sunrise = BreakHourOfDay(sun.time_of_sunrise);
const BrokenTime sunset = BreakHourOfDay(sun.time_of_sunset);
buffer.UnsafeFormat(_T("%02u:%02u - %02u:%02u"),
sunrise.hour, sunrise.minute,
sunset.hour, sunset.minute);
AddReadOnly(_("Daylight time"), nullptr, buffer);
}
if (basic.location_available) {
const GeoVector vector = basic.location.DistanceBearing(waypoint.location);
TCHAR distance_buffer[32];
FormatUserDistanceSmart(vector.distance, distance_buffer,
ARRAY_SIZE(distance_buffer));
FormatBearing(buffer.buffer(), buffer.MAX_SIZE,
vector.bearing, distance_buffer);
AddReadOnly(_("Bearing and Distance"), nullptr, buffer);
}
if (basic.location_available && basic.NavAltitudeAvailable() &&
settings.polar.glide_polar_task.IsValid()) {
const GlideState glide_state(basic.location.DistanceBearing(waypoint.location),
waypoint.elevation + settings.task.safety_height_arrival,
basic.nav_altitude,
calculated.GetWindOrZero());
GlidePolar gp0 = settings.polar.glide_polar_task;
gp0.SetMC(fixed(0));
AddGlideResult(_("Alt. diff. MC 0"),
MacCready::Solve(settings.task.glide,
gp0, glide_state));
AddGlideResult(_("Alt. diff. MC safety"),
MacCready::Solve(settings.task.glide,
calculated.glide_polar_safety,
glide_state));
AddGlideResult(_("Alt. diff. MC current"),
MacCready::Solve(settings.task.glide,
settings.polar.glide_polar_task,
glide_state));
}
if (basic.location_available && basic.NavAltitudeAvailable()) {
const TaskBehaviour &task_behaviour =
CommonInterface::GetComputerSettings().task;
const fixed safety_height = task_behaviour.safety_height_arrival;
const fixed target_altitude = waypoint.elevation + safety_height;
const fixed delta_h = basic.nav_altitude - target_altitude;
if (positive(delta_h)) {
const fixed distance = basic.location.Distance(waypoint.location);
const fixed gr = distance / delta_h;
if (GradientValid(gr)) {
buffer.UnsafeFormat(_T("%.1f"), (double)gr);
AddReadOnly(_("Required glide ratio"), nullptr, buffer);
}
}
}
}
