bool
dlgTaskPointType(OrderedTask &task, const unsigned index)
{
point_types.clear();
task.GetFactory().GetValidTypes(index)
.CopyTo(std::back_inserter(point_types));
if (point_types.empty()) {
assert(1);
return false;
}
if (point_types.size() == 1)
return SetPointType(task, index, point_types[0]);
const auto &point = task.GetPoint(index);
const auto current_type = task.GetFactory().GetType(point);
unsigned initial_index = 0;
const auto b = point_types.begin(), e = point_types.end();
auto i = std::find(b, e, current_type);
if (i != e)
initial_index = std::distance(b, i);
MutateTaskPointRenderer item_renderer(current_type);
int result = ListPicker(_("Task Point Type"),
point_types.size(), initial_index,
item_renderer.CalculateLayout(UIGlobals::GetDialogLook()),
item_renderer, false,
nullptr, TPTypeItemHelp);
return result >= 0 && SetPointType(task, index, point_types[result]);
}
static void
RenderFAISectors(Canvas &canvas, const WindowProjection &projection,
const OrderedTask &task)
{
const FAITriangleSettings &settings =
task.GetOrderedTaskSettings().fai_triangle;
const unsigned size = task.TaskSize();
const unsigned end = size - 1;
for (unsigned i = 0; i != end; ++i)
RenderFAISector(canvas, projection,
task.GetPoint(i).GetLocation(),
task.GetPoint(i + 1).GetLocation(),
true, settings);
for (unsigned i = 0; i != end; ++i)
RenderFAISector(canvas, projection,
task.GetPoint(i).GetLocation(),
task.GetPoint(i + 1).GetLocation(),
false, settings);
}
inline void
TaskPointWidget::OnRelocateClicked()
{
const GeoPoint &gpBearing = active_index > 0
? ordered_task->GetPoint(active_index - 1).GetLocation()
: CommonInterface::Basic().location;
const Waypoint *wp = ShowWaypointListDialog(gpBearing,
ordered_task, active_index);
if (wp == nullptr)
return;
ordered_task->GetFactory().Relocate(active_index, *wp);
ordered_task->ClearName();
task_modified = true;
RefreshView();
}
void
TaskPointWidget::PaintMap(Canvas &canvas, const PixelRect &rc)
{
const OrderedTaskPoint &tp = ordered_task->GetPoint(active_index);
#ifdef ENABLE_OPENGL
/* enable clipping */
GLCanvasScissor scissor(canvas);
#endif
const MapLook &look = UIGlobals::GetMapLook();
const NMEAInfo &basic = CommonInterface::Basic();
PaintTaskPoint(canvas, rc, *ordered_task, tp,
basic.location_available
? basic.location : GeoPoint::Invalid(),
CommonInterface::GetMapSettings(),
look.task, look.airspace,
terrain, &airspace_database);
}
bool
TaskPointWidget::ReadValues()
{
OrderedTaskPoint &tp = ordered_task->GetPoint(active_index);
if (tp.GetType() == TaskPointType::AST) {
const bool new_score_exit = score_exit.GetState();
ASTPoint &ast = (ASTPoint &)tp;
if (new_score_exit != ast.GetScoreExit()) {
ast.SetScoreExit(new_score_exit);
ordered_task->ClearName();
task_modified = true;
}
}
return properties_widget == nullptr ||
properties_widget->Save(task_modified);
}
static int
GetIndexInTask(const OrderedTask &task, const Waypoint &waypoint)
{
if (task.TaskSize() == 0)
return -1;
unsigned i = task.GetActiveIndex();
if (i >= task.TaskSize())
return -1;
int TPindex = -1;
for (unsigned i = task.TaskSize(); i--;) {
const OrderedTaskPoint &tp = task.GetPoint(i);
if (tp.GetWaypoint() == waypoint) {
TPindex = i;
break;
}
}
return TPindex;
}
void
TaskEditPanel::EditTaskPoint(unsigned ItemIndex)
{
if (ItemIndex < ordered_task->TaskSize()) {
if (dlgTaskPointShowModal(*ordered_task, ItemIndex)) {
*task_modified = true;
ordered_task->ClearName();
ordered_task->UpdateGeometry();
RefreshView();
}
} else if (!ordered_task->IsFull()) {
OrderedTaskPoint* point = nullptr;
AbstractTaskFactory &factory = ordered_task->GetFactory();
const Waypoint* way_point =
ShowWaypointListDialog(ordered_task->TaskSize() > 0
? ordered_task->GetPoint(ordered_task->TaskSize() - 1).GetLocation()
: CommonInterface::Basic().location,
ordered_task, ItemIndex);
if (!way_point)
return;
if (ItemIndex == 0) {
point = (OrderedTaskPoint*)factory.CreateStart(*way_point);
} else {
point = (OrderedTaskPoint*)factory.CreateIntermediate(*way_point);
}
if (point == nullptr)
return;
if (factory.Append(*point, true)) {
*task_modified = true;
ordered_task->ClearName();
ordered_task->UpdateGeometry();
RefreshView();
}
delete point;
}
}
/**
* @return true if the task was modified
*/
static bool
SetPointType(OrderedTask &task, unsigned index,
TaskPointFactoryType type)
{
AbstractTaskFactory &factory = task.GetFactory();
const auto &old_point = task.GetPoint(index);
const auto current_type = factory.GetType(old_point);
if (type == current_type)
// no change
return false;
bool task_modified = false;
auto point = factory.CreateMutatedPoint(old_point, type);
if (point == nullptr)
return false;
if (factory.Replace(*point, index, true))
task_modified = true;
delete point;
return task_modified;
}
inline void
TaskPointWidget::OnDetailsClicked()
{
const OrderedTaskPoint &task_point = ordered_task->GetPoint(active_index);
dlgWaypointDetailsShowModal(task_point.GetWaypoint(), false);
}
void
TaskPointWidget::RefreshView()
{
map.Invalidate();
OrderedTaskPoint &tp = ordered_task->GetPoint(active_index);
properties_dock.SetWidget(new PanelWidget());
ObservationZonePoint &oz = tp.GetObservationZone();
const bool is_fai_general =
ordered_task->GetFactoryType() == TaskFactoryType::FAI_GENERAL;
properties_widget = CreateObservationZoneEditWidget(oz, is_fai_general);
if (properties_widget != nullptr) {
properties_widget->SetListener(this);
properties_dock.SetWidget(properties_widget);
}
type_label.SetCaption(OrderedTaskPointName(ordered_task->GetFactory().GetType(tp)));
previous_button->SetEnabled(active_index > 0);
next_button->SetEnabled(active_index < (ordered_task->TaskSize() - 1));
optional_starts.SetVisible(active_index == 0);
if (!ordered_task->HasOptionalStarts())
optional_starts.SetCaption(_("Enable Alternate Starts"));
else {
StaticString<50> tmp;
tmp.Format(_T("%s (%d)"), _("Edit Alternates"),
ordered_task->GetOptionalStartPointCount());
optional_starts.SetCaption(tmp);
}
if (tp.GetType() == TaskPointType::AST) {
const ASTPoint &ast = (const ASTPoint &)tp;
score_exit.Show();
score_exit.SetState(ast.GetScoreExit());
} else
score_exit.Hide();
StaticString<100> name_prefix_buffer, type_buffer;
switch (tp.GetType()) {
case TaskPointType::START:
type_buffer = _("Start point");
name_prefix_buffer = _T("Start: ");
break;
case TaskPointType::AST:
type_buffer = _("Task point");
name_prefix_buffer.Format(_T("%d: "), active_index);
break;
case TaskPointType::AAT:
type_buffer = _("Assigned area point");
name_prefix_buffer.Format(_T("%d: "), active_index);
break;
case TaskPointType::FINISH:
type_buffer = _("Finish point");
name_prefix_buffer = _T("Finish: ");
break;
default:
gcc_unreachable();
}
dialog.SetCaption(type_buffer);
{
StaticString<100> buffer;
buffer.Format(_T("%s %s"), name_prefix_buffer.c_str(),
tp.GetWaypoint().name.c_str());
waypoint_name.SetCaption(buffer);
}
}
void
PrintHelper::orderedtask_print(const OrderedTask &task,
const AircraftState &state)
{
abstracttask_print(task, state);
if (!task.CheckTask())
return;
std::ofstream fi("output/results/res-isolines.txt");
for (unsigned i = 0; i < task.TaskSize(); ++i) {
const OrderedTaskPoint &tp = task.GetPoint(i);
fi << "## point " << i << "\n";
if (tp.GetType() == TaskPointType::AAT) {
aatpoint_print(fi, (const AATPoint &)tp, state,
task.GetTaskProjection(), 1);
} else {
orderedtaskpoint_print(fi, tp, state, 1);
}
fi << "\n";
}
std::ofstream f1("output/results/res-task.txt");
f1 << "#### Task points\n";
for (unsigned i = 0; i < task.TaskSize(); ++i) {
f1 << "## point " << i << " ###################\n";
const OrderedTaskPoint &tp = task.GetPoint(i);
if (tp.GetType() == TaskPointType::AAT) {
aatpoint_print(f1, (const AATPoint &)tp, state,
task.GetTaskProjection(), 0);
} else {
orderedtaskpoint_print(f1, tp, state, 0);
}
f1 << "\n";
}
std::ofstream f5("output/results/res-ssample.txt");
f5 << "#### Task sampled points\n";
for (unsigned i =0 ; i < task.TaskSize(); ++i) {
const OrderedTaskPoint &tp = task.GetPoint(i);
f5 << "## point " << i << "\n";
sampledtaskpoint_print_samples(f5, tp, state);
f5 << "\n";
}
std::ofstream f2("output/results/res-max.txt");
f2 << "#### Max task\n";
for (unsigned i = 0; i < task.TaskSize(); ++i) {
const OrderedTaskPoint &tp = task.GetPoint(i);
f2 << tp.GetLocationMax().longitude << " "
<< tp.GetLocationMax().latitude << "\n";
}
std::ofstream f3("output/results/res-min.txt");
f3 << "#### Min task\n";
for (unsigned i = 0; i < task.TaskSize(); ++i) {
const OrderedTaskPoint &tp = task.GetPoint(i);
f3 << tp.GetLocationMin().longitude << " "
<< tp.GetLocationMin().latitude << "\n";
}
std::ofstream f4("output/results/res-rem.txt");
f4 << "#### Remaining task\n";
for (unsigned i = 0; i < task.TaskSize(); ++i) {
const OrderedTaskPoint &tp = task.GetPoint(i);
f4 << tp.GetLocationRemaining().longitude << " "
<< tp.GetLocationRemaining().latitude << "\n";
}
}
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);
}
}