/// <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)
{
//Get the document from external command data.
UIDocument activeDoc = commandData.Application.ActiveUIDocument;
Autodesk.Revit.DB.Document doc = activeDoc.Document;
if (null == doc)
{
return(Result.Failed);
}
try
{
// Start detailed steel modeling transaction
using (FabricationTransaction trans = new FabricationTransaction(doc, false, "Create structural plate"))
{
// Creating the plate, using AdvanceSteel's Plate class
// for more details, please consult http://www.autodesk.com/adv-steel-api-walkthroughs-2019-enu
Point3d ptOrig = new Point3d(20, 30, 40);
Plate plate = new Plate(new Autodesk.AdvanceSteel.Geometry.Plane(ptOrig, new Vector3d(0, 0, 1)), ptOrig, 1000, 500);
plate.Thickness = 10;
ObjectId idPlate = plate.WriteToDb();
trans.Commit();
}
}
catch (Autodesk.Revit.Exceptions.OperationCanceledException)
{
return(Result.Cancelled);
}
return(Result.Succeeded);
}
public virtual Result Execute(ExternalCommandData commandData, ref string message, ElementSet elements)
{
UIDocument activeDoc = commandData.Application.ActiveUIDocument;
Autodesk.Revit.DB.Document doc = activeDoc.Document;
if (null == doc)
{
return(Result.Failed);
}
try
{
// Start detailed steel modeling transaction
using (FabricationTransaction trans = new FabricationTransaction(doc, false, "Update connection parameters"))
{
// for more details, please consult http://www.autodesk.com/adv-steel-api-walkthroughs-2019-enu
Reference eRef = activeDoc.Selection.PickObject(ObjectType.Element, "Pick a base plate connection");
Element elem = doc.GetElement(eRef.ElementId);
if (null == elem || !(elem is StructuralConnectionHandler))
{
return(Result.Failed);
}
StructuralConnectionHandler rvtConnection = (StructuralConnectionHandler)elem;
FilerObject filerObj = Utilities.Functions.GetFilerObject(doc, eRef);
if (null == filerObj || !(filerObj is UserAutoConstructionObject))
{
return(Result.Failed);
}
UserAutoConstructionObject asConnection = (UserAutoConstructionObject)filerObj;
//
//read connection parameters
IFiler connectionFiler = asConnection.Save();
if (connectionFiler != null)
{
//I choose to modify thickess of the base plate
connectionFiler.WriteItem(Convert.ToDouble(50.0), "BaseThickness"); //units must be milimmeters;
asConnection.Load(connectionFiler); //update connection parameters
asConnection.Update();
//
//if the connection parameters are modified, than we have to set this flag to true,
//meaning that this connection has different parameters than it's connection type.
rvtConnection.OverrideTypeParams = true;
}
trans.Commit();
}
}
catch (Autodesk.Revit.Exceptions.OperationCanceledException)
{
return(Result.Cancelled);
}
return(Result.Succeeded);
}
/// <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)
{
//Get the document from external command data.
UIDocument activeDoc = commandData.Application.ActiveUIDocument;
Autodesk.Revit.DB.Document doc = activeDoc.Document;
if (null == doc)
{
return(Result.Failed);
}
try
{
// Start detailed steel modeling transaction
using (FabricationTransaction trans = new FabricationTransaction(doc, false, "Create hole in plate"))
{
// Creating a plate, using AdvanceSteel classes and objects
// for more details, please consult http://www.autodesk.com/adv-steel-api-walkthroughs-2019-enu
Reference eRef = activeDoc.Selection.PickObject(ObjectType.Element, "Pick a plate");
FilerObject filerObj = Utilities.Functions.GetFilerObject(doc, eRef);
if (null == filerObj)
{
return(Result.Failed);
}
if (!(filerObj is Plate))
{
return(Result.Failed);
}
// Point of reference for the hole in plate feature. We use GlobalPoint. GlobalPoint is the point where the plate is being hit when selected.
Point3d p1 = new Point3d(eRef.GlobalPoint.X, eRef.GlobalPoint.Y, eRef.GlobalPoint.Z);
Plate plate = filerObj as Plate;
// Adding a hole to the plate, using AdvanceSteel classes and objects
Matrix3d csHole = new Matrix3d();
csHole.SetCoordSystem(p1 * Utilities.Functions.FEET_TO_MM, Vector3d.kXAxis, Vector3d.kYAxis, Vector3d.kZAxis);
ConnectionHolePlate hole = new ConnectionHolePlate(plate, csHole);
hole.Arranger = new BoundedRectArranger(0, 0);
hole.Arranger.Nx = 1;
hole.Arranger.Ny = 1;
hole.Hole = new Hole(100);
plate.AddFeature(hole);
hole.updateYourself();
trans.Commit();
}
}
catch (Autodesk.Revit.Exceptions.OperationCanceledException)
{
return(Result.Cancelled);
}
return(Result.Succeeded);
}
/// <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)
{
// Get the document from external command data.
UIDocument activeDoc = commandData.Application.ActiveUIDocument;
Autodesk.Revit.DB.Document doc = activeDoc.Document;
if (null == doc)
{
return(Result.Failed);
}
try
{
// Start detailed steel modeling transaction
using (FabricationTransaction trans = new FabricationTransaction(doc, false, "Create corner cut"))
{
// for more details, please consult http://www.autodesk.com/adv-steel-api-walkthroughs-2019-enu
Reference eRef = activeDoc.Selection.PickObject(ObjectType.Element, "Pick a plate");
FilerObject filerObj = Utilities.Functions.GetFilerObject(doc, eRef);
if (null == filerObj)
{
return(Result.Failed);
}
if (!(filerObj is Plate))
{
return(Result.Failed);
}
// Point of reference for the corner cut feature. We use GlobalPoint. GlobalPoint is the point where the plate is being hit when selected.
Point3d p1 = new Point3d(eRef.GlobalPoint.X, eRef.GlobalPoint.Y, eRef.GlobalPoint.Z);
Plate plate = filerObj as Plate;
// Adding the corner cut feature to the plate. Coordinates are scaled from [ft] to [mm]
int edgeIndex, vertexIndex;
plate.GetEdgeAndVertex(p1 * Utilities.Functions.FEET_TO_MM, out edgeIndex, out vertexIndex);
double radius = 35.0;
PlateFeatVertFillet plateFillet = new PlateFeatVertFillet(0, (short)vertexIndex, radius);
plate.AddFeature(plateFillet);
trans.Commit();
}
}
catch (Autodesk.Revit.Exceptions.OperationCanceledException)
{
return(Result.Cancelled);
}
return(Result.Succeeded);
}
/// <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)
{
// Get the document from external command data.
UIDocument activeDoc = commandData.Application.ActiveUIDocument;
Autodesk.Revit.DB.Document doc = activeDoc.Document;
if (null == doc)
{
return(Result.Failed);
}
try
{
// Selecting the elements to create the anchor pattern on
Reference eRef = activeDoc.Selection.PickObject(ObjectType.Element, "Pick an element to create the anchor pattern on");
// Start detailed steel modeling transaction
using (FabricationTransaction trans = new FabricationTransaction(activeDoc.Document, false, "Create anchor pattern"))
{
// We create the anchor pattern using Advance Steel classes and objects only.
// for more details, please consult http://www.autodesk.com/adv-steel-api-walkthroughs-2019-enu
List <FilerObject> filerObjectList = new List <FilerObject>();
FilerObject filerObj = Utilities.Functions.GetFilerObject(doc, eRef);
if (null == filerObj)
{
return(Result.Failed);
}
filerObjectList.Add(filerObj);
// Point of reference for the anchor pattern. We use GlobalPoint to create the pattern on the plate. GlobalPoint is the point where the plate is being hit when selected.
Point3d p1 = new Point3d(eRef.GlobalPoint.X, eRef.GlobalPoint.Y, eRef.GlobalPoint.Z);
Point3d p2 = new Point3d(p1.x + 0.5, p1.y + 0.5, p1.z + 0.5);
AnchorPattern anchorPattern = new AnchorPattern(p1 * Utilities.Functions.FEET_TO_MM, p2 * Utilities.Functions.FEET_TO_MM, new Vector3d(1, 0, 0), new Vector3d(0, 1, 0));
anchorPattern.Connect(filerObjectList.ToArray(), Autodesk.AdvanceSteel.ConstructionTypes.AtomicElement.eAssemblyLocation.kOnSite);
anchorPattern.WriteToDb();
trans.Commit();
}
}
catch (Autodesk.Revit.Exceptions.OperationCanceledException)
{
return(Result.Cancelled);
}
return(Result.Succeeded);
}
/// <summary>
/// Creates steel plate.
/// </summary>
/// <returns>Returns Revit id of the created plate.</returns>
private ElementId CreatePlate(XYZ plateCenter)
{
ElementId ret = ElementId.InvalidElementId;
Guid plateUniqueId = Guid.Empty;
try
{
// Start detailed steel modeling transaction
using (FabricationTransaction trans = new FabricationTransaction(_doc, false, "Create structural plate"))
{
// Create a plate using Advance Steel API (internal Advance Steel units are in mm)
Point3d orig = new Point3d(Utilities.Functions.FEET_TO_MM * plateCenter.X,
Utilities.Functions.FEET_TO_MM * plateCenter.Y,
Utilities.Functions.FEET_TO_MM * plateCenter.Z);
Plate plate = new Plate(new Autodesk.AdvanceSteel.Geometry.Plane(Point3d.kOrigin, Vector3d.kZAxis), orig, 2000, 1000);
plate.Thickness = 10;
// Write plate to database.
plate.WriteToDb();
plateUniqueId = plate.GetUniqueId();
trans.Commit();
}
}
catch (System.InvalidOperationException ex)
{
//Cannot copy plate due to background calculation in progress !
System.Diagnostics.Debug.WriteLine(ex.Message);
}
// Get Revit element id from Advance Steel plate unique id.
Reference elem = SteelElementProperties.GetReference(_doc, plateUniqueId);
if (elem != null)
{
ret = elem.ElementId;
}
return(ret);
}
/// <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)
{
//Get the document from external command data.
UIDocument activeDoc = commandData.Application.ActiveUIDocument;
Autodesk.Revit.DB.Document doc = activeDoc.Document;
if (null == doc)
{
return(Result.Failed);
}
try
{
// The list of elements to create the shear stud pattern on
Reference eRef = activeDoc.Selection.PickObject(ObjectType.Face, "Please pick an element to create the shear stud pattern on");
// Start detailed steel modeling transaction
using (FabricationTransaction trans = new FabricationTransaction(doc, false, "Create shear stud pattern"))
{
// Creating the shear stud pattern involves using AdvanceSteel classes and objects only.
// for more details, please consult http://www.autodesk.com/adv-steel-api-walkthroughs-2019-enu
FilerObject filerObj = Utilities.Functions.GetFilerObject(doc, eRef);
if (null == filerObj)
{
return(Result.Failed);
}
Autodesk.AdvanceSteel.Modelling.Connector shearStud = new Autodesk.AdvanceSteel.Modelling.Connector();
shearStud.WriteToDb();
// Creating a rectangle for the shear stud pattern. A Polyline3d is required for the rectangle. We will use it for the Arranger and the Matrix3d objects.
Polyline3d polyLine = new Polyline3d();
Matrix3d matCS = new Matrix3d();
Arranger arranger = null;
double x = eRef.GlobalPoint.X * Utilities.Functions.FEET_TO_MM;
double y = eRef.GlobalPoint.Y * Utilities.Functions.FEET_TO_MM;
double z = eRef.GlobalPoint.Z * Utilities.Functions.FEET_TO_MM;
double w = 500; // width of the contour;
double h = 500; // height of the contour;
polyLine.Append(new Point3d(x, y, z));
polyLine.Append(new Point3d(x + w, y, z));
polyLine.Append(new Point3d(x + w, y + h, z));
polyLine.Append(new Point3d(x, y + h, z));
Point3d[] vertices = polyLine.Vertices;
if (vertices.Length == 4) //rectangular shear stud pattern
{
Vector3d xAxis1 = vertices[0].Subtract(vertices[1]);
Vector3d xAxis2 = vertices[0].Subtract(vertices[3]);
Vector3d zAxis = new Vector3d(0, 0, 1);
Vector3d vDiag = vertices[0].Subtract(vertices[2]);
Point3d orig = new Point3d(vertices[2]);
orig = orig.Add(vDiag * 0.5);
if (xAxis1.GetLength() > xAxis2.GetLength())
{
arranger = new BoundedRectArranger(xAxis1.GetLength(), xAxis2.GetLength());
matCS.SetCoordSystem(orig, xAxis1.Normalize(), zAxis.CrossProduct(xAxis1).Normalize(), zAxis.Normalize());
}
else
{
arranger = new BoundedRectArranger(xAxis2.GetLength(), xAxis1.GetLength());
matCS.SetCoordSystem(orig, xAxis2.Normalize(), zAxis.CrossProduct(xAxis2).Normalize(), zAxis.Normalize());
}
arranger.Nx = 2;
arranger.Ny = 2;
}
shearStud.Arranger = arranger;
shearStud.SetCS(matCS);
shearStud.Connect(filerObj, matCS);
shearStud.Material = "Mild Steel";
shearStud.Standard = "Nelson S3L-Inch";
shearStud.Diameter = 19.05;
shearStud.Length = 101.6;
trans.Commit();
}
}
catch (Autodesk.Revit.Exceptions.OperationCanceledException)
{
return(Result.Cancelled);
}
return(Result.Succeeded);
}
/// <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)
{
//Get the document from external command data.
UIDocument activeDoc = commandData.Application.ActiveUIDocument;
Autodesk.Revit.DB.Document doc = activeDoc.Document;
if (null == doc)
{
return(Result.Failed);
}
try
{
// Start detailed steel modeling transaction
using (FabricationTransaction trans = new FabricationTransaction(doc, false, "Create cope skewed"))
{
// for more details, please consult http://www.autodesk.com/adv-steel-api-walkthroughs-2019-enu
Reference eRef = activeDoc.Selection.PickObject(ObjectType.Element, "Pick a beam");
Element elem = null;
if (eRef != null && eRef.ElementId != ElementId.InvalidElementId)
{
elem = doc.GetElement(eRef.ElementId);
}
if (null == elem)
{
return(Result.Failed);
}
// adding fabrication data, if the element doesn't already have it.
SteelElementProperties cell = SteelElementProperties.GetSteelElementProperties(elem);
if (null == cell)
{
List <ElementId> elemsIds = new List <ElementId>();
elemsIds.Add(elem.Id);
SteelElementProperties.AddFabricationInformationForRevitElements(doc, elemsIds);
}
FilerObject filerObj = Utilities.Functions.GetFilerObject(doc, eRef);
if (null == filerObj)
{
return(Result.Failed);
}
if (!(filerObj is Beam))
{
return(Result.Failed);
}
// Creating a beam, using AdvanceSteel classes
Beam beam = filerObj as Beam;
// Calculating the end and the side of the beam
Beam.eEnd end = Utilities.Functions.CalculateBeamEnd(beam, new XYZ(eRef.GlobalPoint.X, eRef.GlobalPoint.Y, eRef.GlobalPoint.Z));
Beam.eSide side = Utilities.Functions.CalculateBeamSide(beam, new XYZ(eRef.GlobalPoint.X, eRef.GlobalPoint.Y, eRef.GlobalPoint.Z));
double length = 1000;
double depth = -50;
// Adding the cope feature to the beam, using AdvanceSteel's BeamNotchEx class.
BeamNotchEx cope = new BeamNotchEx(end, side, length, depth);
beam.AddFeature(cope);
trans.Commit();
}
}
catch (Autodesk.Revit.Exceptions.OperationCanceledException)
{
return(Result.Cancelled);
}
return(Result.Succeeded);
}
/// <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)
{
// Get the document from external command data.
UIDocument activeDoc = commandData.Application.ActiveUIDocument;
Autodesk.Revit.DB.Document doc = activeDoc.Document;
if (null == doc)
{
return(Result.Failed);
}
try
{
// Start detailed steel modeling transaction
using (FabricationTransaction trans = new FabricationTransaction(doc, false, "Create contour cut"))
{
// for more details, please consult http://www.autodesk.com/adv-steel-api-walkthroughs-2019-enu
// Selecting the elements to create the contour cut on
Reference eRef = activeDoc.Selection.PickObject(ObjectType.Element, "Please pick an element to create the contour cut on");
// getting the selected element
Element elem = null;
if (eRef != null && eRef.ElementId != ElementId.InvalidElementId)
{
elem = doc.GetElement(eRef.ElementId);
}
if (null == elem)
{
return(Result.Failed);
}
// ensuring the element has FabricationData
SteelElementProperties cell = SteelElementProperties.GetSteelElementProperties(elem);
if (null == cell)
{
List <ElementId> elemsIds = new List <ElementId>();
elemsIds.Add(elem.Id);
SteelElementProperties.AddFabricationInformationForRevitElements(doc, elemsIds);
}
FilerObject filerObj = Utilities.Functions.GetFilerObject(doc, eRef);
if (null == filerObj)
{
return(Result.Failed);
}
if (!(filerObj is Plate) && !(filerObj is Beam))
{
return(Result.Failed);
}
// The point where the element was hit when selected.
Point3d p1 = new Point3d(eRef.GlobalPoint.X, eRef.GlobalPoint.Y, eRef.GlobalPoint.Z);
// Contour coordinates, according to the point where the element was hit when selected
double x = Utilities.Functions.FEET_TO_MM * p1.x; // x of upper-left corner of the contour;
double y = Utilities.Functions.FEET_TO_MM * p1.y; // y of upper-left corner of the contour;
double z = Utilities.Functions.FEET_TO_MM * p1.z; // z of upper-left corner of the contour;
// Adding the contour cut, using AdvanceSteel classes.
Polyline3d plContour;
Polyline3d contour = new Polyline3d();
if (filerObj is Plate)
{
double w = 500; // width of the contour;
double h = 500; // height of the contour;
contour.Append(new Point3d(x, y, z));
contour.Append(new Point3d(x + w, y, z));
contour.Append(new Point3d(x + w, y + h, z));
contour.Append(new Point3d(x, y + h, z));
if (contour.VertexCount <= 0)
{
return(Result.Failed);
}
Plate plate = filerObj as Plate;
plate.GetBaseContourPolygon(1, out plContour);
plContour.Project(new Autodesk.AdvanceSteel.Geometry.Plane(contour.Vertices[0], contour.PolyNormal), contour.PolyNormal);
PlateContourNotch plateContour = new PlateContourNotch(plate, 0, contour, contour.Normal, contour.Normal.GetPerpVector());
plate.AddFeature(plateContour);
}
else if (filerObj is Beam)
{
double w = 50; // width of the contour;
double h = 50; // height of the contour;
contour.Append(new Point3d(x, y, z));
contour.Append(new Point3d(x + w, y, z));
contour.Append(new Point3d(x + w, y, z + h));
contour.Append(new Point3d(x, y, z + h));
if (contour.VertexCount <= 0)
{
return(Result.Failed);
}
Beam beam = filerObj as Beam;
Point3d ptClosest = beam.GetClosestPointToSystemline(contour.Vertices[0]);
double d1 = ptClosest.DistanceTo(beam.GetPointAtStart());
double d2 = ptClosest.DistanceTo(beam.GetPointAtEnd());
Beam.eEnd beamEnd = d1 > d2 ? Beam.eEnd.kEnd : Beam.eEnd.kStart;
Vector3d normal = contour.Normal;
Vector3d xVec = normal.GetPerpVector();
BeamMultiContourNotch beamContour = new BeamMultiContourNotch(beam, beamEnd, contour, normal, xVec);
beam.AddFeature(beamContour);
}
trans.Commit();
}
}
catch (Autodesk.Revit.Exceptions.OperationCanceledException)
{
return(Result.Cancelled);
}
return(Result.Succeeded);
}
/// <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)
{
// Get the document from external command data.
UIDocument activeDoc = commandData.Application.ActiveUIDocument;
Autodesk.Revit.DB.Document doc = activeDoc.Document;
if (null == doc)
{
return(Result.Failed);
}
try
{
// Start detailed steel modeling transaction
using (FabricationTransaction trans = new FabricationTransaction(doc, false, "Create weld point"))
{
// for more details, please consult http://www.autodesk.com/adv-steel-api-walkthroughs-2019-enu
Reference eRef = activeDoc.Selection.PickObject(ObjectType.Edge, "Pick an edge");
Element elem = null;
if (eRef != null && eRef.ElementId != ElementId.InvalidElementId)
{
elem = (doc.GetElement(eRef.ElementId));
}
if (null == elem)
{
return(Result.Failed);
}
// adding fabrication data, if the element doesn't already have it.
SteelElementProperties cell = SteelElementProperties.GetSteelElementProperties(elem);
if (null == cell)
{
List <ElementId> elemsIds = new List <ElementId>();
elemsIds.Add(elem.Id);
SteelElementProperties.AddFabricationInformationForRevitElements(doc, elemsIds);
}
FilerObject filerObj = Utilities.Functions.GetFilerObject(doc, eRef);
if (null == filerObj)
{
return(Result.Failed);
}
// Point of reference for the weld point. We use GlobalPoint to create the weld point on the selected edge. GlobalPoint is the point where the edge is being hit when selected.
Point3d p1 = new Point3d(eRef.GlobalPoint.X, eRef.GlobalPoint.Y, eRef.GlobalPoint.Z);
// Creating a weld point, using AdvanceSteel's WeldPoint class
Vector3d vX = new Vector3d(100, 100, 100);
Vector3d vY = new Vector3d(100, 100, 100);
WeldPoint weld = new WeldPoint(p1 * Utilities.Functions.FEET_TO_MM, vX, vY);
if (null != weld)
{
weld.WriteToDb();
HashSet <FilerObject> objsToConnect = new HashSet <FilerObject>();
objsToConnect.Add(filerObj);
weld.Connect(objsToConnect, Autodesk.AdvanceSteel.ConstructionTypes.AtomicElement.eAssemblyLocation.kInShop);
}
trans.Commit();
}
}
catch (Autodesk.Revit.Exceptions.OperationCanceledException)
{
return(Result.Cancelled);
}
return(Result.Succeeded);
}
/// <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)
{
// Get the document from external command data.
UIDocument activeDoc = commandData.Application.ActiveUIDocument;
Autodesk.Revit.DB.Document doc = activeDoc.Document;
if (null == doc)
{
return(Result.Failed);
}
try
{
// Start detailed steel modeling transaction
using (FabricationTransaction trans = new FabricationTransaction(doc, false, "Create shortening"))
{
Reference eRef = activeDoc.Selection.PickObject(ObjectType.Element, "Pick a beam to add shortening on it");
Element elem = null;
if (eRef != null && eRef.ElementId != ElementId.InvalidElementId)
{
elem = (doc.GetElement(eRef.ElementId));
}
if (null == elem)
{
return(Result.Failed);
}
// adding fabrication information, if the element doesn't already have it.
SteelElementProperties cell = SteelElementProperties.GetSteelElementProperties(elem);
if (null == cell)
{
List <ElementId> elemsIds = new List <ElementId>();
elemsIds.Add(elem.Id);
SteelElementProperties.AddFabricationInformationForRevitElements(doc, elemsIds);
}
// Create the modifier using AdvanceSteel API.
// For more details, please consult http://www.autodesk.com/adv-steel-api-walkthroughs-2019-enu
FilerObject filerObj = Utilities.Functions.GetFilerObject(doc, eRef);
if (null != filerObj)
{
if (!(filerObj is Beam))
{
return(Result.Failed);
}
Beam beam = filerObj as Beam;
Beam.eEnd end = Utilities.Functions.CalculateBeamEnd(beam, new XYZ(10, 20, 20));
BeamShortening beamShort = new BeamShortening(end, 150.0);
beam.AddFeature(beamShort);
}
trans.Commit();
}
}
catch (Autodesk.Revit.Exceptions.OperationCanceledException)
{
return(Result.Cancelled);
}
return(Result.Succeeded);
}