///// <summary> ///// ///// </summary> ///// <param name="filterRules"></param> ///// <param name="inverted"></param> ///// <returns></returns> //public static revitDB.ElementFilter FilterElementParameter(IList<revitDB.FilterRule> filterRules, bool inverted) //{ // return new revitDB.ElementParameterFilter(filterRules, inverted); //} /// <summary> /// /// </summary> /// <param name="parameterId"></param> /// <param name="value"></param> /// <param name="inverted"></param> /// <returns></returns> //public static revitDB.ElementFilter FilterElementParameterStringEquals(int parameterId, string value, bool inverted) //{ // revitDB.ParameterValueProvider provider = new revitDB.ParameterValueProvider(new revitDB.ElementId(parameterId)); // revitDB.FilterStringRuleEvaluator evaluator = new revitDB.FilterStringEquals(); // revitDB.FilterRule filterRule = new revitDB.FilterStringRule(provider, evaluator, value, false); // return new revitDB.ElementParameterFilter(filterRule, inverted); //} /// <summary> /// Creates a ElementFilter that passes elements with a string based parameter that match the provided FilterStringRuleEvaluator. The filter should then be passed to a Collector node and the Collector retrieves elements that pass the filter. /// </summary> /// <param name="parameterId">The ElementId as an int of the parameter to search.</param> /// <param name="value">Value of the parameter to search for.</param> /// <param name="filterStringRule">Revit FilterStringRuleEvaluator that determines how to search the parameter.</param> /// <param name="inverted">If true, the filter elements NOT matching the filter criteria are chosen.</param> /// <returns name="ElementFilter">An Element Filter. The filter should then be passed to a Collector node and the Collector retrieves elements that pass the filter.</returns> public static revitDB.ElementFilter FilterElementStringParameter( int parameterId, string value, revitDB.FilterStringRuleEvaluator filterStringRule, [DefaultArgument("false")] bool inverted) { revitDB.ParameterValueProvider provider = new revitDB.ParameterValueProvider(new revitDB.ElementId(parameterId)); if (filterStringRule != null) { revitDB.FilterRule filterRule = new revitDB.FilterStringRule(provider, filterStringRule, value, false); return(new revitDB.ElementParameterFilter(filterRule, inverted)); } else { return(null); } }
internal static bool TryGetFilterStringParam(DB.BuiltInParameter paramId, ref string pattern, out DB.ElementFilter filter) { if (pattern is string subPattern) { var inverted = false; var method = Operator.CompareMethodFromPattern(ref subPattern, ref inverted); if (Operator.CompareMethod.Nothing < method && method < Operator.CompareMethod.Wildcard) { var evaluator = default(DB.FilterStringRuleEvaluator); switch (method) { case Operator.CompareMethod.Equals: evaluator = new DB.FilterStringEquals(); break; case Operator.CompareMethod.StartsWith: evaluator = new DB.FilterStringBeginsWith(); break; case Operator.CompareMethod.EndsWith: evaluator = new DB.FilterStringEndsWith(); break; case Operator.CompareMethod.Contains: evaluator = new DB.FilterStringContains(); break; } var rule = new DB.FilterStringRule ( new DB.ParameterValueProvider(new DB.ElementId(paramId)), evaluator, subPattern, true ); filter = new DB.ElementParameterFilter(rule, inverted); pattern = default; return(true); } } filter = default; return(false); }
protected override void TrySolveInstance(IGH_DataAccess DA) { var parameterKey = default(Types.ParameterKey); if (!DA.GetData("ParameterKey", ref parameterKey)) { return; } DA.DisableGapLogic(); if (!TryGetParameterDefinition(parameterKey.Document, parameterKey.Id, out var storageType, out var parameterType)) { if (parameterKey.Id.TryGetBuiltInParameter(out var builtInParameter)) { AddRuntimeMessage(GH_RuntimeMessageLevel.Warning, $"Failed to found parameter '{DB.LabelUtils.GetLabelFor(builtInParameter)}' in Revit document."); } else { AddRuntimeMessage(GH_RuntimeMessageLevel.Warning, $"Failed to found parameter '{parameterKey.Id.IntegerValue}' in Revit document."); } return; } var provider = new DB.ParameterValueProvider(parameterKey); DB.FilterRule rule = null; if (storageType == DB.StorageType.String) { DB.FilterStringRuleEvaluator ruleEvaluator = null; switch (Condition) { case ConditionType.NotEquals: case ConditionType.Equals: ruleEvaluator = new DB.FilterStringEquals(); break; case ConditionType.Greater: ruleEvaluator = new DB.FilterStringGreater(); break; case ConditionType.GreaterOrEqual: ruleEvaluator = new DB.FilterStringGreaterOrEqual(); break; case ConditionType.Less: ruleEvaluator = new DB.FilterStringLess(); break; case ConditionType.LessOrEqual: ruleEvaluator = new DB.FilterStringLessOrEqual(); break; } var goo = default(GH_String); if (DA.GetData("Value", ref goo)) { rule = new DB.FilterStringRule(provider, ruleEvaluator, goo.Value, true); } } else { DB.FilterNumericRuleEvaluator ruleEvaluator = null; switch (Condition) { case ConditionType.NotEquals: case ConditionType.Equals: ruleEvaluator = new DB.FilterNumericEquals(); break; case ConditionType.Greater: ruleEvaluator = new DB.FilterNumericGreater(); break; case ConditionType.GreaterOrEqual: ruleEvaluator = new DB.FilterNumericGreaterOrEqual(); break; case ConditionType.Less: ruleEvaluator = new DB.FilterNumericLess(); break; case ConditionType.LessOrEqual: ruleEvaluator = new DB.FilterNumericLessOrEqual(); break; } switch (storageType) { case DB.StorageType.Integer: { var goo = default(GH_Integer); if (DA.GetData("Value", ref goo)) { rule = new DB.FilterIntegerRule(provider, ruleEvaluator, goo.Value); } } break; case DB.StorageType.Double: { var goo = default(GH_Number); if (DA.GetData("Value", ref goo)) { if (Condition == ConditionType.Equals || Condition == ConditionType.NotEquals) { if (parameterType == DB.ParameterType.Length || parameterType == DB.ParameterType.Area || parameterType == DB.ParameterType.Volume) { rule = new DB.FilterDoubleRule(provider, ruleEvaluator, ToHost(goo.Value, parameterType), ToHost(Revit.VertexTolerance, parameterType)); } else { rule = new DB.FilterDoubleRule(provider, ruleEvaluator, ToHost(goo.Value, parameterType), 1e-6); } } else { rule = new DB.FilterDoubleRule(provider, ruleEvaluator, ToHost(goo.Value, parameterType), 0.0); } } } break; case DB.StorageType.ElementId: { switch (parameterType) { case (DB.ParameterType) int.MaxValue: // Category { var value = default(Types.Category); if (DA.GetData("Value", ref value)) { rule = new DB.FilterElementIdRule(provider, ruleEvaluator, value); } } break; case DB.ParameterType.Material: { var value = default(Types.Material); if (DA.GetData("Value", ref value)) { rule = new DB.FilterElementIdRule(provider, ruleEvaluator, value); } } break; case DB.ParameterType.FamilyType: { var value = default(Types.ElementType); if (DA.GetData("Value", ref value)) { rule = new DB.FilterElementIdRule(provider, ruleEvaluator, value); } } break; default: { var value = default(Types.Element); if (DA.GetData("Value", ref value)) { rule = new DB.FilterElementIdRule(provider, ruleEvaluator, value); } } break; } } break; } } if (rule is object) { if (Condition == ConditionType.NotEquals) { DA.SetData("Rule", new DB.FilterInverseRule(rule)); } else { DA.SetData("Rule", rule); } } }