static ContainerRegister()
{
RegisterMultiThreadConfiguration(true);
container
.Singleton(container)
.Singleton <ICommandFactory, CommandFactory>()
.Singleton(() => new CommandsDiscover(EvaluateExecuteCommandFactoryHalper.Create(true)))
//.Singleton(() => new CommandsDiscover(AlwaysCanExecuteCommandFactoryHalper.Create(true, new DefaultViewModelChecker("Validation errors on UI", "Check the UI"))))
.Singleton <IMessageBroker, LocalMessageBroker>()
.Singleton <IDialogService, DefaultDialogService>()
.Singleton <IMapper, AutoMapperMapper>()
.Singleton(typeof(ServiceFactory <>))
.Singleton <IMessageBox, LoggingMessageBox>()
.Singleton(typeof(IDisposableFactory <>), typeof(DemoProxyFactory <>))
.Singleton <CommandConvention, DemoCommandConvention>();
TimerFactory.Set(new DispatcherTimerFactory());
CollectionFactory.Set(() => new SafeCollectionFactory());
CommandsDiscoverFactory.Set(container.Resolve <CommandsDiscover>);
MessageBroker.Set(container.Resolve <IMessageBroker>);
DialogService.Set(container.Resolve <IDialogService>);
Mapper.Set(container.Resolve <IMapper>);
ViewModelController.Set(() => container);
}
public static void SelectEntity(IEnumerable <Entity> entities)
{
// Update property editor selection.
if (selectedEntitiesContext != null)
{
selectedEntitiesContext.ViewModelByGuid.Clear();
var viewModels = entities
.Where(entity => entity != null)
.Select(entity => selectedEntitiesContext.GetModelView(entity).Children.First(x => x.PropertyName == "Components"))
.ToArray();
if (viewModels.Count() > 1)
{
selectedEntitiesContext.Root = ViewModelController.Combine(selectedEntitiesContext, viewModels);
}
else
{
selectedEntitiesContext.Root = viewModels.FirstOrDefault();
}
}
// Update picking system (gizmo).
// It will also update the remote selection in entity tree view.
var entitiesArray = entities.ToArray();
if (!ArrayExtensions.ArraysEqual(pickingSystem.SelectedEntities, entitiesArray))
{
pickingSystem.SelectedEntities = entitiesArray;
}
entitiesChangePacketEvent.Set();
}
public ExifToolViewModel()
{
DirectoryModel = new DirectoryModel();
ImageModel = new ImageModel();
_viewModelController = new ViewModelController();
ImageModel.PropertyChanged += ImageModel_PropertyChanged;
}
private void Window_Closing(object sender, System.ComponentModel.CancelEventArgs e)
{
try
{
ViewModelController.ChangeViewModel(null);
if (Globals.LoggedUser != null && Connection.Instance.Service?.State == CommunicationState.Opened)
{
Connection.Instance.Service?.Logout();
}
Connection.Instance.Service?.Abort();
}
catch (FaultException <OperationFault> faultException)
{
MessageBox.Show(faultException.Detail.ErrorMessage,
$"Error in: {faultException.Detail.Operation}",
MessageBoxButton.OK,
MessageBoxImage.Error);
}
catch (Exception ex)
{
MessageBox.Show(ex.Message,
$"Error in:",
MessageBoxButton.OK,
MessageBoxImage.Error);
}
}
public MainWindow()
{
InitializeComponent();
Globals.UIDispatcher = Dispatcher;
DataContext = ViewModelController.Instance;
ViewModelController.ChangeViewModel(new LoginViewModel());
//Connection.Initalize();// TODO: Change to LoginViewModel or something
connectionThread = new Thread(() => Connection.Initalize());
connectionThread.Start();
}
public MainViewModel()
{
serviceFactory = ViewModelController.ServiceFactory <ICustomerService>();
timerFactory = ViewModelController.TimerFactory();
MessageBroker.Register <DeleteCustomerMessage>(this, DeleteCustomer);
Property(() => FullName).OnChanged(x => NameLength = x.Length);
InitializeProperties();
}
public object Convert(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture)
{
string valueAsString = value.ToString();
if (valueAsString.Contains("."))
{
valueAsString = valueAsString.Substring(0, valueAsString.IndexOf('.'));
}
ViewModelController viewModelController = App.Current.Resources["ViewModelController"] as ViewModelController;
return(viewModelController.Models.ShellViewModel.CurrentToolStepLabels[int.Parse(valueAsString) - 1]);
}
/***Methods***/
public graphView(IClientModel c, ViewModelController vmc)
{
InitializeComponent();
this.vmCon = vmc;
this.graphViewModel = new GraphViewModel(c, vmc, attPlot, corrPlot, LRPlot);
this.DataContext = graphViewModel;
StackPanel stackPanel = new StackPanel();
//creating buttons
setupButtons(stackPanel);
scorllButtons.Content = stackPanel;
Attpv = attPlot;
Corrpv = corrPlot;
RegLinepv = LRPlot;
Loaded += GraphView_Loaded;
}
public object Convert(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture)
{
ViewModelController viewModelController = App.Current.Resources["ViewModelController"] as ViewModelController;
return((viewModelController.Models.ShellViewModel.CurrentToolCurrentStep == (double)value) ? App.Current.Resources["CurrentSliderTick"] as Style : App.Current.Resources["SliderTick"] as Style);
}
public async static Task ProcessClient(EngineContext engineContext, SocketContext socketContext, SocketContext socketContextAsync)
{
socketContext.AddPacketHandler <DownloadFileQuery>(
async(packet) =>
{
var stream = await VirtualFileSystem.OpenStreamAsync(packet.Url, VirtualFileMode.Open, VirtualFileAccess.Read);
var data = new byte[stream.Length];
await stream.ReadAsync(data, 0, data.Length);
stream.Close();
socketContext.Send(new DownloadFileAnswer {
StreamId = packet.StreamId, Data = data
});
});
socketContext.AddPacketHandler <UploadFilePacket>(
async(packet) =>
{
var stream = await VirtualFileSystem.OpenStreamAsync(packet.Url, VirtualFileMode.Create, VirtualFileAccess.Write);
await stream.WriteAsync(packet.Data, 0, packet.Data.Length);
stream.Close();
});
var viewModelGlobalContext = new ViewModelGlobalContext();
selectedEntitiesContext = new ViewModelContext(viewModelGlobalContext);
selectedEntitiesContext.ChildrenPropertyEnumerators.Add(new EntityComponentEnumerator(engineContext));
selectedEntitiesContext.ChildrenPropertyEnumerators.Add(new RenderPassPluginEnumerator());
selectedEntitiesContext.ChildrenPropertyEnumerators.Add(new ChildrenPropertyInfoEnumerator());
//selectedEntitiesContext.ChildrenPropertyEnumerators.Add(new EffectPropertyEnumerator(engineContext));
var renderPassHierarchyContext = new ViewModelContext(viewModelGlobalContext);
renderPassHierarchyContext.ChildrenPropertyEnumerators.Add(new RenderPassHierarchyEnumerator());
renderPassHierarchyContext.Root = new ViewModelNode("Root", engineContext.RenderContext.RootRenderPass).GenerateChildren(renderPassHierarchyContext);
var renderPassPluginsContext = new ViewModelContext(viewModelGlobalContext);
renderPassPluginsContext.ChildrenPropertyEnumerators.Add(new RenderPassPluginsEnumerator {
SelectedRenderPassPluginContext = selectedEntitiesContext
});
renderPassPluginsContext.Root = new ViewModelNode("Root", new EnumerableViewModelContent <ViewModelReference>(
() => engineContext.RenderContext.RenderPassPlugins.Select(x => new ViewModelReference(x, true))));
var entityHierarchyEnumerator = new EntityHierarchyEnumerator(engineContext.EntityManager, selectedEntitiesContext);
var entityHierarchyContext = new ViewModelContext(viewModelGlobalContext);
entityHierarchyContext.ChildrenPropertyEnumerators.Add(entityHierarchyEnumerator);
entityHierarchyContext.ChildrenPropertyEnumerators.Add(new ChildrenPropertyInfoEnumerator());
entityHierarchyContext.Root = new ViewModelNode("EntityHierarchyRoot", new EnumerableViewModelContent <ViewModelReference>(
() => engineContext.EntityManager.Entities
.Where(x =>
{
var transformationComponent = x.Transformation;
return(transformationComponent == null || transformationComponent.Parent == null);
})
.Select(x => new ViewModelReference(x, true))));
entityHierarchyEnumerator.SelectedEntities.CollectionChanged += (sender, args) =>
{
SelectEntity(entityHierarchyEnumerator.SelectedEntities);
};
//entityHierarchyContext.Root.Children.Add(new ViewModelNode("SelectedItems", EnumerableViewModelContent.FromUnaryLambda<ViewModelReference, ViewModelReference>(new NullViewModelContent(),
// (x) => { return new[] { new ViewModelReference(pickingSystem.SelectedEntity) }; })));
/*(value) =>
* {
* var entityModelView = value != null ? entityHierarchyContext.GetModelView(value.Guid) : null;
* var entity = entityModelView != null ? (Entity)entityModelView.NodeValue : null;
* SelectEntity(entity);
* })));*/
entityHierarchyContext.Root.Children.Add(new ViewModelNode("DropEntity", new RootViewModelContent((ExecuteCommand)((viewModel2, parameter) =>
{
var dropParameters = (DropCommandParameters)parameter;
var movedItem = dropParameters.Data is Guid ? entityHierarchyContext.GetModelView((Guid)dropParameters.Data) : null;
var newParent = dropParameters.Parent is Guid ? entityHierarchyContext.GetModelView((Guid)dropParameters.Parent) : null;
if (newParent == null || movedItem == null)
{
return;
}
var parent = ((Entity)newParent.NodeValue).Transformation;
if (dropParameters.TargetIndex > parent.Children.Count)
{
return;
}
var transformationComponent = ((Entity)movedItem.NodeValue).Transformation;
transformationComponent.Parent = null;
parent.Children.Insert(dropParameters.TargetIndex, transformationComponent);
}))));
entityHierarchyContext.Root.Children.Add(new ViewModelNode("DropAsset", new RootViewModelContent((ExecuteCommand)(async(viewModel2, parameter) =>
{
var dropParameters = (DropCommandParameters)parameter;
var assetUrl = (string)dropParameters.Data;
/*var newParent = entityHierarchyContext.GetModelView((Guid)dropParameters.Parent);
*
* if (newParent == null || assetUrl == null)
* return;
*
* var parent = ((Entity)newParent.NodeValue).Transformation;
* if (dropParameters.ItemIndex > parent.Children.Count)
* return;*/
engineContext.Scheduler.Add(async() =>
{
// Load prefab entity
var loadedEntityPrefab = await engineContext.AssetManager.LoadAsync <Entity>(assetUrl + "#");
// Build another entity from prefab
var loadedEntity = Prefab.Inherit(loadedEntityPrefab);
// Add it to scene
engineContext.EntityManager.AddEntity(loadedEntity);
if (loadedEntity.ContainsKey(AnimationComponent.Key))
{
Scheduler.Current.Add(() => AnimScript.AnimateFBXModel(engineContext, loadedEntity));
}
});
}))));
var scriptEngineContext = new ViewModelContext(viewModelGlobalContext);
scriptEngineContext.ChildrenPropertyEnumerators.Add(new ScriptAssemblyEnumerator(engineContext));
scriptEngineContext.ChildrenPropertyEnumerators.Add(new ChildrenPropertyInfoEnumerator());
scriptEngineContext.Root = new ViewModelNode(new EnumerableViewModelContent <ViewModelReference>(
() => engineContext.ScriptManager.ScriptAssemblies.Select(x => new ViewModelReference(x, true))));
scriptEngineContext.Root.Children.Add(new ViewModelNode("RunScript", new RootViewModelContent((ExecuteCommand)(async(viewModel2, parameter) =>
{
var scriptName = (string)parameter;
var matchingScript = engineContext.ScriptManager.Scripts.Where(x => x.TypeName + "." + x.MethodName == scriptName);
if (matchingScript.Any())
{
var scriptEntry = matchingScript.Single();
var microThread = engineContext.ScriptManager.RunScript(scriptEntry, null);
}
}))));
var runningScriptsContext = new ViewModelContext(viewModelGlobalContext);
runningScriptsContext.ChildrenPropertyEnumerators.Add(new MicroThreadEnumerator(selectedEntitiesContext));
runningScriptsContext.ChildrenPropertyEnumerators.Add(new ChildrenPropertyInfoEnumerator());
runningScriptsContext.Root = new ViewModelNode("MicroThreads", new EnumerableViewModelContent <ViewModelReference>(
() => engineContext.Scheduler.MicroThreads.Select(x => new ViewModelReference(x, true))
));
var effectsContext = new ViewModelContext(viewModelGlobalContext);
effectsContext.ChildrenPropertyEnumerators.Add(new EffectEnumerator(selectedEntitiesContext));
effectsContext.ChildrenPropertyEnumerators.Add(new ChildrenPropertyInfoEnumerator());
effectsContext.Root = new ViewModelNode("Effects", new EnumerableViewModelContent <ViewModelReference>(
() => engineContext.RenderContext.Effects.Select(x => new ViewModelReference(x, true))
));
//effectsContext.Root.Children.Add(new ViewModelNode("PluginDefinitions", new RootViewModelContent()));
var assetBrowserContext = new ViewModelContext(viewModelGlobalContext);
assetBrowserContext.ChildrenPropertyEnumerators.Add(new AssetBrowserEnumerator(engineContext));
assetBrowserContext.ChildrenPropertyEnumerators.Add(new ChildrenPropertyInfoEnumerator());
assetBrowserContext.Root = new ViewModelNode("Root", "Root").GenerateChildren(assetBrowserContext);
var editorContext = new ViewModelContext(viewModelGlobalContext);
editorContext.Root = new ViewModelNode("Root");
editorContext.Root.Children.Add(new ViewModelNode("SwitchSelectionMode", new CommandViewModelContent((sender, parameters) => { pickingSystem.ActiveGizmoActionMode = PickingSystem.GizmoAction.None; })));
editorContext.Root.Children.Add(new ViewModelNode("SwitchTranslationMode", new CommandViewModelContent((sender, parameters) => { pickingSystem.ActiveGizmoActionMode = PickingSystem.GizmoAction.Translation; })));
editorContext.Root.Children.Add(new ViewModelNode("SwitchRotationMode", new CommandViewModelContent((sender, parameters) => { pickingSystem.ActiveGizmoActionMode = PickingSystem.GizmoAction.Rotation; })));
var contexts = new Dictionary <string, Tuple <ViewModelContext, ViewModelState> >();
contexts.Add("Editor", Tuple.Create(editorContext, new ViewModelState()));
contexts.Add("RenderPassPlugins", Tuple.Create(renderPassPluginsContext, new ViewModelState()));
contexts.Add("RenderPasses", Tuple.Create(renderPassHierarchyContext, new ViewModelState()));
contexts.Add("SelectedEntities", Tuple.Create(selectedEntitiesContext, new ViewModelState()));
contexts.Add("EntityHierarchy", Tuple.Create(entityHierarchyContext, new ViewModelState()));
contexts.Add("ScriptEngine", Tuple.Create(scriptEngineContext, new ViewModelState()));
contexts.Add("MicroThreads", Tuple.Create(runningScriptsContext, new ViewModelState()));
contexts.Add("AssetBrowser", Tuple.Create(assetBrowserContext, new ViewModelState()));
contexts.Add("Effects", Tuple.Create(effectsContext, new ViewModelState()));
int lastAckPacket = 0;
var entitiesChangePackets = new ConcurrentQueue <EntitiesChangePacket>();
socketContext.AddPacketHandler <EntitiesChangePacket>(
(packet) =>
{
entitiesChangePackets.Enqueue(packet);
entitiesChangePacketEvent.Set();
});
Action asyncThreadStart = () =>
{
while (true)
{
Thread.Sleep(100);
foreach (var context in contexts)
{
// Process async data
Guid[] path = null;
object value = null;
lock (context.Value.Item1)
{
var pendingNode = context.Value.Item1.GetNextPendingAsyncNode();
if (pendingNode != null)
{
value = pendingNode.Value;
path = ViewModelController.BuildPath(pendingNode);
}
}
if (path != null)
{
// Temporary encoding through our serializer (until our serializer are used for packets)
var memoryStream = new MemoryStream();
var writer = new BinarySerializationWriter(memoryStream);
writer.SerializeExtended(null, value, ArchiveMode.Serialize);
var change = new NetworkChange {
Path = path.ToArray(), Type = NetworkChangeType.ValueUpdateAsync, Value = memoryStream.ToArray()
};
var packet = new EntitiesChangePacket {
GroupKey = context.Key, Changes = new NetworkChange[] { change }
};
socketContextAsync.Send(packet);
break;
}
}
}
};
new Thread(new ThreadStart(asyncThreadStart)).Start();
// TODO: Move some of this code directly inside ViewModelContext/Controller classes
while (true)
{
await TaskEx.WhenAny(TaskEx.Delay(250), entitiesChangePacketEvent.WaitAsync());
EntitiesChangePacket packet;
while (entitiesChangePackets.TryDequeue(out packet))
{
ViewModelController.NetworkApplyChanges(contexts[packet.GroupKey].Item1, packet.Changes);
lastAckPacket = packet.Index;
}
// Wait a single frame so that network updates get applied properly by all rendering systems for next update
await Scheduler.Current.NextFrame();
// If entity disappeared, try to replace it with new one (happen during file reload)
// It's little bit cumbersome to test, need some simplification of this specific entity view model root.
if (selectedEntitiesContext.Root != null &&
selectedEntitiesContext.Root.Parent != null &&
selectedEntitiesContext.Root.Parent.NodeValue is Entity)
{
var entity = (Entity)selectedEntitiesContext.Root.Parent.NodeValue;
if (!engineContext.EntityManager.Entities.Contains(entity))
{
entity = engineContext.EntityManager.Entities.FirstOrDefault(x => x.Guid == entity.Guid);
if (entity != null)
{
selectedEntitiesContext.ViewModelByGuid.Clear();
selectedEntitiesContext.Root = selectedEntitiesContext.GetModelView(entity).Children.First(x => x.PropertyName == "Components");
}
}
}
var data = new Dictionary <string, byte[]>();
foreach (var context in contexts)
{
lock (context.Value.Item1)
{
if (context.Value.Item1.Root != null)
{
context.Value.Item1.AddModelView(context.Value.Item1.Root);
}
ViewModelController.UpdateReferences(context.Value.Item1, true);
data[context.Key] = ViewModelController.NetworkSerialize(context.Value.Item1, context.Value.Item2);
}
}
viewModelGlobalContext.UpdateObjects(contexts.Select(x => x.Value.Item1));
//Console.WriteLine("DataSize: {0}", data.Sum(x => x.Value.Length));
await Task.Factory.StartNew(() => socketContext.Send(new EntitiesUpdatePacket {
AckIndex = lastAckPacket, Data = data
}));
}
}
protected void InitViewModel()
{
Dictionary <String, String> d = default(Dictionary <String, String>);
try
{
//tell controller how model should notify view about non-persisted properties AND including model properties that may be part of settings
ModelController <MVCModel> .DefaultHandler = PropertyChangedEventHandlerDelegate;
//tell controller how settings should notify view about persisted properties
SettingsController <MVCSettings> .DefaultHandler = PropertyChangedEventHandlerDelegate;
InitModelAndSettings();
#if USE_CUSTOM_VIEWMODEL
//class to handle standard behaviors
d = new Dictionary <String, String>();
d.Add("New", "New");
d.Add("Save", "Save");
d.Add("Open", "Open");
d.Add("Print", "Print");
d.Add("Copy", "Copy");
d.Add("Properties", "Properties");
ViewModelController <String, MVCConsoleViewModel> .New
(
ViewName,
new MVCConsoleViewModel
(
this.PropertyChangedEventHandlerDelegate,
d
)
);
//select a viewmodel by view name
ViewModel =
ViewModelController <String, MVCConsoleViewModel> .ViewModel[ViewName];
#else
//class to handle standard behaviors
ViewModelController <String, ConsoleViewModel <String, MVCSettings, MVCModel> > .New
(
ViewName,
new ConsoleViewModel <String, MVCSettings, MVCModel>
(
this.PropertyChangedEventHandlerDelegate,
new Dictionary <String, String>()
{
{ "New", "New" },
{ "Save", "Save" },
{ "Open", "Open" },
{ "Print", "Print" },
{ "Copy", "Copy" },
{ "Properties", "Properties" }
}
)
);
//select a viewmodel by view name
ViewModel =
ViewModelController <String, ConsoleViewModel <String, MVCSettings, MVCModel> > .ViewModel[ViewName];
#endif
//Init config parameters
if (!LoadParameters())
{
throw new Exception(String.Format("Unable to load config file parameter(s)."));
}
//DEBUG:filename coming in is being converted/passed as DOS 8.3 format equivalent
//Load
if ((SettingsController <MVCSettings> .FilePath == null) || (SettingsController <MVCSettings> .Filename == SettingsController <MVCSettings> .FILE_NEW))
{
//NEW
ViewModel.FileNew();
}
else
{
//OPEN
ViewModel.FileOpen();
}
}
catch (Exception ex)
{
if (ViewModel != null)
{
ViewModel.ErrorMessage = ex.Message;
}
Log.Write(ex, MethodBase.GetCurrentMethod(), EventLogEntryType.Error);
}
}
protected void InitViewModel()
{
Dictionary <String, Bitmap> d = default(Dictionary <String, Bitmap>);
try
{
//tell controller how model should notify view about non-persisted properties AND including model properties that may be part of settings
ModelController <MVCModel> .DefaultHandler = PropertyChangedEventHandlerDelegate;
//tell controller how settings should notify view about persisted properties
SettingsController <MVCSettings> .DefaultHandler = PropertyChangedEventHandlerDelegate;
InitModelAndSettings();
FileDialogInfo settingsFileDialogInfo =
new FileDialogInfo
(
SettingsController <MVCSettings> .FILE_NEW,
null,
null,
MVCSettings.FileTypeExtension,
MVCSettings.FileTypeDescription,
MVCSettings.FileTypeName,
new String[]
{
"XML files (*.xml)|*.xml",
"All files (*.*)|*.*"
},
false,
default(Environment.SpecialFolder),
PathExtensions.WithTrailingSeparator(Environment.GetFolderPath(Environment.SpecialFolder.Personal))
);
//set dialog caption
settingsFileDialogInfo.Title = this.Text;
d = new Dictionary <String, Bitmap>();
d.Add("New", MVCForms.Properties.Resources.New);
d.Add("Open", MVCForms.Properties.Resources.Open);
d.Add("Save", MVCForms.Properties.Resources.Save);
d.Add("Print", MVCForms.Properties.Resources.Print);
d.Add("Undo", MVCForms.Properties.Resources.Undo);
d.Add("Redo", MVCForms.Properties.Resources.Redo);
d.Add("Cut", MVCForms.Properties.Resources.Cut);
d.Add("Copy", MVCForms.Properties.Resources.Copy);
d.Add("Paste", MVCForms.Properties.Resources.Paste);
d.Add("Delete", MVCForms.Properties.Resources.Delete);
d.Add("Find", MVCForms.Properties.Resources.Find);
d.Add("Replace", MVCForms.Properties.Resources.Replace);
d.Add("Refresh", MVCForms.Properties.Resources.Reload);
d.Add("Preferences", MVCForms.Properties.Resources.Preferences);
d.Add("Properties", MVCForms.Properties.Resources.Properties);
d.Add("Contents", MVCForms.Properties.Resources.Contents);
d.Add("About", MVCForms.Properties.Resources.About);
//class to handle standard behaviors
ViewModelController <Bitmap, MVCViewModel> .New
(
ViewName,
new MVCViewModel
(
this.PropertyChangedEventHandlerDelegate,
d,
settingsFileDialogInfo
)
);
//select a viewmodel by view name
ViewModel = ViewModelController <Bitmap, MVCViewModel> .ViewModel[ViewName];
BindFormUi();
//Init config parameters
if (!LoadParameters())
{
throw new Exception(String.Format("Unable to load config file parameter(s)."));
}
//DEBUG:filename coming in is being converted/passed as DOS 8.3 format equivalent
//Load
if ((SettingsController <MVCSettings> .FilePath == null) || (SettingsController <MVCSettings> .Filename == SettingsController <MVCSettings> .FILE_NEW))
{
//NEW
ViewModel.FileNew();
}
else
{
//OPEN
ViewModel.FileOpen(false);
}
#if debug
//debug view
menuEditProperties_Click(sender, e);
#endif
//Display dirty state
ModelController <MVCModel> .Model.Refresh();
}
catch (Exception ex)
{
if (ViewModel != null)
{
ViewModel.ErrorMessage = ex.Message;
}
Log.Write(ex, MethodBase.GetCurrentMethod(), EventLogEntryType.Error);
}
}
/***Methods***/
// the constructor of the Graph View Model - getting a client object and 3 plotviews for graphs
public GraphViewModel(IClientModel c, ViewModelController vmc, OxyPlot.Wpf.PlotView Attpv, OxyPlot.Wpf.PlotView Corrpv, OxyPlot.Wpf.PlotView regLinepv)
{
//getting args from constructor
clientModel = c;
viewModelController = vmc;
VM_pvAtt = Attpv;
VM_pvCorr = Corrpv;
VM_pvLR = regLinepv;
//setting up timer
timer = new Stopwatch();
lastUpdate = 0;
timer.Start();
//parsing XML for buttons name
clientModel.xmlParser();
//Plot models inti
VM_AttPlotModel = new PlotModel();
VM_CorrPlotModel = new PlotModel();
VM_RegLinePlotModel = new PlotModel();
//init list for later
floatAttList = new List <float>();
floatCorrList = new List <float>();
buttonsList = new List <Button>();
//onPropertyChanged methods
clientModel.PropertyChanged += delegate(object sender, PropertyChangedEventArgs e)
{
onPropertyChanged("VM_" + e.PropertyName);
};
// responsible of updating the graphs
clientModel.PropertyChanged += delegate(object sender, PropertyChangedEventArgs e)
{
if (e.PropertyName == "lineNumber" && VM_AttUserChoose != null && VM_corralative != null && VM_pvLR != null)
{
if (timer.ElapsedMilliseconds - lastUpdate > 500)
{
//setting up attPlotModel
VM_AttPlotModel.Series.Clear();
SetUpModel(VM_AttPlotModel);
LoadLineDataGraph(VM_currLine, VM_pvAtt, floatAttList, VM_AttPlotModel);
VM_pvAtt.InvalidatePlot(true);
//setting up corrPlotModel
VM_CorrPlotModel.Series.Clear();
SetUpModel(VM_CorrPlotModel);
LoadLineDataGraph(VM_currLine, VM_pvCorr, floatCorrList, VM_CorrPlotModel);
VM_pvCorr.InvalidatePlot(true);
//setting up regLinePlotModel or minCircle
VM_RegLinePlotModel.Series.Clear();
VM_RegLinePlotModel.Annotations.Clear();
SetUpModel(VM_RegLinePlotModel);
if (viewModelController.isRegLine)
{
LoadScatterGraphData(VM_currLine, VM_pvLR, floatAttList, floatCorrList, VM_RegLinePlotModel);
}
if (viewModelController.isCircel)
{
LoadCircleGraphData(VM_currLine, VM_pvLR, floatAttList, floatCorrList, VM_RegLinePlotModel);
}
VM_pvLR.InvalidatePlot(true);
//updating lastUpdate timer
lastUpdate = timer.ElapsedMilliseconds;
}
}
};
viewModelController.PropertyChanged += delegate(object sender, PropertyChangedEventArgs e)
{
if (e.PropertyName == "VM_dllCounter" && viewModelController.VM_dllCounter > 0 && viewModelController.VM_AnomalyReport != null)
{
foreach (Button b in buttonsList)
{
foreach (KeyValuePair <string, List <int> > entry in viewModelController.VM_AnomalyReport)
{
if (entry.Key.Contains(b.Content.ToString()))
{
b.Background = Brushes.DarkRed;
b.Foreground = Brushes.White;
break;
}
else
{
b.Background = Brushes.LightGray;
b.Foreground = Brushes.Black;
}
}
}
}
;
};
}
