Example #1
0
        /// <summary>
        /// Получить выбранный узел для выбора устройств записываемых в поле.
        /// </summary>
        /// <param name="e"></param>
        /// <returns></returns>
        private Node GetSelectedNodeForCheckOperationTree(TreePathEventArgs e)
        {
            Node selectedNode;

            if (!OnCheckOperationTree.UseParentNode)
            {
                selectedNode = (Node)e.Path.LastNode;
            }
            else
            {
                var path       = e.Path.FullPath;
                int pathLength = path.Length;
                if (pathLength > 1)
                {
                    var lastNode = (Node)path.Last();
                    selectedNode = lastNode.Parent;
                }
                else
                {
                    selectedNode = (Node)path.First();
                }

                OnCheckOperationTree.UseParentNode = false;
            }

            return(selectedNode);
        }
Example #2
0
        /// <summary>
        /// Снять выделение с некорректных значений внутри узла.
        /// </summary>
        /// <param name="e">Контекст переданный вызывающим кодом</param>
        /// <param name="selectedNodeText">Выбранное значение</param>
        private void UnselectIncorrectValues(TreePathEventArgs e,
                                             string selectedNodeText)
        {
            var lastNode       = e.Path.LastNode as Node;
            int fullPathLength = e.Path.FullPath.Length;

            if (lastNode.Nodes.Count == 0 && fullPathLength > 1)
            {
                int preLastIndexOffset = 2;
                int preLastNodeIndex   = fullPathLength - preLastIndexOffset;
                var preLastNode        = e.Path.FullPath[preLastNodeIndex] as Node;
                foreach (var node in preLastNode.Nodes)
                {
                    if (node.Text != selectedNodeText)
                    {
                        node.CheckState = CheckState.Unchecked;
                        OnCheckOperationTree.UseParentNode = true;
                    }
                }
            }
            else
            {
                lastNode.CheckState = CheckState.Unchecked;
            }
        }
Example #3
0
        private void _checked_CheckStateChanged(object sender, TreePathEventArgs e)
        {
            var  node      = ((AdvancedTreeNode)e.Path.LastNode);
            bool isChecked = node.Checked;

            //var item = _questions.FirstOrDefault(i => i.Title == node.Text);

            if (Reload && !WizardBeingUpdated)
            {
                bool previous = !isChecked;

                if (ContinueWithSignificantChange(sender, previous))
                {
                    GenerateNewTemplate = true;
                }
            }


            AutoSelectChildren(node, isChecked);
            TreeNodeAdv tvaNode = tvaQuestions.AllNodes.FirstOrDefault(x => x.ToString() == node.Text);

            if (tvaNode != null)
            {
                tvaNode.ExpandAll();
            }
        }
 public void OnStructureChanged(TreePathEventArgs args)
 {
     if (StructureChanged != null)
     {
         StructureChanged(this, args);
     }
 }
Example #5
0
        private void UpdatePlotSelection(object sender,
                                         TreePathEventArgs e)
        {
            List <ISensor> selected             = new List <ISensor>();
            IDictionary <ISensor, Color> colors = new Dictionary <ISensor, Color>();
            int colorIndex = 0;

            foreach (TreeNodeAdv node in treeView.AllNodes)
            {
                SensorNode sensorNode = node.Tag as SensorNode;
                if (sensorNode != null &&
                    sensorNode.Sensor.SensorType == SensorType.Temperature)
                {
                    if (sensorNode.Plot)
                    {
                        colors.Add(sensorNode.Sensor,
                                   plotColorPalette[colorIndex % plotColorPalette.Length]);
                        selected.Add(sensorNode.Sensor);
                    }
                    colorIndex++;
                }
            }
            sensorPlotColors = colors;
            plotPanel.SetSensors(selected, colors);
        }
