private static void SetReadonlyCosts(Document doc, Func <Element, int, double> valueGetter)
        {
            FilteredElementCollector collector = new FilteredElementCollector(doc);

            collector.WhereElementIsElementType();
            FilterRule             rule   = ParameterFilterRuleFactory.CreateSharedParameterApplicableRule("ReadonlyCost");
            ElementParameterFilter filter = new ElementParameterFilter(rule);

            collector.WherePasses(filter);

            int increment = 1;

            using (Transaction t = new Transaction(doc, "Apply ReadonlyCost"))
            {
                t.Start();
                foreach (Element elem in collector)
                {
                    Parameter p = elem.LookupParameter("ReadonlyCost");
                    if (p != null)
                    {
                        p.Set(valueGetter(elem, increment));
                    }
                    increment++;
                }
                t.Commit();
            }
        }
Beispiel #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);
            }
        }
        private static void SetReadonlyIds(Document doc, Func <Element, string> idGetter)
        {
            FilteredElementCollector collector = new FilteredElementCollector(doc);
            FilterRule             rule        = ParameterFilterRuleFactory.CreateSharedParameterApplicableRule("ReadonlyId");
            ElementParameterFilter filter      = new ElementParameterFilter(rule);

            collector.WherePasses(filter);

            using (Transaction t = new Transaction(doc, "Apply ReadonlyId"))
            {
                t.Start();
                foreach (Element elem in collector)
                {
                    Parameter p = elem.LookupParameter("ReadonlyId");
                    if (p != null)
                    {
                        p.Set(idGetter(elem));
                    }
                }
                t.Commit();
            }
        }