System.Windows.Forms.TreeNodeCollection.Add(string)

Here are the examples of the csharp api System.Windows.Forms.TreeNodeCollection.Add(string) taken from open source projects. By voting up you can indicate which examples are most useful and appropriate.

84 Examples 7

19 Source : DatabaseObjects.cs
with GNU General Public License v3.0
from alexgracianoarj

private void DatabaseObjects_Load(object sender, EventArgs e)
        {
            ConvertToPascalCase = true;

            TreeNode rootTables = triStateTreeView1.Nodes.Add("Tables");

            foreach(DatabaseTable table in tables)
            {
                rootTables.Nodes.Add(table.Name);
            }

            TreeNode rootViews = triStateTreeView1.Nodes.Add("Views");

            foreach (DatabaseView view in views)
            {
                rootViews.Nodes.Add(view.Name);
            }
        }

19 Source : CppClassesTab.cs
with MIT License
from AndresTraks

private void AddModelNode(ModelNodeDefinition modelNode, TreeNode parentTreeNode)
        {
            if (parentTreeNode == null)
            {
                parentTreeNode = clreplacedTree.Nodes.Add("global");
                parentTreeNode.Expand();
            }
            else
            {
                string replacedle = NodereplacedleProvider.Get(modelNode);
                parentTreeNode = parentTreeNode.Nodes.Add(replacedle);
            }
            SetNodeProperties(modelNode, parentTreeNode);

            foreach (var child in modelNode.Children
                .OrderBy(GetNodeTypeOrder)
                .ThenBy(c => c.Name))
            {
                AddModelNode(child, parentTreeNode);
            }
        }

19 Source : frmManager.cs
with MIT License
from AyrA

private void InitFiles()
        {
            tvFiles.Nodes.Clear();
            var Sessions = new Dictionary<string, TreeNode>();
            Thread T = new Thread(delegate ()
            {
                foreach (var FileName in Directory.GetFiles(Program.SaveDirectory, "*.sav", SearchOption.AllDirectories))
                {
                    if (Disposing || IsDisposed)
                    {
                        return;
                    }
                    SaveFile F = null;
                    try
                    {
                        using (var FS = File.OpenRead(FileName))
                        {
                            F = SaveFile.Open(FS);
                        }
                    }
                    catch (Exception ex)
                    {
                        Log.Write(new Exception($"Invalid or locked save file: {FileName}", ex));
                    }

                    if (F != null)
                    {
                        //File is valid game file
                        TreeNode Node = null;
                        var SessionName = string.IsNullOrWhiteSpace(F.SessionName) ? "<no name>" : F.SessionName;
                        if (Sessions.ContainsKey(SessionName))
                        {
                            Node = Sessions[SessionName];
                        }
                        else
                        {
                            Invoke((MethodInvoker)delegate ()
                            {
                                Node = tvFiles.Nodes.Add(SessionName);
                                Sessions.Add(SessionName, Node);
                            });
                        }
                        Invoke((MethodInvoker)delegate ()
                        {
                            var AddedNode = Node.Nodes.Add(Path.GetFileNameWithoutExtension(FileName));
                            AddedNode.Tag = new LocalFileView(FileName, true);
                            Node.ExpandAll();
                        });
                    }
                    else
                    {
                        //File is invalid game file
                        TreeNode InvalidNode = null;
                        if (Sessions.ContainsKey(""))
                        {
                            InvalidNode = Sessions[""];
                        }
                        else
                        {
                            Sessions[""] = InvalidNode = new TreeNode("INVALID");
                            InvalidNode.ForeColor = Color.Red;
                            InvalidNode.BackColor = Color.Yellow;
                        }
                        var Invalid = InvalidNode.Nodes.Add(Path.GetFileNameWithoutExtension(FileName));
                        Invalid.ForeColor = Color.Red;
                        Invalid.Tag = new LocalFileView(FileName, false);
                    }
                }
                //Add invalid nodes on the bottom
                if (Sessions.ContainsKey(""))
                {
                    Log.Write("{0}: At least one invalid save file was found", GetType().Name);
                    Invoke((MethodInvoker)delegate ()
                    {
                        if (Sessions[""].TreeView == null)
                        {
                            tvFiles.Nodes.Add(Sessions[""]);
                            Sessions[""].ExpandAll();
                        }
                    });
                }
            });
            T.Start();
        }

19 Source : frm_Editor.cs
with GNU General Public License v3.0
from cjybyjk

private void LoadFilesAndDirectoriesToTree(string path, TreeNodeCollection treeNodeCollection)
        {
            string[] files = Directory.GetFiles(path);
            string[] dirs = Directory.GetDirectories(path);
            foreach (string item in files)
            {
                treeNodeCollection.Add(Path.GetFileName(item));
            }
            foreach (string item in dirs)
            {
                TreeNode node = treeNodeCollection.Add(Path.GetFileName(item));
                LoadFilesAndDirectoriesToTree(item, node.Nodes);
            }

        }

19 Source : BackupsManager.cs
with GNU General Public License v3.0
from DaneelTrevize

protected virtual void OnBackupSavesChanged( BackupSavesChangedEventArgs e )
        {
            e.Backups = new TreeNode[backupsTree.Count];

            List<KeyValuePair<string,string>> backupsNamesToNewest = new List<KeyValuePair<string,string>>( backupsTree.Count );
            foreach( var saveSet in backupsTree )
            {
                backupsNamesToNewest.Add( new KeyValuePair<string,string>( saveSet.Key, saveSet.Value.Last() ) );   // Pair baseNames and newest timeDirs
            }
            backupsNamesToNewest.Sort( ( pair1, pair2 ) => pair2.Value.CompareTo( pair1.Value ) );                  // Sort by timeDirs

            int i = 0;
            foreach( var pair in backupsNamesToNewest )
            {
                string baseName = pair.Key;
                TreeNode baseNode = new TreeNode( baseName ) { Name = baseName };
                e.Backups[i++] = baseNode;

                SortedSet<string> timeDirs;
                backupsTree.TryGetValue( baseName, out timeDirs );  // Not checking concurrency issues, but then again the nested SortedSets aren't thread-safe anyway...
                foreach( string time in timeDirs.Reverse() )
                {
                    baseNode.Nodes.Add( time );
                }
                baseNode.Expand();
            }

            e.Count = checksummedBackups.Count();
            BackupSavesChanged?.Invoke( this, e );
        }

19 Source : MainForm.cs
with BSD 2-Clause "Simplified" License
from David-JonesDVN

private void JSONToTree(SubNode nodeList, TreeNodeCollection parent)
        {
            for (int i = 0; i < nodeList.Nodes.Count; i++)
            {
                TreeNode newNode = parent.Add(nodeList.Nodes[i].Text);
                newNode.Tag = nodeList.Nodes[i].Games;
                JSONToTree(nodeList.Nodes[i], parent[i].Nodes);
            }
        }

19 Source : ScriptDebugger.cs
with GNU General Public License v2.0
from devmvalvm

private void BuildVarTree(TreeNode parent, ScriptVariable sv)
        {
#if! DEBUG
            try
            {
#endif
            TreeNode type;
            TreeNode value;
            TreeNode count;

            switch (sv.Type)
            {
                case Var_Types.NULL:
                    type = new TreeNode("Type : NULL");
                    value = new TreeNode("Value : NULL");

                    parent.Nodes.Add(type);
                    parent.Nodes.Add(value);
                    break;
                case Var_Types.INT:
                    type = new TreeNode("Type : INT");
                    value = new TreeNode("Value : " + System.Convert.ToInt64(sv.Value).ToString());

                    parent.Nodes.Add(type);
                    parent.Nodes.Add(value);
                    break;
                case Var_Types.DOUBLE:
                    type = new TreeNode("Type : DOUBLE");
                    value = new TreeNode("Value : " + System.Convert.ToDouble(sv.Value).ToString());

                    parent.Nodes.Add(type);
                    parent.Nodes.Add(value);
                    break;
                case Var_Types.STRING:
                    type = new TreeNode("Type : STRING");
                    value = new TreeNode("Value : " + System.Convert.ToString(sv.Value));

                    parent.Nodes.Add(type);
                    parent.Nodes.Add(value);
                    break;
                case Var_Types.FILEWRITER:
                    type = new TreeNode("Type : FILEWRITER");
                    value = new TreeNode("Value : " + ((System.IO.StreamWriter)sv.Value).ToString());

                    parent.Nodes.Add(type);
                    parent.Nodes.Add(value);
                    break;
                case Var_Types.FILEREADER:
                    type = new TreeNode("Type : FILEREADER");
                    value = new TreeNode("Value : " + ((System.IO.StreamReader)sv.Value).ToString());

                    parent.Nodes.Add(type);
                    parent.Nodes.Add(value);
                    break;
                case Var_Types.ARRAYLIST:
                    type = new TreeNode("Type : ARRAYLIST");
                    count = new TreeNode("Count : " + ((System.Collections.ArrayList)sv.Value).Count.ToString());
                    value = new TreeNode("Values");

                    foreach (ScriptVariable child_sv in ((System.Collections.ArrayList)sv.Value))
                    {
                        //TreeNode child_node = new TreeNode(child_sv.Name);
                        TreeNode child_node = new TreeNode("[" + ((System.Collections.ArrayList)sv.Value).IndexOf(child_sv).ToString() + "]");
                        child_node.Nodes.Add("Index : " + ((System.Collections.ArrayList)sv.Value).IndexOf(child_sv).ToString());
                        child_node.Nodes.Add("Name : " + child_sv.Name);

                        BuildVarTree(child_node, child_sv);

                        value.Nodes.Add(child_node);
                    }

                    parent.Nodes.Add(type);
                    parent.Nodes.Add(count);
                    parent.Nodes.Add(value);
                    break;
                case Var_Types.SORTEDLIST:
                    type = new TreeNode("Type : SORTEDLIST");
                    count = new TreeNode("Count : " + ((System.Collections.SortedList)sv.Value).Count.ToString());
                    value = new TreeNode("Values");

                    try
                    {
                        foreach (string key in ((System.Collections.SortedList)sv.Value).Keys)
                        {
                            try
                            {
                                ScriptVariable child_sv = (ScriptVariable)(((System.Collections.SortedList)sv.Value)[key]);

                                //TreeNode child_node = new TreeNode(child_sv.Name);
                                TreeNode child_node = new TreeNode("[" + key + "]");
                                child_node.Nodes.Add("Key : " + key);
                                child_node.Nodes.Add("Name : " + child_sv.Name);

                                BuildVarTree(child_node, child_sv);

                                value.Nodes.Add(child_node);
                            }
                            catch
                            {
                                Globals.l2net_home.Add_Debug("error creating debug leaf for sortedlist - foreach inside " + key);
                            }
                        }
                    }
                    catch
                    {
                        Globals.l2net_home.Add_Debug("error creating debug leaf for sortedlist - foreach " + sv.Name);
                    }

                    parent.Nodes.Add(type);
                    parent.Nodes.Add(count);
                    parent.Nodes.Add(value);
                    break;
                case Var_Types.STACK:
                    type = new TreeNode("Type : STACK");
                    count = new TreeNode("Count : " + ((System.Collections.Stack)sv.Value).Count.ToString());

                    parent.Nodes.Add(type);
                    parent.Nodes.Add(count);
                    break;
                case Var_Types.QUEUE:
                    type = new TreeNode("Type : QUEUE");
                    count = new TreeNode("Count : " + ((System.Collections.Queue)sv.Value).Count.ToString());

                    parent.Nodes.Add(type);
                    parent.Nodes.Add(count);
                    break;
                case Var_Types.CLreplaced:
                    type = new TreeNode("Type : CLreplaced - " + ((Script_ClreplacedData)sv.Value).Name);
                    value = new TreeNode("Values");

                    foreach (ScriptVariable child_sv in ((Script_ClreplacedData)sv.Value)._Variables.Values)
                    {
                        TreeNode child_node = new TreeNode(child_sv.Name);

                        BuildVarTree(child_node, child_sv);

                        value.Nodes.Add(child_node);
                    }

                    parent.Nodes.Add(type);
                    parent.Nodes.Add(value);
                    break;
                case Var_Types.BYTEBUFFER:
                    type = new TreeNode("Type : BYTEBUFFER");
                    count = new TreeNode("Length - " + ((ByteBuffer)sv.Value).Length().ToString());
                    value = new TreeNode("Values");

                    for (int i = 0; i < ((ByteBuffer)sv.Value).Length(); i++)
                    {
                        TreeNode child_node = new TreeNode("0x" + i.ToString("X2") + " : " + "0x" + ((ByteBuffer)sv.Value).GetByte(i).ToString("X2") + " = '" + (char)((ByteBuffer)sv.Value).GetByte(i) + "'");
                        value.Nodes.Add(child_node);
                    }

                    parent.Nodes.Add(type);
                    parent.Nodes.Add(count);
                    parent.Nodes.Add(value);
                    break;
                case Var_Types.WINDOW:
                    type = new TreeNode("Type : WINDOW");

                    parent.Nodes.Add(type);
                    break;
                case Var_Types.THREAD:
                    type = new TreeNode("Type : THREAD");

                    TreeNode thread_info_node_id = new TreeNode("ID : " + ((ScriptThread)sv.Value).ID.ToString());
                    TreeNode thread_info_node_file = new TreeNode("File : " + ((ScriptThread)sv.Value).Current_File);
                    TreeNode thread_info_node_line = new TreeNode("Running Line : " + ((ScriptThread)sv.Value).Line_Pos.ToString());
                    TreeNode thread_info_node_stack = new TreeNode("Current Stack Depth : " + (((ScriptThread)sv.Value).StackHeight + 1).ToString());
                    TreeNode thread_info_node_func = new TreeNode("Function Call Depth : " + ((ScriptThread)sv.Value)._functioncalls.Count.ToString());
                    TreeNode thread_info_node_sub = new TreeNode("Sub Call Depth : " + ((ScriptThread)sv.Value)._subcalls.Count.ToString());
                    TreeNode thread_info_node_sleep = new TreeNode("Sleep Until : " + ((ScriptThread)sv.Value).Sleep_Until.ToLongTimeString());
                    parent.Nodes.Add(thread_info_node_id);
                    parent.Nodes.Add(thread_info_node_file);
                    parent.Nodes.Add(thread_info_node_line);
                    parent.Nodes.Add(thread_info_node_stack);
                    parent.Nodes.Add(thread_info_node_func);
                    parent.Nodes.Add(thread_info_node_sub);
                    parent.Nodes.Add(thread_info_node_sleep);
                    break;
            }
#if! DEBUG
            }
            catch
            {
                //broke our little tree... too bad
                Globals.l2net_home.Add_Debug("error creating debug leaf for var: " + sv.Name + " of type: " + sv.Type.ToString());
            }
#endif
        }

19 Source : CharacterGenForm.cs
with MIT License
from diamondo25

