public static void LoadLayout(DataGrid DataGrid, ICollectionView Collection, string GridName, GridSetting defaultLayout)
{
if (DataGrid == null)
{
return;
}
var settingsResult = m_SettingsBll.GetSettings();
if (!settingsResult.Succeeded)
{
return;
}
var gridSetting = settingsResult.Result.GridSettings.FirstOrDefault(s => s.GridName == GridName);
if (gridSetting != null)
{
__LoadLayout(DataGrid, Collection, gridSetting);
}
else if (defaultLayout != null)
{
__LoadLayout(DataGrid, Collection, defaultLayout);
}
}
public ESTWOnlineScope(ESTW estw, string estwOnlineDirectory, string dataFilePath)
{
m_Estw = estw;
m_OldDataFilePath = Field.GetValue(m_Estw) as string;
Field.SetValue(m_Estw, dataFilePath);
var SettingsResult = m_SettingsBll.GetSettings();
if (SettingsResult.Succeeded)
{
m_OldEstwOnlinePath = SettingsResult.Result.EstwOnlinePath;
SettingsResult.Result.EstwOnlinePath = Path.Combine(Environment.CurrentDirectory, estwOnlineDirectory);
}
}
private void __StartEstwOnline()
{
var SettingsResult = m_SettingsBll.GetSettings();
if (SettingsResult.Succeeded && SettingsResult.Result != null)
{
if (SettingsResult.Result.EstwOnlinePath.IsNullOrWhiteSpace())
{
MessageBox.Show(StatusBarText = "ESTWonline Pfad nicht gesetzt", "Fehler", MessageBoxButton.OK, MessageBoxImage.Error);
}
else
{
string EstwOnlinePath = Path.Combine(SettingsResult.Result.EstwOnlinePath, "ESTWonline.exe");
if (!File.Exists(EstwOnlinePath))
{
MessageBox.Show("ESTWonline Pfad ungültig", "Fehler", MessageBoxButton.OK, MessageBoxImage.Error);
}
else
{
try
{
Process.Start(EstwOnlinePath);
}
catch (Exception ex)
{
MessageBox.Show(String.Format("Konnte ESTWonline nicht starten: {0}", ex.Message), "Fehler", MessageBoxButton.OK, MessageBoxImage.Error);
}
}
}
}
}
public SettingsScope()
{
m_SettingsBll = new SettingsBLL();
var settingsResult = m_SettingsBll.GetSettings();
if (settingsResult.Succeeded)
{
m_Settings = settingsResult.Result;
m_OriginalSettings = m_Settings.Clone();
m_Settings.DelayJustificationEnabled = true;
m_Settings.DelayJustificationMinutes = 3;
}
}
public ESTWRootScope()
{
var SettingsResult = m_SettingsBll.GetSettings();
if (SettingsResult.Succeeded)
{
var Paths = SettingsResult.Result.Paths;
m_OldPaths = Paths.Clone();
m_OldEstwOnlinePath = SettingsResult.Result.EstwOnlinePath;
var ResourceSet = Properties.Resources.ResourceManager.GetResourceSet(CultureInfo.CurrentUICulture, true, true);
foreach (DictionaryEntry Resource in ResourceSet)
{
if (Resource.Key is string && (Resource.Key as string).StartsWith("path_") && Resource.Value is string)
{
string EstwId = (Resource.Key as string).Substring(5);
Paths[EstwId] = Path.Combine(Environment.CurrentDirectory, Resource.Value as string);
}
}
SettingsResult.Result.EstwOnlinePath = Path.Combine(Environment.CurrentDirectory, @"TestData\ESTWOnline");
}
}
public ChildWindow(string Identifier)
: base()
{
this.Identifier = Identifier;
CloseCommand = new CommandHandler(Close, true);
SizeToContentCommand = new CommandHandler(__SizeToContent, true);
DataContextChanged += __DataContextChanged;
Closed += __Closed;
WindowState = Xceed.Wpf.Toolkit.WindowState.Open;
var SettingsBll = new SettingsBLL();
var SettingsResult = SettingsBll.GetSettings();
if (SettingsResult.Succeeded)
{
WindowColor = SettingsResult.Result.WindowColor;
}
}
public SettingsViewModel(ObservableCollection <Area> areas)
{
m_Areas = areas;
m_SettingsBll = new SettingsBLL();
Areas = new ObservableCollection <AreaViewModel>();
var SettingsResult = m_SettingsBll.GetSettings();
if (SettingsResult.Succeeded)
{
m_Settings = SettingsResult.Result.Clone();
__Initialize();
}
else
{
ShowMessage(SettingsResult);
}
m_SaveCommand = new CommandHandler(__Save, false);
m_CancelCommand = new CommandHandler(__Cancel, true);
m_EstwOnlineCommand = new CommandHandler(__BrowseEstwOnline, true);
}
public void Refresh(Area Area)
{
var SettingsResult = m_SettingsBll.GetSettings();
if (!SettingsResult.Succeeded)
{
MessageBox.Show(SettingsResult.Message, "Fehler", MessageBoxButton.OK, MessageBoxImage.Error);
return;
}
var Settings = SettingsResult.Result;
var CurrentSchedules = new List <TrainScheduleStationViewModel>();
var Estw = Area.ESTWs.FirstOrDefault(estw => estw.Time != null);
if (Estw == null)
{
return;
}
var SchedulesResult = m_CalculationBll.GetSchedulesByTime(CurrentTrain.Schedules, Estw.Time);
if (!SchedulesResult.Succeeded)
{
Dispatcher.Invoke(() => MessageBox.Show(SchedulesResult.Message, "Fehler", MessageBoxButton.OK, MessageBoxImage.Error));
return;
}
bool HasStartStation = SchedulesResult.Result.Any(s => s.Handling == eHandling.Start);
bool HasDestinationStation = SchedulesResult.Result.Any(s => s.Handling == eHandling.Destination);
TrainScheduleStationViewModel FirstStationSchedule = null;
TrainScheduleStationViewModel FirstStationDummy = null;
TrainScheduleStationViewModel LastStationSchedule = null;
TrainScheduleStationViewModel LastStationDummy = null;
if (!HasStartStation && CurrentTrain.Start != null)
{
FirstStationSchedule = Stations.FirstOrDefault();
FirstStationDummy = Stations.ElementAtOrDefault(1);
if (FirstStationSchedule == null || FirstStationSchedule.HasSchedule)
{
FirstStationDummy = new TrainScheduleStationViewModel();
FirstStationSchedule = new TrainScheduleStationViewModel(CurrentTrain.Start, false);
Dispatcher.Invoke(() => Stations.Insert(0, FirstStationDummy));
Dispatcher.Invoke(() => Stations.Insert(0, FirstStationSchedule));
}
CurrentSchedules.Add(FirstStationDummy);
CurrentSchedules.Add(FirstStationSchedule);
}
if (!HasDestinationStation && CurrentTrain.Destination != null)
{
LastStationSchedule = Stations.LastOrDefault();
LastStationDummy = Stations.ElementAtOrDefault(Stations.Count - 2);
if (LastStationSchedule == null || LastStationSchedule.HasSchedule || LastStationSchedule == FirstStationDummy)
{
LastStationDummy = new TrainScheduleStationViewModel();
LastStationSchedule = new TrainScheduleStationViewModel(CurrentTrain.Destination, true);
Dispatcher.Invoke(() => Stations.Add(LastStationDummy));
Dispatcher.Invoke(() => Stations.Add(LastStationSchedule));
}
CurrentSchedules.Add(LastStationDummy);
CurrentSchedules.Add(LastStationSchedule);
}
bool PreviousVisible = false;
bool DummyFlag = false;
bool Reorder = false;
// Group schedules by station and time to avoid duplicate entries for stations that are located between ESTW bordery stations when both ESTWs are loaded
// i.e. Bosserode and Obersuhl are located between Hönebach (ESTW Bebra) and Gerstungen (ESTW Eisenach)
foreach (var ScheduleGroup in SchedulesResult.Result.GroupBy(s => new { s.Station.ShortSymbol, s.Time }))
{
bool GroupVisible = false;
foreach (var Schedule in ScheduleGroup)
{
if (Schedule.Station == null)
{
continue;
}
bool Visible = true;
bool IsNew = false;
var Current = Stations.FirstOrDefault(s => s.CurrentSchedule == Schedule);
if (Current == null)
{
Current = new TrainScheduleStationViewModel(Schedule);
Current.PropertyChanged += __Station_PropertyChanged;
IsNew = true;
}
else if (Reorder)
{
Dispatcher.Invoke(() => Stations.Remove(Current));
IsNew = true;
}
Current.Departure = Schedule.Departure; // For special trains schedule is generated at runtime
if (!Settings.DisplayCompleteTrainSchedule && !Schedule.Station.ESTW.Stations.Any(s => Runtime.VisibleStations.Contains(s)))
{
Visible = Schedule.Handling == eHandling.Start || Schedule.Handling == eHandling.Destination;
}
if (Area.LiveTrains.ContainsKey(CurrentTrain.Number))
{
m_LiveTrain = Area.LiveTrains[CurrentTrain.Number];
var LiveSchedule = m_LiveTrain.Schedules.FirstOrDefault(s => s.Schedule == Schedule);
if (LiveSchedule != null)
{
if (FirstStationSchedule != null)
{
FirstStationSchedule.IsArrived = m_LiveTrain.Schedules.Any(s => s.IsArrived);
FirstStationSchedule.IsDeparted = FirstStationSchedule.IsArrived;
}
if (FirstStationDummy != null)
{
FirstStationDummy.IsArrived = m_LiveTrain.Schedules.Any(s => s.IsArrived);
FirstStationDummy.IsDeparted = FirstStationDummy.IsArrived;
}
if (LiveSchedule.ExpectedArrival != null && Schedule.Arrival != null)
{
Current.DelayArrival = (LiveSchedule.ExpectedArrival - Schedule.Arrival).TotalMinutes;
}
else
{
Current.DelayArrival = null;
}
if (LiveSchedule.ExpectedDeparture != null && Schedule.Departure != null)
{
Current.DelayDeparture = (LiveSchedule.ExpectedDeparture - Schedule.Departure).TotalMinutes;
}
else
{
Current.DelayDeparture = null;
}
Current.IsDelayManuallySet = LiveSchedule.ExpectedDelay.HasValue && !LiveSchedule.IsDeparted;
var Index = m_LiveTrain.Schedules.IndexOf(LiveSchedule);
if (m_LiveTrain.Schedules.Where((schedule, index) => index > Index && (schedule.Schedule.Station.ShortSymbol != Schedule.Station.ShortSymbol || schedule.Schedule.Time != Schedule.Time) && schedule.IsArrived).Any())
{
Current.IsArrived = true;
Current.IsDeparted = true;
var isSkipped = !LiveSchedule.IsArrived && !LiveSchedule.IsDeparted;
if (Current.IsSkipped && !isSkipped)
{
// Trigger re-ordering of this and all subsequent entries
Dispatcher.Invoke(() => Stations.Remove(Current));
IsNew = true;
Reorder = true;
}
Current.IsSkipped = isSkipped;
}
else
{
Current.IsArrived = LiveSchedule.IsArrived;
Current.IsDeparted = LiveSchedule.IsDeparted;
}
Current.LiveTrack = LiveSchedule.LiveTrack;
var Minutes = LiveSchedule.Delays.Sum(d => d.Minutes);
if (LiveSchedule.Delays.Any(d => d.Reason.IsNullOrWhiteSpace()) && Schedule.Station.ESTW.Stations.Any(s => Runtime.VisibleStations.Contains(s)))
{
Current.DelayInfo = String.Format("+{0} Bitte begründen!", Minutes);
Dispatcher.Invoke(() => Current.IsDelayJustified = false);
}
else if (LiveSchedule.Delays.Any(d => d.Reason.IsNotNullOrWhiteSpace()))
{
Current.DelayInfo = String.Format("+{0} {1}", Minutes, String.Join(", ", LiveSchedule.Delays.Where(d => d.Reason.IsNotNullOrWhiteSpace()).Select(d =>
{
string result = d.Reason;
if (d.CausedBy.HasValue)
{
result += String.Format(" ({0})", d.CausedBy);
}
return(result);
})));
Dispatcher.Invoke(() => Current.IsDelayJustified = true);
}
else
{
Current.DelayInfo = null;
}
}
}
GroupVisible |= Visible;
if (Visible)
{
if (IsNew)
{
int Index = -1;
if (Current.LiveTime != null)
{
for (int i = 0; i < Stations.Count; i++)
{
if (Stations[i].HasSchedule && Stations[i].LiveTime > Current.LiveTime)
{
Index = i;
break;
}
}
}
if (Index == -1)
{
for (int i = 0; i < Stations.Count; i++)
{
if (Stations[i].HasSchedule && Stations[i].CurrentSchedule.Time > Current.CurrentSchedule.Time)
{
Index = i;
break;
}
}
}
if (Index == -1)
{
Index = Stations.Count;
}
Dispatcher.Invoke(() => Stations.Insert(Index, Current));
}
CurrentSchedules.Add(Current);
if (DummyFlag)
{
var Index = Stations.IndexOf(Current);
var Dummy = Stations.ElementAtOrDefault(Index - 1);
if (Dummy == null || Dummy.HasStation)
{
Dummy = new TrainScheduleStationViewModel();
Dispatcher.Invoke(() => Stations.Insert(Index, Dummy));
}
Dummy.IsArrived = Current.IsArrived;
Dummy.IsDeparted = Current.IsArrived;
CurrentSchedules.Add(Dummy);
DummyFlag = false;
}
break;
}
}
if (!GroupVisible && PreviousVisible)
{
DummyFlag = true;
}
PreviousVisible = GroupVisible;
}
var RemovedItems = Stations.Except(CurrentSchedules).ToList();
Dispatcher.Invoke(() => RemovedItems.ForEach(s => Stations.Remove(s)));
}
public void Refresh(Area Area)
{
var SettingsResult = m_SettingsBll.GetSettings();
if (!SettingsResult.Succeeded)
{
MessageBox.Show(SettingsResult.Message, "Fehler", MessageBoxButton.OK, MessageBoxImage.Error);
return;
}
var Settings = SettingsResult.Result;
var CurrentTrains = new List <TrainStationViewModel>();
foreach (var LiveTrain in Area.LiveTrains.Values)
{
if (LiveTrain.Train == null)
{
continue;
}
var Train = LiveTrain.Train;
foreach (var LiveSchedule in LiveTrain.Schedules)
{
if (LiveSchedule.Schedule == null || LiveSchedule.Schedule.Station == null)
{
continue;
}
var Schedule = LiveSchedule.Schedule;
var Station = Schedule.Station;
bool Visible = true;
bool IsNew = false;
if (!Runtime.VisibleStations.Contains(Station))
{
Visible = false;
}
LeibitTime ActualTime;
if (LiveTrain.Block != null && LiveTrain.Block.Track != null)
{
ActualTime = LiveTrain.Block.Track.Station.ESTW.Time;
}
else
{
ActualTime = Area.ESTWs.Where(e => e.IsLoaded).DefaultIfEmpty().Max(e => e.Time);
}
if (ActualTime != null && LiveTrain.LastModified != null && ActualTime > LiveTrain.LastModified.AddMinutes(1))
{
Visible = false;
}
var Current = Trains.FirstOrDefault(t => t.Station.ShortSymbol == Station.ShortSymbol && t.TrainNumber == Train.Number && t.Schedule.Time == Schedule.Time);
if (Current == null)
{
Current = new TrainStationViewModel(LiveTrain, Schedule);
IsNew = true;
}
Current.Delay = LiveTrain.Delay;
Current.ExpectedArrival = LiveSchedule.ExpectedArrival;
Current.ExpectedDeparture = LiveSchedule.ExpectedDeparture;
Current.LiveTrack = LiveSchedule.LiveTrack == null || LiveSchedule.LiveTrack.Name == Schedule.Track?.Name ? null : LiveSchedule.LiveTrack;
Current.LocalOrders = Schedule.LocalOrders.IsNotNullOrWhiteSpace() ? 'J' : ' ';
var NextSchedules = LiveTrain.Schedules.Skip(LiveTrain.Schedules.IndexOf(LiveSchedule) + 1);
if (NextSchedules.Any(s => (s.Schedule.Station.ShortSymbol != Station.ShortSymbol || s.Schedule.Time != Schedule.Time) && s.LiveArrival != null))
{
Visible = false;
}
var Delays = LiveTrain.Schedules.SelectMany(s => s.Delays);
var UnjustifiedDelays = Delays.Where(d => d.Reason.IsNullOrWhiteSpace() && d.Schedule.Schedule.Station.ESTW.Stations.Any(s => Runtime.VisibleStations.Contains(s)));
if (UnjustifiedDelays.Any())
{
Current.DelayInfo = 'U';
if (UnjustifiedDelays.Any(d => d.Schedule.Schedule.Station.ShortSymbol == Schedule.Station.ShortSymbol))
{
Visible = true;
}
}
else if (Delays.Any(d => d.Reason.IsNotNullOrWhiteSpace()))
{
Current.DelayInfo = 'J';
}
else
{
Current.DelayInfo = ' ';
}
if (Visible)
{
if (LiveTrain.Block != null && LiveTrain.Block.Track != null && LiveTrain.Block.Track.Station != null)
{
Current.CurrentStation = LiveTrain.Block.Track.Station;
var CurrentSchedule = LiveTrain.Schedules.LastOrDefault(s => s.IsArrived && s.Schedule != null && s.Schedule.Station != null && s.Schedule.Station.ShortSymbol == LiveTrain.Block.Track.Station.ShortSymbol);
if (CurrentSchedule == null)
{
Current.State = LiveSchedule.IsDeparted ? "beendet" : "ab";
}
else
{
int CurrentScheduleIndex = LiveTrain.Schedules.IndexOf(CurrentSchedule);
int LiveScheduleIndex = LiveTrain.Schedules.IndexOf(LiveSchedule);
if (LiveSchedule.Schedule.Station.ShortSymbol == CurrentSchedule.Schedule.Station.ShortSymbol && LiveSchedule.Schedule.Time == Current.Schedule.Time)
{
CurrentScheduleIndex = LiveScheduleIndex;
}
if (CurrentScheduleIndex > LiveScheduleIndex)
{
Current.State = "beendet";
}
else if (!CurrentSchedule.IsDeparted)
{
if (CurrentSchedule.Schedule.Handling == eHandling.Start &&
Settings.AutomaticReadyMessageEnabled &&
CurrentSchedule.Schedule.Station.ESTW.Time >= CurrentSchedule.Schedule.Departure.AddMinutes(-Settings.AutomaticReadyMessageTime))
{
Current.State = "fertig";
}
else
{
Current.State = "an";
}
}
else
{
if (CurrentScheduleIndex == LiveScheduleIndex)
{
Current.State = "beendet";
}
else
{
Current.State = "ab";
}
}
}
}
if (IsNew)
{
Dispatcher.Invoke(() => Trains.Add(Current));
}
CurrentTrains.Add(Current);
}
}
}
var RemovedTrains = Trains.Except(CurrentTrains).ToList();
Dispatcher.Invoke(() => RemovedTrains.ForEach(t => Trains.Remove(t)));
}