Пример #1
0
 /// <summary>
 ///
 /// </summary>
 /// <param name="Path"></param>
 public void CollapseNode(string Path)
 {
     foreach (TreeNodeAdv Node in MainTreeView.AllNodes)
     {
         DeltaTreeNode Meta = Node.Tag as DeltaTreeNode;
         if (Meta != null && Meta.FullPath == Path)
         {
             Node.Collapse();
             return;
         }
     }
 }
Пример #2
0
 /// <summary>
 ///
 /// </summary>
 /// <param name="Path"></param>
 public void SelectPath(string Path)
 {
     foreach (TreeNodeAdv Node in MainTreeView.AllNodes)
     {
         DeltaTreeNode Meta = Node.Tag as DeltaTreeNode;
         if (Meta != null && Meta.FullPath == Path)
         {
             MainTreeView.SelectedNode = Node;
             return;
         }
     }
 }
Пример #3
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void NodeCollapsed(object sender, TreeViewAdvEventArgs e)
        {
            if (MainTreeView.SelectedNode == null)
            {
                return;
            }

            DeltaTreeNode Node = e.Node.Tag as DeltaTreeNode;

            if (Node == null)
            {
                return;
            }

            OnNodeCollapsed?.Invoke(Node.FullPath);
        }
Пример #4
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void OnSelectionChanged(object sender, EventArgs e)
        {
            if (MainTreeView.SelectedNode == null)
            {
                return;
            }

            DeltaTreeNode Node = MainTreeView.SelectedNode.Tag as DeltaTreeNode;

            if (Node == null)
            {
                return;
            }

            OnSelectedNodeChanged?.Invoke(Node.FullPath);
        }
Пример #5
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="TrNode"></param>
        /// <param name="Node"></param>
        private void UpdateNode(DeltaTreeNode TrNode)
        {
            TrNode.Icon = icon_folder_open;

            if (TrNode.Diff != null)
            {
                switch (TrNode.Diff.Type)
                {
                case BuildManifestFileDiffType.Added:
                {
                    TrNode.Icon = icon_added;
                    break;
                }

                case BuildManifestFileDiffType.Modified:
                {
                    TrNode.Icon = icon_edited;
                    break;
                }

                case BuildManifestFileDiffType.Removed:
                {
                    TrNode.Icon = icon_removed;
                    break;
                }

                case BuildManifestFileDiffType.Unchanged:
                {
                    TrNode.Icon = icon_unchanged;
                    break;
                }
                }

                if (TrNode.Diff.Type != BuildManifestFileDiffType.Removed)
                {
                    TrNode.SizeFormatted     = StringUtils.FormatAsSize((long)TrNode.Diff.FileInfo.Size);
                    TrNode.ChecksumFormatted = string.Format("{0:x}", TrNode.Diff.FileInfo.Checksum);
                }
                else
                {
                    TrNode.SizeFormatted     = "";
                    TrNode.ChecksumFormatted = "";
                }
            }
        }
Пример #6
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void DrawNodeText(object sender, DrawEventArgs e)
        {
            DeltaTreeNode DeltaNode = e.Node.Tag as DeltaTreeNode;

            if (DeltaNode != null)
            {
                BuildManifestFileDiffType Type = BuildManifestFileDiffType.Unchanged;

                if (DeltaNode.Diff != null)
                {
                    Type = DeltaNode.Diff.Type;
                }
                else if (FolderDiffTypes.ContainsKey(DeltaNode.FullPath))
                {
                    Type = FolderDiffTypes[DeltaNode.FullPath];
                }

                switch (Type)
                {
                case BuildManifestFileDiffType.Added:
                {
                    e.TextColor = Color.Green;
                    break;
                }

                case BuildManifestFileDiffType.Modified:
                {
                    e.TextColor = Color.Orange;
                    break;
                }

                case BuildManifestFileDiffType.Removed:
                {
                    e.TextColor = Color.Red;
                    break;
                }

                case BuildManifestFileDiffType.Unchanged:
                {
                    break;
                }
                }
            }
        }
Пример #7
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="Path"></param>
        /// <param name="Metadata"></param>
        /// <returns></returns>
        private Node GetOrCreateNode(string Path, BuildManifestFileDiff Metadata, bool DoNotCreate = false)
        {
            if (Path == "")
            {
                return(Model.Root);
            }

            if (NodeCache.ContainsKey(Path))
            {
                return(NodeCache[Path]);
            }

            string ChildNode = VirtualFileSystem.GetNodeName(Path);

            Node Parent = GetOrCreateNode(VirtualFileSystem.GetParentPath(Path), null);

            /*foreach (Node node in Parent.Nodes)
             * {
             *  if (node.Text == ChildNode)
             *  {
             *      return node;
             *  }
             * }*/

            if (DoNotCreate)
            {
                return(null);
            }

            DeltaTreeNode NewNode = new DeltaTreeNode();

            NewNode.Name     = ChildNode;
            NewNode.Diff     = Metadata;
            NewNode.Text     = ChildNode;
            NewNode.FullPath = Path;
            Parent.Nodes.Add(NewNode);
            NodeCache.Add(Path, NewNode);
            UpdateNode(NewNode);

            return(NewNode);
        }