private void LoadData()
        {
            if (_mainNode.GetNode("Base/zmap.img") == null)
            {
                MessageBox.Show("Unable to load Character Gen Form, please load Base, Character and String folders/wzs");
                return;
            }

            LoadBlock("zmap.img", delegate
            {
                var arr = new List<string>();
                foreach (var node in _mainNode.GetNode("Base/zmap.img"))
                {
                    arr.Add(node.Name);
                }

                arr.Reverse();

                zmap = arr.ToArray();
            });

            LoadBlock("smap.img", delegate
            {
                smap = new Dictionary<string, string>();
                foreach (var node in _mainNode.GetNode("Base/smap.img"))
                {
                    smap[node.Name] = node.GetString();
                }
            });

            LoadBlock("Skins", delegate
            {
                TreeNode skinNode = null;
                Invoke((MethodInvoker)delegate { skinNode = allPossibleItems.Nodes.Add("Skin"); });
                foreach (var sn in _mainNode.GetNode("Character/"))
                {
                    if (!sn.Name.EndsWith(".img")) continue;
                    var nameWithoutImg = sn.Name.Remove(sn.Name.Length - 4);
                    var nameWithoutZeroes = nameWithoutImg.TrimStart('0');
                    if (!nameWithoutZeroes.StartsWith("2")) continue;
                    int id;
                    if (!int.TryParse(nameWithoutZeroes, out id)) continue;

                    Invoke((MethodInvoker)delegate
                    {
                        var node = skinNode.Nodes.Add("Skin color " + (id % 1000));
                        node.Tag = new ChosenItem
                        {
                            SelectedPath = node.FullPath,
                            NodePath = sn.GetFullPath(),
                            ID = (id % 1000),
                        };
                    });
                }
            });


            LoadBlock("Equip strings", delegate
            {
                var itemNode = _mainNode.GetNode("String/Item.img");
                ScriptNode scriptnodeToProcess;
                if (itemNode != null)
                {
                    scriptnodeToProcess = itemNode["Eqp"];
                }
                else
                {
                    // Load separate files
                    scriptnodeToProcess = _mainNode.GetNode("String/Eqp.img/Eqp");
                }

                if (scriptnodeToProcess != null)
                {
                    Invoke((MethodInvoker)delegate
                    {
                        LoadScriptNodeToTreeView(scriptnodeToProcess, allPossibleItems.Nodes);
                    });
                }
            });

            Invoke((MethodInvoker)delegate
            {
                filterNodes();
                UseWaitCursor = false;
            });
        }

19 Source : InstanceMonitor.cs
with Mozilla Public License 2.0
from ehsan2022002

private void InitializeView()
        {
            if (InvokeRequired)
                Invoke(new Action(InitializeView));
            else
            {
                Core factory = Factory;
                if (null != factory)
                {
                    IEnumerable<ICOMObject> comObjects = factory.GetRootInstances();

                    foreach (ICOMObject comObject in comObjects)
                    {
                        TreeNode node = View.Nodes.Add(ComObjectName(comObject));
                        node.Tag = comObject.GetHashCode();
                        ICOMObject[] childs = ToArray(comObject.ChildObjects);
                        TreeNode[] childNodes = new TreeNode[childs.Length];
                        for (int i = 0; i < childs.Length; i++)
                        {
                            ICOMObject subObj = childs[i];
                            childNodes[i] = new TreeNode(ComObjectName(subObj));
                            childNodes[i].Tag = subObj.GetHashCode();
                            EnumerateProxies(childNodes[i], ToArray(subObj.ChildObjects));
                        }

                        if (childNodes.Length > 0)
                            node.Nodes.AddRange(childNodes);
                    }
                }
            }
        }

19 Source : InstanceMonitor.cs
with Mozilla Public License 2.0
from ehsan2022002

private void Core_ProxyAdded(Core sender, IEnumerable<ICOMObject> ownerPath, ICOMObject comObject)
        {
            Action method = delegate
            {
                try
                {
                    TreeNode node = FindPath(ownerPath);
                    if (null != node)
                    {
                        TreeNode newNode = node.Nodes.Add(ComObjectName(comObject));
                        newNode.Tag = comObject.GetHashCode();
                        if (HighlightNewProxies)
                        {
                            newNode.BackColor = _highlightColor;
                            HighlightNodes.Add(newNode, DateTime.Now);
                        }
                        if (AutoExpandNodes)
                            View.ExpandAll();
                    }
                    else
                    {
                        TreeNode newNode = View.Nodes.Add(ComObjectName(comObject));
                        newNode.Tag = comObject.GetHashCode();
                        if (HighlightNewProxies)
                        {
                            newNode.BackColor = _highlightColor;
                            HighlightNodes.Add(newNode, DateTime.Now);
                        }
                        if (AutoExpandNodes)
                            View.ExpandAll();
                    }
                }
                catch (Exception exception)
                {
                    ShowOverlayError(exception);
                }
            };
            TryBeginInvoke(method);
        }

19 Source : TrayMenuMonitorItemControl.cs
with Mozilla Public License 2.0
from ehsan2022002

private void Core_ProxyAdded(Core sender, IEnumerable<ICOMObject> ownerPath, ICOMObject comObject)
        {
            Action method = delegate
            {
                try
                {
                    TreeNode node = FindPath(ownerPath);
                    if (null != node)
                    {
                        TreeNode newNode = node.Nodes.Add(ComObjectName(comObject));
                        newNode.Tag = comObject.GetHashCode();
                        if (ViewOptions.HighlightNewNodes)
                        {
                            newNode.BackColor = Color.LightGreen;
                            HighlightNodes.Add(newNode, DateTime.Now);
                        }
                        if (ViewOptions.AutoExpandNodes)
                            HierarchicalGrid.ExpandAll();
                    }
                }
                catch (Exception exception)
                {
                    ShowOverlayError(exception);
                }
            };
            TryBeginInvoke(method);
        }

19 Source : ExceptionStreamView.cs
with MIT License
from GregTheDev

private void AddExceptionNode(TreeNode exceptionNode, MiniDumpException exception)
        {
            exceptionNode.Nodes.Add(String.Format("ExceptionCode: 0x{0:x8}", exception.ExceptionCode));

            if (exception.ExceptionFlags == MiniDumpException.EXCEPTION_NONCONTINUABLE)
                exceptionNode.Nodes.Add("ExceptionFlags: EXCEPTION_NONCONTINUABLE");
            else
                exceptionNode.Nodes.Add(String.Format("ExceptionFlags: {0}", exception.ExceptionFlags));

            exceptionNode.Nodes.Add(String.Format("ExceptionRecord: 0x{0:x8}", exception.ExceptionRecordRaw));
            exceptionNode.Nodes.Add(String.Format("ExceptionAddress: 0x{0:x8}", exception.ExceptionAddress));
            exceptionNode.Nodes.Add(String.Format("NumberParameters: {0}", exception.NumberParameters));

            TreeNode informationNode = exceptionNode.Nodes.Add("ExceptionInformation");

            for (int i = 0; i < exception.ExceptionInformation.Length; i++)
                informationNode.Nodes.Add(String.Format("[{0}]: 0x{1:x8}", i, exception.ExceptionInformation[i]));
        }

19 Source : XmlSourceFrame.cs
with Microsoft Public License
from harborsiem

private TreeNode AddNode(TreeNode parent, XElement element,
            ref int lineNum)
        {
            TreeNode result;
            TreeNode endNode;
            string text = string.Empty;
            if (parent != null)
            {
                result = parent.Nodes.Add(text);
            }
            else
            {
                result = new TreeNode(text);
                _treeNodes.Add(result);
            }
            result.Tag = element;
            result.ImageIndex = lineNum;
            lineNum++;
            if (element.Nodes().Count() > 0)
            {
                bool isXmlElement = false;
                foreach (XNode child in element.Nodes())
                {
                    XElement childElement = child as XElement;
                    if (childElement != null)
                    {
                        isXmlElement = true;
                        AddNode(result, childElement, ref lineNum);
                    }
                }

                if (isXmlElement)
                {
                    text = element.Name.LocalName;
                    if (parent != null)
                    {
                        endNode = parent.Nodes.Add(text);
                    }
                    else
                    {
                        endNode = new TreeNode(text);
                        _treeNodes.Add(endNode);
                    }
                    endNode.ImageIndex = lineNum;
                    lineNum++;
                }
            }
            return result;
        }

19 Source : AttributesForm.cs
with MIT License
from hybridview

private static TreeNode CreateAddParameterNode( TreeNode attributeNode )
        {
            TreeNode addParameter = attributeNode.Nodes.Add( "<add parameter>" );
            addParameter.ImageKey = addParameter.SelectedImageKey = "DoubleBrace";
            addParameter.ForeColor = Color.DarkGray;
            addParameter.Tag = "addparameter";
            return addParameter;
        }

19 Source : UcExplorer.cs
with GNU General Public License v3.0
from iceman1001

private void GetLogicalDrives(TreeView parent)
        {
            // Add Chameleon Mini application folder 
            AddSpecialFolder(@"../..", parent);

            // Some special folders
            AddSpecialFolder(Environment.GetFolderPath(Environment.SpecialFolder.Desktop), parent);
            AddSpecialFolder(Environment.GetFolderPath(Environment.SpecialFolder.MyDoreplacedents), parent);

            // DRIVES
            var drives = Environment.GetLogicalDrives();
            foreach (var drive in drives)
            {
                var di = new DriveInfo(drive);
                int image;
                int selectectimage;
                switch (di.DriveType)
                {
                    case DriveType.CDRom:
                        image = 1;
                        selectectimage = 1;
                        break;
                    case DriveType.Network:
                        image = 2;
                        selectectimage = 2;
                        break;
                    case DriveType.NoRootDirectory:
                        image = 4;
                        selectectimage = 3;
                        break;
                    case DriveType.Unknown:
                        image = 5;
                        selectectimage = 5;
                        break;
                    default:
                        image = 0;
                        selectectimage = 0;
                        break;
                }
                var node = new TreeNode(drive.Substring(0, 1), image, selectectimage) { Tag = di };

                if (di.IsReady)
                {
                    node.Nodes.Add("...");
                }

                parent.Nodes.Add(node);
            }
        }

19 Source : fmGrammarExplorer.cs
with MIT License
from IronyProject

private void AddParseNodeRec(TreeNode parent, ParseTreeNode node) {
      if (node == null) return;
      string txt = node.ToString();
      TreeNode tvNode = (parent == null? tvParseTree.Nodes.Add(txt) : parent.Nodes.Add(txt) );
      tvNode.Tag = node;
      foreach(var child in node.ChildNodes)
        AddParseNodeRec(tvNode, child);
    }

19 Source : fmGrammarExplorer.cs
with MIT License
from IronyProject

private void AddAstNodeRec(TreeNode parent, object astNode) {
      if (astNode == null) return;
      string txt = astNode.ToString();
      TreeNode newNode = (parent == null ?
        tvAst.Nodes.Add(txt) : parent.Nodes.Add(txt));
      newNode.Tag = astNode;
      var iBrowsable = astNode as IBrowsableAstNode;
      if (iBrowsable == null) return;
      var childList = iBrowsable.GetChildNodes();
      foreach (var child in childList)
        AddAstNodeRec(newNode, child);
    }

19 Source : OutlineWindow.cs
with MIT License
from joergkrause

private void RetrieveChildren(IElement element, TreeNode currentNode)
        {
          if (element == null) return;
            string marker = "|";
            if (element.ElementDom.FirstChild == null || element.ElementDom.FirstChild.Equals(element))
                marker = "^";
            if (element.ElementDom.LastChild == null || element.ElementDom.LastChild.Equals(element))
                marker = (marker == "^") ? "()" : "v";

            // add current node
            TreeNode curNode = currentNode.Nodes.Add(String.Format("<{0}>", element.TagName.ToUpper()));
            curNode.Tag = element;
            curNode.ToolTipText = element.OuterHtml.Trim();
            // loop further through children
            if (element.ElementDom.GetChildNodes().Count > 0)
            {
                foreach (IElement child in element.GetChildren())
                {
                    RetrieveChildren(child, curNode);
                }
            }
        }

19 Source : Form1.cs
with GNU Affero General Public License v3.0
from josephworks

private void Form1_Load(object sender, EventArgs e)
        {
            Directory.SetCurrentDirectory("c:\\");
            foreach (string d in Directory.GetDirectories("c:\\"))
            {
                TreeNode t = treeView1.Nodes.Add(d);
                t.Nodes.Add("x");
            }
        }

19 Source : MainFrom.cs
with Microsoft Public License
from keif888

private void AddChildren(int parentID, TreeNode parentNode)
        {
            using (SqlCommand childrenCommand = new SqlCommand("EXEC [dbo].[usp_RetrieveContained] @SrcObjectKey", sqlConnection))
            {
                childrenCommand.Parameters.Add("@SrcObjectKey", SqlDbType.Int).Value = parentID;
                using (SqlDataReader sqlReader = childrenCommand.ExecuteReader())
                {
                    string lastCategory = null;
                    TreeNode categoryNode = null;
                    while (sqlReader.Read())
                    {
                        // get the type category
                        string currentCategory = sqlReader.GetString(2);

                        if (lastCategory != currentCategory)
                        {
                            lastCategory = currentCategory;
                            categoryNode = parentNode.Nodes.Add(currentCategory);
                        }

                        TreeNode objectNode = categoryNode.Nodes.Add(sqlReader.GetInt32(0).ToString(), sqlReader.GetString(1));

                        objectNode.Nodes.Add(new DummyTreeNode());
                    }
                }
            }
        }

19 Source : MSBP.cs
with GNU General Public License v3.0
from KillzXGaming

public void Load(System.IO.Stream stream)
        {
            CanSave = false;
            Text = FileName;

            header = new Header();
            header.Read(new FileReader(stream));

            TreeNode clr1Node = new TreeNode("Colors");
            TreeNode ati2Node = new TreeNode("Attributes");
            TreeNode tgg2Node = new TreeNode("Tag Groups");
            TreeNode syl3Node = new TreeNode("Styles");
            TreeNode cti1Node = new TreeNode("Project Contents");

            for (int i = 0; i < header.entries.Count; i++)
            {
                var node = new TreeNode(header.entries[i].Signature);

                if (header.entries[i] is CTI1)
                {
                    CTI1 cti1 = header.entries[i] as CTI1;

                    for (int t = 0; t < cti1.TextEntries.Count; t++)
                    {
                        cti1Node.Nodes.Add(cti1.TextEntries[t]);
                    }
                }
                else
                    Nodes.Add(node);
            }

            if (clr1Node.Nodes.Count > 0) Nodes.Add(clr1Node);
            if (ati2Node.Nodes.Count > 0) Nodes.Add(ati2Node);
            if (tgg2Node.Nodes.Count > 0) Nodes.Add(tgg2Node);
            if (syl3Node.Nodes.Count > 0) Nodes.Add(syl3Node);
            if (cti1Node.Nodes.Count > 0) Nodes.Add(cti1Node);
        }

19 Source : LM3_DICT.cs
with GNU General Public License v3.0
from KillzXGaming

