public SelectParameterForm(SetRevitDataForm _parent, List <RevitParameter> allParams, List <RevitParameter> selectedParams)
{
parameters = allParams;
parent = _parent;
InitializeComponent();
// Add list items for each parameters
listView.ItemsSource = parameters;
listView.DisplayMemberPath = "ParameterName";
// Preselected parameters
if (selectedParams.Count > 0)
{
foreach (object t in listView.Items)
{
RevitParameter rp = t as RevitParameter;
foreach (RevitParameter sp in selectedParams)
{
if (rp != null && rp.ParameterName == sp.ParameterName)
{
listView.SelectedItems.Add(rp);
}
}
}
}
}
private void okButton_Click(object sender, RoutedEventArgs e)
{
List <RevitParameter> selectedParams = new List <RevitParameter>();
try
{
foreach (RevitParameter item in listView.SelectedItems)
{
try
{
RevitParameter rp = item;
selectedParams.Add(rp);
}
catch (Exception exception)
{
Debug.WriteLine(exception.Message);
}
}
}
catch (Exception ex)
{
MessageBox.Show(ex.ToString());
}
parent.SelectedParameters = selectedParams;
parent.AddControls();
Close();
}
public IList <Element> GetElementValueDouble(RevitParameter valRevitParameter, List <ElementId> valCategoryElementId, string valValue)
{
IList <Element> vResult = new List <Element>();
foreach (var vCategoryId in valCategoryElementId)
{
BuiltInCategory vBuiltInCategory = (BuiltInCategory)vCategoryId.IntegerValue;
ParameterValueProvider vPovider = new ParameterValueProvider(valRevitParameter.ElementId);
string vRulestring = valValue;
FilteredElementCollector vCollector = new FilteredElementCollector(_Doc);
vCollector.OfCategory(vBuiltInCategory);
LibNumeric insLibNumeric = new LibNumeric();
double ruleValDb = 0.0;
if (insLibNumeric.IsDouble(valValue))
{
Double vNum = 0;
Double.TryParse(valValue, out vNum);
ruleValDb = vNum;
}
ParameterValueProvider pvp = new ParameterValueProvider(valRevitParameter.ElementId);
FilterNumericEquals fnrv = new FilterNumericEquals();
var vFilterDoubleRule = new FilterDoubleRule(pvp, fnrv, ruleValDb, 10e-10);
var epf = new ElementParameterFilter(vFilterDoubleRule);
vCollector.WherePasses(epf);
IList <Element> vElements = vCollector.ToElements();
if (vElements != null)
{
if (vElements.Count > 0)
{
vResult = vElements.Concat(vElements).ToList();
}
}
}
return(vResult);
}
public ParameterControl(RevitParameter rp)
{
parameter = rp;
InitializeComponent();
paramNameLabel.Content = parameter.ParameterName;
isTypeLabel.Content = parameter.IsType ? "Type Parameter" : "Instance Parameter";
storageTypeLabel.Content = parameter.StorageType;
}
public IList <Element> GetBy(RevitParameter valRevitParameter, List <ElementId> valCategoryElementId, string valValue)
{
IList <Element> vResult = new List <Element>();
bool vIsParse = false;
double vData = 0;
string vValueToString = valValue;
if (!StringClasses.lstNames().Contains(valRevitParameter.Name))
{
if (IsParsed(valValue, out vData))
{
valValue = vData.ToString();
vIsParse = true;
}
}
LibNumeric insLibNumeric = new LibNumeric();
if (insLibNumeric.IsDouble(valValue) && !StringClasses.lstNames().Contains(valRevitParameter.Name))
{
vResult = GetElementValueDouble(valRevitParameter, valCategoryElementId, valValue);
if (vResult.Count == 0)
{
if (vIsParse)
{
vResult = GetElementValueDoubleLessOrEqual(valRevitParameter, valCategoryElementId, valValue, vValueToString);
if (vResult.Count == 0)
{
vResult = GetElementValueDoubleGreaterOrEqual(valRevitParameter, valCategoryElementId, valValue, vValueToString);
}
if (vResult.Count == 0)
{
vResult = GetElementValueIntOrstring(valRevitParameter, valCategoryElementId, valValue);
if (vResult.Count <= 0)
{
vResult = FindByInternalValue(valRevitParameter, valCategoryElementId, valValue);
}
}
}
}
}
else
{
vResult = GetElementValueIntOrstring(valRevitParameter, valCategoryElementId, valValue);
if (vResult.Count <= 0)
{
vResult = FindByInternalValue(valRevitParameter, valCategoryElementId, valValue);
}
}
return(vResult);
}
public void AddFamilyParameterNote(RevitParameter parameter)
{
if (this.textNoteTypeResults == null)
{
this.textNoteTypeResults = new List <AddParameterResult>();
}
AddParameterResult r = new AddParameterResult {
Name = parameter.ParamName
};
this.textNoteTypeResults.Add(r);
}
private IList <Element> FindByInternalValue(RevitParameter valRevitParameter, List <ElementId> valCategoryElementId, string valValue)
{
LibNumeric vLibNumeric = new LibNumeric();
List <Element> vResult = new List <Element>();
IList <string> vInternalValues = GetInternalValue(valValue);
foreach (var vInternalValue in vInternalValues)
{
if (vLibNumeric.IsDouble(vInternalValue))
{
IList <Element> vSearchResult = GetElementValueDouble(valRevitParameter, valCategoryElementId, vInternalValue);
vResult = vResult.Concat(vSearchResult).ToList();
}
}
return(vResult);
}
/***************************************************/
/**** Public methods ****/
/***************************************************/
public static void CopyParameters(this IBHoMObject bHoMObject, Element element, ParameterSettings settings = null)
{
if (bHoMObject == null || element == null)
{
return;
}
List <RevitParameter> parameters = new List <RevitParameter>();
oM.Adapters.Revit.Parameters.ParameterMap parameterMap = settings?.ParameterMap(bHoMObject.GetType());
IEnumerable <IParameterLink> parameterLinks = null;
if (parameterMap != null)
{
Element elementType = element.Document.GetElement(element.GetTypeId());
IEnumerable <IParameterLink> typeParameterLinks = parameterMap.ParameterLinks.Where(x => x is ElementTypeParameterLink);
if (elementType != null && typeParameterLinks.Count() != 0)
{
foreach (Parameter parameter in elementType.ParametersMap)
{
RevitParameter bHoMParameter = parameter.ParameterFromRevit(typeParameterLinks, true);
if (bHoMParameter != null)
{
parameters.Add(bHoMParameter);
}
}
}
parameterLinks = parameterMap.ParameterLinks.Where(x => !(x is ElementTypeParameterLink));
}
IEnumerable elementParams = element.ParametersMap;
if (((Autodesk.Revit.DB.ParameterMap)elementParams).IsEmpty)
{
elementParams = element.Parameters;
}
foreach (Parameter parameter in elementParams)
{
parameters.Add(parameter.ParameterFromRevit(parameterLinks, false));
}
bHoMObject.Fragments.Add(new RevitPulledParameters(parameters));
}
public bool Contains(string valValueToString, RevitParameter valRevitParameter, Element valElement)
{
bool vResult = false;
List <RevitParameterInfocs> vList = GetParametersBy(valElement);
if (vList != null)
{
if (string.IsNullOrEmpty(valValueToString))
{
vResult = (vList.Where(p => p.ID == valRevitParameter.Id.ToString()).Count() > 0);
}
else
{
vResult = (vList.Where(p => p.ID == valRevitParameter.Id.ToString() && p.Value == valValueToString).Count() > 0);
}
}
return(vResult);
}
private IList <Element> GetElementValueIntOrstring(RevitParameter valRevitParameter, List <ElementId> valCategoryElementId, string valValue)
{
IList <Element> vResult = new List <Element>();
IList <Element> vResultTemp = new List <Element>();
foreach (var vCategoryId in valCategoryElementId)
{
IList <ElementFilter> vList = new List <ElementFilter>();
BuiltInCategory vBuiltInCategory = (BuiltInCategory)vCategoryId.IntegerValue;
ParameterValueProvider vPovider = new ParameterValueProvider(valRevitParameter.ElementId);
string vRulestring = valValue;
FilterStringRuleEvaluator vEvaluator = new FilterStringEquals();
FilteredElementCollector vCollector = new FilteredElementCollector(_Doc);
vCollector.OfCategory(vBuiltInCategory);
FilterRule vRuleRulestring = new FilterStringRule(vPovider, vEvaluator, vRulestring, false);
ElementParameterFilter vFilterRulestring = new ElementParameterFilter(vRuleRulestring);
LibNumeric insLibNumeric = new LibNumeric();
if (insLibNumeric.IsInt(valValue))
{
int vNum = 0;
int.TryParse(valValue, out vNum);
FilterNumericEquals vEvaluatorNumeri = new FilterNumericEquals();
int vRuleIntVal = vNum;
var vFilterIntRule = new FilterIntegerRule(vPovider, vEvaluatorNumeri, vRuleIntVal);
var vElementParameterFilterIntRule = new ElementParameterFilter(vFilterIntRule);
vList.Add(vElementParameterFilterIntRule);
}
vList.Add(vFilterRulestring);
LogicalOrFilter vLogicalOrFilter = new LogicalOrFilter(vList);
vCollector.WherePasses(vLogicalOrFilter);
IList <Element> vElements = vCollector.ToElements();
if (vElements != null)
{
if (vElements.Count > 0)
{
foreach (var vElement in vElements)
{
vResult.Add(vElement);
}
}
}
}
return(vResult);
}
public IList <Element> GetElementValueToString(RevitParameter valRevitParameter, IList <Element> valElements, string valValueToString, string valValue)
{
IList <Element> vResult = new List <Element>();
foreach (var vElement in valElements)
{
LibParameters insLibParameters = new LibParameters(_Doc);
var vParameter = vElement.get_Parameter((BuiltInParameter)valRevitParameter.ElementId.IntegerValue);
var vDiferen = Math.Round(vParameter.AsDouble(), 2) - Math.Round(Convert.ToDouble(valValue), 2);
if (vDiferen < 0)
{
vDiferen = vDiferen * -1;
}
if (vDiferen < 0.01)
{
vResult.Add(vElement);
}
}
return(vResult);
}
void FilterParameter(string valFilter)
{
LibElement vLibElement = new LibElement(_Doc);
LibParameters inSLibParameters = new LibParameters(_Doc);
List <RevitParameter> vParamsList = inSLibParameters.GetFilterByCategory(CategoriesList());
RevitParameter vPickedElement = (RevitParameter)ListParameter.SelectedItem;
List <RevitParameter> vCommonParameters = vParamsList.FindAll(p => p.Name.Equals(vPickedElement.Name));
IList <Element> vResult = new List <Element>();
foreach (RevitParameter vParam in vCommonParameters)
{
IList <Element> vList = vLibElement.GetBy(vParam, CategoriesList(), valFilter);
if (null != vList)
{
vResult = vResult.Concat(vList).ToList();
}
}
ElementList = new ObservableCollection <Element>(vResult);
ElementListView.ItemsSource = ElementList;
}
/***************************************************/
/**** Private Methods ****/
/***************************************************/
public static bool TrySetTypeFromString(this Element element, IBHoMObject bHoMObject, RevitSettings settings)
{
if (element.Category.Id.IntegerValue < 0)
{
RevitParameter param = (bHoMObject.Fragments?.FirstOrDefault(x => x is RevitParametersToPush) as RevitParametersToPush)?.Parameters?.FirstOrDefault(x => x.Name == "Type");
if (param?.Value is string)
{
ElementType et = element.Document.ElementType(null, (string)param.Value, new[] { (BuiltInCategory)element.Category.Id.IntegerValue }, settings);
if (et != null)
{
element.SetParameter(BuiltInParameter.ELEM_TYPE_PARAM, et.Id);
return(true);
}
else
{
BH.Engine.Reflection.Compute.RecordWarning($"Element type not updated: type named {param.Value} of category {element.Category.Name} could not be found in the model. ElementId: {element.Id.IntegerValue}");
}
}
}
return(false);
}
public List <RevitParameter> GetFilterByCategory(List <ElementId> valValue)
{
List <RevitParameter> vResult = new List <RevitParameter>();
foreach (var vData in valValue.AsParallel())
{
List <ElementId> vFilter = new List <ElementId>();
vFilter.Add(vData);
var vList = ParameterFilterUtilities.GetFilterableParametersInCommon(_Doc, vFilter);
//Category vCategory = _Doc.Settings.Categories.get_Item((BuiltInCategory)vData.IntegerValue);
foreach (ElementId vElementId in vList.AsParallel())
{
RevitParameter vRecord = new RevitParameter();
string vName = string.Empty;
if (vResult.Where(p => p.Id == vElementId.IntegerValue).Count() == 0)
{
if (vElementId.IntegerValue < 0)
{
vName = LabelUtils.GetLabelFor((BuiltInParameter)vElementId.IntegerValue).Trim();
}
else
{
vName = _Doc.GetElement(vElementId).Name.Trim();
}
vRecord.Id = vElementId.IntegerValue;
vRecord.ElementId = vElementId;
vRecord.Name = vName;
//vRecord.Definition = vElementId;
vResult.Add(vRecord);
}
}
}
return(vResult);
}
public static object GetRevitParameterValue(this IBHoMObject bHoMObject, string parameterName)
{
if (bHoMObject == null)
{
return(null);
}
RevitParametersToPush pushFragment = bHoMObject.Fragments?.FirstOrDefault(x => x is RevitParametersToPush) as RevitParametersToPush;
if (pushFragment?.Parameters != null)
{
RevitParameter param = pushFragment.Parameters.FirstOrDefault(x => x.Name == parameterName);
if (param != null)
{
return(param.Value);
}
}
RevitPulledParameters pullFragment = bHoMObject.Fragments?.FirstOrDefault(x => x is RevitPulledParameters) as RevitPulledParameters;
if (pullFragment?.Parameters != null)
{
RevitParameter param = pullFragment.Parameters.FirstOrDefault(x => x.Name == parameterName);
if (param != null)
{
return(param.Value);
}
}
RevitIdentifiers identifierFragment = bHoMObject.Fragments?.FirstOrDefault(x => x is RevitIdentifiers) as RevitIdentifiers;
if (identifierFragment != null)
{
string paramName = string.Concat(parameterName.Where(c => !char.IsWhiteSpace(c)));
if (Reflection.Query.PropertyNames(identifierFragment).Contains(paramName))
{
return(Reflection.Query.PropertyValue(identifierFragment, paramName));
}
}
Dictionary <string, object> bHoMPropDic = Reflection.Query.PropertyDictionary(bHoMObject);
foreach (KeyValuePair <string, object> bHoMPropEntry in bHoMPropDic)
{
IBHoMObject bHoMProp = bHoMPropEntry.Value as IBHoMObject;
if (bHoMProp != null)
{
RevitPulledParameters typePullFragment = bHoMProp.Fragments?.FirstOrDefault(x => x is RevitPulledParameters) as RevitPulledParameters;
if (typePullFragment?.Parameters != null)
{
RevitParameter param = typePullFragment.Parameters.FirstOrDefault(x => x.Name == parameterName);
if (param != null)
{
Engine.Reflection.Compute.RecordWarning("The value for parameter " + parameterName + " for the object with BHoM_Guid " + bHoMObject.BHoM_Guid + " has been retrieved from its property " + bHoMPropEntry.Key + ".");
return(param.Value);
}
}
}
}
return(null);
}
