Beispiel #1
0
void
TaskPointRenderer::DrawOrdered(const OrderedTaskPoint &tp, Layer layer)
{
  switch (layer) {
  case LAYER_OZ_SHADE:
    if (tp.BoundingBoxOverlaps(bb_screen))
      // draw shaded part of observation zone
      DrawOZBackground(canvas, tp);

    break;

  case LAYER_LEG:
    if (index > 0)
      DrawTaskLine(last_point, tp.GetLocationRemaining());

    last_point = tp.GetLocationRemaining();

    break;

  case LAYER_OZ_OUTLINE:
    if (tp.BoundingBoxOverlaps(bb_screen))
      DrawOZForeground(tp);

    break;

  case LAYER_SYMBOLS:
    return;
  }
}
void
TaskPointRenderer::Draw(const TaskPoint &tp, Layer layer)
{
  const OrderedTaskPoint &otp = (const OrderedTaskPoint &)tp;
  const AATPoint &atp = (const AATPoint &)tp;

  switch (tp.GetType()) {
  case TaskPointType::UNORDERED:
    if (layer == LAYER_LEG && location.IsValid())
      DrawTaskLine(location, tp.GetLocationRemaining());

    if (layer == LAYER_SYMBOLS)
      DrawBearing(tp);

    index++;
    break;

  case TaskPointType::START:
    index = 0;

    DrawOrdered(otp, layer);
    if (layer == LAYER_SYMBOLS) {
      DrawBearing(tp);
      DrawTarget(tp);
    }

    break;

  case TaskPointType::AST:
    index++;

    DrawOrdered(otp, layer);
    if (layer == LAYER_SYMBOLS) {
      DrawBearing(tp);
      DrawTarget(tp);
    }
    break;

  case TaskPointType::AAT:
    index++;

    DrawOrdered(otp, layer);
    if (layer == LAYER_SYMBOLS) {
      DrawIsoline(atp);
      DrawBearing(tp);
      DrawTarget(tp);
    }
    break;

  case TaskPointType::FINISH:
    index++;

    DrawOrdered(otp, layer);
    if (layer == LAYER_SYMBOLS) {
      DrawBearing(tp);
      DrawTarget(tp);
    }
    break;
  }
}
void
TaskPointRenderer::DrawOrdered(const OrderedTaskPoint &tp, Layer layer)
{
  int offset = index - active_index;

  if (offset == 0 && task_finished && tp.GetType() == TaskPointType::FINISH)
    /* if the task is finished, pretend the active_index is past the
       current index; we need this because XCSoar never moves
       active_index to one after the finish point, because that would
       point to an invalid task point index */
    offset = -1;

  switch (layer) {
  case LAYER_OZ_SHADE:
    if (tp.BoundingBoxOverlaps(bb_screen))
      // draw shaded part of observation zone
      DrawOZBackground(canvas, tp, offset);

    break;

  case LAYER_LEG:
    if (index > 0)
      DrawTaskLine(last_point, tp.GetLocationRemaining());

    last_point = tp.GetLocationRemaining();

    break;

  case LAYER_OZ_OUTLINE:
    if (tp.BoundingBoxOverlaps(bb_screen)) {
      if (mode_optional_start && offset == 0)
        /* render optional starts as deactivated */
        offset = -1;

      DrawOZForeground(tp, offset);
    }

    break;

  case LAYER_SYMBOLS:
    return;
  }
}
Beispiel #4
0
void
RenderTaskPoint::Draw(const TaskPoint &tp, Layer layer)
{
    const OrderedTaskPoint &otp = (const OrderedTaskPoint &)tp;
    const AATPoint &atp = (const AATPoint &)tp;

    switch (tp.GetType()) {
    case TaskPoint::UNORDERED:
        if (layer == LAYER_LEG)
            DrawTaskLine(location, tp.GetLocationRemaining());

        if (layer == LAYER_SYMBOLS)
            DrawBearing(tp);

        index++;
        break;

    case TaskPoint::START:
        index = 0;

        DrawOrdered(otp, layer);
        if (layer == LAYER_SYMBOLS) {
            DrawBearing(tp);
            DrawTarget(tp);
        }

        break;

    case TaskPoint::AST:
        index++;

        DrawOrdered(otp, layer);
        if (layer == LAYER_SYMBOLS) {
            DrawBearing(tp);
            DrawTarget(tp);
        }
        break;

    case TaskPoint::AAT:
        index++;

        DrawOrdered(otp, layer);
        if (layer == LAYER_SYMBOLS) {
            DrawIsoline(atp);
            DrawBearing(tp);
            DrawTarget(tp);
        }
        break;

    case TaskPoint::FINISH:
        index++;

        DrawOrdered(otp, layer);
        if (layer == LAYER_SYMBOLS) {
            DrawBearing(tp);
            DrawTarget(tp);
        }
        break;

    case TaskPoint::ROUTE:
        /* unreachable */
        assert(false);
        break;
    }
}