水管编辑

[Transaction(TransactionMode.Manual)]
    public class SelEditPipe : IExternalCommand
    {
        #region IExternalCommand Members
        public Result Execute(ExternalCommandData commandData, ref string message, ElementSet elements)
        {
            UIDocument uiDoc = commandData.Application.ActiveUIDocument;
            Selection sel = uiDoc.Selection;
            sel.Elements.Clear();
            List<Pipe> pipeList = new List<Pipe>();//获得选中的水管

            try
            {
                PipeSelectionFilter pipeSelFilter = new PipeSelectionFilter(uiDoc.Document);
                IList<Reference> iReferList = sel.PickObjects(ObjectType.Element, pipeSelFilter, "请选择要查询、修改的水管：");
                foreach (var item in iReferList)
                {
                    Element elem = uiDoc.Document.GetElement(item);
                    if (elem is Pipe)
                    {
                        pipeList.Add(elem as Pipe);
                        sel.Elements.Add(elem);
                    }
                }
                if (pipeList.Count > 0)
                {
                    PipeFrm frmPipe = new PipeFrm(commandData, elements, pipeList);
                    frmPipe.Show();
                    frmPipe.TopMost = true;
                }
                else
                {
                    DialogResult result = MessageBox.Show("没有选中任何水管，是否重新选择水管？", "信息提示！", MessageBoxButtons.YesNo, MessageBoxIcon.Question);
                    if (result == DialogResult.Yes)
                    {
                        sel.Elements.Clear();//清除选中元素
                        iReferList = sel.PickObjects(ObjectType.Element, pipeSelFilter, "请选择要查询、修改的水管：");
                        foreach (var item in iReferList)
                        {
                            Element elem = uiDoc.Document.GetElement(item);
                            if (elem is Pipe)
                            {
                                pipeList.Add(elem as Pipe);
                                sel.Elements.Add(elem);
                            }
                        }
                        if (pipeList.Count > 0)
                        {
                            PipeFrm frmPipe = new PipeFrm(commandData, elements, pipeList);
                            frmPipe.Show();
                            frmPipe.TopMost = true;
                        }
                    }
                    else
                    {
                        sel.Elements.Clear();
                        return Result.Cancelled;
                    }
                }

            }
            catch (Exception ex)
            {
                message = ex.Message;
                return Result.Succeeded;
            }
            return Result.Succeeded;
        }

        #endregion
    }
    /// <summary>
    ///水管选择过滤器
    /// </summary>
    public class PipeSelectionFilter : ISelectionFilter
    {
        #region ISelectionFilter Members
        Document doc = null;
        public PipeSelectionFilter(Document document)
        {
            doc = document;
        }

        public bool AllowElement(Element elem)
        {
            return elem is Pipe;
        }

        public bool AllowReference(Reference reference, XYZ position)
        {
            if (doc.GetElement(reference) is Pipe)
            {
                return true;
            }
            return false;
        }

        #endregion
    }

