void
UpdateInfoBoxTeamBearing(InfoBoxData &data)
{
const TeamCodeSettings &settings =
CommonInterface::GetComputerSettings().team_code;
const TrafficList &flarm = CommonInterface::Basic().flarm.traffic;
const TeamInfo &teamcode_info = CommonInterface::Calculated();
if (teamcode_info.teammate_available) {
// Set Value
data.SetValue(teamcode_info.teammate_vector.bearing);
}
else
data.SetValueInvalid();
// Set Comment
if (!settings.team_flarm_id.IsDefined())
data.SetCommentInvalid();
else if (!settings.team_flarm_callsign.empty())
data.SetComment(settings.team_flarm_callsign.c_str());
else
data.SetComment(_T("???"));
if (flarm.FindTraffic(settings.team_flarm_id) != NULL)
data.SetCommentColor(2);
else
data.SetCommentColor(1);
}
void
InfoBoxContentTeamCode::Update(InfoBoxData &data)
{
const TeamCodeSettings &settings =
CommonInterface::GetComputerSettings().team_code;
const TeamInfo &teamcode_info = CommonInterface::Calculated();
if (!settings.team_code_reference_waypoint) {
data.SetInvalid();
return;
}
// Set Value
data.SetValue(CommonInterface::Calculated().own_teammate_code.GetCode());
// Set Comment
if (teamcode_info.flarm_teammate_code.IsDefined()) {
data.SetComment(teamcode_info.flarm_teammate_code.GetCode());
data.SetCommentColor(teamcode_info.flarm_teammate_code_current ? 2 : 1);
} else if (settings.team_code.IsDefined()) {
data.SetComment(settings.team_code.GetCode());
data.SetCommentColor(0);
}
else
data.SetCommentInvalid();
}
void
InfoBoxContentTaskTimeUnderMaxHeight::Update(InfoBoxData &data)
{
const CommonStats &common_stats = XCSoarInterface::Calculated().common_stats;
const TaskStats &task_stats = XCSoarInterface::Calculated().task_stats;
const fixed maxheight = fixed(protected_task_manager->
GetOrderedTaskBehaviour().start_max_height);
if (!task_stats.task_valid || !positive(maxheight)
|| !protected_task_manager
|| !positive(common_stats.TimeUnderStartMaxHeight)) {
data.SetInvalid();
return;
}
const int dd = (int)(XCSoarInterface::Basic().time -
common_stats.TimeUnderStartMaxHeight);
TCHAR value[32];
TCHAR comment[32];
FormatTimeTwoLines(value, comment, dd);
data.SetValue(value);
data.SetComment(_("Time Below"));
}
void
UpdateInfoBoxTaskTimeUnderMaxHeight(InfoBoxData &data)
{
const auto &calculated = CommonInterface::Calculated();
const TaskStats &task_stats = calculated.ordered_task_stats;
const CommonStats &common_stats = calculated.common_stats;
const fixed maxheight = fixed(protected_task_manager->
GetOrderedTaskSettings().start_constraints.max_height);
if (!task_stats.task_valid || !positive(maxheight)
|| !protected_task_manager
|| !positive(common_stats.TimeUnderStartMaxHeight)) {
data.SetInvalid();
return;
}
const int dd = (int)(CommonInterface::Basic().time -
common_stats.TimeUnderStartMaxHeight);
TCHAR value[32];
TCHAR comment[32];
FormatTimeTwoLines(value, comment, dd);
data.SetValue(value);
data.SetComment(_("Time Below"));
}
void
InfoBoxContentFinalETEVMG::Update(InfoBoxData &data)
{
const NMEAInfo &basic = CommonInterface::Basic();
const TaskStats &task_stats = CommonInterface::Calculated().task_stats;
if (!basic.ground_speed_available || task_stats.task_valid ||
task_stats.total.remaining.IsDefined()) {
data.SetInvalid();
return;
}
const fixed d = task_stats.total.remaining.get_distance();
const fixed &v = basic.ground_speed;
if (!task_stats.task_valid ||
!positive(d) ||
!positive(v)) {
data.SetInvalid();
return;
}
TCHAR HHMMSSsmart[32];
TCHAR SSsmart[32];
const int dd = (int)(d/v);
Units::TimeToTextSmart(HHMMSSsmart, SSsmart, dd);
data.SetValue(HHMMSSsmart);
data.SetComment(SSsmart);
}
void
UpdateInfoBoxFinalETEVMG(InfoBoxData &data)
{
const NMEAInfo &basic = CommonInterface::Basic();
const TaskStats &task_stats = CommonInterface::Calculated().task_stats;
if (!basic.ground_speed_available || !task_stats.task_valid ||
!task_stats.total.remaining.IsDefined()) {
data.SetInvalid();
return;
}
const fixed d = task_stats.total.remaining.GetDistance();
const fixed v = basic.ground_speed;
if (!task_stats.task_valid ||
!positive(d) ||
!positive(v)) {
data.SetInvalid();
return;
}
TCHAR value[32];
TCHAR comment[32];
const int dd = (int)(d/v);
FormatTimeTwoLines(value, comment, dd);
data.SetValue(value);
data.SetComment(comment);
}
void
InfoBoxContentThermalRatio::Update(InfoBoxData &data)
{
// Set Value
data.SetValue(_T("%2.0f%%"),
XCSoarInterface::Calculated().circling_percentage);
}
void
InfoBoxContentTemperatureForecast::Update(InfoBoxData &data)
{
auto temperature = CommonInterface::GetComputerSettings().forecast_temperature;
data.SetValue(_T("%2.1f"), temperature.ToUser());
data.SetValueUnit(Units::current.temperature_unit);
}
void
InfoBoxContentLDAvg::Update(InfoBoxData &data)
{
if (XCSoarInterface::Calculated().average_ld == 0) {
data.SetInvalid();
return;
}
// Set Value
if (XCSoarInterface::Calculated().average_ld < 0)
data.SetValue(_T("^^^"));
else if (XCSoarInterface::Calculated().average_ld >= 999)
data.SetValue(_T("+++"));
else
SetValueFromFixed(data, _T("%2.0f"),
fixed(XCSoarInterface::Calculated().average_ld));
}
static void
SetVSpeed(InfoBoxData &data, fixed value)
{
TCHAR buffer[32];
FormatUserVerticalSpeed(value, buffer, false);
data.SetValue(buffer[0] == _T('+') ? buffer + 1 : buffer);
data.SetValueUnit(Units::current.vertical_speed_unit);
}
void
UpdateInfoBoxGRAvg(InfoBoxData &data)
{
const auto average_gr = CommonInterface::Calculated().average_gr;
if (average_gr == 0) {
data.SetInvalid();
return;
}
// Set Value
if (average_gr < 0)
data.SetValue(_T("^^^"));
else if (!::GradientValid(average_gr))
data.SetValue(_T("+++"));
else
data.SetValueFromGlideRatio(average_gr);
}
void
InfoBoxContentTrack::Update(InfoBoxData &data)
{
if (!XCSoarInterface::Basic().track_available) {
data.SetInvalid();
return;
}
data.SetValue(XCSoarInterface::Basic().track);
}
void
UpdateInfoBoxThermalRatio(InfoBoxData &data)
{
// Set Value
if (negative(CommonInterface::Calculated().circling_percentage))
data.SetInvalid();
else
data.SetValue(_T("%2.0f%%"),
CommonInterface::Calculated().circling_percentage);
}
void
UpdateInfoBoxGLoad(InfoBoxData &data)
{
if (!CommonInterface::Basic().acceleration.available) {
data.SetInvalid();
return;
}
// Set Value
data.SetValue(_T("%2.2f"), CommonInterface::Basic().acceleration.g_load);
}
void
InfoBoxContentGLoad::Update(InfoBoxData &data)
{
if (!XCSoarInterface::Basic().acceleration.available) {
data.SetInvalid();
return;
}
// Set Value
data.SetValue(_T("%2.2f"), XCSoarInterface::Basic().acceleration.g_load);
}
void
UpdateInfoBoxTaskSpeedHour(InfoBoxData &data)
{
const WindowStats &window =
CommonInterface::Calculated().task_stats.last_hour;
if (negative(window.duration)) {
data.SetInvalid();
return;
}
data.SetValue(_T("%2.0f"), Units::ToUserTaskSpeed(window.speed));
data.SetValueUnit(Units::current.task_speed_unit);
}
void
InfoBoxContentBearing::Update(InfoBoxData &data)
{
const TaskStats &task_stats = CommonInterface::Calculated().task_stats;
const GeoVector &vector_remaining = task_stats.current_leg.vector_remaining;
if (!task_stats.task_valid || !vector_remaining.IsValid() ||
vector_remaining.distance <= fixed(10)) {
data.SetInvalid();
return;
}
// Set Value
data.SetValue(vector_remaining.bearing);
}
void
UpdateInfoBoxTemperature(InfoBoxData &data)
{
const NMEAInfo &basic = CommonInterface::Basic();
if (!basic.temperature_available) {
data.SetInvalid();
return;
}
// Set Value
data.SetValue(_T("%2.1f"), basic.temperature.ToUser());
data.SetValueUnit(Units::current.temperature_unit);
}
void
UpdateInfoBoxBearing(InfoBoxData &data)
{
const TaskStats &task_stats = CommonInterface::Calculated().task_stats;
const GeoVector &vector_remaining = task_stats.current_leg.vector_remaining;
if (!task_stats.task_valid || !vector_remaining.IsValid() ||
vector_remaining.distance <= 10) {
data.SetInvalid();
return;
}
// Set Value
data.SetValue(vector_remaining.bearing);
data.SetValueColor(task_stats.inside_oz ? 3 : 0);
}
void
InfoBoxContentTemperature::Update(InfoBoxData &data)
{
const NMEAInfo &basic = XCSoarInterface::Basic();
if (!basic.temperature_available) {
data.SetInvalid();
return;
}
// Set Value
data.SetValue(_T("%2.1f"),
Units::ToUserTemperature(basic.temperature));
data.SetValueUnit(Units::current.temperature_unit);
}
void
UpdateInfoBoxWindBearing(InfoBoxData &data)
{
const DerivedInfo &info = CommonInterface::Calculated();
if (!info.wind_available) {
data.SetInvalid();
return;
}
data.SetValue(info.wind.bearing);
TCHAR buffer[16];
FormatUserWindSpeed(info.wind.norm, buffer, true, false);
data.SetComment(buffer);
}
void
UpdateInfoBoxTaskSpeedInstant(InfoBoxData &data)
{
const TaskStats &task_stats = CommonInterface::Calculated().task_stats;
if (!task_stats.task_valid || !task_stats.IsPirkerSpeedAvailable()) {
data.SetInvalid();
return;
}
// Set Value
data.SetValue(_T("%2.0f"),
Units::ToUserTaskSpeed(task_stats.get_pirker_speed()));
// Set Unit
data.SetValueUnit(Units::current.task_speed_unit);
}
void
UpdateInfoBoxTaskSpeed(InfoBoxData &data)
{
const TaskStats &task_stats = CommonInterface::Calculated().task_stats;
if (!task_stats.task_valid || !task_stats.total.travelled.IsDefined()) {
data.SetInvalid();
return;
}
// Set Value
data.SetValue(_T("%2.0f"),
Units::ToUserTaskSpeed(task_stats.total.travelled.GetSpeed()));
// Set Unit
data.SetValueUnit(Units::current.task_speed_unit);
}
void
UpdateInfoBoxHeadWind(InfoBoxData &data)
{
const DerivedInfo &info = CommonInterface::Calculated();
if (!info.head_wind_available) {
data.SetInvalid();
return;
}
// Set Value
data.SetValue(_T("%2.0f"),
Units::ToUserWindSpeed(info.head_wind));
// Set Unit
data.SetValueUnit(Units::current.wind_speed_unit);
}
void
InfoBoxContentAlternateGR::Update(InfoBoxData &data)
{
if (protected_task_manager == NULL) {
data.SetInvalid();
return;
}
ProtectedTaskManager::Lease lease(*protected_task_manager);
const AlternateList &alternates = lease->GetAlternates();
const AlternatePoint *alternate;
if (!alternates.empty()) {
if (index >= alternates.size())
index = alternates.size() - 1;
alternate = &alternates[index];
} else {
alternate = NULL;
}
data.FormatTitle(_T("Altn %d GR"), index + 1);
if (alternate == NULL) {
data.SetInvalid();
return;
}
data.SetComment(alternate->waypoint.name.c_str());
fixed gradient =
::AngleToGradient(alternate->solution.DestinationAngleGround());
if (negative(gradient)) {
data.SetValueColor(0);
data.SetValue(_T("+++"));
return;
}
if (::GradientValid(gradient)) {
data.SetValueFromGlideRatio(gradient);
} else {
data.SetInvalid();
}
// Set Color (blue/black)
data.SetValueColor(alternate->solution.IsFinalGlide() ? 2 : 0);
}
void
InfoBoxContentTaskSpeedAchieved::Update(InfoBoxData &data)
{
const TaskStats &task_stats = XCSoarInterface::Calculated().task_stats;
if (!task_stats.task_valid ||
!task_stats.total.remaining_effective.IsDefined()) {
data.SetInvalid();
return;
}
// Set Value
data.SetValue(_T("%2.0f"),
Units::ToUserTaskSpeed(task_stats.total.remaining_effective.get_speed()));
// Set Unit
data.SetValueUnit(Units::current.task_speed_unit);
}
void
UpdateInfoBoxThermalLastTime(InfoBoxData &data)
{
const OneClimbInfo &thermal = CommonInterface::Calculated().last_thermal;
if (!thermal.IsDefined()) {
data.SetInvalid();
return;
}
// Set Value
TCHAR value[32], comment[32];
FormatTimeTwoLines(value, comment, (int)thermal.duration);
data.SetValue(value);
data.SetComment(comment);
}
void
UpdateInfoBoxTimeFlight(InfoBoxData &data)
{
const FlyingState &flight = CommonInterface::Calculated().flight;
if (!positive(flight.flight_time)) {
data.SetInvalid();
return;
}
// Set Value
TCHAR value[32], comment[32];
FormatTimeTwoLines(value, comment, (int)flight.flight_time);
data.SetValue(value);
data.SetComment(comment);
}
void
UpdateInfoBoxHeadWindSimplified(InfoBoxData &data)
{
const NMEAInfo &basic = CommonInterface::Basic();
if (!basic.ground_speed_available || !basic.airspeed_available) {
data.SetInvalid();
return;
}
fixed value = basic.true_airspeed - basic.ground_speed;
// Set Value
data.SetValue(_T("%2.0f"), Units::ToUserWindSpeed(value));
// Set Unit
data.SetValueUnit(Units::current.wind_speed_unit);
}
void
UpdateInfoBoxATCRadial(InfoBoxData &data)
{
const NMEAInfo &basic = CommonInterface::Basic();
const GeoPoint &reference =
CommonInterface::GetComputerSettings().poi.atc_reference;
if (!basic.location_available || !reference.IsValid()) {
data.SetInvalid();
return;
}
const GeoVector vector(reference, basic.location);
data.SetValue(vector.bearing);
FormatDistance(data.comment.buffer(), vector.distance,
Unit::NAUTICAL_MILES, true, 1);
}