void
WaypointIconRenderer::Draw(const Waypoint &waypoint, const PixelPoint &point,
                           Reachability reachable, bool in_task)
{
    if (waypoint.IsLandable())
        DrawLandable(waypoint, point, reachable);
    else
        // non landable turnpoint
        GetWaypointIcon(look, waypoint, small_icons, in_task).Draw(canvas, point);
}
Exemple #2
0
bool 
GotoTask::DoGoto(const Waypoint & wp)
{
  if (task_behaviour.goto_nonlandable || wp.IsLandable()) {
    delete tp;
    tp = new UnorderedTaskPoint(wp, task_behaviour);
    stats.start.Reset();
    force_full_update = true;
    return true;
  } else {
    return false;
  }
}
Exemple #3
0
void
WaypointEditWidget::Prepare(gcc_unused ContainerWindow &parent,
                            gcc_unused const PixelRect &rc)
{
  AddText(_("Name"), nullptr, value.name.c_str());
  AddText(_("Comment"), nullptr, value.comment.c_str());
  Add(_("Location"), nullptr, new GeoPointDataField(value.location,UIGlobals::GetFormatSettings().coordinate_format));
  AddFloat(_("Altitude"), nullptr,
           _T("%.0f %s"), _T("%.0f"),
           0, 30000, 5, false,
           UnitGroup::ALTITUDE, value.elevation);
  AddEnum(_("Type"), nullptr, waypoint_types,
          value.IsAirport() ? 1u : (value.IsLandable() ? 2u : 0u ));
}
Exemple #4
0
static void
TestZanderWaypoint(const Waypoint org_wp, const Waypoint *wp)
{
    if (wp == NULL) {
        skip(7, 0, "waypoint not found");
        return;
    }

    ok1(wp->type == ((!org_wp.IsLandable()) ?
                     Waypoint::TYPE_NORMAL : (Waypoint::Type)org_wp.type));
    ok1(wp->flags.turn_point == org_wp.flags.turn_point);
    ok1(wp->flags.home == org_wp.flags.home);
    ok1(wp->flags.start_point == org_wp.flags.start_point);
    ok1(wp->flags.finish_point == org_wp.flags.finish_point);
}
Exemple #5
0
void
WaypointWriter::WriteFlags(TextWriter &writer, const Waypoint &wp)
{
  if (wp.IsAirport())
    writer.write('A');
  if (wp.flags.turn_point)
    writer.write('T');
  if (wp.IsLandable())
    writer.write('L');
  if (wp.flags.home)
    writer.write('H');
  if (wp.flags.start_point)
    writer.write('S');
  if (wp.flags.finish_point)
    writer.write('F');

  // set as turnpoint by default if nothing else
  if (!wp.flags.turn_point &&
      !wp.IsLandable() &&
      !wp.flags.home &&
      !wp.flags.start_point &&
      !wp.flags.finish_point)
    writer.write('T');
}
Exemple #6
0
void
WaypointEditWidget::Prepare(ContainerWindow &parent, const PixelRect &rc)
{
    AddText(_("Name"), nullptr, value.name.c_str());
    AddText(_("Comment"), nullptr, value.comment.c_str());
    Add(_("Location"), nullptr, new GeoPointDataField(value.location,
            // TODO: use configured CoordinateFormat
            CoordinateFormat::DDMMSS));
    AddFloat(_("Altitude"), nullptr,
             _T("%.0f %s"), _T("%.0f"),
             fixed(0), fixed(30000), fixed(5), false,
             UnitGroup::ALTITUDE, value.elevation);
    AddEnum(_("Type"), nullptr, waypoint_types,
            value.IsAirport() ? 1u : (value.IsLandable() ? 2u : 0u ));
}
Exemple #7
0
static void
TestWinPilotWaypoint(const Waypoint org_wp, const Waypoint *wp)
{
    if (wp == NULL) {
        skip(7, 0, "waypoint not found");
        return;
    }

    ok1(wp->type == ((!org_wp.IsLandable()) ?
                     Waypoint::TYPE_NORMAL : (Waypoint::Type)org_wp.type));
    ok1(wp->flags.turn_point == org_wp.flags.turn_point);
    ok1(wp->flags.home == org_wp.flags.home);
    ok1(wp->flags.start_point == org_wp.flags.start_point);
    ok1(wp->flags.finish_point == org_wp.flags.finish_point);
    ok1(wp->runway.IsDirectionDefined() == org_wp.runway.IsDirectionDefined() &&
        (!wp->runway.IsDirectionDefined() ||
         wp->runway.GetDirectionDegrees() == org_wp.runway.GetDirectionDegrees()));
}
Exemple #8
0
  static bool
  CompareType(const Waypoint &waypoint, TypeFilter type)
  {
    switch (type) {
    case TF_ALL:
      return true;

    case TF_AIRPORT:
      return waypoint.IsAirport();

    case TF_LANDABLE:
      return waypoint.IsLandable();

    case TF_TURNPOINT:
      return waypoint.IsTurnpoint();

    case TF_START:
      return waypoint.IsStartpoint();

    case TF_FINISH:
      return waypoint.IsFinishpoint();

    case TF_FAI_TRIANGLE_LEFT:
      return triangle_validator->IsFAITrianglePoint(waypoint, fixed(-1));

    case TF_FAI_TRIANGLE_RIGHT:
      return triangle_validator->IsFAITrianglePoint(waypoint, fixed_one);

    case TF_FILE_1:
      return waypoint.file_num == 1;

    case TF_FILE_2:
      return waypoint.file_num == 2;

    case TF_LAST_USED:
      return false;
    }

    /* not reachable */
    return false;
  }
