// Переопределение графики для фильра IdentityDataAnalysis_AnVisibility
private void SetAnVisibilityFilter(Document doc)
{
ElementClassFilter filter = new ElementClassFilter(typeof(ParameterFilterElement));
FilteredElementCollector collector = new FilteredElementCollector(doc);
collector.WherePasses(filter).ToElements()
.Cast <ParameterFilterElement>().ToList <ParameterFilterElement>();
var result =
from item in collector
where item.Name.Equals("IdentityDataAnalysis_AnVisibility")
select item;
if (result.Count() > 0)
{
ParameterFilterElement filterForAnVisibility = result.First() as ParameterFilterElement;
View view = doc.ActiveView;
using (Transaction t = new Transaction(doc, "SetAnVisibilityFilter"))
{
t.Start();
if (!view.GetFilters().Contains(filterForAnVisibility.Id))
{
view.AddFilter(filterForAnVisibility.Id);
}
view.SetFilterVisibility(filterForAnVisibility.Id, false);
t.Commit();
}
}
else
{
throw new NullReferenceException();
}
}
public void CreateFilterRule3dGrid(Document doc, out ParameterFilterElement parameterFilterElement)
{
if (CheckFilter(doc, out parameterFilterElement))
{
}
else
{
List <ElementId> categories = new List <ElementId>();
categories.Add(new ElementId(BuiltInCategory.OST_GenericModel));
List <FilterRule> filterRules = new List <FilterRule>();
// Create filter element assocated to the input categories
parameterFilterElement = ParameterFilterElement.Create(doc, "Grid 3D", categories);
var collector = (from x in new FilteredElementCollector(doc).OfCategory(BuiltInCategory.OST_GenericModel).OfClass(typeof(FamilyInstance)).Cast <FamilyInstance>() where x.Name.Contains("650mm Bubble - Single") select x).ToList();
FamilyInstance familyInstance = collector.First();
if (familyInstance != null)
{
ElementId sharedParamId = familyInstance.get_Parameter(BuiltInParameter.ALL_MODEL_FAMILY_NAME).Id;
filterRules.Add(ParameterFilterRuleFactory.CreateContainsRule(sharedParamId, "3D Grid", true));
}
parameterFilterElement.SetRules(filterRules);
// Apply filter to view
//doc.ActiveView.AddFilter(parameterFilterElement.Id);
//doc.ActiveView.SetFilterVisibility(parameterFilterElement.Id, false);
}
}
public bool ApplyFilters(Document doc, View v, ElementId fillPatternId, bool colorLines, bool colorFill)
{
for (int i = 0; i < valuesList.Count; i++)
{
MyParameter mp = valuesList[i];
Parameter param = mp.RevitParameter;
string filterName = _filterNamePrefix + catsName + " " + paramName;
if (_criteriaType == CriteriaType.Equals)
{
filterName = filterName + " равно ";
}
else if (_criteriaType == CriteriaType.StartsWith)
{
filterName = filterName + " нач.с ";
}
filterName += mp.AsValueString();
ParameterFilterElement filter = FilterCreator.createSimpleFilter(doc, catsIds, filterName, mp, _criteriaType);
if (filter == null)
{
continue;
}
ViewUtils.ApplyViewFilter(doc, v, filter, fillPatternId, i, colorLines, colorFill);
}
return(true);
}
public static void ApplyViewFilter(Document doc, View view, ParameterFilterElement filter, ElementId solidFillPatternId, int colorNumber, bool colorLines, bool colorFill)
{
view.AddFilter(filter.Id);
OverrideGraphicSettings ogs = new OverrideGraphicSettings();
byte red = Convert.ToByte(ColorsCollection.colors[colorNumber].Substring(1, 2), 16);
byte green = Convert.ToByte(ColorsCollection.colors[colorNumber].Substring(3, 2), 16);
byte blue = Convert.ToByte(ColorsCollection.colors[colorNumber].Substring(5, 2), 16);
Color clr = new Color(red, green, blue);
if (colorLines)
{
ogs.SetProjectionLineColor(clr);
ogs.SetCutLineColor(clr);
}
if (colorFill)
{
#if R2017 || R2018
ogs.SetProjectionFillColor(clr);
ogs.SetProjectionFillPatternId(solidFillPatternId);
ogs.SetCutFillColor(clr);
ogs.SetCutFillPatternId(solidFillPatternId);
#else
ogs.SetSurfaceForegroundPatternColor(clr);
ogs.SetSurfaceForegroundPatternId(solidFillPatternId);
ogs.SetCutForegroundPatternColor(clr);
ogs.SetCutForegroundPatternId(solidFillPatternId);
#endif
}
view.SetFilterOverrides(filter.Id, ogs);
}
public Result Execute(ExternalCommandData commandData, ref string message, ElementSet elements)
{
// get UIdocument
UIDocument uidoc = commandData.Application.ActiveUIDocument;
//get document
Document doc = uidoc.Document;
//create filter
List <ElementId> cats = new List <ElementId>();
cats.Add(new ElementId(BuiltInCategory.OST_Sections));
ElementParameterFilter filter = new ElementParameterFilter(ParameterFilterRuleFactory.CreateContainsRule(new ElementId(BuiltInParameter.VIEW_NAME), "wip", false));
try
{
using (Transaction trans = new Transaction(doc, "create plan view"))
{
trans.Start();
//apply filter
ParameterFilterElement filterElement = ParameterFilterElement.Create(doc, "My First Filter", cats, filter);
doc.ActiveView.AddFilter(filterElement.Id);
doc.ActiveView.SetFilterVisibility(filterElement.Id, false);
trans.Commit();
}
return(Result.Succeeded);
}
catch (Exception e)
{
message = e.Message;
return(Result.Failed);
}
}
public static OverrideGraphicsSettings FilterOverrides(View view, ParameterFilterElement parameterFilter)
{
var v = (Autodesk.Revit.DB.View)view.InternalElement;
var overrides = v.GetFilterOverrides(parameterFilter.InternalElement.Id);
return(new OverrideGraphicsSettings(overrides));
}
public static bool FilterVisibility(View view, ParameterFilterElement parameterFilter)
{
var v = (Autodesk.Revit.DB.View)view.InternalElement;
var visible = v.GetFilterVisibility(parameterFilter.InternalElement.Id);
return(visible);
}
public static bool IsFilterApplied(View view, ParameterFilterElement parameterFilter)
{
var v = (Autodesk.Revit.DB.View)view.InternalElement;
var visible = v.IsFilterApplied(parameterFilter.InternalElement.Id);
return(visible);
}
public void SwitchFilters(ParameterFilterElement filter = null)
{
if (IsViewTemplateApplied())
{
if (UserDecideToKeepTemplate())
{
return;
}
}
try
{
Transaction t = new Transaction(_doc, "Switch Visibility");
t.Start();
if (filter != null)
{
_view.SetFilterVisibility(filter.Id, !_view.GetFilterVisibility(filter.Id));
}
else
{
foreach (ParameterFilterElement f in _filterElementsAppliedToView)
{
_view.SetFilterVisibility(f.Id, !_view.GetFilterVisibility(f.Id));
}
}
t.Commit();
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
}
}
private void CreateFilterForPipeSystem(Document doc, Element sysNameParam, string systemName)
{
using var tr = new Transaction(doc, "Создание фильтра для: " + systemName);
tr.Start();
var view = _uiDoc.ActiveView;
var categories = new List <ElementId>
{
new ElementId(BuiltInCategory.OST_PipeAccessory),
new ElementId(BuiltInCategory.OST_PipeCurves),
new ElementId(BuiltInCategory.OST_PipeFitting),
new ElementId(BuiltInCategory.OST_PipeInsulations),
new ElementId(BuiltInCategory.OST_PlumbingFixtures),
new ElementId(BuiltInCategory.OST_FlexPipeCurves),
new ElementId(BuiltInCategory.OST_PlaceHolderPipes),
new ElementId(BuiltInCategory.OST_GenericModel),
new ElementId(BuiltInCategory.OST_MechanicalEquipment),
new ElementId(BuiltInCategory.OST_Sprinklers)
};
var rule = ParameterFilterRuleFactory.CreateNotContainsRule(sysNameParam.Id, systemName, true);
var epf = new ElementParameterFilter(rule);
var ef = (ElementFilter)epf;
ParameterFilterElement filter;
try
{
filter = ParameterFilterElement.Create(doc, "ADSK_Трубопровод_" + systemName, categories, ef);
}
catch (ArgumentException)
{
var filter1 = new FilteredElementCollector(doc)
.OfClass(typeof(ParameterFilterElement))
.FirstOrDefault(f => f.Name == "ADSK_Трубопровод_" + systemName);
filter = filter1 as ParameterFilterElement;
filter?.SetElementFilter(ef);
}
var eView = new FilteredElementCollector(doc)
.OfClass(typeof(View))
.WhereElementIsNotElementType()
.FirstOrDefault(v => v.Name == $"{view.Name}_{systemName}");
if (null == eView)
{
var copyViewId = view.Duplicate(ViewDuplicateOption.Duplicate);
if (doc.GetElement(copyViewId) is View copiedView)
{
copiedView.Name = $"{view.Name}_{systemName}";
if (filter != null)
{
copiedView.AddFilter(filter.Id);
copiedView.SetFilterVisibility(filter.Id, false);
}
}
}
tr.Commit();
}
Boolean CreateCopy(Autodesk.Revit.UI.UIDocument project, ParameterFilterElement filter) //select filters (or create them)
{
//search filters
//ParameterFilterElement filter = null;
// FilteredElementCollector coll = new FilteredElementCollector(project.Document).OfClass(typeof(ParameterFilterElement));
// string topRebarFilter = "Rebar Layer Top";
// string bottomRebarFilter = "Rebar Layer Bottom";
return(true);
}
// Переопределение графики для фильра IdentityDataAnalysis_Visibility
private void SetVisibilityFilter(Document doc)
{
ElementClassFilter filter = new ElementClassFilter(typeof(ParameterFilterElement));
FilteredElementCollector collector = new FilteredElementCollector(doc);
collector.WherePasses(filter).ToElements()
.Cast <ParameterFilterElement>().ToList <ParameterFilterElement>();
var result =
from item in collector
where item.Name.Equals("IdentityDataAnalysis_Visibility")
select item;
if (result.Count() > 0)
{
ParameterFilterElement filterForVisibility = result.First() as ParameterFilterElement;
View view = doc.ActiveView;
using (Transaction t = new Transaction(doc, "SetVisibilityFilter"))
{
t.Start();
if (!view.GetFilters().Contains(filterForVisibility.Id))
{
view.AddFilter(filterForVisibility.Id);
}
OverrideGraphicSettings settings = new OverrideGraphicSettings();
FillPatternElement fillPatternElement = GetSolidFillPaeern(doc);
settings.SetSurfaceForegroundPatternId(fillPatternElement.Id);
settings.SetSurfaceBackgroundPatternId(fillPatternElement.Id);
settings.SetCutForegroundPatternId(fillPatternElement.Id);
settings.SetCutBackgroundPatternId(fillPatternElement.Id);
Color redColor = new Color(255, 0, 0);
settings.SetSurfaceForegroundPatternColor(redColor);
settings.SetSurfaceBackgroundPatternColor(redColor);
settings.SetCutForegroundPatternColor(redColor);
settings.SetCutBackgroundPatternColor(redColor);
settings.SetSurfaceTransparency(20);
view.SetFilterOverrides(filterForVisibility.Id, settings);
t.Commit();
}
}
else
{
throw new NullReferenceException();
}
}
private void ClearFilters(Document doc, View view)
{
Debug.WriteLine("Clear coloring filters on view: " + view.Name);
foreach (ElementId filterId in view.GetFilters())
{
ParameterFilterElement filter = doc.GetElement(filterId) as ParameterFilterElement;
if (filter.Name.StartsWith("_"))
{
view.RemoveFilter(filterId);
}
}
Debug.WriteLine("Clear filters completed");
}
private IList <ElementId> CreateFiltersIfMissing(Document doc)
{
bool[] array = new bool[4];
FilteredElementCollector val = new FilteredElementCollector(doc);
val.OfClass(typeof(ParameterFilterElement));
ICollection <ElementId> collection = val.ToElementIds();
foreach (ElementId item2 in collection)
{
Element val2 = doc.GetElement(item2);
for (int i = 0; i < filterNames.Length; i++)
{
if (val2.get_Name() == filterNames[i])
{
array[i] = true;
}
}
}
if (array.Any((bool b) => !b))
{
ElementId val3 = LODapp.GetLODparameter(doc, "Current_LOD").get_Id();
IList <ElementId> list = (from cat in LODapp.lodCatArray
where (int)cat != -2000220
select new ElementId(cat)).ToList();
Transaction val4 = new Transaction(doc, "Create LOD filters");
try
{
val4.Start();
for (int j = 0; j < filterNames.Length; j++)
{
if (!array[j])
{
ParameterFilterElement val5 = ParameterFilterElement.Create(doc, filterNames[j], (ICollection <ElementId>)list);
FilterRule item = ParameterFilterRuleFactory.CreateEqualsRule(val3, lodValues[j]);
val5.SetRules((IList <FilterRule>) new List <FilterRule>(1)
{
item
});
}
}
val4.Commit();
}
catch (Exception innerException)
{
val4.RollBack();
throw new Exception("Failed to create filters.", innerException);
}
}
return(GetLODfilters(doc));
}
Boolean CreateFilters(Autodesk.Revit.UI.UIDocument project) //select filters (or create them)
{
// FilteredElementCollector coll = new FilteredElementCollector(project.Document).OfClass(typeof(ParameterFilterElement));
string topRebarFilter = "Rebar Layer Top";
string bottomRebarFilter = "Rebar Layer Bottom";
string topAddRebarFilter = "Rebar Layer Top Add";
string bottomAddRebarFilter = "Rebar Layer Bottom Add";
/*
* ParameterFilterElement f_topRebarView = null;
* ParameterFilterElement f_bottomRebarView = null;
* ParameterFilterElement f_topAddRebarView = null;
* ParameterFilterElement f_bottomAddRebarView = null;
* */
IEnumerable <Element> filters = new FilteredElementCollector(project.Document).OfClass(typeof(ParameterFilterElement)).ToElements();
//List<ElementId> categories = new List<ElementId>();
//categories.Add(new ElementId(BuiltInCategory.OST_Rebar));
// List<FilterRule> filterRules = new List<FilterRule>();
foreach (Element element in filters)
{
if (element.Name.Equals(topRebarFilter))
{
f_topRebarView = element as ParameterFilterElement;
}
else
{
} //create new filter
if (element.Name.Equals(bottomRebarFilter))
{
f_bottomRebarView = element as ParameterFilterElement;
}
else
{
} //create new filter
if (element.Name.Equals(topAddRebarFilter))
{
f_topAddRebarView = element as ParameterFilterElement;
}
else
{
} //create new filter
if (element.Name.Equals(bottomAddRebarFilter))
{
f_bottomAddRebarView = element as ParameterFilterElement;
}
}
return(true);
}
public static ElementFilter GetElementFilter(this ParameterFilterElement parameterFilter)
{
var filters = new List <ElementFilter>()
{
new ElementMulticategoryFilter(parameterFilter.GetCategories())
};
foreach (var rule in parameterFilter.GetRules())
{
filters.Add(new ElementParameterFilter(rule));
}
return(new LogicalAndFilter(filters));
}
public void CreateDublicate(Document doc, ParameterFilterElement filter, string nameprefix)
{
Autodesk.Revit.DB.View viewcur = doc.ActiveView;
Transaction t = new Transaction(doc);
t.Start("Create new dublicate");
ElementId newViewId = ElementId.InvalidElementId;
Autodesk.Revit.DB.View newView = null;
newViewId = viewcur.Duplicate(ViewDuplicateOption.Duplicate);
newView = viewcur.Document.GetElement(newViewId) as Autodesk.Revit.DB.View;
newView.Name = newView.Name + nameprefix;
t.Commit();
}
// Создание фильтров IdentityDataAnalysis_Visibility и IdentityDataAnalysis_AnVisibility,
// назначение им правил
private void CreateFilters(UIDocument uiDoc, Parameter parameter, List <Element> elements)
{
IList <FilterRule> visibilityFilterRules = new List <FilterRule>();
visibilityFilterRules.Add(ParameterFilterRuleFactory.CreateEqualsRule(parameter.Id, "", true));
ElementParameterFilter visibilityFilter = new ElementParameterFilter(visibilityFilterRules);
IList <FilterRule> anVisibilityFilterRules = new List <FilterRule>();
anVisibilityFilterRules.Add(ParameterFilterRuleFactory.CreateNotEqualsRule(parameter.Id, "", true));
ElementParameterFilter anVisibilityFilter = new ElementParameterFilter(anVisibilityFilterRules);
List <ElementId> categorysIds = GetUniquCategorysIds(elements);
ParameterFilterElement filterForVisibility = CreateFilterElement(uiDoc.Document, "IdentityDataAnalysis_Visibility", categorysIds, visibilityFilter);
ParameterFilterElement filterForAnVisibility = CreateFilterElement(uiDoc.Document, "IdentityDataAnalysis_AnVisibility", categorysIds, anVisibilityFilter);
}
public static IEnumerable <Revit.Elements.Element> AllElementsByFilter(ParameterFilterElement parameterFilterElement)
{
Document document = DocumentManager.Instance.CurrentDBDocument;
var parameterFilter = parameterFilterElement as ParameterFilterElement;
var categoriesIds = parameterFilter.GetCategories();
var elementFilter = parameterFilter.GetElementFilter();
var elements = new List <Autodesk.Revit.DB.Element>();
foreach (var id in categoriesIds)
{
elements.AddRange(new FilteredElementCollector(document).OfCategoryId(id).WherePasses(elementFilter));
}
return(elements.Select(x => x.ToDSType(true)));
}
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
{
}
}
public static List <RevitElements.Element> GetFiltersFromView(Revit.Elements.Element View)
{
DB.Document doc = DocumentManager.Instance.CurrentDBDocument;
List <RevitElements.Element> filters = new List <RevitElements.Element>();
View _view = View.InternalElement as View;
ICollection <ElementId> filterIds = _view.GetFilters();
List <DB.Element> parameterFilterElements = filterIds.Select(id => doc.GetElement(id)).ToList();
foreach (DB.Element pfe in parameterFilterElements)
{
ParameterFilterElement _pfe = pfe as ParameterFilterElement;
filters.Add(_pfe.ToDSType(true));
}
return(filters);
}
// Создание или переопределение фильтра
private ParameterFilterElement CreateFilterElement(Document doc, string name, List <ElementId> categoriesIds, ElementFilter elementFilter)
{
ElementClassFilter filter = new ElementClassFilter(typeof(ParameterFilterElement));
FilteredElementCollector collector = new FilteredElementCollector(doc);
collector.WherePasses(filter).ToElements()
.Cast <ParameterFilterElement>().ToList <ParameterFilterElement>();
var result =
from item in collector
where item.Name.Equals(name)
select item;
ParameterFilterElement filterElement;
if (result.Count() == 0)
{
using (Transaction t = new Transaction(doc, "CreateFilterElement"))
{
t.Start();
filterElement = ParameterFilterElement.Create(doc, name, categoriesIds, elementFilter);
t.Commit();
}
}
else
{
filterElement = result.First() as ParameterFilterElement;
using (Transaction t = new Transaction(doc, "SetCategoriesFilterElement"))
{
t.Start();
filterElement.SetCategories(categoriesIds);
filterElement.SetElementFilter(elementFilter);
t.Commit();
}
}
if (filterElement != null)
{
return(filterElement);
}
else
{
throw new Exception();
}
}
public static List <RevitElements.Element> GetallFilters(bool Run)
{
if (!Run)
{
return(null);
}
DB.Document doc = DocumentManager.Instance.CurrentDBDocument;
List <RevitElements.Element> filters = new List <RevitElements.Element>();
ICollection <ElementId> filterIds = new FilteredElementCollector(doc).OfClass(typeof(ParameterFilterElement)).ToElementIds();
List <DB.Element> parameterFilterElements = filterIds.Select(id => doc.GetElement(id)).ToList();
foreach (DB.Element pfe in parameterFilterElements)
{
ParameterFilterElement _pfe = pfe as ParameterFilterElement;
filters.Add(_pfe.ToDSType(true));
}
return(filters);
}
protected override Result ProcessCommand(ExternalCommandData commandData, ref string message, ElementSet elements)
{
// Create Category
var cats = new List <ElementId>();
cats.Add(new ElementId(BuiltInCategory.OST_Sections));
var sectionFilter = ParameterFilterRuleFactory.CreateContainsRule(new ElementId(BuiltInParameter.VIEW_NAME), "Section 1", false);
var elementFilter = new ElementParameterFilter(sectionFilter);
using (Transaction trans = new Transaction(_activeDocument, "Create Filter"))
{
trans.Start();
var filter = ParameterFilterElement.Create(_activeDocument, "Wall Filter", cats, elementFilter);
_activeDocument.ActiveView.AddFilter(filter.Id);
_activeDocument.ActiveView.SetFilterVisibility(filter.Id, false);
trans.Commit();
}
return(Result.Succeeded);
}
public static ParameterFilterElement createSimpleFilter(Document doc, List <ElementId> catsIds, string filterName, MyParameter mp, CriteriaType ctype)
{
List <ParameterFilterElement> filters = new FilteredElementCollector(doc)
.OfClass(typeof(ParameterFilterElement))
.Cast <ParameterFilterElement>()
.ToList();
FilterRule rule = null;
List <ParameterFilterElement> checkFilters = filters.Where(f => f.Name == filterName).ToList();
ParameterFilterElement filter = null;
if (checkFilters.Count != 0)
{
filter = checkFilters[0];
}
else
{
rule = FilterCreator.CreateRule(mp, ctype);
if (rule == null)
{
return(null);
}
List <FilterRule> filterRules = new List <FilterRule> {
rule
};
try
{
filter = ParameterFilterElement.Create(doc, filterName, catsIds);
#if R2017 || R2018
filter.SetRules(filterRules);
#else
filter.SetElementFilter(new ElementParameterFilter(filterRules));
#endif
}
catch { }
}
return(filter);
}
public bool ApplyFilters(Document doc, View v, ElementId fillPatternId, bool colorLines, bool colorFill)
{
Debug.WriteLine("Start apply rebar filters for view: " + v.Name);
for (int i = 0; i < values.Count; i++)
{
string val = values[i];
Debug.WriteLine("Value: " + val);
ParameterFilterElement filterConstr = FilterCreator.CreateConstrFilter(doc, catIdConstructions, markParam, val, _filterNamePrefix);
ViewUtils.ApplyViewFilter(doc, v, filterConstr, fillPatternId, i, colorLines, colorFill);
if (!_rebarIsFamilyParamExists)
{
ParameterFilterElement filterRebarSingleMode = FilterCreator
.CreateRebarHostFilter(doc, catIdRebar, rebarIsFamilyParam, rebarHostParam, rebarMrkParam, val, _filterNamePrefix, RebarFilterMode.SingleMode);
ViewUtils.ApplyViewFilter(doc, v, filterRebarSingleMode, fillPatternId, i, colorLines, colorFill);
continue;
}
#if R2017 || R2018
ParameterFilterElement filterRebarStandardRebar = FilterCreator
.CreateRebarHostFilter(doc, catIdRebar, rebarIsFamilyParam, rebarHostParam, rebarMrkParam, val, _filterNamePrefix, RebarFilterMode.StandardRebarMode);
ViewUtils.ApplyViewFilter(doc, v, filterRebarStandardRebar, fillPatternId, i, colorLines, colorFill);
Debug.WriteLine("Filter created and applied to view: " + filterRebarStandardRebar.Name);
ParameterFilterElement filterRebarIfcRebar = FilterCreator
.CreateRebarHostFilter(doc, new List <ElementId> {
new ElementId(BuiltInCategory.OST_Rebar)
}, rebarIsFamilyParam, rebarHostParam, rebarMrkParam, val, _filterNamePrefix, RebarFilterMode.IfcMode);
ViewUtils.ApplyViewFilter(doc, v, filterRebarIfcRebar, fillPatternId, i, colorLines, colorFill);
Debug.WriteLine("Filter created and applied to view: " + filterRebarIfcRebar.Name);
#else
ParameterFilterElement filterRebarOrStyle = FilterCreator
.CreateRebarHostFilter(doc, catIdRebar, rebarIsFamilyParam, rebarHostParam, rebarMrkParam, val, _filterNamePrefix, RebarFilterMode.DoubleMode);
ViewUtils.ApplyViewFilter(doc, v, filterRebarOrStyle, fillPatternId, i, colorLines, colorFill);
Debug.WriteLine("Filter created and applied to view: " + filterRebarOrStyle.Name);
#endif
}
Debug.WriteLine("All filters applied");
return(true);
}
public bool CheckFilter(Document doc, out ParameterFilterElement parameterFilterElement)
{
bool flag = false;
parameterFilterElement = null;
var col = new FilteredElementCollector(doc).OfClass(typeof(ParameterFilterElement)).Cast <ParameterFilterElement>().ToList();
foreach (var item in col)
{
if (item.Name == "Grid 3D")
{
parameterFilterElement = item;
return(flag = true);
}
if (flag)
{
break;
}
}
return(flag);
}
private bool CanPassFilterRules(ParameterFilterElement filter, ElementId elemId)
{
Element elem = CurrentDocument.GetElement(elemId);
if (elem == null)
{
return(false);
}
bool bPassed = true;
foreach (FilterRule rule in filter.GetRules())
{
if (!rule.ElementPasses(elem))
{
bPassed = false;
break;
}
}
return(bPassed);
}
public static List <RevitElements.Element> GetFiltersFromActiveView(bool Run)
{
if (!Run)
{
return(null);
}
DB.Document doc = DocumentManager.Instance.CurrentDBDocument;
List <RevitElements.Element> filters = new List <RevitElements.Element>();
ICollection <ElementId> filterIds = doc.ActiveView.GetFilters();
List <DB.Element> parameterFilterElements = filterIds.Select(id => doc.GetElement(id)).ToList();
foreach (DB.Element pfe in parameterFilterElements)
{
ParameterFilterElement _pfe = pfe as ParameterFilterElement;
filters.Add(_pfe.ToDSType(true));
}
return(filters);
}
public static ParameterFilterElement CreateConstrFilter(Document doc, List <ElementId> catsIds, Parameter markParam, string mark, string filterNamePrefix)
{
string filterName = filterNamePrefix + "_Конструкция " + mark;
ParameterFilterElement filter = DocumentGetter.GetFilterByName(doc, filterName);
if (filter != null)
{
return(filter);
}
FilterRule markEquals = ParameterFilterRuleFactory.CreateEqualsRule(markParam.Id, mark, true);
#if R2017 || R2018
filter = ParameterFilterElement.Create(doc, filterName, catsIds);
filter.SetRules(new List <FilterRule> {
markEquals
});
#else
ElementParameterFilter epf = new ElementParameterFilter(markEquals);
filter = ParameterFilterElement.Create(doc, filterName, catsIds, epf);
#endif
return(filter);
}
