/// <summary> /// Event handler that is called when the document node has disposed or name changed. Because the path to the node can have changed too, /// the path is renewed in this case. The <see cref="OnChanged" /> method is called then for the proxy itself. /// </summary> /// <param name="sender"></param> /// <param name="source"></param> /// <param name="e"></param> private void EhDocNode_TunneledEvent(object sender, object source, Main.TunnelingEventArgs e) { if (IsDisposeInProgress) { return; } #if DEBUG_DOCNODEPROXYLOGGING Current.Console.WriteLine("RelDocNodeProxy.EhDocNode_TunneledEvent: sender={0}, source={1} e={2}", sender, source, e); #endif bool shouldFireChangedEvent = false; var senderAsNode = source as IDocumentLeafNode; if (!(senderAsNode != null)) { throw new InvalidProgramException(); } if (e is DisposeEventArgs) { // when our DocNode was disposed, it is probable that the parent of this node (and further parents) are disposed too // thus we need to watch the first node that is not disposed var docNode = InternalDocNode; ClearDocNode(); if (!(sender is AltaxoDocument)) // if the whole document is disposed, there is no point in trying to watch something { // note Dispose is designed to let the hierarchy from child to parent (root) valid, but not from root to child! // thus trying to get an actual document path here is in must cases unsuccessfull. We have to rely on our stored path, and that it was always updated! // the only case were it is successfull if a new node immediately replaces an old document node var node = RelativeDocumentPath.GetNodeOrLeastResolveableNode(_docNodePath, senderAsNode, out var wasResolvedCompletely); if (wasResolvedCompletely) { InternalSetDocNode(node, _parent); } else { SetWatchOnNode(node); } shouldFireChangedEvent = true; } } else if (e is DocumentPathChangedEventArgs) { if (null != InternalDocNode) { InternalDocumentPath = RelativeDocumentPath.GetRelativePathFromTo(_parent, InternalDocNode); } shouldFireChangedEvent = true; } if (shouldFireChangedEvent) { EhSelfChanged(EventArgs.Empty); } }
/// <summary> /// Sets the document node that is held by this proxy. /// </summary> /// <param name="value">The document node. If <c>docNode</c> implements <see cref="Main.IDocumentLeafNode" />, /// the document path is stored for this object in addition to the object itself.</param> /// <param name="parentNode">The start point of the document path. Should be equal to the member _parent, but this might be not set now.</param> protected void InternalSetDocNode(Main.IDocumentLeafNode value, IDocumentLeafNode parentNode) { if (!IsValidDocument(value)) { throw new ArgumentException("This type of document is not allowed for the proxy of type " + GetType().ToString()); } if (null == parentNode) { throw new InvalidOperationException("Parent of this node must be set in order to set the docnode."); } var oldValue = InternalDocNode; if (object.ReferenceEquals(oldValue, value)) { return; // Nothing to do } if (null != _weakDocNodeChangedHandler) { _weakDocNodeChangedHandler.Remove(); _weakDocNodeChangedHandler = null; } if (null != _weakDocNodeTunneledEventHandler) { _weakDocNodeTunneledEventHandler.Remove(); _weakDocNodeTunneledEventHandler = null; } if (null != oldValue) { ClearDocNode(); } var newPath = RelativeDocumentPath.GetRelativePathFromTo(parentNode, value); if (null != newPath) { InternalDocumentPath = newPath; // especially in dispose situations, the new path can be null. In this case we leave the path as it was } _docNodeRef = new WeakReference(value); #if DEBUG_DOCNODEPROXYLOGGING Current.Console.WriteLine("RelDocNodeProxy.SetDocNode, path is <<{0}>>", _docNodePath); #endif value.TunneledEvent += (_weakDocNodeTunneledEventHandler = new WeakActionHandler <object, object, TunnelingEventArgs>(EhDocNode_TunneledEvent, handler => value.TunneledEvent -= handler)); if (null != _docNodePath && !_docNodePath.IsIdentity) // it does not make sense to watch the changed event of our target node is our parent because the parent can handle the Changed event itself { value.Changed += (_weakDocNodeChangedHandler = new WeakEventHandler(EhDocNode_Changed, handler => value.Changed -= handler)); } OnAfterSetDocNode(); EhSelfChanged(new Main.InstanceChangedEventArgs(oldValue, value)); }
/// <summary> /// Event handler that is called when the watched node or a parent node below has disposed or its name changed. We then try to resolve the path again. /// </summary> /// <param name="sender"></param> /// <param name="source">Source of the tunneled event.</param> /// <param name="e"></param> private void EhWatchedNode_TunneledEvent(object sender, object source, Main.TunnelingEventArgs e) { if (IsDisposeInProgress) { return; } if (!(_docNodeRef == null)) { throw new InvalidProgramException(); } var senderAsDocNode = sender as IDocumentLeafNode; var sourceAsDocNode = source as IDocumentLeafNode; if (!(senderAsDocNode != null)) { throw new InvalidProgramException(); } if (!(sourceAsDocNode != null)) { throw new InvalidProgramException(); } // then we try to resolve the path again if ((e is DisposeEventArgs) || (e is DocumentPathChangedEventArgs)) { #if DEBUG_DOCNODEPROXYLOGGING Current.Console.WriteLine("DocNodeProxy.EhWatchedNode_TunneledEvent"); #endif var node = RelativeDocumentPath.GetNodeOrLeastResolveableNode(_docNodePath, sourceAsDocNode, out var wasResolvedCompletely); if (null == node) { throw new InvalidProgramException(nameof(node) + " should always be != null, since we use absolute paths, and at least an AltaxoDocument should be resolved here."); } if (wasResolvedCompletely) { ClearWatch(); InternalSetDocNode(node, _parent); } else // not completely resolved { if (!object.ReferenceEquals(sender, node)) { ClearWatch(); SetWatchOnNode(node); } } } }
public override void EhParentTunnelingEventHappened(IDocumentNode sender, IDocumentNode originalSource, TunnelingEventArgs e) { // since we deal with relative path, we have to watch changes to our path too if (e is Main.DocumentPathChangedEventArgs) { var node = InternalDocNode; if (null != node) { _docNodePath = RelativeDocumentPath.GetRelativePathFromTo(_parent, node); } } base.EhParentTunnelingEventHappened(sender, originalSource, e); }
/// <summary> /// Event handler that is called when the document node has changed. Because the path to the node can have changed too, /// the path is renewed in this case. The <see cref="OnChanged" /> method is called then for the proxy itself. /// </summary> /// <param name="sender"></param> /// <param name="e"></param> private void EhDocNode_Changed(object sender, EventArgs e) { if (IsDisposeInProgress) { return; } #if DEBUG_DOCNODEPROXYLOGGING Current.Console.WriteLine("DocNodeProxy.EhDocNode_Changed: sender={0}, e={1}", sender, e); #endif if (null != InternalDocNode) { _docNodePath = RelativeDocumentPath.GetRelativePathFromTo(_parent, InternalDocNode); } EhSelfChanged(EventArgs.Empty); }
/// <summary> /// Gets the node that is designated by the provided <paramref name="path"/> or the least resolveable node. /// </summary> /// <param name="path">The document path to resolve.</param> /// <param name="startnode">The startnode.</param> /// <param name="pathWasCompletelyResolved">If set to <c>true</c> on return, the path was completely resolved. Otherwise, <c>false</c>.</param> /// <returns>The resolved node, or the least node on the path that could be resolved.</returns> /// <exception cref="System.ArgumentNullException"> /// path /// or /// startnode /// </exception> public static IDocumentLeafNode GetNodeOrLeastResolveableNode(RelativeDocumentPath path, IDocumentLeafNode startnode, out bool pathWasCompletelyResolved) { if (null == path) { throw new ArgumentNullException(nameof(path)); } if (null == startnode) { throw new ArgumentNullException(nameof(startnode)); } var node = startnode; var prevNode = startnode; for (int i = 0; i < path._numberOfLevelsDown && null != node; ++i) { prevNode = node; node = node.ParentNode; } if (null == node) { pathWasCompletelyResolved = false; return(prevNode); } pathWasCompletelyResolved = true; for (int i = 0; i < path._pathParts.Length && null != node; i++) { prevNode = node; if (node is Main.IDocumentNode) { node = ((Main.IDocumentNode)node).GetChildObjectNamed(path._pathParts[i]); } else { node = null; } } // end for pathWasCompletelyResolved = null != node; return(node ?? prevNode); }
/// <summary> /// Event handler that is called when the watched node (a node that is not the document node) has changed. Maybe this watched node had now created a parent node, and our /// document path can resolved now. That's why we try to resolve our document path now. /// </summary> /// <param name="sender"></param> /// <param name="e"></param> private void EhWatchedNode_Changed(object sender, EventArgs e) { if (IsDisposeInProgress) { return; } #if DEBUG_DOCNODEPROXYLOGGING Current.Console.WriteLine("DocNodeProxy.EhWatchedNode_Changed: sender={0}, e={1}", sender, e); #endif if (!(_docNodeRef == null)) { throw new InvalidProgramException(); } var senderAsDocNode = sender as IDocumentLeafNode; if (!(senderAsDocNode != null)) { throw new InvalidProgramException(); } var node = RelativeDocumentPath.GetNodeOrLeastResolveableNode(_docNodePath, senderAsDocNode, out var wasResolvedCompletely); if (null == node) { throw new InvalidProgramException("node should always be != null, since we use absolute paths, and at least an AltaxoDocument should be resolved here."); } if (wasResolvedCompletely) { ClearWatch(); InternalSetDocNode(node, _parent); } else // not completely resolved { if (!object.ReferenceEquals(sender, node)) { ClearWatch(); SetWatchOnNode(node); } } }
public static IDocumentLeafNode GetObject(RelativeDocumentPath path, IDocumentLeafNode startnode) { if (null == path) { throw new ArgumentNullException(nameof(path)); } if (null == startnode) { throw new ArgumentNullException(nameof(startnode)); } var node = startnode; for (int i = 0; i < path._numberOfLevelsDown && null != node; ++i) { node = node.ParentNode; } if (null == node) { return(null); // Path not resolveable } for (int i = 0; i < path._pathParts.Length; i++) { if (node is Main.IDocumentNode) { node = ((Main.IDocumentNode)node).GetChildObjectNamed(path._pathParts[i]); } else { return(null); } } // end for return(node); }
public RelativeDocumentPath(RelativeDocumentPath from) : this(from._numberOfLevelsDown, from._pathParts) { }
public RelativeDocumentPath(RelativeDocumentPath from) : this(from._numberOfLevelsDown, from._pathParts) { }
/// <summary> /// Gets the node that is designated by the provided <paramref name="path"/> or the least resolveable node. /// </summary> /// <param name="path">The document path to resolve.</param> /// <param name="startnode">The startnode.</param> /// <param name="pathWasCompletelyResolved">If set to <c>true</c> on return, the path was completely resolved. Otherwise, <c>false</c>.</param> /// <returns>The resolved node, or the least node on the path that could be resolved.</returns> /// <exception cref="System.ArgumentNullException"> /// path /// or /// startnode /// </exception> public static IDocumentLeafNode GetNodeOrLeastResolveableNode(RelativeDocumentPath path, IDocumentLeafNode startnode, out bool pathWasCompletelyResolved) { if (null == path) throw new ArgumentNullException(nameof(path)); if (null == startnode) throw new ArgumentNullException(nameof(startnode)); var node = startnode; var prevNode = startnode; for (int i = 0; i < path._numberOfLevelsDown && null != node; ++i) { prevNode = node; node = node.ParentNode; } if (null == node) { pathWasCompletelyResolved = false; return prevNode; } pathWasCompletelyResolved = true; for (int i = 0; i < path._pathParts.Length && null != node; i++) { prevNode = node; if (node is Main.IDocumentNode) node = ((Main.IDocumentNode)node).GetChildObjectNamed(path._pathParts[i]); else node = null; } // end for pathWasCompletelyResolved = null != node; return node ?? prevNode; }
public static IDocumentLeafNode GetObject(RelativeDocumentPath path, IDocumentLeafNode startnode) { if (null == path) throw new ArgumentNullException(nameof(path)); if (null == startnode) throw new ArgumentNullException(nameof(startnode)); var node = startnode; for (int i = 0; i < path._numberOfLevelsDown && null != node; ++i) { node = node.ParentNode; } if (null == node) return null; // Path not resolveable for (int i = 0; i < path._pathParts.Length; i++) { if (node is Main.IDocumentNode) node = ((Main.IDocumentNode)node).GetChildObjectNamed(path._pathParts[i]); else return null; } // end for return node; }
/// <summary> /// Event handler that is called when the document node has disposed or name changed. Because the path to the node can have changed too, /// the path is renewed in this case. The <see cref="OnChanged" /> method is called then for the proxy itself. /// </summary> /// <param name="sender"></param> /// <param name="source"></param> /// <param name="e"></param> private void EhDocNode_TunneledEvent(object sender, object source, Main.TunnelingEventArgs e) { if (IsDisposeInProgress) return; #if DEBUG_DOCNODEPROXYLOGGING Current.Console.WriteLine("RelDocNodeProxy.EhDocNode_TunneledEvent: sender={0}, source={1} e={2}", sender, source, e); #endif bool shouldFireChangedEvent = false; var senderAsNode = source as IDocumentLeafNode; if (!(senderAsNode != null)) throw new InvalidProgramException(); if (e is DisposeEventArgs) { // when our DocNode was disposed, it is probable that the parent of this node (and further parents) are disposed too // thus we need to watch the first node that is not disposed var docNode = InternalDocNode; ClearDocNode(); if (!(sender is AltaxoDocument)) // if the whole document is disposed, there is no point in trying to watch something { // note Dispose is designed to let the hierarchy from child to parent (root) valid, but not from root to child! // thus trying to get an actual document path here is in must cases unsuccessfull. We have to rely on our stored path, and that it was always updated! // the only case were it is successfull if a new node immediately replaces an old document node bool wasResolvedCompletely; var node = RelativeDocumentPath.GetNodeOrLeastResolveableNode(_docNodePath, senderAsNode, out wasResolvedCompletely); if (wasResolvedCompletely) { InternalSetDocNode(node, _parent); } else { SetWatchOnNode(node); } shouldFireChangedEvent = true; } } else if (e is DocumentPathChangedEventArgs) { if (null != InternalDocNode) { InternalDocumentPath = RelativeDocumentPath.GetRelativePathFromTo(_parent, InternalDocNode); } shouldFireChangedEvent = true; } if (shouldFireChangedEvent) EhSelfChanged(EventArgs.Empty); }