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;
}
}
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 List <IILayer> NameToIILayer(string[] layers)
{
List <IILayer> result = new List <IILayer>();
foreach (var l in layers)
{
IILayer lay = Loader.Core.LayerManager.GetLayer(l);
if (lay != null)
{
_dependentLayers.AddRange(lay.ParentsLayers());
result.Add(lay);
}
}
foreach (var PNode in _dependentLayers)
{
if (!result.Contains(PNode))
{
result.Add(PNode);
}
}
return(result);
}
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 static bool HasNode(this IILayer layer, IINode node, bool checkInChild = true)
{
#if MAX2020
ITab <IINode> nodes = Loader.Global.INodeTab.Create();
#else
ITab <IINode> nodes = Loader.Global.INodeTabNS.Create();
#endif
IILayerProperties layerProperties = Loader.IIFPLayerManager.GetLayer(layer.Name);
layerProperties.Nodes(nodes);
foreach (IINode n in Tools.ITabToIEnumerable(nodes))
{
if (node.Handle == n.Handle)
{
return(true);
}
}
for (int i = 0; i < layer.NumOfChildLayers; i++)
{
IILayer child = layer.GetChildLayer(i);
if (child.HasNode(node, checkInChild))
{
return(true);
}
}
return(false);
}
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);
}
/// <summary>
/// Moves the provided IINode objects to the provided layer.
/// </summary>
/// <param name="nodes"></param>
/// <param name="layer"></param>
public static void MoveNodesToLayer(IEnumerable <IINode> nodes, IILayer layer)
{
foreach (IINode node in nodes)
{
MoveNodeToLayer(node, layer);
}
}
/// <summary>
/// Freezes / Unfreezes all IILayer objects.
/// </summary>
public static void FreezeUnfreezeAll()
{
Boolean isFrozen = false;
IILayerManager LayerManager = GlobalInterface.Instance.COREInterface13.LayerManager;
for (int i = 0; i < LayerManager.LayerCount; i++)
{
IILayer layer = LayerManager.GetLayer(i);
if (!layer.IsFrozen)
{
isFrozen = true;
}
}
for (int i = 0; i < LayerManager.LayerCount; i++)
{
IILayer layer = LayerManager.GetLayer(i);
#if Max2013 || Max2014
layer.IsFrozen = isFrozen;
#endif
#if Max2015
layer.Freeze(isFrozen, false);
#endif
}
MaxUI.RedrawViewportsNow();
}
private void SetCurrentLayer(IILayer layer)
{
String name = layer.Name;
MaxInterfaces.IILayerManager.SetCurrentLayer(ref name);
MaxInterfaces.Global.BroadcastNotification(LayerNotificationCode.LayerCurrentChanged, this.oldCurrentLayer);
MaxInterfaces.Global.BroadcastNotification(LayerNotificationCode.LayerCurrentChanged, this.newCurrentLayer);
}
public SetLayerParentRestoreObj(IILayer layer, IILayer parent, Boolean updateProperties)
{
Throw.IfNull(layer, "layer");
this.layer = layer;
this.parent = parent;
this.updateProperties = updateProperties;
}
public override void Do()
{
if (this.name != null)
this.createdLayer = MaxInterfaces.IILayerManager.CreateLayer(ref this.name);
else
this.createdLayer = MaxInterfaces.IILayerManager.CreateLayer();
this.CreatedLayer.AddChildNodes(this.nodes);
}
public static IEnumerable <IILayer> ParentsLayers(this IILayer layer)
{
var p = layer;
while (p.ParentLayer != null)
{
p = p.ParentLayer;
yield return(p);
}
}
/// <summary>
/// Sets the current layer in an undo context.
/// </summary>
/// <param name="newCurrentLayer">The new active layer.</param>
public static void SetCurrentLayer(IILayer newCurrentLayer)
{
IHold theHold = MaxInterfaces.Global.TheHold;
if (theHold.Holding)
{
SetCurrentLayerRestoreObj restoreObj = new SetCurrentLayerRestoreObj(newCurrentLayer);
theHold.Put(restoreObj);
restoreObj.Redo();
}
}
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();
}
/// <summary>
/// Returns all child IINode objects of provided IILayer.
/// </summary>
/// <param name="layer"></param>
/// <returns></returns>
public static IEnumerable <IINode> GetChildNodes(IILayer layer)
{
IILayerProperties layerProps = GetLayerProperties(layer);
ITab <IINode> layerNodes = GlobalInterface.Instance.Tab.Create <IINode>();
layerProps.Nodes(layerNodes);
for (int i = 0; i < layerNodes.Count; i++)
{
yield return(layerNodes[(IntPtr)i]);
}
}
/// <summary>
/// Moves the provided IINode Anim handles to the provided layer.
/// If the handle is not an IINode, it will be skipped.
/// </summary>
/// <param name="handles"></param>
/// <param name="layer"></param>
public static void MoveNodesToLayer(IEnumerable <UIntPtr> handles, IILayer layer)
{
foreach (UIntPtr handle in handles)
{
IINode maxNode = MaxAnimatable.GetAnimByHandle(handle) as IINode;
if (maxNode != null)
{
MoveNodeToLayer(maxNode as IINode, layer);
}
}
}
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 static bool ContainLayer(this List <IILayer> layers, IILayer layer)
{
foreach (IILayer iLayer in layers)
{
if (iLayer.Name == layer.Name)
{
return(true);
}
}
return(false);
}
public static IEnumerable <IINode> LayerNodes(this IILayer layer)
{
IILayerProperties layerProp = Loader.IIFPLayerManager.GetLayer(layer.Name);
#if MAX2020
ITab <IINode> nodes = Loader.Global.INodeTab.Create();
#else
ITab <IINode> nodes = Loader.Global.INodeTabNS.Create();
#endif
layerProp.Nodes(nodes);
return(Tools.ITabToIEnumerable(nodes));
}
public static IEnumerable <IILayer> LayerTree(this IILayer layer)
{
for (int i = 0; i < layer.NumOfChildLayers; i++)
{
yield return(layer.GetChildLayer(i));
foreach (var y in layer.GetChildLayer(i).LayerTree())
{
yield return(y);
}
}
}
// If the cell being edited is layer 0, cancel the cell edit.
private void onBeforeLabelEdit(Object sender, CellEditEventArgs e)
{
if (e.RowObject is LayerTreeNode)
{
IILayer layer = MaxLayers.GetLayer(0);
UIntPtr handle = MaxAnimatable.GetHandleByAnim(layer);
if ((e.RowObject as LayerTreeNode).Handle == handle)
{
e.Cancel = true;
}
}
}
public static IILayer GetNodeLayer(this IINode node)
{
int num = node.NumRefs;
for (int i = 0; i < num; i++)
{
IILayer r = node.GetReference(i) as IILayer;
if (r != null)
{
return(r);
}
}
return(null);
}
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 void BuildLayerTreeRecusively(IILayer layer, int index, TreeNodeCollection treeNodeCollection)
{
for (int i = 0; i < layer.NumOfChildLayers; i++)
{
IILayer childLayer = layer.GetChildLayer(i);
TreeNode layerNode = treeNodeCollection[index].Nodes.Add(childLayer.Name);
if (SelectedLayers.Contains(layer))
{
layerNode.Checked = true;
}
BuildLayerTreeRecusively(childLayer, i, treeNodeCollection[index].Nodes);
}
}
public static List <IILayer> GetContainerLayers(this IIContainerObject container)
{
List <IILayer> result = new List <IILayer>();
List <IINode> containerNodes = container.ContainerNode.ContainerNodeTree(true);
foreach (IINode node in containerNodes)
{
IILayer nodeLayer = node.GetNodeLayer();
if (nodeLayer != null)
{
result.Add(node.GetNodeLayer());
}
}
return(result);
}
private void confirmButton_Click(object sender, EventArgs e)
{
for (int i = 0; i < layerTreeView.Nodes.Count; i++)
{
TreeNode nodeLayer = layerTreeView.Nodes[i];
if (nodeLayer.Checked)
{
IILayer l = Loader.Core.LayerManager.GetLayer(nodeLayer.Text);
SelectedLayers.Add(l);
}
}
OnConfirmButtonClicked?.Invoke(this, EventArgs.Empty);
Dispose();
}
private void onNodeCreated(object sender, SystemNotificationAnimEventArgs e)
{
#if DEBUG
MaxListener.PrintToListener("onNodeCreated");
#endif
try
{
ListView.BeginUpdate();
List <BaseTreeNode> refreshNodes = new List <BaseTreeNode>();
foreach (UIntPtr handle in e.Handles)
{
IAnimatable anim = MaxAnimatable.GetAnimByHandle(handle);
if (anim == null)
{
return;
}
IINode node = anim as IINode;
IILayer layer = MaxLayers.GetLayer(node);
UIntPtr layerHandle = MaxAnimatable.GetHandleByAnim(layer);
ObjectTreeNode.ObjectClass objectClass = MaxNodes.GetObjectClass(node);
List <BaseTreeNode> layerTreeNodes = NodeControl.HandleMap.GetTreeNodesByHandle(layerHandle);
foreach (BaseTreeNode layerTreeNode in layerTreeNodes)
{
ObjectTreeNode objectTreeNode = new ObjectTreeNode(objectClass, handle, NodeControl.HandleMap);
NodeControl.Parent.AddChild(objectTreeNode, layerTreeNode, false);
if (!refreshNodes.Contains(layerTreeNode))
{
refreshNodes.Add(layerTreeNode);
}
}
}
MaxListener.PrintToListener(refreshNodes.Count.ToString());
ListView.RefreshObjects(refreshNodes);
ListView.Sort(ListView.NlmColumns.NameColumn, SortOrder.Ascending);
}
catch
{
throw new Exception();
}
finally
{
ListView.EndUpdate();
}
}
private void ValidateCellEdit(Object o, CellEditEventArgs e)
{
String oldValue = e.Value as String;
String newValue = e.NewValue as String;
if (oldValue != newValue)
{
IILayer layer = MaxLayers.GetLayer(newValue);
if (layer != null)
{
e.Cancel = true;
MessageBox.Show("A Layer with that name already Exists.");
}
}
}
private void CalculateSelectedLayers(TreeNodeCollection nodeLayers)
{
for (int i = 0; i < nodeLayers.Count; i++)
{
TreeNode nodeLayer = nodeLayers[i];
if (!nodeLayer.Checked && nodeLayer.Nodes != null)
{
CalculateSelectedLayers(nodeLayer.Nodes);
}
else
{
IILayer l = Loader.Core.LayerManager.GetLayer(nodeLayer.Text);
SelectedLayers.Add(l);
}
}
}
/// <summary>
/// Creates an IILayer in 3ds Max.
/// </summary>
/// <returns>Returns the created IILayer</returns>
public static IILayer CreateLayer(Boolean makeCurrent, Boolean addSelection)
{
IILayer layer = GlobalInterface.Instance.COREInterface14.LayerManager.CreateLayer();
if (makeCurrent)
{
SetCurrentLayer(layer);
}
if (addSelection)
{
MaxNodes.MoveNodesToLayer(MaxNodes.SelectedNodes, layer);
}
return(layer);
}
public static List <IILayer> GetSelectedLayers(SceneExplorerDialog sceneExplorer)
{
List <IILayer> selectedLayer = new List <IILayer>();
TraversalNode[] traversalNodes = sceneExplorer.ExplorerControl.GetSelectedNodes(false, false, false);
foreach (TraversalNode traversalNode in traversalNodes)
{
if (INodeUtilities.IsMaxLayerTraversalNode(traversalNode))
{
ITraversalILayer l = traversalNode as ITraversalILayer;
IILayer layer = Loader.Core.LayerManager.GetLayer(l.SceneName);
selectedLayer.Add(layer);
}
}
return(selectedLayer);
}
public override void LayerChanged(ITab <UIntPtr> nodes)
{
#if DEBUG
MaxListener.PrintToListener("NodeEventCallback > LayerChanged");
#endif
List <BaseTreeNode> deleteNodes = new List <BaseTreeNode>();
List <Tuple <BaseTreeNode, BaseTreeNode> > addNodes = new List <Tuple <BaseTreeNode, BaseTreeNode> >();
for (int i = 0; i < nodes.Count; i++)
{
UIntPtr maxNodeHandle = nodes[(IntPtr)i];
IINode maxNode = MaxAnimatable.GetAnimByHandle(maxNodeHandle) as IINode;
IILayer maxLayer = MaxLayers.GetLayer(maxNode);
UIntPtr layerHandle = MaxAnimatable.GetHandleByAnim(maxLayer);
// We need to handle the following scenarios:
// An object being moved to another layer.
// Objects on instances layers moving to uninstanced layers.
// Objects on uninstanced layers moving to instanced layers.
// The easiest way to do this is to remove old object nodes and create new ones.
// This should be pretty fast, and this event should fire relatively rarely,
// but it may have to be rethought if it's too slow.
// First we remove the old nodes.
List <BaseTreeNode> objectTreeNodes = NodeControl.HandleMap.GetTreeNodesByHandle(maxNodeHandle);
deleteNodes.AddRange(objectTreeNodes);
// Then we add the object node to the new layer.
List <BaseTreeNode> layerTreeNodes = NodeControl.HandleMap.GetTreeNodesByHandle(layerHandle);
foreach (BaseTreeNode layerTreeNode in layerTreeNodes)
{
ObjectTreeNode newObjectTreeNode = new ObjectTreeNode(MaxNodes.GetObjectClass(maxNode), maxNodeHandle, NodeControl.HandleMap);
addNodes.Add(new Tuple <BaseTreeNode, BaseTreeNode> (newObjectTreeNode, layerTreeNode));
}
}
// And finally we actually do the update all at once.
NodeControl.Destroy.DeleteTreeNodes(deleteNodes);
foreach (Tuple <BaseTreeNode, BaseTreeNode> tuple in addNodes)
{
NodeControl.Parent.AddChild(tuple.Item1, tuple.Item2, false);
}
// And sort :)
ListView.Sort(ListView.NlmColumns.NameColumn, SortOrder.Ascending);
}
public void FillLayerSelector(List <IILayer> previoslySelected)
{
layerTreeView.Nodes.Clear();
List <IILayer> rootLayers = LayerUtilities.RootLayers();
for (int i = 0; i < rootLayers.Count; i++)
{
IILayer layer = rootLayers[i];
TreeNode layerNode = layerTreeView.Nodes.Add(layer.Name);
if (previoslySelected != null && previoslySelected.Contains(layer))
{
layerNode.Checked = true;
}
BuildLayerTreeRecusively(layer, i, layerTreeView.Nodes);
}
}
public static void DeleteLayer(UIntPtr layerHandle)
{
IILayer layer = MaxAnimatable.GetAnimByHandle(layerHandle) as IILayer;
if (layer == null)
{
return;
}
IILayerProperties layerProperties = MaxLayers.GetLayerProperties(layer);
if (layerProperties.Current)
{
MaxLayers.SetCurrentLayer(0);
}
MaxInterfaces.Instance.FPLayerManager.DeleteLayer(layer.Name);
}
private static Boolean GetLayerProperty(IILayer layer, BooleanNodeProperty property)
{
switch (property)
{
case BooleanNodeProperty.IsHidden: return layer.IsHidden;
case BooleanNodeProperty.IsFrozen: return layer.IsFrozen;
case BooleanNodeProperty.SeeThrough: return layer.XRayMtl;
case BooleanNodeProperty.BoxMode: return layer.BoxMode;
case BooleanNodeProperty.BackfaceCull: return layer.BackCull;
case BooleanNodeProperty.AllEdges: return layer.AllEdges;
case BooleanNodeProperty.VertexTicks: return layer.VertTicks;
case BooleanNodeProperty.Trajectory: return layer.Trajectory_;
case BooleanNodeProperty.IgnoreExtents: return layer.IgnoreExtents;
case BooleanNodeProperty.FrozenInGray: return layer.ShowFrozenWithMtl;
case BooleanNodeProperty.Renderable: return layer.Renderable;
case BooleanNodeProperty.InheritVisibility: return layer.InheritVisibility;
case BooleanNodeProperty.PrimaryVisibility: return layer.PrimaryVisibility;
case BooleanNodeProperty.SecondaryVisibility: return layer.SecondaryVisibility;
case BooleanNodeProperty.ReceiveShadows: return layer.RcvShadows;
case BooleanNodeProperty.CastShadows: return layer.CastShadows;
case BooleanNodeProperty.ApplyAtmospherics: return layer.ApplyAtmospherics;
case BooleanNodeProperty.RenderOccluded: return layer.RenderOccluded;
default: return false;
}
}
private static void SetLayerProperty(IILayer layer, BooleanNodeProperty property, Boolean value)
{
switch (property)
{
case BooleanNodeProperty.IsHidden:
layer.IsHidden = value;
break;
case BooleanNodeProperty.IsFrozen:
layer.IsFrozen = value;
break;
case BooleanNodeProperty.SeeThrough:
layer.XRayMtl = value;
break;
case BooleanNodeProperty.BoxMode:
layer.BoxMode = value;
break;
case BooleanNodeProperty.BackfaceCull:
layer.BackCull = value;
break;
case BooleanNodeProperty.AllEdges:
layer.AllEdges = value;
break;
case BooleanNodeProperty.VertexTicks:
layer.VertTicks = value;
break;
case BooleanNodeProperty.Trajectory:
layer.Trajectory(value, false);
break;
case BooleanNodeProperty.IgnoreExtents:
layer.IgnoreExtents = value;
break;
case BooleanNodeProperty.FrozenInGray:
layer.ShowFrozenWithMtl = value;
break;
case BooleanNodeProperty.Renderable:
layer.Renderable = value;
break;
case BooleanNodeProperty.InheritVisibility:
layer.InheritVisibility = value;
break;
case BooleanNodeProperty.PrimaryVisibility:
layer.PrimaryVisibility = value;
break;
case BooleanNodeProperty.SecondaryVisibility:
layer.SecondaryVisibility = value;
break;
case BooleanNodeProperty.ReceiveShadows:
layer.RcvShadows = value;
break;
case BooleanNodeProperty.CastShadows:
layer.CastShadows = value;
break;
case BooleanNodeProperty.ApplyAtmospherics:
layer.ApplyAtmospherics = value;
break;
case BooleanNodeProperty.RenderOccluded:
layer.RenderOccluded = value;
break;
default:
break;
}
}
/// <summary>
/// Returns the value of a property on the layer.
/// It will return the layer's own value, regardless of whether it has been overridden by a parent layer.
/// </summary>
public static Boolean GetProperty(IILayer layer, BooleanNodeProperty property)
{
byte[] data = NestedLayers.getAppData(layer, property);
if (data != null)
return BitConverter.ToBoolean(data, 0);
else
return NestedLayers.GetLayerProperty(layer, property);
}
/// <summary>
/// Sets a layer property and propagates it to its children.
/// </summary>
public static void SetProperty(IILayer layer, BooleanNodeProperty prop, Boolean value)
{
NestedLayers.SetProperty(layer, prop, value, false);
}
private static void SetProperty(IILayer layer, BooleanNodeProperty property, Boolean value, Boolean setByParent)
{
if (layer == null)
return;
//Store new value in AppDataChunk.
if (!setByParent)
NestedLayers.setAppData(layer, property, BitConverter.GetBytes(value));
//Set new value based on value and parent value.
Boolean ownValue = NestedLayers.GetProperty(layer, property);
Boolean newValue = ownValue;
IILayer parentLayer = NestedLayers.GetParent(layer);
if (parentLayer != null)
{
Boolean parentValue = NestedLayers.GetLayerProperty(parentLayer, property);
BinaryPredicate<Boolean> pred = Functor.Or;
if (!NestedLayers.propertyOps.TryGetValue(property, out pred))
pred = Functor.Or;
newValue = pred(ownValue, parentValue);
}
NestedLayers.SetLayerProperty(layer, property, newValue);
//Broadcast notification.
if (property == BooleanNodeProperty.IsHidden)
{
MaxInterfaces.Global.BroadcastNotification(SystemNotificationCode.LayerHiddenStateChanged, layer);
}
else if (property == BooleanNodeProperty.IsFrozen)
{
MaxInterfaces.Global.BroadcastNotification(SystemNotificationCode.LayerFrozenStateChanged, layer);
}
else
{
LayerPropertyChangedParam parameters = new LayerPropertyChangedParam(layer, NodeProperties.ToProperty(property));
MaxInterfaces.Global.BroadcastNotification(LayerNotificationCode.LayerPropertyChanged, parameters);
}
//Propagate to children.
IEnumerable<IILayer> childLayers = NestedLayers.GetChildren(layer, false);
foreach (IILayer childLayer in childLayers)
{
NestedLayers.SetProperty(childLayer, property, value, true);
}
}
public override void Redo()
{
this.prevParent = NestedLayers.GetParent(layer);
NestedLayers.SetParent(this.layer, this.parent, this.updateProperties);
}
/// <summary>
/// Initializes a new instance of the ILayerWrapper class.
/// </summary>
/// <param name="ilayer">The ILayer object to wrap.</param>
public ILayerWrapper(IILayer ilayer)
{
Throw.IfNull(ilayer, "ilayer");
this.ilayer = ilayer;
}
/// <summary>
/// Initializes a new instance of the LayerPropertyChangedParam struct.
/// </summary>
/// <param name="layer">The layer of which a property has changed.</param>
/// <param name="property">The property that changed.</param>
public LayerPropertyChangedParam(IILayer layer, NodeProperty property)
{
this.layer = layer;
this.property = property;
}
/// <summary>
/// Returns a list with all children of a layer.
/// </summary>
/// <param name="parent">The parent layer to get the childlayers from.</param>
/// <param name="recursive">Include the entire layer tree.</param>
public static IEnumerable<IILayer> GetChildren(IILayer parent, Boolean recursive)
{
List<IILayer> children = new List<IILayer>();
IILayerManager layerManager = MaxInterfaces.IILayerManager;
for (int i = 0; i < layerManager.LayerCount; i++)
{
IILayer layer = layerManager.GetLayer(i);
IILayer layerParent = NestedLayers.GetParent(layer);
if ((parent == null && layerParent == null) ||
(parent != null && layerParent != null && layerParent.Handle == parent.Handle))
{
children.Add(layer);
if (recursive)
children.AddRange(NestedLayers.GetChildren(layer, recursive));
}
}
return children;
}
public override void Redo()
{
this.oldCurrentLayer = MaxInterfaces.IILayerManager.CurrentLayer;
this.SetCurrentLayer(this.newCurrentLayer);
}
public SetCurrentLayerRestoreObj(IILayer newCurrentLayer)
{
this.newCurrentLayer = newCurrentLayer;
}
private static void readProperties(BinaryReader reader, IILayer layer)
{
Type propType = typeof(BooleanNodeProperty);
int numProps = reader.ReadByte() / 2;
for (int p = 0; p < numProps; p++)
{
Int32 propInt = reader.ReadInt32();
BooleanNodeProperty prop = (BooleanNodeProperty)Enum.ToObject(propType, propInt);
Boolean propValue = reader.ReadBoolean();
NestedLayers.SetProperty(layer, prop, propValue);
}
}
/// <summary>
/// Gets AutoInherit on a layer for a specific property.
/// </summary>
public static Boolean GetAutoInherit(IILayer layer, NodeLayerProperty prop)
{
if (layer == null)
throw new ArgumentNullException("layer");
IAppDataChunk chunk = layer.GetAppDataChunk(classID, SClass_ID.Gup, (uint)prop);
return (chunk != null) ? BitConverter.ToBoolean(chunk.Data, 0) : false;
}
/// <summary>
/// Sets AutoInherit on a layer for a specific property.
/// </summary>
public static void SetAutoInherit(IILayer layer, NodeLayerProperty prop, Boolean value)
{
if (layer == null)
throw new ArgumentNullException("layer");
//Set AppDataChunk.
layer.AddAppDataChunk(classID, SClass_ID.Gup, (uint)prop, BitConverter.GetBytes(value));
//Update nodes on layer.
ITab<IINode> nodes = MaxInterfaces.Global.INodeTabNS.Create();
IILayerProperties layerProperties = MaxInterfaces.IIFPLayerManager.GetLayer(layer.Name);
layerProperties.Nodes(nodes);
foreach (IINode node in IINodes.ITabToIEnumerable(nodes))
{
setNodeInheritProperty(node, prop, value);
}
}
/// <summary>
/// Tests if a layer is a root layer (i.e. it has no parent layer).
/// </summary>
public static Boolean IsRootLayer(IILayer layer)
{
return NestedLayers.GetParent(layer) == null;
}
private static void writeProperties(BinaryWriter writer, IILayer layer)
{
IEnumerable<BooleanNodeProperty> layerProps = Enum.GetValues(typeof(BooleanNodeProperty))
.Cast<BooleanNodeProperty>();
//Write property chunk size in bytes.
//1 byte for each enum value, 1 byte for each property value
writer.Write((byte)(layerProps.Count() * 2));
//Write property values.
foreach (BooleanNodeProperty prop in layerProps)
{
writer.Write((Int32)prop);
writer.Write(NestedLayers.GetProperty(layer, prop));
}
}
/// <summary>
/// Initializes a new instance of the ILayerWrapper class.
/// </summary>
/// <param name="ilayer">The ILayer object to wrap.</param>
/// <param name="ilayerProperties">The ILayerProperties of the ILayer to wrap.</param>
public ILayerWrapper(IILayer ilayer, IILayerProperties ilayerProperties)
{
this.ilayer = ilayer;
this.ilayerProperties = ilayerProperties;
}
/// <summary>
/// Returns a list with all direct children of a layer (non-recursive).
/// </summary>
/// <param name="parent">The parent layer to get the childlayers from.</param>
public static IEnumerable<IILayer> GetChildren(IILayer parent)
{
return NestedLayers.GetChildren(parent, false);
}
private static void updateProperties(IILayer layer, Boolean recursive)
{
IEnumerable<BooleanNodeProperty> layerProps = Enum.GetValues(typeof(BooleanNodeProperty))
.Cast<BooleanNodeProperty>()
.Where(p => p != BooleanNodeProperty.None);
foreach (BooleanNodeProperty prop in layerProps)
{
NestedLayers.SetProperty(layer, prop, NestedLayers.GetProperty(layer, prop));
}
if (recursive)
{
foreach (IILayer child in NestedLayers.GetChildren(layer, false))
NestedLayers.updateProperties(child, recursive);
}
}
internal static void SetParent(IILayer layer, IILayer parent, Boolean updateProperties)
{
if (layer == null || layer == parent)
return;
NestedLayers.removeAppData(layer, SubID.ParentHandle);
if (parent != null)
{
UIntPtr handle = MaxInterfaces.Global.Animatable.GetHandleByAnim(parent);
byte[] data = BitConverter.GetBytes(handle.ToUInt64());
NestedLayers.setAppData(layer, SubID.ParentHandle, data);
}
if (updateProperties)
NestedLayers.updateProperties(layer, true);
MaxInterfaces.Global.BroadcastNotification(LayerNotificationCode.LayerParented, layer);
}
/// <summary>
/// Tests if the given property on the given layer is inherited from a parent layer.
/// </summary>
public static Boolean IsPropertyInherited(IILayer layer, BooleanNodeProperty prop)
{
if (layer == null)
return false;
Boolean ownValue = NestedLayers.GetProperty(layer, prop);
Boolean actualValue = NestedLayers.GetLayerProperty(layer, prop);
return (ownValue != actualValue);
}
/// <summary>
/// Retrieves the parent of the given layer. Returns null if it is a root layer.
/// </summary>
public static IILayer GetParent(IILayer layer)
{
if (layer == null)
return null;
byte[] data = NestedLayers.getAppData(layer, SubID.ParentHandle);
if (data == null)
return null;
UIntPtr handle = new UIntPtr(BitConverter.ToUInt64(data, 0));
return MaxInterfaces.Global.Animatable.GetAnimByHandle(handle) as IILayer;
}
/// <summary>
/// Sets the parent of the given layer. Use null to make the layer a root layer.
/// </summary>
public static void SetParent(IILayer layer, IILayer parent)
{
SetLayerParentRestoreObj restoreObj = new SetLayerParentRestoreObj(layer, parent, true);
if (MaxInterfaces.Global.TheHold.Holding)
{
MaxInterfaces.Global.TheHold.Put(restoreObj);
}
restoreObj.Redo();
//NestedLayers.SetParent(layer, parent, true);
}
