public ApprTypesViewModel(IRootModel deserializedContents, IViewModelNavigator viewModelNavigator,
IList <IContentViewModel> viewModelsICanNavigateTo, string level1ID)
{
var deserializedContents1 = deserializedContents as PAVContent;
_level1ID = level1ID;
_viewModelNavigator = viewModelNavigator;
_viewModelsICanNavigateTo = viewModelsICanNavigateTo;
// Find and grab the relevant "ID" fields from the Models as these will be used for the buttons' text
if (deserializedContents1 != null)
{
var phaseVoltages = (from a in deserializedContents1.ApprPhaseVoltages
where string.Compare(a.ID, _level1ID, StringComparison.CurrentCultureIgnoreCase) == 0
from b in a.ApprTypes
select b).ToList();
foreach (var phaseVoltage in phaseVoltages)
{
_buttonTextsParentIDs.Add(phaseVoltage.ID);
}
_parentIDsCount = phaseVoltages.Count;
}
else
{
throw new ArgumentNullException("deserializedContents", String.Format("{0} is referencing null deserialized contents", GetType()));
}
Title = _level1ID;
}
public CategoriesViewModel(IRootModel deserializedContents, string level1ID)
{
var deserializedContents1 = deserializedContents as MADContent;
_level1ID = level1ID;
// Find and grab the relevant "ID" fields from the Models as these will be used for the buttons' text
// Also find and grab relevant "Data" fields from the Models as these will be used for the popup displays
if (deserializedContents1 != null)
{
var MADPhaseVoltages = (from a in deserializedContents1.Categories
where string.Compare(a.ID, _level1ID, StringComparison.CurrentCultureIgnoreCase) == 0
from b in a.MADPhaseVoltages
select b).ToList();
foreach (var MADPhaseVoltage in MADPhaseVoltages)
{
_buttonTextsChildIDs.Add(MADPhaseVoltage.ID);
_buttonTextsChildData.Add(MADPhaseVoltage.Data);
}
_childIDsCount = MADPhaseVoltages.Count;
}
else
{
throw new ArgumentNullException("deserializedContents", String.Format("{0} is referencing null deserialized contents", GetType()));
}
Title = "Phase Voltage";
}
public MeasurementsViewModel(IRootModel deserializedContents, string level1ID, string level2ID)
{
var deserializedContents1 = deserializedContents as CondContent;
_level1ID = level1ID;
_level2ID = level2ID;
// Find and grab the relevant "ID" fields from the Models as these will be used for the buttons' text
// Also find and grab relevant "Data" fields from the Models as these will be used for the popup displays
if (deserializedContents1 != null)
{
var measurements = (from a in deserializedContents1.Conductors
where string.Compare(a.ID, _level1ID, StringComparison.CurrentCultureIgnoreCase) == 0
from b in a.Names
where string.Compare(b.ID, _level2ID, StringComparison.CurrentCultureIgnoreCase) == 0
from c in b.Measurements
select c).ToList();
foreach (var measurement in measurements)
{
_buttonTextsChildIDs.Add(measurement.ID);
_buttonTextsChildData.Add(measurement.Data);
}
_childIDsCount = measurements.Count;
}
else
{
throw new ArgumentNullException("deserializedContents", String.Format("{0} is referencing null deserialized contents", GetType()));
}
Title = _level2ID;
}
static void Main(string[] args)
{
try
{
var tester = new ClientTester();
IRootModel result = null;
switch (args[0])
{
case "-n":
case "--normal":
result = tester.Run(false).Result;
break;
case "-w":
case "--with-converter":
result = tester.Run(true).Result;
break;
default:
throw new ArgumentException("Please use either -n or -c parameter");
}
Console.WriteLine($"Test finished, result: {result.SubModel.ResultNumber}, press any key to close");
Console.ReadLine();
}
catch (Exception e)
{
Console.WriteLine(e);
}
}
public void CreateNewPage(IRootModel model, ControlType ctlType)
{
if (model is null)
{
return;
}
_ = ModelPageService.Current.CreateNewPageAsync(model, ctlType);
}
public async Task <IRootModel> Calculate(IRootModel model)
{
model.SubModel.ResultNumber = model.SubModel.SampleNumber1 + model.SubModel.SampleNumber2;
// Simulate async operation
await Task.Delay(500);
return(model);
}
public async Task <IRootModel> CalculateWithConverter(RootModelWithConverter model)
{
_logger.LogWarning("Starting calculation of {id}", model.Id);
IRootModel result = await _calculator.Calculate(model);
_logger.LogWarning("Finished calculation of {id}", model.Id);
return(result);
}
public ModelGraphControl(IRootModel model)
{
Model = model ?? throw new ArgumentNullException(nameof(model));
_root = model.DataRoot;
_graph = model.RootItem as Graph;
_selector = new Selector(_graph);
InitializeComponent();
InitializeControlPanel();
}
public void CloseModel()
{
if (IModel is null)
{
return;
}
IModel = null;
var task = Dispatcher.RunAsync(CoreDispatcherPriority.Low, () =>
{
_window.Close();
});
}
public static void Load(this IRootModel @this, ICodeTextWriter writer, SourceBuilder builder, INamedTypeSymbol @interface, ScopeInfo scope, IEnumerable <IMemberInfo> references)
{
{
SourceBuilder builder2 = builder.AppendNewBuilder(false);
writer.WriteTypeReference(builder2, @interface, scope);
@this.Interface = builder2.ToString();
}
@this.References.AddRange(references.Select(delegate(IMemberInfo member)
{
SourceBuilder builder2 = builder.AppendNewBuilder(false);
writer.WriteIdentifier(builder2, member.Member);
return(builder2.ToString());
}));
}
public void CloseRelatedModels(IRootModel model)
{
var views = SecondaryViews.ToArray();
foreach (var view in views)
{
var m = view.IModel;
if (m is null)
{
continue;
}
if (m.DataRoot != m.DataRoot)
{
continue;
}
view.CloseModel();
}
}
//
#region RemoveModelPage ==============================================
public void RemoveModelPage(IRootModel model)
{
var item = navigationView.MenuItems
.OfType <WinUI.NavigationViewItem>()
.FirstOrDefault(menuItem => (menuItem.Tag == model));
if (item is null)
{
return;
}
navigationView.MenuItems.Remove(item);
var home = navigationView.MenuItems
.OfType <WinUI.NavigationViewItem>()
.FirstOrDefault(menuItem => (menuItem.Name == "Home"));
if (!(home is null))
{
home.IsSelected = true;
NavigationService.Navigate(typeof(MainPage));
}
}
public MADViewModel(IRootModel deserializedContents, IViewModelNavigator viewModelNavigator,
IList <IContentViewModel> viewModelsICanNavigateTo)
{
_deserializedContents = deserializedContents as MADContent;
_viewModelNavigator = viewModelNavigator;
_viewModelsICanNavigateTo = viewModelsICanNavigateTo;
// Find and grab the relevant "ID" fields from the Models as these will be used for the buttons' text
if (_deserializedContents != null)
{
foreach (var category in _deserializedContents.Categories)
{
_buttonTextsParentIDs.Add(category.ID);
}
}
else
{
throw new ArgumentNullException("deserializedContents", String.Format("{0} is referencing null deserialized contents", GetType()));
}
Title = "Category";
}
public async Task <IRootModel> Run(bool withConverter)
{
if (withConverter)
{
using (var client = new CalculateClient <RootModelWithConverter>(new Uri("http://localhost:5000"), new LoggerFactory()))
{
await client.ConnectAsync();
var model = new RootModelWithConverter {
Id = 1, SubModel = new SubModel {
Id = 2, Name = "Test", SampleNumber1 = 14, SampleNumber2 = 234
}
};
IRootModel result = await client.CalculateWithConverter(model);
return(result);
}
}
else
{
using (var client = new CalculateClient <RootModel>(new Uri("http://localhost:5000"), new LoggerFactory()))
{
await client.ConnectAsync();
var model = new RootModel {
Id = 3, SubModel = new SubModel {
Id = 4, Name = "Test", SampleNumber1 = 564, SampleNumber2 = 464
}
};
IRootModel result = await client.Calculate(model);
return(result);
}
}
}
public WLLViewModel(IRootModel deserializedContents)
{
_deserializedContents = deserializedContents as WLLContent;
// Find and grab the relevant "ID" fields from the Models as these will be used for the buttons' text
// Also find and grab relevant "Data" fields from the Models as these will be used for the popup displays
if (_deserializedContents != null)
{
foreach (var item in _deserializedContents.Items)
{
_buttonTextsChildIDs.Add(item.ID);
_buttonTextsChildData.Add(item.Data);
}
_childIDsCount = _deserializedContents.Items.Count;
}
else
{
throw new ArgumentNullException("deserializedContents", String.Format("{0} is referencing null deserialized contents", GetType()));
}
Title = "Item";
}
//
#region InsertModelPage ==============================================
public void InsertModelPage(IRootModel model)
{
if (model is null)
{
return;
}
model.DataRoot.SetLocalizer(Helpers.ResourceExtensions.CoreLocalizer());
var item = navigationView.MenuItems
.OfType <WinUI.NavigationViewItem>()
.FirstOrDefault(menuItem => (menuItem.Name == "Home"));
if (item is null)
{
return;
}
var index = navigationView.MenuItems.IndexOf(item) + 2;
var navItem = new WinUI.NavigationViewItem
{
Content = model.TitleName,
Icon = new SymbolIcon(Symbol.AllApps),
Tag = model
};
ToolTipService.SetToolTip(navItem, model.TitleSummary);
navItem.Loaded += NavItem_Loaded;
navigationView.MenuItems.Insert(index, navItem);
//navigationView.SelectedItem = navItem;
//Selected = navItem;
NavigationService.Navigate(typeof(ModelPage), model);
}
public async Task <TResult> CalculateWithConverter(IRootModel model)
{
return(await _connection.Invoke <TResult>("CalculateWithConverter", model));
}
private async Task <ViewLifetimeControl> CreateViewLifetimeControlAsync(string windowTitle, Type pageType, IRootModel model = null)
{
ViewLifetimeControl viewControl = null;
await CoreApplication.CreateNewView().Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
viewControl = ViewLifetimeControl.CreateForCurrentView();
viewControl.Title = windowTitle;
viewControl.IModel = model;
viewControl.StartViewInUse();
var frame = new Frame
{
RequestedTheme = ThemeSelectorService.Theme
};
frame.Navigate(pageType, viewControl);
Window.Current.Content = frame;
Window.Current.Activate();
ApplicationView.GetForCurrentView().Title = viewControl.Title;
});
return(viewControl);
}
public SymbolEditControl(IRootModel model)
{
if (model is null || model.RootItem is null || !(model.RootItem is SymbolX))
{
_isScratchPad = true;
}
//public async Task<bool> Dispatch(UIRequestOld rq, IModelPageControl ctrl)
//{
// if (rq is null || ctrl is null) return false;
// switch (rq.RequestType)
// {
// case RequestType.Apply:
// await ctrl.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () => { ctrl.Apply(); });
// return true;
// case RequestType.Revert:
// await ctrl.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () => { ctrl.Revert(); });
// return true;
// case RequestType.Save:
// await ctrl.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () => { ctrl.IModel.Chef.Repository.SaveAsync(ctrl.IModel.Chef); });
// return true;
// case RequestType.SaveAs:
// await ctrl.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () => { ctrl.IModel.Chef.Repository.SaveAS(ctrl.IModel.Chef); });
// return true;
// case RequestType.Refresh:
// await ctrl.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () => { ctrl.Refresh(); });
// return true;
// case RequestType.Reload:
// await ctrl.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () => { _ = ReloadModelAsync(ctrl); });
// return true;
// case RequestType.Close:
// await ctrl.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () => { RemoveModelPage(ctrl.IModel); WindowManagerService.Current.CloseRelatedModels(ctrl.IModel); ctrl.Release(); });
// return true;
// case RequestType.CreateView:
// await ctrl.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () => InsertModelPage(new IModel(rq)));
// return true;
// case RequestType.CreatePage:
// var rootModel = new IModel(rq);
// var viewLifetimeControl = await WindowManagerService.Current.TryShowAsStandaloneAsync(rootModel.TitleName, typeof(ModelPage), rootModel).ConfigureAwait(true);
// viewLifetimeControl.Released += ViewLifetimeControl_Released;
// return true;
// }
// GC.Collect();
// return false;
//}
internal async Task CreateNewPageAsync(IRootModel model, ControlType ctlType)
{
var viewLifetimeControl = await WindowManagerService.Current.TryShowAsStandaloneAsync(model.TitleName, typeof(ModelPage), model).ConfigureAwait(true);
viewLifetimeControl.Released += ViewLifetimeControl_Released;
}
public async Task <ViewLifetimeControl> TryShowAsStandaloneAsync(string windowTitle, Type pageType, IRootModel model)
{
ViewLifetimeControl viewControl = await CreateViewLifetimeControlAsync(windowTitle, pageType, model);
SecondaryViews.Add(viewControl);
viewControl.StartViewInUse();
var viewShown = await ApplicationViewSwitcher.TryShowAsStandaloneAsync(viewControl.Id, ViewSizePreference.Default, ApplicationView.GetForCurrentView().Id, ViewSizePreference.Default);
viewControl.StopViewInUse();
return(viewControl);
}
