public void TreePrint(TreeItem treeItem)
 {
     foreach (var item in treeItem.SubItems.OrderBy(x => x.Order))
     {
         ChildPrint(item, 0);
     }
 }

        private static void PopulateFolders(string dirName, TreeItem<string> parentFolder)
        {
            string[] folderItems = Directory.GetFileSystemEntries(dirName);

            foreach (var folderItem in folderItems)
            {
                TreeItem<string> folderSubItem = new TreeItem<string>(folderItem);
                parentFolder.AddChild(folderSubItem);

                // If the current node is a filename, don't call recursion and continue
                try
                {
                    Directory.GetDirectories(folderItem);
                }
                catch (IOException ex)
                {
                    continue;
                }
                catch (UnauthorizedAccessException)
                {
                    Console.WriteLine("LOG: No access to folder {0}", dirName);
                    continue;
                }

                PopulateFolders(folderItem, folderSubItem);
            }
        }

 public TreeItem GenerateTteeVm(int col, int depth, string version)
 {
     OrderInc = 0;
     var item = new TreeItem() { Name = "root " + version };
     item.SubItems = GenerateTteeItemList(col, depth,version);
     return item;
 }

 private void GenerateTree(TreeItem<FileSystemItem> node, int depth, int level = 0)
 {
     var itemCount = C.Random<int>(_fakingRules.GetItemCount(level));
     var nodes = node.AddRange(C.CollectionOfFake<FileSystemItem>(itemCount, new { Type = _fakingRules.GetItemTypes(level), Name = new Range(8,13) }));
     foreach (var n in nodes)
     {
         n.Content.FullPath = n.Content.Path = node.Content.Path + "/" + n.Content.Name;
         n.Content.Size = C.Random<int>(0xFF, 0xFFFF);
         if (level < depth) GenerateTree(n, depth, level+1);
     }
 }

		public TreeItem (TreeStore store, TreeItem parent, CoverageItem model, string title) {
			this.store = store;
			this.parent = parent;
			this.model = model;

			if (parent == null)
				iter = store.AppendValues (title);
			else
				iter = store.AppendValues (parent.Iter, title);
			FillColumns ();
		}

        public TreeEntryMenu(ITreeSource treeSource, TreeItem treeItem)
        {
            if(treeSource == null) throw new ArgumentNullException("treeSource");
            if(treeItem == null) throw new ArgumentNullException("treeItem");

            _treeSource = treeSource;
            _treeItem = treeItem;

            // save as
            // checkout

            Items.Add(GuiItemFactory.GetCheckoutPathItem<ToolStripMenuItem>(treeSource, treeItem.RelativePath));
        }

 public void WriteTree(Guid versionId, TreeItem item)
 {
     OrderInc = 0;
     //            using (var context = _context)
     {
         //foreach (var element in item.SubItems.OrderBy(x => x.Order))
         {
             var root = Dive(item, null, versionId);
             HierarchyParentChildContext.Elements.Add(root);
             HierarchyParentChildContext.SaveChanges();
         }
     }
 }

 TreeItem CreateTreeItem(int level, string name, Image image)
 {
     var item = new TreeItem {
         Text = name,
         Expanded = expanded++ % 2 == 0,
         Image = image
     };
     if (level < 4) {
         for (int i = 0; i < 4; i++) {
             item.Children.Add (CreateTreeItem (level + 1, name + " " + i, image));
         }
     }
     return item;
 }

        public UnstagedItemMenu(TreeItem item)
        {
            Verify.Argument.IsValidGitObject(item, "item");
            Verify.Argument.AreEqual(StagedStatus.Unstaged, item.StagedStatus & StagedStatus.Unstaged, "item",
                "This item is not unstaged.");

            _item = item;

            var dir = _item as TreeDirectory;
            if(_item.Status != FileStatus.Removed)
            {
                var fullPath = _item.FullPath;
                if(dir == null)
                {
                    Items.Add(GuiItemFactory.GetOpenUrlItem<ToolStripMenuItem>(Resources.StrOpen, null, fullPath));
                    Items.Add(GuiItemFactory.GetOpenUrlWithItem<ToolStripMenuItem>(Resources.StrOpenWith.AddEllipsis(), null, fullPath));
                    Items.Add(GuiItemFactory.GetOpenUrlItem<ToolStripMenuItem>(Resources.StrOpenContainingFolder, null, Path.GetDirectoryName(fullPath)));
                }
                else
                {
                    Items.Add(GuiItemFactory.GetOpenUrlItem<ToolStripMenuItem>(Resources.StrOpenInWindowsExplorer, null, fullPath));
                }
                Items.Add(new ToolStripSeparator());
            }
            Items.Add(GuiItemFactory.GetStageItem<ToolStripMenuItem>(_item));
            if(dir != null)
            {
                if(HasRevertableItems(dir))
                {
                    Items.Add(GuiItemFactory.GetRevertPathItem<ToolStripMenuItem>(_item));
                }
            }
            else
            {
                if(_item.Status == FileStatus.Removed || _item.Status == FileStatus.Modified)
                {
                    Items.Add(GuiItemFactory.GetRevertPathItem<ToolStripMenuItem>(_item));
                }
                if(_item.Status == FileStatus.Modified || _item.Status == FileStatus.Added)
                {
                    Items.Add(GuiItemFactory.GetRemovePathItem<ToolStripMenuItem>(_item));
                }
            }
        }

        private static void FindExeFile(List<string> foundExeFiles, TreeItem<string> treeItem)
        {
            string pattern = "exe";

            if (!treeItem.IsFolder)
            {
                string[] fileParts = treeItem.Value.Split('.');

                if (fileParts[fileParts.Length - 1] == pattern)
                {
                    foundExeFiles.Add(treeItem.Value);
                }
            }

            for (int i = 0; i < treeItem.ChildItemsCount; i++)
            {
                FindExeFile(foundExeFiles, treeItem.GetChild(i));
            }
        }

        public void Index_GET()
        {
            IList<SiteDto> sites=SiteCacheManager.GetAllSites();
            TreeItem[] items=new TreeItem[sites.Count];
            for (int i = 0; i < sites.Count; i++)
            {
                items[i] = new TreeItem
                {
                    ID=sites[i].SiteId,
                    Name=sites[i].Name + (sites[i].Note.Trim()!=""?"["+sites[i].Note+"]":"")
                };
            }


            base.RenderTemplate(ResourceMap.GetPageContent(ManagementPage.Site_Index), new
            {
                siteTree=Helper.SingleTree("所有站点",items)
            });
        }

		public UserList (Channel channel)
		{
			this.Channel = channel;
			tree = new TreeView ();
			tree.Style = "userList";
			tree.Activated += HandleActivated;
			
			items = new TreeItemCollection ();
			items.Add (owners = new TreeItem { Text = "Room Owners", Expanded = true });
			items.Add (online = new TreeItem { Text = "Online", Expanded = true });
			items.Add (away = new TreeItem { Text = "Away", Expanded = true });
			if (Generator.ID == Generators.Mac) {
				foreach (var item in items.OfType<TreeItem>()) {
					item.Text = item.Text.ToUpperInvariant();
				}
			}
			tree.DataStore = items;
			
			this.AddDockedControl (tree);
		}

        static void Main(string[] args)
        {
            string rootDirectory = @"C:\Windows";

            TreeItem<string> rootFolder = new TreeItem<string>(rootDirectory);

            Console.WriteLine("Getting items in {0}, this can take a while", rootDirectory);
            Console.WriteLine();

            PopulateFolders(rootDirectory, rootFolder);

            Tree<string> foldersTree = new Tree<string>(rootFolder);

            List<string> exeFiles = new List<string>();

            FindExeFile(exeFiles, foldersTree.Root);

            Console.WriteLine();
            Console.WriteLine("Found {0} .exe files", exeFiles.Count);
        }

      /// <summary>
      /// Expands the root tree item to the currently selected item.
      /// </summary>
      /// <param name="iRoot">Root tree item.</param>
      private void ExpandToSelection(ref TreeItem iRoot)
      {
         if (iRoot == null || SelectedId == 0 || SelectedId == iRoot.Id)
            return;

         var treeItem = LoadTreeItem(SelectedId);

         var records = EmployeeModel.AllRecords;
         var record = records.FirstOrDefault(i => i.Id == SelectedId);
         var reportToId = record.ReportTo;

         // Start from the selected item and work our way up until the root is reached.
         while (reportToId != iRoot.Id && (record = records.FirstOrDefault(i => i.Id == reportToId)) != null)
         {
            var parentItem = LoadTreeItem(record.Id);
            parentItem.Children[parentItem.Children.FindIndex(i => i.Id == treeItem.Id)] = treeItem;
            reportToId = record.ReportTo;
            treeItem = parentItem;
         }
         iRoot.Children[iRoot.Children.FindIndex(i => i.Id == treeItem.Id)] = treeItem;
      }

 private static Result CompareTrees(TreeItem tree1, TreeItem tree2)
 {
     if (tree1.Name != tree2.Name) return new Result(false, tree1, tree2);
     if (tree1.Order != tree2.Order) return new Result(false, tree1, tree2);
     if (tree1.SubItems == null)
     {
         if (tree2.SubItems != null) return new Result(false, tree1, tree2);
         if (tree1.Placeholder != tree2.Placeholder) return new Result(false, tree1, tree2);
     }
     else
     {
         if (tree2.SubItems == null) return new Result(false, tree1, tree2);
         if (tree1.SubItems.Count != tree2.SubItems.Count) return new Result(false, tree1, tree2);
         for (int i = 0; i < tree1.SubItems.Count; i++)
         {
             var r = CompareTrees(tree1.SubItems[i], tree2.SubItems[i]);
             if (!r.Equals) return r;
         }
     }
     return new Result(true, null, null);
 }

        public void GenerateCustomDataTree(out TreeItem input, out TreeItem output)
        {
            input = new TreeItem() { Name = "InputData", IsChoice = false, SubItems = new List<TreeItem>() };
            output = new TreeItem() { Name = "OutputData", IsChoice = false, SubItems = new List<TreeItem>() };

            input.SubItems.Add(new TreeItem() { Name = "Корневой", Placeholder = "я корневой", Order = 0 });
            TreeItem inputRoot = new TreeItem()
            {
                Name = "Справка",
                SubItems = new List<TreeItem>()
                {
                    new TreeItem()
                    {
                        Name = "Паспорт",
                        Order = 0,
                        SubItems =
                            new List<TreeItem>()
                            {
                                new TreeItem() {Name = "Серия", Placeholder = "8003", Order = 0},
                                new TreeItem() {Name = "номер", Placeholder = "600000", Order = 1}
                            }
                    },
                    new TreeItem()
                    {
                        Name = "ФИО",
                        Order = 1,
                        SubItems =
                            new List<TreeItem>()
                            {
                                new TreeItem() {Name = "Имя", Placeholder = "Петя", Order = 0},
                                new TreeItem() {Name = "Фамилия", Placeholder = "Кошечкин", Order = 1}
                            }
                    },
                    new TreeItem() {Name = "Номер справки", Placeholder = "СПР-1", Order = 2}
                },
                Order = 1
            };
            input.SubItems.Add(inputRoot);
            output.SubItems.Add(new TreeItem() { Name = "Корневой Вых", Placeholder = "я корневой вых", Order = 0 });
        }

        private List<TreeItem<FileLayerSongDO>> BuildTree(IEnumerable<Tuple<int, List<string>>> data, int depth)
        {
            // wenn depth == items2.length
            // break;

            var grped = from r in
                            (from item in data
                             where item.Item2.Count > depth
                             select item)
                        group r by r.Item2[depth] into grp
                        select grp;

            List<TreeItem<FileLayerSongDO>> result = null;
            if (grped.Any())
            {
                result = new List<TreeItem<FileLayerSongDO>>();

                foreach (var item in grped)
                {
                    var child = new TreeItem<FileLayerSongDO>();
                    child.Level = depth;
                    var temp = new FileLayerSongDO();
                    temp.SetByDepth(depth, item.Key);
                    var current = item.First();

                    if (depth == current.Item2.Count - 1)
                        temp.ID = item.First().Item1;

                    child.Value = temp;

                    var childs = BuildTree(item, depth + 1);
                    if (childs != null)
                        child.SetChildren(childs);

                    result.Add(child);
                }
            }
            return result;
        }

        public void TestDataContractJsonSerializer()
        {
            var treeitem = new TreeItem<string>();
            treeitem.Id = "1";
            treeitem.Text = "Root";
            treeitem.Value = "3223";
            treeitem.Isexpand = true;
            treeitem.Showcheck = true;
            treeitem.Add(
                new TreeItem<string>
                    {
                       Id = "2", Text = "Node2", Value = "9982", Showcheck = true, Isexpand = true, Checkstate = 1 
                    });

            string mstr = treeitem.ToJsonString2();

            Console.WriteLine(mstr);

            string tstr = treeitem.ToJsonString();
            Console.WriteLine(tstr);

            Assert.Equal(tstr.Length, mstr.Length);
        }

        private void ChildPrint(TreeItem element, int i)
        {
            var ii = i;
            var tab = "";
            for (int j = 0; j < i; j++)
            {
                tab = tab + "_";
            }

            if (element.SubItems == null)
            {
                Console.WriteLine(tab + element.Name + " " + element.Placeholder);
            }
            else
            {
                Console.WriteLine(tab + element.Name);
                ++ii;
                foreach (var child in element.SubItems.OrderBy(x => x.Order))
                {
                    ChildPrint(child, ii);
                }
            }
        }

        public bool Proccess(string atom, AbstractTreeItem seed, out AbstractTreeItem item)
        {
            MathExpr[] exprs = null;
            item= new TreeItem();
            item.Type=TreeItemType.Выражение;
            string polska = null;
            try
            {
                polska = GetPolskaFormat(atom, out exprs);
            }
            catch (MpException e)
            {
                item.Error = true;
                item.ErrorCode = e.Code;
            }
            catch (Exception e)
            {
                item.Error = true;
                item.ErrorCode = ErrorCodes.Unknown;
            }
            throw new NotImplementedException();

        }