public TrackControllerUi(ISimulationEnvironment e, ITrackController primary)
{
_current = (TrackController) primary;
_primary = (TrackController) primary;
_trains = Tc.Trains;
_blocks = Tc.Blocks;
_routes = Tc.Routes;
InitializeComponent();
ITrackController c = _primary;
while (c != null)
{
tcComboBox.Items.Add(string.Format("Track Controller {0}", c.ID));
tcCountBox.Text = string.Format("{0} Track Controllers", c.ID + 1);
c = c.Next;
}
okButton.Click += OkButtonClick;
tcCountBox.BackColor = (String.Compare(_primary.Line, "Green", StringComparison.Ordinal) == 0)
? Color.Green
: Color.Red;
tcCountBox.ForeColor = Color.White;
_tickCount = 0;
e.Tick += ETick;
Draw();
}
public PlaybackController(ITrackController trackController)
{
this.trackController = trackController;
playbackTimer.Elapsed += new ElapsedEventHandler(PlaybackTimer_Elapsed);
playbackTimer.Start();
player.CurrentAudioStreamEnded += new EventHandler<EventArgs>(CurrentAudioStreamEnded);
if (!System.IO.Directory.Exists(playbackCachePath))
System.IO.Directory.CreateDirectory(playbackCachePath);
}
public CTCOffice(ISimulationEnvironment env, ITrackController redTC, ITrackController greenTC)
{
_populateTrackMutex = new Mutex(false);
_updateTrackMutex = new Mutex(false);
_loadTrackMutex = new Mutex(false);
_rate = 100; //num of ticks
_tickCount = 0;
_rate = env.GetInterval();
_env = env;
_primaryTrackControllerGreen = greenTC;
_primaryTrackControllerRed = redTC;
_env.TrackModel.TrackChangedEvent += new EventHandler<EventArgs>(TrackModel_TrackChangedEvent);
_messages = new List<string>();
//subscribe to Environment Tick
_env.Tick += _env_Tick;
//create new resource wrapper
_res = new ResourceWrapper();
//create new operator object
_op = new Operator();
//set credentials
_op.SetAuth("root", "admin");
//create queues
_requestsOut = new Queue<IRequest>();
_requestsIn = new Queue<IRequest>();
//create queue events
RequestQueueIn += CTCOffice_RequestQueueIn;
RequestQueueOut += CTCOffice_RequestQueueOut;
//create queue processing flags / mutex
_processingOutRequests = false;
_processingInRequests = false;
_redLoaded = false;
_greenLoaded = false;
_containedTrainAndBlock = new List<TrainAndBlock>();
if (_env.TrackModel == null)
{
_env.SendLogEntry("CTCOffice: NULL Reference to TrackModel");
}
}
/// <summary>
/// Opens the track block
/// </summary>
/// <param name="block">Track block to open</param>
/// <returns>bool Success</returns>
public bool OpenTrackBlock(TrackBlock block)
{
bool result = false;
ITrackController controller = GetTrackController(block);
//Attempt to open the track block
if (controller != null)
{
try
{
result = controller.OpenTrack(block.Name);
}
catch (Exception e)
{
m_log.LogError("Error opening track block", e);
}
}
return(result);
}
public MainWindow()
{
// TrackConverter that takes a TransponderReceiver and starts it
trackConverter = new TrackConverter(TransponderReceiverFactory.CreateTransponderDataReceiver());
// A sorter that uses the information from the TrackConverter
sorter = new Sorter(trackConverter);
// The logic-classes using and handling data
ts = new TrackSpeed();
tcc = new TrackCompassCourse();
checker = new CheckForSeparationEvent();
warningCreator = new CreateWarning(checker);
logger = new LogSeparationEvent(checker);
// Controller that delegates out the data
controller = new Controller(sorter, ts, tcc, checker, warningCreator, logger);
InitializeComponent();
DataContext = new Controller(sorter, ts, tcc, checker, warningCreator, logger);
Loaded += new RoutedEventHandler(MainWindow_Loaded);
}
public void SetUp()
{
_sorter = Substitute.For <ISorter>();
_speed = Substitute.For <ITrackSpeed>();
_compassCourse = Substitute.For <ITrackCompassCourse>();
_checker = Substitute.For <ISeperationEventChecker>();
_warningCreator = Substitute.For <ISeperationEventHandler>();
_logger = Substitute.For <ISeperationEventLogger>();
_uut = new Controller(_sorter, _speed, _compassCourse, _checker, _warningCreator, _logger);
_sorter.TrackSortedReady += (o, args) =>
{
_receivedArgs = args;
};
_listOfTracks = new List <TrackObject>();
// Create tracks
_track1 = new TrackObject("Tag123", 70000, 70000, 1000, DateTime.ParseExact("20180412111111111", "yyyyMMddHHmmssfff", CultureInfo.InvariantCulture));
_track2 = new TrackObject("Tag456", 68000, 68000, 800, DateTime.ParseExact("20180412111111111", "yyyyMMddHHmmssfff", CultureInfo.InvariantCulture));
_track3 = new TrackObject("Tag789", 89000, 89000, 5000, DateTime.ParseExact("20180412111111111", "yyyyMMddHHmmssfff", CultureInfo.InvariantCulture));
_track4 = new TrackObject("TagABC", 72000, 72000, 1200, DateTime.ParseExact("20180412111111111", "yyyyMMddHHmmssfff", CultureInfo.InvariantCulture));
}
private void FileControllers_ItemRemoved(ITrackController controller)
{
lsvControllers.Items.RemoveByKey($"lsvControllersItem_{controller.Name}");
}
public SourceController(IOldRepository <ISource> repository, ITrackController trackController)
{
this.repository = repository;
this.trackController = trackController;
}
public void Initialize(ITrackController trackController, ITagController tagController)
{
this.trackController = trackController;
this.tagController = tagController;
}
public void Initialize(ISourceController sourceController, ITrackController trackController, ITagController tagController)
{
this.sourceController = sourceController;
this.trackController = trackController;
this.tagController = tagController;
treeView.ItemsSource = boundSources;
boundSources.Add(new DeviceCatalogSource { Name = "Devices" });
var sources = sourceController.Search(new Dictionary<string, object> { { "Parent", null } });
if (sources != null && sources.Count() > 0)
{
foreach (var source in sources)
{
boundSources.Add(source);
LoadSourceChildren(source);
}
}
}
public void Initialize(ITrackController trackController, IPlaybackController playbackController)
{
this.trackController = trackController;
this.playbackController = playbackController;
playButtonImage.DataContext = playbackController.Status;
}
/// <summary>
/// Do Processing on Tick
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void _env_Tick(object sender, TickEventArgs e)
{
//check for track if both tracks are not up.. if tracks are up.. dont check
if (!(_redLoaded && _greenLoaded))
{
IsTrackUp();
}
if (_primaryTrackControllerRed == null)
{
_primaryTrackControllerRed = _env.PrimaryTrackControllerRed;
}
if (_primaryTrackControllerGreen == null)
{
_primaryTrackControllerGreen = _env.PrimaryTrackControllerGreen;
}
_tickCount++;
if (_tickCount >= _rate)
{
//AddAutomaticUpdate();//no longer need this information as of Track Model Update
_tickCount = 0;
PopulateTrack();//add trains to track
}
}
public void Initialize(ITrackController trackController, ITagController tagController)
{
this.trackController = trackController;
this.tagController = tagController;
}
private void Controllers_ItemAdded(ITrackController obj)
{
obj.CommandCenter.SubscribeTo(CommandCenter);
}
/// <summary>
/// Creates track controllers and assigns track blocks to them
/// </summary>
///
/// <param name="blocks">List of track blocks in the layout</param>
///
/// <returns>bool Sucess</returns>
private bool BuildLayout(List <TrackBlock> blocks, List <TrackSwitch> switches)
{
if (blocks == null)
{
return(false);
}
//Collection of track controllers
Dictionary <string, ITrackController> trackControllers = new Dictionary <string, ITrackController>();
//Variables for calculating the size of the layout
double minX = Double.PositiveInfinity;
double maxX = 0;
double minY = Double.PositiveInfinity;
double maxY = 0;
//Reset
m_controllerList.Clear();
m_trainList.Clear();
m_trackTable.Clear();
m_blockTable.Clear();
foreach (TrackBlock b in blocks)
{
if (!string.IsNullOrEmpty(b.ControllerId))
{
m_blockTable[b.Name] = b;
if (!trackControllers.ContainsKey(b.ControllerId))
{
//Create a new track controller
ITrackController controller = new TrackController();
controller.AddTrackBlock(b);
m_trackTable[b] = controller;
m_controllerList.Add(controller);
trackControllers[b.ControllerId] = controller;
}
else
{
//Add it to the existing track controller
ITrackController controller = trackControllers[b.ControllerId];
controller.AddTrackBlock(b);
m_trackTable[b] = controller;
}
}
else
{
m_log.LogError("Block primary controller ID was null or empty. Skipping block");
continue;
}
if (!string.IsNullOrEmpty(b.SecondaryControllerId))
{
if (!trackControllers.ContainsKey(b.SecondaryControllerId))
{
//Create a new track controller
ITrackController controller = new TrackController();
controller.AddTrackBlock(b);
m_controllerList.Add(controller);
trackControllers[b.SecondaryControllerId] = controller;
//No need to add the controller to the track table.
}
else
{
//Add it to the existing track controller
ITrackController controller = trackControllers[b.SecondaryControllerId];
controller.AddTrackBlock(b);
//No need to add the controller to the track table.
}
}
//Calculate the min and max coordinates of the layout
if (b.StartPoint.X < minX)
{
//Only need to check the start point since it is always smaller
minX = b.StartPoint.X;
}
if (b.EndPoint.X > maxX)
{
//Only need to check the end point since it is always larger
maxX = b.EndPoint.X;
}
//Need to check both the start and end point for Y
if (b.StartPoint.Y < minY)
{
minY = b.StartPoint.Y;
}
if (b.EndPoint.Y < minY)
{
minY = b.EndPoint.Y;
}
if (b.StartPoint.Y > maxY)
{
maxY = b.StartPoint.Y;
}
if (b.EndPoint.Y > maxY)
{
maxY = b.EndPoint.Y;
}
}
//Now go back and assign previous/next blocks
foreach (TrackBlock b in blocks)
{
if (!string.IsNullOrEmpty(b.PreviousBlockId))
{
if (m_blockTable.ContainsKey(b.PreviousBlockId))
{
b.PreviousBlock = m_blockTable[b.PreviousBlockId];
}
}
if (!string.IsNullOrEmpty(b.NextBlockId))
{
if (m_blockTable.ContainsKey(b.NextBlockId))
{
b.NextBlock = m_blockTable[b.NextBlockId];
}
}
}
//Now create the switches and assign them to track controllers
if (switches != null)
{
foreach (TrackSwitch s in switches)
{
if (m_blockTable.ContainsKey(s.BranchClosedId) && m_blockTable.ContainsKey(s.BranchOpenId) && m_blockTable.ContainsKey(s.TrunkId))
{
if (trackControllers.ContainsKey(s.ControllerId))
{
//Assign the blocks to the switch
s.Trunk = m_blockTable[s.TrunkId];
s.BranchClosed = m_blockTable[s.BranchClosedId];
s.BranchOpen = m_blockTable[s.BranchOpenId];
s.State = TrackSwitchState.Closed;
trackControllers[s.ControllerId].SetSwitch(s);
}
else
{
m_log.LogError("Switch Track Controller Id was invalid. Skipping.");
}
}
else
{
m_log.LogError("Block Id not found. Skipping.");
}
}
}
//Calculate the start point and total size
m_layoutStartPoint = new Point(System.Convert.ToInt32(minX), System.Convert.ToInt32(minY));
if (maxX < Double.PositiveInfinity && maxY < Double.PositiveInfinity)
{
m_layoutSize = new Size(System.Convert.ToInt32(maxX - minX), System.Convert.ToInt32(maxY - minY));
}
return(true);
}
private void Controllers_ItemRemoved(ITrackController obj)
{
obj.CommandCenter.DesubscribeFrom(CommandCenter);
}
public void Initialize(ITrackController trackController, ITagController tagController, PlaybackView playbackView, MediaPropertyView mediaPropertyView)
{
this.trackController = trackController;
this.tagController = tagController;
this.playbackView = playbackView;
this.mediaPropertyView = mediaPropertyView;
mediaList.ItemsSource = trackController.Tracks;
}
