C# TreeListNode.SetValue方法代码示例

 public override void Execute(TreeListNode node)
 {
     if (node.HasAsParent(_parentNode))
         node.SetValue(_column, _state);
     else
     {
         if (_parentNode.HasAsParent(node))
             if (_state)
                 node[_column] = _state;
             else node[_column] = !_state;
     }
 }

 public void CalcYearVol(TreeListNode node, double vol,string year)
 {
     double v = vol - double.Parse(lastEditValue);
     double temp = 0.0;
     double tot=double.Parse(node.GetValue("y"+Convert.ToString(yAnge.StartYear+1)).ToString());
     if (tot >= v)
     {
         node.SetValue("y" + Convert.ToString(yAnge.StartYear + 1), tot - v);
         //node.SetValue("AftVolumn", double.Parse(node.GetValue("AftVolumn").ToString())-v);
        // node.ParentNode.SetValue("AftVolumn", double.Parse(node.ParentNode.GetValue("AftVolumn").ToString()) - v);
         node.ParentNode.SetValue("y" + Convert.ToString(yAnge.StartYear + 1), double.Parse(node.ParentNode.GetValue("y" + Convert.ToString(yAnge.StartYear + 1)).ToString()) - v);
         node.SetValue(year, vol);
     }
 }

 public void CalcNotZero(TreeListNode node,double vol)
 {
     double v=vol-double.Parse(lastEditValue);
     double temp=0.0,temp1=0.0,temp2=0.0;
     node.SetValue("AftVolumn", double.Parse(node.GetValue("AftVolumn").ToString()) - v);
     node.ParentNode.SetValue("AftVolumn", double.Parse(node.ParentNode.GetValue("AftVolumn").ToString()) - v);
     for (int i = yAnge.StartYear + 5; i >= yAnge.StartYear + 1 ; i--)
     {
         temp2=temp = double.Parse(node.GetValue("y" + i).ToString());
         temp1 = double.Parse(node.ParentNode.GetValue("y" + i).ToString());
         if (temp != 0.0)
         {
             temp = temp - v;
            // temp1=temp1-v;
             v = 0 - temp;
             if (temp < 0)
                 temp = 0;
           //  if (temp1 < 0)
           //      temp1 = 0;
             node.SetValue("y" + i, temp);
             node.ParentNode.SetValue("y" + i, temp1-temp2+temp);
             if (temp > 0)
                 return;
         }
     }
 }

 public void CalcNotAll(TreeListNode node, double vol)
 {
     double v = vol - double.Parse(lastEditValue);
        // node.ParentNode.SetValue("AllVolumn", double.Parse(node.ParentNode.GetValue("AllVolumn").ToString()) + v);
     double temp = 0.0, temp1 = 0.0, temp2 = 0.0;
     double tot = double.Parse(node.GetValue("y" + Convert.ToString(yAnge.StartYear + 1)).ToString());
     node.SetValue("AftVolumn", double.Parse(node.GetValue("AftVolumn").ToString()) + v);
     node.ParentNode.SetValue("AftVolumn", double.Parse(node.ParentNode.GetValue("AftVolumn").ToString()) + v);
     if (v > 0)
     {
         node.SetValue("y" + Convert.ToString(yAnge.StartYear + 1), tot + v);
         node.ParentNode.SetValue("y" + Convert.ToString(yAnge.StartYear + 1), double.Parse(node.ParentNode.GetValue("y" + Convert.ToString(yAnge.StartYear + 1)).ToString()) + v);
     }
     else
     {
         for (int i = yAnge.StartYear + 5; i >= yAnge.StartYear + 1; i--)
         {
             temp2 = temp = double.Parse(node.GetValue("y" + i).ToString());
             temp1 = double.Parse(node.ParentNode.GetValue("y" + i).ToString());
             if (temp != 0.0)
             {
                 temp = temp + v;
                 // temp1=temp1-v;
                 v = 0 - temp;
                 if (temp < 0)
                     temp = 0;
                 //  if (temp1 < 0)
                 //      temp1 = 0;
                 node.SetValue("y" + i, temp);
                 node.ParentNode.SetValue("y" + i, temp1 - temp2 + temp);
                 if (temp > 0)
                     return;
             }
         }
     }
 }

        //���������ֵ
        private void CalculateSum(TreeListNode node)
        {
            double total = 0.0;//��
            double max = 0.0;//���ֵ

            for (int i = 1; i < 13; i++ )
            {
                object v = node.GetValue(i.ToString() + "��");
                if (v != DBNull.Value)
                {
                    double dv = (double)v;
                    total += dv;
                    if(max < dv)
                    {
                        max = dv;
                    }
                }
            }

            node.SetValue("13��", Math.Round(total, 4));
            node.SetValue("14��", Math.Round(max, 4));
            node.SetValue("15��", Math.Round(total / 12.0 / max, 4));
        }

        public void CalcTotal(TreeListNode node, TreeListColumn column)
        {
            double total = 0.0;

            foreach (TreeListNode nd in node.Nodes)
            {
                string temp = column.Name.ToString().Substring(4, column.Name.ToString().Length-4);
                total += double.Parse(nd.GetValue(temp).ToString());
            }
            node.SetValue(column.Name.ToString().Substring(4, column.Name.ToString().Length - 4), total);
        }

 void CreateMessagesForNode(TreeListNode node)
 {
     List<User> users = new List<User>();
     MailType mailType = (MailType)node.GetValue(colType);
     MailFolder mailFolder = (MailFolder)node.GetValue(colFolder);
     foreach (User user in DataHelper.User)
     {
         //if (user.MailType == mailType &&
         //    (user.MailFolder == mailFolder || mailFolder == MailFolder.All) &&
         //    !user.Deleted)
         users.Add(user);
     }
     node.SetValue(colData, users);
 }

 private void UpdateTreeListNodeText(TreeListNode treeListNode, ScriptBase scriptBase)
 {
     string[] columnTexts = GetTreeListNodeText(scriptBase);
     for (int i = 0; i < columnTexts.Length; i++)
     {
         treeListNode.SetValue(i, columnTexts[i]);
     }
     treeListNode.Tag = scriptBase;
 }

        private void SetRateYearValue(TreeListNode node, double sum)
        {
            string baseyear = "";
            baseyear = EnsureBaseYear(baseyear);
            if (baseyear != "")
            {
                double rate = 0;
                double sumtemp = sum;
                int yeartemp = 0;
                PSP_Years psp_Year = new PSP_Years();
                psp_Year.Flag = typeFlag2;
                psp_Year.Year = Convert.ToInt32(baseyear);
                IList<PSP_Years> listYears = Common.Services.BaseService.GetList<PSP_Years>("SelectPSP_YearsListByFlagAndYear", psp_Year);
                yeartemp = Convert.ToInt32(baseyear);

                foreach (PSP_Years yearvalue in listYears)
                {

                    if (yearvalue.Year == Convert.ToInt32(baseyear)) continue;
                    try
                    {
                        PSP_BaseYearRate yearvaluetemp = new PSP_BaseYearRate();
                        yearvaluetemp.BaseYear = yearvalue.Year.ToString();
                        yearvaluetemp.TypeID =Convert.ToInt32(node.GetValue("ID"));
                        IList<PSP_BaseYearRate> list1 = Common.Services.BaseService.GetList<PSP_BaseYearRate>("SelectPSP_BaseYearRateByYear", yearvaluetemp);

                        if (list1.Count == 1)
                    {
                        rate = Convert.ToDouble(list1[0].YearRate);
                    }
                    sumtemp = sumtemp * Math.Pow(1 + rate, yearvalue.Year - yeartemp);

                    node.SetValue(yearvalue.Year + "��", Math.Round(sumtemp, 2));
                    yeartemp = yearvalue.Year;
                    SaveCellValue((int)yearvalue.Year, (int)node.GetValue("ID"), Convert.ToDouble(sumtemp));

                 }
                catch { }
                }

            }
        }

        //someoneyear
        public void CalcYearVol(TreeListNode node, double vol,string year)
        {
            double v = vol;
            double tempdb = 0.0;
            double maxdb=0;
            if (int.Parse(node.GetValue("BuildEd").ToString()) >= yAnge.StartYear + 5)
            {
                 //maxdb= double.Parse(node.GetValue("y"+(yAnge.StartYear + 5)).ToString());
                for (int i = yAnge.StartYear + 4; i >= yAnge.StartYear + 1; i--)
                {
                    if (("y" + i).ToString() != year)
                    {
                        tempdb += double.Parse(node.GetValue("y" + i).ToString());
                    }

                }
                maxdb = double.Parse(node.GetValue("AftVolumn").ToString())-tempdb;
                if (vol>maxdb)
                {

                    node.SetValue(year, maxdb);
                    node.SetValue("y" + (yAnge.StartYear + 5), 0);
                }
                else
                {
                    node.SetValue("y" + (yAnge.StartYear + 5), maxdb -v);
                }
            }
            else
            {
                string endyear = "y" + node.GetValue("BuildEd").ToString();

                //maxdb = double.Parse(node.GetValue(endyear).ToString());
                for (int i = yAnge.StartYear + 5; i >= yAnge.StartYear + 1; i--)
                {
                    if (("y" + i).ToString() != year && ("y" + i).ToString() != endyear)
                    {
                        tempdb += double.Parse(node.GetValue("y" + i).ToString());
                    }

                }
                maxdb = double.Parse(node.GetValue("AftVolumn").ToString()) - tempdb;
                if (vol > maxdb)
                {

                    node.SetValue(year, maxdb);
                    node.SetValue(endyear, 0);
                }
                else
                {
                    node.SetValue(endyear, maxdb-v);
                }
            }
            DataRow row = (node.TreeList.GetDataRecordByNode(node) as DataRowView).Row;
            Ps_Table_TZGS tzgs = DataConverter.RowToObject<Ps_Table_TZGS>(row);
            Common.Services.BaseService.Update<Ps_Table_TZGS>(tzgs);
        }

        //befovlumn
        public void CalcNotZero(TreeListNode node,double vol)
        {
            double v = vol;
            double temp=0.0,temp1=0.0,temp2=0.0;
            temp=double.Parse(node.GetValue("AllVolumn").ToString()) ;
            double aftvolumn = temp- v;
            if (aftvolumn<=0)
            {
                aftvolumn = 0;
                node.SetValue("AftVolumn", 0);
                node.SetValue("BefVolumn", temp);
            }
            node.SetValue("AftVolumn",aftvolumn );

            if (int.Parse(node.GetValue("BuildEd").ToString()) >= yAnge.StartYear + 5)
            {
                node.SetValue("y" + (yAnge.StartYear + 5), aftvolumn);
                node.SetValue("y" + (yAnge.StartYear + 4), 0);

                node.SetValue("y" + (yAnge.StartYear + 3), 0);

                node.SetValue("y" + (yAnge.StartYear + 2), 0);

                node.SetValue("y" + (yAnge.StartYear + 1), 0);

            }
            else
            {

                for (int i = yAnge.StartYear + 5; i >= yAnge.StartYear + 1; i--)
                {
                    if (i == int.Parse(node.GetValue("BuildEd").ToString()))
                    {
                        node.SetValue("y" +i, aftvolumn);
                    }
                    else
                    {
                        node.SetValue("y" + i, 0);
                    }
                }
            }
            DataRow row = (node.TreeList.GetDataRecordByNode(node) as DataRowView).Row;
            Ps_Table_TZGS tzgs = DataConverter.RowToObject<Ps_Table_TZGS>(row);
            Common.Services.BaseService.Update<Ps_Table_TZGS>(tzgs);
        }

        private void CalculateSum3(TreeListNode parentNode, string columnname)
        {
            if (parentNode == null)
            {
                return;
            }

            double sum = 0;
            foreach (TreeListNode nd in parentNode.Nodes)
            {
                object value = nd.GetValue(columnname);
                double tempdb = 0;
                if (value != null && value != DBNull.Value)
                {
                    double.TryParse(value.ToString(), out tempdb);
                    sum += tempdb;
                }
            }
            if (sum != 0)
            {
                bPast = true;
                parentNode.SetValue(columnname, sum);
                bPast = false;
                DataRow row = (parentNode.TreeList.GetDataRecordByNode(parentNode) as DataRowView).Row;
                Ps_Table_TZGS tzgs = DataConverter.RowToObject<Ps_Table_TZGS>(row);
                Common.Services.BaseService.Update<Ps_Table_TZGS>(tzgs);

            }
            else
            {
                bPast = true;
                parentNode.SetValue(columnname, 0);
                bPast = false;
            }
        }

        public void CalcYearVol(TreeListNode node, double vol,string year,TreeListColumn column)
        {
            //double v = vol - double.Parse(lastEditValue);
            //double temp = 0.0;
            //double tot=double.Parse(node.GetValue("y"+Convert.ToString(yAnge.StartYear+1)).ToString());
            //if (tot >= v)
            //{
            //    node.SetValue("y" + Convert.ToString(yAnge.StartYear + 1), tot - v);
            //    //node.SetValue("AftVolumn", double.Parse(node.GetValue("AftVolumn").ToString())-v);
            //   // node.ParentNode.SetValue("AftVolumn", double.Parse(node.ParentNode.GetValue("AftVolumn").ToString()) - v);
            //    node.ParentNode.SetValue("y" + Convert.ToString(yAnge.StartYear + 1), double.Parse(node.ParentNode.GetValue("y" + Convert.ToString(yAnge.StartYear + 1)).ToString()) - v);
            //    node.SetValue(year, vol);
            //}

            double tot = 0.0;
            for (int i = 1; i < 6; i++)
            {
                tot += double.Parse(node.GetValue("y" + Convert.ToString(yAnge.StartYear + i)).ToString());
            }
            if (double.Parse(node.GetValue("Amount").ToString()) <tot)
            {
                flag = true;
                MessageBox.Show("分年投资总额不能大于总投资", "错误");
                node.SetValue(year, double.Parse(OldEditValue));
                flag = false;
                 return;
            }

            //重新计算当前列的父结点值
            CalculateSum(node, column);

            //改变分项n-m年投资合计
            node.SetValue("AftVolumn", tot);
            //改变分项n—m年投资合计的总值父结点
            CalcTotal(node.ParentNode, "AftVolumn");

            node.SetValue("BefVolumn", Math.Round(double.Parse(node.GetValue("Amount").ToString()) - tot,3));
            //改变分项m年低投资合计的总值父结点
            CalcTotal(node.ParentNode, "BefVolumn");

            //保存数据
            try
            {
                DataRow row = (node.TreeList.GetDataRecordByNode(node) as DataRowView).Row;
                Ps_Table_TZGS tzgs = DataConverter.RowToObject<Ps_Table_TZGS>(row);
                Common.Services.BaseService.Update<Ps_Table_TZGS>(tzgs);

                DataRow row1 = (node.ParentNode.TreeList.GetDataRecordByNode(node.ParentNode) as DataRowView).Row;
                Ps_Table_TZGS tzgs1 = DataConverter.RowToObject<Ps_Table_TZGS>(row1);
                Common.Services.BaseService.Update<Ps_Table_TZGS>(tzgs1);
            }
            catch (Exception)
            {

                throw;
            }
        }

        //
        private void SetDefaultValues(TreeListNode node)
        {
            if (node.HasChildren)
            {
                foreach (TreeListNode nd in node.Nodes)
                {
                    SetDefaultValues(nd);
                }
            }
            else
            {

                for (int i = forecastReport.StartYear + 1; i <= forecastReport.EndYear; i++)
                {
                    foreach (DataRow row in dataTable2.Rows)
                    {
                        if (row["Title"].ToString() != node["Title"].ToString())
                            continue;
                        try
                        {
                            double d1 = (double)row[i.ToString() + "年"];
                            double d2 = (double)row[(i - 1).ToString() + "年"];
                            node.SetValue(i + "年", (d1 - d2) / d2);
                        }
                        catch { }
                    }

                }
            }
        }

        private void UpdateScriptObjectNode(TreeListNode scriptObjectNode, ScriptObject scriptObject)
        {
            scriptObjectNode.SetValue(0, scriptObject.Alias);
            scriptObjectNode.SetValue(1, scriptObject.Name != scriptObject.Alias ? scriptObject.Name : null);
            scriptObjectNode.Tag = scriptObject;
            AddOptionNodes(scriptObjectNode, scriptObject);

            TreeListNode columnNodes = treeList.AppendNode(new object[] { "Columns", null, null }, scriptObjectNode);
            columnNodes.Tag = scriptObject.Columns;
            columnNodes.ImageIndex = columnNodes.SelectImageIndex = (int)Images.Column;

            foreach (Column column in scriptObject.Columns)
            {
                TreeListNode columnNode = treeList.AppendNode(GetTreeListNodeText(column), columnNodes);
                columnNode.Tag = column;
                columnNode.ImageIndex = columnNode.SelectImageIndex = (int)Images.GreenBullet;
                AddOptionNodes(columnNode, (ScriptBase)column);
            }

            TreeListNode relationshipNodes = treeList.AppendNode(new object[] { "Relationships" }, scriptObjectNode);
            relationshipNodes.Tag = scriptObject.Relationships;
            relationshipNodes.ImageIndex = relationshipNodes.SelectImageIndex = (int)Images.Relationship;

            TreeListNode oneToOneRelationshipNodes = treeList.AppendNode(new object[] { "One to One" }, relationshipNodes);
            oneToOneRelationshipNodes.Tag = scriptObject.OneToOneRelationships;
            oneToOneRelationshipNodes.ImageIndex = oneToOneRelationshipNodes.SelectImageIndex = (int)Images.Relationship;

            foreach (OneToOneRelationship oneToOneRelationship in scriptObject.OneToOneRelationships)
            {
                TreeListNode oneToOneRelationshipNode = treeList.AppendNode(GetTreeListNodeText(oneToOneRelationship), oneToOneRelationshipNodes);
                oneToOneRelationshipNode.Tag = oneToOneRelationship;
                oneToOneRelationshipNode.ImageIndex = oneToOneRelationshipNode.SelectImageIndex = (int)Images.GreenBullet;
                AddOptionNodes(oneToOneRelationshipNode, (ScriptBase)oneToOneRelationship);
            }

            TreeListNode oneToManyRelationshipNodes = treeList.AppendNode(new object[] { "One to Many" }, relationshipNodes);
            oneToManyRelationshipNodes.Tag = scriptObject.OneToManyRelationships;
            oneToManyRelationshipNodes.ImageIndex = oneToManyRelationshipNodes.SelectImageIndex = (int)Images.Relationship;

            foreach (OneToManyRelationship oneToManyRelationship in scriptObject.OneToManyRelationships)
            {
                TreeListNode oneToManyRelationshipNode = treeList.AppendNode(GetTreeListNodeText(oneToManyRelationship), oneToManyRelationshipNodes);
                oneToManyRelationshipNode.Tag = oneToManyRelationship;
                oneToManyRelationshipNode.ImageIndex = oneToManyRelationshipNode.SelectImageIndex = (int)Images.GreenBullet;
                AddOptionNodes(oneToManyRelationshipNode, (ScriptBase)oneToManyRelationship);
            }

            TreeListNode manyToOneRelationshipNodes = treeList.AppendNode(new object[] { "Many to One" }, relationshipNodes);
            manyToOneRelationshipNodes.Tag = scriptObject.ManyToOneRelationships;
            manyToOneRelationshipNodes.ImageIndex = manyToOneRelationshipNodes.SelectImageIndex = (int)Images.Relationship;

            foreach (ManyToOneRelationship manyToOneRelationship in scriptObject.ManyToOneRelationships)
            {
                TreeListNode manyToOneRelationshipNode = treeList.AppendNode(GetTreeListNodeText(manyToOneRelationship), manyToOneRelationshipNodes);
                manyToOneRelationshipNode.Tag = manyToOneRelationship;
                manyToOneRelationshipNode.ImageIndex = manyToOneRelationshipNode.SelectImageIndex = (int)Images.GreenBullet;
                AddOptionNodes(manyToOneRelationshipNode, (ScriptBase)manyToOneRelationship);
            }

            TreeListNode manyToManyRelationshipNodes = treeList.AppendNode(new object[] { "Many to Many" }, relationshipNodes);
            manyToManyRelationshipNodes.Tag = scriptObject.ManyToManyRelationships;
            manyToManyRelationshipNodes.ImageIndex = manyToManyRelationshipNodes.SelectImageIndex = (int)Images.Relationship;

            foreach (ManyToManyRelationship manyToManyRelationship in scriptObject.ManyToManyRelationships)
            {
                TreeListNode manyToManyRelationshipNode = treeList.AppendNode(GetTreeListNodeText(manyToManyRelationship), manyToManyRelationshipNodes);
                manyToManyRelationshipNode.Tag = manyToManyRelationship;
                manyToManyRelationshipNode.ImageIndex = manyToManyRelationshipNode.SelectImageIndex = (int)Images.GreenBullet;
                AddOptionNodes(manyToManyRelationshipNode, (ScriptBase)manyToManyRelationship);
            }

            TreeListNode filterNodes = treeList.AppendNode(new object[] { "Filters" }, scriptObjectNode);
            filterNodes.Tag = scriptObject.Filters;
            filterNodes.ImageIndex = filterNodes.SelectImageIndex = (int)Images.Filter;

            foreach (Filter filter in scriptObject.Filters)
            {
                TreeListNode filterNode = treeList.AppendNode(GetTreeListNodeText(filter), filterNodes);
                filterNode.Tag = filter;
                filterNode.ImageIndex = filterNode.SelectImageIndex = (int)Images.GreenBullet;
                AddOptionNodes(filterNode, (ScriptBase)filter);
            }

            if (scriptObject.GetType() == typeof(ArchAngel.Providers.Database.Model.Table))
            {
                ArchAngel.Providers.Database.Model.Table table = (ArchAngel.Providers.Database.Model.Table)scriptObject;
                TreeListNode indexNodes = treeList.AppendNode(new object[] { "Indexes" }, scriptObjectNode);
                indexNodes.Tag = table.Indexes;
                indexNodes.ImageIndex = indexNodes.SelectImageIndex = (int)Images.Index;

                foreach (Index index in table.Indexes)
                {
                    TreeListNode indexNode = treeList.AppendNode(GetTreeListNodeText(index), indexNodes);
                    indexNode.Tag = index;
                    indexNode.ImageIndex = indexNode.SelectImageIndex = (int)Images.GreenBullet;
                }

                TreeListNode keyNodes = treeList.AppendNode(new object[] { "Keys" }, scriptObjectNode);
                keyNodes.Tag = table.Keys;
                keyNodes.ImageIndex = keyNodes.SelectImageIndex = (int)Images.Key;
//.........这里部分代码省略.........