/// <summary>
        /// 删除焦点对象
        /// </summary>
        public void DeleteObject()
        {
            //获取焦点对象
            PSP_VolumeBalance obj = FocusedObject;

            if (obj == null)
            {
                return;
            }

            //请求确认
            if (MsgBox.ShowYesNo(Strings.SubmitDelete) != DialogResult.Yes)
            {
                return;
            }

            //执行删除操作
            try
            {
                Services.BaseService.Delete <PSP_VolumeBalance>(obj);
            }
            catch (Exception exc)
            {
                Debug.Fail(exc.Message);
                HandleException.TryCatch(exc);
                return;
            }

            this.gridView.BeginUpdate();
            //记住当前焦点行索引
            int iOldHandle = this.gridView.FocusedRowHandle;

            //从链表中删除
            ObjectList.Remove(obj);
            //刷新表格
            gridControl.RefreshDataSource();
            //设置新的焦点行索引
            GridHelper.FocuseRowAfterDelete(this.gridView, iOldHandle);
            this.gridView.EndUpdate();
            if (ObjectList.Count == 0 || EnsureBaseYear() == obj.Year)
            {
                PSP_VolumeBalanceDataSource BaseYearrate = new PSP_VolumeBalanceDataSource();
                BaseYearrate.UID    = baseyeartype;
                BaseYearrate.Value  = 1990;
                BaseYearrate.TypeID = Convert.ToInt32(obj.TypeID);
                BaseYearrate.Flag   = flag;
                Services.BaseService.Update("UpdatePSP_VolumeBalanceDataSource2", BaseYearrate);
            }
        }
        /// <summary>
        /// 删除焦点对象
        /// </summary>
        ///
        #region 添加负荷行
        private void AddFuHe(PSP_VolumeBalance obj)
        {
            PSP_VolumeBalance pvc = new PSP_VolumeBalance();

            pvc.TypeID = type;
            pvc.Flag   = flag;
            pvc.Year   = EnsureBaseYear();
            IList <PSP_VolumeBalance> list = Services.BaseService.GetList <PSP_VolumeBalance>("SelectPSP_VolumeBalanceByTypeIDAndYear", pvc);

            if (list != null)
            {
                if (list.Count == 1)
                {
                    PSP_VolumeBalance_Calc pvc2 = new PSP_VolumeBalance_Calc();
                    pvc2.Type = "1";
                    pvc2.Flag = list[0].UID;
                    IList <PSP_VolumeBalance_Calc> list2 = Services.BaseService.GetList <PSP_VolumeBalance_Calc>("SelectPSP_VolumeBalance_CalcByTypeFlag", pvc2);
                    PSP_VolumeBalance_Calc         pvc3  = new PSP_VolumeBalance_Calc();
                    pvc3.Type = "1";
                    pvc3.Flag = obj.UID;
                    IList <PSP_VolumeBalance_Calc> list3 = Services.BaseService.GetList <PSP_VolumeBalance_Calc>("SelectPSP_VolumeBalance_CalcByTypeFlag", pvc3);
                    if (list2 != null)
                    {
                        if (list2.Count > 0)
                        {
                            foreach (PSP_VolumeBalance_Calc pvctemp in list2)
                            {
                                if (list3 != null)
                                {
                                    if (list3.Count == list2.Count)
                                    {
                                        break;
                                    }
                                }
                                PSP_VolumeBalance_Calc _obj = new PSP_VolumeBalance_Calc();
                                _obj      = pvctemp;
                                _obj.Flag = obj.UID;
                                _obj.Vol  = 0;
                                _obj.UID  = Guid.NewGuid().ToString();


                                Services.BaseService.Create <PSP_VolumeBalance_Calc>(_obj);
                            }
                        }
                    }
                }
            }
        }
        private void barButtonItem3_ItemClick(object sender, DevExpress.XtraBars.ItemClickEventArgs e)
        {
            if (gridView1.FocusedRowHandle < 0)
            {
                return;
            }
            if (!base.DeleteRight)
            {
                MsgBox.Show("您没有权限进行此项操作!");
                return;
            }

            if (MsgBox.ShowYesNo("是否删除 " + gridView1.GetDataRow(gridView1.FocusedRowHandle)["ListName"])
                == DialogResult.No)
            {
                return;
            }

            PowerEachList report = Itop.Common.DataConverter.RowToObject <PowerEachList>(gridView1.GetDataRow(gridView1.FocusedRowHandle));

            try
            {
                PSP_VolumeBalance ob = new PSP_VolumeBalance();
                ob.Flag = report.UID;
                if (typeFlag.Contains("110"))
                {
                    ob.TypeID = "110";
                }
                else if (typeFlag.Contains("220"))
                {
                    ob.TypeID = "220";
                }
                IList <PSP_VolumeBalance> list = Services.BaseService.GetList <PSP_VolumeBalance>("SelectPSP_VolumeBalanceByTypeID", ob);
                foreach (PSP_VolumeBalance listtemp in list)
                {
                    Services.BaseService.Update("DeletePSP_VolumeBalance2", listtemp);
                }

                Common.Services.BaseService.Update("DeletePowerEachList_VolumeBalance", report);
                gridView1.DeleteRow(gridView1.FocusedRowHandle);
            }
            catch (Exception ex)
            {
                MsgBox.Show("删除出错:" + ex.Message);
            }
        }
        /// <summary>
        /// 刷新表格中的数据
        /// </summary>
        /// <returns>ture:成功  false:失败</returns>
        public bool RefreshData()
        {
            try
            {
                int iOldHandle        = this.gridView.FocusedRowHandle;
                PSP_VolumeBalance vol = new PSP_VolumeBalance();
                vol.TypeID = type;
                vol.Flag   = flag;

                IList <PSP_VolumeBalance> list = Services.BaseService.GetList <PSP_VolumeBalance>("SelectPSP_VolumeBalanceByTypeID", vol);
                this.gridControl.DataSource = list;
                if (list != null)
                {
                    if (list.Count > 0)
                    {
                        baseyear = list[0].Year;
                    }
                }


                try

                {
                    if (Volumecalc == "")
                    {
                        Volumecalc = "0";
                    }
                    //Volumecalc = System.Configuration.ConfigurationSettings.AppSettings["Volumecalc"];
                    colL8.Caption = "需" + type + "kV变电容量(容载比" + Volumecalc + ")";
                    GridHelper.FocuseRowAfterDelete(this.gridView, iOldHandle);
                    if (type == "35")
                    {
                        colL5.Caption = "需" + type + "千伏变电电力(负荷同时率" + loadrate + ")";
                    }
                }
                catch { }
            }
            catch (Exception exc)
            {
                Debug.Fail(exc.Message);
                HandleException.TryCatch(exc);
                return(false);
            }

            return(true);
        }
Beispiel #5
0
        /// <summary>
        /// 删除后保存合计
        /// </summary>
        /// <returns>ture:成功  false:失败</returns>
        public bool deleSaveSum(IList <PSP_VolumeBalance_Calc> ObjectList1, string flag)
        {
            try
            {
                double s = 0.0;
                sum = 0;
                foreach (PSP_VolumeBalance_Calc pvc in ObjectList1)
                {
                    sum += pvc.Vol;
                }

                PSP_VolumeBalance pv = Services.BaseService.GetOneByKey <PSP_VolumeBalance>(flag);
                if (flag == "")
                {
                    return(false);
                }

                switch (type)
                {
                case "1":
                    pv.L2 = sum;
                    break;

                case "2":
                    pv.L10 = sum;
                    break;

                case "3":
                    pv.L11 = sum;
                    break;
                }
                Services.BaseService.Update <PSP_VolumeBalance>(pv);
            }
            catch (Exception exc)
            {
                //Debug.Fail(exc.Message);
                //HandleException.TryCatch(exc);
                return(false);
            }

            return(true);
        }
