static void ProcessTree(ObjectTreeNode parent, ArchiveFileInfo file, string[] paths, int index)
{
string currentPath = paths[index];
if (paths.Length - 1 == index)
{
var fileNode = new ObjectTreeNode(currentPath);
string ext = Utils.GetExtension(currentPath);
if (FileImageKeys.Lookup.ContainsKey(ext))
{
fileNode.ImageKey = FileImageKeys.Lookup[ext];
}
else
{
fileNode.ImageKey = "File";
}
fileNode.Type = ext;
fileNode.Size = STMath.GetFileSize(file.GetFileSize());
fileNode.Tag = file;
parent.AddChild(fileNode);
return;
}
var node = FindFolderNode(parent, currentPath);
if (node == null)
{
node = new ObjectTreeNode(currentPath);
node.ImageKey = "Folder";
parent.AddChild(node);
}
ProcessTree(node, file, paths, index + 1);
}
public ObjectTreeNode GetRootNode(Guid id)
{
var project = new ObjectDataSource().GetObject(ObjectType.Project, id);
var node = new ObjectTreeNode(null, project, project.ID, this, TreeNodePath.Root.Then(Element.Project));
return(node);
}
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 void ShowTarget(Object linkModifier)
{
IObjectMember om = (IObjectMember)linkModifier;
ObjectTreeNode.
SelectObjectMember(om, ObjectTreeNode.CREATE_OBJ);
}
internal static ObjectInfo CreateObject(IDragDropItem sourceNode, ObjectTreeNode targetNode)
{
ObjectCreator objCreator = new ObjectCreator();
_objCreator = objCreator;
return(objCreator.CreateObjectInternal(sourceNode, targetNode));
}
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 void LoadImageList(ImageList imgList)
{
ImageList = imgList;
stListView1.LargeImageList = new ImageList()
{
ColorDepth = ColorDepth.Depth32Bit
};
stListView1.SmallImageList = new ImageList()
{
ColorDepth = ColorDepth.Depth32Bit
};
this.Label.ImageGetter = delegate(object row) {
ObjectTreeNode node = (ObjectTreeNode)row;
String key = node.ImageKey;
if (ImageList.Images.ContainsKey(key) && !this.stListView1.LargeImageList.Images.ContainsKey(key))
{
Image smallImage = this.ImageList.Images[key];
Image largeImage = this.ImageList.Images[key];
this.stListView1.SmallImageList.Images.Add(key, smallImage);
this.stListView1.LargeImageList.Images.Add(key, largeImage);
}
return(key);
};
}
public ArchiveHiearchy(IArchiveFile archiveFile, ObjectTreeNode node)
{
if (node.Tag is ArchiveFileInfo)
{
ArchiveFileInfo = (ArchiveFileInfo)node.Tag;
}
ArchiveFile = archiveFile;
ReferenceNode = node;
Label = node.Label;
Tag = node.Tag;
ImageKey = node.ImageKey;
if (node.ChildCount > 0)
{
ImageKey = "Folder";
Children.Add(new ObjectTreeNode("dummy"));
}
if (ArchiveFileInfo != null)
{
foreach (var loader in FileManager.GetFileIconLoaders())
{
string key = loader.Identify(Label, ArchiveFileInfo.FileData);
if (key != string.Empty)
{
ImageKey = key;
}
}
}
}
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);
}
internal BaseTypeHandler GetTypeHandler(Type type, ObjectTreeNode node)
{
TypeHandlerInfo thInfo = null;
if (type == null)
{
return(null);
}
foreach (TypeHandlerInfo t in _typeHandlers)
{
if (t._typeHandled.IsAssignableFrom(type))
{
thInfo = t;
break;
}
}
if (thInfo == null)
{
return(null);
}
// We assume there is only one constructor,
// which takes the type handler info and the node
ConstructorInfo ci = thInfo._handlerType.
GetConstructors(ReflectionHelper.ALL_BINDINGS)[0];
Object[] parameters = new Object[] { thInfo, node };
return((BaseTypeHandler)ci.Invoke(parameters));
}
public void LoadFormat(ICompressionFormat fileFormat, System.IO.Stream stream, string fileName)
{
ObjectTreeNode dataNode = new ObjectTreeNode(System.IO.Path.GetFileName(fileName));
dataNode.Tag = stream;
ObjectHiearchy.Add(dataNode);
}
/// <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 ObjectTreeNode LoadTextureFormat(STGenericTexture texture)
{
ObjectTreeNode node = new ObjectTreeNode(texture.Name);
node.ImageKey = "Texture";
node.Tag = texture;
return(node);
}
private ObjectTreeNode LoadMesh(STGenericMesh mesh)
{
ObjectTreeNode node = new ObjectTreeNode(mesh.Name);
node.ImageKey = "Mesh";
node.Tag = mesh;
return(node);
}
static ObjectTreeNode CreateObjectHiearchy(ObjectTreeNode parent, IArchiveFile archiveFile)
{
// build a TreeNode collection from the file list
foreach (var file in archiveFile.Files)
{
string[] paths = file.FileName.Split('/');
ProcessTree(parent, file, paths, 0);
}
return(parent);
}
public void LoadRoot(ObjectTreeNode node)
{
Children.Clear();
CachedChildren.Clear();
Children.Add(node);
CachedChildren.Add(node);
stListView1.UpdateObjects(Children);
ReloadArchiveFolderColumns();
}
private void ObjectList_RightClicked(object sender, EventArgs e)
{
ObjectTreeNode obj = ObjectHiearchy.GetSelectedNodes().FirstOrDefault();
if (obj == null || obj.Tag == null)
{
return;
}
LoadContextMenus(obj);
}
private ObjectTreeNode ReadChunk(ChunkTable.ChunkDataEntry entry)
{
var subNode = new ObjectTreeNode(entry.ChunkType.ToString() + $"_{entry.ChunkType.ToString("X")}_Flags_{entry.Flags}_OFFSET_{entry.ChunkOffset}_SIZE_{entry.ChunkSize}");
subNode.Tag = entry.Data;
foreach (var child in entry.SubData)
{
subNode.AddChild(ReadChunk(child));
}
return(subNode);
}
static ObjectTreeNode LoadModelFormat(IModelSceneFormat modelFormat)
{
IFileFormat fileFormat = (IFileFormat)modelFormat;
var scene = modelFormat.ToGeneric();
ObjectTreeNode root = new ObjectTreeNode(fileFormat.FileInfo.FileName)
{
Tag = modelFormat
};
return(root);
}
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 ObjectTreeNode OpenFormat(ImageList imageList, IFileFormat fileFormat)
{
ObjectTreeNode hiearchyNode = null;
if (fileFormat is IArchiveFile)
{
hiearchyNode = LoadArchiveFormat((IArchiveFile)fileFormat);
if (fileFormat is ObjectTreeNode)
{
hiearchyNode.OnBeforeExpand();
foreach (var child in ((ObjectTreeNode)fileFormat).Children)
{
hiearchyNode.AddChild(child);
}
}
}
else if (fileFormat is ObjectTreeNode)
{
hiearchyNode = (ObjectTreeNode)fileFormat;
}
else if (fileFormat is ITextureContainer)
{
hiearchyNode = LoadTextureContainerFormat(imageList, (ITextureContainer)fileFormat);
}
else if (fileFormat is STGenericTexture)
{
hiearchyNode = LoadTextureFormat((STGenericTexture)fileFormat);
}
else if (fileFormat is IModelFormat)
{
hiearchyNode = LoadModelFormat((IModelFormat)fileFormat);
}
else if (fileFormat is IModelSceneFormat)
{
hiearchyNode = LoadModelFormat((IModelSceneFormat)fileFormat);
}
else
{
hiearchyNode = new ObjectTreeNode(fileFormat.FileInfo.FileName)
{
Tag = fileFormat,
}
};
hiearchyNode.OnBeforeExpand();
if (fileFormat is IArchiveFile && fileFormat is ITextureContainer)
{
hiearchyNode.Children.AddRange(LoadTextureContainerFormat(imageList, (ITextureContainer)fileFormat).Children);
}
return(hiearchyNode);
}
public static List <ObjectTreeNode> CreateMaterialChunkList(Stream materialStream, Stream lookupStream, List <ModelChunk.MeshInfo> meshes)
{
List <uint[]> materialPointers = GetLookupPointers(meshes, lookupStream);
for (int i = 0; i < meshes.Count; i++)
{
materialPointers[i] = materialPointers[i].Where(x => x != 0 && x < materialStream.Length).ToArray();
for (int j = 0; j < materialPointers[i].Length; j++)
{
Console.WriteLine($"pointer_{i} { materialPointers[i][j]}");
}
}
materialPointers = materialPointers.OrderBy(x => x[0]).ToList();
List <ObjectTreeNode> meshNodes = new List <ObjectTreeNode>();
using (var reader = new FileReader(materialStream, true))
{
for (int i = 0; i < meshes.Count; i++)
{
ObjectTreeNode meshNode = new ObjectTreeNode();
meshNodes.Add(meshNode);
uint[] pointers = materialPointers[i];
for (int j = 0; j < pointers.Length; j++)
{
uint size = 0;
if (j + 1 < pointers.Length)
{
size = pointers[j + 1] - pointers[j];
}
else if (i + 1 < meshes.Count)
{
size = materialPointers[i + 1][0] - pointers[j];
}
else
{
size = (uint)materialStream.Length - pointers[j];
}
Console.WriteLine($"pointer {pointers[j]} size {size}");
ObjectTreeNode matNode = new ObjectTreeNode($"Mat_{j}");
matNode.Tag = new SubStream(materialStream, pointers[j], size);
meshNode.AddChild(matNode);
}
}
}
return(meshNodes);
}
public DynamicHiearchy(ObjectTreeNode node)
{
ReferenceNode = node;
Label = node.Label;
Tag = node.Tag;
ImageKey = node.ImageKey;
if (node.ChildCount > 0)
{
ImageKey = "Folder";
Children.Add(new ObjectTreeNode("dummy"));
}
}
public override Boolean Filter(Object treeNode)
{
ObjectTreeNode objectTreeNode = treeNode as ObjectTreeNode;
if (objectTreeNode != null)
{
if (objectTreeNode.Class == ObjectClass)
{
return(false);
}
}
return(true);
}
private void nodeTextBoxType_DrawText(object sender, Aga.Controls.Tree.NodeControls.DrawTextEventArgs e)
{
DataTreeNode node = e.Node.Tag as DataTreeNode;
ObjectTreeNode objNode = node as ObjectTreeNode;
if (objNode != null && objNode.ResolvedMember == null)
{
e.TextColor = Color.Red;
}
else
{
e.TextColor = Color.Black;
}
}
private void LoadAnimations()
{
ObjectTreeNode animFolder = new ObjectTreeNode("Animations");
this.AddChild(animFolder);
foreach (var anim in Header.MotionData.Animations)
{
anim.AnimationNextFrame += OnAnimationNextFrame;
animFolder.AddChild(new ObjectTreeNode(anim.Name)
{
Tag = anim
});
}
}
private static ObjectTreeNode FindFolderNode(ObjectTreeNode parent, string path)
{
ObjectTreeNode node = null;
foreach (var child in parent.Children.ToArray())
{
if (child.Label.Equals(path))
{
node = (ObjectTreeNode)child;
break;
}
}
return(node);
}
public ArchiveFileWrapper(ObjectTreeNode node)
{
ArchiveFile = (IArchiveFile)node.Tag;
ReferenceNode = node;
Label = node.Label;
Tag = node.Tag;
ImageKey = node.ImageKey;
if (node.ChildCount > 0)
{
ImageKey = "Folder";
Children.Add(new ObjectTreeNode("dummy"));
}
}
static ObjectTreeNode LoadTextureContainerFormat(ImageList imageList, ITextureContainer textureContainer)
{
IFileFormat fileFormat = (IFileFormat)textureContainer;
ObjectTreeNode root = new ObjectTreeNode(fileFormat.FileInfo.FileName);
root.Tag = fileFormat;
root.ImageKey = "TextureContainer";
foreach (var tex in textureContainer.TextureList)
{
root.AddChild(LoadTextureFormat(tex));
}
return(root);
}
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();
}
}
public void Serilazed_Details_Object_With_ObjectTreeNode_Exists()
{
// arrange
var scenario = new Scenario { Name = ScenarioName, Description = "a scenario for testing trees in details", Status = "failed" };
// A tree containing most important item types that need to be supported
// (same types are allowed for items in tree nodes as for values in Details --> reuse code from
// SerializableDictionary!).
// Root node with string as item
var rootNode = new ObjectTreeNode<object> { Item = "Root" };
rootNode.AddDetail(
"detailKey",
"Tree nodes can have again details, use same serialization as already tested!");
// node one with object description as item
var childWithObject = new ObjectTreeNode<object>();
var objDescription = new ObjectDescription("serviceCall", "AddressWebService.getAdress");
objDescription.AddDetail("justADetail", "just an example");
childWithObject.Item = objDescription;
rootNode.AddChild(childWithObject);
// node two with object reference as item
var childWithObjectRef = new ObjectTreeNode<object>();
var objRef = new ObjectReference("serviceCall", "AddressWebService.getAdress");
childWithObjectRef.Item = objRef;
rootNode.AddChild(childWithObjectRef);
// node three with List of Strings as item
var childWithList = new ObjectTreeNode<IObjectTreeNode<object>>();
var list = new ObjectList<object> { "item1", "item2", "item3" };
childWithList.Item = list;
rootNode.AddChild(childWithList);
// node four with details as item
var childWithDetails = new ObjectTreeNode<object>();
var detailsMap = new Details();
detailsMap.AddDetail("key1", "value1");
detailsMap.AddDetail("key2", "value2");
detailsMap.AddDetail("anyGenericObjectReference", new ObjectReference("serviceCall", "MainDB.getUsers"));
detailsMap.AddDetail(
"anyGenericObject",
new ObjectDescription("configuration", "my_dummy_mocks_configuration.properties"));
childWithDetails.Item = detailsMap;
rootNode.AddChild(childWithDetails);
scenario.AddDetail("exampleTree", rootNode);
// act
writer.SaveScenario(SerializationUseCase, scenario);
writer.Flush();
// assert
Assert.IsTrue(File.Exists(docuFiles.GetScenarioFile(BranchName, BuildName, SerializationUseCase, ScenarioName)));
scenario.Status = "success";
writer.SaveScenario(SerializationUseCase, scenario);
}
