public static ClonedType CloneType(this IBHoMObject sourceRevitObject, string newName)
{
if (sourceRevitObject == null)
{
BH.Engine.Reflection.Compute.RecordError("It is impossible to clone a null Revit object.");
return null;
}
RevitIdentifiers identifiers = sourceRevitObject.FindFragment<RevitIdentifiers>();
if (identifiers == null)
{
BH.Engine.Reflection.Compute.RecordError("The input object is not a valid pulled Revit element.");
return null;
}
ClonedType result = new ClonedType { SourceTypeId = identifiers.FamilyTypeId, Name = newName };
if (identifiers.ElementId == identifiers.FamilyTypeId)
{
RevitParametersToPush parametersToPush = sourceRevitObject.FindFragment<RevitParametersToPush>();
if (parametersToPush != null)
{
BH.Engine.Reflection.Compute.RecordWarning("Parameters to push have been cloned from the source Revit type object.");
result.AddFragment(parametersToPush.DeepClone());
}
}
else
BH.Engine.Reflection.Compute.RecordWarning("The input object is a pulled Revit element, its type has been cloned.");
return result;
}
public static List <RevitParameter> GetRevitParameters(this IBHoMObject bHoMObject)
{
if (bHoMObject == null)
{
return(null);
}
RevitPulledParameters pullFragment = bHoMObject.Fragments?.FirstOrDefault(x => x is RevitPulledParameters) as RevitPulledParameters;
RevitParametersToPush pushFragment = bHoMObject.Fragments?.FirstOrDefault(x => x is RevitParametersToPush) as RevitParametersToPush;
List <RevitParameter> result = new List <RevitParameter>();
if (pullFragment?.Parameters != null)
{
result.AddRange(pullFragment.Parameters);
}
if (pushFragment?.Parameters != null)
{
bool mixed = false;
foreach (RevitParameter param in pushFragment.Parameters)
{
int index = result.FindIndex(x => x.Name == param.Name);
if (index == -1)
{
result.Add(param);
}
else
{
mixed = true;
result.RemoveAt(index);
result.Add(param);
}
}
if (mixed)
{
BH.Engine.Reflection.Compute.RecordNote("Some of the parameters were retrieved from collection of pulled ones, some from the ones meant to be pushed.");
}
}
return(result);
}
public static IBHoMObject SetRevitParameters(this IBHoMObject bHoMObject, List <string> paramNames, List <object> values)
{
if (bHoMObject == null)
{
return(null);
}
if (paramNames.Count != values.Count)
{
BH.Engine.Reflection.Compute.RecordError("Number of input names needs to be equal to the number of input values. Parameters have not been set.");
return(bHoMObject);
}
List <RevitParameter> parameters = paramNames.Zip(values, (x, y) => new RevitParameter {
Name = x, Value = y
}).ToList();
RevitParametersToPush existingFragment = bHoMObject.Fragments.FirstOrDefault(x => x is RevitParametersToPush) as RevitParametersToPush;
if (existingFragment != null)
{
foreach (RevitParameter parameter in existingFragment.Parameters)
{
if (paramNames.All(x => parameter.Name != x))
{
parameters.Add(parameter);
}
}
}
RevitParametersToPush fragment = new RevitParametersToPush {
Parameters = parameters
};
IBHoMObject obj = bHoMObject.ShallowClone();
obj.Fragments = new FragmentSet(bHoMObject.Fragments.Where(x => !(x is RevitParametersToPush)).ToList());
obj.Fragments.Add(fragment);
return(obj);
}
public static IBHoMObject SetRevitParameter(this IBHoMObject bHoMObject, string paramName, object value)
{
if (bHoMObject == null)
{
return(null);
}
List <RevitParameter> parameters = new List <RevitParameter> {
new RevitParameter {
Name = paramName, Value = value
}
};
RevitParametersToPush existingFragment = bHoMObject.Fragments.FirstOrDefault(x => x is RevitParametersToPush) as RevitParametersToPush;
if (existingFragment != null)
{
foreach (RevitParameter parameter in existingFragment.Parameters)
{
if (parameter.Name != paramName)
{
parameters.Add(parameter);
}
}
}
RevitParametersToPush fragment = new RevitParametersToPush {
Parameters = parameters
};
IBHoMObject obj = bHoMObject.ShallowClone();
obj.Fragments = new FragmentSet(bHoMObject.Fragments.Where(x => !(x is RevitParametersToPush)).ToList());
obj.Fragments.Add(fragment);
return(obj);
}
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);
}
/***************************************************/
public static void CopyParameters(this Element element, IBHoMObject bHoMObject, RevitSettings settings = null)
{
if (bHoMObject == null || element == null)
{
return;
}
settings = settings.DefaultIfNull();
RevitParametersToPush fragment = bHoMObject.Fragments.FirstOrDefault(x => x is RevitParametersToPush) as RevitParametersToPush;
if (fragment == null)
{
return;
}
ElementType elementType = element.Document.GetElement(element.GetTypeId()) as ElementType;
Type type = bHoMObject.GetType();
BH.oM.Adapters.Revit.Parameters.ParameterMap parameterMap = settings?.ParameterSettings?.ParameterMap(type);
IEnumerable <PropertyInfo> propertyInfos = type.MapPropertyInfos();
if (propertyInfos != null)
{
propertyInfos = propertyInfos.Where(x => x.PropertyType != typeof(double)).Union(propertyInfos.Where(x => x.PropertyType == typeof(double)));
foreach (PropertyInfo pInfo in propertyInfos)
{
object value = pInfo.GetValue(bHoMObject);
HashSet <string> parameterNames = settings.ParameterSettings.ParameterNames(type, pInfo.Name, false);
if (parameterNames != null && element.SetParameters(parameterNames, value))
{
continue;
}
if (elementType == null)
{
continue;
}
parameterNames = settings.ParameterSettings.ParameterNames(type, pInfo.Name, true);
if (parameterNames != null)
{
element.SetParameters(parameterNames, value);
}
}
}
// Sort the parameters so that doubles get assigned last, to make sure all reference levels etc. go first.
foreach (RevitParameter param in fragment.Parameters.Where(x => !(x.Value is double)).Union(fragment.Parameters.Where(x => x.Value is double)))
{
IEnumerable <IParameterLink> parameterLinks = parameterMap.ParameterLinks(param.Name);
if (parameterLinks != null)
{
foreach (IParameterLink parameterLink in parameterLinks)
{
if (parameterLink is ElementParameterLink)
{
element.SetParameters(parameterLink.ParameterNames, param.Value);
}
else if (elementType != null)
{
elementType.SetParameters(parameterLink.ParameterNames, param.Value);
}
}
}
else
{
element.SetParameters(param.Name, param.Value);
}
}
element.Document.Regenerate();
}
