Exemple #1
0
        public void OnNodeCliked(TreeNode node)
        {
            view.tsbRemoveWSEnabled     = false;
            view.tsbAddLinkWSEnabled    = false;
            view.tsbRemoveLinkWSEnabled = false;


            NodeTypes?nodeType = node.Tag as NodeTypes?;

            if (nodeType == NodeTypes.Page || nodeType == NodeTypes.Section ||
                nodeType == NodeTypes.SectionGroup || nodeType == NodeTypes.Notebook)
            {
                if (DisplayTreeView.IsNodeInWorkingSet(node) == false)
                {
                    view.tsbAddLinkWSEnabled = true;
                }
                NavigateTo(node.Name);
            }
            if (nodeType == NodeTypes.WorkingSet)
            {
                view.tsbRemoveWSEnabled = true;
            }

            LazyTreeNode parentNode = node.Parent as LazyTreeNode;

            if (parentNode != null)
            {
                NodeTypes?parentType = parentNode.Tag as NodeTypes?;
                if (parentType == NodeTypes.WorkingSet)
                {
                    view.tsbRemoveLinkWSEnabled = true;
                }
            }
        }
        private List <LazyTreeNode> DataViewToNodes(DataView dataView)
        {
            var retTreeNodes = new List <LazyTreeNode>();

            foreach (DataRowView drv in dataView)
            {
                string typeName    = Enum.GetName(typeof(NodeTypes), drv["Nodetype"]);
                var    newTreeNode = new LazyTreeNode
                {
                    Name = drv["ID"].ToString(),
                    Text = drv["DisplayName"].ToString(),
                    Tag  = (NodeTypes)drv["Nodetype"],
                    //               ImageKey = String.Format("TreeView4.Resources.{0}.bmp", typeName) ,
                    //                 SelectedImageKey = String.Format("TreeView4.Resources.{0}.bmp", typeName)
                };


                if ((NodeTypes)newTreeNode.Tag == NodeTypes.Page)
                {
                    newTreeNode.Nodes.Clear();
                    newTreeNode.IsLoaded = true;
                }

                retTreeNodes.Add(newTreeNode);
            }
            return(retTreeNodes);
        }
        public void ChangeSelectedNode(string ID)
        {
            displayTree.BeginUpdate();
            if (ID == null)
            {
                return;
            }
            clearDisplay();
            setDisplayNode(AllNode);

            TreeNode[] matchNodes = displayTree.Nodes.Find(ID, true);

            for (int i = 0; i < matchNodes.Length; i++)
            {
                if (IsNodeInWorkingSet(matchNodes[i]) == true)
                {
                    matchNodes[i] = null;
                }
            }


            if (matchNodes.Length == 0 || matchNodes[0] == null)
            {
                string parentID = presenter.GetNodeParent(ID);
                ChangeSelectedNode(parentID);
                matchNodes = AllNode.Nodes.Find(ID, true);
            }
            if (matchNodes.Length == 0)
            {
                return;
            }
            displayTree.Expand(matchNodes[0]);
            SelectedNode = matchNodes[0] as LazyTreeNode;
            displayTree.EndUpdate();
        }
Exemple #4
0
        public void AddWorkingSetLink(LazyTreeNode tn, LazyTreeNode ws)
        {
            var frmWS = new AddWSLink();
            frmWS.LoadList(ws);
            frmWS.WorkingSetSelectionMade += new AddWSLink.ChosenWorkingSet(frmWS_WorkingSetSelectionMade);
            AddLinkToWorkingSet = tn;
            frmWS.ShowDialog();

            //dataManager.workingSet.AddWorkingSetLink();
        }
Exemple #5
0
        private void RootsListRecurser(LazyTreeNode node)
        {
            LazyTreeNode parentNode = (LazyTreeNode)node.Parent;

            if (parentNode != null)
            {
                RootsListRecurser(parentNode);
            }

            tscbRootList.Items.Add(new ComboBoxItem(node));
        }
Exemple #6
0
        private void btnOkClicked(object sender, EventArgs e)
        {
            LazyTreeNode           newNode = lbWorkingSets.SelectedItem as LazyTreeNode;
            WorkingSetSelectedArgs args    = new WorkingSetSelectedArgs(newNode);

            if (WorkingSetSelectionMade != null)
            {
                WorkingSetSelectionMade(this, args);
            }

            this.Close();
        }
Exemple #7
0
        public void LoadList(LazyTreeNode node)
        {
            foreach (LazyTreeNode tn in node.Nodes)
            {
                lbWorkingSets.DisplayMember = "Text";
                lbWorkingSets.Items.Add(tn);
            }

            if (lbWorkingSets.Items.Count > 0)
            {
                lbWorkingSets.SelectedItem = this.lbWorkingSets.Items[0];
            }
        }
