Exemplo n.º 1
0
        private static FilterRule CreateRule(ElementId ParameterId, string Function, ElementId ValueId)
        {
            switch (Function)
            {
            case "Равно":
                return(ParameterFilterRuleFactory.CreateEqualsRule(ParameterId, ValueId));

            case "Не равно":
                return(ParameterFilterRuleFactory.CreateNotEqualsRule(ParameterId, ValueId));

            case "Больше":
                return(ParameterFilterRuleFactory.CreateGreaterRule(ParameterId, ValueId));

            case "Больше или равно":
                return(ParameterFilterRuleFactory.CreateLessOrEqualRule(ParameterId, ValueId));

            case "Меньше":
                return(ParameterFilterRuleFactory.CreateLessRule(ParameterId, ValueId));

            case "Меньше или равно":
                return(ParameterFilterRuleFactory.CreateLessOrEqualRule(ParameterId, ValueId));

            default:
                return(null);
            }
        }
Exemplo n.º 2
0
        private static FilterRule CreateRule(ElementId ParameterId, string Function, string Value)
        {
            switch (Function)
            {
            case "Равно":
                return(ParameterFilterRuleFactory.CreateEqualsRule(ParameterId, Value, true));

            case "Не равно":
                return(ParameterFilterRuleFactory.CreateNotEqualsRule(ParameterId, Value, true));

            case "Больше":
                return(ParameterFilterRuleFactory.CreateGreaterRule(ParameterId, Value, true));

            case "Больше или равно":
                return(ParameterFilterRuleFactory.CreateLessOrEqualRule(ParameterId, Value, true));

            case "Меньше":
                return(ParameterFilterRuleFactory.CreateLessRule(ParameterId, Value, true));

            case "Меньше или равно":
                return(ParameterFilterRuleFactory.CreateLessOrEqualRule(ParameterId, Value, true));

            case "Содержит":
                return(ParameterFilterRuleFactory.CreateContainsRule(ParameterId, Value, true));

            case "Не содержит":
                return(ParameterFilterRuleFactory.CreateNotContainsRule(ParameterId, Value, true));

            case "Начинается с":
                return(ParameterFilterRuleFactory.CreateBeginsWithRule(ParameterId, Value, true));

            case "Не начинается с":
                return(ParameterFilterRuleFactory.CreateNotBeginsWithRule(ParameterId, Value, true));

            case "Заканчивается на":
                return(ParameterFilterRuleFactory.CreateEndsWithRule(ParameterId, Value, true));

            case "Не заканчивается на":
                return(ParameterFilterRuleFactory.CreateNotEndsWithRule(ParameterId, Value, true));

            case "Поддерживает":
                return(ParameterFilterRuleFactory.CreateSharedParameterApplicableRule(Value));

            default:
                return(null);
            }
        }
Exemplo n.º 3
0
        public Result Execute(ExternalCommandData commandData, ref string message, ElementSet elements)
        {
            //FilterElementCollect的使用
            UIDocument uiDoc = commandData.Application.ActiveUIDocument;
            Document   doc   = uiDoc.Document;
            FilteredElementCollector collector = new FilteredElementCollector(doc);

            //QuickFilter过滤所有窗
            collector = collector.OfCategory(BuiltInCategory.OST_Windows).OfClass(typeof(FamilySymbol));
            //FamilyInstanceFilter找1200*1500mm的窗
            IEnumerable <Element> query = from element in collector
                                          where element.Name == "1200*1500mm"
                                          select element;
            List <Element>           famSyms  = query.ToList <Element>();
            ElementId                symbolId = famSyms[1].Id;
            FamilyInstanceFilter     fiFilter = new FamilyInstanceFilter(doc, symbolId);
            FilteredElementCollector c1       = new FilteredElementCollector(doc);
            ICollection <Element>    found    = c1.WherePasses(fiFilter).ToElements();
            //ElementParameterFilter找到标记小于五的窗
            ElementId                ruleValId = new ElementId(-10010203);
            FilterRule               fr        = ParameterFilterRuleFactory.CreateLessRule(ruleValId, "5", true);
            ElementParameterFilter   pFilter   = new ElementParameterFilter(fr);
            FilteredElementCollector c2        = new FilteredElementCollector(doc);

            c2 = c2.OfCategory(BuiltInCategory.OST_Windows).WherePasses(fiFilter).WherePasses(pFilter);
            //LogicalOrFilter计算门窗总和
            ElementCategoryFilter    doorFilter   = new ElementCategoryFilter(BuiltInCategory.OST_Doors);
            ElementCategoryFilter    windowFilter = new ElementCategoryFilter(BuiltInCategory.OST_Windows);
            LogicalOrFilter          lFilter      = new LogicalOrFilter(doorFilter, windowFilter);
            FilteredElementCollector c3           = new FilteredElementCollector(doc);
            ICollection <Element>    fds          = c3.OfClass(typeof(FamilyInstance)).WherePasses(lFilter).ToElements();

            //taskdialog输出结果
            TaskDialog.Show("查找", "已找到型号为“1200*1500mm”的推拉窗" + found.Count.ToString() +
                            "个\n其中标记小于5的有" + c2.ToList().Count.ToString() + "个\n门窗总和为:" +
                            fds.Count.ToString());

            return(Result.Succeeded);
        }