Beispiel #6
0
        /// <summary>
        /// 添加对象
        /// </summary>
        public void AddObject()
        {
            //检查对象链表是否已经加载
            if (ObjectList == null)
            {
                return;
            }
            //新建对象
            PSP_VolumeBalance_Calc obj = new PSP_VolumeBalance_Calc();

            obj.Flag       = flag;
            obj.Type       = type;
            obj.Col1       = dy;
            obj.CreateTime = DateTime.Now;

            //执行添加操作
            using (FrmPSP_VolumeBalance_CalcDialog dlg = new FrmPSP_VolumeBalance_CalcDialog())
            {
                dlg.IsCreate  = true;                   //设置新建标志
                dlg.Object    = obj;
                dlg.Type      = type;
                dlg.CtrTitle  = ctrtitle;
                dlg.FormTitle = FormTitle;
                if (type == "1" && dy == "220")
                {
                    dlg.editorRow2.Visible = true;
                }
                if (dlg.ShowDialog() != DialogResult.OK)
                {
                    return;
                }
            }

            //将新对象加入到链表中
            ObjectList.Add(obj);
            SaveSum();
            //刷新表格,并将焦点行定位到新对象上。
            gridControl.RefreshDataSource();
            GridHelper.FocuseRow(this.gridView, obj);
            if (obj.Type == "1")
            {
                PSP_VolumeBalance ob = new PSP_VolumeBalance();
                //ob.TypeID = dy;
                ob.UID = obj.Flag;
                //string s ="";
                IList <PSP_VolumeBalance> list = Services.BaseService.GetList <PSP_VolumeBalance>("SelectPSP_VolumeBalanceByKey", ob);
                if (list != null)
                {
                    if (list.Count == 1)
                    {
                        ob.Flag   = list[0].Flag;
                        ob.TypeID = list[0].TypeID;
                        //s = obj.Flag;
                        list.Clear();
                        list = Services.BaseService.GetList <PSP_VolumeBalance>("SelectPSP_VolumeBalanceByTypeID", ob);
                        foreach (PSP_VolumeBalance pvm in list)
                        {
                            if (pvm.UID == ob.UID)
                            {
                                continue;
                            }
                            PSP_VolumeBalance_Calc pvc = new PSP_VolumeBalance_Calc();
                            pvc      = obj;
                            pvc.Flag = pvm.UID;
                            pvc.UID  = Guid.NewGuid().ToString();
                            pvc.Vol  = 0;
                            pvc.Col2 = "";
                            Services.BaseService.Create <PSP_VolumeBalance_Calc>(pvc);
                        }
                    }
                }
                RefreshData();
            }
        }
        /// <summary>
        /// ��Ӷ���
        /// </summary>
        public void AddObject()
        {
            //�����������Ƿ��Ѿ�����
            if (ObjectList == null)
            {
                return;
            }
            //�½�����
            PSP_VolumeBalance_Calc obj = new PSP_VolumeBalance_Calc();
            obj.Flag = flag;
            obj.Type = type;
            obj.Col1 = dy;
            obj.CreateTime = DateTime.Now;

            //ִ����Ӳ���
            using (FrmPSP_VolumeBalance_CalcDialog dlg = new FrmPSP_VolumeBalance_CalcDialog())
            {
                dlg.IsCreate = true;    //�����½���־
                dlg.Object = obj;
                dlg.Type = type;
                dlg.CtrTitle = ctrtitle;
                dlg.FormTitle = FormTitle;
                if (type == "1" && dy=="220")
                dlg.editorRow2.Visible = true;
                if (dlg.ShowDialog() != DialogResult.OK)
                {
                    return;
                }
            }

            //���¶�����뵽������
            ObjectList.Add(obj);
            SaveSum();
            //ˢ�±�񣬲��������ж�λ���¶����ϡ�
            gridControl.RefreshDataSource();
            GridHelper.FocuseRow(this.gridView, obj);
            if (obj.Type == "1")
            {
                PSP_VolumeBalance ob = new PSP_VolumeBalance();
                //ob.TypeID = dy;
                ob.UID = obj.Flag;
                //string s ="";
                IList<PSP_VolumeBalance> list = Services.BaseService.GetList<PSP_VolumeBalance>("SelectPSP_VolumeBalanceByKey", ob);
                if(list!=null)
                    if (list.Count == 1)
                    {

                        ob.Flag = list[0].Flag;
                        ob.TypeID = list[0].TypeID;
                        //s = obj.Flag;
                        list.Clear();
                        list = Services.BaseService.GetList<PSP_VolumeBalance>("SelectPSP_VolumeBalanceByTypeID", ob);
                        foreach (PSP_VolumeBalance pvm in list)
                        {
                            if (pvm.UID == ob.UID)
                                continue;
                            PSP_VolumeBalance_Calc pvc = new PSP_VolumeBalance_Calc();
                            pvc = obj;
                            pvc.Flag = pvm.UID;
                            pvc.UID = Guid.NewGuid().ToString();
                            pvc.Vol = 0;
                            pvc.Col2 = "";
                            Services.BaseService.Create<PSP_VolumeBalance_Calc>(pvc);
                        }
                    }
                RefreshData();
            }
        }
        private void barA5_ItemClick(object sender, DevExpress.XtraBars.ItemClickEventArgs e)
        {
            FrmBalance_Calc FrmBalance = new FrmBalance_Calc();
            FrmBalance.FormTitle = "规划新增变电容量";
            FrmBalance.CtrTitle = this.ctrlPSP_VolumeBalance1.GridView.GroupPanelText;
            FrmBalance.ADdRight = AddRight;
            FrmBalance.EDitRight = EditRight;
            FrmBalance.DEleteRight = DeleteRight;
            FrmBalance.PRintRight = PrintRight;
            PSP_VolumeBalance vol = new PSP_VolumeBalance();
            if (this.ctrlPSP_VolumeBalance1.GridView.GetRow(this.ctrlPSP_VolumeBalance1.GridView.FocusedRowHandle) != null)
            {
                vol = this.ctrlPSP_VolumeBalance1.GridView.GetRow(this.ctrlPSP_VolumeBalance1.GridView.FocusedRowHandle) as PSP_VolumeBalance;

                FrmBalance.FLAG = vol.UID;
                FrmBalance.TYPE = "3";
                FrmBalance.DY = TypeID;

                if (FrmBalance.FLAG != "")
                {
                    FrmBalance.ShowDialog();
                    this.ctrlPSP_VolumeBalance1.RefreshData();
                    vol.GetType().GetProperty("L11").SetValue(vol, FrmBalance.SUM, null);
                    this.ctrlPSP_VolumeBalance1.reloadsum(vol);
                }
            }
        }
        private void barButtonItem1_ItemClick(object sender, DevExpress.XtraBars.ItemClickEventArgs e)
        {
            PSP_VolumeBalance vol = new PSP_VolumeBalance();
            vol.TypeID = TypeID;
            vol.Flag = Flag;
            IList<PSP_VolumeBalance> listTypes = Services.BaseService.GetList<PSP_VolumeBalance>("SelectPSP_VolumeBalanceByTypeID", vol);
            FormChooseYears frm = new FormChooseYears();
            foreach (PSP_VolumeBalance year in listTypes)
                frm.ListYearsForChoose.Add(year.Year);

            frm.NoIncreaseRate = true;
            if (frm.ShowDialog() == DialogResult.OK)
            {
                int k = 0;
                PSP_VolumeBalance vb = new PSP_VolumeBalance();
                vb.TypeID = TypeID;
                vb.Flag = Flag;
                IList<PSP_VolumeBalance> pspvb = Services.BaseService.GetList<PSP_VolumeBalance>("SelectPSP_VolumeBalanceByTypeID", vb);
                string str = "";
                PSP_VolumeBalance_Calc vbc = new PSP_VolumeBalance_Calc();
                try
                {
                    vbc.Flag = pspvb[0].UID;
                }
                catch { }
                vbc.Type = "1";
                IList<PSP_VolumeBalance_Calc> vbclist = Services.BaseService.GetList<PSP_VolumeBalance_Calc>("SelectPSP_VolumeBalance_CalcByTypeFlag", vbc);

                DataTable dt = new DataTable();
                //dt.Columns.Add("Sort", typeof(int));
                dt.Columns.Add("序号", typeof(int));
                dt.Columns.Add("项目", typeof(string));

                int isort = 0;
                if (TypeID == "220")
                {
                    foreach (GridColumn i in ctrlPSP_VolumeBalance1.GridView.Columns)
                    {
                        if (i.Caption != "年度" && i.Caption != "小电厂需备用容量" && i.Caption != "外网供电" && i.FieldName != "S2" && i.FieldName != "S3")
                        {
                            if (i.FieldName == "S4")
                                i.Caption = "注:";
                            if (isort == 2)
                            {
                                foreach (PSP_VolumeBalance_Calc pspvbc in vbclist)
                                {
                                    DataRow drow = dt.NewRow();

                                    //drow["序号"] = isort + 1;
                                    drow["项目"] = pspvbc.Title;
                                    dt.Rows.Add(drow);

                                    DataRow drow1 = dt.NewRow();
                                    drow1["项目"] = "注:";
                                    dt.Rows.Add(drow1);
                                }

                                isort++;
                                k = isort + vbclist.Count;
                            }
                            else if (isort == 10)
                            {
                                DataRow drow = dt.NewRow();
                                //drow["序号"] = isort + 1;
                                drow["项目"] = "注:";
                                dt.Rows.Add(drow);
                                isort++;
                            }
                            else if (isort == 12)
                            {
                                DataRow drow = dt.NewRow();
                                //drow["序号"] = isort + 1;
                                drow["项目"] = "注:";
                                dt.Rows.Add(drow);
                                isort++;
                            }
                            DataRow dr = dt.NewRow();
                            //dr["序号"] = isort + 1;
                            dr["项目"] = i.Caption;
                            //dr["Sort"] = isort + 1;
                            dt.Rows.Add(dr);
                            isort++;
                        }
                    }
                }
                if (TypeID == "35")
                {
                    foreach (GridColumn i in ctrlPSP_VolumeBalance1.GridView.Columns)
                    {
                        if (i.Caption != "年度" && i.Caption != "小电厂需备用容量" && i.Caption != "110kV及以下小电源直接供电负荷" && i.FieldName != "S3")
                        {
                            if(i.FieldName== "S2"|| i.FieldName == "S4")
                                i.Caption = "注:";
                            if (isort == 10)
                            {
                                DataRow drow = dt.NewRow();
                                //drow["序号"] = isort + 1;
                                drow["项目"] = "注:";
                                dt.Rows.Add(drow);
                                isort++;
                            }
                            else if (isort == 12)
                            {
                                DataRow drow = dt.NewRow();
                                //drow["序号"] = isort + 1;
                                drow["项目"] = "注:";
                                dt.Rows.Add(drow);
                                isort++;
                            }
                            DataRow dr = dt.NewRow();
                            //dr["序号"] = isort + 1;

                            dr["项目"] = i.Caption;
                            if (dr["项目"]!=null)
                            if (dr["项目"].ToString().Contains("(负荷同时率" + Ensureloadrate() + ")"))
                                 dr["项目"]=dr["项目"].ToString().Replace("(负荷同时率" + Ensureloadrate() + ")", "");
                            //dr["Sort"] = isort + 1;
                            dt.Rows.Add(dr);
                            isort++;
                        }
                    }
                }
                if (TypeID == "110")
                {
                    foreach (GridColumn i in ctrlPSP_VolumeBalance1.GridView.Columns)
                    {
                        if (i.Caption != "年度" && i.Caption != "小电厂需备用容量" )
                        {
                            if (i.FieldName == "S2" || i.FieldName == "S4" || i.FieldName == "S3")
                                i.Caption = "注:";
                            if (isort == 12)
                            {
                                DataRow drow = dt.NewRow();
                                //drow["序号"] = isort + 1;
                                drow["项目"] = "注:";
                                dt.Rows.Add(drow);
                                isort++;
                            }
                            else if (isort == 14)
                            {
                                DataRow drow = dt.NewRow();
                                //drow["序号"] = isort + 1;
                                drow["项目"] = "注:";
                                dt.Rows.Add(drow);
                                isort++;
                            }
                            DataRow dr = dt.NewRow();
                            //dr["序号"] = isort + 1;
                            dr["项目"] = i.Caption;
                            //dr["Sort"] = isort + 1;
                            dt.Rows.Add(dr);
                            isort++;
                        }
                    }
                }
                isort = 1;
                foreach (System.Data.DataRow row in dt.Rows)
                {
                    row["序号"] = isort;
                    isort++;
                }

                foreach (ChoosedYears i in frm.ListChoosedYears)
                {
                    dt.Columns.Add(i.Year + "年", typeof(string));
                }
                //if (TypeID == "220")
                //{
                //    dt.Rows.RemoveAt(vbclist.Count + 14);
                //}
                foreach (ChoosedYears i in frm.ListChoosedYears)
                {

                    foreach (PSP_VolumeBalance balan in pspvb)
                    {
                        if (balan.Year == i.Year)
                        {
                            int j = 0;
                            dt.Rows[0][i.Year + "年"] = balan.L1;
                            dt.Rows[1][i.Year + "年"] = balan.L2;
                            PSP_VolumeBalance_Calc vbcalc = new PSP_VolumeBalance_Calc();
                            vbcalc.Flag = balan.UID;
                            vbcalc.Type = "1";
                            IList<PSP_VolumeBalance_Calc> vbclist1 = Services.BaseService.GetList<PSP_VolumeBalance_Calc>("SelectPSP_VolumeBalance_CalcByTypeFlag", vbcalc);

                            if (TypeID == "220")
                            {

                                foreach (PSP_VolumeBalance_Calc pspvbc in vbclist1)
                                {
                                    dt.Rows[j+2][i.Year + "年"] = pspvbc.Vol.ToString();
                                    j++;
                                    dt.Rows[j + 2][i.Year + "年"] = pspvbc.Col2.ToString();
                                    j++;
                                }
                                dt.Rows[j + 2][i.Year + "年"] = balan.L5;
                                dt.Rows[j + 3][i.Year + "年"] = balan.S4;
                                dt.Rows[j + 4][i.Year + "年"] = balan.L6;
                                dt.Rows[j + 5][i.Year + "年"] = balan.L7;
                                dt.Rows[j + 6][i.Year + "年"] = balan.L8;
                                dt.Rows[j + 7][i.Year + "年"] = balan.L9;
                                dt.Rows[j + 8][i.Year + "年"] = balan.L10;

                                str = "";
                                vbcalc.Type = "2";
                                IList<PSP_VolumeBalance_Calc> vbclist2 = Services.BaseService.GetList<PSP_VolumeBalance_Calc>("SelectPSP_VolumeBalance_CalcByTypeFlag", vbcalc);
                                foreach (PSP_VolumeBalance_Calc pspvbc in vbclist2)
                                {
                                    if (pspvbc.LX1 == "新建")
                                        str += pspvbc.LX1 + "" + pspvbc.Title + "" + pspvbc.LX2;
                                    else
                                        str += pspvbc.Title + "" + pspvbc.LX1 + "" + pspvbc.LX2;
                                    if (pspvbc.UID != vbclist2[vbclist2.Count - 1].UID)
                                        str += ",";

                                }
                                dt.Rows[j + 9][i.Year + "年"] = str;
                                dt.Rows[j + 10][i.Year + "年"] = balan.L11;
                                str = "";
                                vbcalc.Type = "3";
                                IList<PSP_VolumeBalance_Calc> vbclist3 = Services.BaseService.GetList<PSP_VolumeBalance_Calc>("SelectPSP_VolumeBalance_CalcByTypeFlag", vbcalc);
                                foreach (PSP_VolumeBalance_Calc pspvbc in vbclist3)
                                {
                                    if (pspvbc.LX1 == "新建")
                                        str += pspvbc.LX1 + "" + pspvbc.Title + "" + pspvbc.LX2;
                                    else
                                        str += pspvbc.Title + "" + pspvbc.LX1 + "" + pspvbc.LX2;
                                    if (pspvbc.UID != vbclist3[vbclist3.Count - 1].UID)
                                        str += ",";
                                }
                                dt.Rows[j + 11][i.Year + "年"] = str;
                                dt.Rows[j + 12][i.Year + "年"] = balan.L12;
                                dt.Rows[j + 13][i.Year + "年"] = balan.L13;
                                dt.Rows[j + 14][i.Year + "年"] = balan.L14;
                            }
                            else if (TypeID == "110")
                            {
                                //foreach (PSP_VolumeBalance_Calc pspvbc in vbclist1)
                                //{
                                //    str = "(" + pspvbc.Title + "," + pspvbc.LX1 + "," + pspvbc.LX2 + ")  " + str;
                                //}
                                dt.Rows[2][i.Year + "年"] = balan.S2;

                                dt.Rows[j + 3][i.Year + "年"] = balan.L4;
                                dt.Rows[j + 4][i.Year + "年"] = balan.S3;
                                dt.Rows[j + 5][i.Year + "年"] = balan.L5;
                                dt.Rows[j + 6][i.Year + "年"] = balan.S4;
                                dt.Rows[j + 7][i.Year + "年"] = balan.L6;
                                dt.Rows[j + 8][i.Year + "年"] = balan.L7;
                                dt.Rows[j + 9][i.Year + "年"] = balan.L8;
                                dt.Rows[j + 10][i.Year + "年"] = balan.L9;
                                dt.Rows[j + 11][i.Year + "年"] = balan.L10;

                                str = "";
                                vbcalc.Type = "2";
                                IList<PSP_VolumeBalance_Calc> vbclist2 = Services.BaseService.GetList<PSP_VolumeBalance_Calc>("SelectPSP_VolumeBalance_CalcByTypeFlag", vbcalc);
                                foreach (PSP_VolumeBalance_Calc pspvbc in vbclist2)
                                {
                                    if (pspvbc.LX1 == "新建")
                                        str += pspvbc.LX1 + "" + pspvbc.Title + "" + pspvbc.LX2;
                                    else
                                        str += pspvbc.Title + "" + pspvbc.LX1 + "" + pspvbc.LX2;
                                    if (pspvbc.UID != vbclist2[vbclist2.Count - 1].UID)
                                        str += ",";

                                }
                                dt.Rows[j + 12][i.Year + "年"] = str;
                                dt.Rows[j + 13][i.Year + "年"] = balan.L11;

                                str = "";
                                vbcalc.Type = "3";
                                IList<PSP_VolumeBalance_Calc> vbclist3 = Services.BaseService.GetList<PSP_VolumeBalance_Calc>("SelectPSP_VolumeBalance_CalcByTypeFlag", vbcalc);
                                foreach (PSP_VolumeBalance_Calc pspvbc in vbclist3)
                                {
                                    if (pspvbc.LX1 == "新建")
                                        str += pspvbc.LX1 + "" + pspvbc.Title + "" + pspvbc.LX2;
                                    else
                                        str += pspvbc.Title + "" + pspvbc.LX1 + "" + pspvbc.LX2;
                                    if (pspvbc.UID != vbclist3[vbclist3.Count - 1].UID)
                                        str += ",";
                                }
                                dt.Rows[j + 14][i.Year + "年"] = str;
                                dt.Rows[j + 15][i.Year + "年"] = balan.L12;
                                dt.Rows[j + 16][i.Year + "年"] = balan.L13;
                                dt.Rows[j + 17][i.Year + "年"] = balan.L14;
                            }
                            else if (TypeID == "35")
                            {
                                dt.Rows[j+2][i.Year + "年"] = balan.S2;
                                dt.Rows[j + 3][i.Year + "年"] = balan.L5;
                                dt.Rows[j + 4][i.Year + "年"] = balan.S4;
                                dt.Rows[j + 5][i.Year + "年"] = balan.L6;
                                dt.Rows[j + 6][i.Year + "年"] = balan.L7;
                                dt.Rows[j + 7][i.Year + "年"] = balan.L8;
                                dt.Rows[j + 8][i.Year + "年"] = balan.L9;
                                dt.Rows[j + 9][i.Year + "年"] = balan.L10;
                                //dt.Rows[j + 8][i.Year + "年"] = balan.L10;
                                str = "";
                                vbcalc.Type = "2";
                                IList<PSP_VolumeBalance_Calc> vbclist2 = Services.BaseService.GetList<PSP_VolumeBalance_Calc>("SelectPSP_VolumeBalance_CalcByTypeFlag", vbcalc);
                                foreach (PSP_VolumeBalance_Calc pspvbc in vbclist2)
                                {
                                    if (pspvbc.LX1 == "新建")
                                        str += pspvbc.LX1 + "" + pspvbc.Title + "" + pspvbc.LX2;
                                    else
                                        str += pspvbc.Title + "" + pspvbc.LX1 + "" + pspvbc.LX2;
                                    if (pspvbc.UID != vbclist2[vbclist2.Count - 1].UID)
                                        str += ",";

                                }
                                dt.Rows[j + 10][i.Year + "年"] = str;
                                dt.Rows[j + 11][i.Year + "年"] = balan.L11;
                                str = "";
                                vbcalc.Type = "3";
                                IList<PSP_VolumeBalance_Calc> vbclist3 = Services.BaseService.GetList<PSP_VolumeBalance_Calc>("SelectPSP_VolumeBalance_CalcByTypeFlag", vbcalc);
                                foreach (PSP_VolumeBalance_Calc pspvbc in vbclist3)
                                {
                                    if (pspvbc.LX1 == "新建")
                                        str += pspvbc.LX1 + "" + pspvbc.Title + "" + pspvbc.LX2;
                                    else
                                        str += pspvbc.Title + "" + pspvbc.LX1 + "" + pspvbc.LX2;
                                    if (pspvbc.UID != vbclist3[vbclist3.Count - 1].UID)
                                        str += ",";
                                }
                                dt.Rows[j + 12][i.Year + "年"] = str;
                                dt.Rows[j + 13][i.Year + "年"] = balan.L12;
                                dt.Rows[j + 14][i.Year + "年"] = balan.L13;

                            }
                        }
                    }

                }

                FormPSP_VolumeBalance_Print fr = new FormPSP_VolumeBalance_Print();
                fr.GridDataTable = dt;
                //if (TypeID == "220")
                //{
                    fr.Text = this.Text;
                    fr.gridView1.GroupPanelText = this.Text;
                    fr.PRintRight = PrintRight;
                //}
                fr.ShowDialog();
            }
        }
        public void reloadsum(PSP_VolumeBalance objtemp)
        {
            double factor = 1;

            if (type == "35")
            {
                if (loadrate != "")
                {
                    factor = Convert.ToDouble(loadrate);
                }
            }
            if (objtemp.S1 == "1")
            {
                objtemp.L5 = Math.Round(objtemp.L1 + objtemp.L3 - objtemp.L2 - objtemp.L4, 2);
                if (objtemp.L5 != 0)
                {
                    objtemp.L7 = Math.Round(objtemp.L6 / (objtemp.L5 * factor), 2);
                }
                else
                {
                    objtemp.L7 = 0;
                }
                objtemp.L8  = Math.Round((objtemp.L5 * factor) * Convert.ToDouble(Volumecalc), 2);
                objtemp.L9  = Math.Round(objtemp.L6 - objtemp.L8, 2);
                objtemp.L12 = Math.Round(objtemp.L6 + objtemp.L10 + objtemp.L11, 2);
                if (objtemp.L5 != 0)
                {
                    objtemp.L13 = Math.Round(objtemp.L12 / (objtemp.L5 * factor), 2);
                }
                else
                {
                    objtemp.L13 = 0;
                }
                Services.BaseService.Update("UpdatePSP_VolumeBalance2", objtemp);
                if (EnsureBaseYear() <= objtemp.Year)
                {
                    sum(objtemp);
                }
            }
            else
            {
                PSP_VolumeBalance volumtemp = new PSP_VolumeBalance();
                volumtemp.TypeID = type;
                volumtemp.Flag   = flag;
                volumtemp.Year   = objtemp.Year;
                IList <PSP_VolumeBalance> list = Services.BaseService.GetList <PSP_VolumeBalance>("SelectPSP_VolumeBalanceByTypeIDLessYear", volumtemp);
                if (list.Count > 0)
                {
                    objtemp.L6 = Math.Round(list[list.Count - 1].L12, 2);
                }
                else
                {
                    objtemp.L6 = 0;
                }
                objtemp.L5 = Math.Round(objtemp.L1 + objtemp.L3 - objtemp.L2 - objtemp.L4, 2);
                if (objtemp.L5 != 0)
                {
                    objtemp.L7 = Math.Round(objtemp.L6 / (objtemp.L5 * factor), 2);
                }
                else
                {
                    objtemp.L7 = 0;
                }
                objtemp.L8  = Math.Round((objtemp.L5 * factor) * Convert.ToDouble(Volumecalc), 2);
                objtemp.L9  = Math.Round(objtemp.L6 - objtemp.L8, 2);
                objtemp.L12 = Math.Round(objtemp.L6 + objtemp.L10 + objtemp.L11, 2);
                if (objtemp.L5 != 0)
                {
                    objtemp.L13 = Math.Round(objtemp.L12 / (objtemp.L5 * factor), 2);
                }
                else
                {
                    objtemp.L13 = 0;
                }
                Services.BaseService.Update("UpdatePSP_VolumeBalance2", objtemp);
                if (EnsureBaseYear() <= objtemp.Year)
                {
                    sum(objtemp);
                }
            }
            RefreshData();
        }
        private void barA2_ItemClick(object sender, DevExpress.XtraBars.ItemClickEventArgs e)
        {
            //DevExpress.XtraBars.BarItem bot = (DevExpress.XtraBars.BarItem)sender;
            FormPSP_VolumeBalanceVolumecalc frm = new FormPSP_VolumeBalanceVolumecalc();

            frm.Type = TypeID;
            //if (bot.Caption == "设定容载比")
            //{
                frm.Text = "设定容载比";
                frm.CtrTitle = "容载比";
                frm.YearValue = EnsureVolumecalc();
                frm.UID = Volumecalc;
            //}
            //else
            //    if (bot.Caption== "设定负荷同时率")
            //    {
            //        frm.Text = "设定负荷同时率";
            //        frm.CtrTitle = "负荷同时率";
            //        frm.YearValue =Ensureloadrate();
            //        frm.UID = loadrate;
            //    }
            frm.Flag = Flag;
            if (frm.ShowDialog() == DialogResult.OK)
            {
                this.ctrlPSP_VolumeBalance1.Volumecalc0 = EnsureVolumecalc().ToString();
                this.ctrlPSP_VolumeBalance1.colL8.Caption = "需" + TypeID + "kV变电容量(容载比" + EnsureVolumecalc() + ")";
                //if(TypeID=="35")
                //    this.ctrlPSP_VolumeBalance1.colL5.Caption = "需" + TypeID + "千伏变电电力(负荷同时率" + Ensureloadrate() + ")";
                PSP_VolumeBalance vol = new PSP_VolumeBalance();
                vol.Year = this.ctrlPSP_VolumeBalance1.EnsureBaseYear();
                vol.Flag = Flag;
                vol.TypeID = TypeID;
                if (vol.Year > 1900)
                {
                    IList<PSP_VolumeBalance> list = Services.BaseService.GetList<PSP_VolumeBalance>("SelectPSP_VolumeBalanceByTypeIDLessYear", vol);

                    if (list != null)
                    {
                        foreach (PSP_VolumeBalance pvo in list)
                        {
                            this.ctrlPSP_VolumeBalance1.reloadsum(pvo);
                        }
                    }
                    if (list != null) list.Clear();
                    list = Services.BaseService.GetList<PSP_VolumeBalance>("SelectPSP_VolumeBalanceByTypeIDAndYear", vol);

                    if (list != null)
                    {
                        if (list.Count == 1)
                            this.ctrlPSP_VolumeBalance1.reloadsum(list[0]);
                    }
                }
                else
                {
                    PSP_VolumeBalance voltemp = new PSP_VolumeBalance();
                    voltemp.Flag = Flag;
                    voltemp.TypeID = TypeID;
                    IList<PSP_VolumeBalance> list = Services.BaseService.GetList<PSP_VolumeBalance>("SelectPSP_VolumeBalanceByTypeID", voltemp);
                    foreach(PSP_VolumeBalance pvo in list)
                    {
                        this.ctrlPSP_VolumeBalance1.reloadsum(pvo);
                    }
                }
            }
        }
        protected bool SaveRecord()
        {
            //����/�޸� ����
            try
            {

                if (IsCreate)
                {
                    Services.BaseService.Create<PSP_VolumeBalance>(_obj);
                }
                else
                {
                    Services.BaseService.Update<PSP_VolumeBalance>(_obj);
                }

            }
            catch (Exception exc)
            {
                Debug.Fail(exc.Message);
                HandleException.TryCatch(exc);
                return false ;
            }
            if (_obj.S1 == "1")
            {
                PSP_VolumeBalance ob = new PSP_VolumeBalance();
                ob.Year = EnsureBaseYear();
                ob.TypeID = type;
                ob.Flag = flag;
                IList<PSP_VolumeBalance> list0 = Services.BaseService.GetList<PSP_VolumeBalance>("SelectPSP_VolumeBalanceByTypeIDAndYear", ob);
                if (list0 != null)
                {
                    if (list0.Count == 1)
                    {
                        list0[0].S1 = "0";
                        Services.BaseService.Update<PSP_VolumeBalance>(list0[0]);
                    }
                }
                PSP_VolumeBalanceDataSource BaseYearrate = new PSP_VolumeBalanceDataSource();
                BaseYearrate.UID = baseyeartype;
                BaseYearrate.Flag = flag;
                BaseYearrate.Value = _obj.Year;
                BaseYearrate.TypeID = Convert.ToInt32(_obj.TypeID);
                Services.BaseService.Update("UpdatePSP_VolumeBalanceDataSource2", BaseYearrate);
            }
            else if (_obj.Year == EnsureBaseYear() /*|| (EnsureBaseYear() == baseyear)*/)
            {
                PSP_VolumeBalance ob = new PSP_VolumeBalance();
                ob.Flag = flag;
                ob.TypeID = type;
                IList<PSP_VolumeBalance> list0 = Services.BaseService.GetList<PSP_VolumeBalance>("SelectPSP_VolumeBalanceByTypeID", ob);
                if (list0 != null)
                    if (list0.Count > 0)
                        ob = list0[0];
                PSP_VolumeBalanceDataSource BaseYearrate = new PSP_VolumeBalanceDataSource();
                BaseYearrate.Flag = flag;
                BaseYearrate.UID = baseyeartype;
                BaseYearrate.Value = baseyear;
                BaseYearrate.TypeID = Convert.ToInt32(_obj.TypeID);
                Services.BaseService.Update("UpdatePSP_VolumeBalanceDataSource2", BaseYearrate);
                PSP_VolumeBalanceDataSource volumtemp = new PSP_VolumeBalanceDataSource();
                volumtemp.TypeID = Convert.ToInt32(type);
                volumtemp.Flag = flag;
                IList<PSP_VolumeBalanceDataSource> list = Services.BaseService.GetList<PSP_VolumeBalanceDataSource>("SelectPSP_VolumeBalanceDataSourceByTypeID", volumtemp);
                        if (ob != null)
                            if (ob.UID != "")
                                foreach (PSP_VolumeBalanceDataSource psptemp in list)
                                {
                                    if (psptemp.UID == baseyeartype)
                                        continue;
                                    if (hs[psptemp.Name] != null)
                                    ob.GetType().GetProperty("L" + hs[psptemp.Name].ToString()).SetValue(ob, psptemp.Value, null);
                                }
                        try
                        {
                            ob.S1 = "1";
                            Services.BaseService.Update<PSP_VolumeBalance>(ob);
                            isresum = true;
                        }

                        catch (Exception ex)
                        {
                            System.Console.WriteLine(ex.ToString());
                        }

            }
            //�����ѳɹ�
            return true;
        }
        /// <summary>
        /// 添加对象
        /// </summary>
        public void AddObject()
        {
            //检查对象链表是否已经加载
            if (ObjectList == null)
            {
                return;
            }
            //新建对象
            PSP_VolumeBalance obj = new PSP_VolumeBalance();

            obj.TypeID = type;
            obj.Flag   = flag;
            //执行添加操作
            using (FrmPSP_VolumeBalanceDialog dlg = new FrmPSP_VolumeBalanceDialog())
            {
                dlg.Type     = type;
                dlg.Flag     = flag;
                dlg.List     = gridView.DataSource as IList <PSP_VolumeBalance>;
                dlg.IsCreate = true;                    //设置新建标志
                dlg.Object   = obj;
                if (ObjectList.Count > 0)
                {
                    baseyear = ObjectList[0].Year;
                }
                dlg.BaseYear = baseyear;
                if (type == "220")
                {
                    dlg.xtraTabControl1.TabPages[0].Text = "220千伏变电容量平衡表";
                    dlg.Text = "220千伏变电容量平衡表";
                    dlg.rowL1.Properties.Caption = "综合最高负荷";
                    dlg.rowL2.Properties.Caption = "直接供电负荷";
                    dlg.rowL2.Visible            = false;
                    dlg.rowL4.Properties.Caption = "外网供电";
                    //dlg.rowL3.Visible = false;
                    // dlg.rowL4.Visible = true;
                    dlg.rowL6.Properties.Caption        = "现有220kV降压变电容量";
                    dlg.categoryRow1.Visible            = false;
                    dlg.categoryRow2.Visible            = false;
                    dlg.categoryRow3.Properties.Caption = "需220kV降压供电负荷";
                    //dlg.rowL14.Visible = false;
                }
                else
                if (type == "35")
                {
                    dlg.xtraTabControl1.TabPages[0].Text = "35千伏变电容量平衡表";
                    dlg.Text = "35千伏变电容量平衡表";
                    dlg.rowL1.Properties.Caption = "本区负荷";
                    dlg.rowL2.Properties.Caption = "本地平衡负荷";
                    //dlg.rowL2.Visible = false;
                    //dlg.rowL4.Properties.Caption = "外网供电";
                    //dlg.rowL3.Visible = false;
                    dlg.rowL4.Visible            = false;
                    dlg.rowL6.Properties.Caption = "现有35千伏变电容量";
                    //dlg.rowL14.Visible = false;
                }
                if (dlg.ShowDialog() != DialogResult.OK)
                {
                    return;
                }
            }

            //将新对象加入到链表中
            ObjectList.Add(obj);
            reloadsum(obj);
            //刷新表格,并将焦点行定位到新对象上。
            gridControl.RefreshDataSource();
            GridHelper.FocuseRow(this.gridView, obj);
            AddFuHe(obj);
        }
        public void reloadsum(PSP_VolumeBalance objtemp)
        {
            double factor = 1;
            if (type == "35")
                if (loadrate != "")
                    factor = Convert.ToDouble(loadrate);
                if (objtemp.S1 == "1")
                {

                    objtemp.L5 =Math.Round(objtemp.L1 + objtemp.L3 - objtemp.L2 - objtemp.L4,2);
                    if (objtemp.L5 != 0)
                        objtemp.L7 = Math.Round(objtemp.L6 /(objtemp.L5*factor),2);
                    else
                        objtemp.L7 = 0;
                        objtemp.L8 = Math.Round((objtemp.L5 * factor) * Convert.ToDouble(Volumecalc), 2);
                    objtemp.L9 = Math.Round(objtemp.L6 - objtemp.L8,2);
                    objtemp.L12 = Math.Round(objtemp.L6 + objtemp.L10 + objtemp.L11,2);
                    if (objtemp.L5 != 0)
                        objtemp.L13 = Math.Round(objtemp.L12 / (objtemp.L5 * factor), 2);
                    else
                        objtemp.L13 = 0;
                    Services.BaseService.Update("UpdatePSP_VolumeBalance2", objtemp);
                    if (EnsureBaseYear() <=objtemp.Year)
                    sum(objtemp);
                }
                else
                {
                    PSP_VolumeBalance volumtemp = new PSP_VolumeBalance();
                    volumtemp.TypeID = type;
                    volumtemp.Flag = flag;
                    volumtemp.Year = objtemp.Year;
                    IList<PSP_VolumeBalance> list = Services.BaseService.GetList<PSP_VolumeBalance>("SelectPSP_VolumeBalanceByTypeIDLessYear", volumtemp);
                    if (list.Count > 0)
                    {
                        objtemp.L6 = Math.Round(list[list.Count - 1].L12,2);
                    }
                    else
                        objtemp.L6 = 0;
                    objtemp.L5 = Math.Round(objtemp.L1 + objtemp.L3 - objtemp.L2 - objtemp.L4,2);
                    if (objtemp.L5 != 0)
                        objtemp.L7 = Math.Round(objtemp.L6 / (objtemp.L5 * factor), 2);
                    else
                        objtemp.L7 = 0;
                    objtemp.L8 = Math.Round((objtemp.L5 * factor) * Convert.ToDouble(Volumecalc), 2);
                    objtemp.L9 = Math.Round(objtemp.L6 - objtemp.L8,2);
                    objtemp.L12 = Math.Round(objtemp.L6 + objtemp.L10 + objtemp.L11,2);
                    if (objtemp.L5 != 0)
                        objtemp.L13 = Math.Round(objtemp.L12 / (objtemp.L5 * factor), 2);
                    else
                        objtemp.L13= 0;
                    Services.BaseService.Update("UpdatePSP_VolumeBalance2", objtemp);
                    if (EnsureBaseYear() <= objtemp.Year)
                    sum(objtemp);
                }
                RefreshData();
        }
        /// <summary>
        /// �޸Ľ������
        /// </summary>
        public void UpdateObject()
        {
            //��ȡ�������
            PSP_VolumeBalance obj = FocusedObject;
            bool isresum=false;
            if (obj == null)
            {
                return;
            }

            //���������һ������
            PSP_VolumeBalance objCopy = new PSP_VolumeBalance();
            DataConverter.CopyTo<PSP_VolumeBalance>(obj, objCopy);
            if ((gridView.FocusedColumn.FieldName != "L2"&& gridView.FocusedColumn.FieldName != "L10" && gridView.FocusedColumn.FieldName != "L11")||(gridView.FocusedColumn.FieldName == "L2")&&type!="220")
            {
                //ִ���޸IJ���
                using (FrmPSP_VolumeBalanceDialog dlg = new FrmPSP_VolumeBalanceDialog())
                {
                    dlg.Type = type;
                    dlg.Flag = flag;
                    dlg.List = gridView.DataSource as IList<PSP_VolumeBalance>;
                    dlg.Object = objCopy;   //�󶨸���
                    baseyear = ObjectList[0].Year;
                    dlg.BaseYear = baseyear;
                    if (type == "220")
                    {
                        dlg.xtraTabControl1.TabPages[0].Text = "220ǧ���������ƽ���";
                        dlg.Text = "220ǧ���������ƽ���";
                        dlg.rowL1.Properties.Caption = "�ۺ���߸���";
                        dlg.rowL2.Properties.Caption = "ֱ�ӹ��縺��";
                        dlg.rowL2.Visible = false;
                        dlg.rowL4.Properties.Caption = "��������";
                        //dlg.rowL3.Visible = false;
                      //  dlg.rowL4.Visible = true;
                        dlg.rowL6.Properties.Caption = "����220kV��ѹ�������";
                        dlg.rowL14.Visible = false;
                        dlg.categoryRow1.Visible = false;
                        dlg.categoryRow2.Visible = false;
                        dlg.categoryRow3.Properties.Caption = "��220kV��ѹ���縺��";
                    }
                    else
                        if (type == "35")
                        {
                            dlg.xtraTabControl1.TabPages[0].Text = "35ǧ���������ƽ���";
                            dlg.Text = "35ǧ���������ƽ���";
                            dlg.rowL1.Properties.Caption = "��������";
                            dlg.rowL2.Properties.Caption = "����ƽ�⸺��";
                            dlg.rowL4.Visible = false;
                            dlg.rowL6.Properties.Caption = "����35ǧ���������";
                            dlg.categoryRow1.Properties.Caption = "����ƽ�⸺��";
                            dlg.categoryRow2.Visible = false;
                            dlg.categoryRow3.Properties.Caption = "��35ǧ����ѹ���縺��";

                        }
                    if (dlg.ShowDialog() != DialogResult.OK)
                    {
                        return;
                    }
                    isresum=dlg.IsReSum;
                }
            }
            else
            {
                FrmBalance_Calc FrmBalance = new FrmBalance_Calc();
                FrmBalance.FormTitle = gridView.FocusedColumn.Caption;
                FrmBalance.CtrTitle = gridView.GroupPanelText;
                PSP_VolumeBalance vol = new PSP_VolumeBalance();
                if (gridView.GetRow(gridView.FocusedRowHandle) != null)
                    vol = gridView.GetRow(gridView.FocusedRowHandle) as PSP_VolumeBalance;
                switch (gridView.FocusedColumn.FieldName)
                {
                    case "L2":

                            FrmBalance.FLAG = vol.UID;
                            FrmBalance.TYPE = "1";

                            FrmBalance.DY = type;
                            FrmBalance.ADdRight = AddRight;
                            FrmBalance.EDitRight = EditRight;
                            FrmBalance.DEleteRight = DeleteRight;
                            FrmBalance.PRintRight = PrintRight;
                         break;
                     case "L10":
                         FrmBalance.FLAG = vol.UID;
                         FrmBalance.TYPE = "2";
                         FrmBalance.DY = type;
                         FrmBalance.ADdRight = AddRight;
                         FrmBalance.EDitRight = EditRight;
                         FrmBalance.DEleteRight = DeleteRight;
                         FrmBalance.PRintRight = PrintRight;
                         break;
                    case"L11":
                        FrmBalance.FLAG = vol.UID;
                        FrmBalance.TYPE = "3";
                        FrmBalance.DY = type;
                        FrmBalance.ADdRight = AddRight;
                        FrmBalance.EDitRight = EditRight;
                        FrmBalance.DEleteRight = DeleteRight;
                        FrmBalance.PRintRight = PrintRight;
                        break;
                    default:
                        break;
                }
                if (FrmBalance.FLAG != "")
                {
                    FrmBalance.ShowDialog();
                    objCopy.GetType().GetProperty(gridView.FocusedColumn.FieldName).SetValue(objCopy, FrmBalance.SUM, null);

                }
            }

            //�ø������½������
            DataConverter.CopyTo<PSP_VolumeBalance>(objCopy, obj);

            if (isresum)
            {

                PSP_VolumeBalance ob = new PSP_VolumeBalance();
                ob.TypeID = type;
                ob.Flag = flag;
                IList<PSP_VolumeBalance> list0 = Services.BaseService.GetList<PSP_VolumeBalance>("SelectPSP_VolumeBalanceByTypeID", ob);
                if (list0 != null)
                    if (list0.Count > 0)
                        ob = list0[0];
                if(ob.UID!=obj.UID)
                    Services.BaseService.Update("UpdatePSP_VolumeBalance2", obj);
                reloadsum(ob);
            }
            else
                reloadsum(obj);
            //ˢ�±��
            gridControl.RefreshDataSource();
        }
        /// <summary>
        /// ˢ�±���е�����
        /// </summary>
        /// <returns>ture:�ɹ�  false:ʧ��</returns>
        public bool RefreshData()
        {
            try
            {
                int iOldHandle = this.gridView.FocusedRowHandle;
                PSP_VolumeBalance vol = new PSP_VolumeBalance();
                vol.TypeID = type;
                vol.Flag = flag;

                IList<PSP_VolumeBalance> list = Services.BaseService.GetList<PSP_VolumeBalance>("SelectPSP_VolumeBalanceByTypeID", vol);
                this.gridControl.DataSource = list;
                if (list != null)
                    if (list.Count > 0)
                        baseyear = list[0].Year;

                try

                {
                    if (Volumecalc == "")
                        Volumecalc = "0";
                    //Volumecalc = System.Configuration.ConfigurationSettings.AppSettings["Volumecalc"];
                    colL8.Caption="��"+type+"kV�������(���ر�"+Volumecalc+")";
                    GridHelper.FocuseRowAfterDelete(this.gridView, iOldHandle);
                    if (type == "35")
                       colL5.Caption = "��" + type + "ǧ��������(����ͬʱ��" + loadrate + ")";
                }
                catch { }
            }
            catch (Exception exc)
            {
                Debug.Fail(exc.Message);
                HandleException.TryCatch(exc);
                return false;
            }

            return true;
        }
        /// <summary>
        /// ��Ӷ���
        /// </summary>
        public void AddObject()
        {
            //�����������Ƿ��Ѿ�����
            if (ObjectList == null)
            {
                return;
            }
            //�½�����
            PSP_VolumeBalance obj = new PSP_VolumeBalance();
            obj.TypeID = type;
            obj.Flag = flag;
            //ִ����Ӳ���
            using (FrmPSP_VolumeBalanceDialog dlg = new FrmPSP_VolumeBalanceDialog())
            {
                dlg.Type=type;
                dlg.Flag = flag;
                dlg.List = gridView.DataSource as IList<PSP_VolumeBalance>;
                dlg.IsCreate = true;    //�����½���־
                dlg.Object = obj;
                if (ObjectList.Count>0)
                    baseyear = ObjectList[0].Year;
                dlg.BaseYear = baseyear;
                if (type == "220")
                {
                    dlg.xtraTabControl1.TabPages[0].Text = "220ǧ���������ƽ���";
                    dlg.Text = "220ǧ���������ƽ���";
                    dlg.rowL1.Properties.Caption = "�ۺ���߸���";
                    dlg.rowL2.Properties.Caption = "ֱ�ӹ��縺��";
                    dlg.rowL2.Visible = false;
                    dlg.rowL4.Properties.Caption = "��������";
                    //dlg.rowL3.Visible = false;
                   // dlg.rowL4.Visible = true;
                    dlg.rowL6.Properties.Caption = "����220kV��ѹ�������";
                    dlg.categoryRow1.Visible = false;
                    dlg.categoryRow2.Visible = false;
                    dlg.categoryRow3.Properties.Caption = "��220kV��ѹ���縺��";
                    //dlg.rowL14.Visible = false;

                }
                else
                    if (type == "35")
                    {
                        dlg.xtraTabControl1.TabPages[0].Text = "35ǧ���������ƽ���";
                        dlg.Text = "35ǧ���������ƽ���";
                        dlg.rowL1.Properties.Caption = "��������";
                        dlg.rowL2.Properties.Caption = "����ƽ�⸺��";
                        //dlg.rowL2.Visible = false;
                        //dlg.rowL4.Properties.Caption = "��������";
                        //dlg.rowL3.Visible = false;
                        dlg.rowL4.Visible = false;
                        dlg.rowL6.Properties.Caption = "����35ǧ���������";
                        //dlg.rowL14.Visible = false;

                    }
                if (dlg.ShowDialog() != DialogResult.OK)
                {

                    return;
                }
            }

            //���¶�����뵽������
            ObjectList.Add(obj);
            reloadsum(obj);
            //ˢ�±�񣬲��������ж�λ���¶����ϡ�
            gridControl.RefreshDataSource();
            GridHelper.FocuseRow(this.gridView, obj);
            AddFuHe(obj);
        }
        private void sum(PSP_VolumeBalance objtemp)
        {
            //PSP_VolumeBalance volumtemp = new PSP_VolumeBalance();
            //volumtemp.TypeID =type;
            //volumtemp.Year = objtemp.Year;
            //IList<PSP_VolumeBalance> listtemp = Services.BaseService.GetList<PSP_VolumeBalance>("SelectPSP_VolumeBalanceByTypeIDAboveYear", volumtemp);
            double l6temp = objtemp.L12;
            double factor = 1;

            if (type == "35")
            {
                if (loadrate != "")
                {
                    factor = Convert.ToDouble(loadrate);
                }
            }
            PSP_VolumeBalance vol = new PSP_VolumeBalance();

            vol.Flag   = flag;
            vol.TypeID = type;
            IList     List = Services.BaseService.GetList("SelectPSP_VolumeBalanceByTypeID", vol);
            DataTable da   = DataConverter.ToDataTable(List, typeof(PSP_VolumeBalance));

            DataRow[] dr = da.Select("Year>" + objtemp.Year);
            foreach (DataRow drtemp  in dr)
            {
                PSP_VolumeBalance psp = new PSP_VolumeBalance();
                foreach (DataColumn dm in da.Columns)
                {
                    psp.GetType().GetProperty(dm.ColumnName).SetValue(psp, drtemp[dm.ColumnName], null);
                }

                //psp = psptemp;
                psp.L6 = Math.Round(l6temp, 2);
                psp.L5 = Math.Round(psp.L1 + psp.L3 - psp.L2 - psp.L4, 2);
                if (psp.L5 != 0)
                {
                    psp.L7 = Math.Round(psp.L6 / (psp.L5 * factor), 2);
                }
                else
                {
                    psp.L7 = 0;
                }
                psp.L8  = Math.Round((psp.L5 * factor) * Convert.ToDouble(Volumecalc), 2);
                psp.L9  = Math.Round(psp.L6 - psp.L8, 2);
                psp.L12 = Math.Round(psp.L6 + psp.L10 + psp.L11, 2);
                if (psp.L5 != 0)
                {
                    psp.L13 = Math.Round(psp.L12 / (psp.L5 * factor), 2);
                }
                else
                {
                    psp.L13 = 0;
                }
                l6temp = Math.Round(psp.L12, 2);
                Services.BaseService.Update("UpdatePSP_VolumeBalance2", psp);

                //foreach (DataColumn dm in da.Columns)
                //{
                //    drtemp[dm.ColumnName]= psp.GetType().GetProperty(dm.ColumnName).GetValue(psp, null);
                //}
            }
        }
        protected bool SaveRecord()
        {
            //创建/修改 对象
            try
            {
                if (IsCreate)
                {
                    Services.BaseService.Create <PSP_VolumeBalance>(_obj);
                }
                else
                {
                    Services.BaseService.Update <PSP_VolumeBalance>(_obj);
                }
            }
            catch (Exception exc)
            {
                Debug.Fail(exc.Message);
                HandleException.TryCatch(exc);
                return(false);
            }
            if (_obj.S1 == "1")
            {
                PSP_VolumeBalance ob = new PSP_VolumeBalance();
                ob.Year   = EnsureBaseYear();
                ob.TypeID = type;
                ob.Flag   = flag;
                IList <PSP_VolumeBalance> list0 = Services.BaseService.GetList <PSP_VolumeBalance>("SelectPSP_VolumeBalanceByTypeIDAndYear", ob);
                if (list0 != null)
                {
                    if (list0.Count == 1)
                    {
                        list0[0].S1 = "0";
                        Services.BaseService.Update <PSP_VolumeBalance>(list0[0]);
                    }
                }
                PSP_VolumeBalanceDataSource BaseYearrate = new PSP_VolumeBalanceDataSource();
                BaseYearrate.UID    = baseyeartype;
                BaseYearrate.Flag   = flag;
                BaseYearrate.Value  = _obj.Year;
                BaseYearrate.TypeID = Convert.ToInt32(_obj.TypeID);
                Services.BaseService.Update("UpdatePSP_VolumeBalanceDataSource2", BaseYearrate);
            }
            else if (_obj.Year == EnsureBaseYear() /*|| (EnsureBaseYear() == baseyear)*/)
            {
                PSP_VolumeBalance ob = new PSP_VolumeBalance();
                ob.Flag   = flag;
                ob.TypeID = type;
                IList <PSP_VolumeBalance> list0 = Services.BaseService.GetList <PSP_VolumeBalance>("SelectPSP_VolumeBalanceByTypeID", ob);
                if (list0 != null)
                {
                    if (list0.Count > 0)
                    {
                        ob = list0[0];
                    }
                }
                PSP_VolumeBalanceDataSource BaseYearrate = new PSP_VolumeBalanceDataSource();
                BaseYearrate.Flag   = flag;
                BaseYearrate.UID    = baseyeartype;
                BaseYearrate.Value  = baseyear;
                BaseYearrate.TypeID = Convert.ToInt32(_obj.TypeID);
                Services.BaseService.Update("UpdatePSP_VolumeBalanceDataSource2", BaseYearrate);
                PSP_VolumeBalanceDataSource volumtemp = new PSP_VolumeBalanceDataSource();
                volumtemp.TypeID = Convert.ToInt32(type);
                volumtemp.Flag   = flag;
                IList <PSP_VolumeBalanceDataSource> list = Services.BaseService.GetList <PSP_VolumeBalanceDataSource>("SelectPSP_VolumeBalanceDataSourceByTypeID", volumtemp);
                if (ob != null)
                {
                    if (ob.UID != "")
                    {
                        foreach (PSP_VolumeBalanceDataSource psptemp in list)
                        {
                            if (psptemp.UID == baseyeartype)
                            {
                                continue;
                            }
                            if (hs[psptemp.Name] != null)
                            {
                                ob.GetType().GetProperty("L" + hs[psptemp.Name].ToString()).SetValue(ob, psptemp.Value, null);
                            }
                        }
                    }
                }
                try
                {
                    ob.S1 = "1";
                    Services.BaseService.Update <PSP_VolumeBalance>(ob);
                    isresum = true;
                }

                catch (Exception ex)
                {
                    System.Console.WriteLine(ex.ToString());
                }
            }
            //操作已成功
            return(true);
        }
        private void barA1_ItemClick(object sender, DevExpress.XtraBars.ItemClickEventArgs e)
        {
            bool issum = true;
            PSP_VolumeBalance sumobj = new PSP_VolumeBalance();

            Form1_Fs_VolumeBalance frm = new Form1_Fs_VolumeBalance();
                frm.Text = "选择最高负荷";
                frm.TYPEFLAG2 = "2";
                //frm.ShowDialog();
                if (frm.ShowDialog() == DialogResult.OK)
                {
                    IList<PSP_VolumeBalance> list;
                    if (this.ctrlPSP_VolumeBalance1.GridControl.DataSource != null && this.ctrlPSP_VolumeBalance1.GridControl.DataSource != DBNull.Value)
                    {
                        list = this.ctrlPSP_VolumeBalance1.GridControl.DataSource as IList<PSP_VolumeBalance>;
                        foreach (PSP_VolumeBalance pspvol in list)
                            foreach (TreeListColumn tlc in frm.TLN.TreeList.Columns)
                            {
                                if (tlc.FieldName.IndexOf("年") < 0)
                                    continue;

                                if (Convert.ToInt32(tlc.FieldName.Replace("年","")) == pspvol.Year)
                                {

                                    try
                                    {
                                        pspvol.L1 = Math.Round(Convert.ToDouble(frm.TLN[tlc.FieldName]),2);
                                        Services.BaseService.Update<PSP_VolumeBalance>(pspvol);
                                        if (issum)
                                        {
                                            issum = false;
                                        }
                                    }
                                    catch (Exception ex)
                                    {
                                        // MessageBox.Show(ex.ToString());
                                    }
                                }
                            }

                        if (!issum)
                        {
                           foreach(PSP_VolumeBalance vol in list)
                               if (this.ctrlPSP_VolumeBalance1.EnsureBaseYear() > 1900)
                               {
                                   if (vol.Year < this.ctrlPSP_VolumeBalance1.EnsureBaseYear())
                                   {
                                       this.ctrlPSP_VolumeBalance1.reloadsum(vol);

                                   }
                                   else if (vol.Year == this.ctrlPSP_VolumeBalance1.EnsureBaseYear())
                                   {
                                       this.ctrlPSP_VolumeBalance1.reloadsum(vol);

                                   }

                               }
                               else
                               {
                                   this.ctrlPSP_VolumeBalance1.reloadsum(vol);
                               }
                        }
                    }
                }
        }
        private void AddFuHe(PSP_VolumeBalance obj)
        {
            PSP_VolumeBalance pvc = new PSP_VolumeBalance();
            pvc.TypeID = type;
            pvc.Flag = flag;
            pvc.Year = EnsureBaseYear();
            IList<PSP_VolumeBalance> list = Services.BaseService.GetList<PSP_VolumeBalance>("SelectPSP_VolumeBalanceByTypeIDAndYear", pvc);
            if (list != null)
                if (list.Count == 1)
                {
                    PSP_VolumeBalance_Calc pvc2 = new PSP_VolumeBalance_Calc();
                    pvc2.Type ="1";
                    pvc2.Flag = list[0].UID;
                    IList<PSP_VolumeBalance_Calc> list2 = Services.BaseService.GetList<PSP_VolumeBalance_Calc>("SelectPSP_VolumeBalance_CalcByTypeFlag", pvc2);
                    PSP_VolumeBalance_Calc pvc3 = new PSP_VolumeBalance_Calc();
                    pvc3.Type = "1";
                    pvc3.Flag = obj.UID;
                    IList<PSP_VolumeBalance_Calc> list3 = Services.BaseService.GetList<PSP_VolumeBalance_Calc>("SelectPSP_VolumeBalance_CalcByTypeFlag", pvc3);
                    if (list2 != null)
                        if (list2.Count > 0)
                        {

                            foreach (PSP_VolumeBalance_Calc pvctemp in list2)
                            {
                                if (list3 != null)
                                    if (list3.Count == list2.Count)
                                        break;
                                PSP_VolumeBalance_Calc _obj = new PSP_VolumeBalance_Calc();
                                _obj = pvctemp;
                                _obj.Flag = obj.UID;
                                _obj.Vol = 0;
                                _obj.UID = Guid.NewGuid().ToString();

                                Services.BaseService.Create<PSP_VolumeBalance_Calc>(_obj);
                            }
                        }
                }
        }
        /// <summary>
        /// 修改焦点对象
        /// </summary>
        public void UpdateObject()
        {
            //获取焦点对象
            PSP_VolumeBalance obj = FocusedObject;
            bool isresum          = false;

            if (obj == null)
            {
                return;
            }

            //创建对象的一个副本
            PSP_VolumeBalance objCopy = new PSP_VolumeBalance();

            DataConverter.CopyTo <PSP_VolumeBalance>(obj, objCopy);
            if ((gridView.FocusedColumn.FieldName != "L2" && gridView.FocusedColumn.FieldName != "L10" && gridView.FocusedColumn.FieldName != "L11") || (gridView.FocusedColumn.FieldName == "L2") && type != "220")
            {
                //执行修改操作
                using (FrmPSP_VolumeBalanceDialog dlg = new FrmPSP_VolumeBalanceDialog())
                {
                    dlg.Type     = type;
                    dlg.Flag     = flag;
                    dlg.List     = gridView.DataSource as IList <PSP_VolumeBalance>;
                    dlg.Object   = objCopy; //绑定副本
                    baseyear     = ObjectList[0].Year;
                    dlg.BaseYear = baseyear;
                    if (type == "220")
                    {
                        dlg.xtraTabControl1.TabPages[0].Text = "220千伏变电容量平衡表";
                        dlg.Text = "220千伏变电容量平衡表";
                        dlg.rowL1.Properties.Caption = "综合最高负荷";
                        dlg.rowL2.Properties.Caption = "直接供电负荷";
                        dlg.rowL2.Visible            = false;
                        dlg.rowL4.Properties.Caption = "外网供电";
                        //dlg.rowL3.Visible = false;
                        //  dlg.rowL4.Visible = true;
                        dlg.rowL6.Properties.Caption        = "现有220kV降压变电容量";
                        dlg.rowL14.Visible                  = false;
                        dlg.categoryRow1.Visible            = false;
                        dlg.categoryRow2.Visible            = false;
                        dlg.categoryRow3.Properties.Caption = "需220kV降压供电负荷";
                    }
                    else
                    if (type == "35")
                    {
                        dlg.xtraTabControl1.TabPages[0].Text = "35千伏变电容量平衡表";
                        dlg.Text = "35千伏变电容量平衡表";
                        dlg.rowL1.Properties.Caption        = "本区负荷";
                        dlg.rowL2.Properties.Caption        = "本地平衡负荷";
                        dlg.rowL4.Visible                   = false;
                        dlg.rowL6.Properties.Caption        = "现有35千伏变电容量";
                        dlg.categoryRow1.Properties.Caption = "本地平衡负荷";
                        dlg.categoryRow2.Visible            = false;
                        dlg.categoryRow3.Properties.Caption = "需35千伏降压供电负荷";
                    }
                    if (dlg.ShowDialog() != DialogResult.OK)
                    {
                        return;
                    }
                    isresum = dlg.IsReSum;
                }
            }
            else
            {
                FrmBalance_Calc FrmBalance = new FrmBalance_Calc();
                FrmBalance.FormTitle = gridView.FocusedColumn.Caption;
                FrmBalance.CtrTitle  = gridView.GroupPanelText;
                PSP_VolumeBalance vol = new PSP_VolumeBalance();
                if (gridView.GetRow(gridView.FocusedRowHandle) != null)
                {
                    vol = gridView.GetRow(gridView.FocusedRowHandle) as PSP_VolumeBalance;
                }
                switch (gridView.FocusedColumn.FieldName)
                {
                case "L2":


                    FrmBalance.FLAG = vol.UID;
                    FrmBalance.TYPE = "1";

                    FrmBalance.DY          = type;
                    FrmBalance.ADdRight    = AddRight;
                    FrmBalance.EDitRight   = EditRight;
                    FrmBalance.DEleteRight = DeleteRight;
                    FrmBalance.PRintRight  = PrintRight;
                    break;

                case "L10":
                    FrmBalance.FLAG        = vol.UID;
                    FrmBalance.TYPE        = "2";
                    FrmBalance.DY          = type;
                    FrmBalance.ADdRight    = AddRight;
                    FrmBalance.EDitRight   = EditRight;
                    FrmBalance.DEleteRight = DeleteRight;
                    FrmBalance.PRintRight  = PrintRight;
                    break;

                case "L11":
                    FrmBalance.FLAG        = vol.UID;
                    FrmBalance.TYPE        = "3";
                    FrmBalance.DY          = type;
                    FrmBalance.ADdRight    = AddRight;
                    FrmBalance.EDitRight   = EditRight;
                    FrmBalance.DEleteRight = DeleteRight;
                    FrmBalance.PRintRight  = PrintRight;
                    break;

                default:
                    break;
                }
                if (FrmBalance.FLAG != "")
                {
                    FrmBalance.ShowDialog();
                    objCopy.GetType().GetProperty(gridView.FocusedColumn.FieldName).SetValue(objCopy, FrmBalance.SUM, null);
                }
            }

            //用副本更新焦点对象
            DataConverter.CopyTo <PSP_VolumeBalance>(objCopy, obj);

            if (isresum)
            {
                PSP_VolumeBalance ob = new PSP_VolumeBalance();
                ob.TypeID = type;
                ob.Flag   = flag;
                IList <PSP_VolumeBalance> list0 = Services.BaseService.GetList <PSP_VolumeBalance>("SelectPSP_VolumeBalanceByTypeID", ob);
                if (list0 != null)
                {
                    if (list0.Count > 0)
                    {
                        ob = list0[0];
                    }
                }
                if (ob.UID != obj.UID)
                {
                    Services.BaseService.Update("UpdatePSP_VolumeBalance2", obj);
                }
                reloadsum(ob);
            }
            else
            {
                reloadsum(obj);
            }
            //刷新表格
            gridControl.RefreshDataSource();
        }
        private void barButtonItem3_ItemClick(object sender, DevExpress.XtraBars.ItemClickEventArgs e)
        {
            if (gridView1.FocusedRowHandle < 0)
            {
                return;
            }
            if (!base.DeleteRight)
            {
                MsgBox.Show("您没有权限进行此项操作!");
                return;
            }

            if (MsgBox.ShowYesNo("是否删除 " + gridView1.GetDataRow(gridView1.FocusedRowHandle)["ListName"])
                == DialogResult.No)
            {
                return;
            }

            PowerEachList report = Itop.Common.DataConverter.RowToObject<PowerEachList>(gridView1.GetDataRow(gridView1.FocusedRowHandle));

            try
            {
                PSP_VolumeBalance ob = new PSP_VolumeBalance();
                ob.Flag = report.UID;
                if (typeFlag.Contains("110"))
                    ob.TypeID = "110";
                else if (typeFlag.Contains("220"))
                    ob.TypeID = "220";
                IList<PSP_VolumeBalance> list = Services.BaseService.GetList<PSP_VolumeBalance>("SelectPSP_VolumeBalanceByTypeID", ob);
                foreach(PSP_VolumeBalance listtemp in list)
                    Services.BaseService.Update("DeletePSP_VolumeBalance2", listtemp);

                Common.Services.BaseService.Update("DeletePowerEachList_VolumeBalance", report);
                gridView1.DeleteRow(gridView1.FocusedRowHandle);
            }
            catch (Exception ex)
            {
                MsgBox.Show("删除出错:" + ex.Message);
            }
        }
        private void sum(PSP_VolumeBalance objtemp)
        {
            //PSP_VolumeBalance volumtemp = new PSP_VolumeBalance();
            //volumtemp.TypeID =type;
            //volumtemp.Year = objtemp.Year;
            //IList<PSP_VolumeBalance> listtemp = Services.BaseService.GetList<PSP_VolumeBalance>("SelectPSP_VolumeBalanceByTypeIDAboveYear", volumtemp);
            double l6temp = objtemp.L12;
            double factor = 1;
            if (type == "35")
                if (loadrate != "")
                    factor = Convert.ToDouble(loadrate);
            PSP_VolumeBalance vol = new PSP_VolumeBalance();
            vol.Flag=flag;
            vol.TypeID=type;
            IList List = Services.BaseService.GetList("SelectPSP_VolumeBalanceByTypeID", vol);
            DataTable da = DataConverter.ToDataTable(List, typeof(PSP_VolumeBalance));
            DataRow[] dr = da.Select("Year>"+objtemp.Year);
            foreach (DataRow drtemp  in dr)
            {
                PSP_VolumeBalance psp = new PSP_VolumeBalance();
                foreach (DataColumn dm in da.Columns)
                {
                    psp.GetType().GetProperty(dm.ColumnName).SetValue(psp, drtemp[dm.ColumnName], null);
                }

                //psp = psptemp;
                psp.L6 = Math.Round(l6temp,2);
                psp.L5 = Math.Round(psp.L1 + psp.L3 - psp.L2 - psp.L4,2);
                if (psp.L5 != 0)
                    psp.L7 = Math.Round(psp.L6 / (psp.L5 * factor), 2);
                else
                    psp.L7 = 0;
                psp.L8 = Math.Round((psp.L5 * factor) * Convert.ToDouble(Volumecalc), 2);
                psp.L9 = Math.Round(psp.L6 - psp.L8,2);
                psp.L12 = Math.Round(psp.L6 + psp.L10 + psp.L11,2);
                if (psp.L5 != 0)
                    psp.L13 = Math.Round(psp.L12 / (psp.L5 * factor), 2);
                else
                    psp.L13 = 0;
                l6temp = Math.Round(psp.L12,2);
                Services.BaseService.Update("UpdatePSP_VolumeBalance2", psp);

                //foreach (DataColumn dm in da.Columns)
                //{
                //    drtemp[dm.ColumnName]= psp.GetType().GetProperty(dm.ColumnName).GetValue(psp, null);
                //}
            }
        }