Exemple #9
0
bool
CAI302Device::WriteNavpoint(unsigned id, const Waypoint &wp,
                            OperationEnvironment &env)
{
  if (!DownloadMode(env))
    return false;

  char name[64], remark[64];
  ToASCII(name, ARRAY_SIZE(name), wp.name.c_str());
  ToASCII(remark, ARRAY_SIZE(remark), wp.comment.c_str());

  if (!CAI302::DownloadNavpoint(port, wp.location, (int)wp.elevation, id,
                                wp.IsTurnpoint(), wp.IsAirport(), false,
                                wp.IsLandable(), wp.IsStartpoint(),
                                wp.IsFinishpoint(), wp.flags.home,
                                false, wp.IsTurnpoint(), false,
                                name, remark, env)) {
    mode = Mode::UNKNOWN;
    return false;
  }

  return true;
}
Exemple #10
0
  void FormatLabel(TCHAR *buffer, size_t buffer_size,
                   const Waypoint &way_point,
                   WaypointRenderer::Reachability reachable,
                   const ReachResult &reach) const {
    FormatTitle(buffer, buffer_size - 20, way_point);

    if (!way_point.IsLandable() && !way_point.flags.watched)
      return;

    if (settings.arrival_height_display == WaypointRendererSettings::ArrivalHeightDisplay::REQUIRED_GR) {
      if (!basic.location_available || !basic.NavAltitudeAvailable())
        return;

      const auto safety_height = task_behaviour.safety_height_arrival;
      const auto target_altitude = way_point.elevation + safety_height;
      const auto delta_h = basic.nav_altitude - target_altitude;
      if (delta_h <= 0)
        /* no L/D if below waypoint */
        return;

      const auto distance = basic.location.DistanceS(way_point.location);
      const auto gr = distance / delta_h;
      if (!GradientValid(gr))
        return;

      size_t length = _tcslen(buffer);
      if (length > 0)
        buffer[length++] = _T(':');
      StringFormatUnsafe(buffer + length, _T("%.1f"), (double) gr);
      return;
    }

    if (reachable == WaypointRenderer::Invalid)
      return;

    if (!reach.IsReachableDirect() && !way_point.flags.watched)
      return;

    if (settings.arrival_height_display == WaypointRendererSettings::ArrivalHeightDisplay::NONE)
      return;

    size_t length = _tcslen(buffer);
    int uah_glide = (int)Units::ToUserAltitude(reach.direct);
    int uah_terrain = (int)Units::ToUserAltitude(reach.terrain);

    if (settings.arrival_height_display == WaypointRendererSettings::ArrivalHeightDisplay::TERRAIN) {
      if (reach.IsReachableTerrain()) {
        if (length > 0)
          buffer[length++] = _T(':');
        StringFormatUnsafe(buffer + length, _T("%d%s"),
                           uah_terrain, altitude_unit);
      }
      return;
    }

    if (length > 0)
      buffer[length++] = _T(':');

    if (settings.arrival_height_display == WaypointRendererSettings::ArrivalHeightDisplay::GLIDE_AND_TERRAIN &&
        reach.IsReachableDirect() && reach.IsReachableTerrain() &&
        reach.IsDeltaConsiderable()) {
      StringFormatUnsafe(buffer + length, _T("%d/%d%s"), uah_glide,
                         uah_terrain, altitude_unit);
      return;
    }

    StringFormatUnsafe(buffer + length, _T("%d%s"), uah_glide, altitude_unit);
  }
