private Result ProcessConfigurationItem(
Result <Action <ILocalAndDeviceValueContainingViewModel, ILocalAndDeviceValueContainingViewModel> > callback,
IConfigurationItemViewModel configurationItemViewModel1,
IConfigurationItemViewModel configurationItemViewModel2)
{
if (configurationItemViewModel1 is RuntimePropertyViewModel propertyViewModel1 &&
configurationItemViewModel2 is RuntimePropertyViewModel propertyViewModel2)
{
callback.OnSuccess(func => func(propertyViewModel1, propertyViewModel2));
}
if (configurationItemViewModel1 is IItemGroupViewModel itemGroupViewModel1 &&
configurationItemViewModel2 is IItemGroupViewModel itemGroupViewModel2)
{
var count = itemGroupViewModel1.ChildStructItemViewModels.Count;
if (count != itemGroupViewModel2.ChildStructItemViewModels.Count)
{
return(Result.Create(false));
}
for (int i = 0; i < count; i++)
{
var res = ProcessConfigurationItem(callback, itemGroupViewModel1.ChildStructItemViewModels[i],
itemGroupViewModel2.ChildStructItemViewModels[i]);
if (!res.IsSuccess)
{
return(res);
}
}
}
return(Result.Create(true));
}
private void AddTreeGridItem(ObservableCollection <IConfigurationItemViewModel> treeGridItems,
IConfigurationItemViewModel newConfigurationItem,
IConfigurationItemViewModel oldConfigurationItem, int index)
{
newConfigurationItem.Level = oldConfigurationItem.Level + 1;
treeGridItems.Insert(index, newConfigurationItem);
}
public bool SetElement(IConfigurationItemViewModel element, bool isUp)
{
if (ChildStructItemViewModels.Contains(element))
{
int moveIndexFrom = ChildStructItemViewModels.IndexOf(element as IEditorConfigurationItemViewModel);
int moveIndexTo;
bool valid = false;
if (isUp)
{
moveIndexTo = moveIndexFrom - 1;
valid = (moveIndexTo >= 0) && (moveIndexFrom > 0);
}
else
{
moveIndexTo = moveIndexFrom + 1;
valid = moveIndexFrom < ChildStructItemViewModels.Count - 1;
}
if (valid)
{
element.Checked?.Invoke(false);
ChildStructItemViewModels.Move(moveIndexFrom, moveIndexTo);
//}
this.Checked?.Invoke(false);
this.Checked?.Invoke(true);
return(true);
}
else
{
throw new Exception("invalid data input");
}
}
return(false);
}
public Maybe <List <TagBuilder> > RenderHtmlFromItem(IConfigurationItemViewModel configurationItem,
SelectorForItemsGroup selectorForItemsGroup, int depthLevel = 0)
{
IRuntimePropertyViewModel defaultProperty = configurationItem as IRuntimePropertyViewModel;
return(Maybe <List <TagBuilder> > .FromValue(new List <TagBuilder>()
{
ConfigTableRowRenderer
.Create()
.SetDepth(depthLevel)
.SetName(new RenderData(defaultProperty.Header))
.SetDeviceData(Result <string> .Create(() => defaultProperty.DeviceValue.AsString(),
defaultProperty.DeviceValue != null))
.SetLocalData(Result <string> .Create(() => defaultProperty.LocalValue
.AsString(),
defaultProperty.LocalValue != null))
.SetRange(Result <string> .Create(
$"[{defaultProperty.RangeViewModel.RangeFrom} : {defaultProperty.RangeViewModel.RangeTo}]",
defaultProperty.IsRangeEnabled))
.SetMeasureUnit(Result <string> .Create(defaultProperty.MeasureUnit,
defaultProperty.IsMeasureUnitEnabled))
.SetSelectors(selectorForItemsGroup.IsPrintDeviceValuesAllowed,
selectorForItemsGroup.IsPrintLocalValuesAllowed)
.Render()
}));
}
private void TreeViewToggleButtonBehavior_Checked(object sender, System.Windows.RoutedEventArgs e)
{
IConfigurationItemViewModel oldItem = ((sender as ToggleButton).DataContext as IConfigurationItemViewModel);
if (oldItem == null)
{
return;
}
if (oldItem.IsChecked)
{
(sender as ToggleButton).IsChecked = false;
TreeViewToggleButtonBehavior_Unchecked(sender, e);
return;
}
oldItem.IsChecked = true;
ObservableCollection <IConfigurationItemViewModel> treeGridItems = ((sender as ToggleButton)?.Tag as ObservableCollection <IConfigurationItemViewModel>);
int index = treeGridItems.IndexOf(oldItem);
if (oldItem?.ChildStructItemViewModels is IEnumerable <IConfigurationItemViewModel> )
{
IEnumerable <IConfigurationItemViewModel> newItems = oldItem.ChildStructItemViewModels;
foreach (IConfigurationItemViewModel newItem in newItems)
{
index++;
AddTreeGridItem(treeGridItems, newItem, oldItem, index);
}
return;
}
}
private void AddTreeGridItem(ObservableCollection <IConfigurationItemViewModel> treeGridItems,
IConfigurationItemViewModel childConfigurationItemViewModel,
IConfigurationItemViewModel parentConfigurationItemViewModel, int index)
{
childConfigurationItemViewModel.Level = parentConfigurationItemViewModel.Level + 1;
treeGridItems.Insert(index, childConfigurationItemViewModel);
}
public Maybe <List <TagBuilder> > RenderHtmlFromItem(IConfigurationItemViewModel configurationItem,
SelectorForItemsGroup selectorForItemsGroup, int depthLevel = 0)
{
if (selectorForItemsGroup == null || !selectorForItemsGroup.IsSelected)
{
return(Maybe <List <TagBuilder> > .Empty());
}
var group = configurationItem as IItemGroupViewModel;
List <TagBuilder> tagBuilders = new List <TagBuilder>
{
ConfigTableRowRenderer
.Create()
.SetName(new RenderData(group.Header, depthLevel == 0 ? "rootItem" : null))
.SetDepth(depthLevel)
.SetShouldRenderEmptyItems(depthLevel != 0)
.SetSelectors(selectorForItemsGroup.IsPrintDeviceValuesAllowed, selectorForItemsGroup.IsPrintLocalValuesAllowed)
.Render()
};
group.ChildStructItemViewModels.ForEach((item =>
{
_itemRendererFactory
.GetConfigurationItemRenderer(item)
.RenderHtmlFromItem(item,
selectorForItemsGroup.Selectors.FirstOrDefault((itemsGroup =>
itemsGroup.RelatedItemsGroup == item)) ?? selectorForItemsGroup, depthLevel + 1)
.OnNotEmpty(result => tagBuilders.AddRange(result));
}));
return(Maybe <List <TagBuilder> > .FromValue(tagBuilders));
}
public static bool ValidateConfigItem(IConfigurationItemViewModel configurationViewModel, bool initial)
{
bool res = initial;
if (configurationViewModel is ICanBeHidden canBeHidden && !canBeHidden.IsHidden)
{
if (configurationViewModel is ILocalAndDeviceValueContainingViewModel
localAndDeviceValueContainingViewModel &&
localAndDeviceValueContainingViewModel.LocalValue != null &&
localAndDeviceValueContainingViewModel.LocalValue.HasErrors)
{
var errorMes =
$"{StaticContainer.Container.Resolve<ILocalizerService>().GetLocalizedString(ApplicationGlobalNames.StatusMessages.ERROR)}: {configurationViewModel.BuildItemPath()}";
StaticContainer.Container.Resolve <ILogService>().LogMessage(errorMes, LogMessageTypeEnum.Error);
res = false;
}
}
if (configurationViewModel.ChildStructItemViewModels.Count > 0)
{
foreach (var configurationItemViewModel in configurationViewModel.ChildStructItemViewModels)
{
res = ValidateConfigItem(configurationItemViewModel, res);
}
}
return(res);
}
public ConfigItemWrapper(IEnumerable <ConfigItemWrapper> childConfigItemWrappers,
IConfigurationItemViewModel relatedConfigurationItemViewModel, bool toInclude, bool matchesFilter = true)
{
ChildConfigItemWrappers = childConfigItemWrappers;
RelatedConfigurationItemViewModel = relatedConfigurationItemViewModel;
ToInclude = toInclude;
MatchesFilter = matchesFilter;
}
public static RuntimeConfigurationItemViewModelFactory WithParent(
this RuntimeConfigurationItemViewModelFactory factory, IConfigurationItemViewModel parent)
{
var newFactory = factory.Clone() as RuntimeConfigurationItemViewModelFactory;
newFactory.Parent = parent;
return(newFactory);
}
public bool IsStructureSimilar(IConfigurationItemViewModel configurationItemViewModel1,
IConfigurationItemViewModel configurationItemViewModel2)
{
var res = ProcessConfigurationItem(
Result <Action <ILocalAndDeviceValueContainingViewModel, ILocalAndDeviceValueContainingViewModel> >
.Create(false), configurationItemViewModel1, configurationItemViewModel2);
return(res.IsSuccess);
}
public bool GetIsSetElementPossible(IConfigurationItemViewModel element, bool isUp)
{
if (ChildStructItemViewModels.Contains(element))
{
int startIndex = ChildStructItemViewModels.IndexOf(element as IEditorConfigurationItemViewModel);
return(isUp ? startIndex > 0 : ChildStructItemViewModels.Count - 1 > startIndex);
}
return(false);
}
private void InitializeBaseProperties(IConfigurationItemViewModel configurationViewModel, IConfigurationItem configurationItem)
{
configurationViewModel.Description = configurationItem?.Description;
configurationViewModel.Header = configurationItem?.Name;
if (Parent != null)
{
configurationViewModel.Parent = Parent;
configurationViewModel.Level = Parent.Level + 1;
}
}
public IConfigurationItemRenderer GetConfigurationItemRenderer(IConfigurationItemViewModel configurationItem)
{
try
{
return(_typesContainer.Resolve <IConfigurationItemRenderer>(configurationItem.StrongName));
}
catch
{
return(new FallbackItemRenderer());
}
}
public List <EditorValidationErrorViewModel> CheckItem(List <EditorValidationErrorViewModel> initialErrors,
IConfigurationItemViewModel configurationEditorItemViewModel,
IConfigurationEditorViewModel configurationEditorViewModel)
{
if (configurationEditorItemViewModel is IPropertyEditorViewModel propertyEditorViewModel &&
!(configurationEditorItemViewModel is IComplexPropertyEditorViewModel))
{
if (propertyEditorViewModel.FormatterParametersViewModel == null ||
(propertyEditorViewModel.FormatterParametersViewModel.RelatedUshortsFormatterViewModel == null &&
!propertyEditorViewModel.FormatterParametersViewModel.IsFromSharedResources))
{
initialErrors.Add(new EditorValidationErrorViewModel(
$"{propertyEditorViewModel.Name} ({_localizerService.GetLocalizedString("Address")}:{propertyEditorViewModel.Address}): {_localizerService.GetLocalizedString(ApplicationGlobalNames.StatusMessages.EMPTY_FORMATTING_MESSAGE)}",
Result <Action> .Create(
() =>
{
_formatterEditorFactory.EditFormatterByUser(propertyEditorViewModel,
configurationEditorViewModel.RootConfigurationItemViewModels.ToList());
}, true)));
}
if (propertyEditorViewModel.FormatterParametersViewModel != null &&
propertyEditorViewModel.FormatterParametersViewModel.IsFromSharedResources &&
_sharedResourcesGlobalViewModel.GetResourceByName(propertyEditorViewModel
.FormatterParametersViewModel.Name) == null)
{
initialErrors.Add(new EditorValidationErrorViewModel(
$"{propertyEditorViewModel.Name} ({_localizerService.GetLocalizedString("Address")}:{propertyEditorViewModel.Address}): {_localizerService.GetLocalizedString(ApplicationGlobalNames.StatusMessages.FORMATTING_RESOURCE_NOT_FOUND_MESSAGE)}",
Result <Action> .Create(
() =>
{
_formatterEditorFactory.EditFormatterByUser(propertyEditorViewModel,
configurationEditorViewModel.RootConfigurationItemViewModels.ToList());
}, true)));
}
}
if (configurationEditorItemViewModel is IConfigurationGroupEditorViewModel configurationGroupEditorViewModel
)
{
configurationGroupEditorViewModel.ChildStructItemViewModels.ForEach(model =>
CheckItem(initialErrors, model, configurationEditorViewModel));
}
if (configurationEditorItemViewModel is IComplexPropertyEditorViewModel complexPropertyEditorViewModel)
{
complexPropertyEditorViewModel.SubPropertyEditorViewModels.ForEach(model =>
CheckItem(initialErrors, model, configurationEditorViewModel));
}
return(initialErrors);
}
private void RefreshToggleButtonRows()
{
ObservableCollection <IConfigurationItemViewModel> allItems =
_assToggleButton.Tag as ObservableCollection <IConfigurationItemViewModel>;
IConfigurationItemViewModel currentItem = _assToggleButton.DataContext as IConfigurationItemViewModel;
if (allItems != null)
{
int startIndex =
allItems.IndexOf(currentItem);
if (startIndex < 0)
{
return;
}
if (currentItem.ChildStructItemViewModels is IEnumerable <IConfigurationItemViewModel> )
{
IEnumerable <IConfigurationItemViewModel> childItems =
currentItem.ChildStructItemViewModels;
foreach (IConfigurationItemViewModel child in childItems)
{
child.Checked?.Invoke(false);
startIndex++;
if (allItems.Count > startIndex)
{
if (allItems[startIndex].GetType() == child.GetType())
{
if (allItems[startIndex] == child)
{
continue;
}
if (allItems.Count > startIndex)
{
if (allItems[startIndex].GetType() == allItems[startIndex + 1].GetType())
{
allItems.Move(startIndex, startIndex + 1);
}
}
}
else
{
allItems.Insert(startIndex, child);
}
}
else
{
allItems.Add(child);
}
}
}
}
}
public Maybe <List <TagBuilder> > RenderHtmlFromItem(IConfigurationItemViewModel configurationItem,
SelectorForItemsGroup selectorForItemsGroup = null, int depthLevel = 0)
{
return(Maybe <List <TagBuilder> > .FromValue(new List <TagBuilder>()
{
ConfigTableRowRenderer
.Create()
.SetDepth(depthLevel)
.SetName(new RenderData(configurationItem.Header))
.SetSelectors(selectorForItemsGroup.IsPrintDeviceValuesAllowed, selectorForItemsGroup.IsPrintLocalValuesAllowed)
.Render()
}));
}
public void CopyValuesToItem(IConfigurationItemViewModel configurationItemViewModelFrom,
IConfigurationItemViewModel configurationItemViewModelTo)
{
var callback =
Result <Action <ILocalAndDeviceValueContainingViewModel, ILocalAndDeviceValueContainingViewModel> >
.Create((viewModel1, viewModel2) =>
{
viewModel2.LocalValue.Accept(
_editableValueCopyVisitorProvider.GetValueViewModelCopyVisitor(viewModel1.LocalValue));
}, true);
var res = ProcessConfigurationItem(callback, configurationItemViewModelFrom, configurationItemViewModelTo);
}
public List <EditorValidationErrorViewModel> CheckItem(List <EditorValidationErrorViewModel> initialErrors,
IConfigurationItemViewModel configurationEditorViewModel)
{
if (configurationEditorViewModel is IPropertyEditorViewModel propertyEditorViewModel &&
!(configurationEditorViewModel is IComplexPropertyEditorViewModel))
{
var resources = propertyEditorViewModel.DependencyViewModels
.Where(model => model is ConditionResultDependencyViewModel)
.Select(model => (model as ConditionResultDependencyViewModel).SelectedConditionViewModel)
.Where(model => model is RegexMatchConditionViewModel)
.Cast <RegexMatchConditionViewModel>()
.Select(model => _sharedResourcesGlobalViewModel.GetResourceViewModelByName(model.ReferencedResourcePropertyName))
.Choose()
.Where(nameable => nameable is IPropertyEditorViewModel)
.Select(nameable => (nameable as IPropertyEditorViewModel).FormatterParametersViewModel)
.ToList();
if (resources.Any(model => !_formatterInfoService.ReturnsString(model.RelatedUshortsFormatterViewModel)))
{
initialErrors.Add(new EditorValidationErrorViewModel(
$"{propertyEditorViewModel.Name} ({_localizerService.GetLocalizedString("Address")}:{propertyEditorViewModel.Address}): {_localizerService.GetLocalizedString(ApplicationGlobalNames.StatusMessages.REGEX_RESOURCE_FORMATTER_IS_NOT_STRING_MESSAGE)}",
Result <Action> .Create(
() =>
{
_dependenciesService.EditDependencies(propertyEditorViewModel,
new DependenciesConfiguration(("ConditionResultDependency",
() => _dependencyFillHelper.CreateEmptyConditionResultDependencyViewModel())));
}, true)));
}
}
if (configurationEditorViewModel is IConfigurationGroupEditorViewModel configurationGroupEditorViewModel)
{
configurationGroupEditorViewModel.ChildStructItemViewModels.ForEach(model =>
CheckItem(initialErrors, model));
}
if (configurationEditorViewModel is IComplexPropertyEditorViewModel complexPropertyEditorViewModel)
{
complexPropertyEditorViewModel.SubPropertyEditorViewModels.ForEach(model =>
CheckItem(initialErrors, model));
}
return(initialErrors);
}
public List <EditorValidationErrorViewModel> CheckItem(List <EditorValidationErrorViewModel> initialErrors,
IConfigurationItemViewModel configurationEditorViewModel)
{
if (configurationEditorViewModel is IPropertyEditorViewModel propertyEditorViewModel &&
!(configurationEditorViewModel is IComplexPropertyEditorViewModel))
{
var dependenciesWithResources = propertyEditorViewModel.DependencyViewModels
.Where(model => model is ConditionResultDependencyViewModel)
.Select(model => (model as ConditionResultDependencyViewModel).SelectedConditionViewModel)
.Where(model => model is IConditionWithResourceViewModel)
.Cast <IConditionWithResourceViewModel>()
.ToList();
if (dependenciesWithResources.Any(model =>
string.IsNullOrEmpty(model.ReferencedResourcePropertyName)) ||
dependenciesWithResources.Any(model =>
!_sharedResourcesGlobalViewModel.GetResourceViewModelByName(
model.ReferencedResourcePropertyName).IsSuccess))
{
initialErrors.Add(new EditorValidationErrorViewModel(
$"{propertyEditorViewModel.Name} ({_localizerService.GetLocalizedString("Address")}:{propertyEditorViewModel.Address}): {_localizerService.GetLocalizedString(ApplicationGlobalNames.StatusMessages.RESOURCE_FOR_DEPENDENCY_NOT_FOUND_MESSAGE)}",
Result <Action> .Create(
() =>
{
_dependenciesService.EditDependencies(propertyEditorViewModel,
new DependenciesConfiguration(("ConditionResultDependency",
() => _dependencyFillHelper.CreateEmptyConditionResultDependencyViewModel())));
}, true)));
}
}
if (configurationEditorViewModel is IConfigurationGroupEditorViewModel configurationGroupEditorViewModel)
{
configurationGroupEditorViewModel.ChildStructItemViewModels.ForEach(model =>
CheckItem(initialErrors, model));
}
if (configurationEditorViewModel is IComplexPropertyEditorViewModel complexPropertyEditorViewModel)
{
complexPropertyEditorViewModel.SubPropertyEditorViewModels.ForEach(model =>
CheckItem(initialErrors, model));
}
return(initialErrors);
}
private void TreeViewToggleButtonBehavior_Unchecked(object sender, System.Windows.RoutedEventArgs e)
{
ObservableCollection <IConfigurationItemViewModel> allItems =
(sender as ToggleButton).Tag as ObservableCollection <IConfigurationItemViewModel>;
if (allItems == null)
{
return;
}
IConfigurationItemViewModel oldItem = ((sender as ToggleButton).DataContext as IConfigurationItemViewModel);
if (oldItem == null)
{
return;
}
oldItem.IsChecked = false;
DeleteTreeGridItem(allItems, oldItem, false);
}
private void InitTree(ToggleButton toggleButton)
{
IConfigurationItemViewModel oldItem = (toggleButton.DataContext as IConfigurationItemViewModel);
if (oldItem == null)
{
return;
}
if (oldItem is IAsTableViewModel configurationAsTableViewModel && configurationAsTableViewModel.IsTableView)
{
return;
}
oldItem.IsChecked = true;
ObservableCollection <IConfigurationItemViewModel> treeGridItems = (toggleButton?.Tag as ObservableCollection <IConfigurationItemViewModel>);
int index = treeGridItems.IndexOf(oldItem);
if (oldItem?.ChildStructItemViewModels is IEnumerable <IConfigurationItemViewModel> )
{
IEnumerable <IConfigurationItemViewModel> newItems = oldItem.ChildStructItemViewModels;
foreach (IConfigurationItemViewModel newItem in newItems)
{
bool isAdded = false;
if (newItem is IGroupedConfigurationItemViewModel)
{
if (!(newItem as IGroupedConfigurationItemViewModel).IsGroupedProperty)
{
newItem.ChildStructItemViewModels.ForEach((model =>
{
index++;
AddTreeGridItem(treeGridItems, model, oldItem, index);
}));
isAdded = true;
}
}
if (!isAdded)
{
index++;
AddTreeGridItem(treeGridItems, newItem, oldItem, index);
}
}
}
}
/// <summary>
/// рекурсивное удаление всей ветки
/// </summary>
/// <param name="treeGridItems">коллекция всех объектов в строках</param>
/// <param name="removingItem">текущие элемент</param>
/// <param name="removeFromCollection">удалять ли из коллекции текущий элемент</param>
private void DeleteTreeGridItem(ObservableCollection <IConfigurationItemViewModel> treeGridItems,
IConfigurationItemViewModel removingItem, bool removeFromCollection)
{
if (removingItem.ChildStructItemViewModels is IEnumerable <IConfigurationItemViewModel> )
{
IEnumerable <IConfigurationItemViewModel> newItems =
removingItem.ChildStructItemViewModels;
foreach (IConfigurationItemViewModel newItem in newItems)
{
DeleteTreeGridItem(treeGridItems, newItem, true);
}
}
else if (removingItem.ChildStructItemViewModels is IConfigurationItemViewModel)
{
DeleteTreeGridItem(treeGridItems, removingItem.ChildStructItemViewModels as IConfigurationItemViewModel, true);
}
if (removeFromCollection)
{
RemoveItemFromList(treeGridItems, removingItem);
}
}
public MainConfigItemViewModel(IEnumerable <MainConfigItemViewModel> childConfigItemViewModels,
IConfigurationItemViewModel relatedConfigurationItemViewModel)
{
ChildConfigItemViewModels = childConfigItemViewModels;
RelatedConfigurationItemViewModel = relatedConfigurationItemViewModel;
IsTableEnabled =
(relatedConfigurationItemViewModel is IItemGroupViewModel groupViewModel) &&
groupViewModel.IsTableViewAllowed;
// IGroupWithReiterationInfo groupWithReiterationInfo = null;
//if (RelatedConfigurationItemViewModel is IItemGroupViewModel groupViewModelWithreit &&
// groupViewModelWithreit.Model is IItemsGroup itemsGroup &&
// itemsGroup.GroupInfo is IGroupWithReiterationInfo groupWithReiteration)
//{
// IsGroupWithReiteration = groupWithReiteration.IsReiterationEnabled;
// groupWithReiterationInfo = groupWithReiteration;
//}
if (!childConfigItemViewModels.Any() || IsGroupWithReiteration)
{
var relatedRows = new List <IConfigurationItemViewModel>();
if (IsGroupWithReiteration)
{
//var factory = StaticContainer.Container.Resolve<IRuntimeConfigurationItemViewModelFactory>();
//var children = groupWithReiterationInfo.SubGroups.Select(
// (info => factory.CreateGroupWithReiterationViewModel(info))).ToList();
//FillRelatedRows(relatedRows, children, 0);
}
else
{
FillRelatedRows(relatedRows, relatedConfigurationItemViewModel.ChildStructItemViewModels, 0);
}
RelatedRows = relatedRows;
}
}
private void TreeViewToggleButtonBehavior_Checked(object sender, System.Windows.RoutedEventArgs e)
{
IConfigurationItemViewModel oldItem = ((sender as ToggleButton).DataContext as IConfigurationItemViewModel);
if (oldItem == null)
{
return;
}
oldItem.IsChecked = true;
ObservableCollection <IConfigurationItemViewModel> treeGridItems = ((sender as ToggleButton)?.Tag as ObservableCollection <IConfigurationItemViewModel>);
int index = treeGridItems.IndexOf(oldItem);
if (oldItem?.ChildStructItemViewModels is IEnumerable <IConfigurationItemViewModel> )
{
IEnumerable <IConfigurationItemViewModel> newItems = oldItem.ChildStructItemViewModels;
foreach (IConfigurationItemViewModel newItem in newItems)
{
bool isAdded = false;
if (newItem is IGroupedConfigurationItemViewModel)
{
if (!(newItem as IGroupedConfigurationItemViewModel).IsGroupedProperty)
{
newItem.ChildStructItemViewModels.ForEach(model =>
{
index++;
AddTreeGridItem(treeGridItems, model, oldItem, index);
});
isAdded = true;
}
}
if (!isAdded)
{
index++;
AddTreeGridItem(treeGridItems, newItem, oldItem, index);
}
}
}
}
public bool GetIsSetElementPossible(IConfigurationItemViewModel element, bool isUp)
{
if (ChildStructItemViewModels.Contains(element))
{
if (isUp)
{
if (ChildStructItemViewModels.IndexOf(element as IEditorConfigurationItemViewModel) >
0)
{
return(true);
}
}
else
{
if (ChildStructItemViewModels.IndexOf(element as IEditorConfigurationItemViewModel) <
ChildStructItemViewModels.Count - 1)
{
return(true);
}
}
}
return(false);
}
private static string GetMessageForAlreadySetItem(IConfigurationItemViewModel configurationItemViewModel)
{
return
($"{StaticContainer.Container.Resolve<ILocalizerService>().GetLocalizedString("ThisBitSetIn")} {Environment.NewLine} {configurationItemViewModel.BuildItemPath()}");
}
public static string BuildItemPath(this IConfigurationItemViewModel configurationViewModel)
{
return((configurationViewModel.Parent != null
? $"{BuildItemPath(configurationViewModel.Parent)}."
: null) + configurationViewModel.Header);
}
protected override void OnDisposing()
{
Parent = null;
base.OnDisposing();
}
private void RemoveItemFromList(ObservableCollection <IConfigurationItemViewModel> treeGridItems,
IConfigurationItemViewModel removingItem)
{
treeGridItems.Remove(removingItem);
removingItem.Level = 0;
}
