src/overlay_cmd.cpp

   1 /* $Id$ */
   2
   3 /** @file overlay_cmd.cpp Handling of overlays. */
   4
   5 #include "stdafx.h"
   6 #include "tile_type.h"
   7 #include "tile_cmd.h"
   8 #include "overlay.h"
   9 #include "station_func.h"
  10 #include "viewport_func.h"
  11 #include "overlay_cmd.h"
  12
  13 Overlays* Overlays::instance = nullptr;
  14
  15 Overlays* Overlays::Instance()
  16 {
  17         if (instance == nullptr)
  18                 instance = new Overlays();
  19         return instance;
  20 };
  21
  22 void Overlays::AddStation(const Station* st)
  23 {
  24         this->catchmentOverlay.insert(st);
  25 };
  26
  27 void Overlays::RemoveStation(const Station* st)
  28 {
  29         this->catchmentOverlay.erase(st);
  30 };
  31
  32 void Overlays::ToggleStation(const Station* st)
  33 {
  34         if(this->HasStation(st)) {
  35                 this->RemoveStation(st);
  36         } else {
  37                 this->AddStation(st);
  38         }
  39 };
  40
  41 void Overlays::HandleSignalProgramDeletion(const SignalProgram* program)
  42 {
  43         if (this->logic_signal_program == program) {
  44                 RefreshLogicSignalOverlay();
  45                 this->logic_signal_program = nullptr;
  46         }
  47 };
  48
  49 void Overlays::SetLogicSignalOverlay(const SignalProgram* program)
  50 {
  51         // Old program input tiles
  52         RefreshLogicSignalOverlay();
  53
  54         this->logic_signal_program = program;
  55
  56         // New program input tiles
  57         RefreshLogicSignalOverlay();
  58 };
  59
  60 void Overlays::ClearLogicSignalOverlay()
  61 {
  62         SetLogicSignalOverlay(nullptr);
  63 };
  64
  65 void Overlays::RefreshLogicSignalOverlay() const
  66 {
  67         if (this->logic_signal_program != nullptr) {
  68                 auto signal_references = this->logic_signal_program->GetSignalReferences();
  69
  70                 for (auto reference : signal_references) {
  71                         MarkTileDirtyByTile(GetTileFromSignalReference(reference));
  72                 }
  73
  74                 MarkTileDirtyByTile(this->logic_signal_program->tile);
  75         }
  76 }
  77
  78 void Overlays::Clear()
  79 {
  80         this->catchmentOverlay.clear();
  81
  82         // Old program input tiles
  83         RefreshLogicSignalOverlay();
  84
  85         this->logic_signal_program = nullptr;
  86 };
  87
  88 bool Overlays::IsTileLogicSignalInput(const TileInfo* ti)
  89 {
  90         if (this->logic_signal_program == nullptr) return false;
  91
  92         auto signal_references = this->logic_signal_program->GetSignalReferences();
  93
  94         return std::any_of(signal_references.begin(), signal_references.end(), [&](auto signal_reference) {
  95                 return GetTileFromSignalReference(signal_reference) == ti->tile;
  96         });
  97 }
  98
  99 bool Overlays::IsTileLogicSignalOutput(const TileInfo* ti) const
 100 {
 101         if (this->logic_signal_program == nullptr) return false;
 102
 103         return ti->tile == this->logic_signal_program->tile;
 104 };
 105
 106 bool Overlays::IsTileInCatchmentArea(const TileInfo* ti, CatchmentType type)
 107 {
 108         for(std::set<const Station *>::iterator iter = catchmentOverlay.begin();iter != catchmentOverlay.end();) {
 109                 const Station *st = *iter;
 110                 if( st->IsTileInCatchmentArea(ti, type))
 111                         return true;
 112                 iter++;
 113         }
 114         return false;
 115 };
 116
 117 bool Overlays::HasStation(const Station* st)
 118 {
 119         return (this->catchmentOverlay.find(st) != this->catchmentOverlay.end());
 120 };
 121
 122 Overlays::~Overlays()
 123 {
 124         this->catchmentOverlay.clear();
 125 };