Stream(ArrayList data, RebarConstraintsManager rbcm)
{
data.Add(new Snoop.Data.ClassSeparator(typeof(RebarConstraintsManager)));
data.Add(new Snoop.Data.Enumerable("ConstrainedHandles", rbcm.GetAllConstrainedHandles()));
foreach (RebarConstrainedHandle ch in rbcm.GetAllConstrainedHandles())
{
data.Add(new Snoop.Data.Object("Current Constraint on Handle", rbcm.GetCurrentConstraintOnHandle(ch)));
data.Add(new Snoop.Data.Object("User Preferred Constraint on Handle", rbcm.GetPreferredConstraintOnHandle(ch)));
data.Add(new Snoop.Data.Enumerable("ConstraintCandidatesFor Handle", rbcm.GetConstraintCandidatesForHandle(ch)));
}
}
CollectEvent(object sender, CollectorEventArgs e)
{
// cast the sender object to the SnoopCollector we are expecting
Collector snoopCollector = sender as Collector;
if (snoopCollector == null)
{
Debug.Assert(false); // why did someone else send us the message?
return;
}
// see if it is a type we are responsible for
Color color = e.ObjToSnoop as Color;
if (color != null)
{
Stream(snoopCollector.Data(), color);
return;
}
LayoutRule layoutRule = e.ObjToSnoop as LayoutRule;
if (layoutRule != null)
{
Stream(snoopCollector.Data(), layoutRule);
return;
}
FormatOptions formatOptions = e.ObjToSnoop as FormatOptions;
if (formatOptions != null)
{
Stream(snoopCollector.Data(), formatOptions);
return;
}
CurtainGrid curtainGrid = e.ObjToSnoop as CurtainGrid;
if (curtainGrid != null)
{
Stream(snoopCollector.Data(), curtainGrid);
return;
}
CurtainCell curtainCell = e.ObjToSnoop as CurtainCell;
if (curtainCell != null)
{
Stream(snoopCollector.Data(), curtainCell);
return;
}
RebarHostData rebarHostData = e.ObjToSnoop as RebarHostData;
if (rebarHostData != null)
{
Stream(snoopCollector.Data(), rebarHostData);
return;
}
Leader leader = e.ObjToSnoop as Leader;
if (leader != null)
{
Stream(snoopCollector.Data(), leader);
return;
}
AreaVolumeSettings areaSettings = e.ObjToSnoop as AreaVolumeSettings;
if (areaSettings != null)
{
Stream(snoopCollector.Data(), areaSettings);
return;
}
ViewSheetSetting viewSheetSetting = e.ObjToSnoop as ViewSheetSetting;
if (viewSheetSetting != null)
{
Stream(snoopCollector.Data(), viewSheetSetting);
return;
}
Autodesk.Revit.UI.Events.DialogBoxData dlgBoxData = e.ObjToSnoop as Autodesk.Revit.UI.Events.DialogBoxData;
if (dlgBoxData != null)
{
Stream(snoopCollector.Data(), dlgBoxData);
return;
}
Construction construct = e.ObjToSnoop as Construction;
if (construct != null)
{
Stream(snoopCollector.Data(), construct);
return;
}
FamilyElementVisibility famElemVisib = e.ObjToSnoop as FamilyElementVisibility;
if (famElemVisib != null)
{
Stream(snoopCollector.Data(), famElemVisib);
return;
}
FamilyManager famManager = e.ObjToSnoop as FamilyManager;
if (famManager != null)
{
Stream(snoopCollector.Data(), famManager);
return;
}
FamilyParameter famParam = e.ObjToSnoop as FamilyParameter;
if (famParam != null)
{
Stream(snoopCollector.Data(), famParam);
return;
}
FamilyType famType = e.ObjToSnoop as FamilyType;
if (famType != null)
{
Stream(snoopCollector.Data(), famType);
return;
}
MEPSpaceConstruction mepSpaceConstuct = e.ObjToSnoop as MEPSpaceConstruction;
if (mepSpaceConstuct != null)
{
Stream(snoopCollector.Data(), mepSpaceConstuct);
return;
}
BuildingSiteExportOptions bldSiteExpOptions = e.ObjToSnoop as BuildingSiteExportOptions;
if (bldSiteExpOptions != null)
{
Stream(snoopCollector.Data(), bldSiteExpOptions);
return;
}
DGNExportOptions dgnExpOptions = e.ObjToSnoop as DGNExportOptions;
if (dgnExpOptions != null)
{
Stream(snoopCollector.Data(), dgnExpOptions);
return;
}
DWFExportOptions dwfExpOptions = e.ObjToSnoop as DWFExportOptions;
if (dwfExpOptions != null)
{
Stream(snoopCollector.Data(), dwfExpOptions);
return;
}
DWGExportOptions dwgExpOptions = e.ObjToSnoop as DWGExportOptions;
if (dwgExpOptions != null)
{
Stream(snoopCollector.Data(), dwgExpOptions);
return;
}
DWGImportOptions dwgImpOptions = e.ObjToSnoop as DWGImportOptions;
if (dwgImpOptions != null)
{
Stream(snoopCollector.Data(), dwgImpOptions);
return;
}
FBXExportOptions fbxExpOptions = e.ObjToSnoop as FBXExportOptions;
if (fbxExpOptions != null)
{
Stream(snoopCollector.Data(), fbxExpOptions);
return;
}
TrussMemberInfo trussInfo = e.ObjToSnoop as TrussMemberInfo;
if (trussInfo != null)
{
Stream(snoopCollector.Data(), trussInfo);
return;
}
VertexIndexPair vertIndPair = e.ObjToSnoop as VertexIndexPair;
if (vertIndPair != null)
{
Stream(snoopCollector.Data(), vertIndPair);
return;
}
PointElementReference ptElemRef = e.ObjToSnoop as PointElementReference;
if (ptElemRef != null)
{
Stream(snoopCollector.Data(), ptElemRef);
return;
}
Autodesk.Revit.DB.Architecture.BoundarySegment boundSeg = e.ObjToSnoop as Autodesk.Revit.DB.Architecture.BoundarySegment;
if (boundSeg != null)
{
Stream(snoopCollector.Data(), boundSeg);
return;
}
PointLocationOnCurve ptLocOnCurve = e.ObjToSnoop as PointLocationOnCurve;
if (ptLocOnCurve != null)
{
Stream(snoopCollector.Data(), ptLocOnCurve);
return;
}
Entity entity = e.ObjToSnoop as Entity;
if (entity != null)
{
Stream(snoopCollector.Data(), entity);
return;
}
Field field = e.ObjToSnoop as Field;
if (field != null)
{
Stream(snoopCollector.Data(), field);
return;
}
ExtensibleStorageField storeagefield = e.ObjToSnoop as ExtensibleStorageField;
if (storeagefield != null)
{
Stream(snoopCollector.Data(), storeagefield);
return;
}
IList <Autodesk.Revit.DB.BoundarySegment> boundSegs = e.ObjToSnoop as
IList <Autodesk.Revit.DB.BoundarySegment>;
if (boundSegs != null)
{
Stream(snoopCollector.Data(), boundSegs);
return;
}
if (e.ObjToSnoop is KeyValuePair <String, String> )
{
KeyValuePair <String, String> stringspair = (KeyValuePair <String, String>)e.ObjToSnoop;
Stream(snoopCollector.Data(), stringspair);
return;
}
Schema schema = e.ObjToSnoop as Schema;
if (schema != null)
{
Stream(snoopCollector.Data(), schema);
return;
}
ElementId elemId = e.ObjToSnoop as ElementId;
if (elemId != null)
{
Stream(snoopCollector.Data(), elemId);
return;
}
PlanViewRange plvr = e.ObjToSnoop as PlanViewRange;
if (plvr != null)
{
Stream(snoopCollector.Data(), plvr);
return;
}
//TF
RebarConstraintsManager rbcm = e.ObjToSnoop as RebarConstraintsManager;
if (rbcm != null)
{
Stream(snoopCollector.Data(), rbcm);
return;
}
RebarConstrainedHandle rbch = e.ObjToSnoop as RebarConstrainedHandle;
if (rbch != null)
{
Stream(snoopCollector.Data(), rbch);
return;
}
RebarConstraint rbc = e.ObjToSnoop as RebarConstraint;
if (rbc != null)
{
Stream(snoopCollector.Data(), rbc);
return;
}
//TFEND
if (Utils.IsSupportedType(e.ObjToSnoop) && e.ObjToSnoop != null)
{
Utils.StreamWithReflection(snoopCollector.Data(), e.ObjToSnoop.GetType(), e.ObjToSnoop);
}
}
Stream(ArrayList data, RebarConstraintsManager rbcm)
{
data.Add(new Snoop.Data.ClassSeparator(typeof(RebarConstraintsManager)));
data.Add(new Snoop.Data.Enumerable("ConstrainedHandles", rbcm.GetAllConstrainedHandles()));
foreach (RebarConstrainedHandle ch in rbcm.GetAllConstrainedHandles())
{
data.Add(new Snoop.Data.Object("Current Constraint on Handle", rbcm.GetCurrentConstraintOnHandle(ch)));
data.Add(new Snoop.Data.Object("User Preferred Constraint on Handle", rbcm.GetPreferredConstraintOnHandle(ch)));
data.Add(new Snoop.Data.Enumerable("ConstraintCandidatesFor Handle", rbcm.GetConstraintCandidatesForHandle(ch)));
}
}
/// <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);
}
}