Example #6
0
        private void _checked_CheckStateChanged(object sender, TreePathEventArgs e)
        {
            var node      = ((AdvancedTreeNode)e.Path.LastNode);
            var isChecked = node.Checked;

            if (isChecked)
            {
                var item = MinorItems.Find(i => i.Title == node.Text);
                if (item != null)
                {
                    tvaPolicies.AllNodes.ToList().ForEach(
                        (x) =>
                    {
                        var nodeControl = tvaPolicies.GetNodeControls(x);
                        if (nodeControl != null)
                        {
                            var checkbox = nodeControl.FirstOrDefault(y => (y.Control is NodeCheckBox));
                            //checkbox found
                            var dCheckBox = (NodeCheckBox)checkbox.Control;
                            if (dCheckBox != null)
                            {
                                dCheckBox.SetValue(x, false);
                            }
                        }
                    }
                        );
                    node.Checked    = true;
                    _selectedPolicy = item;
                }
            }
        }
Example #7
0
 protected void OnStructureChanged(TreePathEventArgs e)
 {
     if (StructureChanged != null)
     {
         StructureChanged(this, e);
     }
 }
Example #8
0
        /// <summary>
        /// Обработка выбора операции для добавления в ограничение.
        /// После выбора операции мы передаем новый словарь с ограничениями
        /// через делегат functionAfterCheck.
        /// </summary>
        private void treeItem_AfterCheck(object sender, TreePathEventArgs e)
        {
            if (functionAfterCheck != null)
            {
                OnCheckOperationTree.ResetResStr();
                OnCheckOperationTree.ResetResDict();

                string res     = "";
                var    resDict = new SortedDictionary <int, List <int> >();

                treeItem_ChangeCheckBoxState(sender, e);

                List <TreeNodeAdv> treeNodes = modesTreeViewAdv.AllNodes
                                               .ToList();
                TreeNodeAdv treeNode = treeNodes[0];
                OnCheckOperationTree.Execute(treeNode);

                res     = OnCheckOperationTree.GetResStr();
                resDict = OnCheckOperationTree.GetResDict();

                modesTreeViewAdv.Refresh();

                functionAfterCheck(resDict);
            }
        }
Example #9
0
 protected void OnCheckStateChanged(TreePathEventArgs args)
 {
     if (CheckStateChanged != null)
     {
         CheckStateChanged(this, args);
     }
 }
Example #10
0
        /// <summary>
        /// Функция обновления состояний чекбоксов
        /// </summary>
        /// <param name="sender">Объект, который вызвал функцию</param>
        /// <param name="e">Контекст переданный вызывающим кодом</param>
        private void exportingObjectsTree_ChangeCheckBoxState(object sender,
                                                              TreePathEventArgs e)
        {
            object nodeObject  = e.Path.LastNode;
            Node   checkedNode = nodeObject as Node;

            StaticHelper.GUIHelper.CheckCheckState(checkedNode);
        }
Example #11
0
        /// <summary>
        /// Функция обновления состояний чекбоксов
        /// </summary>
        /// <param name="sender">Объект, который вызвал функцию</param>
        /// <param name="e">Контекст переданный вызывающим кодом</param>
        private void treeItem_ChangeCheckBoxState(object sender,
                                                  TreePathEventArgs e)
        {
            // Нажатый узел дерева
            object nodeObject  = e.Path.LastNode;
            Node   checkedNode = nodeObject as Node;

            StaticHelper.GUIHelper.CheckCheckState(checkedNode);
        }
Example #12
0
        void CheckBoxStateChanged(object sender, TreePathEventArgs e)
        {
            ComponentNode node = e.Path.LastNode as ComponentNode;

            if (node != null)
            {
                RecursiveCheckComponent(node.TypedContent);
            }
        }
Example #13
0
        private void chkRuleEnabled_CheckStateChanged(object sender, TreePathEventArgs e)
        {
            var ignoredRule = e.Path.LastNode as BestPracticeRule;

            foreach (var rule in Analyzer.AllRules.Where(r => r.ID.EqualsI(ignoredRule.ID)))
            {
                rule.Enabled = ignoredRule.Enabled;
            }
        }
Example #14
0
        protected void OnStructureChanged(TreePathEventArgs e)
        {
            var handler = this.StructureChanged;

            if (handler != null)
            {
                handler(this, e);
            }
        }
