void BeveledRoundedRectangle(Pt ul, Pt lr, Clr color, Clr border_color, bool up, unsigned int corner_radius/* = 5*/, unsigned int bevel_thick/* = 2*/)
{
RoundedRectangle(ul, lr, color,
(up ? LightColor(border_color) : DarkColor(border_color)),
(up ? DarkColor(border_color) : LightColor(border_color)),
corner_radius, bevel_thick);
}
void Bubble(Pt ul, Pt lr, Clr color, bool up/* = true*/)
{
BubbleArc(ul, lr, color,
(up ? DarkColor(color) : LightColor(color)),
(up ? LightColor(color) : DarkColor(color)),
0, 0);
}
void BeveledCircle(Pt ul, Pt lr, Clr color, Clr border_color, bool up/* = true*/, unsigned int bevel_thick/* = 2*/)
{
CircleArc(ul, lr, color,
(up ? DarkColor(border_color) : LightColor(border_color)),
(up ? LightColor(border_color) : DarkColor(border_color)),
bevel_thick, 0, 0);
}
void BubbleRectangle(Pt ul, Pt lr, Clr color, bool up, unsigned int corner_radius/* = 5*/)
{
::BubbleRectangle(ul, lr, color,
(up ? LightColor(color) : DarkColor(color)),
(up ? DarkColor(color) : LightColor(color)),
corner_radius);
}
void
HorizonRenderer::Draw(Canvas &canvas, const PixelRect &rc, const NMEAInfo &Basic)
{
/*
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.
*/
RasterPoint center;
center.y = (rc.top + rc.bottom) / 2;
center.x = (rc.left + rc.right) / 2;
const int radius = min(rc.right - rc.left, rc.bottom - rc.top) / 2 -
Layout::Scale(1);
Pen hpHorizonSky(Layout::Scale(1), DarkColor(Graphics::skyColor));
Brush hbHorizonSky(Graphics::skyColor);
Pen hpHorizonGround(Layout::Scale(1), DarkColor(Graphics::GroundColor));
#define fixed_div fixed(1.0 / 50.0)
#define fixed_89 fixed_int_constant(89)
fixed phi = max(-fixed_89,
min(fixed_89, Basic.acceleration.bank_angle.Degrees()));
fixed alpha = fixed_rad_to_deg * acos(max(-fixed_one,min(fixed_one,
Basic.acceleration.pitch_angle.Degrees() * fixed_div)));
fixed sphi = fixed_180 - phi;
Angle alpha1 = Angle::Degrees(sphi - alpha);
Angle alpha2 = Angle::Degrees(sphi + alpha);
// draw sky part
canvas.Select(hpHorizonSky);
canvas.Select(hbHorizonSky);
canvas.DrawSegment(center.x, center.y, radius, alpha2, alpha1, true);
// draw ground part
canvas.Select(hpHorizonGround);
canvas.Select(Graphics::hbGround);
canvas.DrawSegment(center.x, center.y, radius, alpha1, alpha2, true);
// draw aircraft symbol
Pen aircraft_pen(Layout::Scale(2), COLOR_BLACK);
canvas.Select(aircraft_pen);
canvas.line(center.x + radius / 2, center.y, center.x - radius / 2, center.y);
canvas.line(center.x, center.y - radius / 4, center.x, center.y);
// draw 45 degree dash marks
const UPixelScalar rr2p = uround(radius * fixed_sqrt_half) + Layout::Scale(1);
const UPixelScalar rr2n = rr2p - Layout::Scale(2);
canvas.line(center.x + rr2p, center.y - rr2p,
center.x + rr2n, center.y - rr2n);
canvas.line(center.x - rr2p, center.y - rr2p,
center.x - rr2n, center.y - rr2n);
}
void BeveledRectangle(Pt ul, Pt lr, Clr color, Clr border_color, bool up, unsigned int bevel_thick/* = 2*/,
bool bevel_left/* = true*/, bool bevel_top/* = true*/, bool bevel_right/* = true*/, bool bevel_bottom/* = true*/)
{
Rectangle(ul, lr, color,
(up ? LightColor(border_color) : DarkColor(border_color)),
(up ? DarkColor(border_color) : LightColor(border_color)),
bevel_thick, bevel_left, bevel_top, bevel_right, bevel_bottom);
}
/**
* Returns a darker version of the specified color.
*/
static inline constexpr Color
DarkColor(Color c)
{
#ifdef GREYSCALE
return Color(DarkColor(c.GetLuminosity()));
#else
return Color(DarkColor(c.Red()), DarkColor(c.Green()),
DarkColor(c.Blue()));
#endif
}
void
HorizonLook::Initialise()
{
aircraft_pen.Create(Layout::Scale(2), COLOR_BLACK);
sky_color = Color(0x0a, 0xb9, 0xf3);
sky_brush.Create(sky_color);
sky_pen.Create(Layout::Scale(1), DarkColor(sky_color));
terrain_color = Color(0x80, 0x45, 0x15);
terrain_brush.Create(terrain_color);
terrain_pen.Create(Layout::Scale(1), DarkColor(terrain_color));
}
void
Canvas::DrawButton(PixelRect rc, bool down)
{
const Pen old_pen = pen;
Color gray = COLOR_LIGHT_GRAY;
DrawFilledRectangle(rc, gray);
Pen bright(1, LightColor(gray));
Pen dark(1, DarkColor(gray));
Select(down ? dark : bright);
DrawTwoLines(rc.left, rc.bottom - 2, rc.left, rc.top,
rc.right - 2, rc.top);
DrawTwoLines(rc.left + 1, rc.bottom - 3, rc.left + 1, rc.top + 1,
rc.right - 3, rc.top + 1);
Select(down ? bright : dark);
DrawTwoLines(rc.left + 1, rc.bottom - 1, rc.right - 1, rc.bottom - 1,
rc.right - 1, rc.top + 1);
DrawTwoLines(rc.left + 2, rc.bottom - 2, rc.right - 2, rc.bottom - 2,
rc.right - 2, rc.top + 2);
pen = old_pen;
}
void
VarioBarLook::Initialise(const Font &_font)
{
const uint8_t alpha = 0xA0;
brush_sink.Set(ColorWithAlpha(COLOR_RED, alpha));
brush_sink_avg.Set(ColorWithAlpha(LightColor(COLOR_RED), alpha));
pen_sink.Set(Layout::ScalePenWidth(1), DarkColor(COLOR_RED));
brush_climb.Set(ColorWithAlpha(COLOR_GREEN, alpha));
brush_climb_avg.Set(ColorWithAlpha((LightColor(LightColor(COLOR_GREEN))), alpha));
pen_climb.Set(Layout::ScalePenWidth(1), DarkColor(COLOR_GREEN));
brush_mc.Set(ColorWithAlpha(COLOR_GRAY, alpha));
pen_mc.Set(Layout::ScalePenWidth(1), DarkColor(COLOR_GRAY));
font = &_font;
}
void
ThermalBandLook::Initialise(bool _inverse, Color sky_color)
{
const uint8_t alpha = ALPHA_OVERLAY;
inverse = _inverse;
brush_active.Create(ColorWithAlpha(sky_color, alpha));
brush_inactive.Create(ColorWithAlpha(DarkColor(sky_color), alpha/2));
pen_active.Create(Layout::ScalePenWidth(1), DarkColor(sky_color));
pen_inactive.Create(Layout::ScalePenWidth(1), sky_color);
white_pen.Create(Layout::ScalePenWidth(2), COLOR_WHITE);
black_pen.Create(Layout::ScalePenWidth(2), COLOR_BLACK);
working_band_pen.Create(Layout::ScalePenWidth(2), COLOR_GRAY);
}
void
AircraftLook::Initialise()
{
aircraft_pen.Set(1, COLOR_DARK_GRAY);
aircraft_simple1_pen.Set(Layout::Scale(1), COLOR_BLACK);
aircraft_simple2_pen.Set(Layout::Scale(3), COLOR_WHITE);
canopy_pen.Set(1, DarkColor(COLOR_CYAN));
canopy_brush.Set(COLOR_CYAN);
}
void
ThermalBandLook::Initialise(bool _inverse, Color sky_color)
{
inverse = _inverse;
brush.Create(ColorWithAlpha(sky_color, 0xA0));
pen.Create(Layout::ScalePenWidth(1), DarkColor(sky_color));
white_pen.Create(2, COLOR_WHITE);
black_pen.Create(2, COLOR_BLACK);
}
void
ButtonLook::Initialise(const Font &_font)
{
font = &_font;
standard.foreground_color = COLOR_BLACK;
standard.foreground_brush.Set(standard.foreground_color);
standard.background_color = COLOR_LIGHT_GRAY;
standard.light_border_pen.Set(1, LightColor(standard.background_color));
standard.dark_border_pen.Set(1, DarkColor(standard.background_color));
focused.foreground_color = COLOR_WHITE;
focused.foreground_brush.Set(focused.foreground_color);
focused.background_color = COLOR_XCSOAR_DARK;
focused.light_border_pen.Set(1, LightColor(focused.background_color));
focused.dark_border_pen.Set(1, DarkColor(focused.background_color));
disabled.color = COLOR_GRAY;
disabled.brush.Set(disabled.color);
}
std::shared_ptr<GG::StateButton> CUIStyle::NewTabBarTab(
const std::string& str, const std::shared_ptr<GG::Font>& font,
GG::Flags<GG::TextFormat> format, GG::Clr color,
GG::Clr text_color/* = GG::CLR_BLACK*/) const
{
auto retval = GG::Wnd::Create<CUIStateButton>(str, format, std::make_shared<CUITabRepresenter>());
retval->SetColor(ClientUI::WndColor());
retval->GetLabel()->SetTextColor(DarkColor(ClientUI::TextColor()));
retval->Resize(retval->MinUsableSize() + GG::Pt(GG::X(12), GG::Y0));
return retval;
}
void
AircraftLook::Initialise()
{
// Note: No scaling needed. Pens are used with CanvasRotateShift, which
// applies Layout::scale.
aircraft_pen.Create(1, COLOR_DARK_GRAY);
aircraft_simple1_pen.Create(1, COLOR_BLACK);
aircraft_simple2_pen.Create(3, COLOR_WHITE);
canopy_pen.Create(1, DarkColor(COLOR_CYAN));
canopy_brush.Create(COLOR_CYAN);
}
void
WindArrowLook::Initialise(const Font &_font, bool inverse)
{
arrow_pen.Create(Layout::Scale(1),
inverse
? (HasColors() ? LightColor(COLOR_GRAY) : COLOR_WHITE)
: (HasColors() ? DarkColor(COLOR_GRAY) : COLOR_BLACK));
tail_pen.Create(Pen::DASH2, 1, inverse ? COLOR_WHITE : COLOR_BLACK);
arrow_brush.Create(IsDithered() ? COLOR_DARK_GRAY : COLOR_GRAY);
font = &_font;
}
void
TaskLook::Initialise()
{
// Magenta ICAO color is 0x65,0x23,0x1c
const Color task_color = Color(0x62, 0x4e, 0x90);
const Color bearing_color = Color(0x3e, 0x30, 0x5f);
const Color isoline_color = bearing_color;
oz_current_pen.Create(Pen::SOLID, Layout::ScalePenWidth(2), task_color);
oz_active_pen.Create(Pen::SOLID, Layout::ScalePenWidth(1), task_color);
oz_inactive_pen.Create(Pen::SOLID, Layout::ScalePenWidth(1),
DarkColor(task_color));
leg_active_pen.Create(Pen::DASH, Layout::ScalePenWidth(2), task_color);
leg_inactive_pen.Create(Pen::DASH, Layout::ScalePenWidth(1), task_color);
arrow_pen.Create(Layout::ScalePenWidth(1), task_color);
isoline_pen.Create(Pen::DASH, Layout::ScalePenWidth(1), isoline_color);
bearing_pen.Create(Layout::ScalePenWidth(2),
HasColors() ? bearing_color : COLOR_BLACK);
best_cruise_track_brush.Create(bearing_color);
best_cruise_track_pen.Create(Layout::ScalePenWidth(1),
HasColors()
? DarkColor(bearing_color)
: COLOR_BLACK);
highlight_pen.Create(Layout::ScalePenWidth(4), COLOR_BLACK);
target_icon.LoadResource(IDB_TARGET, IDB_TARGET_HD);
hbGray.Create(COLOR_GRAY);
hbGreen.Create(COLOR_GREEN);
hbOrange.Create(COLOR_ORANGE);
hbLightGray.Create(COLOR_LIGHT_GRAY);
hbNotReachableTerrain.Create(LightColor(COLOR_RED));
}
void
ButtonLook::Initialise(const Font &_font)
{
font = &_font;
standard.foreground_color = COLOR_BLACK;
standard.foreground_brush.Set(standard.foreground_color);
standard.background_color = IsDithered() ? COLOR_WHITE : COLOR_LIGHT_GRAY;
if (IsDithered()) {
standard.light_border_pen.Set(1, COLOR_BLACK);
standard.dark_border_pen.Set(1, COLOR_BLACK);
} else if (!HasColors()) {
standard.light_border_pen.Set(1, LightColor(COLOR_DARK_GRAY));
standard.dark_border_pen.Set(1, COLOR_BLACK);
} else {
standard.light_border_pen.Set(1, LightColor(standard.background_color));
standard.dark_border_pen.Set(1, DarkColor(standard.background_color));
}
focused.foreground_color = COLOR_WHITE;
focused.foreground_brush.Set(focused.foreground_color);
focused.background_color = IsDithered() ? COLOR_BLACK : COLOR_XCSOAR_DARK;
if (IsDithered()) {
focused.light_border_pen.Set(1, COLOR_WHITE);
focused.dark_border_pen.Set(1, COLOR_WHITE);
} else if (!HasColors()) {
focused.light_border_pen.Set(1, LightColor(COLOR_DARK_GRAY));
focused.dark_border_pen.Set(1, COLOR_BLACK);
} else {
focused.light_border_pen.Set(1, LightColor(focused.background_color));
focused.dark_border_pen.Set(1, DarkColor(focused.background_color));
}
disabled.color = COLOR_GRAY;
disabled.brush.Set(disabled.color);
}
void BeveledX(Pt ul, Pt lr, Clr color)
{ XMark(ul, lr, color, LightColor(color), DarkColor(color)); }
void BeveledCheck(Pt ul, Pt lr, Clr color)
{ Check(ul, lr, color, LightColor(color), DarkColor(color)); }
COLORREF TranslateColor(COLORREF clr, int nTransalte)
{
return nTransalte == 0 ? clr : nTransalte > 0 ? LightColor(clr, nTransalte) : DarkColor(clr, nTransalte);
}
#include "Renderer/AirspaceRendererSettings.hpp"
#include "resource.h"
#include "Util/Macros.hpp"
#ifdef USE_GDI
#include "Screen/GDI/AlphaBlend.hpp"
#endif
const Color AirspaceLook::preset_colors[] = {
COLOR_RED,
COLOR_GREEN,
COLOR_BLUE,
COLOR_YELLOW,
COLOR_MAGENTA,
COLOR_CYAN,
DarkColor(COLOR_RED),
DarkColor(COLOR_GREEN),
DarkColor(COLOR_BLUE),
DarkColor(COLOR_YELLOW),
DarkColor(COLOR_MAGENTA),
DarkColor(COLOR_CYAN),
COLOR_WHITE,
COLOR_LIGHT_GRAY,
COLOR_GRAY,
COLOR_BLACK,
};
void
AirspaceLook::Initialise(const AirspaceRendererSettings &settings)
{
for (unsigned i = 0; i < AIRSPACECLASSCOUNT; ++i) {