public void Load(System.IO.Stream stream)
        {
            CanSave = false;

            modelFolder = new LM3_ModelFolder(this); 
            DrawableContainer.Name = FileName;
            Renderer = new LM3_Renderer();
            DrawableContainer.Drawables.Add(Renderer);
            
            Text = FileName;
            using (var reader = new FileReader(stream))
            {
                reader.ByteOrder = Syroot.BinaryData.ByteOrder.LittleEndian;
                uint Identifier = reader.ReadUInt32();
                Unknown0x4 = reader.ReadUInt16(); //Could also be 2 bytes, not sure. Always 0x0401
                IsCompressed = reader.ReadByte() == 1;
                reader.ReadByte(); //Padding
                uint SizeLargestFile = reader.ReadUInt32();
                byte numFiles = reader.ReadByte();
                byte numChunkInfos = reader.ReadByte();
                byte numStrings = reader.ReadByte();
                reader.ReadByte(); //padding

                //Start of the chunk info. A fixed list of chunk information

                for (int i = 0; i < numChunkInfos; i++)
                {
                    ChunkInfo chunk = new ChunkInfo();
                    chunk.Read(reader);
                    ChunkInfos.Add(chunk);
                }

                TreeNode tableNodes = new TreeNode("File Section Entries");
                TreeNode chunkLookupNodes = new TreeNode("Chunk Lookup Files");
                tableNodes.Nodes.Add(chunkLookupNodes);

                Nodes.Add(tableNodes);

                TreeNode stringFolder = new TreeNode("Strings");
                TreeNode chunkTexFolder = new TreeNode("Texture");
                TreeNode chunkModelFolder = new TreeNode("Model");

                long FileTablePos = reader.Position;
                for (int i = 0; i < numFiles; i++)
                {
                    var file = new FileEntry(this);
                    file.Read(reader);
                    fileEntries.Add(file);

                    if (file.DecompressedSize > 0)
                    {
                        file.Text = $"entry {i}";

                        if (i < 52)
                            chunkLookupNodes.Nodes.Add(file);
                        else
                            tableNodes.Nodes.Add(file);
                    }

                    //The first file stores a chunk layout
                    //The second one seems to be a duplicate? 
                    if (i == 0)
                    {
                        using (var tableReader = new FileReader(file.GetData()))
                        {
                            ChunkTable = new LM3_ChunkTable();
                            ChunkTable.Read(tableReader);

                            if (DebugMode)
                            {
                                TreeNode debugFolder = new TreeNode("DEBUG TABLE INFO");
                                Nodes.Add(debugFolder);

                                TreeNode list1 = new TreeNode("Entry List 1");
                                TreeNode list2 = new TreeNode("Entry List 2 ");
                                debugFolder.Nodes.Add(list1);
                                debugFolder.Nodes.Add(list2);
                                debugFolder.Nodes.Add(chunkFolder);

                                foreach (var chunk in ChunkTable.ChunkEntries)
                                {
                                    list1.Nodes.Add($"ChunkType {chunk.ChunkType.ToString("X")} ChunkOffset {chunk.ChunkOffset} ChunkSize {chunk.ChunkSize}  ChunkSubCount {chunk.ChunkSubCount}  Unknown3 {chunk.Unknown3}");
                                }
                                foreach (var chunk in ChunkTable.ChunkSubEntries)
                                {
                                    list2.Nodes.Add($"ChunkType 0x{chunk.ChunkType.ToString("X")} Size {chunk.ChunkSize}   Offset {chunk.ChunkOffset}");
                                }
                            }   
                        }
                    }
                }

                for (int i = 0; i < numStrings; i++)
                {
                    StringList.Add(reader.ReadZeroTerminatedString());
                    stringFolder.Nodes.Add(StringList[i]);
                }

                TreeNode havokFolder = new TreeNode("Havok Physics");

                //Model data block
                //Contains texture hash refs and model headers
                var File052Data = fileEntries[52].GetData();

                //Unsure, layout data??
                var File053Data = fileEntries[53].GetData();

                //Contains model data
                var File054Data = fileEntries[54].GetData();

                //Image header block. Also contains shader data
                var File063Data = fileEntries[63].GetData();

                //Image data block
                var File065Data = fileEntries[65].GetData();

                //Get a list of chunk hashes

                List<uint> ModelHashes = new List<uint>();
                for (int i = 0; i < ChunkTable.ChunkEntries.Count; i++)
                {
                    if (ChunkTable.ChunkEntries[i].ChunkType == DataType.Model)
                    {
                        using (var chunkReader = new FileReader(File052Data, true))
                        {
                            chunkReader.SeekBegin(ChunkTable.ChunkEntries[i].ChunkOffset);
                            uint magic = chunkReader.ReadUInt32();
                            uint hash = chunkReader.ReadUInt32();
                            ModelHashes.Add(hash);
                        }
                    }
                }

                //Set an instance of our current data
                //Chunks are in order, so you build off of when an instance gets loaded
                LM3_Model currentModel = new LM3_Model(this);

                TreeNode currentModelChunk = null;

                TexturePOWE currentTexture = new TexturePOWE();
                ChunkDataEntry currentVertexPointerList = null;

                List<uint> TextureHashes = new List<uint>();

                int chunkId = 0;
                uint modelIndex = 0;
                uint ImageHeaderIndex = 0;
                uint havokFileIndex = 0;
                foreach (var chunk in ChunkTable.ChunkSubEntries)
                {
                    var chunkEntry = new ChunkDataEntry(this, chunk);
                    chunkEntry.Text = $"{chunkId} {chunk.ChunkType.ToString("X")} {chunk.ChunkType} {chunk.ChunkOffset} {chunk.ChunkSize}";

                    switch (chunk.ChunkType)
                    {
                        case SubDataType.HavokPhysics:
                            chunkEntry.DataFile = File052Data;
                            chunkEntry.Text = $"File_{havokFileIndex++}.hkx";
                            havokFolder.Nodes.Add(chunkEntry);
                            break;
                        case SubDataType.TextureHeader:
                            chunkEntry.DataFile = File063Data;

                            //Read the info
                            using (var textureReader = new FileReader(chunkEntry.FileData, true))
                            {
                                currentTexture = new TexturePOWE();
                                currentTexture.HeaderOffset = chunk.ChunkOffset;
                                currentTexture.ImageKey = "texture";
                                currentTexture.SelectedImageKey = currentTexture.ImageKey;
                                currentTexture.Index = ImageHeaderIndex;
                                currentTexture.Read(textureReader);
                                if (DebugMode)
                                    currentTexture.Text = $"Texture {ImageHeaderIndex} {currentTexture.Unknown} {currentTexture.Unknown2} {currentTexture.Unknown3.ToString("X")}";
                                else
                                    currentTexture.Text = $"Texture {currentTexture.ID2.ToString("X")}";

                                if (NLG_Common.HashNames.ContainsKey(currentTexture.ID2))
                                    currentTexture.Text = NLG_Common.HashNames[currentTexture.ID2];

                                textureFolder.Nodes.Add(currentTexture);
                                if (!Renderer.TextureList.ContainsKey(currentTexture.ID2.ToString("x")))
                                    Renderer.TextureList.Add(currentTexture.ID2.ToString("x"), currentTexture);

                                TextureHashes.Add(currentTexture.ID2);

                                ImageHeaderIndex++;
                            }
                            break;
                        case SubDataType.TextureData:
                            chunkEntry.DataFile = File065Data;
                            currentTexture.DataOffset = chunk.ChunkOffset;
                            currentTexture.ImageData = chunkEntry.FileData.ToBytes();
                            break;
                        case SubDataType.ModelInfo:
                            chunkEntry.DataFile = File052Data;

                            uint numModels = chunk.ChunkSize / 12;
                            using (var dataReader = new FileReader(chunkEntry.FileData, true))
                            {
                                for (int i = 0; i < numModels; i++)
                                {
                                    uint hashID = dataReader.ReadUInt32();
                                    uint numMeshes = dataReader.ReadUInt32();
                                    dataReader.ReadUInt32(); //0

                                    string text = hashID.ToString("X");
                                    if (NLG_Common.HashNames.ContainsKey(hashID))
                                        text = NLG_Common.HashNames[hashID];


                                    currentModel.Text = $"Model {modelIndex - 1} [{text}]" ;
                                }
                            }
                            break;
                        case SubDataType.MaterailData:
                            currentModelChunk = new TreeNode($"Model {modelIndex}");
                            chunkFolder.Nodes.Add(currentModelChunk);

                            chunkEntry.DataFile = File052Data;
                            currentModel = new LM3_Model(this);
                            currentModel.ModelInfo = new LM3_ModelInfo();
                            currentModel.Text = $"Model {modelIndex}";
                            currentModel.ModelInfo.Data = chunkEntry.FileData.ToBytes();
                            if (ModelHashes.Count > modelIndex)
                            {
                                currentModel.Text = $"Model {modelIndex} {ModelHashes[(int)modelIndex].ToString("x")}";
                                if (NLG_Common.HashNames.ContainsKey(ModelHashes[(int)modelIndex]))
                                    currentModel.Text = NLG_Common.HashNames[ModelHashes[(int)modelIndex]];
                            }

                            modelIndex++;
                            break;
                        case SubDataType.MeshBuffers:
                            chunkEntry.DataFile = File054Data;
                            currentModel.BufferStart = chunkEntry.Entry.ChunkOffset;
                            currentModel.BufferSize = chunkEntry.Entry.ChunkSize;
                            break;
                        case SubDataType.VertexStartPointers:
                            chunkEntry.DataFile = File052Data;
                            currentVertexPointerList = chunkEntry;
                            break;
                        case SubDataType.SubmeshInfo:
                            chunkEntry.DataFile = File052Data;
                            int MeshCount = (int)chunkEntry.FileData.Length / 0x40;

                            using (var vtxPtrReader = new FileReader(currentVertexPointerList.FileData, true))
                            using (var meshReader = new FileReader(chunkEntry.FileData, true))
                            {
                                for (uint i = 0; i < MeshCount; i++)
                                {
                                    meshReader.SeekBegin(i * 0x40);
                                    LM3_Mesh mesh = new LM3_Mesh();
                                    mesh.Read(meshReader);
                                    currentModel.Meshes.Add(mesh);

                                    var buffer = new LM3_Model.PointerInfo();
                                    buffer.Read(vtxPtrReader, mesh.Unknown3 != 4294967295);
                                    currentModel.VertexBufferPointers.Add(buffer);
                                }
                            }

                            modelFolder.Nodes.Add(currentModel);
                            break;
                        case SubDataType.ModelTransform:
                            chunkEntry.DataFile = File052Data;
                            using (var transformReader = new FileReader(chunkEntry.FileData, true))
                            {
                                //This is possibly very wrong
                                //The data isn't always per mesh, but sometimes is
                                if (transformReader.BaseStream.Length / 0x40 == currentModel.Meshes.Count)
                                {
                                    for (int i = 0; i < currentModel.Meshes.Count; i++)
                                        currentModel.Meshes[i].Transform = transformReader.ReadMatrix4();
                                }
                            }
                            break;
                        case SubDataType.MaterialName:
                            chunkEntry.DataFile = File053Data;
                      /*      using (var matReader = new FileReader(chunkEntry.FileData))
                               {
                                   materialNamesFolder.Nodes.Add(matReader.ReadZeroTerminatedString());
                               }*/
                            break;
                        case SubDataType.UILayoutMagic:
                            chunkEntry.DataFile = File053Data;
                            break;
                        case SubDataType.UILayout:
                            chunkEntry.DataFile = File053Data;
                            break;
                        case SubDataType.BoneData:
                            if (chunk.ChunkSize > 0x40 && currentModel.Skeleton == null)
                            {
                                chunkEntry.DataFile = File052Data;
                                using (var boneReader = new FileReader(chunkEntry.FileData, true))
                                {
                                /*    currentModel.Skeleton = new STSkeleton();
                                    DrawableContainer.Drawables.Add(currentModel.Skeleton);

                                    uint numBones = chunk.ChunkSize / 0x40;
                                    for (int i = 0; i < numBones; i++)
                                    {
                                        boneReader.SeekBegin(i * 0x40);
                                        uint HashID = boneReader.ReadUInt32();
                                        boneReader.ReadUInt32(); //unk
                                        boneReader.ReadUInt32(); //unk
                                        boneReader.ReadSingle(); //0
                                        var Scale = new OpenTK.Vector3(
                                           boneReader.ReadSingle(),
                                           boneReader.ReadSingle(),
                                           boneReader.ReadSingle());
                                        boneReader.ReadSingle(); //0
                                        var Rotate = new OpenTK.Vector3(
                                           boneReader.ReadSingle(),
                                           boneReader.ReadSingle(),
                                           boneReader.ReadSingle());
                                        boneReader.ReadSingle(); //0
                                        var Position = new OpenTK.Vector3(
                                            boneReader.ReadSingle(),
                                            boneReader.ReadSingle(),
                                            boneReader.ReadSingle());
                                        float test = boneReader.ReadSingle(); //1
                                        STBone bone = new STBone(currentModel.Skeleton);
                                        bone.Text = HashID.ToString("x");
                                      //  if (HashNames.ContainsKey(HashID))
                                       //     bone.Text = HashNames[HashID];
                                       // else
                                        //    Console.WriteLine($"bone hash {HashID}");

                                        bone.position = new float[3] { Position.X, Position.Z, Position.Y };
                                        bone.rotation = new float[4] { Rotate.X, Rotate.Y, Rotate.Z, 1 };
                                        bone.scale = new float[3] { 0.2f, 0.2f, 0.2f };

                                        bone.RotationType = STBone.BoneRotationType.Euler;
                                        currentModel.Skeleton.bones.Add(bone);
                                    }

                                    currentModel.Skeleton.reset();
                                    currentModel.Skeleton.update();*/
                                }
                            }
                            break;
                        case (SubDataType)0x5012:
                        case (SubDataType)0x5013:
                        case (SubDataType)0x5014:
                            chunkEntry.DataFile = File063Data;
                            break;
                        case (SubDataType)0x7101:
                        case (SubDataType)0x7102:
                        case (SubDataType)0x7103:
                        case (SubDataType)0x7104:
                        case (SubDataType)0x7106:
                        case (SubDataType)0x6503:
                        case (SubDataType)0x6501:
                            chunkEntry.DataFile = File053Data;
                            break;
                      /*  case (SubDataType)0x7105:
                            chunkEntry.DataFile = File053Data;
                            using (var chunkReader = new FileReader(chunkEntry.FileData))
                            {
                                while (chunkReader.Position <= chunkReader.BaseStream.Length - 8)
                                {
                                    uint hash = chunkReader.ReadUInt32();
                                    uint unk = chunkReader.ReadUInt32();

                                    if (HashNames.ContainsKey(hash))
                                        Console.WriteLine("Hash Match! " + HashNames[hash]);
                                }
                            }
                            break;*/
                        case SubDataType.BoneHashList:
                            chunkEntry.DataFile = File053Data;
                            using (var chunkReader = new FileReader(chunkEntry.FileData, true))
                            {
                                while (chunkReader.Position <= chunkReader.BaseStream.Length - 4)
                                {
                                    uint hash = chunkReader.ReadUInt32();

                                //    if (HashNames.ContainsKey(hash))
                                    //    Console.WriteLine("Hash Match! " + HashNames[hash]);
                                }
                            }
                            break;
                        default:
                            chunkEntry.DataFile = File052Data;
                            break;
                    }

                    if (chunk.ChunkType == SubDataType.MaterailData ||
                        chunk.ChunkType == SubDataType.ModelInfo ||
                        chunk.ChunkType == SubDataType.MeshBuffers ||
                        chunk.ChunkType == SubDataType.MeshIndexTable ||
                        chunk.ChunkType == SubDataType.SubmeshInfo ||
                        chunk.ChunkType == SubDataType.BoneHashList ||
                        chunk.ChunkType == SubDataType.BoneData)
                        currentModelChunk.Nodes.Add(chunkEntry);
                    else if (chunk.ChunkType != SubDataType.HavokPhysics)
                        chunkFolder.Nodes.Add(chunkEntry);

                    chunkId++;
                }

                foreach (var model in modelFolder.Nodes)
                {
                    ((LM3_Model)model).ModelInfo.Read(new FileReader(
                        ((LM3_Model)model).ModelInfo.Data), ((LM3_Model)model), TextureHashes);
                }

                if (havokFolder.Nodes.Count > 0)
                    Nodes.Add(havokFolder);

                if (textureFolder.Nodes.Count > 0)
                    Nodes.Add(textureFolder);

                if (modelFolder.Nodes.Count > 0)
                    Nodes.Add(modelFolder);

                if (stringFolder.Nodes.Count > 0)
                    Nodes.Add(stringFolder);
            }
        }