Example #15
0
        private void _checked_CheckStateChanged(object sender, TreePathEventArgs e)
        {
            var node      = ((AdvancedTreeNode)e.Path.LastNode);
            var isChecked = node.Checked;


            if (Reload && !WizardBeingUpdated)
            {
                var previous = !isChecked;

                if (ContinueWithSignificantChange(sender, previous))
                {
                    GenerateNewTemplate = true;
                }
                else
                {
                    var nodeAdv = tvaPolicies.AllNodes.FirstOrDefault(x => x.ToString() == node.Text);

                    var type = sender.GetType();
                    if (type == typeof(NodeCheckBox))
                    {
                        ((NodeCheckBox)sender).SetValue(nodeAdv, previous);
                    }
                    return;
                }
            }

            var item = MinorItems.Find(i => i.Title == node.Text);

            if (isChecked)
            {
                if (item != null)
                {
                    //does it already exist in the selected fragemnts.
                    //multiple policy classes are mapped to the same fragement, we only want to insert one copy of the fragement in the template
                    //also alert the user that they have selected a policy class already mapped to a selected policy class
                    var mappingAlreadySelected =
                        _selectedQuestionnaireFragments.Find(i => i.FragmentPolicyUrl == item.FragmentPolicyUrl);
                    if (mappingAlreadySelected == null) //no existing mapping found
                    {
                        _selectedQuestionnaireFragments.Add(item);
                    }
                    else
                    {
                        MessageBox.Show(
                            string.Format(
                                "The selected policy class '{0}' is already mapped to the same questionnaire as a previously selected policy class '{1}'. \n You will only receive one questionnaire for these policy classes.",
                                item.Title, mappingAlreadySelected.Title));
                    }
                }
            }
            else
            {
                _selectedQuestionnaireFragments.Remove(item);
            }
        }
Example #16
0
        private void OnTreeModelStructureChanged(object sender, TreePathEventArgs e)
        {
            var rootNode = m_treeModel.Root.Nodes.ElementAt(0);

            m_view.SetExpanded(rootNode);
            if (m_treeModel.FilterIO || m_treeModel.FilterNet || m_treeModel.FilterSecurity)
            {
                ExpandAll(rootNode);
            }
        }
Example #17
0
        /// <summary>
        /// Функция обновления состояний чекбоксов
        /// </summary>
        /// <param name="sender">Объект, который вызвал функцию</param>
        /// <param name="e">Контекст переданный вызывающим кодом</param>
        private void treeItem_ChangeCheckBoxState(object sender, TreePathEventArgs e)
        {
            // Нажатый узел дерева
            object nodeObject  = e.Path.LastNode;
            Node   checkedNode = nodeObject as Node;

            // Выставляем состояние родителя
            RecursiveCheckParent(checkedNode.Parent);

            // Выставляем состояние узла
            RecursiveCheck(checkedNode);
        }
Example #18
0
        /// <summary>
        /// Функция обновления состояний чекбоксов
        /// </summary>
        /// <param name="sender">Объект, который вызвал функцию</param>
        /// <param name="e">Контекст переданный вызывающим кодом</param>
        private void treeItem_ChangeCheckBoxState(object sender,
                                                  TreePathEventArgs e)
        {
            // Нажатый узел дерева
            object nodeObject  = e.Path.LastNode;
            Node   checkedNode = nodeObject as Node;

            if (SelectedTreeItem == EditType.AttachedAgregates)
            {
                UnselectIncorrectValues(e, checkedNode.Text);
            }

            StaticHelper.GUIHelper.CheckCheckState(checkedNode);
        }
