public RelDocNodeProxy(Main.IDocumentLeafNode docNode, Main.IDocumentNode parentNode) { if (null == docNode) { throw new ArgumentNullException(nameof(docNode)); } if (null == parentNode) { throw new ArgumentNullException(nameof(parentNode)); } var docNodeRoot = Main.AbsoluteDocumentPath.GetRootNode(docNode); var parentNodeRoot = Main.AbsoluteDocumentPath.GetRootNode(parentNode); if (!object.ReferenceEquals(docNodeRoot, parentNodeRoot)) { throw new ArgumentException(string.Format("parentNode (type: {0}) and docNode (type: {1}) have no common root. This suggests that one of the items is not rooted. Please report this error! The type of the parent node's root is {2}. The type of the docNode's root is {3}.", parentNode.GetType(), docNode.GetType(), parentNodeRoot.GetType(), docNodeRoot.GetType())); } InternalSetDocNode(docNode, parentNode); if (!(_docNodePath != null)) { throw new InvalidProgramException(); // because we tested above that both nodes have a common root } _parent = parentNode; }
/// <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)); }
public override string GetNameOfChildObject(Main.IDocumentLeafNode obj) { if (obj is TItem item) { if (_itemsByName.ContainsKey(item.Name)) { return(item.Name); } } return(null); }
public override string GetNameOfChildObject(Main.IDocumentLeafNode o) { if (o is DataTable) { var gr = (DataTable)o; if (_itemsByName.ContainsKey(gr.Name)) { return(gr.Name); } } return(null); }
public override string GetNameOfChildObject(Main.IDocumentLeafNode o) { var layout = o as WorksheetLayout; if (layout == null) { return(null); } if (null == this[layout.Guid]) { return(null); // is not contained in this collection } return(layout.Guid.ToString()); }
protected virtual IDocumentLeafNode ResolveDocumentObject(Main.IDocumentLeafNode startnode) { if (IsDisposeInProgress) { return(null); } if (!(_docNodePath != null || IsDisposeInProgress)) { throw new InvalidProgramException(); } var docNode = InternalDocumentNode; if (docNode == null) { #if DEBUG_DOCNODEPROXYLOGGING Current.Console.WriteLine("DocNodeProxy.ResolveDocumentObject, path is <<{0}>>", _docNodePath); #endif #if DOCNODEPROXY_CONCURRENTDEBUG _debug.Enqueue("START ResolveDocumentObject"); #endif var node = Main.AbsoluteDocumentPath.GetNodeOrLeastResolveableNode(_docNodePath, startnode, out var wasCompletelyResolved); 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 (wasCompletelyResolved) { SetDocNode(node); docNode = InternalDocumentNode; } else // not completely resolved { SetWatchOnNode(node); } #if DOCNODEPROXY_CONCURRENTDEBUG _debug.Enqueue("STOP ResolveDocumentObject"); #endif } return(docNode); }
/// <summary> /// Gets the parent GraphDocumentCollection of a child graph. /// </summary> /// <param name="child">A graph for which the parent collection is searched.</param> /// <returns>The parent GraphDocumentCollection, if it exists, or null otherwise.</returns> public static GraphDocumentCollection GetParentGraphDocumentCollectionOf(Main.IDocumentLeafNode child) { return((GraphDocumentCollection)Main.AbsoluteDocumentPath.GetRootNodeImplementing(child, typeof(GraphDocumentCollection))); }
/// <summary> /// Gets the parent DataTableCollection of a child table, a child ColumnCollection, or a child column. /// </summary> /// <param name="child">Can be a DataTable, a DataColumnCollection, or a DataColumn for which the parent table collection is searched.</param> /// <returns>The parent DataTableCollection, if it exists, or null otherwise.</returns> public static Altaxo.Data.DataTableCollection GetParentDataTableCollectionOf(Main.IDocumentLeafNode child) { return((DataTableCollection)Main.AbsoluteDocumentPath.GetRootNodeImplementing(child, typeof(DataTableCollection))); }
/// <summary> /// Gets the parent ProjectFolderPropertyBagCollection of a child graph. /// </summary> /// <param name="child">A graph for which the parent collection is searched.</param> /// <returns>The parent ProjectFolderPropertyBagCollection, if it exists, or null otherwise.</returns> public static ProjectFolderPropertyDocumentCollection GetParentProjectFolderPropertyBagCollectionOf(Main.IDocumentLeafNode child) { return((ProjectFolderPropertyDocumentCollection)Main.AbsoluteDocumentPath.GetRootNodeImplementing(child, typeof(ProjectFolderPropertyDocumentCollection))); }