19 Source : LM2_DICT.cs
with GNU General Public License v3.0
from KillzXGaming

public void Load(System.IO.Stream stream)
        {
            modelFolder = new LM2_ModelFolder(this); 
            DrawableContainer.Name = FileName;
            Renderer = new LM2_Renderer();
            DrawableContainer.Drawables.Add(Renderer);

            Text = FileName;

            var HashNames = NLG_Common.HashNames;

            using (var reader = new FileReader(stream))
            {
                reader.ByteOrder = Syroot.BinaryData.ByteOrder.LittleEndian;
                uint Identifier = reader.ReadUInt32();
                ushort Unknown = reader.ReadUInt16(); //Could also be 2 bytes, not sure. Always 0x0401
                IsCompressed = reader.ReadByte() == 1;
                reader.ReadByte(); //Padding
                uint FileCount = reader.ReadUInt32();
                uint LargestCompressedFile = reader.ReadUInt32();
                reader.SeekBegin(0x2C);
                byte[] Unknowns = reader.ReadBytes((int)FileCount);

                TreeNode tableNodes = new TreeNode("File Section Entries");

                long FileTablePos = reader.Position;
                for (int i = 0; i < FileCount; i++)
                {
                    var file = new FileEntry(this);
                    file.Text = $"entry {i}";
                    file.Read(reader);
                    fileEntries.Add(file);
                    tableNodes.Nodes.Add(file);
                    
                    //The first file stores a chunk layout
                    //The second one seems to be a duplicate? 
                    if (i == 0) 
                    {
                        using (var tableReader = new FileReader(file.GetData()))
                        {
                            ChunkTable = new LM2_ChunkTable();
                            ChunkTable.Read(tableReader);

                            TreeNode debugFolder = new TreeNode("DEBUG TABLE INFO");
                            Nodes.Add(debugFolder);

                            TreeNode list1 = new TreeNode("Entry List 1");
                            TreeNode list2 = new TreeNode("Entry List 2 ");
                            debugFolder.Nodes.Add(tableNodes);
                            debugFolder.Nodes.Add(list1);
                            debugFolder.Nodes.Add(list2);
                            debugFolder.Nodes.Add(chunkFolder);
                            
                            foreach (var chunk in ChunkTable.ChunkEntries)
                            {
                                list1.Nodes.Add($"ChunkType {chunk.ChunkType} ChunkOffset {chunk.ChunkOffset}  Unknown1 {chunk.Unknown1}  ChunkSubCount {chunk.ChunkSubCount}  Unknown3 {chunk.Unknown3}");
                            }
                            foreach (var chunk in ChunkTable.ChunkSubEntries)
                            {
                                list2.Nodes.Add($"ChunkType {chunk.ChunkType} ChunkSize {chunk.ChunkSize} ChunkOffset {chunk.ChunkOffset}");
                            }
                        }
                    }
                }

                //Set an instance of our current data
                //Chunks are in order, so you build off of when an instance gets loaded
                TexturePOWE currentTexture = new TexturePOWE();
                LM2_Model currentModel = new LM2_Model(this);

                //Each part of the file is divided into multiple file/section entries
                //The first entry being the chunk table parsed before this
                //The second file being a duplicate (sometimes slightly larger than the first)
                //The third file stores texture headers, while the fourth one usually has the rest of the main data
                //Any additional ones currently are unknown how they work. Some of which have unknown compression aswell

                byte[] File002Data = fileEntries[2].GetData(); //Get the third file 
                byte[] File003Data = fileEntries[3].GetData(); //Get the fourth file

                List<uint> ModelHashes = new List<uint>();
                for (int i = 0; i < ChunkTable.ChunkEntries.Count; i++)
                {
                    if (ChunkTable.ChunkEntries[i].ChunkType == DataType.Model)
                    {
                 
                    }

                    using (var chunkReader = new FileReader(File002Data))
                    {
                        chunkReader.SeekBegin(ChunkTable.ChunkEntries[i].ChunkOffset);
                        uint magic = chunkReader.ReadUInt32();
                        uint hash = chunkReader.ReadUInt32();
                        ModelHashes.Add(hash);
                        Console.WriteLine($"{ChunkTable.ChunkEntries[i].ChunkType} {hash}");
                    }
                }

                int chunkId = 0;
                uint ImageHeaderIndex = 0;
                uint modelIndex = 0;
                uint messageIndex = 0;
                foreach (var chunk in ChunkTable.ChunkSubEntries)
                {
                    var chunkEntry = new ChunkDataEntry(this, chunk);
                    chunkEntry.Text = $"Chunk {chunk.ChunkType.ToString("X")} {chunk.ChunkType} {chunkId++}";
                    chunkEntries.Add(chunkEntry);
                    chunkFolder.Nodes.Add(chunkEntry);

                    if (chunk.BlockIndex == 0)
                        chunkEntry.DataFile = File002Data;
                    else if (chunk.BlockIndex == 1)
                        chunkEntry.DataFile = File003Data;

                    switch (chunk.ChunkType)
                    {
                        case SubDataType.TextureHeader:

                            //Read the info
                            using (var textureReader = new FileReader(chunkEntry.FileData))
                            {
                                currentTexture = new TexturePOWE();
                                currentTexture.ImageKey = "texture";
                                currentTexture.SelectedImageKey = currentTexture.ImageKey;
                                currentTexture.Index = ImageHeaderIndex;
                                currentTexture.Read(textureReader);
                                currentTexture.Text = $"Texture {ImageHeaderIndex}";
                                textureFolder.Nodes.Add(currentTexture);
                                Renderer.TextureList.Add(currentTexture);

                                Console.WriteLine(currentTexture.ID2);

                                ImageHeaderIndex++;
                            }
                            break;
                        case SubDataType.TextureData:
                            currentTexture.ImageData = chunkEntry.FileData;
                            break;
                        case SubDataType.MaterialData:
                            currentModel = new LM2_Model(this);
                            currentModel.ModelInfo = new LM2_ModelInfo();
                            currentModel.Text = $"Model {modelIndex}";
                            currentModel.ModelInfo.Data = chunkEntry.FileData;
                            modelFolder.Nodes.Add(currentModel);

                            if (ModelHashes.Count > modelIndex)
                            {
                                currentModel.Text = $"Model {modelIndex} {ModelHashes[(int)modelIndex].ToString("x")}";
                                if (HashNames.ContainsKey(ModelHashes[(int)modelIndex]))
                                    currentModel.Text = HashNames[ModelHashes[(int)modelIndex]];
                            }

                            modelIndex++;
                            break;
                        case SubDataType.ModelData:
                            uint numModels = chunk.ChunkSize / 16;
                            using (var dataReader = new FileReader(chunkEntry.FileData))
                            {
                                for (int i = 0; i < numModels; i++)
                                {
                                    uint hashID = dataReader.ReadUInt32();
                                    uint numMeshes = dataReader.ReadUInt32();
                                    dataReader.ReadUInt32(); 
                                    dataReader.ReadUInt32(); //0

                                    Console.WriteLine(hashID);

                                    string text = hashID.ToString("X");
                                    if (HashNames.ContainsKey(hashID))
                                        text = HashNames[hashID];

                                    if (i == 0)
                                        currentModel.Text = text;
                                }
                            }
                            break;
                        case SubDataType.MeshBuffers:
                            currentModel.BufferStart = chunkEntry.Entry.ChunkOffset;
                            currentModel.BufferSize = chunkEntry.Entry.ChunkSize;
                            break;
                        case SubDataType.BoneData:
                            if (chunk.ChunkSize > 0x40 && currentModel.Skeleton == null)
                            {
                                using (var boneReader = new FileReader(chunkEntry.FileData))
                                {
                                    currentModel.Skeleton = new STSkeleton();
                                    DrawableContainer.Drawables.Add(currentModel.Skeleton);

                                    uint numBones = chunk.ChunkSize / 68;
                                    for (int i = 0; i < numBones; i++)
                                    {
                                        boneReader.SeekBegin(i * 68);

                                        uint HashID = boneReader.ReadUInt32();
                                        boneReader.ReadUInt32(); //unk
                                        boneReader.ReadUInt32(); //unk
                                        boneReader.ReadUInt32(); //unk
                                        boneReader.ReadSingle(); //0
                                        var Scale = new OpenTK.Vector3(
                                           boneReader.ReadSingle(),
                                           boneReader.ReadSingle(),
                                           boneReader.ReadSingle());
                                        boneReader.ReadSingle(); //0
                                        var Rotate = new OpenTK.Vector3(
                                           boneReader.ReadSingle(),
                                           boneReader.ReadSingle(),
                                           boneReader.ReadSingle());
                                        boneReader.ReadSingle(); //0
                                        var Position = new OpenTK.Vector3(
                                            boneReader.ReadSingle(),
                                            boneReader.ReadSingle(),
                                            boneReader.ReadSingle());
                                        boneReader.ReadSingle(); //1

                                        STBone bone = new STBone(currentModel.Skeleton);
                                        bone.Text = HashID.ToString("X");
                                        if (NLG_Common.HashNames.ContainsKey(HashID))
                                            bone.Text = NLG_Common.HashNames[HashID];


                                        bone.Position = Position;
                                        bone.EulerRotation = Rotate;
                                        bone.Scale = new OpenTK.Vector3(0.2f, 0.2f, 0.2f);
                                        bone.RotationType = STBone.BoneRotationType.Euler;

                                        currentModel.Skeleton.bones.Add(bone);
                                    }

                                    currentModel.Skeleton.reset();
                                    currentModel.Skeleton.update();
                                }
                            }
                            break;
                        case SubDataType.VertexStartPointers:
                            using (var vtxPtrReader = new FileReader(chunkEntry.FileData))
                            {
                                while (!vtxPtrReader.EndOfStream)
                                    currentModel.VertexBufferPointers.Add(vtxPtrReader.ReadUInt32());
                            }
                            break;
                        case SubDataType.SubmeshInfo:
                            int MeshCount = chunkEntry.FileData.Length / 0x28;
                            using (var meshReader = new FileReader(chunkEntry.FileData))
                            {
                                for (uint i = 0; i < MeshCount; i++)
                                {
                                    LM2_Mesh mesh = new LM2_Mesh();
                                    mesh.Read(meshReader);
                                    currentModel.Meshes.Add(mesh);
                                }
                            }
                            currentModel.ModelInfo.Read(new FileReader(currentModel.ModelInfo.Data), currentModel.Meshes);
                            break;
                        case SubDataType.ModelTransform:
                            using (var transformReader = new FileReader(chunkEntry.FileData))
                            {
                                //This is possibly very wrong
                                //The data isn't always per mesh, but sometimes is
                                if (transformReader.BaseStream.Length / 0x40 == currentModel.Meshes.Count)
                                {
                                    for (int i = 0; i < currentModel.Meshes.Count; i++)
                                        currentModel.Meshes[i].Transform = transformReader.ReadMatrix4();
                                }
                            }
                            break;
                        case SubDataType.BoneHashes:
                            using (var chunkReader = new FileReader(chunkEntry.FileData))
                            {
                                while (chunkReader.Position <= chunkReader.BaseStream.Length - 4)
                                {
                                    uint hash = chunkReader.ReadUInt32();

                                    string strHash = hash.ToString("X");
                                    if (NLG_Common.HashNames.ContainsKey(hash))
                                        strHash = NLG_Common.HashNames[hash];
                                }
                            }
                            break;
                        case (SubDataType)0x7105:
                            using (var chunkReader = new FileReader(chunkEntry.FileData))
                            {
                            
                            }
                            break;
                        case SubDataType.MaterialName:
                            using (var matReader = new FileReader(chunkEntry.FileData))
                            {
                                string mat = matReader.ReadZeroTerminatedString();
                                materialNamesFolder.Nodes.Add(mat);
                            }
                            break;
                        case SubDataType.MessageData:
                            messageFolder.Nodes.Add(new NLOC_Wrapper($"Message Data {messageIndex++}",
                                new System.IO.MemoryStream(chunkEntry.FileData)));
                            break;
                        default:
                            break;
                    }
                }

                foreach (LM2_Model model in modelFolder.Nodes)
                {
                    model.ReadVertexBuffers();
                }

                if (messageFolder.Nodes.Count > 0)
                    Nodes.Add(messageFolder);

                if (modelFolder.Nodes.Count > 0)
                    Nodes.Add(modelFolder);

                if (textureFolder.Nodes.Count > 0)
                    Nodes.Add(textureFolder);

                if (materialNamesFolder.Nodes.Count > 0)
                    Nodes.Add(materialNamesFolder);
            }
        }

19 Source : XLINK.cs
with GNU General Public License v3.0
from KillzXGaming

public void Load(System.IO.Stream stream)
        {
            CanSave = false;

            header = new Header();
            header.Read(new FileReader(stream));

            var userData = new TreeNode("User Data");
        //    Nodes.Add(userData);

            var hashes = new TreeNode("Hashes");
            userData.Nodes.Add(hashes);

            foreach (var hash in header.UserDataTable.CRC32Hashes)
                hashes.Nodes.Add(new TreeNode(hash.ToString("x")));

            var paramDefines = new TreeNode("Param Defines");
       //     Nodes.Add(paramDefines);

            foreach (var param in header.ParamDefineTable.UserParams)
                paramDefines.Nodes.Add(param.Name);
            foreach (var param in header.ParamDefineTable.TriggerParams)
                paramDefines.Nodes.Add(param.Name);
            foreach (var param in header.ParamDefineTable.UserParams)
                paramDefines.Nodes.Add(param.Name);
        }