Example #19
0
        private void _checked_CheckStateChanged(object sender, TreePathEventArgs e)
        {
            var  node      = ((AdvancedTreeNode)e.Path.LastNode);
            bool isChecked = node.Checked;

            if (Reload && !WizardBeingUpdated)
            {
                bool previous = !isChecked;

                if (ContinueWithSignificantChange(sender, previous))
                {
                    GenerateNewTemplate = true;
                }
                else
                {
                    node.Checked = previous;
                }
            }

            //var node = ((AdvancedTreeNode)e.Path.LastNode);
            //var isChecked = node.Checked;

            //if (isChecked)
            //{
            //    var item = MinorItems.Find(i => i.Title == node.Text);
            //    if (item != null)
            //    {
            //        tvaPolicies.AllNodes.ToList().ForEach(
            //            (x) =>
            //            {
            //                var nodeControl = tvaPolicies.GetNodeControls(x);
            //                if (nodeControl != null)
            //                {
            //                    var checkbox = nodeControl.FirstOrDefault(y => (y.Control is NodeCheckBox));
            //                    //checkbox found
            //                    var dCheckBox = (NodeCheckBox)checkbox.Control;
            //                    if (dCheckBox != null)
            //                        dCheckBox.SetValue(x, false);
            //                }
            //            }
            //            );
            //        node.Checked = true;
            //        _selectedPolicy = item;
            //    }
            //}
        }
Example #20
0
        /// <summary>
        /// Обработка выбора операции для добавления в ограничение.
        /// После выбора операции мы передаем новый словарь с ограничениями
        /// через делегат functionAfterCheck.
        /// </summary>
        private void treeItem_AfterCheck(object sender, TreePathEventArgs e)
        {
            if (functionAfterCheck != null)
            {
                treeItem_ChangeCheckBoxState(sender, e);

                Node selectedNode = GetSelectedNodeForCheckOperationTree(e);
                OnCheckOperationTree.Execute(selectedNode, SelectedTreeItem);

                IDictionary <int, List <int> > resDict;
                resDict = OnCheckOperationTree.GetResDict();

                modesTreeViewAdv.Refresh();

                functionAfterCheck(resDict);
            }
        }
Example #21
0
        private void NotifyStructureChanged(RepositoryItem repositoryItem)
        {
            if (!_notify)
            {
                return;
            }

            var model = FindModel();

            if (model != null && this.Parent != null)
            {
                TreePath path = model.GetPath(repositoryItem);
                if (path != null)
                {
                    var args = new TreePathEventArgs(path);
                    model.RaiseStructureChanged(args);
                }
            }
        }
