Ejemplo n.º 1
0
inline void
ChartControl::UpdateCrossSection(const MoreData &basic,
                                 const DerivedInfo &calculated,
                                 const GlideSettings &glide_settings,
                                 const GlidePolar &glide_polar,
                                 const MapSettings &map_settings)
{
  cross_section_renderer.ReadBlackboard(basic, calculated, glide_settings,
                                        glide_polar, map_settings);

  if (basic.location_available && basic.track_available) {
    cross_section_renderer.SetDirection(basic.track);
    cross_section_renderer.SetStart(basic.location);
  } else
    cross_section_renderer.SetInvalid();
}
Ejemplo n.º 2
0
 ChartControl(AnalysisWidget &_analysis_widget,
              const ChartLook &_chart_look,
              const MapLook &map_look,
              const CrossSectionLook &_cross_section_look,
              const ThermalBandLook &_thermal_band_look,
              const CrossSectionLook &cross_section_look,
              const AirspaceLook &airspace_look,
              const Airspaces *airspaces,
              const RasterTerrain *terrain,
              const FullBlackboard &_blackboard,
              const GlideComputer &_glide_computer)
   :analysis_widget(_analysis_widget),
    chart_look(_chart_look),
    cross_section_look(_cross_section_look),
    thermal_band_renderer(_thermal_band_look, chart_look),
    fs_renderer(chart_look, map_look),
    cross_section_renderer(cross_section_look, airspace_look, chart_look),
    blackboard(_blackboard), glide_computer(_glide_computer) {
   cross_section_renderer.SetAirspaces(airspaces);
   cross_section_renderer.SetTerrain(terrain);
 }
Ejemplo n.º 3
0
 /**
  * Set CrossSection start point
  * @param _start Start GeoPoint to use for drawing
  */
 void SetStart(GeoPoint start) {
   renderer.SetStart(start);
 }
Ejemplo n.º 4
0
 /**
  * Set CrossSection direction
  * @param bearing Direction to draw
  */
 void SetDirection(Angle bearing) {
   renderer.SetDirection(bearing);
 }
Ejemplo n.º 5
0
 /**
  * Set CrossSection range
  * @param range Range to draw [m]
  */
 void SetRange(fixed range) {
   renderer.SetRange(range);
 }
Ejemplo n.º 6
0
 /**
  * Set RasterTerrain to use
  * @param _terrain Pointer to the RasterTerrain or NULL
  */
 void SetTerrain(const RasterTerrain *terrain) {
   renderer.SetTerrain(terrain);
 }
Ejemplo n.º 7
0
 /**
  * Set airspace database to use
  * @param _airspace_database Pointer to the airspace database or NULL
  */
 void SetAirspaces(const Airspaces *airspace_database) {
   renderer.SetAirspaces(airspace_database);
 }
Ejemplo n.º 8
0
 void ReadBlackboard(const MoreData &basic,
                     const DerivedInfo &calculated,
                     const AirspaceRendererSettings &ar_settings) {
   renderer.ReadBlackboard(basic, calculated, ar_settings);
 }
Ejemplo n.º 9
0
 void SetInvalid() {
   renderer.SetInvalid();
 }
Ejemplo n.º 10
0
void
ChartControl::OnPaint(Canvas &canvas)
{
  const ComputerSettings &settings_computer = blackboard.GetComputerSettings();
  const MapSettings &settings_map = blackboard.GetMapSettings();
  const MoreData &basic = blackboard.Basic();
  const DerivedInfo &calculated = blackboard.Calculated();

  const ProtectedTaskManager *const protected_task_manager =
    &glide_computer.GetProtectedTaskManager();

#ifdef ENABLE_OPENGL
  /* enable clipping */
  GLCanvasScissor scissor(canvas);
#endif

  canvas.Clear(COLOR_WHITE);
  canvas.SetTextColor(COLOR_BLACK);

  PixelRect rcgfx = GetClientRect();

  // background is painted in the base-class

  switch (page) {
  case AnalysisPage::BAROGRAPH:
    RenderBarograph(canvas, rcgfx, chart_look, cross_section_look,
                    glide_computer.GetFlightStats(),
                    basic, calculated, protected_task_manager);
    break;
  case AnalysisPage::CLIMB:
    RenderClimbChart(canvas, rcgfx, chart_look,
                     glide_computer.GetFlightStats(),
                     settings_computer.polar.glide_polar_task);
    break;
  case AnalysisPage::THERMAL_BAND:
  {
    OrderedTaskSettings otb;
    if (protected_task_manager != NULL) {
      otb = protected_task_manager->GetOrderedTaskSettings();
    }

    thermal_band_renderer.DrawThermalBand(basic,
                                          calculated,
                                          settings_computer,
                                          canvas, rcgfx,
                                          settings_computer.task,
                                          false,
                                          &otb);
  }
    break;
  case AnalysisPage::WIND:
    RenderWindChart(canvas, rcgfx, chart_look,
                    glide_computer.GetFlightStats(),
                    basic, glide_computer.GetWindStore());
    break;
  case AnalysisPage::POLAR:
    RenderGlidePolar(canvas, rcgfx, chart_look,
                     calculated.climb_history,
                     settings_computer,
                     settings_computer.polar.glide_polar_task);
    break;
  case AnalysisPage::TEMPTRACE:
    RenderTemperatureChart(canvas, rcgfx, chart_look,
                           glide_computer.GetCuSonde());
    break;
  case AnalysisPage::TASK:
    if (protected_task_manager != NULL) {
      const auto &trace_computer = glide_computer.GetTraceComputer();
      fs_renderer.RenderTask(canvas, rcgfx, basic,
                             settings_computer, settings_map,
                             *protected_task_manager,
                             &trace_computer);
    }
    break;

  case AnalysisPage::OLC:
    fs_renderer.RenderOLC(canvas, rcgfx, basic,
                          settings_computer, settings_map,
                          calculated.contest_stats,
                          glide_computer.GetTraceComputer(),
                          glide_computer.GetRetrospective());
    break;
  case AnalysisPage::TASK_SPEED:
    if (protected_task_manager != NULL) {
      ProtectedTaskManager::Lease task(*protected_task_manager);
      RenderSpeed(canvas, rcgfx, chart_look,
                  glide_computer.GetFlightStats(),
                  basic, calculated, task);
    }
    break;

  case AnalysisPage::AIRSPACE:
    cross_section_renderer.Paint(canvas, rcgfx);
    break;

  default:
    // should never get here!
    break;
  }
}