public void AddValidationItem(IValidationItem item)
{
if (item == null)
{
return;
}
if (this.idToValidationItem.ContainsKey(item.FID))
{
return;
}
//if (this.IgnoredValidationItemIds.Contains(item.ID))
//{
// // The item was ignored. When you get here it means the rule
// // engine deleted existing validation items and is running again
// // to regenerate them.
// if ((item.ResultType == ValidationType.Message))
// {
// item.ResultType = ValidationType.IgnoredMessage;
// }
// else if (item.ResultType == ValidationType.Warning)
// {
// item.ResultType = ValidationType.IgnoredWarning;
// }
//}
this.validationItems.Add(item);
this.idToValidationItem.Add(item.FID, item);
}
/// <summary>
/// Add a validation item context to a proper group
/// </summary>
/// <param name="itemContext"></param>
private ValidationGroupContext AddToGroup(ValidationItemContextBase itemContext)
{
IValidationItem item = itemContext.ValidationItem;
string groupName = null;
//if (this.DisplayConfig.IsByDeviceType)
groupName = item.DeviceType;
//else
// groupName = item.Category;
ValidationGroupContext group;
if (!groupNameToContext.TryGetValue(groupName, out group))
{
group = new ValidationGroupContext(groupName);
groupNameToContext.Add(groupName, group);
group.IsExpandedChanged += new EventHandler(group_IsExpandedChanged);
this.ValidationGroups.Add(group);
}
if (group.ValidationResultItems.Contains(itemContext) == false)
{
group.ValidationResultItems.Add(itemContext);
}
if (this.validationItem2ItemGroupViewModel.ContainsKey(item) == false)
{
this.validationItem2ItemGroupViewModel.Add(item, group);
}
return(group);
}
//private void UpdateDisplayConfigSettings(int itemCount)
//{
// this.DisplayConfig.IsSortingPossible = (this.ValidationGroups.Count > 1);
// this.DisplayConfig.IsGroupingPossible = (itemCount > 0);
//}
private ValidationGroupContext CreateValidationItemContext(IValidationItem item)
{
ValidationItemContextBase itemContext = new ValidationItemContext(this, item);
if (this.validationItem2ItemViewModel.ContainsKey(item) == false)
{
this.validationItem2ItemViewModel.Add(item, itemContext);
}
//itemContext.UpdateVisibility(this.DisplayConfig.FilterContext);
return(this.AddToGroup(itemContext));
}
/// <summary>
/// isDeletingFeature indicates if it's called by deleting a feature
/// If isDeletingFeature = true, we remove related records from ignored validation item id list;
/// </summary>
public void RemoveValidationItem(IValidationItem item)
{
if (item == null)
{
return;
}
if (!this.idToValidationItem.ContainsKey(item.FID))
{
return;
}
this.validationItems.Remove(item);
this.idToValidationItem.Remove(item.FID);
}
/// <summary>
/// To group validation items
/// </summary>
private void Initialize()
{
this.clickedItem = null;
this.oldSelectedFids = null;
this.ValidationGroups.Clear();
this.groupNameToContext = new Dictionary <string, ValidationGroupContext>();
this.validationItem2ItemViewModel = new Dictionary <IValidationItem, ValidationItemContextBase>();
this.validationItem2ItemGroupViewModel = new Dictionary <IValidationItem, ValidationGroupContext>();
this.BindingList = null;
ValidationManager validationManager = this.ValidationManager;
for (int i = 0; i < validationManager.ValidationItemCount; i++)
{
IValidationItem item = validationManager[i];
if (item == null)
{
continue;
}
this.CreateValidationItemContext(item);
}
ObservableCollection <object> newBindingList = new ObservableCollection <object>();
foreach (ValidationGroupContext group in this.ValidationGroups)
{
group.UpdateHeader();
newBindingList.Add(group);
foreach (var item in group.ValidationResultItems)
{
if (item.IsVisible)
{
newBindingList.Add(item);
}
}
}
this.BindingList = newBindingList;
}
protected ValidationItemContextBase(DesignValidationContext owner, IValidationItem item)
{
if (item == null)
{
throw new NullReferenceException("ValidationItemBase.Constructor: Parameter item can't be null"); // NOXLATE
}
if (owner == null)
{
throw new NullReferenceException("ValidationItemBase.Constructor: Parameter owner can't be null"); // NOXLATE
}
this._owner = owner;
this.IsVisible = true;
this.ValidationItem = item;
SetStatus(ItemStatus.Normal);
this.UpdateUiByValidationType();
}
static void OnValidationItemChanged(DependencyObject sender, DependencyPropertyChangedEventArgs args)
{
ValidationItemContextBase cxt = sender as ValidationItemContextBase;
if (cxt == null)
{
return;
}
cxt.FeatureIdentifier = String.Empty;
if (args.NewValue != null)
{
IValidationItem validationItem = args.NewValue as IValidationItem;
object o = validationItem.FeatureItem;
if (o != null)
{
cxt.FeatureIdentifier = o.ToString();
}
}
}
public void UpdateGoToRuleButtonVisibility()
{
IValidationItem item = this.ValidationItem;
bool hasRule = false;
if (item != null)
{
if (string.IsNullOrWhiteSpace(item.RulePointPath) == false)
{
hasRule = true;
this.RulePointPath = item.RulePointPath;
}
}
if (hasRule)
{
this.GoToRuleButtonVisibility = this.IsMouseHovered ? Visibility.Visible : Visibility.Collapsed;
}
else
{
this.GoToRuleButtonVisibility = Visibility.Collapsed;
}
}
/// <summary>
/// Validation item set changed
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
void validationItems_CollectionChanged(object sender, NotifyCollectionChangedEventArgs e)
{
Dictionary <string, ValidationGroupContext> affectedGroups = new Dictionary <string, ValidationGroupContext>();
if (e.NewItems != null)
{
foreach (var obj in e.NewItems)
{
IValidationItem item = obj as IValidationItem;
if (item == null)
{
continue;
}
ValidationGroupContext group = this.CreateValidationItemContext(item);
ValidationItemContextBase itemCxt = this.validationItem2ItemViewModel[item];
Debug.Assert(itemCxt != null);
int indexToInsert = -1;
if (!this.BindingList.Contains(group))
{
this.BindingList.Add(group);
if (group.IsExpanded)
{
indexToInsert = this.BindingList.IndexOf(group) + 1;
}
}
else
{
if (group.IsExpanded && itemCxt.IsVisible)
{
//note that when calling group.GetVisibleChildrenCount, itemCxt is already counted
indexToInsert = this.BindingList.IndexOf(group) + group.GetVisibleChildrenCount();
}
}
if ((indexToInsert >= 0) && itemCxt.IsVisible)
{
this.BindingList.Insert(indexToInsert, itemCxt);
}
if (affectedGroups.ContainsKey(group.SortingName) == false)
{
affectedGroups.Add(group.SortingName, group);
}
}
}
bool toClearClickedItem = false;
if (e.OldItems != null)
{
foreach (var obj in e.OldItems)
{
IValidationItem item = obj as IValidationItem;
if (item == null)
{
continue;
}
//if ((this.clickedItem != null) &&
// Object.ReferenceEquals(this.clickedItem.ValidationItem, item))
//{
// toClearClickedItem = true;
//}
ValidationGroupContext group = this.validationItem2ItemGroupViewModel[item];
if (group == null)
{
continue;
}
ValidationItemContextBase itemCxt = this.validationItem2ItemViewModel[item];
if (itemCxt == null)
{
continue;
}
group.ValidationResultItems.Remove(itemCxt);
this.validationItem2ItemViewModel.Remove(item);
this.validationItem2ItemGroupViewModel.Remove(item);
if (this.BindingList.Contains(itemCxt))
{
this.BindingList.Remove(itemCxt);
}
if (affectedGroups.ContainsKey(group.SortingName) == false)
{
affectedGroups.Add(group.SortingName, group);
}
}
}
foreach (var group in affectedGroups)
{
if (group.Value.ValidationResultItems.Count == 0)
{
ValidationGroupContext groupCxt = group.Value;
this.RemoveGroup(groupCxt);
}
else
{
group.Value.UpdateHeader();
}
}
ValidationManager validationManager = this.ValidationManager;
if (validationManager == null)
{
return;
}
//this.UpdateDisplayConfigSettings(validationManager.ValidationItemCount);
//if (toClearClickedItem && (this.clickedItem != null))
// this.OnItemClicked(null);
base.OnPropertyChanged("HasResolveItems");
}
public void AddResult(IValidationItem result)
{
_validationItems.Add(result);
}
public ValidationItemContext(DesignValidationContext owner, IValidationItem item)
: base(owner, item)
{
}
