void
MapDrawHelper::buffer_render_finish()
{
if (m_buffer_drawn) {
// need to do this to prevent drawing of colored outline
m_buffer.SelectWhitePen();
if (m_use_stencil) {
#ifdef ENABLE_SDL
m_buffer.copy_transparent_black(m_stencil);
#else
m_buffer.copy_or(m_stencil);
#endif
}
#ifdef HAVE_ALPHA_BLEND
if (settings.transparency && AlphaBlendAvailable())
m_canvas.alpha_blend(0, 0, m_canvas.get_width(), m_canvas.get_height(),
m_buffer,
0, 0, m_canvas.get_width(), m_canvas.get_height(),
60);
else
#endif
m_canvas.copy_and(m_buffer);
m_buffer_drawn = false;
}
}
void
AirspaceLook::Initialise(const AirspaceRendererSettings &settings)
{
for (unsigned i = 0; i < AIRSPACECLASSCOUNT; i++)
pens[i].set(Layout::Scale(2),
colors[settings.colours[i]]);
// airspace brushes and colors
#ifdef HAVE_HATCHED_BRUSH
bitmaps[0].load(IDB_AIRSPACE0);
bitmaps[1].load(IDB_AIRSPACE1);
bitmaps[2].load(IDB_AIRSPACE2);
bitmaps[3].load(IDB_AIRSPACE3);
bitmaps[4].load(IDB_AIRSPACE4);
bitmaps[5].load(IDB_AIRSPACE5);
bitmaps[6].load(IDB_AIRSPACE6);
bitmaps[7].load(IDB_AIRSPACE7);
for (int i = 0; i < NUMAIRSPACEBRUSHES; i++)
brushes[i].set(bitmaps[i]);
#endif
#ifdef HAVE_ALPHA_BLEND
if (AlphaBlendAvailable())
#endif
#if defined(HAVE_ALPHA_BLEND) || !defined(HAVE_HATCHED_BRUSH)
for (unsigned i = 0; i < NUMAIRSPACECOLORS; ++i)
solid_brushes[i].set(colors[i]);
#endif
intercept_icon.load_big(IDB_AIRSPACEI, IDB_AIRSPACEI_HD);
}
inline void
AirspaceRenderer::DrawFillCached(Canvas &canvas, Canvas &stencil_canvas,
const WindowProjection &projection,
const AirspaceRendererSettings &settings,
const AirspaceWarningCopy &awc,
const AirspacePredicate &visible)
{
if (awc.GetSerial() != last_warning_serial ||
!fill_cache.Check(projection)) {
last_warning_serial = awc.GetSerial();
Canvas &buffer_canvas = fill_cache.Begin(canvas, projection);
if (DrawFill(buffer_canvas, stencil_canvas,
projection, settings, awc, visible))
fill_cache.Commit(canvas, projection);
else
fill_cache.CommitEmpty();
}
#ifdef HAVE_ALPHA_BLEND
#ifdef HAVE_HATCHED_BRUSH
if (settings.transparency && AlphaBlendAvailable())
#endif
fill_cache.AlphaBlendTo(canvas, projection, 60);
#ifdef HAVE_HATCHED_BRUSH
else
#endif
#endif
#ifdef HAVE_HATCHED_BRUSH
fill_cache.CopyAndTo(canvas, projection);
#endif
}
void
MapDrawHelper::BufferRenderFinish()
{
if (buffer_drawn) {
// need to do this to prevent drawing of colored outline
buffer.SelectWhitePen();
if (use_stencil) {
#ifdef ENABLE_SDL
buffer.copy_transparent_black(stencil);
#else
buffer.CopyOr(stencil);
#endif
}
#ifdef HAVE_ALPHA_BLEND
if (settings.transparency && AlphaBlendAvailable())
canvas.AlphaBlend(0, 0, canvas.get_width(), canvas.get_height(),
buffer,
0, 0, canvas.get_width(), canvas.get_height(),
60);
else
#endif
canvas.CopyAnd(buffer);
buffer_drawn = false;
}
}
static void
OnAirspaceListEnter(unsigned index)
{
assert(index < AIRSPACECLASSCOUNT);
AirspaceComputerSettings &computer =
CommonInterface::SetComputerSettings().airspace;
AirspaceRendererSettings &renderer =
CommonInterface::SetMapSettings().airspace;
if (color_mode) {
AirspaceLook &look =
CommonInterface::main_window.SetLook().map.airspace;
int color_index = dlgAirspaceColoursShowModal();
if (color_index >= 0) {
renderer.classes[index].color = AirspaceLook::preset_colors[color_index];
ActionInterface::SendMapSettings();
Profile::SetAirspaceColor(index, renderer.classes[index].color);
changed = true;
look.Initialise(renderer);
}
#ifdef HAVE_HATCHED_BRUSH
#ifdef HAVE_ALPHA_BLEND
if (!renderer.transparency || !AlphaBlendAvailable()) {
#endif
int pattern_index = dlgAirspacePatternsShowModal(look);
if (pattern_index >= 0) {
renderer.classes[index].brush = pattern_index;
ActionInterface::SendMapSettings();
Profile::SetAirspaceBrush(index, renderer.classes[index].brush);
changed = true;
}
#ifdef HAVE_ALPHA_BLEND
}
#endif
#endif
} else {
renderer.classes[index].display = !renderer.classes[index].display;
if (!renderer.classes[index].display)
computer.warnings.class_warnings[index] =
!computer.warnings.class_warnings[index];
Profile::SetAirspaceMode(index, renderer.classes[index].display,
computer.warnings.class_warnings[index]);
changed = true;
}
airspace_list->Invalidate();
ActionInterface::SendMapSettings();
}
static void
OnAirspaceListEnter(unsigned ItemIndex)
{
assert(ItemIndex < AIRSPACECLASSCOUNT);
AirspaceComputerSettings &computer =
CommonInterface::SetComputerSettings().airspace;
AirspaceRendererSettings &renderer =
CommonInterface::SetMapSettings().airspace;
if (colormode) {
int c = dlgAirspaceColoursShowModal();
if (c >= 0) {
renderer.colours[ItemIndex] = c;
ActionInterface::SendMapSettings();
Profile::SetAirspaceColor(ItemIndex, renderer.colours[ItemIndex]);
changed = true;
AirspaceLook &look =
CommonInterface::main_window.SetLook().map.airspace;
look.Initialise(renderer);
}
#ifdef HAVE_HATCHED_BRUSH
#ifdef HAVE_ALPHA_BLEND
if (!renderer.transparency || !AlphaBlendAvailable()) {
#endif
int p = dlgAirspacePatternsShowModal();
if (p >= 0) {
renderer.brushes[ItemIndex] = p;
ActionInterface::SendMapSettings();
Profile::SetAirspaceBrush(ItemIndex, renderer.brushes[ItemIndex]);
changed = true;
}
#ifdef HAVE_ALPHA_BLEND
}
#endif
#endif
} else {
renderer.display[ItemIndex] = !renderer.display[ItemIndex];
if (!renderer.display[ItemIndex])
computer.warnings.class_warnings[ItemIndex] =
!computer.warnings.class_warnings[ItemIndex];
Profile::SetAirspaceMode(ItemIndex);
changed = true;
}
wAirspaceList->invalidate();
ActionInterface::SendMapSettings();
}
static void
OnAirspacePaintListItem(Canvas &canvas, const PixelRect rc, unsigned i)
{
assert(i < AIRSPACECLASSCOUNT);
const AirspaceComputerSettings &computer =
CommonInterface::SettingsComputer().airspace;
const AirspaceRendererSettings &renderer =
CommonInterface::SettingsMap().airspace;
int w1, w2, x0;
int w0 = rc.right - rc.left - Layout::FastScale(4);
w1 = canvas.text_width(_("Warn")) + Layout::FastScale(10);
w2 = canvas.text_width(_("Display")) + Layout::FastScale(10);
x0 = w0 - w1 - w2;
if (colormode) {
canvas.white_pen();
#ifdef ENABLE_SDL
canvas.select(Graphics::solid_airspace_brushes[renderer.colours[i]]);
#else
#ifdef HAVE_ALPHA_BLEND
if (renderer.transparency && AlphaBlendAvailable()) {
canvas.select(Graphics::solid_airspace_brushes[renderer.colours[i]]);
} else {
#endif
canvas.set_text_color(Graphics::GetAirspaceColourByClass(i, renderer));
canvas.set_background_color(Color(0xFF, 0xFF, 0xFF));
canvas.select(Graphics::GetAirspaceBrushByClass(i, renderer));
#ifdef HAVE_ALPHA_BLEND
}
#endif
#endif
canvas.rectangle(rc.left + x0, rc.top + Layout::FastScale(2),
rc.right - Layout::FastScale(2), rc.bottom - Layout::FastScale(2));
} else {
if (computer.warnings.class_warnings[i])
canvas.text(rc.left + w0 - w1 - w2, rc.top + Layout::FastScale(2),
_("Warn"));
if (renderer.display[i])
canvas.text(rc.left + w0 - w2, rc.top + Layout::FastScale(2),
_("Display"));
}
canvas.text_clipped(rc.left + Layout::FastScale(2),
rc.top + Layout::FastScale(2), x0 - Layout::FastScale(10),
airspace_class_as_text((AirspaceClass_t)i, false));
}
static void
OnAirspacePaintListItem(Canvas &canvas, const PixelRect rc, unsigned i)
{
assert(i < AIRSPACECLASSCOUNT);
const AirspaceComputerSettings &computer =
CommonInterface::GetComputerSettings().airspace;
const AirspaceRendererSettings &renderer =
CommonInterface::GetMapSettings().airspace;
const AirspaceLook &look = CommonInterface::main_window.GetLook().map.airspace;
PixelScalar w0 = rc.right - rc.left - Layout::FastScale(4);
PixelScalar w1 = canvas.CalcTextWidth(_("Warn")) + Layout::FastScale(10);
PixelScalar w2 = canvas.CalcTextWidth(_("Display")) + Layout::FastScale(10);
PixelScalar x0 = w0 - w1 - w2;
if (color_mode) {
canvas.SelectWhitePen();
#ifndef HAVE_HATCHED_BRUSH
canvas.Select(look.solid_brushes[i]);
#else
#ifdef HAVE_ALPHA_BLEND
if (renderer.transparency && AlphaBlendAvailable()) {
canvas.Select(look.solid_brushes[i]);
} else {
#endif
canvas.SetTextColor(renderer.classes[i].color);
canvas.SetBackgroundColor(Color(0xFF, 0xFF, 0xFF));
canvas.Select(look.brushes[renderer.classes[i].brush]);
#ifdef HAVE_ALPHA_BLEND
}
#endif
#endif
canvas.Rectangle(rc.left + x0, rc.top + Layout::FastScale(2),
rc.right - Layout::FastScale(2), rc.bottom - Layout::FastScale(2));
} else {
if (computer.warnings.class_warnings[i])
canvas.text(rc.left + w0 - w1 - w2, rc.top + Layout::FastScale(2),
_("Warn"));
if (renderer.classes[i].display)
canvas.text(rc.left + w0 - w2, rc.top + Layout::FastScale(2),
_("Display"));
}
canvas.text_clipped(rc.left + Layout::FastScale(2),
rc.top + Layout::FastScale(2), x0 - Layout::FastScale(10),
AirspaceFormatter::GetClass((AirspaceClass)i));
}
static void
OnAirspaceListEnter(unsigned ItemIndex)
{
assert(ItemIndex < AIRSPACECLASSCOUNT);
AirspaceComputerSettings &computer =
CommonInterface::SetSettingsComputer().airspace;
AirspaceRendererSettings &renderer =
CommonInterface::SetSettingsMap().airspace;
if (colormode) {
int c = dlgAirspaceColoursShowModal();
if (c >= 0) {
renderer.colours[ItemIndex] = c;
ActionInterface::SendSettingsMap();
Profile::SetAirspaceColor(ItemIndex, renderer.colours[ItemIndex]);
changed = true;
Graphics::InitAirspacePens(renderer);
}
#ifndef ENABLE_SDL
#ifdef HAVE_ALPHA_BLEND
if (!renderer.transparency || !AlphaBlendAvailable()) {
#endif
int p = dlgAirspacePatternsShowModal();
if (p >= 0) {
renderer.brushes[ItemIndex] = p;
ActionInterface::SendSettingsMap();
Profile::SetAirspaceBrush(ItemIndex, renderer.brushes[ItemIndex]);
changed = true;
}
#ifdef HAVE_ALPHA_BLEND
}
#endif
#endif
} else {
renderer.display[ItemIndex] = !renderer.display[ItemIndex];
if (!renderer.display[ItemIndex])
computer.warnings.class_warnings[ItemIndex] =
!computer.warnings.class_warnings[ItemIndex];
Profile::SetAirspaceMode(ItemIndex);
changed = true;
}
wAirspaceList->invalidate();
ActionInterface::SendSettingsMap();
}
void
AirspaceClassLook::Initialise(const AirspaceClassRendererSettings &settings)
{
fill_color = Color(settings.fill_color);
#ifdef HAVE_ALPHA_BLEND
if (AlphaBlendAvailable())
#endif
#if defined(HAVE_ALPHA_BLEND) || !defined(HAVE_HATCHED_BRUSH)
solid_brush.Set(fill_color);
#endif
if (settings.border_width != 0)
border_pen.Set(Layout::ScalePenWidth(settings.border_width),
Color(settings.border_color));
}
bool
AirspaceConfigPanel::Save(bool &_changed)
{
bool changed = false;
AirspaceComputerSettings &computer =
CommonInterface::SetComputerSettings().airspace;
AirspaceRendererSettings &renderer =
CommonInterface::SetMapSettings().airspace;
changed |= SaveValueEnum(AirspaceDisplay, ProfileKeys::AltMode, renderer.altitude_mode);
changed |= SaveValue(ClipAltitude, UnitGroup::ALTITUDE, ProfileKeys::ClipAlt, renderer.clip_altitude);
changed |= SaveValue(AltWarningMargin, UnitGroup::ALTITUDE, ProfileKeys::AltMargin, computer.warnings.altitude_warning_margin);
changed |= SaveValue(AirspaceWarnings, ProfileKeys::AirspaceWarning, computer.enable_warnings);
if (SaveValue(WarningTime, ProfileKeys::WarningTime, computer.warnings.warning_time)) {
changed = true;
require_restart = true;
}
if (SaveValue(AcknowledgeTime, ProfileKeys::AcknowledgementTime,
computer.warnings.acknowledgement_time)) {
changed = true;
require_restart = true;
}
changed |= SaveValue(UseBlackOutline, ProfileKeys::AirspaceBlackOutline, renderer.black_outline);
changed |= SaveValueEnum(AirspaceFillMode, ProfileKeys::AirspaceFillMode, renderer.fill_mode);
#ifndef ENABLE_OPENGL
#ifdef HAVE_ALPHA_BLEND
if (AlphaBlendAvailable())
changed |= SaveValue(AirspaceTransparency, ProfileKeys::AirspaceTransparency,
renderer.transparency);
#endif
#endif /* !OpenGL */
_changed |= changed;
return true;
}
void AlphaBlend(PixelScalar dest_x, PixelScalar dest_y,
UPixelScalar dest_width, UPixelScalar dest_height,
HDC src,
PixelScalar src_x, PixelScalar src_y,
UPixelScalar src_width, UPixelScalar src_height,
uint8_t alpha) {
assert(AlphaBlendAvailable());
BLENDFUNCTION fn;
fn.BlendOp = AC_SRC_OVER;
fn.BlendFlags = 0;
fn.SourceConstantAlpha = alpha;
fn.AlphaFormat = 0;
::AlphaBlendInvoke(dc, dest_x, dest_y, dest_width, dest_height,
src, src_x, src_y, src_width, src_height,
fn);
}
void
AirspaceClassRendererSettingsPanel::Prepare(ContainerWindow &parent, const PixelRect &rc)
{
RowFormWidget::Prepare(parent, rc);
// Save a working copy
settings = CommonInterface::GetMapSettings().airspace.classes[type];
// Add controls
AddButton(_("Change Border Color"), *this, BorderColor);
AddButton(_("Change Fill Color"), *this, FillColor);
#ifdef HAVE_HATCHED_BRUSH
#ifdef HAVE_ALPHA_BLEND
bool transparency = CommonInterface::GetMapSettings().airspace.transparency;
if (!transparency || !AlphaBlendAvailable())
#endif
AddButton(_("Change Fill Brush"), *this, FillBrush);
#ifdef HAVE_ALPHA_BLEND
else
AddDummy();
#endif
#else
AddDummy();
#endif
AddInteger(_("Border Width"),
_("The width of the border drawn around each airspace. "
"Set this value to zero to hide the border."),
_T("%d"), _T("%d"), 0, 5, 1, settings.border_width);
static constexpr StaticEnumChoice fill_mode_list[] = {
{ (unsigned)AirspaceClassRendererSettings::FillMode::ALL, N_("Filled"), },
{ (unsigned)AirspaceClassRendererSettings::FillMode::PADDING, N_("Only padding"), },
{ (unsigned)AirspaceClassRendererSettings::FillMode::NONE, N_("Not filled"), },
{ 0 }
};
AddEnum(_("Fill Mode"),
_("Defines how the airspace is filled with the configured color."),
fill_mode_list, (unsigned)settings.fill_mode);
}
void
Canvas::AlphaBlend(int dest_x, int dest_y,
unsigned dest_width, unsigned dest_height,
HDC src,
int src_x, int src_y,
unsigned src_width, unsigned src_height,
uint8_t alpha)
{
assert(AlphaBlendAvailable());
BLENDFUNCTION fn;
fn.BlendOp = AC_SRC_OVER;
fn.BlendFlags = 0;
fn.SourceConstantAlpha = alpha;
fn.AlphaFormat = 0;
::AlphaBlendInvoke(dc, dest_x, dest_y, dest_width, dest_height,
src, src_x, src_y, src_width, src_height,
fn);
}
void SetBufferPens(const AbstractAirspace &airspace) {
AirspaceClass airspace_class = airspace.GetType();
#ifndef HAVE_HATCHED_BRUSH
buffer.Select(look.solid_brushes[airspace_class]);
#else /* HAVE_HATCHED_BRUSH */
#ifdef HAVE_ALPHA_BLEND
if (settings.transparency && AlphaBlendAvailable()) {
buffer.Select(look.solid_brushes[airspace_class]);
} else {
#endif
// this color is used as the black bit
buffer.SetTextColor(LightColor(settings.classes[airspace_class].fill_color));
// get brush, can be solid or a 1bpp bitmap
buffer.Select(look.brushes[settings.classes[airspace_class].brush]);
buffer.SetBackgroundOpaque();
buffer.SetBackgroundColor(COLOR_WHITE);
#ifdef HAVE_ALPHA_BLEND
}
#endif
buffer.SelectNullPen();
if (use_stencil) {
if (warnings.HasWarning(airspace) || warnings.IsInside(airspace) ||
settings.classes[airspace_class].fill_mode ==
AirspaceClassRendererSettings::FillMode::ALL) {
stencil.SelectBlackBrush();
stencil.SelectNullPen();
} else {
stencil.Select(look.thick_pen);
stencil.SelectHollowBrush();
}
}
#endif /* HAVE_HATCHED_BRUSH */
}
void
AirspaceLook::Initialise(const AirspaceRendererSettings &settings,
const Font &_name_font)
{
for (unsigned i = 0; i < AIRSPACECLASSCOUNT; ++i) {
const AirspaceClassRendererSettings &class_settings = settings.classes[i];
if (class_settings.border_width != 0)
pens[i].Set(Layout::ScalePenWidth(class_settings.border_width),
class_settings.border_color);
#ifdef HAVE_ALPHA_BLEND
if (AlphaBlendAvailable())
#endif
#if defined(HAVE_ALPHA_BLEND) || !defined(HAVE_HATCHED_BRUSH)
solid_brushes[i].Set(class_settings.fill_color);
#endif
}
// airspace brushes and colors
#ifdef HAVE_HATCHED_BRUSH
bitmaps[0].Load(IDB_AIRSPACE0);
bitmaps[1].Load(IDB_AIRSPACE1);
bitmaps[2].Load(IDB_AIRSPACE2);
bitmaps[3].Load(IDB_AIRSPACE3);
bitmaps[4].Load(IDB_AIRSPACE4);
bitmaps[5].Load(IDB_AIRSPACE5);
bitmaps[6].Load(IDB_AIRSPACE6);
bitmaps[7].Load(IDB_AIRSPACE7);
for (unsigned i = 0; i < ARRAY_SIZE(AirspaceLook::brushes); i++)
brushes[i].Set(bitmaps[i]);
#endif
thick_pen.Set(Layout::ScalePenWidth(10), COLOR_BLACK);
intercept_icon.Load(IDB_AIRSPACEI, IDB_AIRSPACEI_HD);
name_font = &_name_font;
}
void set_buffer_pens(const AbstractAirspace &airspace) {
const unsigned color_index = settings.colours[airspace.GetType()];
#ifndef HAVE_HATCHED_BRUSH
m_buffer.Select(airspace_look.solid_brushes[color_index]);
#else /* HAVE_HATCHED_BRUSH */
#ifdef HAVE_ALPHA_BLEND
if (settings.transparency && AlphaBlendAvailable()) {
m_buffer.Select(airspace_look.solid_brushes[color_index]);
} else {
#endif
// this color is used as the black bit
m_buffer.SetTextColor(LightColor(airspace_look.colors[color_index]));
// get brush, can be solid or a 1bpp bitmap
m_buffer.Select(airspace_look.brushes[settings.brushes[airspace.GetType()]]);
m_buffer.SetBackgroundOpaque();
m_buffer.SetBackgroundColor(COLOR_WHITE);
#ifdef HAVE_ALPHA_BLEND
}
#endif
m_buffer.SelectNullPen();
if (m_warnings.is_warning(airspace) || m_warnings.is_inside(airspace)) {
m_stencil.SelectBlackBrush();
m_stencil.Select(airspace_look.medium_pen);
} else {
m_stencil.Select(airspace_look.thick_pen);
m_stencil.SelectHollowBrush();
}
#endif /* HAVE_HATCHED_BRUSH */
}
void
AirspaceLook::Initialise(const AirspaceRendererSettings &settings)
{
for (unsigned i = 0; i < AIRSPACECLASSCOUNT; i++)
pens[i].Set(Layout::ScalePenWidth(2), settings.classes[i].color);
// airspace brushes and colors
#ifdef HAVE_HATCHED_BRUSH
bitmaps[0].Load(IDB_AIRSPACE0);
bitmaps[1].Load(IDB_AIRSPACE1);
bitmaps[2].Load(IDB_AIRSPACE2);
bitmaps[3].Load(IDB_AIRSPACE3);
bitmaps[4].Load(IDB_AIRSPACE4);
bitmaps[5].Load(IDB_AIRSPACE5);
bitmaps[6].Load(IDB_AIRSPACE6);
bitmaps[7].Load(IDB_AIRSPACE7);
for (unsigned i = 0; i < ARRAY_SIZE(AirspaceLook::brushes); i++)
brushes[i].Set(bitmaps[i]);
#endif
#ifdef HAVE_ALPHA_BLEND
if (AlphaBlendAvailable())
#endif
#if defined(HAVE_ALPHA_BLEND) || !defined(HAVE_HATCHED_BRUSH)
for (unsigned i = 0; i < AIRSPACECLASSCOUNT; ++i)
solid_brushes[i].Set(settings.classes[i].color);
#endif
thick_pen.Set(Layout::ScalePenWidth(10), COLOR_BLACK);
#ifndef ENABLE_OPENGL
medium_pen.Set(Pen::SOLID, Layout::ScalePenWidth(3), COLOR_BLACK);
#endif
intercept_icon.Load(IDB_AIRSPACEI, IDB_AIRSPACEI_HD);
}
void
AirspaceConfigPanel::Prepare(ContainerWindow &parent, const PixelRect &rc)
{
const AirspaceComputerSettings &computer =
CommonInterface::GetComputerSettings().airspace;
const AirspaceRendererSettings &renderer =
CommonInterface::GetMapSettings().airspace;
RowFormWidget::Prepare(parent, rc);
AddEnum(_("Airspace display"),
_("Controls filtering of airspace for display and warnings. The airspace filter button also allows filtering of display and warnings independently for each airspace class."),
as_display_list, (unsigned)renderer.altitude_mode, this);
AddFloat(_("Clip altitude"),
_("For clip airspace mode, this is the altitude below which airspace is displayed."),
_T("%.0f %s"), _T("%.0f"), fixed(0), fixed(20000), fixed(100), false, UnitGroup::ALTITUDE, fixed(renderer.clip_altitude));
AddFloat(_("Margin"),
_("For auto and all below airspace mode, this is the altitude above/below which airspace is included."),
_T("%.0f %s"), _T("%.0f"), fixed(0), fixed(10000), fixed(100), false, UnitGroup::ALTITUDE, fixed(computer.warnings.altitude_warning_margin));
AddBoolean(_("Warnings"), _("Enable/disable all airspace warnings."),
computer.enable_warnings, this);
AddTime(_("Warning time"),
_("This is the time before an airspace incursion is estimated at which the system will warn the pilot."),
10, 1000, 5, computer.warnings.warning_time);
SetExpertRow(WarningTime);
AddTime(_("Acknowledge time"),
_("This is the time period in which an acknowledged airspace warning will not be repeated."),
10, 1000, 5, computer.warnings.acknowledgement_time);
SetExpertRow(AcknowledgeTime);
AddBoolean(_("Use black outline"),
_("Draw a black outline around each airspace rather than the airspace color."),
renderer.black_outline);
SetExpertRow(UseBlackOutline);
AddEnum(_("Airspace fill mode"),
_("Specifies the mode for filling the airspace area."),
as_fill_mode_list, (unsigned)renderer.fill_mode);
SetExpertRow(AirspaceFillMode);
#if !defined(ENABLE_OPENGL) && defined(HAVE_ALPHA_BLEND)
if (AlphaBlendAvailable()) {
AddBoolean(_("Airspace transparency"), _("If enabled, then airspaces are filled transparently."),
renderer.transparency);
SetExpertRow(AirspaceTransparency);
}
#endif
buttonColors = ConfigPanel::GetExtraButton(1);
assert(buttonColors != NULL);
buttonMode = ConfigPanel::GetExtraButton(2);
assert(buttonMode != NULL);
ShowDisplayControls(renderer.altitude_mode); // TODO make this work the first time
ShowWarningControls(computer.enable_warnings);
}
