void
TaskManager::UpdateCommonStatsWaypoints(const AircraftState &state)
{
common_stats.vector_home = task_abort.GetHomeVector(state);
common_stats.landable_reachable = task_abort.HasReachableLandable();
const TaskWaypoint *tp = GetActiveTaskPoint();
if (tp != NULL) {
// must make an UnorderedTaskPoint here so we pick up arrival height requirements
const UnorderedTaskPoint fp(tp->GetWaypoint(), task_behaviour);
// @todo: consider change to task_abort.get_safety_polar();
GlidePolar glide_polar = GetGlidePolar();
common_stats.next_solution =
TaskSolution::GlideSolutionRemaining(fp, state, task_behaviour.glide,
glide_polar);
if (positive(glide_polar.GetMC())) {
glide_polar.SetMC(fixed_zero);
common_stats.next_solution_mc0 =
TaskSolution::GlideSolutionRemaining(fp, state, task_behaviour.glide,
glide_polar);
} else
common_stats.next_solution_mc0 = common_stats.next_solution;
} else {
common_stats.next_solution.Reset();
common_stats.next_solution_mc0.Reset();
}
}
void
GaugeVario::OnPaintBuffer(Canvas &canvas)
{
const PixelRect rc = GetClientRect();
const unsigned width = rc.right - rc.left;
const unsigned height = rc.bottom - rc.top;
if (!IsPersistent() || !layout_initialised) {
unsigned value_height = 4 + look.value_font->GetCapitalHeight()
+ look.text_font->GetCapitalHeight();
middle_position.y = offset.y - value_height / 2;
middle_position.x = rc.right;
top_position.y = middle_position.y - value_height;
top_position.x = rc.right;
bottom_position.y = middle_position.y + value_height;
bottom_position.x = rc.right;
canvas.Stretch(rc.left, rc.top, width, height,
look.background_bitmap,
look.background_x, 0, 58, 120);
layout_initialised = true;
}
if (Settings().show_average) {
// JMW averager now displays netto average if not circling
if (!Calculated().circling) {
RenderValue(canvas, top_position.x, top_position.y, &value_top, &label_top,
Units::ToUserVSpeed(Calculated().netto_average),
_T("NetAvg"));
} else {
RenderValue(canvas, top_position.x, top_position.y,
&value_top, &label_top,
Units::ToUserVSpeed(Calculated().average), _T("Avg"));
}
}
if (Settings().show_mc) {
fixed mc = Units::ToUserVSpeed(GetGlidePolar().GetMC());
RenderValue(canvas, bottom_position.x, bottom_position.y,
&value_bottom, &label_bottom,
mc,
GetComputerSettings().task.auto_mc ? _T("Auto MC") : _T("MC"));
}
if (Settings().show_speed_to_fly)
RenderSpeedToFly(canvas, rc.right - 11, (rc.top + rc.bottom) / 2);
else
RenderClimb(canvas);
if (Settings().show_ballast)
RenderBallast(canvas);
if (Settings().show_bugs)
RenderBugs(canvas);
dirty = false;
int ival, sval, ival_av = 0;
static int vval_last = 0;
static int sval_last = 0;
static int ival_last = 0;
fixed vval = Basic().brutto_vario;
ival = ValueToNeedlePos(fixed(vval));
sval = ValueToNeedlePos(Calculated().sink_rate);
if (Settings().show_average_needle) {
if (!Calculated().circling)
ival_av = ValueToNeedlePos(Calculated().netto_average);
else
ival_av = ValueToNeedlePos(Calculated().average);
}
// clear items first
if (Settings().show_average_needle) {
if (!IsPersistent() || ival_av != ival_last)
RenderNeedle(canvas, ival_last, true, true);
ival_last = ival_av;
}
if (!IsPersistent() || (sval != sval_last) || (ival != vval_last))
RenderVarioLine(canvas, vval_last, sval_last, true);
sval_last = sval;
if (!IsPersistent() || ival != vval_last)
RenderNeedle(canvas, vval_last, false, true);
vval_last = ival;
// now draw items
RenderVarioLine(canvas, ival, sval, false);
if (Settings().show_average_needle)
RenderNeedle(canvas, ival_av, true, false);
RenderNeedle(canvas, ival, false, false);
if (Settings().show_gross) {
fixed vvaldisplay = Clamp(Units::ToUserVSpeed(vval),
fixed(-99.9), fixed(99.9));
RenderValue(canvas, middle_position.x, middle_position.y,
&value_middle, &label_middle,
vvaldisplay,
_T("Gross"));
}
RenderZero(canvas);
}
void
GaugeVario::RenderBallast(Canvas &canvas)
{
static int last_ballast = -1;
static PixelRect label_rect = {-1,-1,-1,-1};
static PixelRect value_rect = {-1,-1,-1,-1};
static RasterPoint label_pos = {-1,-1};
static RasterPoint value_pos = {-1,-1};
if (!ballast_initialised) { // ontime init, origin and background rect
const PixelRect rc = GetClientRect();
PixelSize tSize;
// position of ballast label
label_pos.x = 1;
label_pos.y = rc.top + 2
+ look.text_font->GetCapitalHeight() * 2
- look.text_font->GetAscentHeight();
// position of ballast value
value_pos.x = 1;
value_pos.y = rc.top + 1
+ look.text_font->GetCapitalHeight()
- look.text_font->GetAscentHeight();
// set upper left corner
label_rect.left = label_pos.x;
label_rect.top = label_pos.y
+ look.text_font->GetAscentHeight()
- look.text_font->GetCapitalHeight();
// set upper left corner
value_rect.left = value_pos.x;
value_rect.top = value_pos.y
+ look.text_font->GetAscentHeight()
- look.text_font->GetCapitalHeight();
// get max label size
canvas.Select(*look.text_font);
tSize = canvas.CalcTextSize(TEXT_BALLAST);
// update back rect with max label size
label_rect.right = label_rect.left + tSize.cx;
label_rect.bottom = label_rect.top +
look.text_font->GetCapitalHeight();
// get max value size
tSize = canvas.CalcTextSize(_T("100%"));
value_rect.right = value_rect.left + tSize.cx;
// update back rect with max label size
value_rect.bottom = value_rect.top +
look.text_font->GetCapitalHeight();
ballast_initialised = true;
}
int ballast = iround(GetGlidePolar().GetBallast() * 100);
if (!IsPersistent() || ballast != last_ballast) {
// ballast hase been changed
canvas.Select(*look.text_font);
if (IsPersistent())
canvas.SetBackgroundColor(look.background_color);
else
canvas.SetBackgroundTransparent();
if (IsPersistent() || last_ballast < 1 || ballast < 1) {
// new ballast is 0, hide label
if (ballast > 0) {
canvas.SetTextColor(look.dimmed_text_color);
// ols ballast was 0, show label
if (IsPersistent())
canvas.DrawOpaqueText(label_pos.x, label_pos.y, label_rect, TEXT_BALLAST);
else
canvas.DrawText(label_pos.x, label_pos.y, TEXT_BALLAST);
} else if (IsPersistent())
canvas.DrawFilledRectangle(label_rect, look.background_color);
}
// new ballast 0, hide value
if (ballast > 0) {
TCHAR buffer[18];
_stprintf(buffer, _T("%u%%"), ballast);
canvas.SetTextColor(look.text_color);
if (IsPersistent())
canvas.DrawOpaqueText(value_pos.x, value_pos.y, value_rect, buffer);
else
canvas.DrawText(value_pos.x, value_pos.y, buffer);
} else if (IsPersistent())
canvas.DrawFilledRectangle(value_rect, look.background_color);
if (IsPersistent())
last_ballast = ballast;
}
}