public void RebuildBreadcrumb(TreeItem treeItem, bool isAdd)
        {
            var ancestors   = new List <TreeItem>();
            var ghostParent = treeItem;

            while (treeItem.Parent != null)
            {
                ancestors.Add(treeItem);
                treeItem = treeItem.Parent;
            }

            ancestors.Reverse();

            Breadcrumbs.Clear();

            if (ancestors.Count > 0)
            {
                Breadcrumbs.Data = ancestors;

                Breadcrumbs[Breadcrumbs.Count - 1].IsActive = true;
                if (isAdd)
                {
                    Breadcrumbs[Breadcrumbs.Count - 1].IsAdd = true;
                }

                var ghost = Breadcrumbs.Add();
                ghost.GhostParent = ghostParent;

                foreach (var breadcrumb in Breadcrumbs)
                {
                    breadcrumb.SearchSiblings("");
                }
            }
        }
Example #2
0
        public void Add(IBreadcrumbItem item)
        {
            var exist = Breadcrumbs.FirstOrDefault(q => q.BreadcrumbData.Node.Id == item.Node.Id);

            if (exist != null)
            {
                RemoveTo(exist);
            }
            else
            {
                Breadcrumbs.Add(CreateBreadcrumb(item));
            }
        }
        private void SelectPath(GhTreeItem pathTreeItem, bool insertInBackStack = true)
        {
            PathItems = null;
            var    pathTree = this.PathTree;
            string path     = pathTreeItem.Path;

            if (null != pathTree && null != path)
            {
                if (pathTree.ContainsKey(path))
                {
                    var unsortedItems = pathTree[path];
                    PathItems = unsortedItems
                                .OrderBy(ti => ti.ItemTypeWeightForSorting)
                                .ThenBy(ti => ti.Name)
                                .ToList();

                    if (insertInBackStack)
                    {
                        Breadcrumbs.Add(pathTreeItem);
                    }
                }
            }
        }
Example #4
0
        public async Task SearchAsync(TaxonRank rank, string name)
        {
            if (Shape != null && !Breadcrumbs.ContainsKey(rank))
            {
                Breadcrumbs.Add(Rank, Shape.Copy());
            }

            switch (rank)
            {
            case TaxonRank.Kingdom:
                Shape.Kingdom = name;
                break;

            case TaxonRank.Subkingdom:
                Shape.Subkingdom = name;
                break;

            case TaxonRank.Infrakingdom:
                Shape.Infrakingdom = name;
                break;

            case TaxonRank.Phylum:
                Shape.Phylum = name;
                break;

            case TaxonRank.Subphylum:
                Shape.Subphylum = name;
                break;

            case TaxonRank.Class:
                Shape.Class = name;
                break;

            case TaxonRank.Subclass:
                Shape.Subclass = name;
                break;

            case TaxonRank.Superorder:
                Shape.Superorder = name;
                break;

            case TaxonRank.Order:
                Shape.Order = name;
                break;

            case TaxonRank.Suborder:
                Shape.Suborder = name;
                break;

            case TaxonRank.Family:
                Shape.Family = name;
                break;

            case TaxonRank.Subfamily:
                Shape.Subfamily = name;
                break;

            case TaxonRank.Genus:
                Shape.Genus = name;
                break;

            case TaxonRank.Species:
                Shape.Species = name;
                break;
            }

            Rank = rank.GetChildRank();

            Breadcrumbs[rank] = Shape.Copy();

            await SearchAsync();
        }