Example #22
0
        /// <summary>
        /// Обработка выбора устройства для добавления его к шагу.
        /// После выбора устройства мы передаем новую строку с устройствами
        /// через делегат functionAfterCheck.
        /// </summary>
        private void treeItem_AfterCheck(object sender, TreePathEventArgs e)
        {
            if (functionAfterCheck != null)
            {
                OnCheckOperationTree.ResetResStr();
                string res = "";

                treeItem_ChangeCheckBoxState(sender, e);

                List <TreeNodeAdv> treeNodes = devicesTreeViewAdv.AllNodes.ToList();
                TreeNodeAdv        treeNode  = treeNodes[0];
                OnCheckOperationTree.Execute(treeNode);

                res = OnCheckOperationTree.GetResStr();

                devicesTreeViewAdv.Refresh();

                functionAfterCheck(res);
            }
        }
        void NodeCheckStateChanged(object sender, TreePathEventArgs e)
        {
            ColumnNode checkedNode = (ColumnNode)e.Path.FirstNode;

            if (checkedNode.CheckState == CheckState.Checked)
            {
                //if (checkedNode.Parent.CheckState != CheckState.Checked && checkedNode.Parent.Index !=-1)
                //    UpdateParentCheckState((ColumnNode)checkedNode.Parent);
                //CheckAllSubnodes(checkedNode, false);
                //checkedFilesSize += ((CloudFolder)checkedNode.Tag).Size - ((CloudFolder)checkedNode.Tag).SizeTopDirectoryOnly;
                //label1.Text = $"{Math.Round(checkedFilesSize / 1024000.0, 2)} MB checked";
            }
            else if (checkedNode.CheckState == CheckState.Unchecked)
            {
                //checkedFilesSize -= ((CloudFolder)checkedNode.Tag).Size;
                //if (checkedFilesSize < 0.0001)
                //    checkedFilesSize = 0;
                //label1.Text = $"{Math.Round(checkedFilesSize / 1024000.0, 2)} MB checked";

                //if (checkedNode.Parent.Index != -1)
                //    UpdateParentCheckState((ColumnNode)checkedNode.Parent);
                //CheckAllSubnodes(checkedNode, true);
            }
            else if (checkedNode.CheckState == CheckState.Indeterminate)
            {
                if (checkedNode.Tag?.GetType().ToString() == "CloudFolderBrowser.CloudFile")
                {
                    checkedNode.CheckState = CheckState.Unchecked;
                }
                //checkedFilesSize += ((CloudFolder)checkedNode.Tag).SizeTopDirectoryOnly;//((CloudFolder)parentNode.Tag).Files.Sum(x => x.Size) / 1024000.0;
                //checkedFilesSize = Math.Round(checkedFilesSize, 2);
                //label1.Text = $"{Math.Round(checkedFilesSize / 1024000.0, 2)} MB checked";
                //if(parentNode.Parent.Index != -1)
                //UpdateParentCheckState((ColumnNode)parentNode.Parent);
                //CheckAllSubnodes(parentNode, true);
            }
            if (checkedNode.Parent.Index != -1)
            {
                UpdateParentCheckState((ColumnNode)checkedNode.Parent);
            }
        }
        private void nodeCheckBox1_CheckStateChanged(object sender, TreePathEventArgs e)
        {
            var selectedNode = (e.Path.LastNode as SchemaNode);

            if (SingleSelection)
            {
                if (selectedNode.Selected == false)
                {
                    selectedNode.Selected = true;
                    return;
                }
                foreach (var schemaNode in treeViewAdv1.AllNodes.Select(n => n.Tag).OfType <SchemaNode>().Where(sn => sn.Selected).ToList())
                {
                    if (selectedNode != schemaNode)
                    {
                        schemaNode.Selected = false;
                    }
                }
            }
            OnValidated(new EventArgs());
        }
        private void nodeCheckBox1_CheckStateChanged(object sender, TreePathEventArgs e)
        {
            var currentItem = (e.Path.LastNode as Change);
            var currentNode = treeViewAdv1.FindNode(e.Path);

            if (currentItem.ChangeType != ChangeType.Table)
            {
                var parentNode = currentNode.Parent;
                var parentItem = parentNode.Tag as Change;
                if (parentNode.Children.Any(n => (n.Tag as Change).ChangeInclude != currentItem.ChangeInclude))
                {
                    parentItem.ChangeInclude = CheckState.Indeterminate;
                }
                else
                {
                    parentItem.ChangeInclude = currentItem.ChangeInclude;
                }
            }
            else
            {
                foreach (var child in currentNode.Children)
                {
                    (child.Tag as Change).ChangeInclude = currentItem.ChangeInclude;
                }
            }

            suspendSelectAll = true;
            var state = Model.TableChanges.Keys.First().ChangeInclude;

            if (Model.TableChanges.Keys.All(k => k.ChangeInclude == state))
            {
                chkSelectAll.CheckState = state;
            }
            else
            {
                chkSelectAll.CheckState = CheckState.Indeterminate;
            }
            suspendSelectAll = false;
        }
Example #26
0
 protected void OnStructureChanged(TreePathEventArgs e)
 {
     this.StructureChanged?.Invoke(this, e);
 }
Example #27
0
 public void OnStructureChanged(TreePathEventArgs args)
 {
     StructureChanged?.Invoke(this, args);
 }
Example #28
0
        private void _model_StructureChanged(object sender, TreePathEventArgs e)
        {
            if (e.Path == null)
                throw new ArgumentNullException();

            TreeNodeAdv node = FindNode(e.Path);
            if (node != null)
            {
                Collection<ExpandedNode> expandedNodes = null;
                if (KeepNodesExpanded && node.IsExpanded)
                {
                    expandedNodes = FindExpandedNodes(node);
                }
                _structureUpdating = true;
                try
                {
                    ReadChilds(node, expandedNodes);
                    UpdateSelection();
                }
                finally
                {
                    _structureUpdating = false;
                }
                SmartFullUpdate();
            }
        }
