gcc_pure
static PixelRect
GetBottomWidgetRect(const PixelRect &rc, const Widget *bottom_widget)
{
if (bottom_widget == nullptr) {
/* no bottom widget: return empty rectangle, map uses the whole
main area */
PixelRect result = rc;
result.top = result.bottom;
return result;
}
const unsigned requested_height = bottom_widget->GetMinimumSize().cy;
unsigned height;
if (requested_height > 0) {
const unsigned max_height = rc.GetHeight() / 2;
height = std::min(max_height, requested_height);
} else {
const unsigned recommended_height = rc.GetHeight() / 3;
height = recommended_height;
}
PixelRect result = rc;
result.top = result.bottom - height;
return result;
}
inline void
GLTexture::DrawFlippedOES(PixelRect dest, PixelRect src) const
{
const GLint rect[4] = { src.left, src.top,
(GLint)src.GetWidth(), (GLint)src.GetHeight() };
glTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_CROP_RECT_OES, rect);
/* glDrawTexiOES() circumvents the projection settings, thus we must
roll our own translation */
glDrawTexiOES(OpenGL::translate.x + dest.left,
OpenGL::viewport_size.y - OpenGL::translate.y - dest.bottom,
0, dest.GetWidth(), dest.GetHeight());
}
static void
Draw(Canvas &canvas, PixelRect rc,
const ThermalMapItem &item,
RoughTimeDelta utc_offset,
const TwoTextRowsRenderer &row_renderer,
const MapLook &look)
{
const unsigned line_height = rc.GetHeight();
const unsigned text_padding = Layout::GetTextPadding();
const ThermalSource &thermal = item.thermal;
const PixelPoint pt(rc.left + line_height / 2,
rc.top + line_height / 2);
look.thermal_source_icon.Draw(canvas, pt);
rc.left += line_height + text_padding;
row_renderer.DrawFirstRow(canvas, rc, _("Thermal"));
StaticString<256> buffer;
TCHAR lift_buffer[32];
FormatUserVerticalSpeed(thermal.lift_rate, lift_buffer, 32);
int timespan = BrokenDateTime::NowUTC().GetSecondOfDay() - (int)thermal.time;
if (timespan < 0)
timespan += 24 * 60 * 60;
buffer.Format(_T("%s: %s - left %s ago (%s)"),
_("Avg. lift"), lift_buffer,
FormatTimespanSmart(timespan).c_str(),
FormatLocalTimeHHMM((int)thermal.time, utc_offset).c_str());
row_renderer.DrawSecondRow(canvas, rc, buffer);
}
PixelRect
ButtonPanel::HorizontalRange(PixelRect rc, unsigned start, unsigned end)
{
const unsigned n = end - start;
assert(n > 0);
const unsigned total_width = rc.GetWidth();
const unsigned total_height = rc.GetHeight();
const unsigned max_row_height = Layout::GetMaximumControlHeight();
const unsigned row_height = max_row_height < total_height / 2
? max_row_height
: std::max(Layout::GetMinimumControlHeight(),
total_height / 2);
const unsigned width = total_width / n;
assert(width > 0);
PixelRect button_rc(rc.left, rc.bottom - row_height,
rc.left + width, rc.bottom);
rc.bottom -= row_height;
for (unsigned i = start; i < end; ++i) {
buttons[i]->Move(button_rc);
button_rc.left = button_rc.right;
button_rc.right += width;
}
return rc;
}
static void
Draw(Canvas &canvas, PixelRect rc,
const TaskOZMapItem &item,
const TwoTextRowsRenderer &row_renderer,
const TaskLook &look, const AirspaceLook &airspace_look,
const AirspaceRendererSettings &airspace_settings)
{
const unsigned line_height = rc.GetHeight();
const unsigned text_padding = Layout::GetTextPadding();
const ObservationZonePoint &oz = *item.oz;
const Waypoint &waypoint = *item.waypoint;
const PixelPoint pt(rc.left + line_height / 2,
rc.top + line_height / 2);
const unsigned radius = line_height / 2 - text_padding;
OZPreviewRenderer::Draw(canvas, oz, pt, radius, look,
airspace_settings, airspace_look);
rc.left += line_height + text_padding;
TCHAR buffer[256];
// Draw details line
OrderedTaskPointRadiusLabel(*item.oz, buffer);
if (!StringIsEmpty(buffer))
row_renderer.DrawSecondRow(canvas, rc, buffer);
// Draw waypoint name
OrderedTaskPointLabel(item.tp_type, waypoint.name.c_str(),
item.index, buffer);
row_renderer.DrawFirstRow(canvas, rc, buffer);
}
void
SymbolRenderer::DrawArrow(Canvas &canvas, PixelRect rc, Direction direction)
{
assert(direction == UP || direction == DOWN ||
direction == LEFT || direction == RIGHT);
auto size = std::min(rc.GetWidth(), rc.GetHeight()) / 5;
auto center = rc.GetCenter();
BulkPixelPoint arrow[3];
if (direction == LEFT || direction == RIGHT) {
arrow[0].x = center.x + (direction == LEFT ? size : -size);
arrow[0].y = center.y + size;
arrow[1].x = center.x + (direction == LEFT ? -size : size);
arrow[1].y = center.y;
arrow[2].x = center.x + (direction == LEFT ? size : -size);
arrow[2].y = center.y - size;
} else if (direction == UP || direction == DOWN) {
arrow[0].x = center.x + size;
arrow[0].y = center.y + (direction == UP ? size : -size);
arrow[1].x = center.x;
arrow[1].y = center.y + (direction == UP ? -size : size);
arrow[2].x = center.x - size;
arrow[2].y = center.y + (direction == UP ? size : -size);
}
canvas.DrawTriangleFan(arrow, 3);
}
void
HorizonRenderer::Draw(Canvas &canvas, const PixelRect &rc,
const HorizonLook &look,
const AttitudeState &attitude)
{
/*
This feature of having a backup artificial horizon based on inferred
orientation from GPS and vario data is useful, and reasonably well
tested, but has the issue of potentially invalidating use of XCSoar in
FAI contests due to rule ref Annex A to Section 3 (2010 Edition) 4.1.2
"No instruments permitting pilots to fly without visual reference to
the ground may be carried on board, even if made unserviceable." The
quality of XCSoar's pseudo-AH is arguably good enough that this
violates the rule. We need to seek clarification as to whether this
is the case or not.
*/
const auto center = rc.GetCenter();
const int radius = std::min(rc.GetWidth(), rc.GetHeight()) / 2
- Layout::Scale(1);
auto bank_degrees = attitude.IsBankAngleUseable()
? attitude.bank_angle.Degrees()
: 0.;
auto pitch_degrees = attitude.IsPitchAngleUseable()
? attitude.pitch_angle.Degrees()
: 0.;
auto phi = Clamp(bank_degrees, -89., 89.);
auto alpha = Angle::acos(Clamp(pitch_degrees / 50,
-1., 1.));
auto sphi = Angle::HalfCircle() - Angle::Degrees(phi);
auto alpha1 = sphi - alpha;
auto alpha2 = sphi + alpha;
// draw sky part
canvas.Select(look.sky_pen);
canvas.Select(look.sky_brush);
canvas.DrawSegment(center, radius, alpha2, alpha1, true);
// draw ground part
canvas.Select(look.terrain_pen);
canvas.Select(look.terrain_brush);
canvas.DrawSegment(center, radius, alpha1, alpha2, true);
// draw aircraft symbol
canvas.Select(look.aircraft_pen);
canvas.DrawLine(center.x + radius / 2, center.y, center.x - radius / 2, center.y);
canvas.DrawLine(center.x, center.y - radius / 4, center.x, center.y);
// draw 45 degree dash marks
const int rr2p = uround(radius * M_SQRT1_2) + Layout::Scale(1);
const int rr2n = rr2p - Layout::Scale(2);
canvas.DrawLine(center.x + rr2p, center.y - rr2p,
center.x + rr2n, center.y - rr2n);
canvas.DrawLine(center.x - rr2p, center.y - rr2p,
center.x - rr2n, center.y - rr2n);
}
void
InfoBoxContentWindArrow::OnCustomPaint(Canvas &canvas, const PixelRect &rc)
{
const auto &info = CommonInterface::Calculated();
const auto pt = rc.GetCenter();
const unsigned padding = Layout::FastScale(10u);
unsigned size = std::min(rc.GetWidth(), rc.GetHeight());
if (size > padding)
size -= padding;
// Normalize the size because the Layout::Scale is applied
// by the DrawArrow() function again
size = size * 100 / Layout::Scale(100);
auto angle = info.wind.bearing - CommonInterface::Basic().attitude.heading;
const int length =
std::min(size, std::max(10u, uround(Quadruple(info.wind.norm))));
const int offset = -length / 2;
auto style = CommonInterface::GetMapSettings().wind_arrow_style;
WindArrowRenderer renderer(UIGlobals::GetLook().wind_arrow_info_box);
renderer.DrawArrow(canvas, pt, angle, length, style, offset);
}
void
Canvas::InvertRectangle(PixelRect r)
{
if (r.IsEmpty())
return;
CopyNot(r.left, r.top, r.GetWidth(), r.GetHeight(),
buffer, r.left, r.top);
}
PixelRect
ButtonPanel::UpdateLayout(const PixelRect rc)
{
if (buttons.empty())
return rc;
const bool landscape = rc.GetWidth() > rc.GetHeight();
return landscape
? LeftLayout(rc)
: BottomLayout(rc);
}
void
GlueMapWindow::DrawStallRatio(Canvas &canvas, const PixelRect &rc) const
{
if (Basic().stall_ratio_available) {
// JMW experimental, display stall sensor
auto s = Clamp(Basic().stall_ratio, 0., 1.);
int m = rc.GetHeight() * s * s;
canvas.SelectBlackPen();
canvas.DrawLine(rc.right - 1, rc.bottom - m, rc.right - 11, rc.bottom - m);
}
}
gcc_pure
static PixelRect
GetButtonPosition(unsigned i, PixelRect rc)
{
unsigned hwidth = rc.GetWidth(), hheight = rc.GetHeight();
if (hheight > hwidth) {
// portrait
hheight /= 6;
if (i == 0) {
rc.left = rc.right;
rc.top = rc.bottom;
} else if (i < 5) {
hwidth /= 4;
rc.left += hwidth * (i - 1);
rc.top = rc.bottom - hheight;
} else {
hwidth /= 3;
rc.left = rc.right - hwidth;
rc.top += (i - 5) * hheight;
}
rc.right = rc.left + hwidth;
rc.bottom = rc.top + hheight;
} else {
// landscape
hwidth /= 5;
hheight /= 5;
if (i == 0) {
rc.left = rc.right;
rc.top = rc.bottom;
} else if (i < 5) {
rc.top += hheight * (i - 1);
} else {
rc.left += hwidth * (i - 5);
rc.top = rc.bottom - hheight;
}
rc.right = rc.left + hwidth;
rc.bottom = rc.top + hheight;
}
return rc;
}
void
SymbolRenderer::DrawSign(Canvas &canvas, PixelRect rc, bool plus)
{
unsigned size = std::min(rc.GetWidth(), rc.GetHeight()) / 5;
auto center = rc.GetCenter();
// Draw horizontal bar
canvas.Rectangle(center.x - size, center.y - size / 3,
center.x + size, center.y + size / 3);
if (plus)
// Draw vertical bar
canvas.Rectangle(center.x - size / 3, center.y - size,
center.x + size / 3, center.y + size);
}
AnalysisWidget::Layout::Layout(const PixelRect rc)
{
const unsigned width = rc.GetWidth(), height = rc.GetHeight();
const unsigned button_height = ::Layout::GetMaximumControlHeight();
main = rc;
/* close button on the bottom left */
close_button.left = rc.left;
close_button.right = rc.left + ::Layout::Scale(70);
close_button.bottom = rc.bottom;
close_button.top = close_button.bottom - button_height;
/* previous/next buttons above the close button */
previous_button = close_button;
previous_button.bottom = previous_button.top;
previous_button.top = previous_button.bottom - button_height;
previous_button.right = (previous_button.left + previous_button.right) / 2;
next_button = previous_button;
next_button.left = next_button.right;
next_button.right = close_button.right;
/* "details" button above "previous/next" */
details_button = close_button;
details_button.bottom = previous_button.top;
details_button.top = details_button.bottom - button_height;
if (width > height) {
info = close_button;
info.top = rc.top;
info.bottom = details_button.top;
main.left = close_button.right;
} else {
main.bottom = details_button.top;
info.left = close_button.right;
info.right = rc.right;
info.top = main.bottom;
info.bottom = rc.bottom;
}
}
void
ListControl::DrawItems(Canvas &canvas, unsigned start, unsigned end) const
{
PixelRect rc = item_rect(start);
canvas.SetBackgroundColor(look.list.background_color);
canvas.SetBackgroundTransparent();
canvas.Select(*look.list.font);
#ifdef ENABLE_OPENGL
/* enable clipping */
const PixelRect scissor_rc(0, 0, scroll_bar.GetLeft(GetSize()),
canvas.GetHeight());
GLCanvasScissor scissor(scissor_rc);
#endif
unsigned last_item = std::min(length, end);
const bool focused = !HasCursorKeys() || HasFocus();
for (unsigned i = start; i < last_item; i++) {
const bool selected = i == cursor;
const bool pressed = selected && drag_mode == DragMode::CURSOR;
canvas.DrawFilledRectangle(rc,
look.list.GetBackgroundColor(selected,
focused,
pressed));
canvas.SetTextColor(look.list.GetTextColor(selected, focused, pressed));
if (item_renderer != nullptr)
item_renderer->OnPaintItem(canvas, rc, i);
if (focused && selected)
canvas.DrawFocusRectangle(rc);
rc.Offset(0, rc.GetHeight());
}
/* paint the bottom part below the last item */
rc.bottom = canvas.GetHeight();
if (rc.bottom > rc.top)
canvas.DrawFilledRectangle(rc, look.list.background_color);
}
static void
Draw(Canvas &canvas, PixelRect rc,
const SelfMapItem &item,
const TwoTextRowsRenderer &row_renderer,
const AircraftLook &look,
const MapSettings &settings)
{
const unsigned line_height = rc.GetHeight();
const unsigned text_padding = Layout::GetTextPadding();
const PixelPoint pt(rc.left + line_height / 2, rc.top + line_height / 2);
AircraftRenderer::Draw(canvas, settings, look, item.bearing, pt);
rc.left += line_height + text_padding;
row_renderer.DrawFirstRow(canvas, rc, _("Your Position"));
row_renderer.DrawSecondRow(canvas, rc, FormatGeoPoint(item.location));
}
void
KnobTextEntryWindow::OnPaint(Canvas &canvas)
{
const PixelRect rc = GetClientRect();
canvas.Clear(Color(0x40, 0x40, 0x00));
// Do the actual painting of the text
const DialogLook &look = UIGlobals::GetDialogLook();
canvas.Select(look.text_font);
PixelSize tsize = canvas.CalcTextSize(buffer);
PixelSize tsizec = canvas.CalcTextSize(buffer, cursor);
PixelSize tsizea = canvas.CalcTextSize(buffer, cursor + 1);
BulkPixelPoint p[5];
p[0].x = 10;
p[0].y = (rc.GetHeight() - tsize.cy - 5) / 2;
p[2].x = p[0].x + tsizec.cx;
p[2].y = p[0].y + tsize.cy + 5;
p[3].x = p[0].x + tsizea.cx;
p[3].y = p[0].y + tsize.cy + 5;
p[1].x = p[2].x;
p[1].y = p[2].y - 2;
p[4].x = p[3].x;
p[4].y = p[3].y - 2;
canvas.SelectWhitePen();
canvas.DrawPolyline(p + 1, 4);
canvas.SetBackgroundTransparent();
canvas.SetTextColor(COLOR_WHITE);
canvas.DrawText(p[0].x, p[0].y, buffer);
}
PixelRect
ButtonPanel::VerticalRange(PixelRect rc, unsigned start, unsigned end)
{
const unsigned n = end - start;
assert(n > 0);
const unsigned width = RangeMaxWidth(start, end);
const unsigned total_height = rc.GetHeight();
const unsigned max_height = n * Layout::GetMaximumControlHeight();
const unsigned row_height = std::min(total_height, max_height) / n;
PixelRect button_rc(rc.left, rc.top, rc.left + width, rc.top + row_height);
rc.left += width;
for (unsigned i = start; i < end; ++i) {
buttons[i]->Move(button_rc);
button_rc.top = button_rc.bottom;
button_rc.bottom += row_height;
}
return rc;
}
void
LogoView::draw(Canvas &canvas, const PixelRect &rc)
{
const unsigned width = rc.GetWidth(), height = rc.GetHeight();
enum {
LANDSCAPE, PORTRAIT, SQUARE,
} orientation;
if (width == height)
orientation = SQUARE;
else if (width > height)
orientation = LANDSCAPE;
else
orientation = PORTRAIT;
/* load bitmaps */
const bool use_big =
(orientation == LANDSCAPE && width >= 510 && height >= 170) ||
(orientation == PORTRAIT && width >= 330 && height >= 250) ||
(orientation == SQUARE && width >= 210 && height >= 210);
const Bitmap &bitmap_logo = use_big ? big_logo : logo;
const Bitmap &bitmap_title = use_big ? big_title : title;
// Determine logo size
PixelSize logo_size = bitmap_logo.GetSize();
// Determine title image size
PixelSize title_size = bitmap_title.GetSize();
unsigned spacing = title_size.cy / 2;
unsigned estimated_width, estimated_height;
switch (orientation) {
case LANDSCAPE:
estimated_width = logo_size.cx + spacing + title_size.cx;
estimated_height = logo_size.cy;
break;
case PORTRAIT:
estimated_width = title_size.cx;
estimated_height = logo_size.cy + spacing + title_size.cy;
break;
case SQUARE:
estimated_width = logo_size.cx;
estimated_height = logo_size.cy;
break;
}
const unsigned magnification =
std::min((width - 16u) / estimated_width,
(height - 16u) / estimated_height);
if (magnification > 1) {
logo_size.cx *= magnification;
logo_size.cy *= magnification;
title_size.cx *= magnification;
title_size.cy *= magnification;
spacing *= magnification;
}
int logox, logoy, titlex, titley;
// Determine logo and title positions
switch (orientation) {
case LANDSCAPE:
logox = Center(width, logo_size.cx + spacing + title_size.cx);
logoy = Center(height, logo_size.cy);
titlex = logox + logo_size.cx + spacing;
titley = Center(height, title_size.cy);
break;
case PORTRAIT:
logox = Center(width, logo_size.cx);
logoy = Center(height, logo_size.cy + spacing + title_size.cy);
titlex = Center(width, title_size.cx);
titley = logoy + logo_size.cy + spacing;
break;
case SQUARE:
logox = Center(width, logo_size.cx);
logoy = Center(height, logo_size.cy);
// not needed - silence compiler "may be used uninitialized"
titlex = 0;
titley = 0;
break;
}
// Draw 'XCSoar N.N' title
if (orientation != SQUARE)
canvas.Stretch(titlex, titley, title_size.cx, title_size.cy, bitmap_title);
// Draw XCSoar swift logo
canvas.Stretch(logox, logoy, logo_size.cx, logo_size.cy, bitmap_logo);
// Draw full XCSoar version number
#ifndef USE_GDI
canvas.Select(font);
#endif
canvas.SetTextColor(COLOR_BLACK);
canvas.SetBackgroundTransparent();
canvas.DrawText(2, 2, XCSoar_ProductToken);
}
gcc_pure
static bool IsLandscape(const PixelRect &rc) {
return rc.GetWidth() >= rc.GetHeight();
}
void
GlueMapWindow::UpdateProjection()
{
const PixelRect rc = GetClientRect();
/* not using MapWindowBlackboard here because these methods are
called by the main thread */
const NMEAInfo &basic = CommonInterface::Basic();
const DerivedInfo &calculated = CommonInterface::Calculated();
const MapSettings &settings_map = CommonInterface::GetMapSettings();
const bool circling =
CommonInterface::GetUIState().display_mode == DisplayMode::CIRCLING;
const auto center = rc.GetCenter();
if (circling || !IsNearSelf())
visible_projection.SetScreenOrigin(center.x, center.y);
else if (settings_map.cruise_orientation == MapOrientation::NORTH_UP ||
settings_map.cruise_orientation == MapOrientation::WIND_UP) {
PixelPoint offset{0, 0};
if (settings_map.glider_screen_position != 50 &&
settings_map.map_shift_bias != MapShiftBias::NONE) {
double x = 0, y = 0;
if (settings_map.map_shift_bias == MapShiftBias::TRACK) {
if (basic.track_available &&
basic.ground_speed_available &&
/* 8 m/s ~ 30 km/h */
basic.ground_speed > 8) {
auto angle = basic.track.Reciprocal() - visible_projection.GetScreenAngle();
const auto sc = angle.SinCos();
x = sc.first;
y = sc.second;
}
} else if (settings_map.map_shift_bias == MapShiftBias::TARGET) {
if (calculated.task_stats.current_leg.solution_remaining.IsDefined()) {
auto angle = calculated.task_stats.current_leg.solution_remaining
.vector.bearing.Reciprocal() - visible_projection.GetScreenAngle();
const auto sc = angle.SinCos();
x = sc.first;
y = sc.second;
}
}
double position_factor = (50. - settings_map.glider_screen_position) / 100.;
offset.x = int(x * rc.GetWidth() * position_factor);
offset.y = int(-y * rc.GetHeight() * position_factor);
offset_history.Add(offset);
offset = offset_history.GetAverage();
}
visible_projection.SetScreenOrigin(center.x + offset.x, center.y + offset.y);
} else
visible_projection.SetScreenOrigin(center.x,
((rc.top - rc.bottom) * settings_map.glider_screen_position / 100) + rc.bottom);
if (!IsNearSelf()) {
/* no-op - the Projection's location is updated manually */
} else if (circling && calculated.thermal_locator.estimate_valid) {
const auto d_t = calculated.thermal_locator.estimate_location.DistanceS(basic.location);
if (d_t <= 0) {
SetLocationLazy(basic.location);
} else {
const auto d_max = 2 * visible_projection.GetMapScale();
const auto t = std::min(d_t, d_max)/d_t;
SetLocation(basic.location.Interpolate(calculated.thermal_locator.estimate_location,
t));
}
} else if (basic.location_available)
// Pan is off
SetLocationLazy(basic.location);
else if (!visible_projection.IsValid() && terrain != nullptr)
/* if there's no GPS fix yet and no home waypoint, start at the
map center, to avoid showing a fully white map, which confuses
users */
SetLocation(terrain->GetTerrainCenter());
OnProjectionModified();
}
WaypointDetailsWidget::Layout::Layout(const PixelRect &rc,
const Waypoint &waypoint)
{
const unsigned width = rc.GetWidth(), height = rc.GetHeight();
const unsigned button_height = ::Layout::GetMaximumControlHeight();
main = rc;
if (width > height) {
main.left += ::Layout::Scale(70);
PixelRect buttons = rc;
buttons.right = main.left;
goto_button = buttons;
goto_button.bottom = buttons.top += button_height;
magnify_button = buttons;
magnify_button.bottom = buttons.top += button_height;
shrink_button = magnify_button;
magnify_button.right = shrink_button.left =
(buttons.left + buttons.right) / 2;
close_button = buttons;
close_button.top = buttons.bottom -= button_height;
previous_button = buttons;
previous_button.top = buttons.bottom -= button_height;
next_button = previous_button;
previous_button.right = next_button.left =
(buttons.left + buttons.right) / 2;
} else {
main.bottom -= button_height;
PixelRect buttons = rc;
buttons.top = main.bottom;
const unsigned one_third = (2 * buttons.left + buttons.right) / 3;
const unsigned two_thirds = (buttons.left + 2 * buttons.right) / 3;
goto_button = buttons;
goto_button.right = one_third;
close_button = buttons;
close_button.left = two_thirds;
previous_button = buttons;
previous_button.left = one_third;
next_button = buttons;
next_button.right = two_thirds;
previous_button.right = next_button.left = (one_third + two_thirds) / 2;
const unsigned padding = ::Layout::GetTextPadding();
shrink_button.left = main.left + padding;
shrink_button.top = main.top + padding;
shrink_button.right = shrink_button.left + button_height;
shrink_button.bottom = shrink_button.top + button_height;
magnify_button.right = main.right - padding;
magnify_button.top = main.top + padding;
magnify_button.left = magnify_button.right - button_height;
magnify_button.bottom = magnify_button.top + button_height;
}
details_text.left = 0;
details_text.top = 0;
details_text.right = main.GetWidth();
details_text.bottom = main.GetHeight();
#ifdef HAVE_RUN_FILE
const unsigned num_files = std::distance(waypoint.files_external.begin(),
waypoint.files_external.end());
if (num_files > 0) {
file_list_item_height = ::Layout::Scale(18);
file_list = details_text;
unsigned list_height = file_list_item_height * std::min(num_files, 5u);
file_list.bottom = details_text.top += list_height;
}
#endif
}
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);
}
static void
Draw(Canvas &canvas, PixelRect rc,
const TrafficMapItem &item,
const TwoTextRowsRenderer &row_renderer,
const TrafficLook &traffic_look,
const TrafficList *traffic_list)
{
const unsigned line_height = rc.GetHeight();
const unsigned text_padding = Layout::GetTextPadding();
const FlarmTraffic *traffic = traffic_list == nullptr
? nullptr
: traffic_list->FindTraffic(item.id);
const PixelPoint pt(rc.left + line_height / 2, rc.top + line_height / 2);
// Render the representation of the traffic icon
if (traffic != nullptr)
TrafficRenderer::Draw(canvas, traffic_look, *traffic, traffic->track,
item.color, pt);
rc.left += line_height + text_padding;
// Now render the text information
const FlarmNetRecord *record = FlarmDetails::LookupRecord(item.id);
StaticString<256> title_string;
if (record && !StringIsEmpty(record->pilot))
title_string = record->pilot.c_str();
else
title_string = _("FLARM Traffic");
// Append name to the title, if it exists
const TCHAR *callsign = FlarmDetails::LookupCallsign(item.id);
if (callsign != nullptr && !StringIsEmpty(callsign)) {
title_string.append(_T(", "));
title_string.append(callsign);
}
row_renderer.DrawFirstRow(canvas, rc, title_string);
StaticString<256> info_string;
if (record && !StringIsEmpty(record->plane_type))
info_string = record->plane_type;
else if (traffic != nullptr)
info_string = FlarmTraffic::GetTypeString(traffic->type);
else
info_string = _("Unknown");
// Generate the line of info about the target, if it's available
if (traffic != nullptr) {
if (traffic->altitude_available)
info_string.AppendFormat(_T(", %s: %s"), _("Altitude"),
FormatUserAltitude(traffic->altitude).c_str());
if (traffic->climb_rate_avg30s_available) {
TCHAR tmp[15];
FormatUserVerticalSpeed(traffic->climb_rate_avg30s, tmp, 15);
info_string.AppendFormat(_T(", %s: %s"), _("Vario"), tmp);
}
}
row_renderer.DrawSecondRow(canvas, rc, info_string);
}
unsigned
Canvas::DrawFormattedText(const PixelRect r, const TCHAR *text,
unsigned format)
{
assert(text != nullptr);
#ifndef UNICODE
assert(ValidateUTF8(text));
#endif
if (font == nullptr)
return 0;
unsigned skip = font->GetLineSpacing();
unsigned max_lines = (format & DT_CALCRECT) ? -1 :
(r.GetHeight() + skip - 1) / skip;
size_t len = _tcslen(text);
TCHAR *duplicated = new TCHAR[len + 1], *p = duplicated;
unsigned lines = 1;
for (const TCHAR *i = text; *i != _T('\0'); ++i) {
TCHAR ch = *i;
if (ch == _T('\n')) {
/* explicit line break */
if (++lines > max_lines)
break;
ch = _T('\0');
} else if (ch == _T('\r'))
/* skip */
continue;
else if ((unsigned)ch < 0x20)
/* replace non-printable characters */
ch = _T(' ');
*p++ = ch;
}
*p = _T('\0');
len = p - duplicated;
// simple wordbreak algorithm. looks for single spaces only, no tabs,
// no grouping of multiple spaces
for (size_t i = 0; i < len; i += _tcslen(duplicated + i) + 1) {
PixelSize sz = CalcTextSize(duplicated + i);
TCHAR *prev_p = nullptr;
// remove words from behind till line fits or no more space is found
while (unsigned(sz.cx) > r.GetWidth() &&
(p = StringFindLast(duplicated + i, _T(' '))) != nullptr) {
if (prev_p)
*prev_p = _T(' ');
*p = _T('\0');
prev_p = p;
sz = CalcTextSize(duplicated + i);
}
if (prev_p) {
lines++;
if (lines >= max_lines)
break;
}
}
if (format & DT_CALCRECT) {
delete[] duplicated;
return lines * skip;
}
int y = (format & DT_VCENTER) && lines < max_lines
? (r.top + r.bottom - lines * skip) / 2
: r.top;
for (size_t i = 0; i < len; i += _tcslen(duplicated + i) + 1) {
if (duplicated[i] != _T('\0')) {
int x;
if (format & (DT_RIGHT | DT_CENTER)) {
PixelSize sz = CalcTextSize(duplicated + i);
x = (format & DT_CENTER)
? (r.left + r.right - sz.cx) / 2
: r.right - sz.cx; // DT_RIGHT
} else { // default is DT_LEFT
x = r.left;
}
TextAutoClipped(x, y, duplicated + i);
if (format & DT_UNDERLINE)
DrawHLine(x, x + CalcTextWidth(duplicated + i),
y + font->GetAscentHeight() + 1, text_color);
}
y += skip;
if (y >= r.bottom)
break;
}
delete[] duplicated;
return lines * skip;
}
void
FinalGlideBarRenderer::Draw(Canvas &canvas, const PixelRect &rc,
const DerivedInfo &calculated,
const GlideSettings &glide_settings,
const bool final_glide_bar_mc0_enabled) const
{
#ifdef ENABLE_OPENGL
const ScopeAlphaBlend alpha_blend;
#endif
BulkPixelPoint GlideBar[6] = {
{ 0, 0 }, { 9, -9 }, { 18, 0 }, { 18, 0 }, { 9, 0 }, { 0, 0 }
};
BulkPixelPoint GlideBar0[4] = {
{ 0, 0 }, { 9, -9 }, { 9, 0 }, { 0, 0 }
};
BulkPixelPoint clipping_arrow[6] = {
{ 0, 0 }, { 9, 9 }, { 18, 0 }, { 18, 6 }, { 9, 15 }, { 0, 6 }
};
BulkPixelPoint clipping_arrow0[4] = {
{ 0, 0 }, { 9, 9 }, { 9, 15 }, { 0, 6 }
};
TCHAR Value[10];
const TaskStats &task_stats = calculated.task_stats;
const ElementStat &total = task_stats.total;
const GlideResult &solution = total.solution_remaining;
const GlideResult &solution_mc0 = total.solution_mc0;
if (!task_stats.task_valid || !solution.IsOk() || !solution_mc0.IsDefined())
return;
const int y0 = (rc.bottom + rc.top) / 2;
/* NOTE: size_divisor replaces the fixed value 9 that was used throughout
* the code below which caused fixed size rendering regardless of
* map size (except the effects of Layout::Scale()). This method
* is not usable with variable map sizes (e.g. because of the cross-section
* area). size_divisor is used to introduce a screen size dependent scaling.
* That workaround is an ugly hack and needs a rework. */
const int size_divisor =
std::max(Layout::Scale(3000u / rc.GetHeight()), 4u);
int dy_glidebar = 0;
int dy_glidebar0 = 0;
FormatUserAltitude(solution.SelectAltitudeDifference(glide_settings),
Value, false);
canvas.Select(*look.font);
const PixelSize text_size = canvas.CalcTextSize(Value);
int clipping_arrow_offset = Layout::Scale(4);
int clipping_arrow0_offset = Layout::Scale(4);
// 468 meters is it's size. Will be divided by 9 to fit screen resolution.
int altitude_difference = (int)
solution.SelectAltitudeDifference(glide_settings);
int altitude_difference0 = (int)
solution_mc0.SelectAltitudeDifference(glide_settings);
// TODO feature: should be an angle if in final glide mode
// cut altitude_difference at +- 468 meters (55 units)
if (altitude_difference > 468)
altitude_difference = 468;
if (altitude_difference < -468)
altitude_difference = -468;
// 55 units is size, 468 meters div by 9 means 55.
int Offset = altitude_difference / size_divisor;
Offset = Layout::Scale(Offset);
if (altitude_difference <= 0) {
GlideBar[1].y = Layout::Scale(9);
dy_glidebar = text_size.cy + 2;
} else {
GlideBar[1].y = -Layout::Scale(9);
clipping_arrow[1].y = -clipping_arrow[1].y;
clipping_arrow[3].y = -clipping_arrow[3].y;
clipping_arrow[4].y = -clipping_arrow[4].y;
clipping_arrow[5].y = -clipping_arrow[5].y;
clipping_arrow_offset = -clipping_arrow_offset;
dy_glidebar = -1;
}
// cut altitude_difference0 at +- 468 meters (55 units)
if (altitude_difference0 > 468)
altitude_difference0 = 468;
if (altitude_difference0 < -468)
altitude_difference0 = -468;
// 55 units is size, therefore div by 9.
int Offset0 = altitude_difference0 / size_divisor;
Offset0 = Layout::Scale(Offset0);
if (altitude_difference0 <= 0) {
GlideBar0[1].y = Layout::Scale(9);
dy_glidebar0 = text_size.cy + 2;
} else {
GlideBar0[1].y = -Layout::Scale(9);
clipping_arrow0[1].y = -clipping_arrow0[1].y;
clipping_arrow0[2].y = -clipping_arrow0[2].y;
clipping_arrow0[3].y = -clipping_arrow0[3].y;
clipping_arrow0_offset = -clipping_arrow0_offset;
dy_glidebar0 = -1;
}
for (unsigned i = 0; i < 6; i++) {
GlideBar[i].y += y0 + dy_glidebar;
GlideBar[i].x = Layout::Scale(GlideBar[i].x) + rc.left;
}
GlideBar[0].y -= Offset;
GlideBar[1].y -= Offset;
GlideBar[2].y -= Offset;
for (unsigned i = 0; i < 4; i++) {
GlideBar0[i].y += y0 + dy_glidebar0;
GlideBar0[i].x = Layout::Scale(GlideBar0[i].x) + rc.left;
}
GlideBar0[0].y -= Offset0;
GlideBar0[1].y -= Offset0;
if ((altitude_difference0 >= altitude_difference) && (altitude_difference > 0)) {
// both above and mc0 arrow larger than mc arrow
GlideBar0[2].y = GlideBar[1].y; // both below
GlideBar0[3].y = GlideBar[0].y;
}
// prepare clipping arrow
for (unsigned i = 0; i < 6; i++) {
clipping_arrow[i].y = Layout::Scale(clipping_arrow[i].y) + y0 - Offset
+ clipping_arrow_offset + dy_glidebar;
clipping_arrow[i].x = Layout::Scale(clipping_arrow[i].x) + rc.left;
}
// prepare clipping arrow mc0
for (unsigned i = 0; i < 4; i++) {
clipping_arrow0[i].y = Layout::Scale(clipping_arrow0[i].y) + y0 - Offset0
+ clipping_arrow0_offset + dy_glidebar0;
clipping_arrow0[i].x = Layout::Scale(clipping_arrow0[i].x) + rc.left;
}
// draw actual glide bar
if (altitude_difference <= 0) {
if (calculated.common_stats.landable_reachable) {
canvas.Select(look.pen_below_landable);
canvas.Select(look.brush_below_landable);
} else {
canvas.Select(look.pen_below);
canvas.Select(look.brush_below);
}
} else {
canvas.Select(look.pen_above);
canvas.Select(look.brush_above);
}
canvas.DrawPolygon(GlideBar, 6);
// draw clipping arrow
if ((altitude_difference <= -468 ) || (altitude_difference >= 468))
canvas.DrawPolygon(clipping_arrow, 6);
// draw glide bar at mc 0
if (altitude_difference0 <= 0 && final_glide_bar_mc0_enabled) {
if (calculated.common_stats.landable_reachable) {
canvas.Select(look.pen_below_landable);
canvas.Select(look.brush_below_landable_mc0);
} else {
canvas.Select(look.pen_below);
canvas.Select(look.brush_below_mc0);
}
} else {
canvas.Select(look.pen_above);
canvas.Select(look.brush_above_mc0);
}
if ( ( (altitude_difference != altitude_difference0) || (altitude_difference0 < 0) )
&& final_glide_bar_mc0_enabled) {
canvas.DrawPolygon(GlideBar0, 4);
if ((altitude_difference0 <= -468 ) || (altitude_difference0 >= 468))
canvas.DrawPolygon(clipping_arrow0, 4);
}
// draw cross (x) on final glide bar if unreachable at current Mc
// or above final glide but impeded by obstacle
int cross_sign = 0;
if (!total.IsAchievable())
cross_sign = 1;
if (calculated.terrain_warning_location.IsValid() &&
altitude_difference > 0 )
cross_sign = -1;
if (cross_sign != 0) {
canvas.Select(task_look.bearing_pen);
canvas.DrawLine(Layout::Scale(9 - 5), y0 + cross_sign * Layout::Scale(9 - 5),
Layout::Scale(9 + 5), y0 + cross_sign * Layout::Scale(9 + 5));
canvas.DrawLine(Layout::Scale(9 - 5), y0 + cross_sign * Layout::Scale(9 + 5),
Layout::Scale(9 + 5), y0 + cross_sign * Layout::Scale(9 - 5));
}
canvas.SetTextColor(COLOR_BLACK);
canvas.SetBackgroundColor(COLOR_WHITE);
TextInBoxMode style;
style.shape = LabelShape::ROUNDED_BLACK;
style.move_in_view = true;
if (text_size.cx < Layout::Scale(18)) {
style.align = TextInBoxMode::Alignment::RIGHT;
TextInBox(canvas, Value, Layout::Scale(18), y0, style, rc);
} else
TextInBox(canvas, Value, 0, y0, style, rc);
}
bool
TouchTextEntry(TCHAR *text, size_t width,
const TCHAR *caption,
AllowedCharacters accb,
bool default_shift_state)
{
if (width == 0)
width = MAX_TEXTENTRY;
max_width = std::min(MAX_TEXTENTRY, width);
const DialogLook &look = UIGlobals::GetDialogLook();
WndForm form(look);
form.Create(UIGlobals::GetMainWindow(), caption);
form.SetKeyDownFunction(FormKeyDown);
form.SetCharacterFunction(FormCharacter);
ContainerWindow &client_area = form.GetClientAreaWindow();
const PixelRect rc = client_area.GetClientRect();
const int client_height = rc.GetHeight();
const int padding = Layout::Scale(2);
const int backspace_width = Layout::Scale(36);
const int backspace_left = rc.right - padding - backspace_width;
const int editor_height = Layout::Scale(22);
const int editor_bottom = padding + editor_height;
const int button_height = Layout::Scale(40);
constexpr unsigned keyboard_rows = 5;
const int keyboard_top = editor_bottom + padding;
const int keyboard_height = keyboard_rows * button_height;
const int keyboard_bottom = keyboard_top + keyboard_height;
const bool vertical = client_height >= keyboard_bottom + button_height;
const int button_top = vertical
? rc.bottom - button_height
: keyboard_bottom - button_height;
const int button_bottom = vertical
? rc.bottom
: keyboard_bottom;
const int ok_left = vertical ? 0 : padding;
const int ok_right = vertical
? rc.right / 3
: ok_left + Layout::Scale(80);
const int cancel_left = vertical
? ok_right
: Layout::Scale(175);
const int cancel_right = vertical
? rc.right * 2 / 3
: cancel_left + Layout::Scale(60);
const int clear_left = vertical
? cancel_right
: Layout::Scale(235);
const int clear_right = vertical
? rc.right
: clear_left + Layout::Scale(50);
WndProperty _editor(client_area, look, _T(""),
{ 0, padding, backspace_left - padding, editor_bottom },
0, WindowStyle());
_editor.SetReadOnly();
editor = &_editor;
WindowStyle button_style;
button_style.TabStop();
Button ok_button(client_area, look.button, _("OK"),
{ ok_left, button_top, ok_right, button_bottom },
button_style, form, mrOK);
Button cancel_button(client_area, look.button, _("Cancel"),
{ cancel_left, button_top,
cancel_right, button_bottom },
button_style, form, mrCancel);
auto clear_listener = MakeLambdaActionListener([](unsigned id){
ClearText();
});
Button clear_button(client_area, look.button, _("Clear"),
{ clear_left, button_top,
clear_right, button_bottom },
button_style, clear_listener, 0);
KeyboardWidget keyboard(look.button, FormCharacter, !accb,
default_shift_state);
const PixelRect keyboard_rc = {
padding, keyboard_top,
rc.right - padding, keyboard_bottom
};
keyboard.Initialise(client_area, keyboard_rc);
keyboard.Prepare(client_area, keyboard_rc);
keyboard.Show(keyboard_rc);
kb = &keyboard;
auto backspace_listener = MakeLambdaActionListener([](unsigned id){
OnBackspace();
});
Button backspace_button(client_area, look.button, _T("<-"),
{ backspace_left, padding, rc.right - padding,
editor_bottom },
button_style, backspace_listener, 0);
AllowedCharactersCallback = accb;
cursor = 0;
ClearText();
if (!StringIsEmpty(text)) {
CopyTruncateString(edittext, width, text);
cursor = _tcslen(text);
}
UpdateTextboxProp();
bool result = form.ShowModal() == mrOK;
keyboard.Hide();
keyboard.Unprepare();
if (result) {
CopyTruncateString(text, width, edittext);
}
return result;
}