Exemplo n.º 4
0
        public static Autodesk.Revit.DB.FilterRule GetElementIdRule(ElementId paramId, CriteriaName selectedCriteria, ElementId ruleValue)
        {
            Autodesk.Revit.DB.FilterRule rule = null;
            try
            {
                switch (selectedCriteria)
                {
                case CriteriaName.equals:
                    rule = ParameterFilterRuleFactory.CreateEqualsRule(paramId, ruleValue);
                    break;

                case CriteriaName.isgreaterthan:
                    rule = ParameterFilterRuleFactory.CreateGreaterRule(paramId, ruleValue);
                    break;

                case CriteriaName.isgreaterthanorequalto:
                    rule = ParameterFilterRuleFactory.CreateGreaterOrEqualRule(paramId, ruleValue);
                    break;

                case CriteriaName.islessthan:
                    rule = ParameterFilterRuleFactory.CreateLessRule(paramId, ruleValue);
                    break;

                case CriteriaName.islessthanorequalto:
                    rule = ParameterFilterRuleFactory.CreateLessOrEqualRule(paramId, ruleValue);
                    break;

                case CriteriaName.doesnotequal:
                    rule = ParameterFilterRuleFactory.CreateNotEqualsRule(paramId, ruleValue);
                    break;
                }
            }
            catch (Exception ex)
            {
                System.Windows.MessageBox.Show("Failed to get integer filter rule.\n" + ex.Message, "Get Integer Filter Rule", MessageBoxButton.OK, MessageBoxImage.Warning);
            }
            return(rule);
        }
Exemplo n.º 5
0
        public static Autodesk.Revit.DB.FilterRule GetStringRule(ElementId paramId, CriteriaName selectedCriteria, string ruleValue)
        {
            Autodesk.Revit.DB.FilterRule rule = null;
            try
            {
                switch (selectedCriteria)
                {
                case CriteriaName.beginswith:
                    rule = ParameterFilterRuleFactory.CreateBeginsWithRule(paramId, ruleValue, false);
                    break;

                case CriteriaName.contains:
                    rule = ParameterFilterRuleFactory.CreateContainsRule(paramId, ruleValue, false);
                    break;

                case CriteriaName.endswith:
                    rule = ParameterFilterRuleFactory.CreateEndsWithRule(paramId, ruleValue, false);
                    break;

                case CriteriaName.equals:
                    rule = ParameterFilterRuleFactory.CreateEqualsRule(paramId, ruleValue, false);
                    break;

                case CriteriaName.isgreaterthan:
                    rule = ParameterFilterRuleFactory.CreateGreaterRule(paramId, ruleValue, false);
                    break;

                case CriteriaName.isgreaterthanorequalto:
                    rule = ParameterFilterRuleFactory.CreateGreaterOrEqualRule(paramId, ruleValue, false);
                    break;

                case CriteriaName.islessthan:
                    rule = ParameterFilterRuleFactory.CreateLessRule(paramId, ruleValue, false);
                    break;

                case CriteriaName.islessthanorequalto:
                    rule = ParameterFilterRuleFactory.CreateLessOrEqualRule(paramId, ruleValue, false);
                    break;

                case CriteriaName.doesnotbeginwith:
                    rule = ParameterFilterRuleFactory.CreateNotBeginsWithRule(paramId, ruleValue, false);
                    break;

                case CriteriaName.doesnotcontain:
                    rule = ParameterFilterRuleFactory.CreateNotContainsRule(paramId, ruleValue, false);
                    break;

                case CriteriaName.doesnotendwith:
                    rule = ParameterFilterRuleFactory.CreateNotEndsWithRule(paramId, ruleValue, false);
                    break;

                case CriteriaName.doesnotequal:
                    rule = ParameterFilterRuleFactory.CreateNotEqualsRule(paramId, ruleValue, false);
                    break;
                }
            }
            catch (Exception ex)
            {
                System.Windows.MessageBox.Show("Failed to get string filter rule.\n" + ex.Message, "Get String Filter Rule", MessageBoxButton.OK, MessageBoxImage.Warning);
            }
            return(rule);
        }