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;
}
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
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);
}
PixelRect GetButtonPosition(unsigned MenuID, const PixelRect& rcScreen) {
PixelRect rc = rcScreen;
rc.Grow(-1); // remove Margin
unsigned i = MenuID - 1;
assert(i < MenuButtons.size());
const PixelScalar row = ScreenLandscape ? LandscapeLayout[i].row : PortraitLayout[i].row;
const PixelScalar col = ScreenLandscape ? LandscapeLayout[i].col :PortraitLayout[i].col;
const PixelScalar nbRow = ScreenLandscape ? 5 : 7;
const PixelScalar nbCol = ScreenLandscape ? 5 : 4;
const PixelSize size = {
std::min<PixelScalar>((rc.GetSize().cx-(nbCol-1))/nbCol, NIBLSCALE(80)),
std::min<PixelScalar>((rc.GetSize().cy-nbRow-1)/nbRow, NIBLSCALE(40))
};
const double x_interval = (rc.GetSize().cx - size.cx * nbCol) / (nbCol-1);
const double y_interval = (rc.GetSize().cy - size.cy * nbRow) / (nbRow-1);
const RasterPoint origin = {
rc.left + (PixelScalar)(col * (size.cx + x_interval)),
rc.top + (PixelScalar)(row * (size.cy + y_interval))
};
return PixelRect(origin, size);
}
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);
}
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;
}
void
Window::Create(ContainerWindow *parent, PixelRect rc,
const WindowStyle window_style)
{
assert(IsScreenInitialized());
assert(rc.left <= rc.right);
assert(rc.right - rc.left < 0x8000);
assert(rc.top <= rc.bottom);
assert(rc.bottom - rc.top < 0x8000);
double_clicks = window_style.double_clicks;
this->parent = parent;
position = rc.GetOrigin();
size = rc.GetSize();
tab_stop = window_style.tab_stop;
control_parent = window_style.control_parent;
visible = window_style.visible;
enabled = window_style.enabled;
has_border = window_style.has_border;
text_style = window_style.text_style;
if (parent != NULL)
parent->AddChild(*this);
OnCreate();
OnResize(size);
}
PixelRect
ButtonFrameRenderer::GetDrawingRect(PixelRect rc, bool pressed) const
{
rc.Grow(-2);
if (pressed)
rc.Offset(1, 1);
return rc;
}
inline void
TabMenuDisplay::PaintMainMenuBorder(Canvas &canvas) const
{
PixelRect rc = GetMainMenuButtonSize(0);
rc.bottom = GetMainMenuButtonSize(GetNumMainMenuItems() - 1).bottom;
rc.Grow(GetTabLineHeight());
canvas.DrawFilledRectangle(rc, COLOR_BLACK);
}
static void
Draw(Canvas &canvas)
{
PixelRect rc = canvas.GetRect();
rc.Grow(-16);
DrawBanner(canvas, rc);
DrawFlights(canvas, rc);
}
void
Canvas::InvertRectangle(PixelRect r)
{
if (r.IsEmpty())
return;
CopyNot(r.left, r.top, r.GetWidth(), r.GetHeight(),
buffer, r.left, r.top);
}
inline void
TabMenuDisplay::PaintSubMenuBorder(Canvas &canvas,
const MainMenuButton &main_button) const
{
PixelRect rc = GetSubMenuButtonSize(main_button.first_page_index);
rc.bottom = GetSubMenuButtonSize(main_button.last_page_index).bottom;
rc.Grow(GetTabLineHeight());
canvas.DrawFilledRectangle(rc, COLOR_BLACK);
}
PixelRect
ButtonPanel::UpdateLayout(const PixelRect rc)
{
if (buttons.empty())
return rc;
const bool landscape = rc.GetWidth() > rc.GetHeight();
return landscape
? LeftLayout(rc)
: BottomLayout(rc);
}
virtual void OnPaint(Canvas &canvas) override {
canvas.ClearWhite();
const PixelRect rc = canvas.GetRect();
PixelPoint pt = rc.GetCenter();
canvas.SelectBlackPen();
canvas.SelectHollowBrush();
canvas.DrawCircle(pt.x, pt.y, 2);
renderer.Draw(canvas, Angle::Zero(), wind, pt, rc, WindArrowStyle::ARROW_HEAD);
}
unsigned
WndFrame::GetTextHeight() const
{
PixelRect rc = GetClientRect();
const int padding = Layout::GetTextPadding();
rc.Grow(-padding);
AnyCanvas canvas;
canvas.Select(look.text_font);
return text_renderer.GetHeight(canvas, rc, text.c_str());
}
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());
}
void
GLTexture::DrawFlipped(PixelRect dest, PixelRect src) const
{
#ifdef HAVE_OES_DRAW_TEXTURE
if (OpenGL::oes_draw_texture) {
DrawFlippedOES(dest, src);
return;
}
#endif
const RasterPoint vertices[] = {
dest.GetTopLeft(),
dest.GetTopRight(),
dest.GetBottomLeft(),
dest.GetBottomRight(),
};
const ScopeVertexPointer vp(vertices);
const PixelSize allocated = GetAllocatedSize();
GLfloat x0 = (GLfloat)src.left / allocated.cx;
GLfloat y0 = (GLfloat)src.top / allocated.cy;
GLfloat x1 = (GLfloat)src.right / allocated.cx;
GLfloat y1 = (GLfloat)src.bottom / allocated.cy;
const GLfloat coord[] = {
x0, y1,
x1, y1,
x0, y0,
x1, y0,
};
#ifdef USE_GLSL
glEnableVertexAttribArray(OpenGL::Attribute::TEXCOORD);
glVertexAttribPointer(OpenGL::Attribute::TEXCOORD, 2, GL_FLOAT, GL_FALSE,
0, coord);
#else
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
glTexCoordPointer(2, GL_FLOAT, 0, coord);
#endif
glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
#ifdef USE_GLSL
glDisableVertexAttribArray(OpenGL::Attribute::TEXCOORD);
OpenGL::solid_shader->Use();
#else
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
#endif
}
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;
}
bool
TabDisplay::OnMouseMove(PixelScalar x, PixelScalar y, unsigned keys)
{
if (!dragging)
return false;
const PixelRect rc = GetButtonSize(down_index);
bool not_on_button = !rc.IsInside({ x, y });
if (drag_off_button != not_on_button) {
drag_off_button = not_on_button;
Invalidate(rc);
}
return true;
}
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);
}
bool
WndForm::OnMouseMove(PixelScalar x, PixelScalar y, unsigned keys)
{
if (ContainerWindow::OnMouseMove(x, y, keys))
return true;
if (dragging) {
const PixelRect position = GetPosition();
const int dx = position.left + x - last_drag.x;
const int dy = position.top + y - last_drag.y;
last_drag.x = position.left + x;
last_drag.y = position.top + y;
PixelRect parent = GetParentClientRect();
parent.Grow(-client_rect.top);
PixelRect new_position = position;
new_position.Offset(dx, dy);
if (new_position.right < parent.left)
new_position.Offset(parent.left - new_position.right, 0);
if (new_position.left > parent.right)
new_position.Offset(parent.right - new_position.left, 0);
if (new_position.top > parent.bottom)
new_position.Offset(0, parent.bottom - new_position.top);
if (new_position.top < 0)
new_position.Offset(0, -new_position.top);
#ifdef USE_MEMORY_CANVAS
/* the RasterCanvas class doesn't clip negative window positions
properly, therefore we avoid this problem at this stage */
if (new_position.left < 0)
new_position.left = 0;
if (new_position.top < 0)
new_position.top = 0;
#endif
Move(new_position.left, new_position.top);
return true;
}
return false;
}
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);
}
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);
}
void
KeyboardWidget::PrepareSize(const PixelRect &rc)
{
const PixelSize new_size = rc.GetSize();
button_width = new_size.cx / 10;
button_height = new_size.cy / 5;
}
void
SymbolRenderer::DrawArrow(Canvas &canvas, PixelRect rc, Direction direction)
{
assert(direction == UP || direction == DOWN ||
direction == LEFT || direction == RIGHT);
PixelScalar size = std::min(rc.right - rc.left, rc.bottom - rc.top) / 5;
RasterPoint center = rc.GetCenter();
RasterPoint 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
WndFrame::OnPaint(Canvas &canvas)
{
if (HaveClipping())
canvas.Clear(look.background_brush);
canvas.SetTextColor(caption_color);
canvas.SetBackgroundTransparent();
canvas.Select(look.text_font);
PixelRect rc = GetClientRect();
const int padding = Layout::GetTextPadding();
rc.Grow(-padding);
text_renderer.Draw(canvas, rc, text.c_str());
}
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 */
GLScissor scissor(OpenGL::translate.x,
OpenGL::screen_height - OpenGL::translate.y - canvas.GetHeight() - 1,
scroll_bar.GetLeft(GetSize()), canvas.GetHeight());
#endif
unsigned last_item = std::min(length, end);
const bool focused = 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.bottom - rc.top);
}
/* paint the bottom part below the last item */
rc.bottom = canvas.GetHeight();
if (rc.bottom > rc.top)
canvas.DrawFilledRectangle(rc, look.list.background_color);
}
inline void
AirspaceIntersectionVisitorSlice::RenderBox(const PixelRect rc,
AirspaceClass type) const
{
if (AirspacePreviewRenderer::PrepareFill(canvas, type, airspace_look,
settings)) {
const auto &class_settings = settings.classes[type];
// Draw thick brushed outlines
const int border_width = class_settings.fill_mode ==
AirspaceClassRendererSettings::FillMode::PADDING
? Layout::ScalePenWidth(10)
: 0;
if (border_width > 0 &&
(rc.right - rc.left) > border_width * 2 &&
(rc.bottom - rc.top) > border_width * 2) {
PixelRect border = rc;
border.Grow(-border_width);
// Left border
canvas.Rectangle(rc.left, rc.top, border.left, rc.bottom);
// Right border
canvas.Rectangle(border.right, rc.top, rc.right, rc.bottom);
// Bottom border
canvas.Rectangle(border.left, border.bottom, border.right, rc.bottom);
// Top border
canvas.Rectangle(border.left, rc.top, border.right, border.top);
} else {
// .. or fill the entire rect if the outlines would overlap
canvas.Rectangle(rc.left, rc.top, rc.right, rc.bottom);
}
AirspacePreviewRenderer::UnprepareFill(canvas);
}
// Use transparent brush and type-dependent pen for the outlines
if (AirspacePreviewRenderer::PrepareOutline(canvas, type, airspace_look,
settings))
canvas.Rectangle(rc.left, rc.top, rc.right, rc.bottom);
}
void
NextArrowRenderer::DrawArrow(Canvas &canvas, const PixelRect &rc,
Angle angle)
{
/*
* Define arrow geometry for forward pointing arrow.
* These are the coordinates of the corners, relative to the center (o)
*
* + (0,-head_len)
* / \
* / \
* / \
* (-head_width,-head_base) +-+ +-+ (head_width,-head_base)
* (-tail_width,-head_base) | o | (tail_width,-head_base)
* | |
* | |
* (-tail_width,tail_len) +---+ (tail_width,tail_len)
*
* The "tail" of the arrow is slightly shorter than the "head" to avoid
* the corners of the tail to stick out of the bounding PixelRect.
*/
static constexpr auto head_len = 50;
static constexpr auto head_width = 36;
static constexpr auto head_base = head_len - head_width;
static constexpr auto tail_width = 16;
static constexpr auto tail_len = head_len - tail_width / 2;
// An array of the arrow corner coordinates.
RasterPoint arrow[] = {
{ 0, -head_len },
{ head_width, -head_base },
{ tail_width, -head_base },
{ tail_width, tail_len },
{ -tail_width, tail_len },
{ -tail_width, -head_base },
{ -head_width, -head_base },
};
/*
* Rotate the arrow, center it in the bounding rectangle, and scale
* it to fill the rectangle.
*
* Note that PolygonRotateShift scales a polygon with coordinates
* in the range -50 to +50 to fill a square with the size of the 'scale'
* argument.
*/
const auto size = std::min(rc.right - rc.left, rc.bottom - rc.top);
PolygonRotateShift(arrow, ARRAY_SIZE(arrow),
rc.GetCenter(), angle,
size, false);
// Draw the arrow.
canvas.Select(look.arrow_pen);
canvas.Select(look.arrow_brush);
canvas.DrawPolygon(arrow, ARRAY_SIZE(arrow));
}