internal static IList <FamilyInstance> GetAllRebarsInDoc(Document doc) { System.Func <Document, IList <FamilyInstance> > GetAllRebars = d => { ElementParameterFilter shpFamNameFilter = new ElementParameterFilter(ParameterFilterRuleFactory.CreateBeginsWithRule( new ElementId(BuiltInParameter.ELEM_FAMILY_PARAM), "R-SHP", false)); ElementParameterFilter empFamNameFilter = new ElementParameterFilter( ParameterFilterRuleFactory.CreateBeginsWithRule( new ElementId(BuiltInParameter.ELEM_FAMILY_PARAM), "R-EMP", false)); List <ElementFilter> filters = new List <ElementFilter>() { shpFamNameFilter, empFamNameFilter }; LogicalOrFilter shpEmpFilter = new LogicalOrFilter(filters); return(new FilteredElementCollector(d) .OfCategory(BuiltInCategory.OST_DetailComponents) .WhereElementIsNotElementType() .WherePasses(shpEmpFilter) .Cast <FamilyInstance>() .Where(fi => fi.LookupParameter(IS_SPECIFIABLE).AsInteger() == 1) .ToList()); }; return(GetAllRebars(doc)); }
private ElementId FindTemplateByViewNameEnding(string viewNameEnding) { const int PARTITION_PARAMETER_ID = 2698521; ElementId partitionParamId = new ElementId(PARTITION_PARAMETER_ID); ElementParameterFilter viewNameFilter = new ElementParameterFilter( ParameterFilterRuleFactory .CreateEndsWithRule( new ElementId(BuiltInParameter.VIEW_NAME), viewNameEnding, false)); ElementParameterFilter partitionFilter = new ElementParameterFilter( ParameterFilterRuleFactory .CreateBeginsWithRule(partitionParamId, "#Стандарт", false)); LogicalAndFilter andFilter = new LogicalAndFilter(viewNameFilter, partitionFilter); return (new FilteredElementCollector(m_doc) .OfCategory(BuiltInCategory.OST_Schedules) .WherePasses(andFilter) .ToElementIds() .FirstOrDefault()); }
private ElementId FindScheduleByName(string scheduleName) { ElementParameterFilter viewNameFilter = new ElementParameterFilter( ParameterFilterRuleFactory .CreateBeginsWithRule( new ElementId(BuiltInParameter.VIEW_NAME), scheduleName, false)); return (new FilteredElementCollector(m_doc) .OfCategory(BuiltInCategory.OST_Schedules) .WherePasses(viewNameFilter) .ToElementIds() .FirstOrDefault()); }
ViewSchedule FindScheduleByName(Document doc, string scheduleName) { ElementParameterFilter viewNameFilter = new ElementParameterFilter( ParameterFilterRuleFactory .CreateBeginsWithRule( new ElementId(BuiltInParameter.VIEW_NAME), scheduleName, false)); return (new FilteredElementCollector(doc) .OfClass(typeof(ViewSchedule)) .WherePasses(viewNameFilter) .Cast <ViewSchedule>() .FirstOrDefault()); }
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); } }
IList <ViewSchedule> GetNecessarySchedules(Document doc, string scheduleCode) { ElementParameterFilter viewNameFilter = new ElementParameterFilter( ParameterFilterRuleFactory .CreateBeginsWithRule( new ElementId(BuiltInParameter.VIEW_NAME), scheduleCode, false)); return (new FilteredElementCollector(doc) .OfClass(typeof(ViewSchedule)) .WherePasses(viewNameFilter) .Cast <ViewSchedule>() .OrderBy(vs => vs.ViewName) .ToList()); }
public static void CreateViewFilter(Document doc, View view) { List <ElementId> categories = new List <ElementId>(); categories.Add(new ElementId(BuiltInCategory.OST_Walls)); List <FilterRule> filterRules = new List <FilterRule>(); try { // Create filter element associated to the input categories ParameterFilterElement parameterFilterElement = ParameterFilterElement.Create(doc, "Example view filter", categories); // Criterion 1 - wall type Function is "Exterior" ElementId exteriorParamId = new ElementId(BuiltInParameter.FUNCTION_PARAM); filterRules.Add(ParameterFilterRuleFactory.CreateEqualsRule(exteriorParamId, (int)WallFunction.Exterior)); // Criterion 2 - wall height > some number ElementId lengthId = new ElementId(BuiltInParameter.CURVE_ELEM_LENGTH); filterRules.Add(ParameterFilterRuleFactory.CreateGreaterOrEqualRule(lengthId, 28.0, 0.0001)); // Criterion 3 - custom shared parameter value matches string pattern // Get the id for the shared parameter - the ElementId is not hardcoded, so we need to get an instance of this type to find it Guid spGuid = new Guid("96b00b61-7f5a-4f36-a828-5cd07890a02a"); FilteredElementCollector collector = new FilteredElementCollector(doc); collector.OfClass(typeof(Wall)); Wall wall = collector.FirstElement() as Wall; if (wall != null) { Parameter sharedParam = wall.get_Parameter(spGuid); ElementId sharedParamId = sharedParam.Id; filterRules.Add(ParameterFilterRuleFactory.CreateBeginsWithRule(sharedParamId, "15.", true)); } parameterFilterElement.SetRules(filterRules); // Apply filter to view view.AddFilter(parameterFilterElement.Id); view.SetFilterVisibility(parameterFilterElement.Id, false); } catch { } }
internal static IList <ElementId> GetAllRebarIdsInView(View view) { ElementParameterFilter shpFamNameFilter = new ElementParameterFilter( ParameterFilterRuleFactory.CreateBeginsWithRule( new ElementId(BuiltInParameter.ELEM_FAMILY_PARAM), "R-SHP", false)); ElementParameterFilter sumFamNameFilter = new ElementParameterFilter( ParameterFilterRuleFactory.CreateBeginsWithRule( new ElementId(BuiltInParameter.ELEM_FAMILY_PARAM), "R-SUM", false)); ElementParameterFilter empFamNameFilter = new ElementParameterFilter( ParameterFilterRuleFactory.CreateBeginsWithRule( new ElementId(BuiltInParameter.ELEM_FAMILY_PARAM), "R-EMP", false)); List <ElementFilter> filters = new List <ElementFilter>() { shpFamNameFilter, sumFamNameFilter, empFamNameFilter }; LogicalOrFilter shpSumEmpFilter = new LogicalOrFilter(filters); return(new FilteredElementCollector(view.Document, view.Id) .OfCategory(BuiltInCategory.OST_DetailComponents) .WhereElementIsNotElementType() .WherePasses(shpSumEmpFilter) .ToElementIds() .ToList()); }
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); }
internal static IList <Element> GetAllRebars (Document doc, string partition = null, string hostMark = null, IList <string> assemblies = null) { // Dig out all families beginning with R-SHP and R-EMP ElementParameterFilter shpFamNameFltr = new ElementParameterFilter( ParameterFilterRuleFactory .CreateBeginsWithRule( new ElementId(BuiltInParameter.ELEM_FAMILY_PARAM), "R-SHP", false)); ElementParameterFilter empFamNameFltr = new ElementParameterFilter( ParameterFilterRuleFactory .CreateBeginsWithRule( new ElementId(BuiltInParameter.ELEM_FAMILY_PARAM), "R-EMP", false)); List <ElementFilter> nameFilters = new List <ElementFilter>() { shpFamNameFltr, empFamNameFltr }; LogicalOrFilter orNames = new LogicalOrFilter(nameFilters); // Select all rebars before sorting through them // provided that ancillary parameters are supplied FilteredElementCollector collector = new FilteredElementCollector(doc); IList <Element> allRebars = collector .OfCategory(BuiltInCategory.OST_DetailComponents) .WhereElementIsNotElementType() .WherePasses(orNames) .Where(e => e.LookupParameter(IS_SPECIFIABLE).AsInteger() == 1) .ToList(); Trace.Write("All rebars dug up = " + allRebars.Count); if (partition == null && hostMark == null && assemblies == null) { return(allRebars); } else { if (allRebars.Count == 0) { return(allRebars); } else { IList <Element> partFilteredRebars = new List <Element>(); // Filter out the rebars by partition if (partition != null) { IEnumerator <Element> itr = allRebars.GetEnumerator(); while (itr.MoveNext()) { if (itr.Current.LookupParameter(PARTITION).AsString().Equals(partition)) { partFilteredRebars.Add(itr.Current); } } Trace.Write("By partition: " + partFilteredRebars.Count); if (hostMark == null && assemblies == null) { return(partFilteredRebars); } else if (hostMark == null && assemblies != null) { SelectByAssemblyMarks(partFilteredRebars, assemblies); return(partFilteredRebars); } else { // Filter out the rebars by host mark IList <Element> partHostFilteredRebars = new List <Element>(); itr = partFilteredRebars.GetEnumerator(); while (itr.MoveNext()) { if (itr.Current.LookupParameter(HOST_MARK).AsString().Equals(hostMark)) { partHostFilteredRebars.Add(itr.Current); } } Trace.Write("By partition and host mark: " + partHostFilteredRebars.Count); if (assemblies == null) { return(partHostFilteredRebars); } else { // Filter out the rebars by assembly SelectByAssemblyMarks(partHostFilteredRebars, assemblies); return(partHostFilteredRebars); } } } return(partFilteredRebars.ToList()); } } }
public static FilterRule CreateRule(MyParameter mp, CriteriaType ctype) { Parameter param = mp.RevitParameter; FilterRule rule = null; if (ctype == CriteriaType.Equals) { switch (param.StorageType) { case StorageType.None: break; case StorageType.Integer: rule = ParameterFilterRuleFactory.CreateEqualsRule(param.Id, mp.AsInteger()); break; case StorageType.Double: rule = ParameterFilterRuleFactory.CreateEqualsRule(param.Id, mp.AsDouble(), 0.0001); break; case StorageType.String: string val = mp.AsString(); if (val == null) { break; } rule = ParameterFilterRuleFactory.CreateEqualsRule(param.Id, val, true); break; case StorageType.ElementId: rule = ParameterFilterRuleFactory.CreateEqualsRule(param.Id, mp.AsElementId()); break; default: break; } } if (ctype == CriteriaType.StartsWith) { switch (param.StorageType) { case StorageType.None: break; case StorageType.String: string val = mp.AsString(); if (val == null) { break; } rule = ParameterFilterRuleFactory.CreateBeginsWithRule(param.Id, val, true); break; default: break; } } if (rule == null) { throw new Exception("Не удалось создать правило фильтра"); } return(rule); }
public Result Execute(ExternalCommandData commandData, ref string message, ElementSet elements) { Document doc = commandData.Application.ActiveUIDocument.Document; // Door variables. string doorName = string.Empty; string itemType = string.Empty; string doorType = string.Empty; int height = 0; int width = 0; string props = string.Empty; // Find the right door family. FilteredElementCollector collector = new FilteredElementCollector(doc); FilterRule famNameRule = ParameterFilterRuleFactory .CreateBeginsWithRule( new ElementId((int)BuiltInParameter.ALL_MODEL_FAMILY_NAME), "A-M3-ConceptualDoor", true); FilterRule typeNameRule = ParameterFilterRuleFactory .CreateEqualsRule( new ElementId((int)BuiltInParameter.ALL_MODEL_TYPE_NAME), "Default", true); ElementParameterFilter famNameFlt = new ElementParameterFilter(famNameRule); ElementParameterFilter typeNameFlt = new ElementParameterFilter(typeNameRule); LogicalAndFilter andFilter = new LogicalAndFilter(famNameFlt, typeNameFlt); Func <FamilySymbol, bool> singleLeaf = (fs) => fs.FamilyName == "A-M3-ConceptualDoorSingleLeaf-LOD2"; Func <FamilySymbol, bool> doubleLeaf = (fs) => fs.FamilyName == "A-M3-ConceptualDoorDoubleLeaf-LOD2"; IEnumerable <FamilySymbol> doors = collector .OfCategory(BuiltInCategory.OST_Doors) .WhereElementIsElementType() .WherePasses(andFilter) .Cast <FamilySymbol>(); FamilySymbol singleLeafDoor = doors .Where(singleLeaf) .FirstOrDefault(); FamilySymbol doubleLeafDoor = doors .Where(doubleLeaf) .FirstOrDefault(); if (singleLeafDoor == null) { TaskDialog.Show("No door family", "Please load the family: A-M3-ConceptualDoorSingleLeaf-LOD2"); return(Result.Failed); } // Show the custom window RussianDoorWnd win = new RussianDoorWnd(); win.btnCreate.Click += delegate(object sender, RoutedEventArgs e) { doorName = win.lbg6629.Content.ToString(); itemType = ((ComboBoxItem)win.itemType.SelectedItem).Content.ToString(); doorType = ((ComboBoxItem)win.doorType.SelectedItem).Content.ToString(); height = Int16.Parse((string)((ComboBoxItem)win.height.SelectedItem).Content) * 100; width = Int16.Parse((string)((ComboBoxItem)win.width.SelectedItem).Content) * 100; props = ((ComboBoxItem)win.props.SelectedItem).Content.ToString(); win.Close(); try { using (TransactionGroup tg = new TransactionGroup(doc, "Create new type")) { ElementType newType; tg.Start(); using (Transaction t1 = new Transaction(doc, "Create new type")) { t1.Start(); if (width <= 1200) { newType = singleLeafDoor.Duplicate(doorName); } else { newType = doubleLeafDoor.Duplicate(doorName); } t1.Commit(); } using (Transaction t2 = new Transaction(doc, "Set params")) { t2.Start(); switch (doorType) { case "Г": newType.LookupParameter("Solid Leaf").Set(1); newType.LookupParameter("Glazed Leaf").Set(0); newType.LookupParameter("Leaf with Vent Grille").Set(0); break; case "О": newType.LookupParameter("Solid Leaf").Set(0); newType.LookupParameter("Glazed Leaf").Set(1); newType.LookupParameter("Leaf with Vent Grille").Set(0); break; } newType.LookupParameter("Door Leaf Height") .Set(RvtCnvt.ConvertToInternalUnits((height - 100), DisplayUnitType.DUT_MILLIMETERS)); newType.LookupParameter("Door Leaf Width") .Set(RvtCnvt.ConvertToInternalUnits((width - 100), DisplayUnitType.DUT_MILLIMETERS)); if (props.Contains('Л')) { newType.LookupParameter("RH").Set(0); } else { newType.LookupParameter("RH").Set(1); } if (props.Contains('П')) { newType.LookupParameter("Threshold").Set(1); } else { newType.LookupParameter("Threshold").Set(0); } t2.Commit(); } tg.Assimilate(); } } catch (Autodesk.Revit.Exceptions.ArgumentException ex) { if (ex.ParamName == "name") { TaskDialog.Show("ArgumentError", string.Format("This type already exists.")); } } catch (Exception ex) { TaskDialog.Show("Exception", ex.StackTrace); } }; win.ShowDialog(); return(Result.Succeeded); }