void
TargetMapWindow::DrawTask(Canvas &canvas)
{
if (task == NULL)
return;
ProtectedTaskManager::Lease task_manager(*task);
const AbstractTask *task = task_manager->GetActiveTask();
if (task && task->CheckTask()) {
OZRenderer ozv(task_look, airspace_renderer.GetLook(),
GetMapSettings().airspace);
RenderTaskPoint tpv(canvas,
projection,
task_look,
/* we're accessing the OrderedTask here,
which may be invalid at this point, but it
will be used only if active, so it's ok */
task_manager->GetOrderedTask().GetTaskProjection(),
ozv, false, RenderTaskPoint::ALL,
Basic().location);
TaskRenderer dv(tpv, projection.GetScreenBounds());
dv.Draw(*task);
}
}
void
TargetMapWindow::DrawTask(Canvas &canvas)
{
if (task == NULL)
return;
ProtectedTaskManager::Lease task_manager(*task);
const AbstractTask *task = task_manager->get_active_task();
if (task && task->check_task()) {
RenderObservationZone ozv(task_look, airspace_renderer.GetLook());
RenderTaskPointMap tpv(canvas,
#ifdef ENABLE_OPENGL
/* OpenGL doesn't have the BufferCanvas
class */
NULL,
#else
&buffer_canvas,
#endif
projection,
SettingsMap(),
task_look,
/* we're accessing the OrderedTask here,
which may be invalid at this point, but it
will be used only if active, so it's ok */
task_manager->get_ordered_task().get_task_projection(),
ozv, false, true,
Basic().location);
RenderTask dv(tpv, projection.GetScreenBounds());
((TaskVisitor &)dv).Visit(*task);
}
}
void
OZPreviewRenderer::Draw(Canvas &canvas, const ObservationZonePoint &oz,
const RasterPoint pt, unsigned radius,
const TaskLook &look,
const AirspaceRendererSettings &airspace_settings,
const AirspaceLook &airspace_look)
{
fixed scale;
GeoPoint center;
if (IsAncientHardware()) {
scale = fixed(radius) / ((const CylinderZone &)oz).GetRadius();
center = oz.GetReference();
} else {
OZBoundary boundary = oz.GetBoundary();
auto it = boundary.begin();
GeoBounds bounds(*it);
for (auto it_end = boundary.end(); it != it_end; ++it)
bounds.Extend(*it);
center = bounds.GetCenter();
fixed geo_heigth = GeoPoint(center.longitude, bounds.north).Distance(
GeoPoint(center.longitude, bounds.south));
fixed geo_width = GeoPoint(bounds.west, center.latitude).Distance(
GeoPoint(bounds.east, center.latitude));
scale = fixed(radius * 2) / std::max(geo_heigth, geo_width);
}
WindowProjection projection;
projection.SetScreenSize(radius * 2, radius * 2);
projection.SetScreenOrigin(pt.x, pt.y);
projection.SetGeoLocation(center);
projection.SetScale(scale);
projection.SetScreenAngle(Angle::Zero());
projection.UpdateScreenBounds();
OZRenderer ozv(look, airspace_look, airspace_settings);
ozv.Draw(canvas, OZRenderer::LAYER_SHADE, projection, oz, 1);
ozv.Draw(canvas, OZRenderer::LAYER_INACTIVE, projection, oz, 1);
ozv.Draw(canvas, OZRenderer::LAYER_ACTIVE, projection, oz, 1);
}
void
MapWindow::DrawTask(Canvas &canvas)
{
if (task == NULL)
return;
/* RLD bearing is invalid if GPS not connected and in non-sim mode,
but we can still draw targets */
bool draw_bearing = Basic().track_available;
bool draw_route = draw_bearing;
if (draw_bearing) {
if (Calculated().planned_route.size()>2) {
draw_bearing = false;
} else {
draw_route = false;
}
}
ProtectedTaskManager::Lease task_manager(*task);
const AbstractTask *task = task_manager->GetActiveTask();
if (task && task->CheckTask()) {
RenderTaskPoint::TargetVisibility target_visibility =
IsNearSelf() ? RenderTaskPoint::ACTIVE : RenderTaskPoint::ALL;
OZRenderer ozv(look.task, airspace_renderer.GetLook(),
GetMapSettings().airspace);
RenderTaskPoint tpv(canvas,
render_projection,
look.task,
/* we're accessing the OrderedTask here,
which may be invalid at this point, but it
will be used only if active, so it's ok */
task_manager->GetOrderedTask().GetTaskProjection(),
ozv, draw_bearing,
target_visibility,
Basic().location);
TaskRenderer dv(tpv, render_projection.GetScreenBounds());
dv.Draw(*task);
}
if (draw_route)
DrawRoute(canvas);
}
static void
PaintTask(Canvas &canvas, const WindowProjection &projection,
const OrderedTask &task,
const GeoPoint &location, const SETTINGS_MAP &settings_map,
const TaskLook &task_look,
const AirspaceLook &airspace_look,
const RasterTerrain *terrain)
{
BackgroundDrawHelper background;
background.set_terrain(terrain);
background.Draw(canvas, projection, settings_map.terrain);
RenderObservationZone ozv(task_look, airspace_look);
RenderTaskPoint tpv(canvas, NULL, projection, settings_map, task_look,
task.get_task_projection(),
ozv, false, false, location);
RenderTask dv(tpv, projection.GetScreenBounds());
dv.Visit(task);
}
static void
PaintTask(Canvas &canvas, const WindowProjection &projection,
const OrderedTask &task,
const GeoPoint &location, const MapSettings &settings_map,
const TaskLook &task_look,
const AirspaceLook &airspace_look,
const RasterTerrain *terrain)
{
BackgroundRenderer background;
background.SetTerrain(terrain);
background.Draw(canvas, projection, settings_map.terrain);
OZRenderer ozv(task_look, airspace_look, settings_map.airspace);
RenderTaskPoint tpv(canvas, projection, task_look,
task.GetTaskProjection(),
ozv, false, RenderTaskPoint::NONE, location);
TaskRenderer dv(tpv, projection.GetScreenBounds());
dv.Draw(task);
}
static void
PaintTask(Canvas &canvas, const WindowProjection &projection,
const OrderedTask &task,
const GeoPoint &location, const MapSettings &settings_map,
const TaskLook &task_look,
const AirspaceLook &airspace_look,
const RasterTerrain *terrain, const Airspaces *airspaces)
{
BackgroundRenderer background;
background.SetTerrain(terrain);
background.Draw(canvas, projection, settings_map.terrain);
if (airspaces != NULL) {
AirspaceRenderer airspace_renderer(airspace_look);
airspace_renderer.SetAirspaces(airspaces);
#ifndef ENABLE_OPENGL
BufferCanvas buffer_canvas, stencil_canvas;
buffer_canvas.set(canvas);
stencil_canvas.set(canvas);
#endif
airspace_renderer.Draw(canvas,
#ifndef ENABLE_OPENGL
buffer_canvas, stencil_canvas,
#endif
projection,
settings_map.airspace);
}
#ifdef ENABLE_OPENGL
/* desaturate the map background, to focus on the task */
canvas.FadeToWhite(0xc0);
#endif
OZRenderer ozv(task_look, airspace_look, settings_map.airspace);
RenderTaskPoint tpv(canvas, projection, task_look,
task.GetTaskProjection(),
ozv, false, RenderTaskPoint::NONE, location);
TaskRenderer dv(tpv, projection.GetScreenBounds());
dv.Draw(task);
}
void
OZPreviewRenderer::Draw(Canvas &canvas, const ObservationZonePoint &oz,
const PixelPoint pt, unsigned radius,
const TaskLook &look,
const AirspaceRendererSettings &airspace_settings,
const AirspaceLook &airspace_look)
{
double scale;
GeoPoint center;
if (IsAncientHardware()) {
scale = double(radius) / ((const CylinderZone &)oz).GetRadius();
center = oz.GetReference();
} else {
OZBoundary boundary = oz.GetBoundary();
GeoBounds bounds = GeoBounds::Invalid();
for (auto i = boundary.begin(), end = boundary.end(); i != end; ++i)
bounds.Extend(*i);
center = bounds.GetCenter();
auto geo_width = bounds.GetGeoWidth();
auto geo_heigth = bounds.GetGeoHeight();
scale = double(radius * 2) / std::max(geo_heigth, geo_width);
}
WindowProjection projection;
projection.SetScreenSize({radius * 2, radius * 2});
projection.SetScreenOrigin(pt.x, pt.y);
projection.SetGeoLocation(center);
projection.SetScale(scale);
projection.SetScreenAngle(Angle::Zero());
projection.UpdateScreenBounds();
OZRenderer ozv(look, airspace_look, airspace_settings);
ozv.Draw(canvas, OZRenderer::LAYER_SHADE, projection, oz, 1);
ozv.Draw(canvas, OZRenderer::LAYER_INACTIVE, projection, oz, 1);
ozv.Draw(canvas, OZRenderer::LAYER_ACTIVE, projection, oz, 1);
}
void
PaintTask(Canvas &canvas, const WindowProjection &projection,
const OrderedTask &task,
const GeoPoint &location,
const MapSettings &settings_map,
const TaskLook &task_look,
const AirspaceLook &airspace_look,
const RasterTerrain *terrain, const Airspaces *airspaces,
bool fai_sectors,
int highlight_index)
{
BackgroundRenderer background;
background.SetTerrain(terrain);
background.Draw(canvas, projection, settings_map.terrain);
if (airspaces != NULL) {
AirspaceRenderer airspace_renderer(airspace_look);
airspace_renderer.SetAirspaces(airspaces);
#ifndef ENABLE_OPENGL
BufferCanvas stencil_canvas;
stencil_canvas.Create(canvas);
#endif
airspace_renderer.Draw(canvas,
#ifndef ENABLE_OPENGL
stencil_canvas,
#endif
projection, settings_map.airspace);
}
#ifdef ENABLE_OPENGL
/* desaturate the map background, to focus on the task */
canvas.FadeToWhite(0xc0);
#endif
if (fai_sectors && IsFAITriangleApplicable(task)) {
static constexpr Color fill_color = COLOR_YELLOW;
#if defined(ENABLE_OPENGL) || defined(USE_MEMORY_CANVAS)
#ifdef ENABLE_OPENGL
const ScopeAlphaBlend alpha_blend;
#endif
canvas.Select(Brush(fill_color.WithAlpha(40)));
canvas.Select(Pen(1, COLOR_BLACK.WithAlpha(80)));
RenderFAISectors(canvas, projection, task);
#else
BufferCanvas buffer_canvas;
buffer_canvas.Create(canvas);
buffer_canvas.ClearWhite();
#ifdef HAVE_HATCHED_BRUSH
buffer_canvas.Select(airspace_look.brushes[3]);
buffer_canvas.SetTextColor(fill_color);
buffer_canvas.SetBackgroundColor(COLOR_WHITE);
#else
buffer_canvas.Select(Brush(fill_color));
#endif
buffer_canvas.SelectNullPen();
RenderFAISectors(buffer_canvas, projection, task);
canvas.CopyAnd(buffer_canvas);
canvas.SelectHollowBrush();
canvas.SelectBlackPen();
RenderFAISectors(canvas, projection, task);
#endif
}
OZRenderer ozv(task_look, airspace_look, settings_map.airspace);
TaskPointRenderer tpv(canvas, projection, task_look,
task.GetTaskProjection(),
ozv, false, TaskPointRenderer::NONE,
location);
TaskRenderer dv(tpv, projection.GetScreenBounds());
dv.Draw(task);
// highlight a task point
if (highlight_index >= 0 && highlight_index < (int) task.TaskSize()) {
/* TODO: clumsy way of highlighting. maybe it should be done by
* painting the task point with a different pen and brush,
* e.g. red, 4px wide
*/
auto pt = projection.GeoToScreen(task.GetPoint(highlight_index).
GetLocation());
canvas.Select(task_look.highlight_pen);
canvas.DrawLine(pt.x - 7, pt.y - 7, pt.x + 7, pt.y + 7);
canvas.DrawLine(pt.x + 7, pt.y - 7, pt.x - 7, pt.y + 7);
}
}
