private object TypeCast(IGH_Goo data, IGH_TypeHint hint)
{
if (data == null)
{
return(null);
}
if (hint == null)
{
return(data.ScriptVariable());
}
object objectValue = data.ScriptVariable();
object target;
hint.Cast(objectValue, out target);
return(target);
}
protected override void SolveInstance(IGH_DataAccess DA)
{
Types.BcEntity bcEnt = null;
string propertyName = null;
IGH_Goo propertyValue = null;
Types.PropCategory propertyCategory = null;
if (!DA.GetData("BuildingElement", ref bcEnt) ||
!DA.GetData("PropName", ref propertyName) ||
!DA.GetData("PropVal", ref propertyValue) ||
!DA.GetData("PropCategory", ref propertyCategory))
{
return;
}
var objectId = bcEnt.ObjectId;
object val = null;
switch (propertyValue.ScriptVariable())
{
case string strVal: val = strVal; break;
case int intVal: val = intVal; break;
case double dblVal: val = dblVal; break;
}
if (val == null)
{
AddRuntimeMessage(GH_RuntimeMessageLevel.Error,
string.Format("Conversion failed from {0} to string, int or double", propertyValue.TypeName));
return;
}
if (!Bricscad.Bim.BIMClassification.HasProperty(objectId, propertyName, propertyCategory.Value))
{
AddRuntimeMessage(GH_RuntimeMessageLevel.Error, string.Format("Property with name \"{0}\" does not exist", propertyName));
return;
}
if (Bricscad.Bim.BIMClassification.SetProperty(objectId, propertyName, val, propertyCategory.Value) != Bricscad.Bim.BimResStatus.Ok)
{
AddRuntimeMessage(GH_RuntimeMessageLevel.Error,
string.Format("Failed to set property \"{0}\" for object {1}", propertyName, bcEnt.PersistentRef));
}
}
protected T CreateAssetDataFromInputs(IGH_DataAccess DA)
{
// instantiate an output object
var output = new T();
// set its properties
foreach (var assetPropInfo in _assetData.GetAssetProperties())
{
var paramInfo = _assetData.GetGHParameterInfo(assetPropInfo);
if (paramInfo is null)
{
continue;
}
IGH_Goo inputGHType = default;
var paramIdx = Params.IndexOfInputParam(paramInfo.Name);
if (paramIdx < 0)
{
continue;
}
bool hasInput = DA.GetData(paramInfo.Name, ref inputGHType);
if (hasInput)
{
object inputValue = inputGHType.ScriptVariable();
var valueRange = _assetData.GetAPIAssetPropertyValueRange(assetPropInfo);
if (valueRange != null)
{
inputValue = VerifyInputValue(paramInfo.Name, inputValue, valueRange);
}
assetPropInfo.SetValue(output, inputValue);
output.Mark(assetPropInfo.Name);
}
}
return(output);
}
protected void AddGeometry(File3dm file, IGH_Goo obj)
{
var scriptVariable = obj.ScriptVariable();
var objects = file.Objects;
switch (scriptVariable)
{
case Arc arc: objects.AddArc(arc); break;
case Box box: objects.AddBrep(box.ToBrep()); break;
case Brep brep: objects.AddBrep(brep); break;
case Circle circle: objects.AddCircle(circle); break;
case Curve curve: objects.AddCurve(curve); break;
case Ellipse ellipse: objects.AddEllipse(ellipse); break;
case Extrusion extrusion: objects.AddExtrusion(extrusion); break;
case Hatch hatch: objects.AddHatch(hatch); break;
case Line line: objects.AddLine(line); break;
case Mesh mesh: objects.AddMesh(mesh); break;
case Point3d point: objects.AddPoint(point); break;
case Rectangle3d rect: objects.AddPolyline(rect.ToPolyline()); break;
case Sphere sphere: objects.AddSphere(sphere); break;
case Surface surface: objects.AddSurface(surface); break;
}
}
internal static DB.Parameter GetParameter(IGH_ActiveObject obj, DB.Element element, IGH_Goo key)
{
DB.Parameter parameter = null;
switch (key as Types.ParameterKey ?? key.ScriptVariable())
{
case Types.ParameterKey parameterKey:
if (parameterKey.Document.Equals(element.Document))
{
if (Enum.IsDefined(typeof(DB.BuiltInParameter), parameterKey.Id.IntegerValue))
{
parameter = element.get_Parameter((DB.BuiltInParameter)parameterKey.Id.IntegerValue);
if (parameter is null)
{
obj.AddRuntimeMessage(GH_RuntimeMessageLevel.Warning, $"Parameter '{DB.LabelUtils.GetLabelFor((DB.BuiltInParameter) parameterKey.Id.IntegerValue)}' not defined in 'Element'");
}
}
else if (element.Document.GetElement(parameterKey.Id) is DB.ParameterElement parameterElement)
{
parameter = element.get_Parameter(parameterElement.GetDefinition());
if (parameter is null)
{
obj.AddRuntimeMessage(GH_RuntimeMessageLevel.Warning, $"Parameter '{parameterElement.Name}' not defined in 'Element'");
}
}
else
{
obj.AddRuntimeMessage(GH_RuntimeMessageLevel.Error, $"Data conversion failed from {key.TypeName} to Revit Parameter element");
}
}
else
{
obj.AddRuntimeMessage(GH_RuntimeMessageLevel.Error, $"'ParameterKey' doesn't belong same document as 'Element'");
}
break;
case DB.Parameter param:
if (param.Element.Document.Equals(element.Document) && param.Element.Id == element.Id)
{
parameter = param;
}
else
{
obj.AddRuntimeMessage(GH_RuntimeMessageLevel.Error, $"Parameter '{param.Definition.Name}' doesn't belong to 'Element'");
}
break;
case string parameterName:
parameter = element.GetParameter(parameterName, DBX.ParameterClass.Any);
if (parameter is null)
{
obj.AddRuntimeMessage(GH_RuntimeMessageLevel.Warning, $"Parameter '{parameterName}' not defined in 'Element'");
}
break;
case int parameterId:
if (Enum.IsDefined(typeof(DB.BuiltInParameter), parameterId))
{
parameter = element.get_Parameter((DB.BuiltInParameter)parameterId);
if (parameter is null)
{
obj.AddRuntimeMessage(GH_RuntimeMessageLevel.Warning, $"Parameter '{DB.LabelUtils.GetLabelFor((DB.BuiltInParameter) parameterId)}' not defined in 'Element'");
}
}
else if (element.Document.GetElement(new DB.ElementId(parameterId)) is DB.ParameterElement parameterElement)
{
parameter = element.get_Parameter(parameterElement.GetDefinition());
if (parameter is null)
{
obj.AddRuntimeMessage(GH_RuntimeMessageLevel.Warning, $"Parameter '{parameterElement.Name}' not defined in 'Element'");
}
}
else
{
obj.AddRuntimeMessage(GH_RuntimeMessageLevel.Error, $"Data conversion failed from {key.TypeName} to Revit Parameter element");
}
break;
case DB.ElementId parameterElementId:
if (Enum.IsDefined(typeof(DB.BuiltInParameter), parameterElementId.IntegerValue))
{
parameter = element.get_Parameter((DB.BuiltInParameter)parameterElementId.IntegerValue);
if (parameter is null)
{
obj.AddRuntimeMessage(GH_RuntimeMessageLevel.Warning, $"Parameter '{DB.LabelUtils.GetLabelFor((DB.BuiltInParameter) parameterElementId.IntegerValue)}' not defined in 'Element'");
}
}
else if (element.Document.GetElement(parameterElementId) is DB.ParameterElement parameterElement)
{
parameter = element.get_Parameter(parameterElement.GetDefinition());
if (parameter is null)
{
obj.AddRuntimeMessage(GH_RuntimeMessageLevel.Warning, $"Parameter '{parameterElement.Name}' not defined in 'Element'");
}
}
else
{
obj.AddRuntimeMessage(GH_RuntimeMessageLevel.Error, $"Data conversion failed from {key.TypeName} to Revit Parameter element");
}
break;
case Guid guid:
parameter = element.get_Parameter(guid);
if (parameter is null)
{
obj.AddRuntimeMessage(GH_RuntimeMessageLevel.Warning, $"Parameter '{guid}' not defined in 'Element'");
}
break;
default:
obj.AddRuntimeMessage(GH_RuntimeMessageLevel.Error, $"Data conversion failed from {key.TypeName} to Revit Parameter element");
break;
}
return(parameter);
}
internal static bool SetParameter(IGH_ActiveObject obj, DB.Parameter parameter, IGH_Goo goo)
{
if (goo is null)
{
return(false);
}
try
{
var element = parameter.Element;
var value = goo.ScriptVariable();
var document = default(DB.Document);
if (value is DB.Parameter paramValue)
{
switch (paramValue.StorageType)
{
case DB.StorageType.Integer: value = paramValue.AsInteger(); break;
case DB.StorageType.Double: value = paramValue.AsDoubleInRhinoUnits(); break;
case DB.StorageType.String: value = paramValue.AsString(); break;
case DB.StorageType.ElementId: value = paramValue.AsElementId(); document = paramValue.Element.Document; break;
}
}
switch (parameter.StorageType)
{
case DB.StorageType.Integer:
{
switch (value)
{
case bool boolean: parameter.Set(boolean ? 1 : 0); break;
case int integer: parameter.Set(integer); break;
case double real: parameter.SetDoubleInRhinoUnits((int)Clamp(Round(real), int.MinValue, int.MaxValue)); break;
case System.Drawing.Color color: parameter.Set(((int)color.R) | ((int)color.G << 8) | ((int)color.B << 16)); break;
default: element = null; break;
}
break;
}
case DB.StorageType.Double:
{
switch (value)
{
case int integer: parameter.Set((double)integer); break;
case double real: parameter.SetDoubleInRhinoUnits(real); break;
default: element = null; break;
}
break;
}
case DB.StorageType.String:
{
switch (value)
{
case string str: parameter.Set(str); break;
default: element = null; break;
}
break;
}
case DB.StorageType.ElementId:
{
switch (value)
{
case DB.Element ele:
if (element.Document.Equals(ele.Document))
{
parameter.Set(ele.Id);
}
else
{
obj.AddRuntimeMessage(GH_RuntimeMessageLevel.Error, $"Referencing elements from other documents is not valid");
}
break;
case DB.Category cat:
if (element.Document.Equals(cat.Document()))
{
parameter.Set(cat.Id);
}
else
{
obj.AddRuntimeMessage(GH_RuntimeMessageLevel.Error, $"Referencing categories from other documents is not valid");
}
break;
case DB.ElementId id:
if (document is object)
{
if (element.Document.Equals(document))
{
parameter.Set(id);
}
else
{
obj.AddRuntimeMessage(GH_RuntimeMessageLevel.Error, "Referencing elements from other documents is not valid");
}
}
else
{
element = null;
}
break;
default: element = null; break;
}
break;
}
default:
{
element = null;
break;
}
}
if (element is null && parameter is object)
{
obj.AddRuntimeMessage(GH_RuntimeMessageLevel.Error, $"Failed to cast from {value.GetType().Name} to {parameter.StorageType.ToString()}.");
return(false);
}
}
catch (Autodesk.Revit.Exceptions.InvalidOperationException e)
{
obj.AddRuntimeMessage(GH_RuntimeMessageLevel.Error, $"Failed to set '{parameter.Definition.Name}' value : {e.Message}");
return(false);
}
return(true);
}
public static bool SetParameter(IGH_ActiveObject obj, DB.Element element, DB.Parameter parameter, IGH_Goo goo)
{
try
{
var value = goo.ScriptVariable();
switch (parameter?.StorageType)
{
case DB.StorageType.Integer:
{
switch (value)
{
case bool boolean: parameter.Set(boolean ? 1 : 0); break;
case int integer: parameter.Set(integer); break;
case double real: parameter.Set(Math.Round(ToHost(real, parameter.Definition.ParameterType)).Clamp(int.MinValue, int.MaxValue)); break;
case System.Drawing.Color color: parameter.Set(((int)color.R) | ((int)color.G << 8) | ((int)color.B << 16)); break;
default: element = null; break;
}
break;
}
case DB.StorageType.Double:
{
switch (value)
{
case int integer: parameter.Set((double)integer); break;
case double real: parameter.Set(ToHost(real, parameter.Definition.ParameterType)); break;
default: element = null; break;
}
break;
}
case DB.StorageType.String:
{
switch (value)
{
case string str: parameter.Set(str); break;
default: element = null; break;
}
break;
}
case DB.StorageType.ElementId:
{
switch (value)
{
case DB.Element ele: parameter.Set(ele.Id); break;
case DB.Category cat: parameter.Set(cat.Id); break;
case int integer: parameter.Set(new DB.ElementId(integer)); break;
default: element = null; break;
}
break;
}
default:
{
element = null;
break;
}
}
if (element is null && parameter is object)
{
obj.AddRuntimeMessage(GH_RuntimeMessageLevel.Error, string.Format("Unable to cast 'Value' from {0} to {1}.", value.GetType().Name, parameter.StorageType.ToString()));
}
return(true);
}
catch (Exception e)
{
obj.AddRuntimeMessage(GH_RuntimeMessageLevel.Error, string.Format("Unable to set 'Value' to parameter {0} : {1}", parameter.Definition.Name, e.Message));
}
return(false);
}
/*******************************************/
/**** Private Methods ****/
/*******************************************/
private static T FromGoo <T>(this IGH_Goo goo, IGH_TypeHint hint = null)
{
if (goo == null)
{
return(default(T));
}
// Get the data out of the Goo
object data = goo.ScriptVariable();
while (data is IGH_Goo)
{
data = ((IGH_Goo)data).ScriptVariable();
}
if (data == null)
{
return(default(T));
}
if (data.GetType().Namespace.StartsWith("Rhino.Geometry") && !typeof(T).Namespace.StartsWith("Rhino.Geometry"))
{
data = BH.Engine.Rhinoceros.Convert.IFromRhino(data);
}
// Convert the data to an acceptable format
if (hint != null)
{
object result;
hint.Cast(RuntimeHelpers.GetObjectValue(data), out result);
data = result;
if (data.GetType().Namespace.StartsWith("Rhino.Geometry") && !typeof(T).Namespace.StartsWith("Rhino.Geometry"))
{
data = BH.Engine.Rhinoceros.Convert.IFromRhino(data);
}
}
else if (data is T)
{
return((T)data);
}
else if (data is IEnumerable)
{
UnderlyingType subType = data.GetType().UnderlyingType();
if (typeof(T).IsAssignableFrom(subType.Type))
{
List <T> list = ((IEnumerable)data).Cast <T>().ToList();
if (list.Count == 0)
{
return(default(T));
}
else
{
return(list.First());
}
}
}
try
{
return((T)(data as dynamic));
}
catch
{
Engine.Base.Compute.RecordError("Failed to cast " + data.GetType().IToText() + " into " + typeof(T).IToText());
return(default(T));
}
}