19 Source : StrikersRLG.cs
with GNU General Public License v3.0
from KillzXGaming

public void Load(System.IO.Stream stream)
        {
            Renderer = new Strikers_Renderer();
            DrawableContainer.Name = FileName;
            DrawableContainer.Drawables.Add(Renderer);

            IsGamecube = Utils.GetExtension(FileName) == ".glg";

            Text = FileName;

            using (var reader = new FileReader(stream))
            {
                reader.SetByteOrder(true);
                reader.ReadUInt32(); //magic
                reader.ReadUInt32(); //fileSize

                //Create a list of all the major sections 
                //The sections are not in order, so we must order them while parsing
                Dictionary<SectionMagic, SectionHeader> SectionLookup = new Dictionary<SectionMagic, SectionHeader>();

                while (!reader.EndOfStream) {
                    uint magic = reader.ReadUInt32();
                    uint sectionSize = reader.ReadUInt32();
                        
                    long pos = reader.Position;
                    Console.WriteLine($"Magic {(SectionMagic)magic} sectionSize {sectionSize}");

                    if (!SectionLookup.ContainsKey((SectionMagic)magic))
                        SectionLookup.Add((SectionMagic)magic, new SectionHeader(sectionSize, pos));

                    //This section will skip sub sections so don't do that
                    if (magic != 0x8001B000)
                        reader.SeekBegin(pos + sectionSize);

                    if (!IsGamecube)
                        reader.Align(4);
                }

                var HashList = NLG_Common.HashNames;

                //Now read our model properly
                //First get our model info

                Matrix4 TransformMatrix = Matrix4.Idenreplacedy;

                uint totalNumMeshes = 0;

                uint modelSize = 12;
                if (IsGamecube)
                    modelSize = 16;
                if (SectionLookup.ContainsKey(SectionMagic.ModelData))
                {
                    var modelHeader = SectionLookup[SectionMagic.ModelData];
                    for (int m = 0; m < modelHeader.Size / modelSize; m++)
                    {
                        reader.SeekBegin(modelHeader.Position + (m * modelSize));
                        if (IsGamecube)
                        {
                            totalNumMeshes += reader.ReadUInt32();
                            reader.ReadUInt32();
                        }
                        else
                        {
                            reader.ReadUInt32();
                            totalNumMeshes += reader.ReadUInt32();
                        }
                    }
                }

                uint meshIndex = 0;
                if (SectionLookup.ContainsKey(SectionMagic.ModelData))
                {
                    var modelHeader = SectionLookup[SectionMagic.ModelData];
                    reader.SeekBegin(modelHeader.Position);
                    uint numModels = modelHeader.Size / modelSize;
                    uint hashId = 0;

                    for (int m = 0; m < numModels; m++)
                    {
                        Model model = new Model();
                        Nodes.Add(model);
                        Models.Add(model);

                        uint numMeshes = 0;
                        reader.SeekBegin(modelHeader.Position + (m * modelSize));
                        if (IsGamecube)
                        {
                            numMeshes = reader.ReadUInt32();
                            hashId = reader.ReadUInt32();
                        }
                        else
                        {
                            hashId = reader.ReadUInt32();
                            numMeshes = reader.ReadUInt32();
                        }

                        model.Text = hashId.ToString("X");
                        if (HashList.ContainsKey(hashId))
                            model.Text = HashList[hashId];



                        if (SectionLookup.ContainsKey(SectionMagic.MeshData))
                        {
                            var meshHeader = SectionLookup[SectionMagic.MeshData];
                            reader.SeekBegin(meshHeader.Position);
                            for (int i = 0; i < numMeshes; i++)
                            {
                                if (IsGamecube)
                                {
                                    uint meshSize = meshHeader.Size / totalNumMeshes;
                                    reader.SeekBegin(meshHeader.Position + ((meshIndex + i) * meshSize));
                                }
                                else
                                    reader.SeekBegin(meshHeader.Position + ((meshIndex + i) * 48));

                                var mesh = new MeshData(reader, IsGamecube);
                                model.Meshes.Add(mesh);
                            }

                            meshIndex += numMeshes;
                        }
                    }

                    if (SectionLookup.ContainsKey(SectionMagic.MatrixData))
                    {
                        var matSection = SectionLookup[SectionMagic.MatrixData];
                        reader.SeekBegin(matSection.Position);
                        TransformMatrix = reader.ReadMatrix4(true);
                    }

                    List<VertexAttribute> Pointers = new List<VertexAttribute>();
                    if (SectionLookup.ContainsKey(SectionMagic.VertexAttributePointerData))
                    {
                        var pointerSection = SectionLookup[SectionMagic.VertexAttributePointerData];
                        reader.SeekBegin(pointerSection.Position);
                        int attributeSize = 8;
                        if (IsGamecube)
                            attributeSize = 6;

                        for (int i = 0; i < pointerSection.Size / attributeSize; i++)
                        {
                            VertexAttribute pointer = new VertexAttribute();
                            if (IsGamecube)
                            {
                                pointer.Offset = reader.ReadUInt32();
                                pointer.Type = reader.ReadByte();
                                pointer.Stride = reader.ReadByte();
                            }
                            else
                            {
                                pointer.Offset = reader.ReadUInt32();
                                pointer.Type = reader.ReadByte();
                                pointer.Stride = reader.ReadByte();
                                reader.ReadUInt16();
                            }

                            Pointers.Add(pointer);
                        }
                    }

                    int pointerIndex = 0;
                    foreach (var model in Models)
                    {
                        for (int i = 0; i < model.Meshes.Count; i++)
                        {
                            RenderableMeshWrapper mesh = new RenderableMeshWrapper();
                            model.Nodes.Add(mesh);
                            Renderer.Meshes.Add(mesh);

                            mesh.Text = model.Meshes[i].HashID.ToString("X");
                            if (HashList.ContainsKey(model.Meshes[i].HashID))
                                mesh.Text = HashList[model.Meshes[i].HashID];

                            string material = model.Meshes[i].MaterialHashID.ToString("X");
                            if (HashList.ContainsKey(model.Meshes[i].MaterialHashID))
                                material = HashList[model.Meshes[i].MaterialHashID];
                            mesh.Nodes.Add(material);

                            var faceSecton = SectionLookup[SectionMagic.IndexData];
                            var vertexSecton = SectionLookup[SectionMagic.VertexData];

                            STGenericPolygonGroup polyGroup = new STGenericPolygonGroup();
                            mesh.PolygonGroups.Add(polyGroup);
                            reader.SeekBegin(faceSecton.Position + model.Meshes[i].IndexStartOffset);


                            List<int> faces = new List<int>();
                            for (int f = 0; f < model.Meshes[i].IndexCount; f++)
                            {
                                if (model.Meshes[i].IndexFormat == 0)
                                    polyGroup.faces.Add(reader.ReadUInt16());
                                else
                                    polyGroup.faces.Add(reader.ReadByte());
                            }

                            if (model.Meshes[i].FaceType == MeshData.PolygonType.TriangleStrips)
                                polyGroup.PrimativeType = STPrimitiveType.TrangleStrips;
                            else
                                polyGroup.PrimativeType = STPrimitiveType.Triangles;

                            if (IsGamecube)
                            {
                                uint size = Pointers[pointerIndex + 1].Offset - Pointers[pointerIndex].Offset;
                                model.Meshes[i].VertexCount = (ushort)(size / Pointers[pointerIndex].Stride);
                            }

                            Console.WriteLine($"mesh {mesh.Text} {model.Meshes[i].VertexCount}");

                            for (int v = 0; v < model.Meshes[i].VertexCount; v++)
                            {
                                Vertex vert = new Vertex();
                                mesh.vertices.Add(vert);

                                for (int a = 0; a < model.Meshes[i].NumAttributePointers; a++)
                                {
                                    var pointer = Pointers[pointerIndex + a];
                                    reader.SeekBegin(vertexSecton.Position + pointer.Offset + (pointer.Stride * v));

                                    if (pointer.Type == 0)
                                    {
                                        if (pointer.Stride == 6)
                                            vert.pos = new Vector3(reader.ReadInt16() / 1024f, reader.ReadInt16() / 1024f, reader.ReadInt16() / 1024f);
                                        else if (pointer.Stride == 12)
                                            vert.pos = new Vector3(reader.ReadSingle(), reader.ReadSingle(), reader.ReadSingle());

                                 //       vert.pos = Vector3.TransformPosition(vert.pos, TransformMatrix);
                                    }

                                    if (pointer.Type == 1)
                                    {
                                        if (pointer.Stride == 3)
                                            vert.nrm = Read_8_8_8_Snorm(reader).Normalized();
                                        else if (pointer.Stride == 12)
                                            vert.nrm = new Vector3(reader.ReadSingle(), reader.ReadSingle(), reader.ReadSingle());
                                    }
                                    if (pointer.Type == 3)
                                    {
                                        vert.uv0 = new Vector2(reader.ReadUInt16() / 1024f, reader.ReadUInt16() / 1024f);
                                    }


                                    if (pointer.Type == 0x67)
                                    {
                                        vert.pos = new Vector3(reader.ReadSingle(), reader.ReadSingle(), reader.ReadSingle());
                                    }
                                    if (pointer.Type == 0xFE)
                                    {
                                        vert.nrm = new Vector3(reader.ReadSingle(), reader.ReadSingle(), reader.ReadSingle());
                                    }
                                    if (pointer.Type == 0x26)
                                    {
                                        vert.uv0 = new Vector2(reader.ReadUInt16() / 1024f, reader.ReadUInt16() / 1024f);
                                    }
                                    if (pointer.Type == 0xCC)
                                    {
                                        vert.uv0 = new Vector2(reader.ReadUInt16() / 1024f, reader.ReadUInt16() / 1024f);
                                    }
                                    if (pointer.Type == 0x17)
                                    {
                                        vert.uv1 = new Vector2(reader.ReadUInt16() / 1024f, reader.ReadUInt16() / 1024f);
                                    }
                                    if (pointer.Type == 0xD4)
                                    {
                                        vert.boneIds = new List<int>() { reader.ReadByte(), reader.ReadByte(), reader.ReadByte(), reader.ReadByte() };
                                    }
                                    if (pointer.Type == 0xB0)
                                    {
                                        vert.boneWeights = new List<float>() { reader.ReadSingle(), reader.ReadSingle(), reader.ReadSingle(), reader.ReadSingle() };
                                    }
                                }
                            }

                            mesh.TransformPosition(new Vector3(0), new Vector3(-90, 0, 0), new Vector3(1));

                            pointerIndex += model.Meshes[i].NumAttributePointers;
                        }


                        for (int i = 0; i < model.Meshes.Count; i++)
                        {
                            if (IsGamecube)
                            {
                                var renderedMesh = (RenderableMeshWrapper)Renderer.Meshes[i];
                                renderedMesh.Material = new STGenericMaterial();

                                string diffuseName = model.Meshes[i].TexturHashID.ToString("X");
                                if (HashList.ContainsKey(model.Meshes[i].TexturHashID))
                                    diffuseName = HashList[model.Meshes[i].TexturHashID];

                                var texUnit = 1;
                                renderedMesh.Material.TextureMaps.Add(new STGenericMatTexture()
                                {
                                    textureUnit = texUnit++,
                                    Type = STGenericMatTexture.TextureType.Diffuse,
                                    Name = diffuseName,
                                });
                            }

                            if (SectionLookup.ContainsKey(SectionMagic.MaterialData))
                            {
                                var materialSecton = SectionLookup[SectionMagic.MaterialData];
                                reader.SeekBegin(materialSecton.Position + model.Meshes[i].MaterialOffset);

                                var renderedMesh = (RenderableMeshWrapper)Renderer.Meshes[i];
                                renderedMesh.Material = new STGenericMaterial();

                                switch (model.Meshes[i].MaterailPreset)
                                {
                                    case MaterailPresets.EnvDiffuseDamage:
                                        {
                                            uint diffuseMapHashID = reader.ReadUInt32();
                                            uint diffuseMapParam = reader.ReadUInt32();

                                            string diffuseName = diffuseMapHashID.ToString("X");
                                            if (HashList.ContainsKey(diffuseMapHashID))
                                                diffuseName = HashList[diffuseMapHashID];

                                            var texUnit = 1;
                                            renderedMesh.Material.TextureMaps.Add(new STGenericMatTexture()
                                            {
                                                textureUnit = texUnit++,
                                                Type = STGenericMatTexture.TextureType.Diffuse,
                                                Name = diffuseName,
                                            });
                                        }
                                        break;
                                    default:
                                        {
                                            uint diffuseMapHashID = reader.ReadUInt32();
                                            string diffuseName = diffuseMapHashID.ToString("X");
                                            if (HashList.ContainsKey(diffuseMapHashID))
                                                diffuseName = HashList[diffuseMapHashID];

                                            var texUnit = 1;
                                            renderedMesh.Material.TextureMaps.Add(new STGenericMatTexture()
                                            {
                                                textureUnit = texUnit++,
                                                Type = STGenericMatTexture.TextureType.Diffuse,
                                                Name = diffuseName,
                                            });
                                        }
                                        break;
                                }
                            }
                        }
                    }


                    List<BoneListEntry> BoneLists = new List<BoneListEntry>();

                    List<uint> boneHashOrder = new List<uint>();

                    TreeNode parentBoneList = new TreeNode("Bone List");
                    Nodes.Add(parentBoneList);

                    if (SectionLookup.ContainsKey(SectionMagic.SkeletonData))
                    {
                        var skeletonSection = SectionLookup[SectionMagic.SkeletonData];
                        reader.SeekBegin(skeletonSection.Position);

                        //Read all sub sections
                        while (reader.Position < skeletonSection.Position + skeletonSection.Size)
                        {
                            uint magic = reader.ReadUInt32();
                            uint sectionSize = reader.ReadUInt32();

                            long pos = reader.Position;
                            BoneListEntry entry = new BoneListEntry();
                            BoneLists.Add(entry);

                            //Bone hashes appear for each mesh if it uses rigging
                            //Meshes index these lists for rigging
                            if ((SectionMagic)magic == SectionMagic.BoneHashes)
                            {
                                TreeNode boneListNode = new TreeNode("Mesh Bone List");
                                parentBoneList.Nodes.Add(boneListNode);

                                uint numHashes = sectionSize / 4;
                                for (int i = 0; i < numHashes; i++)
                                {
                                    entry.Hashes.Add(reader.ReadUInt32());
                                    if (IsGamecube)
                                        reader.ReadUInt32();

                                    string hashName = entry.Hashes[i].ToString("X");
                                    if (HashList.ContainsKey(entry.Hashes[i]))
                                        hashName = HashList[entry.Hashes[i]];

                                    boneListNode.Nodes.Add(hashName);
                                }
                            }
                            if ((SectionMagic)magic == SectionMagic.BoneData)
                            {
                                uint numBones = sectionSize / 68;
                                for (int i = 0; i < numBones; i++)
                                {
                                    reader.SeekBegin(pos + i * 68);
                                    BoneEntry bone = new BoneEntry();
                                    bone.HashID = reader.ReadUInt32();
                                    reader.ReadUInt32(); //unk
                                    reader.ReadUInt32(); //unk
                                    reader.ReadUInt32(); //unk
                                    reader.ReadSingle(); //0
                                    bone.Scale = new Vector3(
                                       reader.ReadSingle(),
                                       reader.ReadSingle(),
                                       reader.ReadSingle());
                                    reader.ReadSingle(); //0
                                    bone.Rotate = new Vector3(
                                       reader.ReadSingle(),
                                       reader.ReadSingle(),
                                       reader.ReadSingle());
                                    reader.ReadSingle(); //0
                                    bone.Translate = new Vector3(
                                        reader.ReadSingle(),
                                        reader.ReadSingle(),
                                        reader.ReadSingle());
                                    reader.ReadSingle(); //1

                              //      bone.Translate = Vector3.TransformPosition(bone.Translate, TransformMatrix);

                                    entry.Bones.Add(bone);
                                }
                            }

                            reader.SeekBegin(pos + sectionSize);
                        }
                    }

                    List<BoneEntry> BoneListSorted = new List<BoneEntry>();
                    foreach (var hash in boneHashOrder)
                    {
                        foreach (var boneList in BoneLists)
                        {
                            foreach (var bone in boneList.Bones)
                                if (bone.HashID == hash)
                                    BoneListSorted.Add(bone);
                        }
                    }

                    STSkeleton skeleton = new STSkeleton();
                    DrawableContainer.Drawables.Add(skeleton);

                    foreach (var boneList in BoneLists)
                    {
                        foreach (var bone in boneList.Bones)
                        {
                            STBone stBone = new STBone(skeleton);
                            skeleton.bones.Add(stBone);
                            stBone.Text = bone.HashID.ToString("X");
                            if (HashList.ContainsKey(bone.HashID))
                                stBone.Text = HashList[bone.HashID];

                            stBone.Position = bone.Translate;
                            stBone.EulerRotation = bone.Rotate;
                            stBone.Scale = new Vector3(0.2f, 0.2f, 0.2f);

                            stBone.RotationType = STBone.BoneRotationType.Euler;
                        }
                    }


                    skeleton.reset();
                    skeleton.update();

                    TreeNode skeletonNode = new TreeNode("Skeleton");
                    Nodes.Add(skeletonNode);
                    foreach (var bone in skeleton.bones)
                    {
                        if (bone.Parent == null)
                            skeletonNode.Nodes.Add(bone);
                    }
                }
            }
        }

