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;
}