Exemple #8
0
        public void AddWorkingSetLink(LazyTreeNode tn, LazyTreeNode ws)
        {
            var frmWS = new AddWSLink();

            frmWS.LoadList(ws);
            frmWS.WorkingSetSelectionMade += new AddWSLink.ChosenWorkingSet(frmWS_WorkingSetSelectionMade);
            AddLinkToWorkingSet            = tn;
            frmWS.ShowDialog();



            //dataManager.workingSet.AddWorkingSetLink();
        }
Exemple #9
0
        public void LoadList(LazyTreeNode node)
        {
            foreach (LazyTreeNode tn in node.Nodes)
            {
                lbWorkingSets.DisplayMember = "Text";
                lbWorkingSets.Items.Add(tn);
            }

            if (lbWorkingSets.Items.Count > 0)
            {
                lbWorkingSets.SelectedItem = this.lbWorkingSets.Items[0];
            }
        }
Exemple #10
0
        public override object Clone()
        {
            LazyTreeNode cloned = base.Clone() as LazyTreeNode;

            if (cloned == null)
            {
                return(base.Clone());
            }
            else
            {
                cloned.IsLoaded = this.IsLoaded;
                return(cloned);
            }
        }
Exemple #11
0
        public void MakeRootButtonClicked()
        {
            LazyTreeNode selectedNode = view.DisplaySelectedNode;

            if (selectedNode == null)
            {
                return;
            }

            if (selectedNode.Nodes.Count == 0)
            {
                selectedNode = selectedNode.Parent as LazyTreeNode;
            }

            view.RootsList(selectedNode);
            view.SetDisplayRoot(selectedNode);
        }
        private void OnNodeExpand(object sender, DoWorkEventArgs e)
        {
            TreeViewEventArgs tvargs   = (TreeViewEventArgs)e.Argument;
            LazyTreeNode      lazyNode = (LazyTreeNode)tvargs.Node;

            var retList = new List <LazyTreeNode>();

            if (lazyNode != null)
            {
                if (lazyNode.Tag is NodeTypes)
                {
                    retList = DataViewToNodes(presenter.GetNodeChildren(lazyNode.Name));
                }
                else
                {
                    retList = DataViewToNodes(presenter.GetNodeChildren((RootNodes)lazyNode.Tag));
                }
            }
            e.Result = new object[] { retList };
        }
Exemple #13
0
        public void RootsList(LazyTreeNode node)
        {
            // LazyTreeNode refNode = internalTree.Nodes[0] as LazyTreeNode ;
            // SetDisplayRoot(internalTreeMainRoot);
            LazyTreeNode currNode = this.treeManager.SelectedNode;

            this.tscbRootList.Items.Clear();
            this.treeManager.clearDisplay();
            RootsListRecurser(node);

            this.tscbRootList.SelectedIndexChanged -= new System.EventHandler(this.tscbRootListSelectionChanged);
            if (tscbRootList.Items.Count > 2)
            {
                this.tscbRootList.Items.RemoveAt(this.tscbRootList.Items.Count - 1);
            }
            this.tscbRootList.SelectedItem = this.tscbRootList.Items[this.tscbRootList.Items.Count - 1];


            this.tscbRootList.SelectedIndexChanged += new System.EventHandler(this.tscbRootListSelectionChanged);
            if (currNode != null)
            {
                SetDisplayRoot(currNode);
            }
        }
        public bool setDisplayNode(LazyTreeNode node)
        {
            displayTree.BeginUpdate();
            clearDisplay();

            TreeNode[] nodeRef = AllNode.Nodes.Find(node.Name, true);

            if (nodeRef.Count() < 1 && node.Name != AllNode.Name)
            {
                return(false);
            }

            if (node.Parent != null)
            {
                displayNodeParent = nodeRef[0].Parent as LazyTreeNode;
            }
            else
            {
                displayNodeParent = null;
            }

            if (node.Name == AllNode.Name)
            {
                nodeRef    = new TreeNode[1];
                nodeRef[0] = AllNode;
            }

            rootIndex = nodeRef[0].Index;
            nodeRef[0].Remove();
            displayTree.Nodes.Add(nodeRef[0]);
            displayTree.Expand(nodeRef[0]);

            displayNodeKey = nodeRef[0].Name;
            displayTree.EndUpdate();
            return(true);
        }
Exemple #15
0
        public void Expand(TreeNode treeNode)
        {
            this.BeginUpdate();
            if (treeNode == null)
            {
                return;
            }
            LazyTreeNode lazyNode = treeNode as LazyTreeNode;

            if (lazyNode == null)
            {
                treeNode.Expand();
            }
            else
            {
                OnAfterExpand(new TreeViewEventArgs(lazyNode));
                while (!lazyNode.IsLoaded)
                {
                    Application.DoEvents();
                }
                lazyNode.Expand();
            }
            this.EndUpdate();
        }