19 Source : ByamlEditor.cs
with GNU General Public License v3.0
from KillzXGaming

void parseDictNode(IDictionary<string, dynamic> node, TreeNodeCollection addto)
        {
            int dictionaryIndex = 0;
            int arrayIndex = 0;
            int pathPointIndex = 0;

            foreach (string k in node.Keys)
            {
                if (node[k] is IDictionary<string, dynamic> ||
                    node[k] is IList<dynamic> ||
                    node[k] is IList<ByamlPathPoint>)
                {
                    TreeNode current = addto.Add(k);

                    if (node[k] is IDictionary<string, dynamic>)
                    {
                        current.Text += $" : <Dictionary> {dictionaryIndex++}";
                        current.Tag = node[k];

                        if (HasDynamicListChildren(current))
                            current.Nodes.Add("✯✯dummy✯✯"); //a text that can't be in a byml
                    }
                    else if (node[k] is IList<dynamic>)
                    {
                        current.Text += $" : <Array> {arrayIndex++}";
                        current.Tag = ((IList<dynamic>)node[k]);

                        if (HasDynamicListChildren(current))
                            current.Nodes.Add("✯✯dummy✯✯");
                    }
                    else if (node[k] is IList<ByamlPathPoint>)
                    {
                        current.Text += $" : <PathPointArray> {pathPointIndex++}";
                        current.Tag = ((IList<ByamlPathPoint>)node[k]);
                        parsePathPointArray(node[k], current.Nodes);
                    }
                }
            }
        }

19 Source : ByamlEditor.cs
with GNU General Public License v3.0
from KillzXGaming

void parseArrayNode(IList<dynamic> list, TreeNodeCollection addto)
        {
            int dictionaryIndex = 0;
            int arrayIndex = 0;
            int pathPointIndex = 0;


            int index = 0;
            foreach (dynamic k in list)
            {
                if (k is IDictionary<string, dynamic> ||
                    k is IList<dynamic> ||
                    k is IList<ByamlPathPoint>)
                {
                    if (k is IDictionary<string, dynamic>)
                    {
                        TreeNode current = addto.Add($"<Dictionary> {dictionaryIndex++}");
                        current.Tag = ((IDictionary<string, dynamic>)k);

                        if (HasDynamicListChildren(current))
                            current.Nodes.Add("✯✯dummy✯✯");
                    }
                    else if (k is IList<dynamic>)
                    {
                        TreeNode current = addto.Add($"<Array> {arrayIndex++}");
                        current.Tag = ((IList<dynamic>)k);
                    }
                    else if (k is IList<ByamlPathPoint>)
                    {
                        TreeNode current = addto.Add($"<PathPointArray> {pathPointIndex++}");
                        current.Tag = ((IList<ByamlPathPoint>)k);
                        parsePathPointArray(k, current.Nodes);
                    }
                }

                index++;
            }
        }

19 Source : ByamlEditor.cs
with GNU General Public License v3.0
from KillzXGaming

private void BeforeExpand(object sender, TreeViewCancelEventArgs e)
        {
            if (e.Node.Tag != null && e.Node.Nodes.Count == 1 && e.Node.Nodes[0].Text == "✯✯dummy✯✯")
            {
                e.Node.Nodes.Clear();
                if (((dynamic)e.Node.Tag).Count == 0)
                {
                    e.Node.Nodes.Add("<Empty>");
                    return;
                }
                if (e.Node.Tag is IList<dynamic>) parseArrayNode((IList<dynamic>)e.Node.Tag, e.Node.Nodes);
                else if (e.Node.Tag is IDictionary<string, dynamic>) parseDictNode((IDictionary<string, dynamic>)e.Node.Tag, e.Node.Nodes);
                else throw new Exception("WTF");
            }
        }

19 Source : TreeViewTest.cs
with MIT License
from KirillOsenkov

private void FillStandardTreeView()
		{
			TreeNode t1 = treeView1.Nodes.Add("test1");
			TreeNode t11 = t1.Nodes.Add("subtest11");
			TreeNode t12 = t1.Nodes.Add("subtest12");
			TreeNode t2 = treeView1.Nodes.Add("test2");
			TreeNode t21 = t2.Nodes.Add("subtest21");
			TreeNode t211 = t21.Nodes.Add("subtest211");
			TreeNode t22 = t2.Nodes.Add("subtest22");
			treeView1.ExpandAll();
		}

19 Source : FrmMain.cs
with Apache License 2.0
from kwwwvagaa

private void FrmMain_Load(object sender, EventArgs e)
        {
            try
            {
                ControlHelper.FreezeControl(this, true);
                this.tvMenu.Nodes.Add("关于授权");
                TreeNode tnForm = new TreeNode("  窗体");
                tnForm.Nodes.Add("提示窗体");
                tnForm.Nodes.Add("多输入窗体");
                tnForm.Nodes.Add("气泡提示窗体");
                tnForm.Nodes.Add("有返回的窗体");
                tnForm.Nodes.Add("等待窗体");
                tnForm.Nodes.Add("仅有标题的窗体");
                tnForm.Nodes.Add("确定取消窗体1");
                tnForm.Nodes.Add("确定取消窗体2");
                tnForm.Nodes.Add("资源加载窗体");
                this.tvMenu.Nodes.Add(tnForm);

                TreeNode tnControl = new TreeNode("  控件");
                tnControl.Nodes.Add("表单控件");
                tnControl.Nodes.Add("按钮");
                tnControl.Nodes.Add("选项卡");
                tnControl.Nodes.Add("树");
                tnControl.Nodes.Add("列表");
                tnControl.Nodes.Add("平铺列表");
                tnControl.Nodes.Add("垂直导航");
                tnControl.Nodes.Add("横向列表");
                tnControl.Nodes.Add("分页控件");
                tnControl.Nodes.Add("表格");
                tnControl.Nodes.Add("表格-自定义单元格");
                tnControl.Nodes.Add("树表格");
                tnControl.Nodes.Add("进度条");
                tnControl.Nodes.Add("步骤控件");
                tnControl.Nodes.Add("面包屑导航");
                tnControl.Nodes.Add("文字提示");
                tnControl.Nodes.Add("滚动文字");
                tnControl.Nodes.Add("滑块");
                tnControl.Nodes.Add("水波");
                tnControl.Nodes.Add("有标题的面板");
                tnControl.Nodes.Add("图标");
                tnControl.Nodes.Add("滚动条");
                tnControl.Nodes.Add("控件水印");
                tnControl.Nodes.Add("表单验证");
                tnControl.Nodes.Add("图片采样控件");
                tnControl.Nodes.Add("倒影");
                tnControl.Nodes.Add("内置颜色");
                tnControl.Nodes.Add("导航菜单");
                tnControl.Nodes.Add("扩展导航菜单");
                tnControl.Nodes.Add("类Office导航菜单");
                tnControl.Nodes.Add("分割线标签");
                tnControl.Nodes.Add("时间轴");
                tnControl.Nodes.Add("穿梭框");
                tnControl.Nodes.Add("引用区块");
                tnControl.Nodes.Add("右键菜单");
                tnControl.Nodes.Add("日历备忘录");
                this.tvMenu.Nodes.Add(tnControl);

                TreeNode tnCharts = new TreeNode("  图表");
                tnCharts.Nodes.Add("组织结构图");
                tnCharts.Nodes.Add("滚动图表");
                tnCharts.Nodes.Add("雷达图");
                tnCharts.Nodes.Add("金字塔图");
                tnCharts.Nodes.Add("Live Charts");
                this.tvMenu.Nodes.Add(tnCharts);

                TreeNode tnFactory = new TreeNode("  工业控件");
                tnFactory.Nodes.Add("LED文字");
                tnFactory.Nodes.Add("仪表");
                tnFactory.Nodes.Add("管道");
                tnFactory.Nodes.Add("阀门");
                tnFactory.Nodes.Add("鼓风机");
                tnFactory.Nodes.Add("传送带");
                tnFactory.Nodes.Add("警示灯");
                tnFactory.Nodes.Add("箭头");
                tnFactory.Nodes.Add("温度计");
                tnFactory.Nodes.Add("转子");
                tnFactory.Nodes.Add("多通道转盘");
                tnFactory.Nodes.Add("椭圆转盘");
                tnFactory.Nodes.Add("转盘");
                tnFactory.Nodes.Add("注射器");
                this.tvMenu.Nodes.Add(tnFactory);
                AddControl(new UCShouQuan());
            }
            finally
            {
                ControlHelper.FreezeControl(this, false);
            }
        }

19 Source : frmPresetManager.cs
with GNU General Public License v3.0
from Legolash2o

private void LoadPresetList() {
			tvPreset.Nodes.Clear();
			Application.DoEvents();
			if (Directory.Exists(cMain.Root + "Last Sessions")) {
				foreach (string P in Directory.GetFiles(cMain.Root + "Last Sessions", "*.ini", SearchOption.AllDirectories)) {
					try {
						var TNP = new TreeNode();

						string T = P;
						while (T.ContainsIgnoreCase("\\")) {
							T = T.Substring(1);
						}

						T = T.ReplaceIgnoreCase(".ini", "");
                        
						TNP.Text = T;

						TNP.Tag = P;
						string Ps = "";
						using (var SR = new StreamReader(P)) {
							Ps = SR.ReadToEnd();
						}
						string Cat = "";
						if (!Ps.Substring(0, 4).StartsWithIgnoreCase("*AIO")) { continue; }

						foreach (string S in Ps.Split(Environment.NewLine.ToCharArray())) {
							if (S.StartsWithIgnoreCase("*") && S.ContainsIgnoreCase("|")) {
								TNP.Text = TNP.Text.PadRight(80, ' ');
								string Info = S.Substring(5);
								foreach (string data in Info.Split('|')) {
									TNP.Text += " |   " + data;
								}

							}//&& S.ContainsIgnoreCase(".")) {  }
							try {
								if (!string.IsNullOrEmpty(S) && !S.StartsWithIgnoreCase("*")) {
									if (S.StartsWithIgnoreCase("#")) {
										Cat = S.Substring(1);
										TNP.Nodes.Add(Cat);
									}
									else {
										foreach (TreeNode TN in TNP.Nodes) {
											if (TN.Text == Cat) {
												TN.Nodes.Add(S);

												break;
											}
										}
									}
								}
							}
							catch {
							}
						}
						tvPreset.Nodes.Insert(0, TNP);

						TNP.Expand();
						foreach (TreeNode TP in TNP.Nodes) {
							if (TP.Nodes.Count == 0) {
								TP.Remove();
							}
							else {
								foreach (TreeNode TP2 in TP.Nodes) {
									TP2.Tag = "C";
									HideCheckBox(tvPreset, TP2);
								}
							}
						}
					}
					catch { }
				}
			}

			if (tvPreset.Nodes.Count > 0) {
				cmdLoadPreset.Visible = true;
				cmdExportPreset.Visible = true;
				cmdDeletePreset.Visible = true;
				cmdRenamePreset.Visible = true;
				cmdSkip.Text = "Skip (No Preset)";
			}
			else {
				cmdLoadPreset.Visible = false;
				cmdExportPreset.Visible = false;
				cmdDeletePreset.Visible = false;
				cmdRenamePreset.Visible = false;
				cmdSkip.Text = "Continue (No Preset)";
			}
		}

19 Source : MessageExtensions.cs
with MIT License
from lextudio

