internal virtual void NotifyValidated(AbstractActionModelTreeNode node, string propertyName, object value)
{
if (!ReferenceEquals(this.Parent, null))
{
this.Parent.NotifyValidated(node, propertyName, value);
}
}
public void RenameNode()
{
try
{
if (this.CanRename)
{
AbstractActionModelTreeNode selectedNode = base.SelectedNode;
RenameNodeComponent component = new RenameNodeComponent();
component.Name = selectedNode.Label;
ApplicationComponentExitCode result = ApplicationComponent.LaunchAsDialog(
this.Context.DesktopWindow,
new SimpleComponentContainer(component),
SR.TitleRename);
if (result == ApplicationComponentExitCode.Accepted)
{
selectedNode.Label = component.Name;
}
}
}
catch (Exception ex)
{
ExceptionHandler.Report(ex, this.Context.DesktopWindow);
}
}
internal IAction BuildAction()
{
IAction action = AbstractAction.Create(_action);
Stack <PathSegment> stack = new Stack <PathSegment>();
AbstractActionModelTreeNode current = this;
do
{
stack.Push(current.PathSegment);
current = current.Parent;
} while (current != null);
Path path = new Path(stack.Pop()); // the first path segment is the site, which is never processed through the resource resolver
while (stack.Count > 0)
{
// for each subsequent segment, ensure the action's resolver will resolve the string in the expected way
PathSegment pathSegment = stack.Pop();
string localizedString = action.ResourceResolver.LocalizeString(pathSegment.ResourceKey);
if (localizedString == pathSegment.LocalizedText)
{
path = path.Append(pathSegment);
}
else
{
path = path.Append(new PathSegment(pathSegment.LocalizedText, pathSegment.LocalizedText));
}
}
action.Path = new ActionPath(path.ToString(), action.ResourceResolver);
return(action);
}
public virtual DragDropKind CanAcceptDrop(object dropData, DragDropKind dragDropKind, DragDropPosition dragDropPosition)
{
// drop target must have a parent, otherwise there is no concept of "sibling"
if (dragDropPosition != DragDropPosition.Default && !ReferenceEquals(this.Parent, null))
{
if (dropData is AbstractActionModelTreeNode)
{
AbstractActionModelTreeNode droppedNode = (AbstractActionModelTreeNode)dropData;
if (dragDropKind == DragDropKind.Move)
{
AbstractActionModelTreeNode sibling = null;
if (droppedNode.Parent != null)
{
int index = droppedNode.Parent.Children.IndexOf(droppedNode) + (dragDropPosition == DragDropPosition.After ? -1 : 1);
if (index >= 0 && index < droppedNode.Parent.Children.Count)
{
sibling = droppedNode.Parent.Children[index];
}
}
// to drag-move, we can't be dragging immediately before/after ourself, or onto one of our descendants
if (!ReferenceEquals(this, droppedNode) &&
!ReferenceEquals(this, sibling) &&
!this.IsDescendantOf(droppedNode as AbstractActionModelTreeBranch))
{
return(dragDropKind);
}
}
}
}
return(DragDropKind.None);
}
public override DragDropKind CanAcceptDrop(object dropData, DragDropKind dragDropKind, DragDropPosition dragDropPosition)
{
if (dragDropPosition == DragDropPosition.Default)
{
if (dropData is AbstractActionModelTreeNode)
{
AbstractActionModelTreeNode droppedNode = (AbstractActionModelTreeNode)dropData;
if (dragDropKind == DragDropKind.Move)
{
// to drag-move, we can't be dragging onto ourself, onto our parent, or onto one of our descendants
if (!ReferenceEquals(this, droppedNode) &&
!ReferenceEquals(this, droppedNode.Parent) &&
!this.IsDescendantOf(droppedNode as AbstractActionModelTreeBranch))
{
return(dragDropKind);
}
}
}
}
else if (dragDropPosition == DragDropPosition.After)
{
// prevent dropping something after an expanded branch node with children,
// because the user is physically dropping between the branch and its children
// but the child logically appears as a sibling of the branch *after* both the branch and its children.
if (this.Children.Count > 0 && this.IsExpanded)
{
return(DragDropKind.None);
}
}
return(base.CanAcceptDrop(dropData, dragDropKind, dragDropPosition));
}
public IEnumerable <NodePropertiesComponent> CreateComponents(AbstractActionModelTreeNode selectedNode)
{
if (selectedNode is AbstractActionModelTreeLeafClickAction)
{
yield return(new ClickActionKeystrokePropertyComponent((AbstractActionModelTreeLeafClickAction)selectedNode));
}
}
internal override bool RequestValidation(AbstractActionModelTreeNode node, string propertyName, object value)
{
NodeValidationRequestedEventArgs e = new NodeValidationRequestedEventArgs(node, propertyName, value);
EventsHelper.Fire(this.NodeValidationRequested, this, e);
return(e.IsValid);
}
public NodeValidationRequestedEventArgs(AbstractActionModelTreeNode node, string propertyName, object value)
{
this.Node = node;
this.PropertyName = propertyName;
this.Value = value;
this.IsValid = true;
}
internal virtual bool RequestValidation(AbstractActionModelTreeNode node, string propertyName, object value)
{
if (!ReferenceEquals(this.Parent, null))
{
return(this.Parent.RequestValidation(node, propertyName, value));
}
return(true);
}
protected virtual bool OnRequestNodePropertiesValidation(AbstractActionModelTreeNode node, string propertyName, object value)
{
if (_validationPolicy == null)
{
return(true);
}
return(_validationPolicy.Validate(node, propertyName, value));
}
private void SynchronizeParent(AbstractActionModelTreeNode node, ItemChangeType changeType)
{
switch (changeType)
{
case ItemChangeType.ItemAdded:
case ItemChangeType.ItemInserted:
// set the parent on the added node
node.Parent = this;
// sync the secondary list
_syncList.Add(node);
// force the node to expand
this.IsExpanded = true;
break;
case ItemChangeType.ItemRemoved:
// nullify the parent on the node if and only if it is us (just in case something silly happens and the parent is already updated)
if (ReferenceEquals(this, node.Parent))
{
node.Parent = null;
}
// sync the secondary list
_syncList.Remove(node);
break;
case ItemChangeType.ItemChanged:
// replacing an item in the list can cause ItemChanged, thus we need to resync the entire list to update the replaced item
case ItemChangeType.Reset:
default:
// resync the parent nodes using the secondary list as a reference for what was in the tree before the change
foreach (AbstractActionModelTreeNode child in _syncList)
{
if (!_subtree.Items.Contains(child))
{
if (ReferenceEquals(this, node.Parent))
{
node.Parent = null;
}
}
}
foreach (AbstractActionModelTreeNode child in _subtree.Items)
{
if (!_syncList.Contains(child))
{
child.Parent = this;
}
}
// update the secondary list
_syncList.Clear();
_syncList.AddRange(_subtree.Items);
break;
}
}
public bool Validate(AbstractActionModelTreeNode node, string propertyName, object value)
{
if (_propertyName != propertyName)
{
return(true);
}
if (!(node is T))
{
return(true);
}
return(_delegate.Invoke((T)node, value));
}
public bool Validate(AbstractActionModelTreeNode node, string propertyName, object value)
{
foreach (INodePropertiesValidationRule rule in _rules)
{
// if the node fails any single validation rule, it fails all
if (!rule.Validate(node, propertyName, value))
{
return(false);
}
}
return(true);
}
private void InsertNode(AbstractActionModelTreeNode node, AbstractActionModelTreeNode selectedNode, DragDropPosition position)
{
if (position == DragDropPosition.After && selectedNode.Parent != null)
{
selectedNode.Parent.Children.Insert(selectedNode.Parent.Children.IndexOf(selectedNode) + 1, node);
}
else if (position == DragDropPosition.Default && selectedNode is AbstractActionModelTreeBranch)
{
((AbstractActionModelTreeBranch)selectedNode).Children.Add(node);
selectedNode.IsExpanded = true;
}
else if (position == DragDropPosition.Before && selectedNode.Parent != null)
{
selectedNode.Parent.Children.Insert(selectedNode.Parent.Children.IndexOf(selectedNode), node);
}
else
{
base.Component.AbstractActionModelTreeRoot.Children.Add(node);
base.Component.AbstractActionModelTreeRoot.IsExpanded = true;
}
}
private void InsertNode(AbstractActionModelTreeNode node)
{
AbstractActionModelTreeNode selectedNode = base.SelectedNode;
if (selectedNode is AbstractActionModelTreeBranch && !selectedNode.IsExpanded && selectedNode.Parent != null)
{
this.InsertNode(node, selectedNode, DragDropPosition.After);
}
else if (selectedNode is AbstractActionModelTreeBranch)
{
this.InsertNode(node, selectedNode, DragDropPosition.Default);
}
else if (selectedNode is AbstractActionModelTreeLeaf && selectedNode.Parent != null)
{
this.InsertNode(node, selectedNode, DragDropPosition.After);
}
else
{
this.InsertNode(node, base.Component.AbstractActionModelTreeRoot, DragDropPosition.After);
}
}
public void RemoveNode()
{
try
{
AbstractActionModelTreeNode selectedNode = base.SelectedNode;
if (this.CanRemove && selectedNode.Parent != null)
{
AbstractActionModelTreeBranch branch = selectedNode as AbstractActionModelTreeBranch;
if (branch != null && !branch.HasNoActions)
{
base.Context.DesktopWindow.ShowMessageBox(SR.MessageNodeNotEmpty, MessageBoxActions.Ok);
return;
}
selectedNode.Parent.Children.Remove(selectedNode);
}
}
catch (Exception ex)
{
ExceptionHandler.Report(ex, this.Context.DesktopWindow);
}
}
internal Path GetSeparatorPath()
{
Stack <PathSegment> stack = new Stack <PathSegment>();
stack.Push(new PathSegment(Guid.NewGuid().ToString()));
AbstractActionModelTreeNode current = this.Parent;
while (current != null)
{
stack.Push(current.PathSegment);
current = current.Parent;
}
Path path = new Path(stack.Pop());
while (stack.Count > 0)
{
path = path.Append(stack.Pop());
}
return(path);
}
protected virtual void OnNodePropertiesValidated(AbstractActionModelTreeNode node, string propertyName, object value)
{
}
protected NodePropertiesComponent(AbstractActionModelTreeNode selectedNode)
{
Platform.CheckForNullReference(selectedNode, "selectedNode");
_selectedNode = selectedNode;
}
/// <summary>
/// Use only for performing initial population of the node.
/// </summary>
internal void AppendChild(AbstractActionModelTreeNode child)
{
_subtree.Items.Add(child);
}
internal override void NotifyValidated(AbstractActionModelTreeNode node, string propertyName, object value)
{
NodeValidatedEventArgs e = new NodeValidatedEventArgs(node, propertyName, value);
EventsHelper.Fire(this.NodeValidated, this, e);
}
internal void NotifyChildChanged(AbstractActionModelTreeNode child)
{
_subtree.Items.NotifyItemUpdated(child);
}
protected virtual IEnumerable <NodePropertiesComponent> CreateNodePropertiesComponents(AbstractActionModelTreeNode node)
{
if (node != null)
{
foreach (object extension in new NodePropertiesComponentProviderExtensionPoint().CreateExtensions())
{
INodePropertiesComponentProvider provider = extension as INodePropertiesComponentProvider;
if (provider != null)
{
foreach (NodePropertiesComponent component in provider.CreateComponents(node))
{
yield return(component);
}
}
}
}
}
