public override TreeNode AddNode(IMaxNode wrapper, TreeNodeCollection parentCol)
{
TreeNode tn = base.AddNode(wrapper, parentCol);
MaterialWrapper mtlWrapper = wrapper as MaterialWrapper;
if (mtlWrapper != null)
{
AddObjects(mtlWrapper, tn.Nodes);
AddTextureMaps(mtlWrapper, tn.Nodes);
foreach (IMtl mtl in mtlWrapper.ChildMaterials)
{
this.AddNode(mtl, tn.Nodes);
}
}
else if (!(wrapper is INodeWrapper))
{
foreach (IMaxNode node in wrapper.ChildNodes)
{
this.AddNode(node, tn.Nodes);
}
}
return tn;
}
protected override int InternalCompare(IMaxNode nodeX, IMaxNode nodeY)
{
if (nodeX == nodeY)
return 0;
return NativeMethods.StrCmpLogicalW(nodeX.Name, nodeY.Name);
}
/// <summary>
/// Initializes a new instance of the SetViewCameraCommand class.
/// </summary>
/// <param name="cameraNode">The Camera node to use.</param>
/// <param name="viewport">The viewport to set the camera for.</param>
public SetViewCameraCommand(IMaxNode cameraNode, IViewExp viewport)
{
Throw.IfNull(cameraNode, "cameraNode");
Throw.IfNull(viewport, "viewport");
this.cameraNode = cameraNode;
this.viewport = viewport;
}
protected override IDragDropHandler CreateDragDropHandler(IMaxNode wrapper)
{
if (wrapper is SelectionSetWrapper)
return new SelectionSetDragDropHandler((SelectionSetWrapper)wrapper);
else if (wrapper is INodeWrapper)
return new INodeDragDropHandler(wrapper);
return base.CreateDragDropHandler(wrapper);
}
public override TreeNode AddNode(IMaxNode wrapper, TreeNodeCollection parentCol)
{
TreeNode tn = base.AddNode(wrapper, parentCol);
if (wrapper is SelectionSetWrapper || wrapper is AllObjectsSelectionSetWrapper)
{
foreach (Object child in wrapper.ChildBaseObjects)
this.AddNode(child, tn.Nodes);
}
return tn;
}
protected override int InternalCompare(IMaxNode nodeX, IMaxNode nodeY)
{
INodeWrapper inodeX = nodeX as INodeWrapper;
INodeWrapper inodeY = nodeY as INodeWrapper;
if (inodeX == null)
return -1;
else if (inodeY == null)
return 1;
else
return (int)(inodeX.INode.Handle - inodeY.INode.Handle);
}
/// <summary>
/// Initializes a new instance of the RemoveNodesCommand class.
/// </summary>
/// <param name="target">The IMaxNode to remove nodes from.</param>
/// <param name="nodes">The IMaxNodes to remove from the parent node.</param>
/// <param name="description">The description of the command.</param>
public RemoveNodesCommand( IMaxNode target
, IEnumerable<IMaxNode> nodes
, String description)
{
Throw.IfNull(target, "target");
Throw.IfNull(nodes, "nodes");
Throw.IfNull(description, "description");
this.nodes = nodes.ToList();
this.target = target;
this.description = description;
}
protected override Color GetNodeColor(IMaxNode node)
{
INodeWrapper inode = node as INodeWrapper;
if (inode == null)
return Color.Empty;
ILightObject light = inode.INode.ObjectRef as ILightObject;
if (light == null)
return Color.Empty;
return Colors.FromMaxColor(light.GetRGBColor(0, MaxInterfaces.IntervalForever));
}
public ChangeGroupCommand( IEnumerable<IMaxNode> nodes
, IMaxNode groupHead
, Boolean group)
{
Throw.IfNull(nodes, "nodes");
Throw.IfNull(groupHead, "groupHead");
this.nodes = nodes.OfType<INodeWrapper>()
.ToList();
this.groupHead = groupHead;
this.group = group;
}
protected override IDragDropHandler CreateDragDropHandler(IMaxNode node)
{
INodeWrapper iinodeWrapper = node as INodeWrapper;
if (iinodeWrapper != null)
{
if (iinodeWrapper.INode.IsGroupMember || iinodeWrapper.INode.IsGroupHead)
return new GroupDragDropHandler(node);
else
return new INodeDragDropHandler(node);
}
return base.CreateDragDropHandler(node);
}
protected override int InternalCompare(IMaxNode nodeX, IMaxNode nodeY)
{
ColorTag tagX = ColorTags.GetTag(nodeX.BaseObject as IAnimatable);
ColorTag tagY = ColorTags.GetTag(nodeY.BaseObject as IAnimatable);
if (tagX == tagY)
return 0;
else if (tagX == ColorTag.None)
return 1;
else if (tagY == ColorTag.None)
return -1;
else
return tagX.CompareTo(tagY);
}
private static void MoveCreatedLayer(TreeNode contextTn, IMaxNode createdLayer)
{
if (contextTn != null)
{
IMaxNode node = GetSelectedLayer(contextTn);
if (node != null)
{
AddNodesCommand addCmd = new AddNodesCommand( node
, createdLayer.ToIEnumerable()
, Resources.Command_AddToLayer);
addCmd.Execute();
Viewports.Redraw();
}
}
}
protected override int InternalCompare(IMaxNode nodeX, IMaxNode nodeY)
{
INodeWrapper inodeX = nodeX as INodeWrapper;
if (nodeX == null)
return 0;
INodeWrapper inodeY = nodeY as INodeWrapper;
if (nodeY == null || !nodeY.IsValid)
return 0;
int numFacesX = IINodes.GetPolyCount(inodeX.INode);
int numFacesY = IINodes.GetPolyCount(inodeY.INode);
return numFacesY.CompareTo(numFacesX);
}
protected override int InternalCompare(IMaxNode nodeX, IMaxNode nodeY)
{
if (nodeX == nodeY)
return 0;
Object propValueX = nodeX.GetNodeProperty(this.Property);
Object propValueY = nodeY.GetNodeProperty(this.Property);
IComparable iCompX = propValueX as IComparable;
if (iCompX != null)
return iCompX.CompareTo(propValueY);
else if (propValueX is Color && propValueY is Color)
return Colors.Compare((Color)propValueX, (Color)propValueY);
else
return 0;
}
public TreeNode AddNode(IMaxNode wrapper, TreeNodeCollection parentCol, Boolean recursive)
{
Throw.IfNull(wrapper, "wrapper");
Throw.IfNull(parentCol, "parentCol");
TreeNode tn = base.AddNode(wrapper, parentCol);
if (recursive)
{
foreach (Object child in wrapper.ChildBaseObjects)
{
this.AddNode(child, tn.Nodes);
}
}
return tn;
}
public override TreeNode AddNode(IMaxNode wrapper, TreeNodeCollection parentCol)
{
TreeNode tn = base.AddNode(wrapper, parentCol);
ILayerWrapper layerWrapper = wrapper as ILayerWrapper;
if (layerWrapper != null)
{
//Set italic font for default layer.
if (layerWrapper.IsDefault)
tn.FontStyle = FontStyle.Italic;
//Add nodes belonging to this layer.
foreach (Object node in wrapper.ChildBaseObjects)
{
if (this.ShouldAddNode(node))
this.AddNode(node, tn.Nodes);
}
}
return tn;
}
protected override int InternalCompare(IMaxNode nodeX, IMaxNode nodeY)
{
INodeWrapper inodeX = nodeX as INodeWrapper;
if (inodeX == null)
return 0;
INodeWrapper inodeY = nodeY as INodeWrapper;
if (inodeY == null)
return 0;
IMtl materialX = inodeX.INode.Mtl;
IMtl materialY = inodeY.INode.Mtl;
if (materialX == materialY)
return 0;
else if (materialX == null)
return 1;
else if (materialY == null)
return -1;
else
return NativeMethods.StrCmpLogicalW(materialX.Name, materialY.Name);
}
public override void RemoveChildNode(IMaxNode node)
{
INodeWrapper inodeWrapper = node as INodeWrapper;
if (inodeWrapper == null)
return;
inodeWrapper.INode.Mtl = null;
}
public MaxTreeNode(IMaxNode maxNode)
{
this.MaxNode = maxNode;
}
public override bool CanRemoveChildNode(IMaxNode node)
{
return false;
}
public override void RemoveChildNode(IMaxNode node)
{
Throw.IfNull(node, "node");
INodeWrapper inodeWrapper = node as INodeWrapper;
if (inodeWrapper != null)
inodeWrapper.INode.Detach(0, true);
}
public override void AddChildNode(IMaxNode node)
{
Throw.IfNull(node, "node");
if (!this.CanAddChildNode(node))
return;
//Aggregates (e.g. SelectionSet)
if (node.IsAggregate)
this.AddChildNodes(node.ChildNodes);
IINode inode = node.BaseObject as IINode;
if (inode != null)
this.INode.AttachChild(inode, true);
}
public override bool CanAddChildNode(IMaxNode node)
{
if (node == null)
return false;
//Aggregates (e.g. SelectionSet)
if (node.IsAggregate)
return this.CanAddChildNodes(node.ChildNodes);
//IINode
INodeWrapper inodeWrapper = node as INodeWrapper;
if (inodeWrapper == null)
return false;
if (node.Parent.Equals(this))
return false;
RefResult loop = this.INode.TestForLoop( MaxInterfaces.IntervalForever
, inodeWrapper.INode as IReferenceMaker);
return loop == RefResult.Succeed;
}
protected override int InternalCompare(IMaxNode nodeX, IMaxNode nodeY)
{
return nodeX.SuperClassID.CompareTo(nodeY.SuperClassID);
}
private static void RemoveFromParent(IMaxNode node)
{
IMaxNode parent = node.Parent;
if (parent != null)
parent.RemoveChildNode(node);
}
/// <summary>
/// Initializes a new instance of the MaxNodeDragDropHandler.
/// </summary>
/// <param name="maxNode">The IMaxNode object the DragDropHandler is associated with.</param>
public MaxNodeDragDropHandler(IMaxNode maxNode)
{
this.MaxNode = maxNode;
}
public INodeDragDropHandler(IMaxNode node) : base(node) { }
public override void AddChildNode(IMaxNode node)
{
INodeWrapper inodeWrapper = node as INodeWrapper;
if (inodeWrapper == null)
return;
inodeWrapper.INode.Mtl = this.Material;
}
protected override IDragDropHandler CreateDragDropHandler(IMaxNode node)
{
if (node is MaterialWrapper || node is UnassignedMaterialWrapper)
return new MaterialDragDropHandler(node);
INodeWrapper inodeWrapper = node as INodeWrapper;
if (inodeWrapper != null)
return new INodeDragDropHandler(inodeWrapper);
return base.CreateDragDropHandler(node);
}
public override bool CanRemoveChildNode(IMaxNode node)
{
INodeWrapper inodeWrapper = node as INodeWrapper;
if (inodeWrapper == null)
return false;
IINode inode = inodeWrapper.INode;
return inode.Mtl != null && inode.Mtl.Handle.Equals(this.Material.Handle);
}
