public CNodeEntryViewModel(CKlaxScriptNodeFactory nodeFactory, CAddNodeViewModel parentViewModel, CCategoryViewModel parentCategory)
        {
            NodeFactory       = nodeFactory;
            Name              = nodeFactory.Name;
            m_parentCategory  = parentCategory;
            m_parentViewModel = parentViewModel;

            LeftDoubleClickCommand = new CRelayCommand(OnLeftDoubleClick);

            if (nodeFactory.TargetType != null)
            {
                Tooltip = "Target is " + nodeFactory.TargetType.Name;
            }

            if (!string.IsNullOrWhiteSpace(nodeFactory.Tooltip))
            {
                if (Tooltip != null)
                {
                    Tooltip = Tooltip + System.Environment.NewLine + nodeFactory.Tooltip;
                }
                else
                {
                    Tooltip = nodeFactory.Tooltip;
                }
            }
        }
        private bool SelectFirstEntry(CCategoryViewModel category)
        {
            foreach (var subCategory in category.SubCategories)
            {
                if (SelectFirstEntry(subCategory))
                {
                    return(true);
                }
            }

            if (category.Nodes.Count > 0)
            {
                category.Nodes[0].IsSelected = true;
                return(true);
            }

            return(false);
        }
        public CCategoryViewModel(string name, CAddNodeViewModel parentViewModel, CCategoryViewModel parentCategory)
        {
            Name = name;
            m_combinedCollection = new CompositeCollection();
            CollectionContainer categoriesContainer = new CollectionContainer();

            categoriesContainer.Collection = SubCategories;
            CollectionContainer nodesContainer = new CollectionContainer();

            nodesContainer.Collection = Nodes;
            CombinedCollection.Add(categoriesContainer);
            CombinedCollection.Add(nodesContainer);

            MouseDownCommand = new CRelayCommand(OnMouseDown);

            m_parentCategory  = parentCategory;
            m_parentViewModel = parentViewModel;
        }
        private void PopulatePossibleNodes()
        {
            m_selectedNode = null;
            List <CCategoryViewModel> categories = new List <CCategoryViewModel>(128);
            Dictionary <string, CCategoryViewModel> categoryToViewModel = new Dictionary <string, CCategoryViewModel>();
            CCategoryViewModel memberCategory = new CCategoryViewModel("Variables", this, null);
            bool bFilterTextEmpty             = string.IsNullOrWhiteSpace(FilterText);

            if (!bFilterTextEmpty)
            {
                memberCategory.IsExpanded = true;
            }

            foreach (CKlaxScriptNodeFactory nodeFactory in m_nodeFactories)
            {
                if (!bFilterTextEmpty &&
                    nodeFactory.Name.IndexOf(FilterText, StringComparison.OrdinalIgnoreCase) < 0 &&
                    nodeFactory.Category.IndexOf(FilterText, StringComparison.OrdinalIgnoreCase) < 0)
                {
                    continue;
                }

                if (nodeFactory.IsMemberNode)
                {
                    string baseCategory = "Variables/" + nodeFactory.Category;
                    if (!categoryToViewModel.TryGetValue(baseCategory, out CCategoryViewModel baseCategoryViewModel))
                    {
                        baseCategoryViewModel = new CCategoryViewModel(nodeFactory.Category, this, memberCategory);
                        memberCategory.SubCategories.Add(baseCategoryViewModel);
                        categoryToViewModel.Add(baseCategory, baseCategoryViewModel);

                        if (!bFilterTextEmpty)
                        {
                            baseCategoryViewModel.IsExpanded = true;
                        }
                    }

                    if (nodeFactory.TargetType != null)
                    {
                        string fullCategory = baseCategory + "/" + nodeFactory.TargetType.Name;
                        if (!categoryToViewModel.TryGetValue(fullCategory, out CCategoryViewModel fullCategoryViewModel))
                        {
                            fullCategoryViewModel = new CCategoryViewModel(nodeFactory.TargetType.Name, this, baseCategoryViewModel);
                            baseCategoryViewModel.SubCategories.Add(fullCategoryViewModel);
                            categoryToViewModel.Add(fullCategory, fullCategoryViewModel);

                            if (!bFilterTextEmpty)
                            {
                                fullCategoryViewModel.IsExpanded = true;
                            }
                        }
                        fullCategoryViewModel.Nodes.Add(new CNodeEntryViewModel(nodeFactory, this, fullCategoryViewModel));
                    }
                    else
                    {
                        baseCategoryViewModel.Nodes.Add(new CNodeEntryViewModel(nodeFactory, this, baseCategoryViewModel));
                    }
                }
                else
                {
                    if (categoryToViewModel.TryGetValue(nodeFactory.Category, out CCategoryViewModel viewModel))
                    {
                        viewModel.Nodes.Add(new CNodeEntryViewModel(nodeFactory, this, viewModel));
                    }
                    else
                    {
                        CCategoryViewModel newCategory = new CCategoryViewModel(nodeFactory.Category, this, null);
                        categories.Add(newCategory);
                        categoryToViewModel.Add(nodeFactory.Category, newCategory);
                        newCategory.Nodes.Add(new CNodeEntryViewModel(nodeFactory, this, newCategory));

                        if (!bFilterTextEmpty)
                        {
                            newCategory.IsExpanded = true;
                        }
                    }
                }
            }

            if (memberCategory.Nodes.Count > 0 || memberCategory.SubCategories.Count > 0)
            {
                categories.Add(memberCategory);
            }

            Categories = new ObservableCollection <CCategoryViewModel>(categories);
            if (!bFilterTextEmpty && Categories.Count > 0)
            {
                SelectFirstEntry(Categories[0]);
            }
        }