Exemple #16
0
 public ComboBoxItem(LazyTreeNode node)
 {
     Node = node;
 }
Exemple #17
0
 public void SetDisplayRoot(LazyTreeNode node)
 {
     treeManager.setDisplayNode(node);
 }
        public void LoadTree(Presenter setPresenter)
        {
            LoadImageList();
            displayTree.BeginUpdate();
            presenter = setPresenter;
            displayTree.Nodes.Clear();
            AllNode           = null;
            displayNodeKey    = "";
            displayNodeParent = null;
            rootIndex         = 0;


            displayTree.OnAfterFirstExpandNode += OnNodeExpand;


            LazyTreeNode root = new LazyTreeNode();

            root.Nodes.Clear();
            root.Text = "All";
            root.Name = "All";
            root.Tag  = "All";

            LazyTreeNode newRootNode = null;

            #region Loading the Nodes with Special Root Labels

            foreach (RootNodes rootNode in Enum.GetValues(typeof(RootNodes)))
            {
                DataView dataView = presenter.GetNodeChildren(rootNode);

                if (dataView != null)
                {
                    string imgName = Enum.GetName(typeof(RootNodes), rootNode);
                    newRootNode = new LazyTreeNode
                    {
                        Name = Enum.GetName(typeof(RootNodes), rootNode),
                        Text = Enum.GetName(typeof(RootNodes), rootNode),
                        Tag  = rootNode,
                        // SelectedImageKey = String.Format("TreeView4.Resources.{0}.bmp", imgName),
                        // ImageKey = String.Format("TreeView4.Resources.{0}.bmp", imgName)
                    };

                    if (newRootNode.Name == "WorkingSets")
                    {
                        newRootNode.Text = "Favorite Folders";
                    }

                    List <LazyTreeNode> children = DataViewToNodes(presenter.GetNodeChildren(rootNode));
                    newRootNode.Nodes.Clear();
                    newRootNode.Nodes.AddRange(children.ToArray());
                    newRootNode.IsLoaded = true;
                    root.Nodes.Add(newRootNode);
                }
            }

            #endregion

            root.IsLoaded = true;
            this.AllNode  = root;
            this.setDisplayNode(root);
            this.SelectedNode = root;


            // displayTree.ShowLines = false;
            // displayTree.ShowPlusMinus = false;
            displayTree.EndUpdate();
        }
Exemple #19
0
 public WorkingSetSelectedArgs(LazyTreeNode lazyNode)
 {
     Node = lazyNode;
 }
Exemple #20
0
 public void ListSelectionChange(LazyTreeNode node)
 {
     view.RootsList(node);
     view.SetDisplayRoot(node);
 }
Exemple #21
0
        public void RootsList(LazyTreeNode node)
        {
            // LazyTreeNode refNode = internalTree.Nodes[0] as LazyTreeNode ;
            // SetDisplayRoot(internalTreeMainRoot);
            LazyTreeNode currNode = this.treeManager.SelectedNode;
            this.tscbRootList.Items.Clear();
            this.treeManager.clearDisplay();
            RootsListRecurser(node);

            this.tscbRootList.SelectedIndexChanged -= new System.EventHandler(this.tscbRootListSelectionChanged);
            if (tscbRootList.Items.Count > 2)
            {
                this.tscbRootList.Items.RemoveAt(this.tscbRootList.Items.Count - 1);
            }
            this.tscbRootList.SelectedItem = this.tscbRootList.Items[this.tscbRootList.Items.Count - 1];

            this.tscbRootList.SelectedIndexChanged += new System.EventHandler(this.tscbRootListSelectionChanged);
            if(currNode!=null) SetDisplayRoot(currNode);
        }
Exemple #22
0
 public void SetDisplayRoot(LazyTreeNode node)
 {
     treeManager.setDisplayNode(node);
 }
Exemple #23
0
 public void ListSelectionChange(LazyTreeNode node)
 {
     view.RootsList(node);
     view.SetDisplayRoot(node);
 }
Exemple #24
0
        private void RootsListRecurser(LazyTreeNode node)
        {
            LazyTreeNode parentNode = (LazyTreeNode) node.Parent;

            if(parentNode!=null)
            {
                RootsListRecurser(parentNode);
            }

            tscbRootList.Items.Add(new ComboBoxItem(node));
        }
Exemple #25
0
 public ComboBoxItem(LazyTreeNode node)
 {
     Node = node;
 }
Exemple #26
0
 public WorkingSetSelectedArgs(LazyTreeNode lazyNode)
 {
     Node = lazyNode;
 }