Exemple #11
0
 /**
  * Visit method, adds result to vector
  *
  * @param wp Waypoint that is visited
  */
 void Visit(const Waypoint& wp) {
   if (wp.IsLandable())
     vector.push_back(wp);
 }
Exemple #12
0
static bool
IsLandable(const Waypoint &wp)
{
  return wp.IsLandable();
}
  void
  FormatLabel(TCHAR *buffer, const Waypoint &way_point,
              const ReachResult &reach)
  {
    FormatTitle(buffer, way_point);

    if (!way_point.IsLandable() && !way_point.flags.watched)
      return;

    if (settings.arrival_height_display == WaypointRendererSettings::ArrivalHeightDisplay::REQUIRED_GR) {
      if (!basic.location_available || !basic.NavAltitudeAvailable())
        return;

      const fixed safety_height = task_behaviour.safety_height_arrival;
      const fixed target_altitude = way_point.elevation + safety_height;
      const fixed delta_h = basic.nav_altitude - target_altitude;
      if (!positive(delta_h))
        /* no L/D if below waypoint */
        return;

      const fixed distance = basic.location.Distance(way_point.location);
      const fixed gr = distance / delta_h;
      if (!GradientValid(gr))
        return;

      size_t length = _tcslen(buffer);
      if (length > 0)
        buffer[length++] = _T(':');
      _stprintf(buffer + length, _T("%.1f"), (double) gr);
      return;
    }

    if (!reach.IsReachableDirect() && !way_point.flags.watched)
      return;

    if (settings.arrival_height_display == WaypointRendererSettings::ArrivalHeightDisplay::NONE)
      return;

    size_t length = _tcslen(buffer);
    int uah_glide = (int)Units::ToUserAltitude(fixed(reach.direct));
    int uah_terrain = (int)Units::ToUserAltitude(fixed(reach.terrain));

    if (settings.arrival_height_display == WaypointRendererSettings::ArrivalHeightDisplay::TERRAIN) {
      if (reach.IsReachableTerrain()) {
        if (length > 0)
          buffer[length++] = _T(':');
        _stprintf(buffer + length, _T("%d%s"), uah_terrain, sAltUnit);
      }
      return;
    }

    if (length > 0)
      buffer[length++] = _T(':');

    if (settings.arrival_height_display == WaypointRendererSettings::ArrivalHeightDisplay::GLIDE_AND_TERRAIN &&
        reach.IsReachableDirect() && reach.IsReachableTerrain() &&
        reach.IsDeltaConsiderable()) {
      _stprintf(buffer + length, _T("%d/%d%s"), uah_glide,
                uah_terrain, sAltUnit);
      return;
    }

    _stprintf(buffer + length, _T("%d%s"), uah_glide, sAltUnit);
  }
Exemple #14
0
 /**
  * Visit method, adds result to vector
  *
  * @param wp Waypoint that is visited
  */
 void Visit(const Waypoint& wp) {
   if (wp.IsLandable())
     vector.emplace_back(wp);
 }
Exemple #15
0
 bool operator()(const Waypoint &wp) const {
   return wp.IsLandable();
 }