public static void Fill(this ISnmpMessage message, TreeView tree)
        {
            var messageNode = tree.Nodes.Add(string.Format("Version {0}", message.Version));
            if (message.Version == VersionCode.V3)
            {
                var header = messageNode.Nodes.Add("header");
                header.Nodes.Add(string.Format("message id {0}", message.Header.MessageId));
                header.Nodes.Add(string.Format("max size {0}", message.Header.MaxSize));
                header.Nodes.Add(string.Format("security level {0}", message.Header.SecurityLevel.GetString()));
            }

            var parameter = messageNode.Nodes.Add("parameters");
            if (message.Version == VersionCode.V3)
            {
                parameter.Nodes.Add(string.Format("user {0}", message.Parameters.UserName));
                parameter.Nodes.Add(string.Format("engine id {0}", message.Parameters.EngineId.ToHexString()));
                parameter.Nodes.Add(string.Format("engine boots {0}", message.Parameters.EngineBoots));
                parameter.Nodes.Add(string.Format("engine time {0}", message.Parameters.EngineTime));
                parameter.Nodes.Add(string.Format("checksum {0}", message.Parameters.AuthenticationParameters.ToHexString()));
                parameter.Nodes.Add(string.Format("checksum broken {0}", message.Parameters.IsInvalid));
                parameter.Nodes.Add(string.Format("encryption token {0}", message.Parameters.PrivacyParameters.ToHexString()));
            }
            else
            {
                parameter.Nodes.Add(string.Format("community {0}", message.Parameters.UserName));
            }

            var scope = messageNode.Nodes.Add("scope");
            if (message.TypeCode() == SnmpType.Unknown)
            {
                scope.Nodes.Add("decryption error");
            }
            else if (OctetString.IsNullOrEmpty(message.Parameters.PrivacyParameters))
            {
                if (message.Version == VersionCode.V3)
                {
                    scope.Nodes.Add(string.Format("context name {0}", message.Scope.ContextName));
                    scope.Nodes.Add(string.Format("context engine id {0}", message.Scope.ContextEngineId.ToHexString()));
                }

                var pdu = scope.Nodes.Add(string.Format("pdu type {0}", message.Scope.Pdu.TypeCode));
                pdu.Nodes.Add(string.Format("request id {0}", message.Scope.Pdu.RequestId));
                pdu.Nodes.Add(string.Format("error status {0}", message.Scope.Pdu.ErrorStatus.ToErrorCode()));
                pdu.Nodes.Add(string.Format("error index {0}", message.Scope.Pdu.ErrorIndex));
                var variables = pdu.Nodes.Add(string.Format("variable count {0}", message.Scope.Pdu.Variables.Count));
                foreach (var variable in message.Scope.Pdu.Variables)
                {
                    variables.Nodes.Add(variable.ToString());
                }
            }
            else
            {
                scope.Nodes.Add("encrypted data");
            }

            tree.ExpandAll();
        }

19 Source : Form.cs
with GNU General Public License v3.0
from LoadLibraryW

