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);
}
