public bool AllowElement(Element elem)
{
if (elem is Rebar)
{
Rebar rb = elem as Rebar;
if (rb.LookupParameter("Style").AsInteger() == 1 || rb.LookupParameter("Type").AsString() == "Lockhead")
{
return(true);
}
}
return(false);
}
public void Execute(UpdaterData data)
{
try
{
ICollection <ElementId> modifiedIds = data.GetModifiedElementIds();
if (modifiedIds.Count > 0)// if any curveElement was modified
{
//get all rebar elements anf filter them, to see which need to be notified of the change
FilteredElementCollector collector = new FilteredElementCollector(data.GetDocument());
IList <Element> elemBars = collector.OfClass(typeof(Rebar)).ToElements();
foreach (Element elem in elemBars)
{
Rebar bar = elem as Rebar;
if (bar == null)
{
continue;
}
if (!bar.IsRebarFreeForm())// only need free form bars
{
continue;
}
RebarFreeFormAccessor barAccess = bar.GetFreeFormAccessor();
if (!barAccess.GetServerGUID().Equals(RebarUpdateServer.SampleGuid))// only use our custom FreeForm
{
continue;
}
Parameter paramCurveId = bar.LookupParameter(AddSharedParams.m_CurveIdName);
if (paramCurveId == null)
{
continue;
}
ElementId id = new ElementId(paramCurveId.AsInteger());
if (id == ElementId.InvalidElementId)
{
continue;
}
if (modifiedIds.Contains(id))// if id of line is in the rebar, then trigger regen
{
var param = bar.LookupParameter(AddSharedParams.m_paramName);
param.Set(param.AsInteger() == 0 ? 1 : 0);// just flip the value to register a change that will trigger the regeneration of that rebar on commit.
}
}
return;
}
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
}
}
CurveElement getSelectedCurveElement(Rebar bar, RebarUpdateCurvesData data)
{
RebarFreeFormAccessor barAccess = bar.GetFreeFormAccessor();
ElementId id = new ElementId(bar.LookupParameter(AddSharedParams.m_CurveIdName).AsInteger());
return(data.GetDocument().GetElement(id) as CurveElement);
}
public bool AllowElement(Element elem)
{
if (elem is Rebar)
{
Rebar rb = elem as Rebar;
if (rb.LookupParameter("Comments").AsString() == "add-in")
{
foreach (string level in ConstantValue.Levels)
{
if (rb.LookupParameter("Level").AsString() == level)
{
return(true);
}
}
}
}
return(false);
}
/// <summary>
/// Определяем оригинальный типФормы
/// </summary>
/// <param name="rebar"></param>
/// <returns></returns>
private ElementId GetTrueForm(Rebar rebar)
{
int LenthString = rebar.LookupParameter("Форма").AsValueString().Split(' ').Length;
string new_string = "";
var DuplicateNumber = rebar.LookupParameter("Форма").AsValueString().Split(' ').ToList().GetRange(0, LenthString - 1);
foreach (var el in DuplicateNumber)
{
new_string += el + " ";
}
new_string = new_string.Trim();
ElementId rebarShapeId = new FilteredElementCollector(_doc)
.OfClass(typeof(RebarShape))
.Cast <RebarShape>()
.Where(i => i.Name == new_string)
.ToList()
.First()
.Id;
return(rebarShapeId);
}
public bool AllowElement(Element elem)
{
if (elem is Rebar)
{
Rebar rb = elem as Rebar;
if (rb.LookupParameter("Style").AsInteger() == 1)
{
return(true);
}
}
return(false);
}
/// <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);
}
}