Example #29
0
 protected void OnCheckStateChanged(TreePathEventArgs args)
 {
     if (CheckStateChanged != null)
         CheckStateChanged(this, args);
 }
        private void _checked_CheckStateChanged(object sender, TreePathEventArgs e)
        {
            var node      = ((AdvancedTreeNode)e.Path.LastNode);
            var isChecked = node.Checked;

            if (Reload && !WizardBeingUpdated)
            {
                var previous = !isChecked;

                if (ContinueWithSignificantChange(sender, previous))
                {
                    _generateNewTemplate = true;
                }
                else
                {
                    TreeNodeAdv nodeAdv = tvaPolicies.AllNodes.FirstOrDefault(x => x.ToString() == node.Text);

                    var type = sender.GetType();
                    if (type == typeof(NodeCheckBox))
                    {
                        ((NodeCheckBox)sender).SetValue(nodeAdv, previous);
                    }
                    return;
                }
            }

            if (isChecked)
            {
                var parent = ((AdvancedTreeNode)e.Path.FirstNode);
                if (parent != null)
                {
                    //var item = MinorItems.Find(i => i.Title == node.Text && i.MajorClass == parent.Text);
                    //if (item != null)
                    //{

                    //}
                    //var d = _treeModel.Nodes[2];
                    var insurers = new Popups.Insurers();
                    this.TopMost = false;
                    this.Cursor  = Cursors.WaitCursor;
                    //insurers.CurrentInsurers = _insurers;
                    insurers.ShowDialog();
                    this.Cursor = Cursors.Default;

                    if (insurers.RecommendedInsurer != null && insurers.CurrentInsurer != null)
                    {
                        //item.CurrentInsurer = insurers.CurrentInsurer;
                        //item.RecommendedInsurer = insurers.RecommendedInsurer;
                        //item.CurrentInsurerId = insurers.CurrentInsurerId;
                        //item.RecommendedInsurerId = insurers.RecommendedInsurerId;
                        //  _selectedDocumentFragments.Add(item);

                        node.Reccommended   = insurers.RecommendedInsurer;
                        node.Current        = insurers.CurrentInsurer;
                        node.ReccommendedId = insurers.RecommendedInsurerId;
                        node.CurrentId      = insurers.CurrentInsurerId;

                        TreeNodeAdv maxOrder  = null;
                        int         maxNumber = 0;
                        foreach (TreeNodeAdv x in tvaPolicies.AllNodes)
                        {
                            var currentNumber = _orderPolicy.GetValue(x);
                            if (currentNumber != null)
                            {
                                int intCurrentNumber = 0;
                                if (int.TryParse(currentNumber.ToString(), out intCurrentNumber))
                                {
                                    if (intCurrentNumber > maxNumber)
                                    {
                                        maxNumber = intCurrentNumber;
                                    }
                                }
                            }
                        }
                        node.OrderPolicy = (maxNumber + 1).ToString();
                    }
                    else
                    {
                        node.Checked = false;
                    }
                }
            }
            else
            {
                var item = MinorItems.Find(i => i.Title == node.Text);
                // var item  = fragementPresenter.
                if (item != null)
                {
                    //    _selectedDocumentFragments.Remove(item);
                }
            }
        }
Example #31
0
 private void AnalyzerResultsTreeModel_StructureChanged(object sender, TreePathEventArgs e)
 {
     AutofitColObject();
 }
Example #32
0
 void _innerModel_StructureChanged(object sender, TreePathEventArgs e)
 {
     OnStructureChanged(e);
 }
Example #33
0
        private void _model_StructureChanged(object sender, TreePathEventArgs e)
        {
            if (e.Path == null)
                throw new ArgumentNullException();

            TreeNodeAdv node = FindNode(e.Path);
            if (node != null)
            {
                ReadChilds(node);
                UpdateSelection();
                SmartFullUpdate();
            }
            //else
            //	throw new ArgumentException("Path not found");
        }
Example #34
0
 public void OnStructureChanged(TreePathEventArgs args)
 {
     if (StructureChanged != null)
         StructureChanged(this, args);
 }
Example #35
0
 private void OnPPRTreeModel_StructureChanged(object sender, TreePathEventArgs e)
 {
     //throw new NotImplementedException();
 }