public override Object GetAspect(Object rowObject) { LayerTreeNode layerTreeNode = rowObject as LayerTreeNode; if (layerTreeNode != null) { IILayer layer = MaxAnimatable.GetAnimByHandle(layerTreeNode.Handle) as IILayer; if (layer != null) { IILayerProperties layerProps = MaxLayers.GetLayerProperties(layer); return(layerProps.Current); } } FolderTreeNode folderTreeNode = rowObject as FolderTreeNode; if (folderTreeNode != null) { // Default behaviour of getFolderCheckState returns true. // Only get folder check state if necessary as it is // more expensive than returning false. if (folderTreeNode.Children.Count > 0) { Boolean?checkState = getFolderCheckState(folderTreeNode); if (checkState == true || checkState == null) { return(null); } } } return(false); }
public override Object GetMaxValue(BaseTreeNode treeNode) { ObjectTreeNode objectTreeNode = treeNode as ObjectTreeNode; if (objectTreeNode != null) { IINode maxNode = MaxAnimatable.GetAnimByHandle(objectTreeNode.Handle) as IINode; if (maxNode != null) { return(maxNode.BoxMode_ < 0); } } LayerTreeNode layerTreeNode = treeNode as LayerTreeNode; if (layerTreeNode != null) { IILayer maxLayer = MaxAnimatable.GetAnimByHandle(layerTreeNode.Handle) as IILayer; #if Max2013 || Max2014 if (maxLayer != null) { return(!maxLayer.BoxMode); } #endif #if Max2015 if (maxLayer != null) { return(!maxLayer.BoxMode_); } #endif } return(false); }
public override void PutMaxValue(BaseTreeNode treeNode, Object newValue) { LayerTreeNode layerTreeNode = treeNode as LayerTreeNode; if (layerTreeNode != null) { IILayer maxLayer = MaxAnimatable.GetAnimByHandle(layerTreeNode.Handle) as IILayer; #if Max2013 || Max2014 if (maxLayer != null) { maxLayer.BoxMode = !(Boolean)newValue; } #endif #if Max2015 if (maxLayer != null) { maxLayer.BoxMode(!(Boolean)newValue, false); } #endif return; } ObjectTreeNode objectTreeNode = treeNode as ObjectTreeNode; if (objectTreeNode != null) { IINode maxNode = MaxAnimatable.GetAnimByHandle(objectTreeNode.Handle) as IINode; if (maxNode != null) { maxNode.BoxMode(!(Boolean)newValue); } return; } }
// The first layer of the tree must have been manually filled out // for this to work. private void FillOutTree(List <List <TreeNode <MapTreeItem> > > treeLayers) { foreach (List <TreeNode <MapTreeItem> > layer in treeLayers) { foreach (TreeNode <MapTreeItem> parentNode in layer) { for (int i = 0; i < parentNode.GetNumChildren(); i++) { MapTreeItem childItem = parentNode.GetChild(i).mItem; // Create the map node's branch list childItem.mTreeBranches = new List <GameObject>(); // Put object into its parent's twig. childItem.mTreeTwig = parentNode.mItem.mChildLayerTreeNode.mObject; childItem.mTreeUIItem.transform.SetParent(childItem.mTreeTwig.transform, false); // Start moving back up the layer tree, assigning the helper objects of the map node. LayerTreeNode layerTreeNodeParent = parentNode.mItem.mChildLayerTreeNode.mParent; while (layerTreeNodeParent.mParent == null) { childItem.mTreeBranches.Add(layerTreeNodeParent.mObject); layerTreeNodeParent = layerTreeNodeParent.mParent; } // The last object in the layer tree (which has no parent) // is the layer object itself. childItem.mTreeLayer = layerTreeNodeParent.mObject; } } } }
public override Object GetAspect(Object rowObject) { FolderTreeNode folderTreeNode = rowObject as FolderTreeNode; if (folderTreeNode != null) { return(folderTreeNode.Name); } LayerTreeNode layerTreeNode = rowObject as LayerTreeNode; if (layerTreeNode != null) { IILayer layer = MaxAnimatable.GetAnimByHandle(layerTreeNode.Handle) as IILayer; if (layer != null) { return(layer.Name); } } ObjectTreeNode objectTreeNode = rowObject as ObjectTreeNode; if (objectTreeNode != null) { IINode maxNode = MaxAnimatable.GetAnimByHandle(objectTreeNode.Handle) as IINode; if (maxNode != null) { return(maxNode.Name); } } return(null); }
public void BuildLayerAndObjectNodes(List <BaseTreeNode> treeNodeList, IEnumerable <IILayer> layers, Hashtable folderNodeIdMap) { foreach (IILayer layer in layers) { UIntPtr handle = MaxAnimatable.GetHandleByAnim(layer); LayerData layerNodeData = MaxIO.LoadLayerData(layer); // If layer has node data, create treeNode based on that. // If not, create a new treeNode and append to root. LayerTreeNode layerTreeNode; if (layerNodeData == null) { layerTreeNode = new LayerTreeNode(handle, HandleMap); BuildChildObjects(layerTreeNode, layer); treeNodeList.Add(layerTreeNode); } else { List <Guid> layerTreeNodeParentIDs = layerNodeData.ParentIDs; foreach (Guid layerTreeNodeParentID in layerTreeNodeParentIDs) { // If the handle already exists it is an instance. // Populate the instance properties on all layers with that handle. if (HandleMap.ContainsHandle(handle)) { layerTreeNode = new LayerTreeNode(layerNodeData, handle, HandleMap); } else { layerTreeNode = new LayerTreeNode(layerNodeData, handle, HandleMap); } // If folderNodeData does not have a parent ID, // it should be appended as a root node. if (layerTreeNodeParentID == Guid.Empty) { treeNodeList.Add(layerTreeNode); } // If not, it should be parented to an existing treeNode, // as long as it exists. else { FolderTreeNode parent = folderNodeIdMap[layerTreeNodeParentID] as FolderTreeNode; if (parent == null) { treeNodeList.Add(layerTreeNode); } else { layerTreeNode.Parent = parent; parent.Children.Add(layerTreeNode); } } // Add objects to layer. BuildChildObjects(layerTreeNode, layer); } } } }
/// <summary> /// Deletes the selected treenodes, but does not delete associated max nodes. /// All children need to be provided, otherwise the child nodes will not be removed from the HandleMap. /// </summary> /// <param name="treeNodes"></param> public void DeleteTreeNodes(IEnumerable <BaseTreeNode> treeNodes) { #if DEBUG System.Diagnostics.Stopwatch stopwatch = new System.Diagnostics.Stopwatch(); stopwatch.Start(); #endif List <BaseTreeNode> rootNodes = new List <BaseTreeNode>(); HashSet <BaseTreeNode> refreshNodes = new HashSet <BaseTreeNode>(); // Delete nodes in NLM foreach (BaseTreeNode treeNode in treeNodes) { // Instead of removing each branch node independently, append to array. // We can then remove them all at the same time, which is way quicker. if (treeNode.Parent == null) { rootNodes.Add(treeNode); } else { treeNode.Parent.Children.Remove(treeNode); // Instead of refreshing each node independently, append to array. // We can then refresh all objects at the same time which is way quicker. if (!refreshNodes.Contains(treeNode.Parent) && !treeNodes.Any(x => treeNode.IsAncestor(x))) { refreshNodes.Add(treeNode.Parent); } treeNode.Parent = null; } // Remove anim handle / treenode link from map. // Note: // Using if (x is y) is creating a cast, which is doubling the casting. // Instead, casting once and checking for null is used. // Continue is used to avoid unnecessary casting. ObjectTreeNode objectTreeNode = treeNode as ObjectTreeNode; if (objectTreeNode != null) { HandleMap.RemoveTreeNodeFromHandle(objectTreeNode, objectTreeNode.Handle); continue; } LayerTreeNode layerTreeNode = treeNode as LayerTreeNode; if (layerTreeNode != null) { HandleMap.RemoveTreeNodeFromHandle(layerTreeNode, layerTreeNode.Handle); continue; } } // Work through the appended arrays and remove / refresh. ListView.RemoveObjects(rootNodes); ListView.RefreshObjects(refreshNodes.ToList()); #if DEBUG stopwatch.Stop(); MaxListener.PrintToListener("DeleteTreeNodes completed in: " + stopwatch.ElapsedMilliseconds); #endif }
private static void onCreateLayer(Object sender, ClickEventArgs e, Boolean addSelection) { NlmTreeListView listView = e.ListView; listView.NodeControl.MaxEvents.LayerEvents.LayerCreated.UnregisterNotification(); IILayer layer = MaxLayers.CreateLayer(true, addSelection); UIntPtr handle = MaxAnimatable.GetHandleByAnim(layer); LayerTreeNode layerTreeNode = new LayerTreeNode(handle, listView.NodeControl.HandleMap); // Get parent node. BaseTreeNode parentTreeNode = null; if (listView.SelectedObjects.Count > 0) { BaseTreeNode treeNode = listView.SelectedObjects[0] as BaseTreeNode; if (treeNode is FolderTreeNode) { parentTreeNode = treeNode; } if (treeNode is LayerTreeNode) { parentTreeNode = treeNode.Parent; } } // Add folder to listview, ensure is visible by expanding parents. listView.AddObject(layerTreeNode, parentTreeNode); if (parentTreeNode != null) { listView.Expand(parentTreeNode); } // Scroll to new item. Int32 parentIndex = listView.IndexOf(layerTreeNode); if (parentIndex != -1) { listView.EnsureVisible(parentIndex); } // Sort, select listView.Sort(listView.NlmColumns.NameColumn, SortOrder.Ascending); listView.SelectedObjects = new List <Object> { layerTreeNode }; // Focus on the listview to ensure text entry goes to the edit box, and begin edit. listView.Focus(); listView.EditModel(layerTreeNode); // Register notification. listView.NodeControl.MaxEvents.LayerEvents.LayerCreated.RegisterNotification(); }
private void BuildChildObjects(LayerTreeNode layerTreeNode, IILayer maxLayer) { IEnumerable <IINode> layerNodes = MaxLayers.GetChildNodes(maxLayer); foreach (IINode maxNode in layerNodes) { UIntPtr iNodeHandle = MaxAnimatable.GetHandleByAnim(maxNode); ObjectTreeNode objectTreeNode = new ObjectTreeNode(MaxNodes.GetObjectClass(maxNode), iNodeHandle, HandleMap); ListView.NodeControl.Parent.AddChild(objectTreeNode, layerTreeNode, false); } }
public override Boolean Filter(Object treeNode) { LayerTreeNode layerTreeNode = treeNode as LayerTreeNode; if (layerTreeNode != null) { if (layerTreeNode.Visible == false) { return(false); } } return(true); }
public override void PutAspect(Object rowObject, Object newValue) { LayerTreeNode layerTreeNode = rowObject as LayerTreeNode; if (layerTreeNode != null) { IILayer layer = MaxAnimatable.GetAnimByHandle(layerTreeNode.Handle) as IILayer; if (layer != null) { IILayerProperties layerProps = MaxLayers.GetLayerProperties(layer); layerProps.Current = (Boolean)newValue; } } }
private static void SaveParentFolderData(LayerTreeNode layerTreeNode, IAnimatable layerAnim, NlmTreeListView owner) { if (layerTreeNode.Parent != null) { List <FolderData> folderData = new List <FolderData>(); FolderTreeNode parent = layerTreeNode.Parent as FolderTreeNode; while (parent != null) { folderData.Add(new FolderData(parent, owner)); parent = parent.Parent as FolderTreeNode; } SetAppData(layerAnim, DataAddress.FolderData, folderData); } }
void foreachLayer(LayerTreeNode modelLayer, ModelLayerSetting modelLayerSetting, bool value)//循环设置 { if (modelLayerSetting == ModelLayerSetting.Visibility) { modelLayer.Visibility = value; } else { modelLayer.Transparent = value; } foreach (var item in modelLayer.childNodes) { foreachLayer(item, modelLayerSetting, value); } }
private void onLayerCreated(Object sender, SystemNotificationAnimEventArgs e) { #if DEBUG MaxListener.PrintToListener("onLayerCreated"); #endif List <LayerTreeNode> createdNodes = new List <LayerTreeNode>(); foreach (UIntPtr handle in e.Handles) { // TODO: Add handlemap ref to this class. // LayerTreeNode newNode = NodeControl.Create.CreateTreeNode(NlmTreeNode.NodeClass.Layer, handle); LayerTreeNode newNode = new LayerTreeNode(handle, NodeControl.HandleMap); createdNodes.Add(newNode); } ListView.AddObjects(createdNodes); ListView.Sort(ListView.NlmColumns.NameColumn, SortOrder.Ascending); }
public static void onAddSelectedObjectsToLayer(Object sender, ClickEventArgs e) { // TODO: // This is quite slow compared to the NodeEventCallback LayerChanged. Look at that for tips. // Do we really need BeginUpdate and EndUpdate? Calculate which objects to refresh. // Also fix crappy bug where adding children to an expanded layer does not redraw properly. NlmTreeListView listView = e.ListView; try { listView.BeginUpdate(); IList selection = listView.SelectedObjects; if (selection.Count == 1) { LayerTreeNode layerTreeNode = selection[0] as LayerTreeNode; if (layerTreeNode != null) { List <BaseTreeNode> moveTreeNodes = new List <BaseTreeNode>(); IAnimatable layerAnim = MaxAnimatable.GetAnimByHandle(layerTreeNode.Handle); foreach (IINode maxNode in MaxNodes.SelectedNodes) { UIntPtr maxNodeHandle = MaxAnimatable.GetHandleByAnim(maxNode as IAnimatable); List <BaseTreeNode> treeNodes = listView.NodeControl.HandleMap.GetTreeNodesByHandle(maxNodeHandle); foreach (BaseTreeNode treeNode in treeNodes) { moveTreeNodes.Add(treeNode); } MaxNodes.MoveNodeToLayer(maxNode, layerAnim as IILayer); } listView.NodeControl.Parent.MoveTreeNodes(moveTreeNodes, layerTreeNode); } } listView.Sort(listView.NlmColumns.NameColumn, SortOrder.Ascending); } catch { throw new Exception(); } finally { e.ListView.EndUpdate(); } }
public static void onInstanceSelectedLayers(Object sender, ClickEventArgs e) { NlmTreeListView listView = e.ListView; // Multiple items are being added, so let's use BeginUpdate. try { listView.BeginUpdate(); foreach (BaseTreeNode treeNode in listView.SelectedObjects) { LayerTreeNode layerTreeNode = treeNode as LayerTreeNode; if (layerTreeNode != null) { LayerTreeNode newLayerTreeNode = new LayerTreeNode(layerTreeNode.Handle, listView.NodeControl.HandleMap); foreach (ObjectTreeNode objectTreeNode in treeNode.Children) { ObjectTreeNode newObjectTreeNode = new ObjectTreeNode(objectTreeNode.Class, objectTreeNode.Handle, listView.NodeControl.HandleMap); newObjectTreeNode.Parent = newLayerTreeNode; newLayerTreeNode.Children.Add(newObjectTreeNode); } //foreach (LayerTreeNode instanceNode in layerTreeNode.Instances) //{ // instanceNode.Instances.Add(newLayerTreeNode); // newLayerTreeNode.Instances.Add(instanceNode); //} //layerTreeNode.Instances.Add(newLayerTreeNode); //newLayerTreeNode.Instances.Add(layerTreeNode); listView.AddObject(newLayerTreeNode, treeNode.Parent); } } listView.Sort(listView.NlmColumns.NameColumn, SortOrder.Ascending); } catch { throw new Exception(); } finally { listView.EndUpdate(); } }
private void TraverseNode(int currentDepth, int maxDepth, TreeNode <LayerTreeNode> prevLayerTreeNode, TreeNode <MapTreeItem> mapTreeNode, bool isOnlyChild) { bool isLastLayer = currentDepth == maxDepth; TreeNode <LayerTreeNode> newNode; // If an only child then we avoid new nodes // as we would only add a redudant branch in that case // (ie. a branch containing only one branch). if (isLastLayer || !isOnlyChild) { LayerTreeNode newLayerNode = new LayerTreeNode(); newLayerNode.mParent = prevLayerTreeNode.mItem; newNode = prevLayerTreeNode.AddChild(newLayerNode); } else { newNode = prevLayerTreeNode; } if (isLastLayer) { newNode.mItem.mObject = GameObject.Instantiate(MapTreeTwigPrefab); mapTreeNode.mItem.mChildLayerTreeNode = newNode.mItem; } else { if (!isOnlyChild) { newNode.mItem.mObject = GameObject.Instantiate(MapTreeBranchPrefab); } int numChildren = mapTreeNode.GetNumChildren(); for (int i = 0; i < numChildren; i++) { TraverseNode(currentDepth + 1, maxDepth, newNode, mapTreeNode.GetChild(i), numChildren == 1); } } newNode.mItem.mObject.transform.SetParent(newNode.mItem.mParent.mObject.transform, false); return; }
public override void PutAspect(Object rowObject, Object newValue) { FolderTreeNode folderTreeNode = rowObject as FolderTreeNode; if (folderTreeNode != null) { folderTreeNode.Name = newValue as String; return; } LayerTreeNode layerTreeNode = rowObject as LayerTreeNode; if (layerTreeNode != null) { IILayer maxLayer = MaxAnimatable.GetAnimByHandle(layerTreeNode.Handle) as IILayer; #if Max2013 || Max2014 String newString = newValue as String; if (maxLayer != null) { maxLayer.SetName(ref newString); } #endif #if Max2015 if (maxLayer != null) { maxLayer.Name = (newValue as String); } #endif return; } ObjectTreeNode objectTreeNode = rowObject as ObjectTreeNode; if (objectTreeNode != null) { IINode maxNode = MaxAnimatable.GetAnimByHandle(objectTreeNode.Handle) as IINode; if (maxNode != null) { maxNode.Name = newValue as String; } return; } }
private TreeNode <LayerTreeNode> BuildLayerTree(TreeNode <MapTreeItem> sourceTree, int forLayer) { // Set up layer tree root with first layer and branch TreeNode <LayerTreeNode> returnTreeRoot = new TreeNode <LayerTreeNode>(); returnTreeRoot.mItem = new LayerTreeNode(); returnTreeRoot.mItem.mObject = GameObject.Instantiate(MapTreeLayerPrefab); LayerTreeNode firstBranch = new LayerTreeNode(); firstBranch.mObject = GameObject.Instantiate(MapTreeBranchPrefab); firstBranch.mParent = returnTreeRoot.mItem; firstBranch.mObject.transform.SetParent(returnTreeRoot.mItem.mObject.transform, false); returnTreeRoot.AddChild(firstBranch); // TODO - Better place/way for this? if (forLayer == 0) { // Set up root node's twig TreeNode <LayerTreeNode> firstBranchTreeNode = returnTreeRoot.GetChild(0); TreeNode <LayerTreeNode> firstTwigTreeNode = firstBranchTreeNode.AddChild(new LayerTreeNode()); firstTwigTreeNode.mItem.mObject = GameObject.Instantiate(MapTreeTwigPrefab); firstTwigTreeNode.mItem.mObject.transform.SetParent(firstBranch.mObject.transform, false); firstTwigTreeNode.mItem.mParent = firstBranch; // Set up root node's map item sourceTree.mItem.mTreeUIItem.transform.SetParent(firstTwigTreeNode.mItem.mObject.transform, false); // Assign root node's helper references sourceTree.mItem.mTreeLayer = returnTreeRoot.mItem.mObject; sourceTree.mItem.mTreeBranches = new List <GameObject>(); sourceTree.mItem.mTreeBranches.Add(firstBranch.mObject); sourceTree.mItem.mTreeTwig = firstTwigTreeNode.mItem.mObject; } else { TraverseNode(0, forLayer - 1, returnTreeRoot.GetChild(0), sourceTree, true); } return(returnTreeRoot); }
public LayerData(LayerTreeNode treeNode, NlmTreeListView listView, HandleMap handleMap) { ParentIDs = new List <Guid>(); // Node Properties ID = treeNode.ID; if (treeNode.Parent == null) { ParentIDs.Add(new Guid()); } else { ParentIDs.Add(treeNode.Parent.ID); } foreach (LayerTreeNode instanceParent in handleMap.GetTreeNodesByHandle(treeNode.Handle)) { if (instanceParent != treeNode) { if (instanceParent.Parent == null) { ParentIDs.Add(new Guid()); } else { ParentIDs.Add(instanceParent.Parent.ID); } } } // Column Properties Visible = treeNode.Visible; Freeze = treeNode.Freeze; Render = treeNode.Render; Box = treeNode.Box; Expanded = listView.IsExpanded(treeNode); }
public override Object GetAspect(Object rowObject) { LayerTreeNode layerTreeNode = rowObject as LayerTreeNode; if (layerTreeNode != null) { IILayer maxLayer = MaxAnimatable.GetAnimByHandle(layerTreeNode.Handle) as IILayer; if (maxLayer != null) { // Erm, looks like max has BGR, not RGB. // Because of this, swap B and R to display properly in renderer. Color bgr = maxLayer.WireColor; return(Color.FromArgb(bgr.B, bgr.G, bgr.R)); } } ObjectTreeNode objectTreeNode = rowObject as ObjectTreeNode; if (objectTreeNode != null) { IINode maxNode = MaxAnimatable.GetAnimByHandle(objectTreeNode.Handle) as IINode; if (maxNode != null) { // Erm, looks like max has BGR, not RGB. // Because of this, swap B and R to display properly in renderer. Color bgr = maxNode.WireColor; return(Color.FromArgb(bgr.B, bgr.G, bgr.R)); } } FolderTreeNode folderTreeNode = rowObject as FolderTreeNode; if (folderTreeNode != null) { return(folderTreeNode.Color); } return(null); }
public NameColumn(NlmTreeListView listView) { Text = "Name"; IsEditable = true; Searchable = true; FillsFreeSpace = true; ImageGetter = delegate(Object rowObject) { LayerTreeNode layerTreeNode = rowObject as LayerTreeNode; if (layerTreeNode != null) { if (layerTreeNode.IsInstanced) { return("LayerInstance"); } else { return("Layer"); } } ObjectTreeNode objectTreeNode = rowObject as ObjectTreeNode; if (objectTreeNode != null) { return(objectTreeNode.Class.ToString()); } if (rowObject is FolderTreeNode) { return("Folder"); } return(null); }; AspectEngine = new NameAspectEngine(listView, this); Renderer = new NlmTreeColumnRenderer(); }
public override Object GetMaxValue(BaseTreeNode treeNode) { LayerTreeNode layerTreeNode = treeNode as LayerTreeNode; if (layerTreeNode != null) { IILayer layer = MaxAnimatable.GetAnimByHandle(layerTreeNode.Handle) as IILayer; if (layer != null) { return(!layer.IsHidden); } } ObjectTreeNode objectTreeNode = treeNode as ObjectTreeNode; if (objectTreeNode != null) { IINode maxNode = MaxAnimatable.GetAnimByHandle(objectTreeNode.Handle) as IINode; if (maxNode != null) { return(!maxNode.IsObjectHidden); } } return(false); }
public override void PutAspect(Object rowObject, Object newValue) { FolderTreeNode folderTreeNode = rowObject as FolderTreeNode; if (folderTreeNode != null) { folderTreeNode.Color = (Color)newValue; return; } LayerTreeNode layerTreeNode = rowObject as LayerTreeNode; if (layerTreeNode != null) { IILayer maxLayer = MaxAnimatable.GetAnimByHandle(layerTreeNode.Handle) as IILayer; if (maxLayer != null) { #if Max2013 || Max2014 maxLayer.WireColor = (Color)newValue; #endif #if Max2015 maxLayer.SetWireColor((Color)newValue, false); #endif } return; } ObjectTreeNode objectTreeNode = rowObject as ObjectTreeNode; if (objectTreeNode != null) { IINode maxNode = MaxAnimatable.GetAnimByHandle(objectTreeNode.Handle) as IINode; if (maxNode != null) { maxNode.WireColor = (Color)newValue; } return; } }
public override Object GetMaxValue(BaseTreeNode treeNode) { ObjectTreeNode objectTreeNode = treeNode as ObjectTreeNode; if (objectTreeNode != null) { IINode maxNode = MaxAnimatable.GetAnimByHandle(objectTreeNode.Handle) as IINode; if (maxNode != null) { return(maxNode.Renderable > 0); } } LayerTreeNode layerTreeNode = treeNode as LayerTreeNode; if (layerTreeNode != null) { IILayer maxLayer = MaxAnimatable.GetAnimByHandle(layerTreeNode.Handle) as IILayer; if (maxLayer != null) { return(maxLayer.Renderable); } } return(false); }
public override void PutAspect(Object rowObject, Object newValue) { BaseTreeNode treeNode = rowObject as BaseTreeNode; if (ListView.SmartFolderMode) { // If turning on, the parent folders need to be turned on too. if ((Boolean)newValue) { putValueAllParents(treeNode, true); } ObjectTreeNode objectTreeNode = treeNode as ObjectTreeNode; if (objectTreeNode != null) { IAnimatable anim = MaxAnimatable.GetAnimByHandle(objectTreeNode.Handle); // Set nodeValue and maxValue to new value. PutMaxValue(treeNode, newValue); PutTreeNodeValue(treeNode, newValue); // Avoid unnecessary casting by returning. return; } // Update max state with NLM state, if max node, set new value and update tree node value. LayerTreeNode layerTreeNode = treeNode as LayerTreeNode; if (layerTreeNode != null) { IAnimatable anim = MaxAnimatable.GetAnimByHandle(layerTreeNode.Handle); // Set nodeValue and maxValue to new value. PutMaxValue(treeNode, newValue); PutTreeNodeValue(treeNode, newValue); // Avoid unnecessary casting by returning. return; } // If folder, set tree node visiblity, and change layer value to match. if (treeNode is FolderTreeNode) { PutTreeNodeValue(treeNode, newValue); PutLayerChildrenMaxValue(treeNode, (Boolean)newValue); // Avoid unnecessary casting by returning. return; } } else // Hierarchy folder mode. { // If folder, set tree node visiblity, and change all child layer values to match. if (treeNode is FolderTreeNode) { // Set nodeValue to new value, and recursivly set all children to new value. PutTreeNodeValue(treeNode, newValue); SetFolderCheckState(treeNode, (Boolean)newValue); // Avoid unnecessary casting by returning. return; } // Update max state with NLM state, if max node, set new value and update tree node value. if (treeNode is LayerTreeNode || treeNode is ObjectTreeNode) { // Set maxValue to new value. PutMaxValue(treeNode, newValue); // Avoid unnecessary casting by returning. return; } } }
public void UpdateBinding(LayerTreeNode node) { this.DataContext = node; }