/// <summary>
/// Gets element filter meeting design option requirements.
/// </summary>
/// <returns>The element filter.</returns>
private static ElementFilter GetDesignOptionFilter()
{
ElementFilter designOptionFilter = new ElementDesignOptionFilter(ElementId.InvalidElementId);
ElementFilter primaryOptionsFilter = new PrimaryDesignOptionMemberFilter();
return(new LogicalOrFilter(designOptionFilter, primaryOptionsFilter));
}
/// <summary>
/// Gets element filter meeting design option requirements.
/// </summary>
/// <returns>The element filter.</returns>
private static ElementFilter GetDesignOptionFilter()
{
// We will respect the active design option if we are exporting a specific view.
ElementFilter noDesignOptionFilter = new ElementDesignOptionFilter(ElementId.InvalidElementId);
ElementFilter primaryOptionsFilter = new PrimaryDesignOptionMemberFilter();
ElementFilter designOptionFilter = new LogicalOrFilter(noDesignOptionFilter, primaryOptionsFilter);
View filterView = ExporterCacheManager.ExportOptionsCache.FilterViewForExport;
if (filterView != null)
{
ElementId designOptionId = DesignOption.GetActiveDesignOptionId(ExporterCacheManager.Document);
if (designOptionId != ElementId.InvalidElementId)
{
ElementFilter activeDesignOptionFilter = new ElementDesignOptionFilter(designOptionId);
return new LogicalOrFilter(designOptionFilter, activeDesignOptionFilter);
}
}
return designOptionFilter;
}
/// <summary>
/// Gets element filter meeting design option requirements.
/// </summary>
/// <returns>The element filter.</returns>
private static ElementFilter GetDesignOptionFilter()
{
ElementFilter designOptionFilter = new ElementDesignOptionFilter(ElementId.InvalidElementId);
ElementFilter primaryOptionsFilter = new PrimaryDesignOptionMemberFilter();
return new LogicalOrFilter(designOptionFilter, primaryOptionsFilter);
}
/// <summary>
/// Gets element filter meeting design option requirements.
/// </summary>
/// <returns>The element filter.</returns>
private static ElementFilter GetDesignOptionFilter()
{
// We will respect the active design option if we are exporting a specific view.
ElementFilter noDesignOptionFilter = new ElementDesignOptionFilter(ElementId.InvalidElementId);
ElementFilter primaryOptionsFilter = new PrimaryDesignOptionMemberFilter();
ElementFilter designOptionFilter = new LogicalOrFilter(noDesignOptionFilter, primaryOptionsFilter);
View filterView = ExporterCacheManager.ExportOptionsCache.FilterViewForExport;
if (filterView != null)
{
ElementId designOptionId = DesignOption.GetActiveDesignOptionId(ExporterCacheManager.Document);
if (designOptionId != ElementId.InvalidElementId)
{
ElementFilter activeDesignOptionFilter = new ElementDesignOptionFilter(designOptionId);
return new LogicalOrFilter(designOptionFilter, activeDesignOptionFilter);
}
}
return designOptionFilter;
}
private List <Element> getHosts()
{
LogicalOrFilter dof = null;
var mainModelFilter = new ElementDesignOptionFilter(ElementId.InvalidElementId);
//if search main model, search main options as well
if (this.designOption == null)
{
var primaryDopFilter = new PrimaryDesignOptionMemberFilter();
dof = new LogicalOrFilter(mainModelFilter, primaryDopFilter);
}
else
{
var activeDoFilter = new ElementDesignOptionFilter(DesignOption.GetActiveDesignOptionId(this.Doc));
dof = new LogicalOrFilter(activeDoFilter, mainModelFilter);
}
if (this.HostCategory == HostCategory.Wall)
{
var wallCollector = new FilteredElementCollector(this.Doc)
.WhereElementIsNotElementType()
.OfClass(typeof(Wall))
.WherePasses(this.Filter)
.WherePasses(dof)
.Cast <Wall>()
.Where(x => x.WallType.Kind == WallKind.Basic);
if (this.hostDir != null)
{
wallCollector = wallCollector
.Where(x => x.LocationCurve() is Line &&
x.LocationLine().Direction.IsParallel(this.hostDir));
}
return(wallCollector
.Cast <Element>()
.ToList());
}
else if (this.HostCategory == HostCategory.Floor)
{
var floorCollector = new FilteredElementCollector(this.Doc)
.WhereElementIsNotElementType()
.OfClass(typeof(Floor))
.WherePasses(this.Filter)
.WherePasses(dof);
return(floorCollector
.Cast <Element>().ToList());
}
else
{
var bic = this.HostCategory == HostCategory.EnvelopFamily
? BuiltInCategory.OST_GenericModel
: BuiltInCategory.OST_StructuralFoundation;
IEnumerable <Element> collector = new FilteredElementCollector(this.Doc)
.WhereElementIsNotElementType()
.OfClass(typeof(FamilyInstance))
.OfCategory(bic)
.WherePasses(this.Filter)
.WherePasses(dof);
if (this.hostDir != null)
{
collector = collector
.Cast <FamilyInstance>()
.Where(x => x.HandOrientation.IsParallel(this.hostDir))
.Cast <Element>();
}
if (this.HostCategory == HostCategory.EnvelopFamily)
{
return(collector
.Where(x => goaCustomFamilyFilter.IsEnviFamilyInstanceElem(x))
.ToList());
}
else if (this.HostCategory == HostCategory.SuperSkin)
{
return(collector
.Where(x => goaCustomFamilyFilter.IsSuperSkinInstance(x))
.ToList());
}
else if (this.HostCategory == HostCategory.SuperCornice)
{
return(collector
.Where(x => goaCustomFamilyFilter.IsSuperCorniceElem(x))
.ToList());
}
else if (this.HostCategory == HostCategory.ArrayLineBased)
{
return(collector
.Where(x => goaCustomFamilyFilter.IsArrayLineBasedElem(x))
.ToList());
}
else
{
return(null);
}
}
}
/// <summary>
/// A function to number Family Instances
/// </summary>
/// <param name="doc"></param>
/// <param name="builtInCategory"></param>
public static void numberFamilyInstance(Document doc,
Phase phase,
Boolean numeric,
string separator,
BuiltInCategory builtInCategory,
ref int countInstances,
Parameter parameter)
{
// Create dictionary to store window-room values
Dictionary <FamilyInstance, string> instanceNumbers = new Dictionary <FamilyInstance, string>();
// Create dictionary to store number of windows in room
Dictionary <string, int> instancesInRoomCount = new Dictionary <string, int>();
// Design option filter
ElementDesignOptionFilter designOptionFilter = new ElementDesignOptionFilter(ElementId.InvalidElementId);
// Select elements in phase
ElementId idPhase = phase.Id;
ParameterValueProvider provider = new ParameterValueProvider(new ElementId((int)BuiltInParameter.PHASE_CREATED));
FilterNumericRuleEvaluator evaluator = new FilterNumericEquals();
FilterElementIdRule rule = new FilterElementIdRule(provider, evaluator, idPhase);
ElementParameterFilter paraFilter = new ElementParameterFilter(rule);
// Collect all windows in project
using (FilteredElementCollector instances = new FilteredElementCollector(doc).OfCategory(builtInCategory)
.WhereElementIsNotElementType().WherePasses(designOptionFilter).WherePasses(paraFilter))
{
string roomNumber = "";
// Retrieve rooms from windows
foreach (FamilyInstance inst in instances)
{
if (builtInCategory == BuiltInCategory.OST_Doors)
{
if (inst.ToRoom != null)
{
roomNumber = inst.ToRoom.Number;
}
else if (inst.FromRoom != null)
{
roomNumber = inst.FromRoom.Number;
}
}
else
{
if (inst.FromRoom != null)
{
roomNumber = inst.FromRoom.Number;
}
else if (inst.ToRoom != null)
{
roomNumber = inst.ToRoom.Number;
}
}
if (numeric)
{
Helpers.InstanceFromToRoomNumber(instancesInRoomCount, roomNumber, separator, instanceNumbers, inst);
}
else
{
Helpers.InstanceFromToRoom(instancesInRoomCount, roomNumber, separator, instanceNumbers, inst);
}
}
}
// Create transaction and make changes in Revit
using (Transaction t = new Transaction(doc, "Number Instances"))
{
t.Start();
// Empty Mark parameter to avoid duplicated values
foreach (KeyValuePair <FamilyInstance, string> entry in instanceNumbers)
{
Parameter instanceMark = entry.Key.LookupParameter(parameter.Definition.Name);
instanceMark.Set("");
}
// Populate Mark parameter
foreach (KeyValuePair <FamilyInstance, string> entry in instanceNumbers)
{
Parameter instanceMark = entry.Key.LookupParameter(parameter.Definition.Name);
if (entry.Value != "")
{
instanceMark.Set(entry.Value);
countInstances += 1;
}
}
t.Commit();
}
}
