/// <summary>
/// Implement this method as an external command for Revit.
/// </summary>
/// <param name="commandData">An object that is passed to the external application
/// which contains data related to the command,
/// such as the application object and active view.</param>
/// <param name="message">A message that can be set by the external application
/// which will be displayed if a failure or cancellation is returned by
/// the external command.</param>
/// <param name="elements">A set of elements to which the external application
/// can add elements that are to be highlighted in case of failure or cancellation.</param>
/// <returns>Return the status of the external command.
/// A result of Succeeded means that the API external method functioned as expected.
/// Cancelled can be used to signify that the user cancelled the external operation
/// at some point. Failure should be returned if the application is unable to proceed with
/// the operation.</returns>
public virtual Result Execute(ExternalCommandData commandData
, ref string message, ElementSet elements)
{
try
{
Document doc = commandData.Application.ActiveUIDocument.Document;
if (doc == null)
{
return(Result.Failed);
}
//Fetch a RebarBarType element to be used in Rebar creation.
FilteredElementCollector fec = new FilteredElementCollector(doc).OfClass(typeof(RebarBarType));
if (fec.GetElementCount() <= 0)
{
return(Result.Failed);
}
RebarBarType barType = fec.FirstElement() as RebarBarType;
Rebar rebar = null;
CurveElement curveElem = null;
using (Transaction tran = new Transaction(doc, "Create Rebar"))
{
Element host = null;
Selection sel = commandData.Application.ActiveUIDocument.Selection;
try
{
//Select structural Host.
Reference hostRef = sel.PickObject(ObjectType.Element, "Select Host");
host = doc.GetElement(hostRef.ElementId);
if (host == null)
{
return(Result.Failed);
}
}
catch (Exception e)
{
message = e.Message;
return(Result.Failed);
}
try
{
//Select curve element
Reference lineRef = sel.PickObject(ObjectType.Element, "Select Model curve");
curveElem = doc.GetElement(lineRef.ElementId) as CurveElement;
}
catch (Exception)
{
curveElem = null;
}
tran.Start();
// Create Rebar Free Form by specifying the GUID defining the custom external server.
// The Rebar element returned needs to receive constraints, so that regeneration can
// call the custom geometry calculations and create the bars
rebar = Rebar.CreateFreeForm(doc, RebarUpdateServer.SampleGuid, barType, host);
// Get all bar handles to set constraints to them, so that the bar can generate its geometry
RebarConstraintsManager rManager = rebar.GetRebarConstraintsManager();
IList <RebarConstrainedHandle> handles = rManager.GetAllHandles();
// if bar has no handles then the server can't generate rebar geometry
if (handles.Count <= 0)
{
tran.RollBack();
return(Result.Failed);
}
// iterate through the rebar handles and prompt for face selection for each of them, to get user input
foreach (RebarConstrainedHandle handle in handles)
{
if (handle.GetHandleType() == RebarHandleType.StartOfBar ||
handle.GetHandleType() == RebarHandleType.EndOfBar)
{
continue;// Start handle and end handle will receive constraints from the custom external server execution
}
try
{
Reference reference = sel.PickObject(ObjectType.Face, "Select face for " + handle.GetHandleName());
if (reference == null)
{
continue;
}
// create constraint using the picked faces and set it to the associated handle
List <Reference> refs = new List <Reference>();
refs.Add(reference);
RebarConstraint constraint = RebarConstraint.Create(handle, refs, true, 0.0);
rManager.SetPreferredConstraintForHandle(handle, constraint);
}
catch (Exception e)
{
message = e.Message;
tran.RollBack();
return(Result.Cancelled);
}
}
try
{
//here we add a value to the shared parameter and add it to the regeneration dependencies
Parameter newSharedParam = rebar.LookupParameter(AddSharedParams.m_paramName);
Parameter newSharedParam2 = rebar.LookupParameter(AddSharedParams.m_CurveIdName);
if (newSharedParam != null && newSharedParam2 != null)
{
newSharedParam.Set(0);
newSharedParam2.Set(curveElem == null ? -1 : curveElem.Id.IntegerValue);
RebarFreeFormAccessor accesRebar = rebar.GetFreeFormAccessor();
accesRebar.AddUpdatingSharedParameter(newSharedParam.Id);
accesRebar.AddUpdatingSharedParameter(newSharedParam2.Id);
}
else
{
// The AddSharedParams command should be executed to create and bind these parameters to rebar.
}
}
catch (Exception ex)
{
message = ex.Message;
tran.RollBack();
return(Result.Cancelled);
}
tran.Commit();
return(Result.Succeeded);
}
}
catch (Exception ex)
{
message = ex.Message;
return(Result.Failed);
}
}
/***************************************************/
/**** Private methods ****/
/***************************************************/
private static Rebar ToRevitRebar(this IReinforcingBar bar, Document document, RevitSettings settings = null, Dictionary <Guid, List <int> > refObjects = null)
{
if (bar == null || document == null)
{
return(null);
}
Rebar rebar = refObjects.GetValue <Rebar>(document, bar.BHoM_Guid);
if (rebar != null)
{
return(rebar);
}
settings = settings.DefaultIfNull();
//getting host
Element host = null;
if (bar.CustomData.ContainsKey("HostId"))
{
host = document.GetElement(new ElementId((int)bar.CustomData["HostId"]));
}
else
{
BH.Engine.Reflection.Compute.RecordError("One or more rebars does not contain information about the host.");
return(null);
}
if (host == null)
{
BH.Engine.Reflection.Compute.RecordError($"Rebar host with ID: {bar.CustomData["host"]} does not exist in the Revit project.");
return(null);
}
//getting bar type
RebarBarType barType = bar.ElementType(document, settings);
if (barType == null)
{
BH.Engine.Reflection.Compute.RecordError($"Revit project does not contain rebar family containing type with matching diameter for one or more rebars.\nMissing Family: \"Rebar Bar : {(int)(bar.Diameter * 1000)}\"");
return(null);
}
//setting bend radiuses
barType.SetParameter(BuiltInParameter.REBAR_STANDARD_BEND_DIAMETER, bar.BendRadius * 2);
barType.SetParameter(BuiltInParameter.REBAR_STANDARD_HOOK_BEND_DIAMETER, bar.BendRadius * 2);
barType.SetParameter(BuiltInParameter.REBAR_BAR_STIRRUP_BEND_DIAMETER, bar.BendRadius * 2);
//creating rebar
RebarFreeFormValidationResult rffvr = new RebarFreeFormValidationResult();
List <List <Curve> > curves = new List <List <Curve> > {
bar.CentreCurve.IToRevitCurves()
}; //
IList <IList <Curve> > iListCurves = new List <IList <Curve> >(); // Needed to convert
foreach (List <Curve> list in curves) // List<List<Curve>> -> IList<IList<Curve>>
{
iListCurves.Add(list); //
}
rebar = Rebar.CreateFreeForm(document, barType, host, iListCurves, out rffvr);
//setting hooks
if (bar.GetType() == typeof(Stirrup))
{
RebarHookType rht = new FilteredElementCollector(document).OfClass(typeof(RebarHookType)).Where(x => x.Name == "Standard - 90 deg.").FirstOrDefault() as RebarHookType;
rebar.SetHookTypeId(0, rht.Id);
rebar.SetHookTypeId(1, rht.Id);
rebar.SetHookOrientation(0, RebarHookOrientation.Left);
rebar.SetHookOrientation(1, RebarHookOrientation.Left);
}
rebar.CopyParameters(bar, settings);
refObjects.AddOrReplace(bar, rebar);
return(rebar);
}