风管编辑

    /// <summary>
    /// 风管选择、编辑
    /// </summary>
    [Transaction(TransactionMode.Manual)]
    public class EditCommand: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<Duct> listDuct = new List<Duct>();//存储获得选中的风管

            try
            {
                DuctSelectionFilter dsFilter = new DuctSelectionFilter(uiDoc.Document);
                IList<Reference> listRefer = sel.PickObjects(ObjectType.Element,dsFilter,"请选择要查询、修改的风管：");
                foreach (var item in listRefer)
                {
                    Duct duct = uiDoc.Document.GetElement(item) as Duct;
                    listDuct.Add(duct);
                    sel.Elements.Add(duct);
                }
                if (listDuct.Count>0)
                {
                    FrmDuct frmDuct = new FrmDuct(commandData, elements, listDuct);
                    frmDuct.Show();
                    frmDuct.TopMost = true;
                }
                else
                {
                    DialogResult result = MessageBox.Show("没有选中任何风管，是否重新选择风管？", "信息提示！", MessageBoxButtons.YesNo, MessageBoxIcon.Question);
                    if (result==DialogResult.Yes)
                    {
                        sel.Elements.Clear();
                        listRefer = sel.PickObjects(ObjectType.Element, dsFilter, "请选择要查询、修改的风管：");
                        foreach (var item in listRefer)
                        {
                            Duct duct = uiDoc.Document.GetElement(item) as Duct;
                            listDuct.Add(duct);
                            sel.Elements.Add(duct);
                        }
                        if (listDuct.Count > 0)
                        {
                            FrmDuct frmDuct = new FrmDuct(commandData, elements, listDuct);
                            frmDuct.Show();
                            frmDuct.TopMost = true;
                        }
                    }
                    else
                    {
                        sel.Elements.Clear();
                        return Result.Cancelled;
                    }
                }
            }
            catch (Exception ex)
            {
                message = ex.Message;
                return Result.Cancelled;
            }
            return Result.Succeeded;
        }

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

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

        public bool AllowReference(Reference reference, XYZ position)
        {
            return doc.GetElement(reference) is Duct;
        }

        #endregion
    }

        List<Duct> listDuct = new List<Duct>();
        ExternalCommandData cmmData = null;
        string msg = "";
        ElementSet elemSet = new ElementSet();

        UIDocument uiDoc = null;
        /// <summary>
        /// 构造函数
        /// </summary>
        public FrmDuct()
        {
            InitializeComponent();
        }
        public FrmDuct(ExternalCommandData commandData, ElementSet elementSet, List<Duct> iDuctList)
        {
            InitializeComponent();
            cmmData = commandData;
            elemSet = elementSet;
            listDuct = iDuctList;
        }
        /// <summary>
        /// 窗口初始化信息
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void FrmDuct_Load(object sender, EventArgs e)
        {
            try
            {
                uiDoc = cmmData.Application.ActiveUIDocument;
                this.Text = "风管编辑-共选择"+listDuct.Count+"条风管";
                ReadDuctParaInfo();
            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.Message);
            }

        }
        /// <summary>
        /// 读取风管信息
        /// </summary>
        private void ReadDuctParaInfo()
        {
            try
            {
                BindDSysType(uiDoc.Document, listDuct[0]);// 读取风管类型信息
                BindLevel(uiDoc.Document, listDuct[0]);// 读取所有参照标高信息
                ReadSectionType(listDuct[0]);// 读取截面类型、宽、高值
                ReadParaInfo(listDuct[0]);// 读取偏移量、流量等Parameter信息
            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.Message);
            }
        }
        /// <summary>
        /// 读取风管类型信息
        /// </summary>
        /// <param name="doc"></param>
        /// <param name="duct"></param>
        private void BindDSysType(Document doc,Duct duct)
        {
            FilteredElementCollector fCollect = new FilteredElementCollector(doc);
            List<Element> listElem = new List<Element>();
            listElem = fCollect.OfClass(typeof(MechanicalSystemType)).ToList<Element>();
            Parameter para = duct.get_Parameter(BuiltInParameter.RBS_DUCT_SYSTEM_TYPE_PARAM);
            List<DuctSysType> listDType = new List<DuctSysType>();
            int i = 0; int j = 0;
            foreach (Element item in listElem)
            {
                DuctSysType ductType = new DuctSysType();
                ductType.SysTypeId = item.Id;
                ductType.SysTypeName = item.Name;
                listDType.Add(ductType);
                if (item.Name == doc.get_Element(para.AsElementId()).Name)
                {
                    j = i;
                }
                i++;
            }
            this.cmbDuctSysType.DataSource = listDType;
            this.cmbDuctSysType.ValueMember = "SysTypeId";
            this.cmbDuctSysType.DisplayMember = "SysTypeName";
            this.cmbDuctSysType.SelectedIndex = j;
        }
        /// <summary>
        /// 读取所有参照标高信息
        /// </summary>
        /// <param name="doc"></param>
        /// <param name="duct"></param>
        private void BindLevel(Document doc, Duct duct)
        {
            FilteredElementCollector fCollector = new FilteredElementCollector(doc);
            ICollection<Element> iColl = fCollector.OfClass(typeof(Level)).ToElements();
            int i = 0, j = 0;
            List<DuctLevel> list = new List<DuctLevel>();
            foreach (Element item in iColl)
            {
                Level level = item as Level;
                DuctLevel mLevel = new DuctLevel();
                mLevel.LevelId = level.Id;
                mLevel.LevelName = level.Name;
                list.Add(mLevel);
                if (level != null)
                {
                    if (level.Name == duct.ReferenceLevel.Name)
                    {
                        j = i;
                    }
                    i++;
                }
            }
            this.cmbLevel.DataSource = list;
            this.cmbLevel.DisplayMember = "LevelName";
            this.cmbLevel.ValueMember = "LevelId";
            this.cmbLevel.SelectedIndex = j;
        }
        /// <summary>
        /// 读取偏移量、流量等Parameter信息
        /// </summary>
        /// <param name="duct"></param>
        private void ReadParaInfo(Duct duct)
        {
            Parameter para = null;
            para = duct.get_Parameter(BuiltInParameter.RBS_OFFSET_PARAM);//偏移量
            string offSet = Convert.ToString(UnitConvert.CovertFromAPI(DisplayUnitType.DUT_MILLIMETERS, para.AsDouble()) / 1000.0);
            this.txtOffsetLevel.Text = UnitConvert.GetString(offSet);
            para = duct.get_Parameter(BuiltInParameter.RBS_DUCT_FLOW_PARAM);//流量
            this.txtFlux.Text = Convert.ToString(UnitConvert.CovertFromAPI(DisplayUnitType.DUT_CUBIC_METERS_PER_HOUR, para.AsDouble()));
            para = duct.get_Parameter(BuiltInParameter.RBS_VELOCITY);//流速
            this.txtSpeed.Text = Convert.ToString(UnitConvert.CovertFromAPI(DisplayUnitType.DUT_METERS_PER_SECOND, para.AsDouble()));
            para = duct.get_Parameter(BuiltInParameter.RBS_FRICTION);//比摩阻
            this.txtAttrition.Text = Convert.ToString(UnitConvert.CovertFromAPI(DisplayUnitType.DUT_PASCALS_PER_METER, para.AsDouble()));
            para = duct.get_Parameter(BuiltInParameter.RBS_PRESSURE_DROP);//沿程损失
            this.txtResistance.Text = Convert.ToString(UnitConvert.CovertFromAPI(DisplayUnitType.DUT_PASCALS, para.AsDouble()));
        }
        /// <summary>
        /// 读取截面类型
        /// </summary>
        /// <param name="duct"></param>
        private void ReadSectionType(Duct duct)
        {
            Parameter para = null;
            foreach (Connector item in duct.ConnectorManager.Connectors)
            {
                switch (item.Shape)
                {
                    case ConnectorProfileType.OvalProfile:
                        this.txtSectionType.Text = "椭圆形风管";
                        BindWidthandHeight(duct, para);// 绑定宽高值
                        break;
                    case ConnectorProfileType.RectProfile:
                        this.txtSectionType.Text = "矩形风管";
                        BindWidthandHeight(duct, para);// 绑定宽高值
                        break;
                    case ConnectorProfileType.RoundProfile:
                        this.txtSectionType.Text = "圆形风管";
                        para = duct.get_Parameter(BuiltInParameter.RBS_CURVE_DIAMETER_PARAM);
                        this.txtWidthorDiameter.Text = Convert.ToString(UnitConvert.CovertFromAPI(DisplayUnitType.DUT_MILLIMETERS, para.AsDouble()));//截面直径值
                        this.txtHeight.Enabled = false;
                        this.ckbHeight.Enabled = false;
                        break;
                    default:
                        break;
                }
            }
        }
        /// <summary>
        /// 绑定宽高值
        /// </summary>
        /// <param name="duct"></param>
        /// <param name="para"></param>
        private void BindWidthandHeight(Duct duct, Parameter para)
        {
            if (!this.ckbHeight.Enabled)
            {
                this.ckbHeight.Enabled = true;
            }
            if (!this.txtHeight.Enabled)
            {
                this.txtHeight.Enabled = true;
            }
            para = duct.get_Parameter(BuiltInParameter.RBS_CURVE_WIDTH_PARAM);
            this.txtWidthorDiameter.Text = Convert.ToString(UnitConvert.CovertFromAPI(DisplayUnitType.DUT_MILLIMETERS, para.AsDouble()));//截面宽度
            para = duct.get_Parameter(BuiltInParameter.RBS_CURVE_HEIGHT_PARAM);
            this.txtHeight.Text = Convert.ToString(UnitConvert.CovertFromAPI(DisplayUnitType.DUT_MILLIMETERS, 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 btnReSelect_Click(object sender, EventArgs e)
        {
            try
            {
                this.TopMost = false;
                EditCommand editDuct = new EditCommand();
                editDuct.Execute(cmmData,ref msg, elemSet);
                this.Dispose();
            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.Message);
            }
        }
        /// <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.txtWidthorDiameter.Text, @"^[1-9]+\d*$"))
                {
                    MessageBox.Show("宽度或直径必须是正整数！", "信息提示", MessageBoxButtons.OK, MessageBoxIcon.Information);
                    return;
                }
                if (!Regex.IsMatch(this.txtHeight.Text, @"^[1-9]+\d*$"))
                {
                    MessageBox.Show("高度必须是正整数！", "信息提示", MessageBoxButtons.OK, MessageBoxIcon.Information);
                    return;
                }
                if (!Regex.IsMatch(this.txtOffsetLevel.Text, @"^[+-]?\d*[.]?\d*"))
                {
                    MessageBox.Show("偏移量必须是数字！", "信息提示", MessageBoxButtons.OK, MessageBoxIcon.Information);
                    return;
                }
                if (JudgeModifyParaInfo(listDuct))
                {
                    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.ckbDuctSysType.Checked)
            {
                listChecked.Add(this.ckbDuctSysType.Checked);
            }
            if (this.ckbWidthorDiameter.Checked)
            {
                listChecked.Add(this.ckbWidthorDiameter.Checked);
            }
            if (this.ckbHeight.Checked)
            {
                listChecked.Add(this.ckbHeight.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="listDuct"></param>
        /// <returns></returns>
        private bool JudgeModifyParaInfo(List<Duct> listDuct)
        {
            Parameter para = null;
            List<bool> listMsg = new List<bool>();
            foreach (var item in listDuct)
            {
                if (this.ckbDuctSysType.Checked)
                {
                    para = item.get_Parameter(BuiltInParameter.RBS_DUCT_SYSTEM_TYPE_PARAM);
                    listMsg.Add(para.Set((ElementId)this.cmbDuctSysType.SelectedValue));
                }//修改风管系统类型值
                foreach (Connector conn in item.ConnectorManager.Connectors)
                {
                    switch (conn.Shape)
                    {
                        case ConnectorProfileType.OvalProfile:
                            ModifyWidthHeightInfo(ref para, listMsg, item);// 判断修改宽度值
                            break;
                        case ConnectorProfileType.RectProfile:
                            ModifyWidthHeightInfo(ref para, listMsg, item);// 判断修改高度值
                            break;
                        case ConnectorProfileType.RoundProfile:
                            if (this.ckbWidthorDiameter.Checked)// 判断修改直径值
                            {
                                para = item.get_Parameter(BuiltInParameter.RBS_CURVE_DIAMETER_PARAM);
                                listMsg.Add(para.Set(UnitConvert.CovertToAPI(Convert.ToDouble(this.txtWidthorDiameter.Text), DisplayUnitType.DUT_MILLIMETERS)));
                            }
                            break;
                        default:
                            break;
                    }
                }//判断风管类型，并修改相应的值
                if (this.ckbLevel.Checked)
                {
                    para = item.get_Parameter(BuiltInParameter.RBS_START_LEVEL_PARAM);
                    listMsg.Add(para.Set((ElementId)this.cmbLevel.SelectedValue));
                }//判断修改参照标高
                if (this.ckbOffsetLevel.Checked)
                {
                    para = item.get_Parameter(BuiltInParameter.RBS_OFFSET_PARAM);
                    listMsg.Add(para.Set(UnitConvert.CovertToAPI(Convert.ToDouble(this.txtOffsetLevel.Text) * 1000.0, DisplayUnitType.DUT_MILLIMETERS)));
                }//偏移量
            }
            foreach (var item in listMsg)
            {
                if (!item)
                {
                    return false;
                }
            }
            return true;
        }
        /// <summary>
        /// 判断修改宽高值
        /// </summary>
        /// <param name="para"></param>
        /// <param name="listMsg"></param>
        /// <param name="value"></param>
        /// <param name="item"></param>
        private void ModifyWidthHeightInfo(ref Parameter para, IList<bool> listMsg, Duct item)
        {
            if (this.ckbWidthorDiameter.Checked)
            {
                para = item.get_Parameter(BuiltInParameter.RBS_CURVE_WIDTH_PARAM);
                listMsg.Add(para.Set(UnitConvert.CovertToAPI(Convert.ToDouble(this.txtWidthorDiameter.Text), DisplayUnitType.DUT_MILLIMETERS)));
            }
            if (this.ckbHeight.Checked)
            {
                para = item.get_Parameter(BuiltInParameter.RBS_CURVE_HEIGHT_PARAM);
                listMsg.Add(para.Set(UnitConvert.CovertToAPI(Convert.ToDouble(this.txtHeight.Text), DisplayUnitType.DUT_MILLIMETERS)));
            }
        }
        /// <summary>
        /// 宽度或直径改变，速度跟着变化
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void txtWidthorDiameter_Leave(object sender, EventArgs e)
        {
            if (!Regex.IsMatch(this.txtWidthorDiameter.Text, @"^[1-9]+\d*$"))
            {
                MessageBox.Show("宽度或直径必须是正整数！", "信息提示", MessageBoxButtons.OK, MessageBoxIcon.Information);
                return;
            }// 验证宽度或直径必须是整数
            CalculateSpeed();// 计算速度值，并赋值到速度文本框内
        }
        /// <summary>
        /// 计算速度值，并赋值到速度文本框内
        /// </summary>
        private void CalculateSpeed()
        {
            try
            {
                double flux = Convert.ToDouble(this.txtFlux.Text);//流量
                double width = 0;
                double height = 0;
                double area = 0;
                switch (this.txtSectionType.Text)
                {
                    case "矩形风管":
                        width = Convert.ToDouble(this.txtWidthorDiameter.Text)/1000.0;
                        height = Convert.ToDouble(this.txtHeight.Text)/1000.0;
                        area = width * height;
                        break;
                    case "椭圆形风管":
                        width = Convert.ToDouble(this.txtWidthorDiameter.Text)/1000.0;
                        height = Convert.ToDouble(this.txtHeight.Text)/1000.0;
                        area = Math.PI * width * height / 4.0;
                        break;
                    case "圆形风管":
                        double diameter = Convert.ToDouble(this.txtWidthorDiameter.Text)/1000.0;
                        area = Math.PI * diameter * diameter / 4.0;
                        break;
                    default:
                        break;
                }
                double speed = flux/3600 / area;
                this.txtSpeed.Text=Convert.ToString(speed);
            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.Message);
            }
        }
        /// <summary>
        /// 高度改变，速度跟着变化
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void txtHeight_Leave(object sender, EventArgs e)
        {
            if (!Regex.IsMatch(this.txtHeight.Text, @"^[1-9]+\d*$"))
            {
                MessageBox.Show("高度必须是正整数！", "信息提示", MessageBoxButtons.OK, MessageBoxIcon.Information);
                return;
            }// 验证高度必须是整数
            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 DuctLevel
    {
        public string LevelName { get; set; }
        public ElementId LevelId { get; set; }
    }
    /// <summary>
    /// 风管系统类型
    /// </summary>
    public class DuctSysType
    {
        public string SysTypeName { get; set; }
        public ElementId SysTypeId { get; set; }
    }