/// <summary>
    /// 水管的选择、编辑
    /// </summary>
    public partial class PipeFrm : System.Windows.Forms.Form
    {
        IList<Pipe> listPipe = new List<Pipe>();
        ExternalCommandData cmmData = null;
        string msg = "";
        ElementSet elemSet = new ElementSet();

        UIDocument uiDoc = null;
        public PipeFrm()
        {
            InitializeComponent();
        }
        //构造函数
        public PipeFrm(ExternalCommandData commandData,ElementSet elementSet,IList<Pipe> iPipeList)
        {
            InitializeComponent();
            cmmData = commandData;
            elemSet = elementSet;
            listPipe = iPipeList;
        }
        /// <summary>
        /// 初始化各个参数信息
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void FrmPipe_Load(object sender, EventArgs e)
        {
            try
            {
                uiDoc = cmmData.Application.ActiveUIDocument;
                this.Text = "水管编辑-共选中" + listPipe.Count + "条水管";
                ReadPipeParaInfo();
            }
            catch (Exception ex)
            {

                MessageBox.Show(ex.Message);
            }

        }
        /// <summary>
        /// 读取选中水管各个参数信息
        /// </summary>
        private void ReadPipeParaInfo()
        {
            BindSysType(uiDoc.Document, listPipe[0]);//读取水管系统类型
            BindLevel(uiDoc.Document, listPipe[0]); //读取系统所有标高
            BindParaInfo(listPipe[0]);//读取偏移量、直径等参数
        }
        /// <summary>
        /// 读取水管系统类型
        /// </summary>
        /// <param name="doc"></param>
        /// <param name="pipe"></param>
        private void BindSysType(Document doc, Pipe pipe)
        {
            FilteredElementCollector feCollector = new FilteredElementCollector(doc);
            List<Element> listElem = new List<Element>();
            listElem=feCollector.OfClass(typeof(PipingSystemType)).ToList<Element>();//过滤所有水管的类型
            int i = 0, j = 0;
            Parameter para = pipe.get_Parameter( BuiltInParameter.RBS_PIPING_SYSTEM_TYPE_PARAM);
            List<PipeSysType> listType = new List<PipeSysType>();
            foreach (Element elem in listElem)
            {
                PipeSysType psType = new PipeSysType();
                psType.SysTypeId = elem.Id;
                psType.SysTypeName = elem.Name;
                listType.Add(psType);
                if (elem.Name==doc.get_Element(para.AsElementId()).Name)
                {
                    j = i;
                }
                i++;
            }
            this.cmbSysPipeType.DataSource = listType;
            this.cmbSysPipeType.ValueMember = "SysTypeId";
            this.cmbSysPipeType.DisplayMember = "SysTypeName";
            this.cmbSysPipeType.SelectedIndex = j;
        }
        /// <summary>
        /// 读取系统所有标高
        /// </summary>
        /// <param name="doc"></param>
        /// <param name="pipe"></param>
        private void BindLevel(Document doc, Pipe pipe)
        {
            FilteredElementCollector feCollector = new FilteredElementCollector(doc);
            ICollection<Element> elemIcoll = feCollector.OfClass(typeof(Level)).ToElements();//过滤所有标高对象
            int i = 0, j = 0;
            List<PipeLevel> listLevel = new List<PipeLevel>();
            foreach (var item in elemIcoll)
            {
                Level level = item as Level;
                PipeLevel pLevel = new PipeLevel();
                pLevel.LevelId = level.Id;
                pLevel.LevelName = level.Name;
                listLevel.Add(pLevel);
                if (level.Name==pipe.ReferenceLevel.Name)
                {
                    j = i;
                }
                i++;
            }
            this.cmbLevel.DataSource = listLevel;
            this.cmbLevel.DisplayMember = "LevelName";
            this.cmbLevel.ValueMember = "LevelId";
            this.cmbLevel.SelectedIndex = j;
        }
        /// <summary>
        /// 读取偏移量、直径等参数
        /// </summary>
        /// <param name="pipe"></param>
        private void BindParaInfo(Pipe pipe)
        {
            Parameter para = null;
            para = pipe.get_Parameter( BuiltInParameter.RBS_OFFSET_PARAM);
            this.txtOffsetLevel.Text = UnitConvert.GetString(Convert.ToString(UnitConvert.CovertFromAPI(DisplayUnitType.DUT_MILLIMETERS, para.AsDouble())/1000.0));//偏移量
            para = pipe.get_Parameter(BuiltInParameter.RBS_PIPE_DIAMETER_PARAM);
            this.txtDiameter.Text = Convert.ToString(UnitConvert.CovertFromAPI(DisplayUnitType.DUT_MILLIMETERS, para.AsDouble()));//直径
            para = pipe.get_Parameter(BuiltInParameter.RBS_PIPE_FLOW_PARAM);
            this.txtFlux.Text = Convert.ToString(UnitConvert.CovertFromAPI(DisplayUnitType.DUT_LITERS_PER_SECOND, para.AsDouble())*3.6);//流量
            para = pipe.get_Parameter(BuiltInParameter.RBS_PIPE_VELOCITY_PARAM);
            this.txtSpeed.Text = Convert.ToString(UnitConvert.CovertFromAPI(DisplayUnitType.DUT_METERS_PER_SECOND,para.AsDouble()));//流速
            para = pipe.get_Parameter(BuiltInParameter.RBS_PIPE_FRICTION_PARAM);
            this.txtAttrition.Text = Convert.ToString(UnitConvert.CovertFromAPI(DisplayUnitType.DUT_PASCALS_PER_METER, para.AsDouble()));//比摩阻
            para = pipe.get_Parameter(BuiltInParameter.RBS_PIPE_PRESSUREDROP_PARAM);
            this.txtRestance.Text = Convert.ToString(UnitConvert.CovertFromAPI(DisplayUnitType.DUT_PASCALS, para.AsDouble()));//沿程损失
        }       
        /// <summary>
        /// 关闭该窗口
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void btnExit_Click(object sender, EventArgs e)
        {
            this.Dispose();
        }       
        /// <summary>
        /// 重新开始选择水管
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void btnSelectPipe_Click(object sender, EventArgs e)
        {
            try
            {
                this.TopMost = false;
                SelEditPipe selEditPipe = new SelEditPipe();
                selEditPipe.Execute(cmmData, ref msg, elemSet);
                this.Dispose();
            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.Message);
            }

        }
        List<bool> listBoolean = new List<bool>();
        /// <summary>
        /// 修改各个要修改的参数值
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void btnModify_Click(object sender, EventArgs e)
        {
            try
            {
                if (JudgeCheckBox().Count <=0)
                {
                    MessageBox.Show("您没有修改任何参数！", "信息提示", MessageBoxButtons.OK, MessageBoxIcon.Information);
                    return;
                }
                if (!Regex.IsMatch(this.txtDiameter.Text, @"^[1-9]+\d*$"))
                {
                    MessageBox.Show("直径必须是正整数！", "信息提示", MessageBoxButtons.OK, MessageBoxIcon.Information);
                    return;
                }
                if (!Regex.IsMatch(this.txtOffsetLevel.Text, @"^[+-]?[0-9]+\d*[.]?\d*$"))
                {
                    MessageBox.Show("偏移量必须是数字！", "信息提示", MessageBoxButtons.OK, MessageBoxIcon.Information);
                    return;
                }
                if (JudgeModifyPipeInfo(listPipe))
                {
                    MessageBox.Show("修改成功！", "信息提示", MessageBoxButtons.OK, MessageBoxIcon.Information);
                }//判断是否修改水管参数
                else
                {
                    MessageBox.Show("修改失败！", "信息提示", MessageBoxButtons.OK, MessageBoxIcon.Information);
                }
            }
            catch (Exception ex)
            {

                MessageBox.Show(ex.Message);
            }
        }
        /// <summary>
        /// 判断CheckBox的选择情况
        /// </summary>
        /// <returns></returns>
        private List<bool> JudgeCheckBox()
        {
            List<bool> listChecked = new List<bool>();
            if (this.ckbSysPipeType.Checked)
            {
                listChecked.Add(this.ckbSysPipeType.Checked);
            }
            if (this.ckbDiameter.Checked)
            {
                listChecked.Add(this.ckbDiameter.Checked);
            }
            if (this.ckbLevel.Checked)
            {
                listChecked.Add(this.ckbLevel.Checked);
            }
            if (this.ckbOffsetLevel.Checked)
            {
                listChecked.Add(this.ckbOffsetLevel.Checked);
            }
            return listChecked;
        }
        /// <summary>
        /// 修改各个参数值，并返回成功与否的结果
        /// </summary>
        /// <param name="listPipe"></param>
        /// <returns></returns>
        private bool JudgeModifyPipeInfo(IList<Pipe> listPipe)
        {
            Parameter para = null;
            List<bool> listMsg = new List<bool>();
            double value = 0;
            try
            {
                foreach (Pipe item in listPipe)
                {
                    if (this.ckbSysPipeType.Checked)
                    {
                        para = item.get_Parameter(BuiltInParameter.RBS_PIPING_SYSTEM_TYPE_PARAM);
                        listMsg.Add(para.Set((ElementId)this.cmbSysPipeType.SelectedValue));//修改系统类型值
                    }
                    if (this.ckbLevel.Checked)
                    {
                        para = item.get_Parameter(BuiltInParameter.RBS_START_LEVEL_PARAM);
                        listMsg.Add(para.Set((ElementId)this.cmbLevel.SelectedValue));//修改标高值
                    }
                    if (this.ckbDiameter.Checked)
                    {
                        para = item.get_Parameter(BuiltInParameter.RBS_PIPE_DIAMETER_PARAM);
                        value = Convert.ToDouble(this.txtDiameter.Text);
                        listMsg.Add(para.Set(UnitConvert.CovertToAPI(value, DisplayUnitType.DUT_MILLIMETERS)));//修改直径值
                    }
                    if (this.ckbOffsetLevel.Checked)
                    {
                        para = item.get_Parameter(BuiltInParameter.RBS_OFFSET_PARAM);
                        value = Convert.ToDouble(this.txtOffsetLevel.Text) * 1000.0;
                        listMsg.Add(para.Set(UnitConvert.CovertToAPI(value, DisplayUnitType.DUT_MILLIMETERS)));//修改偏移量
                    }
                }
            }
            catch (Exception ex)
            {

                MessageBox.Show(ex.Message);
            }
            listBoolean = listMsg;
            foreach (var item in listMsg)
            {
                if (!item)
                {
                    return false;
                }
            }
            return true;
        }
         /// <summary>
        /// 失去焦点的时候速度跟着改变，直径改变流速跟着改变的值
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
         private void txtDiameter_Leave(object sender, EventArgs e)
        {
            if (!Regex.IsMatch(this.txtDiameter.Text, @"^[1-9]+\d*$"))
            {
                MessageBox.Show("直径必须是正整数！", "信息提示", MessageBoxButtons.OK, MessageBoxIcon.Information);
                return;
            }
            CalculateSpeed();//直径改变流速跟着改变的值
        }
         /// <summary>
         /// 给速度框赋值
         /// </summary>
         private void CalculateSpeed()
         {
             double diameter = Convert.ToDouble(this.txtDiameter.Text) / 1000.0;
             double flux = Convert.ToDouble(this.txtFlux.Text);
             this.txtSpeed.Text = GetSpeedValue(diameter,flux);
         }
        /// <summary>
         /// 计算速度
        /// </summary>
        /// <param name="diameter"></param>
        /// <param name="addFlux"></param>
        /// <param name="flux"></param>
        /// <returns></returns>
         private string GetSpeedValue(double diameter, double flux)
         {
             try
             {
                 double speed = flux /3600/ (900 * Math.PI * diameter * diameter);
                 return Convert.ToString(speed);
             }
             catch (Exception ex)
             {
                 MessageBox.Show(ex.Message);
             }
             return null;
         }
        /// <summary>
        /// 失去焦点的时候速度跟着改变，其他流量改变流速跟着改变的值
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void txtAddedFlux_Leave(object sender, EventArgs e)
        {
            CalculateSpeed();//其他流量改变流速跟着改变的值
        }
        /// <summary>
        /// 验证偏移量必须为数字
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void txtOffsetLevel_Leave(object sender, EventArgs e)
        {
            if (!Regex.IsMatch(this.txtOffsetLevel.Text, @"^[+-]?[0-9]+\d*[.]?\d*$"))
            {
                MessageBox.Show("偏移量必须是数字！", "信息提示", MessageBoxButtons.OK, MessageBoxIcon.Information);
                return;
            }
        }
    }
    /// <summary>
    /// 水管标高类型
    /// </summary>
    public class PipeLevel
    {
        public string LevelName { get; set; }
        public ElementId LevelId { get; set; }
    }
    /// <summary>
    /// 水管系统类型
    /// </summary>
    public class PipeSysType
    {
        public string SysTypeName { get; set; }
        public ElementId SysTypeId { get; set; }
    }