public DBLogonViewModel(IUIVisualizerService uiVisualizer, IMessageBoxService messageBoxService, IViewAwareStatus viewAwareStatusService)
{
this.uiVisualizer = uiVisualizer;
this.messageBoxService = messageBoxService;
this.viewAwareStatusService = viewAwareStatusService;
this.viewAwareStatusService.ViewLoaded += ViewAwareStatusService_ViewLoaded;
}
public ImageLoaderViewModel(
IMessageBoxService messageBoxService,
IOpenFileService openFileService,
ISaveFileService saveFileService,
IUIVisualizerService uiVisualizerService,
IImageProvider imageProvider,
IImageDiskOperations imageDiskOperations,
IViewAwareStatus viewAwareStatusService)
{
//setup services
this.messageBoxService = messageBoxService;
this.openFileService = openFileService;
this.saveFileService = saveFileService;
this.uiVisualizerService = uiVisualizerService;
this.imageProvider = imageProvider;
this.imageDiskOperations = imageDiskOperations;
this.viewAwareStatusService = viewAwareStatusService;
this.viewAwareStatusService.ViewLoaded += ViewAwareStatusService_ViewLoaded;
//commands, SimpleCommand<T1,T2> T1 is CanExecute parameter type, and T2 is Execute type
AddImageRatingCommand = new SimpleCommand <Object, Object>(ExecuteAddImageRatingCommand);
SaveToFileCommand = new SimpleCommand <Object, Object>(ExecuteSaveToFileCommand);
OpenExistingFileCommand = new SimpleCommand <Object, Object>(ExecuteOpenExistingFileCommand);
//EventToCommand triggered, see the View
ShowActionsCommand = new SimpleCommand <Object, Object>(ExecuteShowActionsCommand);
HideActionsCommand = new SimpleCommand <Object, Object>(ExecuteHideActionsCommand);
//some reverse commands, that the VM fires, and the View uses as CompletedAwareCommandTriggers
//to carry out some actions. In this case GoToStateActions are used in the View
ShowActionsCommandReversed = new SimpleCommand <Object, Object>((input) => { });
HideActionsCommandReversed = new SimpleCommand <Object, Object>((input) => { });
}
protected override void ConfigureViewModelLocator()
{
ViewModelLocationProvider.SetDefaultViewTypeToViewModelTypeResolver((viewType) =>
{
string?viewName = viewType.FullName;
viewName = viewName?.Replace(".Views.", ".ViewModels.");
string?viewAssemblyName = viewType.GetTypeInfo().Assembly.FullName;
string?suffix = viewName != null && (viewName.EndsWith("View") | viewName.EndsWith("Window")) ? "Model" : "ViewModel";
string viewModelName = string.Format(CultureInfo.InvariantCulture, "{0}{1}, {2}", viewName, suffix, viewAssemblyName);
return(Type.GetType(viewModelName));
});
ViewModelLocationProvider.SetDefaultViewModelFactory((view, type) =>
{
object vm = ContainerLocator.Container.Resolve(type);
if (vm is IViewAwareStatusInjectionAware contextViewModel)
{
IViewAwareStatus service = ContainerLocator.Container.Resolve <IViewAwareStatus>();
service.InjectContext(view);
contextViewModel.InitialiseViewAwareService(service);
return(vm);
}
if (vm is IWindowAwareStatusInjectionAware contextWindowModel)
{
IWindowAwareStatus service = ContainerLocator.Container.Resolve <IWindowAwareStatus>();
service.InjectContext(view);
contextWindowModel.InitialiseWindowAwareService(service);
return(vm);
}
return(vm);
});
}
public MainWindowViewModel(IViewAwareStatus viewAwareStatusService, IMessageBoxService messageBoxService)
{
this.viewAwareStatusService = viewAwareStatusService;
this.viewAwareStatusService.ViewLoaded += ViewAwareStatusService_ViewLoaded;
this.MessageBoxService = messageBoxService;
this.UIVisualizerService = ViewModelRepository.Instance.Resolver.Container.GetExport <IUIVisualizerService>().Value;
this.DisplayName = "Main Window";
this.ViewProfileCommand = new CommandBase <User>(o => this.ExecuteViewProfileCommand(o));
if (Designer.IsInDesignMode)
{
return;
}
// add view
WorkspaceData workspace = new WorkspaceData(@"/XRMS.Presentation;component/Images/Cashier.png",
"CashierOrdersView", null, "Orders Management", false);
Views.Add(workspace);
SetActiveWorkspace(workspace);
_refreshingTimer = new DispatcherTimer();
_refreshingTimer.Tick += new EventHandler(OnRefreshingData);
_refreshingTimer.Interval = TimeSpan.FromMilliseconds(1000);
_refreshingTimer.Start();
ReadRestaurantInfo();
}
public PrettierDisplayViewModel(ITweetService tweetService, IViewAwareStatus viewAwareStatus)
: base(tweetService)
{
viewAwareStatus.ViewLoaded += () =>
{
MessageBoxService.ShowInformation("You loaded the pretty view!");
_isLoaded = true;
// use common if you want to loosely couple from the logger type
Logger.Default.Debug("Pretty loaded");
};
viewAwareStatus.ViewUnloaded += () => _isLoaded = false;
TweetSearchTweets.CurrentChanged += (s, e) =>
{
if (!_isLoaded)
{
return;
}
var current = TweetSearchTweets.CurrentItem as LinqTweet;
if (current != null)
{
Process.Start(current.Link);
}
};
}
public LoginViewViewModel(IViewAwareStatus viewAwareStatus, IAuthenticateService authenticateService,
IMessageBoxService messageBoxService, IBusinessUnitService businessUnitService, IViewInjectionService viewInjectionService)
{
//base.IsCloseable = true;
//Initialise Services
this.viewAwareStatus = viewAwareStatus;
this.authenticateService = authenticateService;
this.messageBoxService = messageBoxService;
this.businessUnitService = businessUnitService;
this.viewInjectionService = viewInjectionService;
//this.regionManager = regionManager;
//Initialise Properties
UserName = new DataWrapper <string>(this, userNameArgs);
Password = new DataWrapper <string>(this, passwordArgs);
SelectedBusinessUnit = new DataWrapper <Int32>(this, businessUnitsArgs);
this.viewAwareStatus.ViewLoaded += new Action(viewAwareStatus_ViewLoaded);
cachedListOfDataWrappers =
DataWrapperHelper.GetWrapperProperties <LoginViewViewModel>(this);
//Register Mediator
Mediator.Instance.Register(this);
//Initialise Rules
userName.AddRule(UserNameCannnotBeEmptyRule);
password.AddRule(PasswordCannotBeEmptyRule);
selectedBusinessUnit.AddRule(SelectedBusinessUnitCannotBeEmpty);
//Initialise Commands
LoginCommand = new SimpleCommand <object, object>(CanExecuteLoginCommand, ExecuteLoginCommand);
CancelLoginCommand = new SimpleCommand <object, object>(ExecuteCancelLoginCommand);
}
public UserListViewViewModel(IViewAwareStatus viewAwareStatus, IMessageBoxService messageBoxService, IUserService userService)
{
this.viewAwareStatus = viewAwareStatus;
this.messageBoxService = messageBoxService;
this.userService = userService;
Mediator.Instance.Register(this);
this.viewAwareStatus.ViewLoaded += new Action(viewAwareStatus_ViewLoaded);
}
public UserListViewViewModel(IViewAwareStatus viewAwareStatus, IMessageBoxService messageBoxService, IUserService userService)
{
this.viewAwareStatus = viewAwareStatus;
this.messageBoxService = messageBoxService;
this.userService = userService;
Mediator.Instance.Register(this);
this.viewAwareStatus.ViewLoaded += new Action(viewAwareStatus_ViewLoaded);
}
public CreateMeetViewModel(IViewAwareStatus viewAwareStatus, IMessageBoxService messageBoxService)
{
this.viewAwareStatus = viewAwareStatus;
this.messageBoxService = messageBoxService;
//Commands
CreateMeetCommand = new SimpleCommand<Object, Object>(CanExecuteCreateMeetCommand, ExecuteCreateMeetCommand);
Mediator.Instance.Register(this);
}
public ShellViewModel(IViewAwareStatus viewAwareStatus,
IMessageBoxService messageBoxService)
{
this.viewAwareStatus = viewAwareStatus;
this.messageBoxService = messageBoxService;
//Commands
AddNewMeetCommand = new SimpleCommand<Object, Object>(ExecuteAddNewMeetCommand);
Mediator.Instance.Register(this);
}
public MainWindowViewModel([NotNull] IViewAwareStatus viewAwareStatus,
IMessageBoxService messageBox,
IUIVisualizerService visualizer,
IHRCSaveFileService saveFile)
{
_viewAwareStatus = viewAwareStatus;
_messageBox = messageBox;
_visualizer = visualizer;
_saveFile = saveFile;
_viewAwareStatus.ViewLoaded += () => _visualizer.ShowWindow("PSMBrowserView", new PSMBrowserViewModel(),false,(s, e) => Application.Current.Shutdown());
}
public TablesViewModel(IUIVisualizerService uiVisualizer, IMessageBoxService messageBoxService, IViewAwareStatus viewAwareStatusService)
{
this.uiVisualizer = uiVisualizer;
this.messageBoxService = messageBoxService;
this.viewAwareStatusService = viewAwareStatusService;
this.viewAwareStatusService.ViewLoaded += ViewAwareStatusService_ViewLoaded;
_backgroundWorker = new BackgroundWorker();
_backgroundWorker.DoWork += _backgroundWorker_DoWork;
_backgroundWorker.RunWorkerCompleted += _backgroundWorker_RunWorkerCompleted;
}
public UserRibbonViewViewModel(IMessageBoxService messageBoxService, IViewAwareStatus viewAwareStatus, IViewInjectionService viewInjectionService)
{
this.messageBoxService = messageBoxService;
this.viewAwareStatus = viewAwareStatus;
this.viewInjectionService = viewInjectionService;
Mediator.Instance.Register(this);
//Initialise Commands
AddNewUserCommand = new SimpleCommand <object, object>(CanExecuteAddNewUserCommand, ExecuteAddNewUserCommand);
ViewAllUsersCommand = new SimpleCommand <object, object>(CanExecuteViewAllUsersCommand, ExecuteViewAllUsersCommand);
}
public ForeignKeysViewModel(IUIVisualizerService uiVisualizer, IMessageBoxService messageBoxService, IViewAwareStatus viewAwareStatusService)
{
this.uiVisualizer = uiVisualizer;
this.messageBoxService = messageBoxService;
this.viewAwareStatusService = viewAwareStatusService;
this.viewAwareStatusService.ViewLoaded += ViewAwareStatusService_ViewLoaded;
//Commands
DoCopyToClipboardCommand = new SimpleCommand <Object, Object>(ExecuteDoCopyToClipboardCommand);
DoSaveAsCommand = new SimpleCommand <Object, Object>(ExecuteDoSaveAsCommand);
}
public UserRibbonViewViewModel(IMessageBoxService messageBoxService, IViewAwareStatus viewAwareStatus, IViewInjectionService viewInjectionService)
{
this.messageBoxService = messageBoxService;
this.viewAwareStatus = viewAwareStatus;
this.viewInjectionService = viewInjectionService;
Mediator.Instance.Register(this);
//Initialise Commands
AddNewUserCommand = new SimpleCommand<object, object>(CanExecuteAddNewUserCommand, ExecuteAddNewUserCommand);
ViewAllUsersCommand = new SimpleCommand<object, object>(CanExecuteViewAllUsersCommand, ExecuteViewAllUsersCommand);
}
public MainViewViewModel( IViewAwareStatus viewAwareStatus, IMessageBoxService messageBoxService, IViewInjectionService viewInjectionService)
{
//this.regionManager = regionManager;
this.viewAwareStatus = viewAwareStatus;
this.messageBoxService = messageBoxService;
this.viewInjectionService = viewInjectionService;
this.viewAwareStatus.ViewLoaded += new Action(viewAwareStatus_ViewLoaded);
//Listen for login event
Mediator.Instance.Register(this);
LogoutCommand = new SimpleCommand<object, object>(ExecuteLogoutCommand);
}
public MainViewViewModel(IViewAwareStatus viewAwareStatus, IMessageBoxService messageBoxService, IViewInjectionService viewInjectionService)
{
//this.regionManager = regionManager;
this.viewAwareStatus = viewAwareStatus;
this.messageBoxService = messageBoxService;
this.viewInjectionService = viewInjectionService;
this.viewAwareStatus.ViewLoaded += new Action(viewAwareStatus_ViewLoaded);
//Listen for login event
Mediator.Instance.Register(this);
LogoutCommand = new SimpleCommand <object, object>(ExecuteLogoutCommand);
}
public MainWindowViewModel(IViewAwareStatus viewAwareStatusService, IMessageBoxService messageBoxService)
{
this.viewAwareStatusService = viewAwareStatusService;
this.viewAwareStatusService.ViewLoaded += ViewAwareStatusService_ViewLoaded;
this.messageBoxService = messageBoxService;
//Create an instance of the background worker used for generating the script events.
_generateScriptsBackgroundWorker = new BackgroundWorker();
_generateScriptsBackgroundWorker.DoWork += _generateScriptsBackgroundWorker_DoWork;
_generateScriptsBackgroundWorker.RunWorkerCompleted += _generateScriptsBackgroundWorker_RunWorkerCompleted;
InitialiseViewModel();
}
public HomepageViewModel(IUIVisualizerService uiVisualizer, IMessageBoxService messageBoxService, IViewAwareStatus viewAwareStatusService)
{
this.uiVisualizer = uiVisualizer;
this.messageBoxService = messageBoxService;
this.viewAwareStatusService = viewAwareStatusService;
this.viewAwareStatusService.ViewLoaded += ViewAwareStatusService_ViewLoaded;
_backgroundWorker = new BackgroundWorker();
_backgroundWorker.DoWork += _backgroundWorker_DoWork;
_backgroundWorker.RunWorkerCompleted += _backgroundWorker_RunWorkerCompleted;
//Commands
DoScriptCommand = new SimpleCommand <Object, Object>(ExecuteDoScriptCommand);
}
public ViewAllUsersViewViewModel(IMessageBoxService messageBoxService, IViewAwareStatus viewAwareStatus,
IViewInjectionService viewInjectionService, IUserService userService, IOpenFileService openFileService)
{
this.messageBoxService = messageBoxService;
this.viewAwareStatus = viewAwareStatus;
this.userService = userService;
this.viewInjectionService = viewInjectionService;
this.openFileService = openFileService;
Mediator.Instance.Register(this);
//Initialise Commands
UpdateUserCommand = new SimpleCommand<object, object>(CanExecuteUpdateUserCommand, ExecuteUpdateUserCommand);
UploadUserImageCommand = new SimpleCommand<object, object>(CanExecuteUploadUserImageCommand,
ExecuteUploadUserImageCommand);
viewAwareStatus.ViewLoaded += new Action(viewAwareStatus_ViewLoaded);
}
public StoredProcsViewModel(IUIVisualizerService uiVisualizer, IMessageBoxService messageBoxService, IViewAwareStatus viewAwareStatusService)
{
this.uiVisualizer = uiVisualizer;
this.messageBoxService = messageBoxService;
this.viewAwareStatusService = viewAwareStatusService;
this.viewAwareStatusService.ViewLoaded += ViewAwareStatusService_ViewLoaded;
_backgroundWorker = new BackgroundWorker();
_backgroundWorker.DoWork += _backgroundWorker_DoWork;
_backgroundWorker.RunWorkerCompleted += _backgroundWorker_RunWorkerCompleted;
//Commands
DoCopyToClipboardCommand = new SimpleCommand <Object, Object>(ExecuteDoCopyToClipboardCommand);
DoSaveAsCommand = new SimpleCommand <Object, Object>(ExecuteDoSaveAsCommand);
}
public ViewAllUsersViewViewModel(IMessageBoxService messageBoxService, IViewAwareStatus viewAwareStatus,
IViewInjectionService viewInjectionService, IUserService userService, IOpenFileService openFileService)
{
this.messageBoxService = messageBoxService;
this.viewAwareStatus = viewAwareStatus;
this.userService = userService;
this.viewInjectionService = viewInjectionService;
this.openFileService = openFileService;
Mediator.Instance.Register(this);
//Initialise Commands
UpdateUserCommand = new SimpleCommand <object, object>(CanExecuteUpdateUserCommand, ExecuteUpdateUserCommand);
UploadUserImageCommand = new SimpleCommand <object, object>(CanExecuteUploadUserImageCommand,
ExecuteUploadUserImageCommand);
viewAwareStatus.ViewLoaded += new Action(viewAwareStatus_ViewLoaded);
}
public UglyDisplayViewModel(ITweetService tweetService, IViewAwareStatus viewAwareStatus)
: base(tweetService)
{
viewAwareStatus.ViewLoaded += () =>
{
//MessageBoxService.ShowInformation("You loaded the ugly view!");
Logger.Default.Debug("Ugly loaded");
State = Loaded;
if (!_injected)
{
_injected = true;
RegisterAndActivateView <ITweetBrowser>("BrowserRegion");
}
};
viewAwareStatus.ViewUnloaded += () => State = Unloaded;
}
public MainViewModel(IHRCSaveFileService saveFileService, IViewAwareStatus viewAwareStatus, IMasterDatabaseService database)
{
ESME.Globals.SaveFileService = saveFileService;
ESME.Globals.ViewAwareStatusService = viewAwareStatus;
ESME.Globals.MasterDatabaseService = database;
if (!Designer.IsInDesignMode)
{
viewAwareStatus.ViewLoaded += () =>
{
TransmissionLossViewModel.RadialViewModel = new RadialViewModel { RadialView = ((Window)viewAwareStatus.View).FindChildren<RadialView>().First() };
TransmissionLossViewModel.SaveFileService = saveFileService;
TransmissionLossViewModel.RadialViewModel.WaitToRenderText = "No Scenario Selected";
};
viewAwareStatus.ViewActivated += () => ESME.Globals.MasterDatabaseService.Refresh();
}
}
public MainWindowViewModel(IViewAwareStatus viewAwareStatus)
{
_viewAwareStatus = viewAwareStatus;
_viewAwareStatus.ViewLoaded += () =>
{
_dispatcher = ((Window)_viewAwareStatus.View).Dispatcher;
CreateTopLeftSeries();
CreateTopRightSeries();
CreateMiddleLeftSeries();
CreateMiddleRightSeries();
CreateBottomLeftSeries();
CreateBottomRightSeries();
#if true
var timer = new DispatcherTimer(DispatcherPriority.Background, _dispatcher) { Interval = TimeSpan.FromMilliseconds(5) };
timer.Start();
timer.Tick += (s, e) =>
{
if (AnimateMiddleLeft)
{
var selectedSeries = (BarSeriesViewModel)MiddleLeft.DataSeriesCollection[1];
var seriesData = (ObservableList<Tuple<double, double>>)selectedSeries.SeriesData;
selectedSeries.SeriesName = string.Format("y = {0:0.0} * x", _middleLeftAmplitude);
for (var i = 0; i < seriesData.Count; i++) seriesData[i] = Tuple.Create(seriesData[i].Item1, _middleLeftAmplitude * seriesData[i].Item1);
selectedSeries = (BarSeriesViewModel)MiddleLeft.DataSeriesCollection[2];
seriesData = (ObservableList<Tuple<double, double>>)selectedSeries.SeriesData;
selectedSeries.SeriesName = string.Format("y = {0:0.0} * x", -_middleLeftAmplitude);
for (var i = 0; i < seriesData.Count; i++) seriesData[i] = Tuple.Create(seriesData[i].Item1, -_middleLeftAmplitude * seriesData[i].Item1);
_middleLeftAmplitude += _middleLeftAmplitudeDelta;
if (_middleLeftAmplitude > 10) _middleLeftAmplitudeDelta = -1;
if (_middleLeftAmplitude < -10) _middleLeftAmplitudeDelta = 1;
}
if (!AnimateTopLeft) return;
for (var seriesIndex = 0; seriesIndex < TopLeft.DataSeriesCollection.Count; seriesIndex++)
{
var selectedSeries = (LineSeriesViewModel)TopLeft.DataSeriesCollection[seriesIndex];
var seriesData = (ObservableList<Tuple<double, double>>)selectedSeries.SeriesData;
selectedSeries.SeriesName = string.Format("y = ({0:0.0} * sin(x)) + {1}", _topLeftAmplitude, 11 - seriesIndex);
for (var i = 0; i < seriesData.Count; i++) seriesData[i] = Tuple.Create(seriesData[i].Item1, (_topLeftAmplitude * Math.Sin(seriesData[i].Item1)) + (11 - seriesIndex));
}
_topLeftAmplitude += _topLeftAmplitudeDelta;
if (_topLeftAmplitude > 10) _topLeftAmplitudeDelta = -1;
if (_topLeftAmplitude < -10) _topLeftAmplitudeDelta = 1;
};
#endif
};
}
public AddNewUserViewViewModel(IViewAwareStatus viewAwareStatus, IMessageBoxService messageBoxService, IUserService userService, IOpenFileService openFileService)
{
this.viewAwareStatus = viewAwareStatus;
this.messageBoxService = messageBoxService;
this.userService = userService;
this.openFileService = openFileService;
NewUser = new User();
NewUser.PhotoPath.DataValue = GymSoft.CinchMVVM.Common.GymSoftConfigurationManger.GetDefaultUserPicture().ToString();
//messageBoxService.ShowInformation(Directory.GetCurrentDirectory());
//Initialise Commands
AddNewUserCommand = new SimpleCommand<object, object>(CanAddNewUserCommand, ExecuteAddNewUserCommand);
CancelAddNewUserCommand = new SimpleCommand<object, object>(ExecuteCancelAddNewUserCommand);
UploadUserImageCommand = new SimpleCommand<object, object>(CanExecuteUploadUserImageCommand,
ExecuteUploadUserImageCommand);
//this._viewAwareStatus.ViewLoaded += new Action(_viewAwareStatus_ViewLoaded);
}
public AddNewUserViewViewModel(IViewAwareStatus viewAwareStatus, IMessageBoxService messageBoxService, IUserService userService, IOpenFileService openFileService)
{
this.viewAwareStatus = viewAwareStatus;
this.messageBoxService = messageBoxService;
this.userService = userService;
this.openFileService = openFileService;
NewUser = new User();
NewUser.PhotoPath.DataValue = GymSoft.CinchMVVM.Common.GymSoftConfigurationManger.GetDefaultUserPicture().ToString();
//messageBoxService.ShowInformation(Directory.GetCurrentDirectory());
//Initialise Commands
AddNewUserCommand = new SimpleCommand <object, object>(CanAddNewUserCommand, ExecuteAddNewUserCommand);
CancelAddNewUserCommand = new SimpleCommand <object, object>(ExecuteCancelAddNewUserCommand);
UploadUserImageCommand = new SimpleCommand <object, object>(CanExecuteUploadUserImageCommand,
ExecuteUploadUserImageCommand);
//this._viewAwareStatus.ViewLoaded += new Action(_viewAwareStatus_ViewLoaded);
}
public MainWindowViewModel(
IViewAwareStatus viewAwareStatusService,
IMessageBoxService messageBoxService,
IUIVisualizerService uiVisualizerService,
IOpenFileService openFileService,
ISaveFileService saveFileService,
ISavePNGFileService savePNGService,
IPrintPNGFileService printPNGFileService,
IAssemblyManipulationService assemblyManipulationService
)
{
SettingsViewModel.Instance.SetGraphObject(graphLayout);
this.assemblyManipulationService = assemblyManipulationService;
this.viewAwareStatusService = viewAwareStatusService;
this.viewAwareStatusService.ViewLoaded += ViewAwareStatusService_ViewLoaded;
this.messageBoxService = messageBoxService;
this.uiVisualizerService = uiVisualizerService;
this.openFileService = openFileService;
this.saveFileService = saveFileService;
this.savePNGService = savePNGService;
this.printPNGFileService = printPNGFileService;
//Commands
SaveSettingsAsXmlCommand = new SimpleCommand <Object, Object>(ExecuteSaveSettingsAsXmlCommand);
ShowSettingsWindowCommand = new SimpleCommand <Object, Object>(NotBusyCheck, ExecuteShowSettingsWindowCommand);
OpenFileCommand = new SimpleCommand <Object, Object>(NotBusyCheck, ExecuteOpenFileCommand);
OpenFileDragCommand = new SimpleCommand <Object, Object>(NotBusyCheck, ExecuteOpenFileDragCommand);
CommenceDrawingCommand = new SimpleCommand <Object, Object>(CanExecuteCommenceDrawingCommand, ExecuteCommenceDrawingCommand);
ReLayoutCommand = new SimpleCommand <Object, Object>(NotBusyCheckAndNotDrawingAndHasGraphCheck, ExecuteReLayoutCommand);
SaveCommand = new SimpleCommand <Object, Object>(NotBusyCheckAndNotDrawingAndHasGraphCheck, ExecuteSaveCommand);
PrintFileCommand = new SimpleCommand <Object, Object>(NotBusyCheckAndNotDrawingAndHasGraphCheck, ExecutePrintFileCommand);
ShowSpecificNotAssociatedVertexCommand = new SimpleCommand <Object, Object>(ExecuteShowSpecificNotAssociatedVertexCommand);
AboutCommand = new SimpleCommand <Object, Object>(NotBusyCheck, ExecuteAboutCommand);
HelpCommand = new SimpleCommand <Object, Object>(NotBusyCheck, ExecuteHelpCommand);
CollapseVertexRegionsCommand = new SimpleCommand <Object, Object>(NotBusyCheckAndNotDrawingAndHasGraphCheck, ExecuteCollapseVertexRegionsCommand);
Mediator.Instance.Register(this);
}
public MainWindowViewModel(IViewAwareStatus viewAwareStatusService)
{
ExpandAllCommand = new SimpleCommand <object, EventToCommandArgs>((commandParameter) =>
{
TreeModel.ToggleExpanded(this.ItemsSource, true);
});
CollapseAllCommand = new SimpleCommand <object, EventToCommandArgs>((commandParameter) =>
{
TreeModel.ToggleExpanded(this.ItemsSource, false);
});
GetSelectedCommand = new SimpleCommand <object, EventToCommandArgs>((commandParameter) =>
{
var selectedNode = TreeModel.GetSelectedNode(this.ItemsSource);
this.SelectedDisplayText = selectedNode != null ? selectedNode.DisplayText : "none selected";
});
this._viewAwareStatusService = viewAwareStatusService;
this._viewAwareStatusService.ViewLoaded += ViewAwareStatusService_ViewLoaded;
}
/// <summary>
/// This creates the WPF window from a key.
/// </summary>
/// <param name="key">Key</param>
/// <param name="dataContext">DataContext (state) object</param>
/// <param name="setOwner">True/False to set ownership to MainWindow</param>
/// <param name="completedProc">Callback</param>
/// <param name="isModal">True if this is a ShowDialog request</param>
/// <returns>Success code</returns>
private Window CreateWindow(string key, object dataContext, bool setOwner,
EventHandler <UICompletedEventArgs> completedProc, bool isModal)
{
if (string.IsNullOrEmpty(key))
{
throw new ArgumentNullException("key");
}
Type winType;
lock (_registeredWindows)
{
if (!_registeredWindows.TryGetValue(key, out winType))
{
return(null);
}
}
var win = (Window)Activator.CreateInstance(winType);
if (dataContext is IViewStatusAwareInjectionAware)
{
IViewAwareStatus viewAwareStatus =
ViewModelRepository.Instance.Resolver.Container.GetExport <IViewAwareStatus>().Value;
viewAwareStatus.InjectContext((FrameworkElement)win);
((IViewStatusAwareInjectionAware)dataContext).InitialiseViewAwareService(viewAwareStatus);
}
if (dataContext is IViewStatusAwareWindowInjectionAware)
{
IViewAwareStatusWindow viewAwareStatusWindow =
ViewModelRepository.Instance.Resolver.Container.GetExport <IViewAwareStatusWindow>().Value;
viewAwareStatusWindow.InjectContext((FrameworkElement)win);
((IViewStatusAwareWindowInjectionAware)dataContext).InitialiseViewAwareWindowService(viewAwareStatusWindow);
}
win.DataContext = dataContext;
if (setOwner)
{
win.Owner = Application.Current.MainWindow;
}
if (dataContext != null)
{
var bvm = dataContext as ViewModelBase;
if (bvm != null)
{
if (isModal)
{
bvm.CloseRequest += ((EventHandler <CloseRequestEventArgs>)((s, e) =>
{
try
{
win.DialogResult = e.Result;
}
catch (InvalidOperationException)
{
win.Close();
}
})).MakeWeak(eh => bvm.CloseRequest -= eh);
}
else
{
bvm.CloseRequest += ((EventHandler <CloseRequestEventArgs>)((s, e) => win.Close()))
.MakeWeak(eh => bvm.CloseRequest -= eh);
}
bvm.ActivateRequest += ((EventHandler <EventArgs>)((s, e) => win.Activate()))
.MakeWeak(eh => bvm.ActivateRequest -= eh);
}
}
win.Closed += (s, e) =>
{
win.DataContext = null;
if (completedProc != null)
{
completedProc(this, new UICompletedEventArgs()
{
State = dataContext,
Result = (isModal) ? win.DialogResult : null
});
}
};
return(win);
}
public SimulationLogAnalysisMainViewModel(IViewAwareStatus viewAwareStatus,
IMessageBoxService messageBox,
IUIVisualizerService visualizer,
IHRCSaveFileService saveFile)
{
_viewAwareStatus = viewAwareStatus;
_messageBox = messageBox;
_visualizer = visualizer;
_saveFile = saveFile;
_simulationStartTime = new TimeSpan(0);
_simulationEndTime = new TimeSpan(0);
_viewAwareStatus.ViewLoaded += () =>
{
_dispatcher = ((Window)_viewAwareStatus.View).Dispatcher;
SelectedFileName = (string)Application.Current.Properties["SelectedFileName"];
};
_propertyObserver = new PropertyObserver<SimulationLogAnalysisMainViewModel>(this)
.RegisterHandler(p => p.SelectedFileName, SelectedFileNameChanged)
.RegisterHandler(p => p.AreAnyPlatformsSelected, CommandManager.InvalidateRequerySuggested)
.RegisterHandler(p => p.AreAnyModesSelected, CommandManager.InvalidateRequerySuggested)
.RegisterHandler(p => p.AreAnySpeciesSelected, CommandManager.InvalidateRequerySuggested)
.RegisterHandler(p => p.PerformOurOnlyAnalysis, CommandManager.InvalidateRequerySuggested)
.RegisterHandler(p => p.StartTimeString, StartOrStopTimeStringsChanged)
.RegisterHandler(p => p.StopTimeString, StartOrStopTimeStringsChanged)
.RegisterHandler(p => p.AllTimes,
() =>
{
if (!AllTimes || SelectedFileName == null || !File.Exists(SelectedFileName)) return;
_filterStartTime = new TimeSpan(_simulationStartTime.Ticks);
_filterEndTime = new TimeSpan(_simulationEndTime.Ticks);
StartTimeString = _filterStartTime.ToString(TimeSpanFormatString);
StopTimeString = _filterEndTime.ToString(TimeSpanFormatString);
});
AddValidationRules(new ValidationRule<SimulationLogAnalysisMainViewModel>
{
PropertyName = "StartTimeString",
Description = "Must be a valid, non-negative time span value in the format hh:mm:ss where 00 <= hh <= 23; 00 <= mm <= 59; 00 <= ss <= 59",
IsRuleValid = (target, rule) =>
{
if (AllTimes) return true;
if (string.IsNullOrEmpty(target.StartTimeString)) return false;
TimeSpan timeSpan;
var isOK = TimeSpan.TryParseExact(target.StartTimeString, TimeSpanFormatString, null, out timeSpan);
return isOK && timeSpan.Ticks >= 0;
},
}, new ValidationRule<SimulationLogAnalysisMainViewModel>
{
PropertyName = "StopTimeString",
Description = "Must be a valid, non-negative time span value in the format hh:mm:ss where 00 <= hh <= 23; 00 <= mm <= 59; 00 <= ss <= 59",
IsRuleValid = (target, rule) =>
{
if (AllTimes) return true;
if (string.IsNullOrEmpty(target.StopTimeString)) return false;
TimeSpan timeSpan;
var isOK = TimeSpan.TryParseExact(target.StopTimeString, TimeSpanFormatString, null, out timeSpan);
return isOK && timeSpan.Ticks > 0;
},
});
_startTimeValidationRule = new ValidationRule<SimulationLogAnalysisMainViewModel>
{
PropertyName = "StartTimeString",
Description = string.Format("Must be between {0} and {1}", _simulationStartTime.ToString(TimeSpanFormatString), _filterEndTime.ToString(TimeSpanFormatString)),
IsRuleValid = (target, rule) =>
{
if (AllTimes) return true;
if (_simulationStartTime.Ticks == 0 && _simulationEndTime.Ticks == 0) return true;
if (string.IsNullOrEmpty(target.StartTimeString)) return false;
TimeSpan timeSpan;
var isOK = TimeSpan.TryParseExact(target.StartTimeString, TimeSpanFormatString, null, out timeSpan);
return isOK && timeSpan >= _simulationStartTime && timeSpan < _filterEndTime;
},
};
_endTimeValidationRule = new ValidationRule<SimulationLogAnalysisMainViewModel>
{
PropertyName = "StopTimeString",
Description = string.Format("Must be between {0} and {1}", _filterStartTime.ToString(TimeSpanFormatString), _simulationEndTime.ToString(TimeSpanFormatString)),
IsRuleValid = (target, rule) =>
{
if (AllTimes) return true;
if (_simulationStartTime.Ticks == 0 && _simulationEndTime.Ticks == 0) return true;
if (string.IsNullOrEmpty(target.StopTimeString)) return false;
TimeSpan timeSpan;
var isOK = TimeSpan.TryParseExact(target.StopTimeString, TimeSpanFormatString, null, out timeSpan);
return isOK && timeSpan > _filterStartTime && timeSpan <= _simulationEndTime;
},
};
AddValidationRules(_startTimeValidationRule, _endTimeValidationRule);
}
public LoginViewViewModel(IViewAwareStatus viewAwareStatus, IAuthenticateService authenticateService,
IMessageBoxService messageBoxService, IBusinessUnitService businessUnitService, IViewInjectionService viewInjectionService)
{
//base.IsCloseable = true;
//Initialise Services
this.viewAwareStatus = viewAwareStatus;
this.authenticateService = authenticateService;
this.messageBoxService = messageBoxService;
this.businessUnitService = businessUnitService;
this.viewInjectionService = viewInjectionService;
//this.regionManager = regionManager;
//Initialise Properties
UserName = new DataWrapper<string>(this, userNameArgs);
Password = new DataWrapper<string>(this, passwordArgs);
SelectedBusinessUnit = new DataWrapper<Int32>(this, businessUnitsArgs);
this.viewAwareStatus.ViewLoaded += new Action(viewAwareStatus_ViewLoaded);
cachedListOfDataWrappers =
DataWrapperHelper.GetWrapperProperties<LoginViewViewModel>(this);
//Register Mediator
Mediator.Instance.Register(this);
//Initialise Rules
userName.AddRule(UserNameCannnotBeEmptyRule);
password.AddRule(PasswordCannotBeEmptyRule);
selectedBusinessUnit.AddRule(SelectedBusinessUnitCannotBeEmpty);
//Initialise Commands
LoginCommand = new SimpleCommand<object, object>(CanExecuteLoginCommand, ExecuteLoginCommand);
CancelLoginCommand = new SimpleCommand<object, object>(ExecuteCancelLoginCommand);
}
public SettingsViewModel(IViewAwareStatus viewAwareStatus)
{
_viewAwareStatus = viewAwareStatus;
_themeList = new System.Collections.ObjectModel.ObservableCollection <ThemeListItem>();
foreach (var theme in ControlzEx.Theming.ThemeManager.Current.Themes.OrderBy(t => t.DisplayName))
{
_themeList.Add(new ThemeListItem()
{
Name = theme.DisplayName, Value = theme.Name
});
}
_modeList = new ObservableCollection <ModeListItem>();
_modeList.Add(new ModeListItem()
{
Mode = Common.RadioLogMode.Normal, ModeName = "Normal"
});
_modeList.Add(new ModeListItem()
{
Mode = Common.RadioLogMode.Fireground, ModeName = "Fireground"
});
_displayList = new ObservableCollection <DisplayStyleListItem>();
_displayList.Add(new DisplayStyleListItem()
{
DisplayName = "Tabbed Interface", DisplayStyle = Common.DisplayStyle.TabbedInterface
});
_displayList.Add(new DisplayStyleListItem()
{
DisplayName = "Grid Interface", DisplayStyle = Common.DisplayStyle.GridsOnlyInterface
});
_displayList.Add(new DisplayStyleListItem()
{
DisplayName = "All-in-One", DisplayStyle = Common.DisplayStyle.AllInOne
});
_displayList.Add(new DisplayStyleListItem()
{
DisplayName = "Grids and Auto-Open Sources", DisplayStyle = Common.DisplayStyle.GridsAutoOpenSources
});
_displayList.Add(new DisplayStyleListItem()
{
DisplayName = "Column Interface", DisplayStyle = Common.DisplayStyle.Columns
});
_viewSizeList = new ObservableCollection <ViewSizeListItem>();
_viewSizeList.Add(new ViewSizeListItem()
{
Value = Common.ProcessorViewSize.Normal, Name = "Normal"
});
_viewSizeList.Add(new ViewSizeListItem()
{
Value = Common.ProcessorViewSize.Small, Name = "Small"
});
_viewSizeList.Add(new ViewSizeListItem()
{
Value = Common.ProcessorViewSize.Wide, Name = "Wide"
});
_viewSizeList.Add(new ViewSizeListItem()
{
Value = Common.ProcessorViewSize.ExtraWide, Name = "Extra Wide"
});
_fileBitsPerSampleList = new ObservableCollection <IntListItem>();
_fileBitsPerSampleList.Add(new IntListItem()
{
Value = 8, Name = "8-bits"
});
_fileBitsPerSampleList.Add(new IntListItem()
{
Value = 16, Name = "16-bits"
});
_fileBitsPerSampleList.Add(new IntListItem()
{
Value = 24, Name = "24-bits"
});
_fileBitsPerSampleList.Add(new IntListItem()
{
Value = 32, Name = "32-bits"
});
_fileRecordingRateList = new ObservableCollection <IntListItem>();
_fileRecordingRateList.Add(new IntListItem()
{
Value = 8000, Name = "8000Hz"
});
_fileRecordingRateList.Add(new IntListItem()
{
Value = 16000, Name = "16000Hz"
});
_fileRecordingRateList.Add(new IntListItem()
{
Value = 22050, Name = "22050Hz"
});
_fileRecordingRateList.Add(new IntListItem()
{
Value = 32000, Name = "32000Hz"
});
_fileRecordingRateList.Add(new IntListItem()
{
Value = 44100, Name = "44100Hz"
});
_fileRecordingRateList.Add(new IntListItem()
{
Value = 48000, Name = "48000Hz"
});
_fileRecordingRateList.Add(new IntListItem()
{
Value = 88200, Name = "88200Hz"
});
_fileRecordingRateList.Add(new IntListItem()
{
Value = 96000, Name = "96000Hz"
});
}
public void InitialiseViewAwareService(IViewAwareStatus view)
{
view.Loaded += OnLoaded;
view.Unloaded += OnUnloaded;
}
public void InitialiseViewAwareService(IViewAwareStatus viewAwareStatusService)
{
viewAwareStatusService.ViewLoaded += BeginEdit;
}
public UserDetailViewViewModel(IMessageBoxService messageBoxService, IViewAwareStatus viewAwareStatus)
{
this.messageBoxService = messageBoxService;
this.viewAwareStatus = viewAwareStatus;
this.viewAwareStatus.ViewLoaded += new Action(viewAwareStatus_ViewLoaded);
}
public SettingsViewModel(IViewAwareStatus viewAwareStatus)
{
_viewAwareStatus = viewAwareStatus;
_themeList = new System.Collections.ObjectModel.ObservableCollection<ThemeListItem>();
foreach (MahApps.Metro.AppTheme theme in MahApps.Metro.ThemeManager.AppThemes)
{
string themeName = theme.Name;
if (themeName.StartsWith("Base"))
themeName = themeName.Substring(4);
_themeList.Add(new ThemeListItem() { Name = themeName, Value = theme.Name });
}
_accentList = new System.Collections.ObjectModel.ObservableCollection<string>();
foreach (MahApps.Metro.Accent accent in MahApps.Metro.ThemeManager.Accents.OrderBy(a => a.Name))
{
_accentList.Add(accent.Name);
}
_modeList = new ObservableCollection<ModeListItem>();
_modeList.Add(new ModeListItem() { Mode = Common.RadioLogMode.Normal, ModeName = "Normal" });
_modeList.Add(new ModeListItem() { Mode = Common.RadioLogMode.Fireground, ModeName = "Fireground" });
_displayList = new ObservableCollection<DisplayStyleListItem>();
_displayList.Add(new DisplayStyleListItem() { DisplayName = "Tabbed Interface", DisplayStyle = Common.DisplayStyle.TabbedInterface });
_displayList.Add(new DisplayStyleListItem() { DisplayName = "Grid Interface", DisplayStyle = Common.DisplayStyle.GridsOnlyInterface });
_displayList.Add(new DisplayStyleListItem() { DisplayName = "All-in-One", DisplayStyle = Common.DisplayStyle.AllInOne });
_displayList.Add(new DisplayStyleListItem() { DisplayName = "Grids and Auto-Open Sources", DisplayStyle = Common.DisplayStyle.GridsAutoOpenSources });
_displayList.Add(new DisplayStyleListItem() { DisplayName = "Column Interface", DisplayStyle = Common.DisplayStyle.Columns });
_viewSizeList = new ObservableCollection<ViewSizeListItem>();
_viewSizeList.Add(new ViewSizeListItem() { Value = Common.ProcessorViewSize.Normal, Name = "Normal" });
_viewSizeList.Add(new ViewSizeListItem() { Value = Common.ProcessorViewSize.Small, Name = "Small" });
_viewSizeList.Add(new ViewSizeListItem() { Value = Common.ProcessorViewSize.Wide, Name = "Wide" });
_viewSizeList.Add(new ViewSizeListItem() { Value = Common.ProcessorViewSize.ExtraWide, Name = "Extra Wide" });
_fileBitsPerSampleList = new ObservableCollection<IntListItem>();
_fileBitsPerSampleList.Add(new IntListItem() { Value = 8, Name = "8-bits" });
_fileBitsPerSampleList.Add(new IntListItem() { Value = 16, Name = "16-bits" });
_fileBitsPerSampleList.Add(new IntListItem() { Value = 24, Name = "24-bits" });
_fileBitsPerSampleList.Add(new IntListItem() { Value = 32, Name = "32-bits" });
_fileRecordingRateList = new ObservableCollection<IntListItem>();
_fileRecordingRateList.Add(new IntListItem() { Value = 8000, Name = "8000Hz" });
_fileRecordingRateList.Add(new IntListItem() { Value = 16000, Name = "16000Hz" });
_fileRecordingRateList.Add(new IntListItem() { Value = 22050, Name = "22050Hz" });
_fileRecordingRateList.Add(new IntListItem() { Value = 32000, Name = "32000Hz" });
_fileRecordingRateList.Add(new IntListItem() { Value = 44100, Name = "44100Hz" });
_fileRecordingRateList.Add(new IntListItem() { Value = 48000, Name = "48000Hz" });
_fileRecordingRateList.Add(new IntListItem() { Value = 88200, Name = "88200Hz" });
_fileRecordingRateList.Add(new IntListItem() { Value = 96000, Name = "96000Hz" });
}
public MainViewModel(IViewAwareStatus viewAwareStatus)
{
if (MEFedMVVM.Common.Designer.IsInDesignMode)
return;
_tAudioCheck = new System.Threading.Thread(() =>
{
while (_shouldRunThreads)
{
foreach (SourceGroupModel grp in SignalGroups)
{
grp.UpdateHasAudio();
}
System.Threading.Thread.Sleep(1500);
}
});
_tAudioCheck.IsBackground = true;
_tAudioCheck.Name = "Audio Check Thread";
if (Common.AppSettings.Instance.UseGroups)
{
foreach (Common.SignalGroup grp in Common.AppSettings.Instance.SignalGroups)
{
AddSignalGroupToList(grp);
}
}
else
{
Common.SignalGroup mainGroup = Common.AppSettings.Instance.SignalGroups.FirstOrDefault(g => g.GroupId == Guid.Empty);
if (mainGroup != null)
{
AddSignalGroupToList(mainGroup);
}
}
_viewStatus = viewAwareStatus;
_viewStatus.ViewLoaded += viewAwareStatus_ViewLoaded;
Cinch.Mediator.Instance.RegisterHandler<Common.SignalSourceGroupChangeHolder>("SOURCE_GROUP_CHANGE", ProcessSourceGroupChange);
Cinch.Mediator.Instance.RegisterHandler<Common.SignalSource>("NEW_SIGNAL_SOURCE", ProcessNewSignalSource);
Cinch.Mediator.Instance.RegisterHandler<Guid>("DELETE_SIGNAL_SOURCE", ProcessRemoveSignalSource);
Cinch.Mediator.Instance.RegisterHandler<Guid>("UPDATE_SIGNAL_SOURCE", ProcessRefreshSignalSource);
Cinch.Mediator.Instance.RegisterHandler<Guid>("GROUP_CHANGED", ProcessGroupUpdated);
Cinch.Mediator.Instance.RegisterHandler<Guid>("GROUP_DELETED", ProcessGroupDeleted);
Cinch.Mediator.Instance.RegisterHandler<Common.SignalGroup>("NEW_GROUP_ADDED", ProcessGroupAdded);
Cinch.Mediator.Instance.RegisterHandler<Guid>("TOGGLE_SOURCE_MUTE_OTHERS", ProcessToggleSourceMuteOthers);
Cinch.Mediator.Instance.RegisterHandler<Guid>("END_IF_NON_MUTED_SOURCE", ProcessShutdownSourceMuteOthers);
Cinch.Mediator.Instance.RegisterHandler<bool>("AUDIO_MUTE_STATE_CHANGED", ProcessAudioMuteStateChanged);
Cinch.Mediator.Instance.RegisterHandler<bool>("REFRESH_RADIO_LOOKUPS", (b) =>
{
foreach (RadioSignalItemModel rSig in RadioLog) { rSig.UpdateLookups(); }
foreach (EmergencyRadioSignalItemModel eSig in EmergencyRadioLog) { eSig.UpdateLookups(); }
});
Cinch.Mediator.Instance.RegisterHandler<bool>("SETTINGS_CHANGED", (b) =>
{
GridFontSize = Common.AppSettings.Instance.GridFontSize;
GridSmallFontSize = Common.AppSettings.Instance.GridFontSize - 4;
GridLargeFontSize = Common.AppSettings.Instance.GridFontSize + 4;
foreach (SourceGroupModel grp in _signalGroups)
{
grp.UpdateForSystemSettingsChanged();
}
});
UpdateEmergencyAlarmSoundPlayer();
}
public OtherMeetViewModel(IMessageBoxService messageBoxService, IViewAwareStatus viewAwareStatus)
{
this.messageBoxService = messageBoxService;
this.viewAwareStatus = viewAwareStatus;
this.viewAwareStatus.ViewLoaded += ViewAwareStatus_ViewLoaded;
}
/// <summary>
/// This creates the SL ChildWindow from a key.
/// </summary>
/// <param name="key">Key</param>
/// <param name="dataContext">DataContext (state) object</param>
/// <param name="completedProc">Callback used when UI closes (may be null)</param>
/// <returns>ChildWindow</returns>
private ChildWindow CreateChildWindow(string key, object dataContext,
EventHandler <UICompletedEventArgs> completedProc)
{
if (string.IsNullOrEmpty(key))
{
throw new ArgumentNullException("key");
}
Type winType;
lock (_registeredWindows)
{
if (!_registeredWindows.TryGetValue(key, out winType))
{
return(null);
}
}
var win = (ChildWindow)Activator.CreateInstance(winType);
if (dataContext is IViewStatusAwareInjectionAware)
{
IViewAwareStatus viewAwareStatus =
ViewModelRepository.Instance.Resolver.Container.GetExport <IViewAwareStatus>().Value;
viewAwareStatus.InjectContext((FrameworkElement)win);
((IViewStatusAwareInjectionAware)dataContext).InitialiseViewAwareService(viewAwareStatus);
}
win.DataContext = dataContext;
ViewModelBase bvm = null;
EventHandler <CloseRequestEventArgs> handler = ((s, e) =>
{
try
{
win.DialogResult = e.Result;
}
catch (InvalidOperationException)
{
win.Close();
}
});
if (dataContext != null)
{
bvm = dataContext as ViewModelBase;
if (bvm != null)
{
bvm.CloseRequest += handler;
}
}
win.Closed += (s, e) =>
{
bvm.CloseRequest -= handler;
win.DataContext = dataContext;
if (completedProc != null)
{
completedProc(this, new UICompletedEventArgs()
{
State = dataContext,
Result = win.DialogResult
});
GC.Collect();
}
};
return(win);
}
public MainViewModel(IViewAwareStatus viewAwareStatus,
IMasterDatabaseService database,
IMessageBoxService messageBox,
IUIVisualizerService visualizer,
IHRCSaveFileService saveFile,
IHRCOpenFileService openFile,
TransmissionLossCalculatorService transmissionLoss,
IPluginManagerService plugins,
EnvironmentalCacheService cache)
{
try
{
Mediator.Instance.Register(this);
}
catch (Exception ex)
{
Debug.WriteLine("***********\nMainViewModel: Mediator registration failed: " + ex.Message + "\n***********");
throw;
}
Cursor = Cursors.Arrow;
ESME.Data.AppSettings.ApplicationName = App.Name;
Globals.AppSettings = ESME.Data.AppSettings.Load(ESME.Data.AppSettings.AppSettingsFile);
Globals.AppSettings.Save();
Globals.PluginManagerService = plugins;
Globals.TransmissionLossCalculatorService = transmissionLoss;
Globals.MasterDatabaseService = database;
Globals.VisualizerService = visualizer;
Globals.SaveFileService = saveFile;
Globals.OpenFileService = openFile;
Globals.EnvironmentalCacheService = cache;
Globals.ViewAwareStatusService = viewAwareStatus;
Globals.MessageBoxService = messageBox;
MapViewModel = new MapViewModel(this);
Globals.TransmissionLossCalculatorService.WorkQueue.PropertyChanged +=
(s, e) =>
{
if (e.PropertyName == "Count")
{
TransmissionLossActivity = Globals.TransmissionLossCalculatorService.WorkQueue.Keys.Count > 0
? string.Format("Acoustic Simulator: {0} items", Globals.TransmissionLossCalculatorService.WorkQueue.Keys.Count)
: "Acoustic Simulator: idle";
// Debug.WriteLine(string.Format("TransmissionLossActivity: {0}", TransmissionLossActivity));
var isBusy = Globals.TransmissionLossCalculatorService.WorkQueue.Keys.Count > 0;
IsTransmissionLossBusy = isBusy;
if (!isBusy && IsSaveSampleDataRequested)
{
Globals.MasterDatabaseService.SaveChanges();
IsSaveSampleDataRequested = false;
}
}
};
if (Designer.IsInDesignMode) return;
Globals.ViewAwareStatusService.ViewLoaded += ViewLoaded;
//_appTracker = new ApplicationTracker("UA-44329261-1", "TestWPFApp");
//_appTracker.StartSession();
//_appTracker.TrackEvent(ApplicationTrackerCategories.Command, "ApplicationStartup");
}
public void InitialiseViewAwareService(IViewAwareStatus viewAwareStatusService)
{
this.ViewAwareStatusService = viewAwareStatusService;
this.ViewAwareStatusService.ViewLoaded += ViewAwareStatusService_ViewLoaded;
}
public MainViewModel(IViewAwareStatus viewAwareStatus)
{
if (MEFedMVVM.Common.Designer.IsInDesignMode)
{
return;
}
_tAudioCheck = new System.Threading.Thread(() =>
{
while (_shouldRunThreads)
{
foreach (SourceGroupModel grp in SignalGroups)
{
grp.UpdateHasAudio();
}
System.Threading.Thread.Sleep(1500);
}
});
_tAudioCheck.IsBackground = true;
_tAudioCheck.Name = "Audio Check Thread";
if (Common.AppSettings.Instance.UseGroups)
{
foreach (Common.SignalGroup grp in Common.AppSettings.Instance.SignalGroups)
{
AddSignalGroupToList(grp);
}
}
else
{
Common.SignalGroup mainGroup = Common.AppSettings.Instance.SignalGroups.FirstOrDefault(g => g.GroupId == Guid.Empty);
if (mainGroup != null)
{
AddSignalGroupToList(mainGroup);
}
}
_viewStatus = viewAwareStatus;
_viewStatus.ViewLoaded += viewAwareStatus_ViewLoaded;
Cinch.Mediator.Instance.RegisterHandler <Common.SignalSourceGroupChangeHolder>("SOURCE_GROUP_CHANGE", ProcessSourceGroupChange);
Cinch.Mediator.Instance.RegisterHandler <Common.SignalSource>("NEW_SIGNAL_SOURCE", ProcessNewSignalSource);
Cinch.Mediator.Instance.RegisterHandler <Guid>("DELETE_SIGNAL_SOURCE", ProcessRemoveSignalSource);
Cinch.Mediator.Instance.RegisterHandler <Guid>("UPDATE_SIGNAL_SOURCE", ProcessRefreshSignalSource);
Cinch.Mediator.Instance.RegisterHandler <Guid>("GROUP_CHANGED", ProcessGroupUpdated);
Cinch.Mediator.Instance.RegisterHandler <Guid>("GROUP_DELETED", ProcessGroupDeleted);
Cinch.Mediator.Instance.RegisterHandler <Common.SignalGroup>("NEW_GROUP_ADDED", ProcessGroupAdded);
Cinch.Mediator.Instance.RegisterHandler <Guid>("TOGGLE_SOURCE_MUTE_OTHERS", ProcessToggleSourceMuteOthers);
Cinch.Mediator.Instance.RegisterHandler <Guid>("END_IF_NON_MUTED_SOURCE", ProcessShutdownSourceMuteOthers);
Cinch.Mediator.Instance.RegisterHandler <bool>("AUDIO_MUTE_STATE_CHANGED", ProcessAudioMuteStateChanged);
Cinch.Mediator.Instance.RegisterHandler <bool>("REFRESH_RADIO_LOOKUPS", (b) =>
{
foreach (RadioSignalItemModel rSig in RadioLog)
{
rSig.UpdateLookups();
}
foreach (EmergencyRadioSignalItemModel eSig in EmergencyRadioLog)
{
eSig.UpdateLookups();
}
});
Cinch.Mediator.Instance.RegisterHandler <bool>("SETTINGS_CHANGED", (b) =>
{
GridFontSize = Common.AppSettings.Instance.GridFontSize;
GridSmallFontSize = Common.AppSettings.Instance.GridFontSize - 4;
GridLargeFontSize = Common.AppSettings.Instance.GridFontSize + 4;
foreach (SourceGroupModel grp in _signalGroups)
{
grp.UpdateForSystemSettingsChanged();
}
});
UpdateEmergencyAlarmSoundPlayer();
}
public UserDetailViewViewModel(IMessageBoxService messageBoxService, IViewAwareStatus viewAwareStatus)
{
this.messageBoxService = messageBoxService;
this.viewAwareStatus = viewAwareStatus;
this.viewAwareStatus.ViewLoaded += new Action(viewAwareStatus_ViewLoaded);
}
public void InitialiseViewAwareService(IViewAwareStatus viewAwareStatusService)
{ }
public MainWindowViewModel(IViewAwareStatus viewAwareStatusService, IMessageBoxService messageBoxService)
{
this.viewAwareStatusService = viewAwareStatusService;
this.viewAwareStatusService.ViewLoaded += ViewAwareStatusService_ViewLoaded;
this.messageBoxService = messageBoxService;
}