private void FileDataTreeView_AfterExpand(object sender, TreeViewEventArgs e)
        {
            TreeNode dat = e.Node;
            if (dat.Parent != null) return;
            if (dat.Nodes[0].Text == "Decompiling...")
            {
                // Prevent races
                RecompileDatButton.Enabled = false;
                RestoreDatButton.Enabled = false;

                string datFile = Path.Combine(GameDirectoryPathTextBox.Text, @"contents\Local\NCWEST\data\", dat.Text);

                Debug.WriteLine(GameDirectoryPathTextBox);
                Debug.WriteLine(GameDirectoryPathTextBox.Text);

                var worker = new BackgroundWorker();
                worker.DoWork += (_, arg) =>
                {
                    BNSDat.BNSDat.Extract(datFile, (number, of) => worker.ReportProgress(0, new DATState
                    {
                        node = dat,
                        number = number,
                        of = of
                    }), datFile.Contains("64"));
                };

                worker.RunWorkerCompleted += (_, arg) =>
                {
                    if (arg.Error != null)
                    {
                        MessageBox.Show(arg.Error.Message);
                        dat.Collapse();
                        dat.Nodes.Clear();
                        dat.Nodes.Add("Decompiling...");
                    }
                    else
                    {
                        dat.Nodes.Clear();
                        var Q = new LinkedList<KeyValuePair<TreeNode, string>>();
                        Q.AddFirst(new KeyValuePair<TreeNode, string>(dat, datFile + ".files"));


                        while (Q.Count > 0)
                        {
                            var kv = Q.First();
                            Q.RemoveFirst();

                            var node = kv.Key;
                            var path = kv.Value;

                            foreach (string decompFile in Directory.GetFiles(path))
                            {
                                node.Nodes.Add(new TreeNode { Text = Path.GetFileName(decompFile), Name = decompFile });
                            }

                            foreach (string decompDir in Directory.GetDirectories(path))
                            {
                                var newNode = new TreeNode { Text = Path.GetFileName(decompDir), Name = decompDir };
                                node.Nodes.Add(newNode);
                                Q.AddFirst(new KeyValuePair<TreeNode, string>(newNode, decompDir));
                            }
                        }

                        if (WorkerDenominator == 0)
                        {
                            // Allow restoration and recompilation now
                            RecompileDatButton.Enabled = true;
                            RestoreDatButton.Enabled = true;
                            LaunchButton.Enabled = true;
                        }
                    }
                };

                worker.ProgressChanged += Editor_ProgressChanged;
                worker.WorkerReportsProgress = true;
                worker.RunWorkerAsync();
            }
        }

19 Source : Form1.cs
with GNU Lesser General Public License v2.1
from Mag-nus

private void btnLoadFromDB_Click(object sender, EventArgs e)
		{
			this.Enabled = false;

			XmlSerializer serializer = new XmlSerializer(typeof(List<ExtendedMyWorldObject>));

			CharactersTreeView.Nodes.Clear();
			boundList.Clear();

			Dictionary<string, int> armorSets = new Dictionary<string, int>();

			string txtInventoryRootPathOrig = txtInventoryRootPath.Text;

            string[] serverFolderPaths;

            try
            {
                serverFolderPaths = Directory.GetDirectories(txtInventoryRootPath.Text);
            }
            catch
            {
                this.Enabled = true;
                return;
            }

			for (int i = 0; i < serverFolderPaths.Length; i++)
			{
				string serverName = serverFolderPaths[i].Substring(serverFolderPaths[i].LastIndexOf(Path.DirectorySeparatorChar) + 1, serverFolderPaths[i].Length - serverFolderPaths[i].LastIndexOf(Path.DirectorySeparatorChar) - 1);

				TreeNode serverNode = CharactersTreeView.Nodes.Add(serverName);

				string[] characterFilePaths = Directory.GetFiles(serverFolderPaths[i], "*.Inventory.xml", SearchOption.AllDirectories);

				for (int j = 0; j < characterFilePaths.Length; j++)
				{
					txtInventoryRootPath.Text = txtInventoryRootPathOrig + "   Server " + (i + 1) + " of " + serverFolderPaths.Length + ", Character " + (j + 1) + " of " + characterFilePaths.Length;
					txtInventoryRootPath.Refresh();

					string characterName = characterFilePaths[j].Substring(characterFilePaths[j].LastIndexOf(Path.DirectorySeparatorChar) + 1, characterFilePaths[j].Length - characterFilePaths[j].LastIndexOf(Path.DirectorySeparatorChar) - 1);
					characterName = characterName.Substring(0, characterName.IndexOf(".", StringComparison.Ordinal));

					TreeNode characterNode = serverNode.Nodes.Add(characterName);

					List<ExtendedMyWorldObject> myWorldObjects;

					// This is pretty hacked. SuitBuildableMyWorldObject is a derived clreplaced of MyWorldObject. It extends properties for the binding list.
					// Mag-Tools serializes MyWorldObjects.
					// I don't know how to deserialize those objects out as SuitBuildableMyWorldObjects.
					var fileContents = File.ReadAllText(characterFilePaths[j]);
					fileContents = fileContents.Replace("MyWorldObject", "ExtendedMyWorldObject");

					try
					{
						using (MemoryStream stream = new MemoryStream(Encoding.ASCII.GetBytes(fileContents)))
						using (XmlReader reader = XmlReader.Create(stream))
							myWorldObjects = (List<ExtendedMyWorldObject>) serializer.Deserialize(reader);

						foreach (var mwo in myWorldObjects)
						{
							mwo.Owner = characterName;
							mwo.BuilreplacedemSearchCache();
							if (mwo.ItemSetId != 0 && !armorSets.ContainsKey(mwo.ItemSet) && mwo.EquippableSlots.IsBodyArmor())
								armorSets.Add(mwo.ItemSet, mwo.ItemSetId);
						}

						characterNode.Tag = myWorldObjects;
					}
					catch (Exception ex)
					{
						MessageBox.Show("Error parsing file: " + characterFilePaths[j] + Environment.NewLine + "Try deleting the characters Name.Inventory.xml file and relog him." + Environment.NewLine + Environment.NewLine + ex);
					}
				}
			}

			armorSets = (from entry in armorSets orderby entry.Key ascending select entry).ToDictionary(pair => pair.Key, pair => pair.Value);
			filtersControl1.UpdateArmorSets(armorSets);

			txtInventoryRootPath.Text = txtInventoryRootPathOrig + "    Selecting all nodes...";
			txtInventoryRootPath.Refresh();

			CharactersTreeView.ExpandAll();

			if (CharactersTreeView.Nodes.Count == 1)
				CharactersTreeView.Nodes[0].Checked = true;
			//foreach (TreeNode node in CharactersTreeView.Nodes)
			//	node.Checked = true;

			txtInventoryRootPath.Text = txtInventoryRootPathOrig;

			this.Enabled = true;
		}

19 Source : PerformanceTest.cs
with MIT License
from mauricef

private void _load2_Click(object sender, EventArgs e)
		{
			label5.Text = "Working";
			Application.DoEvents();

			_treeView2.Nodes.Clear();

			TimeCounter.Start();
			_treeView2.BeginUpdate();

			List<TreeNode> list = new List<TreeNode>();
			for (int i = 0; i < 10; i++)
			{
				list.Add(new TreeNode(i.ToString()));
				for (int n = 0; n < 500; n++)
				{
					list[i].Nodes.Add(n.ToString());
					for (int k = 0; k < 5; k++)
						list[i].Nodes[n].Nodes.Add(k.ToString());
				}
			}
			_treeView2.Nodes.AddRange(list.ToArray());

			_treeView2.EndUpdate();
			label5.Text = TimeCounter.Finish().ToString();
		}

19 Source : ObjectView.cs
with GNU Lesser General Public License v3.0
from maxton

void AddObjectNodes(object obj, TreeNodeCollection nodes)
    {
      if (obj == null) return;
      var fields = obj.GetType().GetFields();
      foreach (var f in fields)
      {
        if (f.IsLiteral) continue;

        var val = f.GetValue(obj);
        if (val is byte[] b)
        {
          nodes.Add(f.Name + " = " + LibOrbisPkg.Util.Crypto.AsHexCompact(b));
        }
        else if (f.FieldType.IsPrimitive || f.FieldType == typeof(string) || f.FieldType.IsEnum)
        {
          if (val != null)
          {
            nodes.Add(f.Name + " = " + val.ToString());
          }
        }
        else if (f.FieldType.IsArray)
        {
          AddArrayNodes(f.GetValue(obj) as Array, f.Name, nodes);
        }
        else if (f.FieldType.IsGenericType && f.FieldType.GetGenericTypeDefinition() == typeof(List<>))
        {
          var internalType = f.FieldType.GetGenericArguments()[0];
          AddArrayNodes((f.GetValue(obj) as IList).Cast<object>().ToArray(), f.Name, nodes);
        }
        else
        {
          var node = new TreeNode(f.Name);
          AddObjectNodes(f.GetValue(obj), node.Nodes);
          nodes.Add(node);
        }
      }
    }

19 Source : ObjectInspector.cs
with GNU Lesser General Public License v3.0
from maxton

void AddForgeVal(string name, Value value, TreeNodeCollection nodes)
    {
      if (value is StructValue sv)
      {
        var no = new TreeNode($"{name}: Struct");
        no.Tag = new Action(() =>
        {
          no.Nodes.Clear();
          foreach (var x in sv.Props)
          {
            AddForgeProp(x, no.Nodes);
          }
        });
        no.Nodes.Add("Loading...");
        nodes.Add(no);
      }
      else if (value is ArrayValue arr)
      {
        var no = new TreeNode($"{name}: {(arr.Type as ArrayType).ElementType.InternalType}[] ({arr.Data.Length})");
        no.Tag = new Action(() =>
        {
          no.Nodes.Clear();
          for (var i = 0; i < arr.Data.Length; i++)
          {
            AddForgeVal(name + "[" + i + "]", arr.Data[i], no.Nodes);
          }
        });
        no.Nodes.Add("Loading...");
        nodes.Add(no);
      }
      else if (value is DrivenProp)
      {
        var driv = value as DrivenProp;
        nodes.Add($"{name}: DrivenProp [{driv.ClreplacedName} {driv.PropertyName}] ({driv.Unknown1},{driv.Unknown2}, {driv.Unknown3})");
      }
      else if (value is ColorValue c)
      {
        nodes.Add($"{name}: Color ({c.R},{c.G},{c.B},{c.A}) [{c.Unk1},{c.Unk2},{c.Unk3},{c.Unk4}]");
      }
      else
      {
        var data = value.GetType().GetField("Data")?.GetValue(value);
        nodes.Add(name + ": " + value.Type.InternalType.ToString() + " = " + data);
      }
    }

19 Source : ObjectInspector.cs
with GNU Lesser General Public License v3.0
from maxton

void AddArrayNodes(Array arr, string name, TreeNodeCollection nodes)
    {
      if (arr == null)
      {
        nodes.Add(new TreeNode($"{name} (null)"));
        return;
      }
      var node = new TreeNode($"{name} ({arr.Length})");
      node.Tag = new Action(() => {
        node.Nodes.Clear();
        var eType = arr.GetType().GetElementType();
        if (eType.IsPrimitive || eType == typeof(string) || eType.IsEnum)
        {
          var nodeList = new TreeNode[arr.Length];
          for (var i = 0; i < arr.Length; i++)
          {
            nodeList[i] = new TreeNode($"{name}[{i}] = {arr.GetValue(i)}");
          }
          node.Nodes.AddRange(nodeList);
        }
        else
        {
          for (var i = 0; i < arr.Length; i++)
          {
            var myName = $"{name}[{i}]";
            if (eType.IsArray)
              AddArrayNodes(arr.GetValue(i) as Array, myName, node.Nodes);
            else
            {
              var obj = arr.GetValue(i);
              if (obj == null)
                continue;
              if (obj is Property)
              {
                AddForgeProp(obj as Property, node.Nodes);
                continue;
              }
              if (obj is Value)
              {
                AddForgeVal(myName, obj as Value, node.Nodes);
                continue;
              }

              System.Reflection.FieldInfo nameField;
              if (null != (nameField = obj.GetType().GetField("Name")))
              {
                myName += $" (Name: {nameField.GetValue(obj)})";
              }
              var n = new TreeNode(myName);
              var item = arr.GetValue(i);
              AddObjectNodes(item, n.Nodes);
              node.Nodes.Add(n);
            }
          }
        }
      });
      node.Nodes.Add("Loading...");
      nodes.Add(node);
    }

19 Source : ObjectInspector.cs
with GNU Lesser General Public License v3.0
from maxton

void AddObjectNodes(object obj, TreeNodeCollection nodes)
    {
      if (obj == null) return;
      var fields = obj.GetType().GetFields();
      foreach (var f in fields)
      {
        if (f.IsLiteral) continue;
        if (f.FieldType.IsPrimitive || f.FieldType == typeof(string) || f.FieldType.IsEnum)
        {
          var val = f.GetValue(obj);
          if (val != null)
          {
            nodes.Add(f.Name + " = " + val.ToString());
          }
        }
        else if (f.FieldType.IsArray)
        {
          AddArrayNodes(f.GetValue(obj) as Array, f.Name, nodes);
        }
        else if (f.FieldType.IsGenericType && f.FieldType.GetGenericTypeDefinition() == typeof(List<>))
        {
          var internalType = f.FieldType.GetGenericArguments()[0];
          AddArrayNodes((f.GetValue(obj) as IList).Cast<object>().ToArray(), f.Name, nodes);
        }
        else
        {
          var node = new TreeNode(f.Name);
          AddObjectNodes(f.GetValue(obj), node.Nodes);
          nodes.Add(node);
        }
      }
    }

19 Source : PkgView.cs
with GNU Lesser General Public License v3.0
from maxton

void AddObjectNodes(object obj, TreeNodeCollection nodes)
    {
      if (obj == null) return;
      var fields = obj.GetType().GetFields();
      foreach (var f in fields)
      {
        if (f.IsLiteral) continue;
        var val = f.GetValue(obj);
        if (val is byte[] b)
        {
          nodes.Add(f.Name + " = " + LibOrbisPkg.Util.Crypto.AsHexCompact(b));
        }
        else if (f.FieldType.IsPrimitive || f.FieldType == typeof(string) || f.FieldType.IsEnum)
        {
          if (val != null)
          {
            nodes.Add(f.Name + " = " + toString(val));
          }
        }
        else if (f.FieldType.IsArray)
        {
          AddArrayNodes(f.GetValue(obj) as Array, f.Name, nodes);
        }
        else if (f.FieldType.IsGenericType && f.FieldType.GetGenericTypeDefinition() == typeof(List<>))
        {
          var internalType = f.FieldType.GetGenericArguments()[0];
          AddArrayNodes((f.GetValue(obj) as IList).Cast<object>().ToArray(), f.Name, nodes);
        }
        else
        {
          var node = new TreeNode(f.Name);
          AddObjectNodes(f.GetValue(obj), node.Nodes);
          nodes.Add(node);
        }
      }
    }

19 Source : MainForm.cs
with MIT License
from microsoft

private void PopulateTree(IEnumerable<SchemaDifference> differences, TreeView tv)
        {
            TreeNode functionRootNode = tv.Nodes.Add(_functionTreeNodeText);
            TreeNode functionAddNode = functionRootNode.Nodes.Add("Not In Target");
            TreeNode functionDropNode = functionRootNode.Nodes.Add("Only In Target");
            TreeNode functionEditNode = functionRootNode.Nodes.Add("Different");

            TreeNode ToTreeNode(SchemaDifference difference)
            {
                return new TreeNode()
                {
                    Text = difference.Name,
                    Tag = difference
                };
            }

            var schemaDifferences = differences.ToList();

            foreach (FunctionSchemaDifference schemaDifference in schemaDifferences.OfType<FunctionSchemaDifference>().OrderBy(f => f.Name))
            {
                switch (schemaDifference)
                {
                    case FunctionSchemaDifference drop
                        when drop.Difference is OnlyInTarget:
                        functionDropNode.Nodes.Add(ToTreeNode(drop));
                        break;
                    case FunctionSchemaDifference add
                        when add.Difference is OnlyInSource:
                        functionAddNode.Nodes.Add(ToTreeNode(add));
                        break;
                    case FunctionSchemaDifference change
                        when change.Difference is Modified:
                        functionEditNode.Nodes.Add(ToTreeNode(change));
                        break;
                }
            }

            TreeNode tableRootNode = tv.Nodes.Add(_tablesTreeNodeText);
            TreeNode tableAddNode = tableRootNode.Nodes.Add("Not In Target");
            TreeNode tableDropNode = tableRootNode.Nodes.Add("Only In Target");
            TreeNode tableEditNode = tableRootNode.Nodes.Add("Different");

            foreach (TableSchemaDifference schemaDifference in schemaDifferences.OfType<TableSchemaDifference>().OrderBy(f => f.Name))
            {
                switch (schemaDifference)
                {
                    case TableSchemaDifference drop
                        when drop.Difference is OnlyInTarget:
                        tableDropNode.Nodes.Add(ToTreeNode(drop));
                        break;
                    case TableSchemaDifference add
                        when add.Difference is OnlyInSource:
                        tableAddNode.Nodes.Add(ToTreeNode(add));
                        break;
                    case TableSchemaDifference change
                        when change.Difference is Modified:
                        tableEditNode.Nodes.Add(ToTreeNode(change));
                        break;
                }
            }

            ClearEmptyNodes(functionDropNode, functionAddNode, functionEditNode, tableDropNode, tableAddNode, tableEditNode);
        }

19 Source : WorldExCharTreeNode.cs
with MIT License
from mryp

private void initChar()
		{
			m_cu = GlobalStatus.ParserSrv.GetKagexEnvinitInfo();
			if (m_cu == null)
			{
				return;	//初期化できるデータがない
			}
			m_rootNode.Nodes.Clear();

			List<string> nameList = m_cu.GetCharNameList();
			foreach (string name in nameList)				//名前追加
			{
				if (filterCharItem(name, CharParts.Name) == false)
				{
					continue;	//表示できない
				}
				TreeNode nameNode = m_rootNode.Nodes.Add(name);

				List<string> poseList = m_cu.GetCharPoseList(name);
				foreach (string pose in poseList)			//姿勢追加
				{
					if (filterCharItem(pose, CharParts.Pose) == false)
					{
						continue;	//表示できない
					}
					TreeNode poseNode = nameNode.Nodes.Add(pose);

					List<string> dressList = m_cu.GetCharDressList(name, pose);
					List<string> faceList = m_cu.GetCharFaceList(name, pose);
					foreach (string dress in dressList)		//服装追加
					{
						if (filterCharItem(dress, CharParts.Dress) == false)
						{
							continue;	//表示できない
						}
						TreeNode dressNode = poseNode.Nodes.Add(dress);

						foreach (string face in faceList)	//表情追加
						{
							if (filterCharItem(face, CharParts.Face) == false)
							{
								continue;	//表示できない
							}
							dressNode.Nodes.Add(face);
						}
					}
				}
			}
		}

19 Source : WorldExViewForm.cs
with MIT License
from mryp

private void initChar()
		{
			charTreeView.Nodes.Clear();

			List<string> nameList = m_cu.GetCharNameList();
			foreach (string name in nameList)				//名前追加
			{
				if (filterCharItem(name, CharParts.Name) == false)
				{
					continue;	//表示できない
				}
				TreeNode nameNode = charTreeView.Nodes.Add(name);

				List<string> poseList = m_cu.GetCharPoseList(name);
				foreach (string pose in poseList)			//姿勢追加
				{
					if (filterCharItem(pose, CharParts.Pose) == false)
					{
						continue;	//表示できない
					}
					TreeNode poseNode = nameNode.Nodes.Add(pose);

					List<string> dressList = m_cu.GetCharDressList(name, pose);
					List<string> faceList = m_cu.GetCharFaceList(name, pose);
					foreach (string dress in dressList)		//服装追加
					{
						if (filterCharItem(dress, CharParts.Dress) == false)
						{
							continue;	//表示できない
						}
						TreeNode dressNode = poseNode.Nodes.Add(dress);

						foreach (string face in faceList)	//表情追加
						{
							if (filterCharItem(face, CharParts.Face) == false)
							{
								continue;	//表示できない
							}
							dressNode.Nodes.Add(face);
						}
					}
				}
			}
		}

19 Source : ProjectForm.cs
with MIT License
from mryp

private void initTree()
		{
			//ルートフォルダの取得
			string path = GlobalStatus.Project.DataFullPath;
			if (Directory.Exists(path) == false)
			{
				return;
			}

			//ツリーの初期化
			fileTreeView.Nodes.Clear();

			//プロジェクト名をルートノードとして作成する
			TreeNode rootNode = fileTreeView.Nodes.Add(GlobalStatus.Project.Name
				, GlobalStatus.Project.Name, IMAGE_INDEX_PROJECT, IMAGE_INDEX_PROJECT);
			rootNode.Tag = TreeItemTag.Project;
			rootNode.Nodes.Add(DUMMY_TEXT);
			rootNode.Expand();	//一階層だけ開く
		}

19 Source : ProjectForm.cs
with MIT License
from mryp

private void fileTreeView_BeforeExpand(object sender, TreeViewCancelEventArgs e)
		{
			//ダミーを削除する
			TreeNode node = e.Node;
			node.Nodes.Clear();

			//ディレクトリが存在するときはそのディレクトリ内を読み取りツリーに追加する
			string path = getNodeFullPath(node);
			if (Directory.Exists(path))
			{
				fileTreeView.BeginUpdate();

				//フォルダの追加
				DirectoryInfo dirInfo = new DirectoryInfo(path);
				DirectoryInfo[] dirs = dirInfo.GetDirectories();

				//フォルダ名順に並ぶようにソート
				List<string> dirNameList = new List<string>();
				foreach (DirectoryInfo info in dirs)
				{
					//隠し属性ではないときだけ追加する
					if ((info.Attributes & FileAttributes.Hidden) == 0)
					{
						dirNameList.Add(Path.GetFileName(info.FullName));
					}
				}
				dirNameList.Sort();
				
				//フォルダをツリーに追加する
				foreach (string name in dirNameList)
				{
					TreeNode n = new TreeNode(name, IMAGE_INDEX_DIR_CLOSE, IMAGE_INDEX_DIR_OPEN);
					n.Nodes.Add(DUMMY_TEXT);
					n.Tag = TreeItemTag.Directory;
					node.Nodes.Add(n);
				}

				//ファイルの追加
				FileInfo[] files = dirInfo.GetFiles();

				//ファイル名順で並ぶようにソート
				List<string> fileNameList = new List<string>();
				foreach (FileInfo info in files)
				{
					if ((info.Attributes & FileAttributes.Hidden) == 0)
					{
						fileNameList.Add(Path.GetFileName(info.FullName));
					}
				}
				fileNameList.Sort();
				
				//ファイルをツリーに追加する
				foreach (string name in fileNameList)
				{
					addNodeFile(node, name);
				}

				fileTreeView.EndUpdate();
			}
		}

19 Source : ScreenToolForm.cs
with MIT License
from mryp

private void initTree()
		{
			toolTreeView.Nodes.Clear();

			TreeNode generalNode = toolTreeView.Nodes.Add("全般");
			generalNode.Nodes.Add("画像コントロール").Tag = typeof(ImageType).ToString();
			generalNode.Nodes.Add("ジャンプボタン").Tag = typeof(BaseType).ToString();

			TreeNode saveloadNode = toolTreeView.Nodes.Add("セーブ・ロード");
			saveloadNode.Nodes.Add("セーブコントロール").Tag = typeof(BaseType).ToString();
			saveloadNode.Nodes.Add("ロードコントロール").Tag = typeof(BaseType).ToString();
			saveloadNode.Nodes.Add("ページボタン").Tag = typeof(BaseType).ToString();
			saveloadNode.Nodes.Add("セーブボタン").Tag = typeof(BaseType).ToString();
			saveloadNode.Nodes.Add("ロードボタン").Tag = typeof(BaseType).ToString();
		}

19 Source : ConflictsControl.cs
with MIT License
from mtherien

private void FillConflictNode(TreeNode node, Conflict conflict)
        {
            node.Tag = conflict;

            NodeConflict nodeConflict = conflict as NodeConflict;
            if (nodeConflict != null)
            {
                if (nodeConflict.AcceptedSubdifferences.Count > 0)
                {
                    TreeNode acceptedNode = node.Nodes.Add("Accepted Differences");
                    foreach (Difference subdifference in nodeConflict.AcceptedSubdifferences)
                    {
                        TreeNode subnode = acceptedNode.Nodes.Add(subdifference.ToString());
                        FillDifferenceNode(subnode, subdifference);
                    }
                }

                TreeNode conflictNode = node.Nodes.Add("Conflicts");
                foreach (Conflict subconflict in nodeConflict.Subconflicts)
                {
                    TreeNode subnode = conflictNode.Nodes.Add(subconflict.ToString());
                    FillConflictNode(subnode, subconflict);
                }
            }
        }

19 Source : FileExplorer.cs
with GNU General Public License v3.0
from neodoso

public bool CreateTree(TreeView treeView)
        {

            bool returnValue = false;

            try
            {
                TreeNode files = new TreeNode();
                files.Text = directory;
                files.Tag = "Files";
                files.Nodes.Add("");
                treeView.Nodes.Add(files);
                files.Expand();
            }
            catch
            {
                returnValue = false;
            }
            return returnValue;

        }

19 Source : FileExplorer.cs
with GNU General Public License v3.0
from neodoso

public TreeNode EnumerateDirectory(TreeNode parentNode)
        {

            try
            {
                DirectoryInfo rootDir;

                Char[] arr = { '\\' };
                string[] nameList = parentNode.FullPath.Split(arr);
                string path = directory;

                if (nameList.GetValue(0).ToString() == "Files")
                {
                    path = directory;

                    for (int i = 1; i < nameList.Length; i++)
                    {
                        path = path + nameList[i] + "\\";
                    }

                    rootDir = new DirectoryInfo(path);
                }
                // for other Directories
                else
                {

                    rootDir = new DirectoryInfo(parentNode.FullPath + "\\");
                }

                parentNode.Nodes[0].Remove();
                foreach (DirectoryInfo dir in rootDir.GetDirectories())
                {

                    TreeNode node = new TreeNode();
                    node.Text = dir.Name;
                    node.Nodes.Add("");
                    parentNode.Nodes.Add(node);
                }

                // Fill files
                foreach (FileInfo file in rootDir.GetFiles())
                {
                    if ((file.Extension == ".dat") || (file.Extension == ".bin"))
                    {
                        TreeNode node = new TreeNode();
                        node.Text = file.Name;
                        node.ImageIndex = 2;
                        node.SelectedImageIndex = 2;
                        parentNode.Nodes.Add(node);
                    }
                }
            }

            catch
            {
                return null;
            }

            return parentNode;
        }

19 Source : MainForm.cs
with GNU General Public License v3.0
from NeoSmartpen

private void tvLocalDir_BeforeExpand(object sender, TreeViewCancelEventArgs e)
        {
            TreeNode current = e.Node;

            if (current.Nodes.Count == 1 && current.Nodes[0].Text.Equals("@%"))
            {
                current.Nodes.Clear();

                String path = current.FullPath.Substring(current.FullPath.IndexOf("\\") + 1);

                try
                {
                    string[] directories = Directory.GetDirectories(path);
                    foreach (string directory in directories)
                    {
                        TreeNode newNode = current.Nodes.Add(
                            directory.Substring(
                            directory.LastIndexOf("\\") + 1));
                        newNode.Nodes.Add("@%");
                    }
                }
                catch (Exception ex)
                {
                    MessageBox.Show(ex.Message);
                }
            }
        }

See More Examples