public EntityHierarchyEnumerator(EntitySystem EntitySystem, ViewModelContext selectedEntitiesContext)
{
isSelectedProperty = new PropertyKey<bool>("IsSelected", typeof(EntityHierarchyEnumerator), new StaticDefaultValueMetadata(false) { PropertyUpdateCallback = IsSelectedChanged });
this.EntitySystem = EntitySystem;
this.selectedEntitiesContext = selectedEntitiesContext;
}
public SubDivisionViewModel (DivisionInfo division, ViewModelContext context)
{
Context = context;
Title = division.Title;
HomePage = division.HomePage;
StartDate = division.StartDate;
EndDate = division.EndDate;
}
public void GenerateChildren(ViewModelContext context, IViewModelNode viewModelNode, ref bool handled)
{
if (viewModelNode.NodeValue is EffectOld)
{
viewModelNode.Children.Add(new ViewModelNode("Name", new PropertyInfoViewModelContent(new ParentNodeValueViewModelContent(), typeof(EffectOld).GetProperty("Name"))));
viewModelNode.Children.Add(new ViewModelNode("Plugins",
LambdaViewModelContent<EffectPluginDefinition[]>.FromParent<EffectOld>(
effect => effect.Plugins.Select(plugin => new EffectPluginDefinition { PluginType = plugin.GetType().AssemblyQualifiedName }).ToArray())));
}
}
public void GenerateChildren(ViewModelContext context, IViewModelNode viewModelNode, ref bool handled)
{
if (viewModelNode.NodeValue is RenderPass)
{
viewModelNode.Children.Add(new ViewModelNode("Name", new PropertyInfoViewModelContent(new ParentNodeValueViewModelContent(), typeof(ComponentBase).GetProperty("Name"))));
viewModelNode.Children.Add(new ViewModelNode("SubPasses", EnumerableViewModelContent.FromUnaryLambda<ViewModelReference, RenderPass>(new ParentNodeValueViewModelContent(),
(renderPass) => renderPass.Passes != null
? renderPass.Passes.Select(x => new ViewModelReference(x, true))
: Enumerable.Empty<ViewModelReference>())));
}
}
public void GenerateChildren(ViewModelContext context, IViewModelNode viewModelNode, ref bool handled)
{
if (viewModelNode.NodeValue is EffectOld)
{
viewModelNode.Children.Add(new ViewModelNode("Name", new PropertyInfoViewModelContent(new ParentNodeValueViewModelContent(), typeof(EffectOld).GetProperty("Name"))));
viewModelNode.Children.Add(new ViewModelNode("Plugins",
LambdaViewModelContent <EffectPluginDefinition[]> .FromParent <EffectOld>(
effect => effect.Plugins.Select(plugin => new EffectPluginDefinition {
PluginType = plugin.GetType().AssemblyQualifiedName
}).ToArray())));
}
}
ScienceDirectoryViewModel GetScienceDirectoryViewModel()
{
var settings = new ScienceDirectorySettingsRepository().GetSettings(ActiveModule);
var viewModelContext = new ViewModelContext <ScienceDirectorySettings> (ModuleContext, LocalResourceFile, settings);
var viewModel = new ScienceDirectoryViewModel();
viewModel.EduProgramScienceViewModels = GetEduProgramsForScienceDirectory(settings.DivisionId, settings.EduLevelIds)
.Select(ep => new EduProgramScienceViewModel(ep, viewModelContext));
return(viewModel);
}
public override IEditModel <DocumentInfo> Create(DocumentInfo model, ViewModelContext viewContext)
{
var viewModel = new DocumentEditModel();
CopyCstor.Copy <IDocumentWritable> (model, viewModel);
CopyCstor.Copy <IPublishableEntityWritable> (model, viewModel);
// FIXME: Context not updated for referenced viewmodels
viewModel.DocumentTypeViewModel = new DocumentTypeViewModel(model.DocumentType, viewContext);
viewModel.Context = viewContext;
return(viewModel);
}
public StrategyManagerViewModel(ViewModelContext viewModelContext, IStrategyService strategyService, IStrategyFileManager strategyFileManager)
: base(viewModelContext)
{
this.strategyService = strategyService;
this.strategyFileManager = strategyFileManager;
AddStrategyCommand = new ViewModelCommand(AddStrategy);
DeleteStrategyCommand = new ViewModelCommand(DeleteStrategy);
CloseCommand = new ViewModelCommand(Close);
SelectedStrategyViewModels = new ObservableCollection <StrategyViewModel>();
strategyObservableSubscriptions = new Dictionary <string, IDisposable>();
}
public override IEditModel <EduProgramProfileFormYearInfo> Create(
EduProgramProfileFormYearInfo model, ViewModelContext context)
{
var viewModel = new EduProgramProfileFormYearEditModel();
CopyCstor.Copy <IEduProgramProfileFormYearWritable> (model, viewModel);
CopyCstor.Copy <IPublishableEntityWritable> (model, viewModel);
viewModel.EduFormViewModel = new EduFormViewModel(model.EduForm, context);
viewModel.YearString = model.Year.Year.ToString();
viewModel.Context = context;
return(viewModel);
}
public void GenerateChildren(ViewModelContext context, IViewModelNode viewModelNode, ref bool handled)
{
if (viewModelNode.NodeValue is RenderPassPlugin)
{
var pluginType = viewModelNode.NodeValue.GetType();
foreach (var propertyInfo in pluginType.GetProperties(BindingFlags.FlattenHierarchy | BindingFlags.Public | BindingFlags.Instance))
{
IViewModelContent viewModelContent = new PropertyInfoViewModelContent(new ParentNodeValueViewModelContent(), propertyInfo);
if (propertyInfo.PropertyType == typeof(RenderPass) || propertyInfo.PropertyType.IsSubclassOf(typeof(RenderPass)))
{
viewModelContent = LambdaViewModelContent <ViewModelReference> .FromOperand <RenderPass>(viewModelContent, x => new ViewModelReference(x, false));
}
else if (!propertyInfo.PropertyType.IsValueType || !propertyInfo.PropertyType.FullName.StartsWith("System."))
{
continue;
}
viewModelNode.Children.Add(new ViewModelNode(propertyInfo.Name, viewModelContent));
}
foreach (var fieldinfo in pluginType.GetFields(BindingFlags.FlattenHierarchy | BindingFlags.Public | BindingFlags.Instance))
{
IViewModelContent viewModelContent = new FieldInfoViewModelContent(new ParentNodeValueViewModelContent(pluginType), fieldinfo);
//if (fieldinfo.FieldType.IsValueType && !fieldinfo.FieldType.IsPrimitive && !fieldinfo.FieldType.IsEnum)
// viewModelContent.Flags = ViewModelFlags.None;
viewModelNode.Children.Add(new ViewModelNode(fieldinfo.Name, viewModelContent).GenerateChildren(context));
}
}
#if PARADOX_YEBIS
else if (viewModelNode.Type.Namespace == typeof(ToneMap).Namespace &&
viewModelNode.Type.IsValueType && !viewModelNode.Type.IsPrimitive && !viewModelNode.Type.IsEnum)
{
// Use default for those types
foreach (var fieldinfo in viewModelNode.Type.GetFields(BindingFlags.FlattenHierarchy | BindingFlags.Public | BindingFlags.Instance))
{
IViewModelContent viewModelContent = new FieldInfoViewModelContent(new ParentValueViewModelContent(viewModelNode.Type), fieldinfo);
//if (fieldinfo.FieldType.IsValueType && !fieldinfo.FieldType.IsPrimitive && !fieldinfo.FieldType.IsEnum)
// viewModelContent.Flags = ViewModelFlags.None;
// Doesn't support array
if (fieldinfo.FieldType.IsArray)
{
continue;
}
viewModelNode.Children.Add(new ViewModelNode(fieldinfo.Name, viewModelContent).GenerateChildren(context));
}
}
#endif
}
public async Task LoadIntForString_ReturnFalse()
{
ViewModelContext context = new ViewModelContext();
context.AddValue <string>("id", "qj123");
await context.SaveObjectToJsonFileAsync(filename, settings);
var newcontext = await filename.GetObjectFromJsonFileAsync <ViewModelContext>(settings);
var result = newcontext.TryGetValue <int>("id", out int resInt);
Assert.AreEqual(0, resInt);
Assert.AreEqual(false, result);
}
public UserAccountsViewModel(ViewModelContext viewModelContext, IAccountsService accountsService, ISymbolsLoader symbolsLoader)
: base(viewModelContext)
{
this.accountsService = accountsService;
this.symbolsLoader = symbolsLoader;
AddAccountCommand = new ViewModelCommand(AddAccount);
DeleteAccountCommand = new ViewModelCommand(DeleteAccount);
CloseCommand = new ViewModelCommand(Close);
SelectedUserAccountViewModels = new ObservableCollection <UserAccountViewModel>();
observables = new Dictionary <string, IDisposable>();
}
private async Task OpenWind2()
{
var context = new ViewModelContext();
context.AddValue("Title", "hello from Window1ViewModel");
try
{
await _navigation.NavigateToAsync <Window2ViewModel>(new NavigateParameters(context));
}
catch
{
NotificationMessage = "Error on Win2 open";
}
}
public async Task LoadString_ReturnString()
{
ViewModelContext context = new ViewModelContext();
context.AddValue <string>("id", "textid");
await context.SaveObjectToJsonFileAsync(filename, settings);
var newcontext = await filename.GetObjectFromJsonFileAsync <ViewModelContext>(settings);
var result = newcontext.GetValue <string>("id");
Assert.IsInstanceOfType(result, typeof(string));
Assert.AreEqual("textid", result);
}
public void inject(ViewModelContext context)
{
model = new UnityChanLocomotionModel(
forwardSpeed: context.forwardSpeed,
backwardSpeed: context.backwardSpeed,
rotateSpeed: context.rotateSpeed,
jumpPower: context.jumpPower,
jumpThreshold: context.useCurvesHeight,
colliderOffsetY: context.colliderCenterY,
colliderDefaultHeight: context.colliderHight,
transform: context.transform,
deltaTime: deltaTime.delta
);
}
public override IEditModel <EduProgramProfileFormYearInfo> Create(
EduProgramProfileFormYearInfo model, ViewModelContext context)
{
var viewModel = new EduProgramProfileFormYearEditModel();
CopyCstor.Copy <IEduProgramProfileFormYearWritable> (model, viewModel);
CopyCstor.Copy <IPublishableEntityWritable> (model, viewModel);
viewModel.EduFormViewModel = new EduFormViewModel(model.EduForm, context);
viewModel.HasEduVolume = model.EduVolume != null;
viewModel.HasContingent = model.Contingent != null;
viewModel.Context = context;
return(viewModel);
}
ContingentDirectoryViewModel GetContingentViewModel()
{
var settings = new ContingentDirectorySettingsRepository().GetSettings(ActiveModule);
var viewModelContext = new ViewModelContext <ContingentDirectorySettings> (ModuleContext, LocalResourceFile, settings);
using (var modelContext = new UniversityModelContext()) {
var viewModel = new ContingentDirectoryViewModel();
viewModel.Settings = settings;
viewModel.LastYear = new FlatQuery <YearInfo> (modelContext).List().LastYear();
viewModel.ContingentViewModels =
GetContingentsForContingentDirectory(modelContext, settings)
.Select(ev => new ContingentViewModel(ev, viewModelContext, viewModel));
return(viewModel);
}
}
public AccountsViewModel(
ViewModelContext viewModelContext,
IAccountsService accountsService,
IWpfExchangeService exchangeService,
ISymbolsCacheFactory symbolsCacheFactory,
ILoggerFacade logger)
: base(viewModelContext)
{
this.accountsService = accountsService;
this.exchangeService = exchangeService;
this.symbolsCacheFactory = symbolsCacheFactory;
this.logger = logger;
Accounts = new ObservableCollection <AccountViewModel>();
}
public async Task LoadInt_ReturnInt()
{
ViewModelContext context = new ViewModelContext();
context.AddValue <int>("id", 158);
await context.SaveObjectToJsonFileAsync(filename, settings);
var newcontext = await filename.GetObjectFromJsonFileAsync <ViewModelContext>(settings);
var result = newcontext.GetValue <int>("id");
Assert.IsNotNull(result);
Assert.IsInstanceOfType(result, typeof(int));
Assert.AreEqual(158, result);
}
public async Task LoadDateTime_ReturnDateTime()
{
DateTime now = DateTime.Now;
ViewModelContext context = new ViewModelContext();
context.AddValue <DateTime>("id", now);
await context.SaveObjectToJsonFileAsync(filename, settings);
var newcontext = await filename.GetObjectFromJsonFileAsync <ViewModelContext>(settings);
var result = newcontext.GetValue <DateTime>("id");
Assert.IsInstanceOfType(result, typeof(DateTime));
Assert.AreEqual(now, result);
}
public void GenerateChildren(ViewModelContext context, IViewModelNode viewModelNode, ref bool handled)
{
if (viewModelNode.NodeValue is RenderPassPlugin)
{
viewModelNode.Children.Add(new ViewModelNode("Name", new PropertyInfoViewModelContent(new ParentNodeValueViewModelContent(), typeof(ComponentBase).GetProperty("Name"))));
viewModelNode.Children.Add(new ViewModelNode("EventOpen", new RootViewModelContent((ExecuteCommand)((viewModel2, parameter) =>
{
SelectedRenderPassPluginContext.ViewModelByGuid.Clear();
//SelectedRenderPassPluginContext.Root = SelectedRenderPassPluginContext.GetModelView(viewModel2.Parent.NodeValue);
SelectedRenderPassPluginContext.Root = new ViewModelNode("Root", new RootViewModelContent(new[] { new ViewModelReference(viewModel2.Parent.NodeValue, true) }, typeof(IList <ViewModelReference>)));
//SelectedRenderPassPluginContext.GetModelView(viewModel2.Parent.NodeValue);
}))));
handled = true;
}
}
private IViewModelNode CreateProperty(object obj)
{
var context = new ViewModelContext();
var contextUI = new ViewModelContext();
context.ChildrenPropertyEnumerators.Add(new ChildrenPropertyInfoEnumerator());
// add some more here...
var testModel = new ViewModelNode("Root", obj);
var view = ObservableViewModelNode.CreateObservableViewModel(contextUI, testModel);
ObservableViewModelNode.Refresh(contextUI, context, new ViewModelState());
return view;
}
public void GenerateChildren(ViewModelContext context, IViewModelNode viewModelNode, ref bool handled)
{
if (viewModelNode.NodeValue is RenderPassPlugin)
{
viewModelNode.Children.Add(new ViewModelNode("Name", new PropertyInfoViewModelContent(new ParentNodeValueViewModelContent(), typeof(ComponentBase).GetProperty("Name"))));
viewModelNode.Children.Add(new ViewModelNode("EventOpen", new RootViewModelContent((ExecuteCommand)((viewModel2, parameter) =>
{
SelectedRenderPassPluginContext.ViewModelByGuid.Clear();
//SelectedRenderPassPluginContext.Root = SelectedRenderPassPluginContext.GetModelView(viewModel2.Parent.NodeValue);
SelectedRenderPassPluginContext.Root = new ViewModelNode("Root", new RootViewModelContent(new[] { new ViewModelReference(viewModel2.Parent.NodeValue, true) }, typeof(IList<ViewModelReference>)));
//SelectedRenderPassPluginContext.GetModelView(viewModel2.Parent.NodeValue);
}))));
handled = true;
}
}
public ConfigurationAuthorisationViewModel(ViewModelContext viewModelContext, AuthorisationManagerServiceManager authorisationManagerServiceManager)
: base(viewModelContext)
{
this.authorisationManagerServiceManager = authorisationManagerServiceManager;
NewUserCommand = new WpfCommand(OnNewUser);
NewRoleCommand = new WpfCommand(OnNewRole);
NewActivityCommand = new WpfCommand(OnNewActivity);
SaveCommand = new WpfCommand(OnEntitySave);
DeleteCommand = new WpfCommand(OnEntityDelete);
RemoveItemCommand = new WpfCommand(OnRemoveItem);
DragDropCommand = new WpfCommand(OnDragDrop);
SelectItemCommand = new WpfCommand(OnSelectItem);
Logger.Log("ConfigurationAuthorisationViewModel initialised", Category.Info, Priority.None);
}
public static List<DocumentTypeViewModel> GetBindableList (IEnumerable<DocumentTypeInfo> documentTypes,
ViewModelContext context, bool withDefaultItem)
{
var documentTypeVms = documentTypes.Select (dt => new DocumentTypeViewModel (dt, context)).ToList ();
if (withDefaultItem)
{
documentTypeVms.Insert (0, new DocumentTypeViewModel {
DocumentTypeID = Null.NullInteger,
Type = "Default",
Context = context
});
}
return documentTypeVms;
}
private IViewModelNode CreateProperty(object obj)
{
var context = new ViewModelContext();
var contextUI = new ViewModelContext();
context.ChildrenPropertyEnumerators.Add(new ChildrenPropertyInfoEnumerator());
// add some more here...
var testModel = new ViewModelNode("Root", obj);
var view = ObservableViewModelNode.CreateObservableViewModel(contextUI, testModel);
ObservableViewModelNode.Refresh(contextUI, context, new ViewModelState());
return(view);
}
public static List<EduFormViewModel> GetBindableList (IEnumerable<EduFormInfo> eduForms,
ViewModelContext context, bool withDefaultItem)
{
var eduFormVms = eduForms.Select (ef => new EduFormViewModel (ef, context)).ToList ();
if (withDefaultItem) {
eduFormVms.Insert (0, new EduFormViewModel
{
EduFormID = Null.NullInteger,
Title = "Default",
Context = context
});
}
return eduFormVms;
}
public void NavigateToAsyncNotExists_AtActiveContainer_ActiveContainerNotChangedAndCreatedNewWindow()
{
ViewModelContext viewModelContext = new ViewModelContext();
viewModelContext.AddValue <string>("Title", "New title");
NavigateParameters navigateParameters = new NavigateParameters(viewModelContext);
navigationService.NavigateToAsync <MdiWindowMock>(navigateParameters);
var aimWindow = managerService.Containers[0].WindowsCollection.Last();
Assert.AreEqual("Title1", managerService.ActiveContainer.Title);
Assert.AreEqual(4, managerService.ActiveContainer.WindowsCollection.Count);
Assert.AreEqual("New title", aimWindow.Title);
Assert.IsTrue(aimWindow.IsSelected);
}
public void GenerateChildren(ViewModelContext context, IViewModelNode viewModelNode, ref bool handled)
{
if (viewModelNode.NodeValue is EffectBuilder)
{
viewModelNode.Children.Add(new ViewModelNode("Name", new PropertyInfoViewModelContent(new ParentNodeValueViewModelContent(), typeof(EffectBuilder).GetProperty("Name"))));
viewModelNode.Children.Add(new ViewModelNode("EventOpen", new RootViewModelContent((ExecuteCommand)((viewModel2, parameter) =>
{
selectedEntitiesContext.ViewModelByGuid.Clear();
selectedEntitiesContext.Root = selectedEntitiesContext.GetModelView(viewModel2.Parent.NodeValue);
}))));
viewModelNode.Children.Add(new ViewModelNode("Definition", new AsyncViewModelContent <EffectDefinition>(new ParentNodeValueViewModelContent(),
operand => new EffectDefinition
{
Plugins = ((EffectBuilder)operand.Value).Plugins.Select(x =>
{
var pluginDefinition = new EffectPluginDefinition
{
PluginType = x.GetType().AssemblyQualifiedName,
Parameters = new Dictionary <string, EffectParameterDefinition>()
};
foreach (var property in x.GetType().GetProperties(BindingFlags.FlattenHierarchy | BindingFlags.Public | BindingFlags.Instance))
{
if (property.GetCustomAttributes(typeof(EffectDefinitionPropertyAttribute), true).Length == 0)
{
continue;
}
// Check type and do some simple conversion
var value = property.GetValue(x, null);
if (typeof(RenderPassPlugin).IsAssignableFrom(property.PropertyType))
{
value = Guid.NewGuid();
}
else if (!typeof(ShaderSource).IsAssignableFrom(property.PropertyType) &&
!property.PropertyType.IsValueType)
{
throw new NotSupportedException();
}
pluginDefinition.Parameters.Add(property.Name, new EffectParameterDefinition(property.PropertyType, value));
}
return(pluginDefinition);
}).ToList()
})));
//new AsyncViewModelContent<EffectDefinition>(() => ) { LoadState = ViewModelContentState.NotLoaded, Flags = ViewModelFlags.Static | ViewModelFlags.Async | ViewModelFlags.Serialize });
}
}
public StrategyViewModel(ViewModelContext viewModelContext, IStrategyService strategyService)
: base(viewModelContext)
{
this.strategyService = strategyService;
CanConnect = true;
IsConnected = false;
IsConnecting = false;
Notifications = new ObservableCollection <Message>();
RunCommand = new ViewModelCommand(RunStrategy);
MonitorCommand = new ViewModelCommand(MonitorStrategy);
DisconnectCommand = new ViewModelCommand(Disconnect);
StopCommand = new ViewModelCommand(StopStrategy);
ClearNotificationsCommand = new ViewModelCommand(ClearNotifications);
}
public void GenerateChildren(ViewModelContext context, IViewModelNode viewModelNode, ref bool handled)
{
if (viewModelNode.NodeValue is MicroThread)
{
viewModelNode.Children.Add(new ViewModelNode("Id", new PropertyInfoViewModelContent(new ParentNodeValueViewModelContent(), typeof(MicroThread).GetProperty("Id"))));
viewModelNode.Children.Add(new ViewModelNode("Name", new PropertyInfoViewModelContent(new ParentNodeValueViewModelContent(), typeof(MicroThread).GetProperty("Name"))));
viewModelNode.Children.Add(new ViewModelNode("ScriptName",
LambdaViewModelContent <string> .FromParent <MicroThread>(x => x.Get(ScriptManager.ScriptEntryProperty).TypeName)));
viewModelNode.Children.Add(new ViewModelNode("EventOpen", new RootViewModelContent((ExecuteCommand)((viewModel2, parameter) =>
{
selectedEntitiesContext.ViewModelByGuid.Clear();
selectedEntitiesContext.Root = selectedEntitiesContext.GetModelView(viewModel2.Parent.NodeValue);
}))));
handled = true;
}
}
public void GenerateChildren(ViewModelContext context, IViewModelNode viewModelNode, ref bool handled)
{
if (viewModelNode.NodeValue is MicroThread)
{
viewModelNode.Children.Add(new ViewModelNode("Id", new PropertyInfoViewModelContent(new ParentNodeValueViewModelContent(), typeof(MicroThread).GetProperty("Id"))));
viewModelNode.Children.Add(new ViewModelNode("Name", new PropertyInfoViewModelContent(new ParentNodeValueViewModelContent(), typeof(MicroThread).GetProperty("Name"))));
viewModelNode.Children.Add(new ViewModelNode("ScriptName",
LambdaViewModelContent<string>.FromParent<MicroThread>(x => x.Get(ScriptManager.ScriptEntryProperty).TypeName)));
viewModelNode.Children.Add(new ViewModelNode("EventOpen", new RootViewModelContent((ExecuteCommand)((viewModel2, parameter) =>
{
selectedEntitiesContext.ViewModelByGuid.Clear();
selectedEntitiesContext.Root = selectedEntitiesContext.GetModelView(viewModel2.Parent.NodeValue);
}))));
handled = true;
}
}
private async void DeviceListView_Loaded(object sender, RoutedEventArgs e)
{
ViewModelContext viewModelContext = this.ViewModel.ViewModelContext;
viewModelContext.UserBarVisibility = Visibility.Collapsed;
viewModelContext.BannerVisibility = Visibility.Visible;
viewModelContext.Title = "设备选择"; // TODO: From resource.
try
{
await this.ViewModel.LoadDevicesAsync().ConfigureAwait(true);
}
catch (RpcException ex)
{
MessageBox.Show("Failed to load devices: " + ex.Message);
}
}
public static List <EduFormViewModel> GetBindableList(IEnumerable <EduFormInfo> eduForms,
ViewModelContext context, bool withDefaultItem)
{
var eduFormVms = eduForms.Select(ef => new EduFormViewModel(ef, context)).ToList();
if (withDefaultItem)
{
eduFormVms.Insert(0, new EduFormViewModel
{
EduFormID = Null.NullInteger,
Title = "Default",
Context = context
});
}
return(eduFormVms);
}
public void GenerateChildren(ViewModelContext context, IViewModelNode viewModelNode, ref bool handled)
{
if (viewModelNode.NodeValue is RenderPassPlugin)
{
var pluginType = viewModelNode.NodeValue.GetType();
foreach (var propertyInfo in pluginType.GetProperties(BindingFlags.FlattenHierarchy | BindingFlags.Public | BindingFlags.Instance))
{
IViewModelContent viewModelContent = new PropertyInfoViewModelContent(new ParentNodeValueViewModelContent(), propertyInfo);
if (propertyInfo.PropertyType == typeof(RenderPass) || propertyInfo.PropertyType.IsSubclassOf(typeof(RenderPass)))
viewModelContent = LambdaViewModelContent<ViewModelReference>.FromOperand<RenderPass>(viewModelContent, x => new ViewModelReference(x, false));
else if (!propertyInfo.PropertyType.IsValueType || !propertyInfo.PropertyType.FullName.StartsWith("System."))
continue;
viewModelNode.Children.Add(new ViewModelNode(propertyInfo.Name, viewModelContent));
}
foreach (var fieldinfo in pluginType.GetFields( BindingFlags.FlattenHierarchy | BindingFlags.Public | BindingFlags.Instance))
{
IViewModelContent viewModelContent = new FieldInfoViewModelContent(new ParentNodeValueViewModelContent(pluginType), fieldinfo);
//if (fieldinfo.FieldType.IsValueType && !fieldinfo.FieldType.IsPrimitive && !fieldinfo.FieldType.IsEnum)
// viewModelContent.Flags = ViewModelFlags.None;
viewModelNode.Children.Add(new ViewModelNode(fieldinfo.Name, viewModelContent).GenerateChildren(context));
}
}
#if PARADOX_YEBIS
else if (viewModelNode.Type.Namespace == typeof(ToneMap).Namespace
&& viewModelNode.Type.IsValueType && !viewModelNode.Type.IsPrimitive && !viewModelNode.Type.IsEnum)
{
// Use default for those types
foreach (var fieldinfo in viewModelNode.Type.GetFields(BindingFlags.FlattenHierarchy | BindingFlags.Public | BindingFlags.Instance))
{
IViewModelContent viewModelContent = new FieldInfoViewModelContent(new ParentValueViewModelContent(viewModelNode.Type), fieldinfo);
//if (fieldinfo.FieldType.IsValueType && !fieldinfo.FieldType.IsPrimitive && !fieldinfo.FieldType.IsEnum)
// viewModelContent.Flags = ViewModelFlags.None;
// Doesn't support array
if (fieldinfo.FieldType.IsArray)
continue;
viewModelNode.Children.Add(new ViewModelNode(fieldinfo.Name, viewModelContent).GenerateChildren(context));
}
}
#endif
}
public void GenerateChildren(ViewModelContext context, IViewModelNode viewModelNode, ref bool handled)
{
if (viewModelNode.NodeValue is EffectBuilder)
{
viewModelNode.Children.Add(new ViewModelNode("Name", new PropertyInfoViewModelContent(new ParentNodeValueViewModelContent(), typeof(EffectBuilder).GetProperty("Name"))));
viewModelNode.Children.Add(new ViewModelNode("EventOpen", new RootViewModelContent((ExecuteCommand)((viewModel2, parameter) =>
{
selectedEntitiesContext.ViewModelByGuid.Clear();
selectedEntitiesContext.Root = selectedEntitiesContext.GetModelView(viewModel2.Parent.NodeValue);
}))));
viewModelNode.Children.Add(new ViewModelNode("Definition", new AsyncViewModelContent<EffectDefinition>(new ParentNodeValueViewModelContent(),
operand => new EffectDefinition
{
Plugins = ((EffectBuilder)operand.Value).Plugins.Select(x =>
{
var pluginDefinition = new EffectPluginDefinition
{
PluginType = x.GetType().AssemblyQualifiedName,
Parameters = new Dictionary<string, EffectParameterDefinition>()
};
foreach (var property in x.GetType().GetProperties(BindingFlags.FlattenHierarchy | BindingFlags.Public | BindingFlags.Instance))
{
if (property.GetCustomAttributes(typeof(EffectDefinitionPropertyAttribute), true).Length == 0)
continue;
// Check type and do some simple conversion
var value = property.GetValue(x, null);
if (typeof(RenderPassPlugin).IsAssignableFrom(property.PropertyType))
{
value = Guid.NewGuid();
}
else if (!typeof(ShaderSource).IsAssignableFrom(property.PropertyType)
&& !property.PropertyType.IsValueType)
{
throw new NotSupportedException();
}
pluginDefinition.Parameters.Add(property.Name, new EffectParameterDefinition(property.PropertyType, value));
}
return pluginDefinition;
}).ToList()
})));
//new AsyncViewModelContent<EffectDefinition>(() => ) { LoadState = ViewModelContentState.NotLoaded, Flags = ViewModelFlags.Static | ViewModelFlags.Async | ViewModelFlags.Serialize });
}
}
private IViewModelNode CreateSampleTree()
{
MyDateTime now = MyDateTime.FromDateTime(DateTime.Now);
var context = new ViewModelContext(new ViewModelGlobalContext());
var contextUI = new ViewModelContext(new ViewModelGlobalContext());
context.ChildrenPropertyEnumerators.Add(new ChildrenPropertyInfoEnumerator());
// add some more here...
var testModel = new ViewModelNode("Root", now);
var view = ObservableViewModelNode.CreateObservableViewModel(contextUI, testModel);
ObservableViewModelNode.Refresh(contextUI, context, new ViewModelState());
return view;
}
private IViewModelNode CreateSampleTree()
{
MyDateTime now = MyDateTime.FromDateTime(DateTime.Now);
var context = new ViewModelContext(new ViewModelGlobalContext());
var contextUI = new ViewModelContext(new ViewModelGlobalContext());
context.ChildrenPropertyEnumerators.Add(new ChildrenPropertyInfoEnumerator());
// add some more here...
var testModel = new ViewModelNode("Root", now);
var view = ObservableViewModelNode.CreateObservableViewModel(contextUI, testModel);
ObservableViewModelNode.Refresh(contextUI, context, new ViewModelState());
return(view);
}
public void NavigateToAsyncExists_AtNotActiveContainer_ActiveContainerChanged()
{
Guid winGuid = samples.Guids[1].Value[0];
ViewModelContext viewModelContext = new ViewModelContext();
viewModelContext.AddValue <string>("Title", "New title");
NavigateParameters navigateParameters = new NavigateParameters(viewModelContext, windowGuid: winGuid);
navigationService.NavigateToAsync <MdiWindowMock>(navigateParameters);
var aimWindow = managerService.Containers[1].WindowsCollection[0];
Assert.AreEqual("Title2", managerService.ActiveContainer.Title);
Assert.AreEqual(2, managerService.ActiveContainer.WindowsCollection.Count);
Assert.AreEqual(winGuid, aimWindow.Guid);
Assert.AreEqual("New title", aimWindow.Title);
Assert.IsTrue(aimWindow.IsSelected);
}
public async Task LoadClass_ReturnClass()
{
TestClass obj = new TestClass(19);
ViewModelContext context = new ViewModelContext();
context.AddValue <TestClass>("id", obj);
await context.SaveObjectToJsonFileAsync(filename, settings);
var newcontext = await filename.GetObjectFromJsonFileAsync <ViewModelContext>(settings);
var result = newcontext.GetValue <TestClass>("id");
Assert.IsNotNull(result);
Assert.IsInstanceOfType(result, typeof(TestClass));
//Assert.AreEqual(obj, result);
Assert.AreEqual(19, result.Id);
Assert.AreEqual(DateTime.Today, result.DateTime.Date);
Assert.AreEqual("Id is 19", result.Text);
}
public StrategyRunnerViewModel(
ViewModelContext viewModelContext,
AccountViewModel accountViewModel,
SymbolsViewModel symbolsViewModel,
OrdersViewModel ordersViewModel,
StrategyParametersViewModel strategyParametersViewModel,
IStrategyService strategyService,
IServerMonitorCache serverMonitorCache,
IStrategyAssemblyManager strategyAssemblyManager)
: base(viewModelContext)
{
this.strategyService = strategyService;
this.serverMonitorCache = serverMonitorCache;
this.strategyAssemblyManager = strategyAssemblyManager;
AccountViewModel = accountViewModel;
SymbolsViewModel = symbolsViewModel;
OrdersViewModel = ordersViewModel;
StrategyParametersViewModel = strategyParametersViewModel;
CanRun = false;
CanMonitor = false;
IsConnected = false;
IsConnecting = false;
Notifications = new ObservableCollection <Message>();
RunCommand = new ViewModelCommand(RunStrategy);
MonitorCommand = new ViewModelCommand(MonitorStrategy);
DisconnectCommand = new ViewModelCommand(Disconnect);
StopCommand = new ViewModelCommand(StopStrategy);
ClearNotificationsCommand = new ViewModelCommand(ClearNotifications);
ObserveOrders();
ObserveSymbols();
ObserveAccount();
ObserveParameters();
ObserveServerMonitorCache();
}
public void GenerateChildren(ViewModelContext context, IViewModelNode viewModelNode, ref bool handled)
{
var type = viewModelNode.Type;
if (viewModelNode.NodeValue is ScriptAssembly)
{
viewModelNode.Children.Add(new ViewModelNode("Url", new PropertyInfoViewModelContent(new ParentNodeValueViewModelContent(), typeof(ScriptAssembly).GetProperty("Url"))));
viewModelNode.Children.Add(new ViewModelNode("Scripts", EnumerableViewModelContent.FromUnaryLambda<ViewModelReference, ScriptAssembly>(new ParentNodeValueViewModelContent(),
(scriptAssembly) => scriptAssembly.Scripts.Select(x => new ViewModelReference(x, true)))));
handled = true;
}
if (viewModelNode.NodeValue is ScriptEntry2)
{
viewModelNode.Children.Add(new ViewModelNode("TypeName", new PropertyInfoViewModelContent(new ParentNodeValueViewModelContent(), typeof(ScriptEntry2).GetProperty("TypeName"))));
viewModelNode.Children.Add(new ViewModelNode("MethodName", new PropertyInfoViewModelContent(new ParentNodeValueViewModelContent(), typeof(ScriptEntry2).GetProperty("MethodName"))));
viewModelNode.Children.Add(new ViewModelNode("Run", new RootViewModelContent((ExecuteCommand)((viewModel2, parameter) =>
{
var scriptEntry = (ScriptEntry2)viewModel2.Parent.NodeValue;
var microThread = engineContext.ScriptManager.RunScript(scriptEntry, null);
}))));
handled = true;
}
}
public void GenerateChildren(ViewModelContext context, IViewModelNode viewModelNode, ref bool handled)
{
var type = viewModelNode.Type;
if (viewModelNode.NodeValue is ScriptAssembly)
{
viewModelNode.Children.Add(new ViewModelNode("Url", new PropertyInfoViewModelContent(new ParentNodeValueViewModelContent(), typeof(ScriptAssembly).GetProperty("Url"))));
viewModelNode.Children.Add(new ViewModelNode("Scripts", EnumerableViewModelContent.FromUnaryLambda <ViewModelReference, ScriptAssembly>(new ParentNodeValueViewModelContent(),
(scriptAssembly) => scriptAssembly.Scripts.Select(x => new ViewModelReference(x, true)))));
handled = true;
}
if (viewModelNode.NodeValue is ScriptEntry2)
{
viewModelNode.Children.Add(new ViewModelNode("TypeName", new PropertyInfoViewModelContent(new ParentNodeValueViewModelContent(), typeof(ScriptEntry2).GetProperty("TypeName"))));
viewModelNode.Children.Add(new ViewModelNode("MethodName", new PropertyInfoViewModelContent(new ParentNodeValueViewModelContent(), typeof(ScriptEntry2).GetProperty("MethodName"))));
viewModelNode.Children.Add(new ViewModelNode("Run", new RootViewModelContent((ExecuteCommand)((viewModel2, parameter) =>
{
var scriptEntry = (ScriptEntry2)viewModel2.Parent.NodeValue;
var microThread = engineContext.ScriptManager.RunScript(scriptEntry, null);
}))));
handled = true;
}
}
public void GenerateChildren(ViewModelContext context, IViewModelNode viewModelNode, ref bool handled)
{
if (viewModelNode.NodeValue is Entity)
{
viewModelNode.Children.Add(new ViewModelNode("Name", new PropertyInfoViewModelContent(new ParentNodeValueViewModelContent(), typeof(Entity).GetProperty("Name"))));
viewModelNode.Children.Add(new ViewModelNode("Guid", new PropertyInfoViewModelContent(new ParentNodeValueViewModelContent(), typeof(Entity).GetProperty("Guid"))));
viewModelNode.Children.Add(new ViewModelNode("IsSelected", new PropertyKeyViewModelContent(new ParentNodeValueViewModelContent(), isSelectedProperty)));
viewModelNode.Children.Add(new ViewModelNode("ParentReference", LambdaViewModelContent<ViewModelReference>.FromParent<Entity>(x =>
{
var transformationComponent = x.Transformation;
var parent = transformationComponent != null ? transformationComponent.Parent : null;
return new ViewModelReference(parent != null ? parent.Entity : null);
})));
viewModelNode.Children.Add(new ViewModelNode("HierarchicalEntities", EnumerableViewModelContent.FromUnaryLambda<ViewModelReference, Entity>(new ParentNodeValueViewModelContent(),
(entity) =>
{
var result = Enumerable.Empty<ViewModelReference>();
// Enumerates children nodes
var transformationComponent = entity.Transformation;
if (transformationComponent != null)
result = result.Concat(transformationComponent.Children
.Select(x => new ViewModelReference(x.Entity, true)));
// Enumerates EffectMesh
var meshComponent = entity.Get(ModelComponent.Key);
if (meshComponent != null && meshComponent.InstantiatedSubMeshes != null)
result = result.Concat(meshComponent.InstantiatedSubMeshes.Select((x, i) =>
{
effectMeshIndices.GetOrCreateValue(x.Value).Index = i;
return new ViewModelReference(x.Value, true);
}));
return result;
})));
viewModelNode.Children.Add(new ViewModelNode("EventOpen", new RootViewModelContent((ExecuteCommand)((viewModel2, parameter) =>
{
ScriptDebug.SelectEntity((Entity)viewModel2.Parent.NodeValue);
}))));
viewModelNode.Children.Add(new ViewModelNode("CreateNewEntity", new RootViewModelContent((ExecuteCommand)((viewModel2, parameter) =>
{
var entity = (Entity)viewModel2.Parent.NodeValue;
var newEntity = new Entity("New Entity");
entity.Transformation.Children.Add(newEntity.Transformation);
}))));
viewModelNode.Children.Add(new ViewModelNode("Remove", new RootViewModelContent((ExecuteCommand)((viewModel2, parameter) =>
{
var entity = (Entity)viewModel2.Parent.NodeValue;
EntitySystem.Remove(entity);
}))));
handled = true;
}
else if (viewModelNode.NodeValue is EffectMesh)
{
viewModelNode.Children.Add(new ViewModelNode("Name", new LambdaViewModelContent<string>(new NullViewModelContent(), (content) =>
{
var effectMesh = (EffectMesh)content.OwnerNode.Parent.NodeValue;
var result = effectMeshIndices.GetOrCreateValue(effectMesh).Index.ToString();
if (effectMesh.Name != null)
result += " - " + effectMesh.Name;
return result;
})));
viewModelNode.Children.Add(new ViewModelNode("EventOpen", new RootViewModelContent((ExecuteCommand)((viewModel2, parameter) =>
{
selectedEntitiesContext.ViewModelByGuid.Clear();
selectedEntitiesContext.Root = new ViewModelNode("Root", new RootViewModelContent(new[] { new ViewModelReference(viewModel2.Parent.NodeValue, true) }, typeof(IList<ViewModelReference>)));
}))));
handled = true;
}
}
public void GenerateChildren(ViewModelContext context, IViewModelNode viewModelNode, ref bool handled)
{
if ((viewModelNode.NodeValue as string) == "Root")
{
viewModelNode.Children.Add(new ViewModelNode("SearchResults", new EnumerableViewModelContent<ViewModelReference>(() =>
searchResults != null && searchResults.IsCompleted ? searchResults.Result.Select(searchResult => new ViewModelReference(KeyValuePair.Create(UrlType.SearchResult, searchResult), true))
: new ViewModelReference[] { })));
viewModelNode.Children.Add(new ViewModelNode("SearchFilter",
new LambdaViewModelContent<string>(
() => searchFilter,
(newFilter) =>
{
searchFilter = newFilter;
StartSearch();
})));
viewModelNode.Children.Add(new ViewModelNode("Packages",
new EnumerableViewModelContent<ViewModelReference>(() => engineContext.PackageManager.Packages.Select(package => new ViewModelReference(package, true)))));
fileTracker = new FileTracker();
fileTracker.Setup("/global_data");
fileTracker.Setup("/global_data2");
viewModelNode.Children.Add(new ViewModelNode("FileTracker", new RootViewModelContent(fileTracker)).GenerateChildren(context));
}
if (viewModelNode.Type == typeof(FileTracker))
{
viewModelNode.Content.SerializeFlags = ViewModelContentSerializeFlags.None;
viewModelNode.Children.Add(new ViewModelNode("RootFolder", KeyValuePair.Create(UrlType.FileTracker, "/")).GenerateChildren(context));
handled = true;
}
if (viewModelNode.NodeValue is Package)
{
viewModelNode.Children.Add(new ViewModelNode("Name", new PropertyInfoViewModelContent(new ParentNodeValueViewModelContent(), typeof(Package).GetProperty("Name"))));
handled = true;
}
if (viewModelNode.NodeValue is Tuple<UrlType, string>)
{
var nodeValue = (Tuple<UrlType, string>)viewModelNode.NodeValue;
var url = nodeValue.Item2;
if (nodeValue.Item1 == UrlType.SearchResult)
{
// Load thumbnail (not cached yet)
if (url.EndsWith(".png") || url.EndsWith(".jpg"))
{
//var textureData = engineContext.ContentManager.LoadAsync<Image>(url);
var thumbnail = new ViewModelNode("Thumbnail",
new AsyncViewModelContent<Image>(new NullViewModelContent(), operand => engineContext.AssetManager.Load<Image>(url)));
viewModelNode.Children.Add(thumbnail);
/*textureData.ContinueWith(task =>
{
thumbnail.Value = task.Result;
thumbnail.Content.Flags |= ViewModelFlags.Static;
});*/
}
/*else
{
throw new NotImplementedException();
}*/
viewModelNode.Content = new RootViewModelContent(url);
viewModelNode.Content.SerializeFlags = ViewModelContentSerializeFlags.Serialize;
}
else if (nodeValue.Item1 == UrlType.FileTracker)
{
viewModelNode.Content = new RootViewModelContent(url);
viewModelNode.Content.SerializeFlags = ViewModelContentSerializeFlags.Serialize;
viewModelNode.Children.Add(new ViewModelNode("SetAsSearchFilter", new RootViewModelContent((ExecuteCommand)((viewModel2, parameter) =>
{
searchRoot = url;
StartSearch();
}))));
if (url.EndsWith("/"))
{
viewModelNode.Children.Add(new ViewModelNode("Folders", new EnumerableViewModelContent<ViewModelReference>(() =>
fileTracker.Files
.Where(file => file.StartsWith(url))
.GroupBy(file =>
{
var separatorIndex = file.IndexOf('/', url.Length + 1);
return file.Substring(url.Length, separatorIndex != -1 ? separatorIndex - url.Length + 1 : file.Length - url.Length);
})
.Where(x => x.Key.EndsWith("/") || x.Key.EndsWith(".dat") || x.Key.EndsWith(".xksl"))
.Select(x => new ViewModelReference(KeyValuePair.Create(UrlType.FileTracker, url + x.Key), this))
)));
}
}
handled = true;
}
}
public static string FormatDocumentLinks (IEnumerable<IDocument> documents, ViewModelContext context, string itemTemplate, string listTemplateOne, string listTemplateMany, string microdata, DocumentGroupPlacement groupPlacement, GetDocumentTitle getDocumentTitle = null)
{
var markupBuilder = new StringBuilder ();
var count = 0;
foreach (var document in documents) {
var linkMarkup = document.FormatDocumentLink_WithMicrodata (
(getDocumentTitle == null)? document.Title : getDocumentTitle (document),
Localization.GetString ("LinkOpen.Text", context.LocalResourceFile),
true,
groupPlacement,
context.Module.TabId,
context.Module.ModuleId,
microdata,
HttpContext.Current.Timestamp
);
if (!string.IsNullOrEmpty (linkMarkup)) {
markupBuilder.Append (string.Format (itemTemplate, linkMarkup));
count++;
}
}
var markup = markupBuilder.ToString ();
if (!string.IsNullOrEmpty (markup)) {
return string.Format ((count == 1)? listTemplateOne : listTemplateMany, markup);
}
return string.Empty;
}
public EduProgramProfileObrnadzorEduFormsViewModel (IEduProgramProfile model, ViewModelContext context, ViewModelIndexer indexer)
{
Model = model;
Context = context;
Index = indexer.GetNextIndex ();
}
public static List<DocumentTypeViewModel> GetBindableList (IEnumerable<DocumentTypeInfo> documentTypes,
ViewModelContext context)
{
return documentTypes.Select (dt => new DocumentTypeViewModel (dt, context)).ToList ();
}
public EmployeeListViewModel SetContext (ViewModelContext<EmployeeListSettings> context)
{
Context = context;
return this;
}
public EduProgramStandardObrnadzorViewModel (IEduProgram model, ViewModelContext context, IIndexer indexer)
: base (model)
{
Context = context;
Indexer = indexer;
}
/// <summary>
/// Display components that are tagged with the <see cref="DisplayAttribute"/>.
/// </summary>
/// <param name="context">Context of the view model.</param>
/// <param name="viewModel">The current view model</param>
/// <param name="component">The entity component to display</param>
private void AutoDisplayComponent(ViewModelContext context, IViewModelNode viewModel, EntityComponent component)
{
var displayComp = DisplayAttribute.GetDisplay(component.GetType());
if (displayComp == null)
return;
var componentViewModel = viewModel.GetChildrenByName("Component");
if (componentViewModel == null)
return;
// Change the name of the component being displayed
if (!string.IsNullOrEmpty(displayComp.Name))
{
var componentName = viewModel.GetChildrenByName("PropertyKeyName");
if (componentName != null)
{
componentName.Value = displayComp.Name;
}
}
var propertyToDisplay = new List<Tuple<DisplayAttribute, ViewModelNode>>();
var memberInfos = new List<MemberInfo>();
memberInfos.AddRange(component.GetType().GetProperties());
memberInfos.AddRange(component.GetType().GetFields());
// Process fields and properties
foreach (var property in memberInfos)
{
var display = DisplayAttribute.GetDisplay(property);
if (display == null) continue;
IViewModelContent modelContent = null;
object modelValue = null;
var propertyInfo = property as PropertyInfo;
if (propertyInfo != null)
{
if (typeof(ParameterCollection).IsAssignableFrom(propertyInfo.PropertyType))
{
modelValue = propertyInfo.GetValue(component, null);
}
else
{
modelContent = new PropertyInfoViewModelContent(new ParentNodeValueViewModelContent(), propertyInfo);
}
}
var fieldInfo = property as FieldInfo;
if (fieldInfo != null)
{
if (typeof(ParameterCollection).IsAssignableFrom(fieldInfo.FieldType))
{
modelValue = fieldInfo.GetValue(component);
}
else
{
modelContent = new FieldInfoViewModelContent(new ParentNodeValueViewModelContent(), fieldInfo);
}
}
var propertyViewModel = modelValue != null ? new ViewModelNode(display.Name ?? property.Name, modelValue) : new ViewModelNode(display.Name ?? property.Name, modelContent);
propertyViewModel.GenerateChildren(context);
propertyToDisplay.Add(new Tuple<DisplayAttribute, ViewModelNode>(display, propertyViewModel));
}
foreach(var item in propertyToDisplay.OrderBy((left) => left.Item1.Order))
{
componentViewModel.Children.Add(item.Item2);
}
}
public void GenerateChildren(ViewModelContext context, IViewModelNode viewModelNode, ref bool handled)
{
throw new NotImplementedException();
}
public EduProgramProfileDirectoryEduFormsViewModel SetContext (ViewModelContext context)
{
Context = context;
return this;
}
public EduProgramModuleViewModel SetContext (ViewModelContext context)
{
Context = context;
return this;
}
public EmployeeDirectoryTeachersViewModel SetContext (ViewModelContext context)
{
Context = context;
return this;
}
public DocumentTypeViewModel (IDocumentType documentType, ViewModelContext context)
{
CopyCstor.Copy<IDocumentType> (documentType, this);
Context = context;
}
public void GenerateChildren(ViewModelContext context, IViewModelNode viewModelNode, ref bool handled)
{
bool handleValueType = false;
if (viewModelNode.NodeValue is MicroThread)
{
var microThread = (MicroThread)viewModelNode.NodeValue;
var script = microThread.Get(ScriptManager.ScriptProperty);
viewModelNode.Content = new EnumerableViewModelContent<ViewModelReference>(() => new[] { new ViewModelReference(script, true) });
handled = true;
}
else if (viewModelNode.NodeValue is IScript)
{
var script = (IScript)viewModelNode.NodeValue;
// Expose all variables of IScript (defined by user)
foreach (var property in script.GetType().GetProperties())
{
if (property.PropertyType != typeof(int) && property.PropertyType != typeof(float))
continue;
viewModelNode.Children.Add(new ViewModelNode(property.Name, new PropertyInfoViewModelContent(new ParentNodeValueViewModelContent(), property)));
}
handled = true;
}
else if (viewModelNode.NodeValue is Entity)
{
ViewModelNode componentsViewModelNode;
viewModelNode.Children.Add(new ViewModelNode("Name", new PropertyInfoViewModelContent(new ParentNodeValueViewModelContent(), typeof(Entity).GetProperty("Name"))));
viewModelNode.Children.Add(new ViewModelNode("Guid", new PropertyInfoViewModelContent(new ParentNodeValueViewModelContent(), typeof(Entity).GetProperty("Guid"))));
viewModelNode.Children.Add(componentsViewModelNode = new ViewModelNode("Components", EnumerableViewModelContent.FromUnaryLambda<ViewModelReference, Entity>(new ParentNodeValueViewModelContent(),
(entity) => entity.Properties
.Select(x => x.Value)
.OfType<EntityComponent>()
.Select(x => new ViewModelReference(x, true)))));
var availableKeysContent = new RootViewModelContent(null, typeof(string[]));
componentsViewModelNode.Children.Add(new ViewModelNode("AvailableKeys", availableKeysContent));
componentsViewModelNode.Children.Add(new ViewModelNode("RequestKeys", new RootViewModelContent((ExecuteCommand)((viewModel2, parameter) =>
{
var availableComponentKeys = new List<string>();
// TODO: Improve component keys enumeration (maybe need a registry?)
// For now, scan assemblies for all types inheriting from EntityComponent
foreach (var assembly in AppDomain.CurrentDomain.GetAssemblies())
{
foreach (var type in assembly.GetTypes())
{
if (type.IsSubclassOf(typeof(EntityComponent))
&& type.GetField("Key", BindingFlags.Public | BindingFlags.Static | BindingFlags.FlattenHierarchy) != null)
{
availableComponentKeys.Add(type.AssemblyQualifiedName);
}
}
}
availableKeysContent.Value = availableComponentKeys.ToArray();
}))));
componentsViewModelNode.Children.Add(new ViewModelNode("Add", new RootViewModelContent((ExecuteCommand)((viewModel2, parameter) =>
{
var entity = (Entity)viewModel2.Parent.Parent.NodeValue;
var componentType = Type.GetType((string)parameter);
// For now, assume it will be stored in a PropertyKey inside the actual component named "Key"
var componentKeyField = componentType.GetField("Key", BindingFlags.Public | BindingFlags.Static | BindingFlags.FlattenHierarchy);
entity.SetObject((PropertyKey)componentKeyField.GetValue(null), Activator.CreateInstance(componentType));
}))));
handled = true;
}
else if (viewModelNode.NodeValue is EntityComponent)
{
viewModelNode.PropertyName = "EntityComponent";
var component = (EntityComponent)viewModelNode.NodeValue;
// Would be better higher in the hierarchy, but it would complicate model
var propertyKey = component.Entity.Properties.First(x => x.Value == component).Key;
var propertyKeyName = propertyKey.OwnerType.Name;
viewModelNode.Children.Add(new ViewModelNode("PropertyKeyName", new RootViewModelContent(propertyKeyName)));
viewModelNode.Children.Add(new ViewModelNode("Remove", new RootViewModelContent((ExecuteCommand)((viewModel2, parameter) =>
{
component.Entity.SetObject(propertyKey, null);
}))));
var componentViewModel = new ViewModelNode("Component", component);
viewModelNode.Children.Add(componentViewModel);
if (component is TransformationComponent)
{
componentViewModel.Children.Add(new ViewModelNode("WorldMatrix", new FieldInfoViewModelContent(new ParentNodeValueViewModelContent(), typeof(TransformationComponent).GetField("WorldMatrix"))).GenerateChildren(context));
// TODO: How to switch view model depending on TransformationComponent.Values type? Or should we always expose everything?
componentViewModel.Children.Add(new ViewModelNode("LocalMatrix", new FieldInfoViewModelContent(new PropertyInfoViewModelContent(new ParentNodeValueViewModelContent(), typeof(TransformationComponent).GetProperty("Value")), typeof(TransformationValue).GetField("LocalMatrix"))).GenerateChildren(context));
//if (((TransformationComponent)component).Values is TransformationTRS)
{
componentViewModel.Children.Add(new ViewModelNode("Translation", new FieldInfoViewModelContent(new PropertyInfoViewModelContent(new ParentNodeValueViewModelContent(), typeof(TransformationComponent).GetProperty("Value")), typeof(TransformationTRS).GetField("Translation"))).GenerateChildren(context));
componentViewModel.Children.Add(new ViewModelNode("Rotation", new FieldInfoViewModelContent(new PropertyInfoViewModelContent(new ParentNodeValueViewModelContent(), typeof(TransformationComponent).GetProperty("Value")), typeof(TransformationTRS).GetField("Rotation"))).GenerateChildren(context));
componentViewModel.Children.Add(new ViewModelNode("Scaling", new FieldInfoViewModelContent(new PropertyInfoViewModelContent(new ParentNodeValueViewModelContent(), typeof(TransformationComponent).GetProperty("Value")), typeof(TransformationTRS).GetField("Scaling"))).GenerateChildren(context));
}
componentViewModel.Children.Add(new ViewModelNode("Parent", LambdaViewModelContent<ViewModelReference>.FromOperand<EntityComponent>(new ParentNodeValueViewModelContent(), x => new ViewModelReference(x.Entity, false))));
componentViewModel.Children.Last().Children.Add(new ViewModelNode("SetAsRoot", new RootViewModelContent((ExecuteCommand)((viewModel2, parameter) =>
{
context.ViewModelByGuid.Clear();
context.Root = context.GetModelView(((TransformationComponent)component).Parent.Entity).Children.First(x => x.PropertyName == "Components");
}))));
}
if (component is ModelComponent)
{
componentViewModel.Children.Add(new ViewModelNode("Parameters", ((ModelComponent)component).MeshParameters).GenerateChildren(context));
//componentViewModel.Children.Add(new ViewModelNode(
// "MeshParameters",
// EnumerableViewModelContent.FromUnaryLambda<ViewModelReference, ModelComponent>(
// new ParentNodeValueViewModelContent(),
// (ModelComponent) => ModelComponent.MeshParameters.Keys.Select(key => new ViewModelReference(Tuple.Create(ModelComponent.MeshParameters, key), true)))));
}
if (component is LightComponent)
{
componentViewModel.Children.Add(new ViewModelNode("Type", new PropertyInfoViewModelContent(new ParentNodeValueViewModelContent(), typeof(LightComponent).GetProperty("Type"))).GenerateChildren(context));
componentViewModel.Children.Add(new ViewModelNode("ShadowMap", new PropertyInfoViewModelContent(new ParentNodeValueViewModelContent(), typeof(LightComponent).GetProperty("ShadowMap"))).GenerateChildren(context));
componentViewModel.Children.Add(new ViewModelNode("Deferred", new PropertyInfoViewModelContent(new ParentNodeValueViewModelContent(), typeof(LightComponent).GetProperty("Deferred"))).GenerateChildren(context));
componentViewModel.Children.Add(new ViewModelNode("Intensity", new PropertyInfoViewModelContent(new ParentNodeValueViewModelContent(), typeof(LightComponent).GetProperty("Intensity"))).GenerateChildren(context));
componentViewModel.Children.Add(new ViewModelNode("DecayStart", new PropertyInfoViewModelContent(new ParentNodeValueViewModelContent(), typeof(LightComponent).GetProperty("DecayStart"))).GenerateChildren(context));
componentViewModel.Children.Add(new ViewModelNode("Color", new PropertyInfoViewModelContent(new ParentNodeValueViewModelContent(), typeof(LightComponent).GetProperty("Color"))).GenerateChildren(context));
componentViewModel.Children.Add(new ViewModelNode("LightDirection", new PropertyInfoViewModelContent(new ParentNodeValueViewModelContent(), typeof(LightComponent).GetProperty("LightDirection"))).GenerateChildren(context));
}
if (component is LightShaftsComponent)
{
componentViewModel.Children.Add(new ViewModelNode("Color", new PropertyInfoViewModelContent(new ParentNodeValueViewModelContent(), typeof(LightShaftsComponent).GetProperty("Color"))).GenerateChildren(context));
//componentViewModel.Children.Add(new ViewModelNode("LightShaftsBoundingBoxes", new PropertyInfoViewModelContent(new ParentNodeValueViewModelContent(), typeof(LightShaftsComponent).GetProperty("LightShaftsBoundingBoxes"))).GenerateChildren(context));
}
// Else try to display it using auto-display
AutoDisplayComponent(context, viewModelNode, component);
handled = true;
}
else if (viewModelNode.NodeValue is ParameterCollection)
{
viewModelNode.Content = EnumerableViewModelContent.FromUnaryLambda<ViewModelReference, ParameterCollection>(new NodeValueViewModelContent(), (parameterCollection) =>
parameterCollection.Keys.Where(key => key.PropertyType.IsValueType).Select(key =>
{
if (key.PropertyType.IsValueType)
{
// For value type, generated tree won't change so make value based on key only.
return new ViewModelReference(Tuple.Create(parameterCollection, key), true);
}
else
{
// TODO: resources currently ignored (until fixed)
// For reference type, make value dependent on actual value reference and source.
// This will trigger a regeneration for reference change (i.e. new texture bound).
// Useful since asset type/state might be different.
var value = parameterCollection.GetObject(key);
var valueSource = engineContext.AssetManager.Url.Get(value);
return new ViewModelReference(Tuple.Create(parameterCollection, key, valueSource), true);
}
}));
var availableKeysContent = new RootViewModelContent(null, typeof(string[]));
viewModelNode.Children.Add(new ViewModelNode("AvailableKeys", availableKeysContent));
viewModelNode.Children.Add(new ViewModelNode("RequestKeys", new RootViewModelContent((ExecuteCommand)((viewModel2, parameter) =>
{
var parameterCollection = (ParameterCollection)viewModel2.Parent.NodeValue;
var effectMesh = viewModel2.Parent.Parent.NodeValue as EffectMesh;
if (effectMesh != null)
{
var availableKeys = effectMesh.Effect.Passes.SelectMany(x => x.DefaultParameters.Parameters.Select(y => y.Key)).Distinct().Where(x => !parameterCollection.IsValueOwner(x)).Select(x => x.Name).ToArray();
availableKeysContent.Value = availableKeys;
}
}))));
viewModelNode.Children.Add(new ViewModelNode("Add", new RootViewModelContent((ExecuteCommand)((viewModel2, parameter) =>
{
var effectMesh = viewModel2.Parent.Parent.NodeValue as EffectMesh;
if (effectMesh != null)
{
var key = effectMesh.Effect.Passes.SelectMany(x => x.DefaultParameters.Parameters.Select(y => y.Key)).FirstOrDefault(x => x.Name == (string)parameter);
if (key != null)
{
effectMesh.Parameters.SetDefault(key);
}
}
}))));
}
else if (viewModelNode.NodeValue is EffectMesh)
{
viewModelNode.PropertyName = "Mesh";
viewModelNode.Children.Add(new ViewModelNode("Effect", LambdaViewModelContent<string>.FromParent<EffectMesh>(x => x.EffectMeshData.EffectData.Name, (x, effectName) => x.EffectMeshData.EffectData.Name = effectName)));
viewModelNode.Children.Add(new ViewModelNode("Parameters", ((EffectMesh)viewModelNode.NodeValue).Parameters).GenerateChildren(context));
//viewModelNode.Children.Add(new ViewModelNode("MeshData", LambdaViewModelContent<ViewModelReference>.FromParent<MeshData>(effectMeshData => new ViewModelReference(effectMeshData.MeshData, true))));
handled = true;
}
else if (viewModelNode.NodeValue is ContentData || typeof(ContentData).IsAssignableFrom(viewModelNode.Type))
{
if (viewModelNode.NodeValue is ContentData)
viewModelNode.Content = new NodeValueViewModelContent();
if (viewModelNode.Value != null)
{
viewModelNode.Children.Add(new ViewModelNode("Url", new LambdaViewModelContent<string>(new ParentValueViewModelContent(),
x => engineContext.AssetManager.Url.Get((x.Value)),
(x, y) =>
{
var nodeValue = x.OwnerNode.Parent.NodeValue;
})));
viewModelNode.Children.Add(new ViewModelNode("ChangeUrl", new RootViewModelContent((ExecuteCommand)(async (viewModel2, parameter) =>
{
var dropParameters = (DropCommandParameters)parameter;
var parameterInfo = (Tuple<ParameterCollection, ParameterKey, ContentData>)viewModel2.Parent.Parent.NodeValue;
var parameterCollection = parameterInfo.Item1;
var textureData = await engineContext.AssetManager.LoadAsync<Image>((string)dropParameters.Data);
//parameter.Item1.SetObject(parameter.Item2, );
//parameterCollection.Remove(parameterInfo.Item2);
//var texture = engineContext.ContentManager.Convert<ITexture, Image>(textureData);
Texture texture;
throw new NotImplementedException();
parameterCollection.SetObject(parameterInfo.Item2, texture);
}))));
if (viewModelNode.Type == typeof(Image))
{
Image thumbnail = null;
Task<Image> textureData = null;
viewModelNode.Children.Add(new ViewModelNode("Thumbnail", new LambdaViewModelContent<Image>(new ParentValueViewModelContent(), (viewModelContent) =>
{
if (textureData == null)
{
var textureDataNew = viewModelContent.Value as Image;
if (engineContext.AssetManager.Url.Get(textureDataNew) != null)
{
textureData = engineContext.AssetManager.LoadAsync<Image>(engineContext.AssetManager.Url.Get(textureDataNew));
textureData.ContinueWith(task =>
{
thumbnail = task.Result;
viewModelContent.OwnerNode.Content.SerializeFlags |= ViewModelContentSerializeFlags.Static;
});
}
}
return thumbnail;
})));
}
}
handled = true;
}
else if (viewModelNode.NodeValue is MeshData)
{
handled = true;
}
else if (viewModelNode.NodeValue is Tuple<ParameterCollection, ParameterKey, ContentData>)
{
var value = (Tuple<ParameterCollection, ParameterKey, ContentData>)viewModelNode.NodeValue;
// Ignore namespace and class name for key name
viewModelNode.PropertyName = value.Item2.Name;
if (viewModelNode.PropertyName.Contains('.'))
viewModelNode.PropertyName = viewModelNode.PropertyName.Substring(viewModelNode.PropertyName.LastIndexOf('.') + 1);
viewModelNode.Content = new NullViewModelContent(typeof(Image));
if (value.Item3 != null)
viewModelNode.Children.Add(new ViewModelNode("ObjectRef", new RootViewModelContent(value.Item3) { SerializeFlags = ViewModelContentSerializeFlags.None }).GenerateChildren(context));
handled = true;
}
else if (viewModelNode.NodeValue is Tuple<ParameterCollection, ParameterKey>)
{
var value = (Tuple<ParameterCollection, ParameterKey>)viewModelNode.NodeValue;
// Ignore namespace and class name for key name
viewModelNode.PropertyName = value.Item2.Name;
if (viewModelNode.PropertyName.Contains('.'))
viewModelNode.PropertyName = viewModelNode.PropertyName.Substring(viewModelNode.PropertyName.LastIndexOf('.') + 1);
if (value.Item2.PropertyType.IsValueType)
{
viewModelNode.Content =
new LambdaViewModelContent<object>(() => value.Item1.GetObject(value.Item2), newValue => value.Item1.SetObject(value.Item2, newValue))
{
Type = value.Item2.PropertyType
};
handleValueType = true;
}
handled = true;
}
else if (viewModelNode.Type == typeof(Matrix) || viewModelNode.Type == typeof(Vector3) || viewModelNode.Type == typeof(Color))
{
handled = true;
}
else if (viewModelNode.Type.IsValueType)
{
handleValueType = true;
}
if (handleValueType)
{
if (!(viewModelNode.Type == typeof(Matrix) || viewModelNode.Type == typeof(Vector3) || viewModelNode.Type == typeof(Color) || viewModelNode.Type == typeof(Color3)))
{
if (viewModelNode.Type.IsValueType && !viewModelNode.Type.IsPrimitive && !viewModelNode.Type.IsEnum)
{
viewModelNode.Content.SerializeFlags = ViewModelContentSerializeFlags.None;
// Use default for those types
foreach (var fieldinfo in viewModelNode.Type.GetFields(BindingFlags.FlattenHierarchy | BindingFlags.Public | BindingFlags.Instance))
{
IViewModelContent viewModelContent = new FieldInfoViewModelContent(new ParentValueViewModelContent(viewModelNode.Type), fieldinfo);
//if (fieldinfo.FieldType.IsValueType && !fieldinfo.FieldType.IsPrimitive && !fieldinfo.FieldType.IsEnum)
// viewModelContent.Flags = ViewModelFlags.None;
// Doesn't support array
if (fieldinfo.FieldType.IsArray)
continue;
viewModelNode.Children.Add(new ViewModelNode(fieldinfo.Name, viewModelContent).GenerateChildren(context));
}
handled = true;
}
}
}
}
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 }));
}
}
public EduFormViewModel (IEduForm eduForm, ViewModelContext context)
{
CopyCstor.Copy<IEduForm> (eduForm, this);
Context = context;
}
public EffectEnumerator(ViewModelContext selectedEntitiesContext)
{
this.selectedEntitiesContext = selectedEntitiesContext;
}
