/// <summary>
/// Initialize a FamilyInstance element
/// </summary>
private void InitFamilyInstance(Autodesk.Revit.DB.FamilySymbol fs, Autodesk.Revit.DB.XYZ pos,
Autodesk.Revit.DB.Level level)
{
//Phase 1 - Check to see if the object exists and should be rebound
var oldFam =
ElementBinder.GetElementFromTrace <Autodesk.Revit.DB.FamilyInstance>(Document);
//There was a point, rebind to that, and adjust its position
if (oldFam != null)
{
InternalSetFamilyInstance(oldFam);
InternalSetLevel(level);
InternalSetFamilySymbol(fs);
InternalSetPosition(pos);
return;
}
//Phase 2- There was no existing point, create one
TransactionManager.Instance.EnsureInTransaction(Document);
//If the symbol is not active, then activate it
if (!fs.IsActive)
{
fs.Activate();
}
Autodesk.Revit.DB.FamilyInstance fi;
if (Document.IsFamilyDocument)
{
fi = Document.FamilyCreate.NewFamilyInstance(pos, fs, level,
Autodesk.Revit.DB.Structure.StructuralType.NonStructural);
}
else
{
fi = Document.Create.NewFamilyInstance(
pos, fs, level, Autodesk.Revit.DB.Structure.StructuralType.NonStructural);
}
InternalSetFamilyInstance(fi);
TransactionManager.Instance.TransactionTaskDone();
ElementBinder.SetElementForTrace(InternalElement);
}
private void Init(Autodesk.Revit.DB.DimensionType dimType, string name)
{
var document = DocumentManager.Instance.CurrentDBDocument;
TransactionManager.Instance.EnsureInTransaction(document);
// get element from trace
var element = ElementBinder.GetElementFromTrace <Autodesk.Revit.DB.DimensionType>(document);
if (element == null)
{
element = dimType.Duplicate(name) as Autodesk.Revit.DB.DimensionType;
}
InternalSetElement(element);
TransactionManager.Instance.TransactionTaskDone();
ElementBinder.SetElementForTrace(this.InternalElement);
}
/// <summary>
/// Initialize an AdaptiveComponent element
/// </summary>
/// <param name="pts">Points to use as reference</param>
/// <param name="fs">FamilySymbol to place</param>
private void InitAdaptiveComponent(Point[] pts, FamilySymbol fs)
{
// if the family instance is present in trace...
var oldFam =
ElementBinder.GetElementFromTrace <Autodesk.Revit.DB.FamilyInstance>(Document);
// just mutate it...
if (oldFam != null)
{
InternalSetFamilyInstance(oldFam);
if (fs.InternalFamilySymbol.Id != oldFam.Symbol.Id)
{
InternalSetFamilySymbol(fs);
}
InternalSetPositions(pts.ToXyzs());
return;
}
// otherwise create a new family instance...
TransactionManager.Instance.EnsureInTransaction(Document);
using (Autodesk.Revit.DB.SubTransaction st = new SubTransaction(Document))
{
try
{
st.Start();
var fam = AdaptiveComponentInstanceUtils.CreateAdaptiveComponentInstance(Element.Document, fs.InternalFamilySymbol);
InternalSetFamilyInstance(fam);
InternalSetPositions(pts.ToXyzs());
st.Commit();
}
catch (Exception ex)
{
st.RollBack();
throw new ArgumentException(Revit.Properties.Resources.Adaptive_Component_Creation_Failed + ex.Message);
}
}
TransactionManager.Instance.TransactionTaskDone();
// remember this value
ElementBinder.SetElementForTrace(this.InternalElement);
}
private void Init(Autodesk.Revit.DB.Level level, Autodesk.Revit.DB.XYZ location, string name, string number)
{
TransactionManager.Instance.EnsureInTransaction(Document);
// Get existing space element if possible
var spaceElement = ElementBinder.GetElementFromTrace <Autodesk.Revit.DB.Mechanical.Space>(Document);
if (spaceElement == null)
{
// Create new Space element
spaceElement = Document.Create.NewSpace(level, new Autodesk.Revit.DB.UV(location.X, location.Y));
}
else
{
if (spaceElement.LevelId.Equals(level.Id))
{
// Update Location only
Autodesk.Revit.DB.LocationPoint point = (Autodesk.Revit.DB.LocationPoint)spaceElement.Location;
point.Point = location;
}
else
{
spaceElement = Document.Create.NewSpace(level, new Autodesk.Revit.DB.UV(location.X, location.Y));
}
}
// Apply name and number if set
if (!string.IsNullOrEmpty(name))
{
spaceElement.Name = name;
}
if (!string.IsNullOrEmpty(number))
{
spaceElement.Number = number;
}
InternalSetElement(spaceElement);
// Commit transaction
TransactionManager.Instance.TransactionTaskDone();
ElementBinder.SetElementForTrace(this.InternalElement);
}
/// <summary>
/// Private constructor
/// </summary>
private PerspectiveView(XYZ eye, XYZ target, Autodesk.Revit.DB.Element element, string name, bool isolate)
{
//Phase 1 - Check to see if the object exists and should be rebound
var oldEle =
ElementBinder.GetElementFromTrace <Autodesk.Revit.DB.View3D>(Document);
// Rebind to Element
if (oldEle != null)
{
InternalSetView3D(oldEle);
InternalSetOrientation(BuildOrientation3D(eye, target));
if (isolate)
{
InternalIsolateInView(element);
}
else
{
InternalRemoveIsolation();
}
InternalSetName(name);
return;
}
//Phase 2 - There was no existing Element, create new one
TransactionManager.Instance.EnsureInTransaction(Document);
var vd = Create3DView(BuildOrientation3D(eye, target), name, true);
InternalSetView3D(vd);
if (isolate)
{
InternalIsolateInView(element);
}
else
{
InternalRemoveIsolation();
}
InternalSetName(name);
TransactionManager.Instance.TransactionTaskDone();
ElementBinder.SetElementForTrace(this.InternalElement);
}
/// <summary>
/// Initialize a GlobalParameter element
/// </summary>
/// <param name="line"></param>
private void InitGlobalParameter(string name, Autodesk.Revit.DB.ParameterType type)
{
if (Autodesk.Revit.DB.GlobalParametersManager.IsUniqueName(Document, name))
{
TransactionManager.Instance.EnsureInTransaction(Document);
Autodesk.Revit.DB.GlobalParameter g = Autodesk.Revit.DB.GlobalParameter.Create(Document, name, type);
InternalSetGlobalParameter(g);
TransactionManager.Instance.TransactionTaskDone();
ElementBinder.SetElementForTrace(this.InternalElement);
}
else
{
throw new Exception(Properties.Resources.NameAlreadyInUse);
}
}
private void InitFamilyInstance(FamilySymbol fs, Reference reference, XYZ location,
XYZ referenceDirection)
{
//Phase 1 - Check to see if the object exists and should be rebound
var oldFam =
ElementBinder.GetElementFromTrace <Autodesk.Revit.DB.FamilyInstance>(Document);
//There was an existing family instance, rebind to that, and adjust its position
if (oldFam != null && oldFam.HostFace.ElementId == reference.ElementId)
{
InternalSetFamilyInstance(oldFam);
InternalSetFamilySymbol(fs);
InternalSetPosition(location);
return;
}
//Phase 2- There was no existing point, create one
TransactionManager.Instance.EnsureInTransaction(Document);
//If the symbol is not active, then activate it
if (!fs.IsActive)
{
fs.Activate();
}
Autodesk.Revit.DB.FamilyInstance fi;
if (Document.IsFamilyDocument)
{
fi = Document.FamilyCreate.NewFamilyInstance(reference, location, referenceDirection, fs);
}
else
{
fi = Document.Create.NewFamilyInstance(reference, location, referenceDirection, fs);
}
InternalSetFamilyInstance(fi);
TransactionManager.Instance.TransactionTaskDone();
ElementBinder.SetElementForTrace(InternalElement);
}
private void InitTag(
Autodesk.Revit.DB.View view,
Autodesk.Revit.DB.Element host,
Autodesk.Revit.DB.TagOrientation orientation,
Autodesk.Revit.DB.TagMode mode,
bool addLeader,
Autodesk.Revit.DB.XYZ point)
{
Autodesk.Revit.DB.Document document = DocumentManager.Instance.CurrentDBDocument;
TransactionManager.Instance.EnsureInTransaction(document);
var tagElem = ElementBinder.GetElementFromTrace <Autodesk.Revit.DB.IndependentTag>(document);
if (tagElem == null ||
view.Id != tagElem.OwnerViewId ||
(tagElem.TaggedElementId.HostElementId != host.Id && tagElem.TaggedElementId.LinkedElementId != host.Id))
{
tagElem = document.Create.NewTag(view, host, addLeader, mode, orientation, point);
}
else
{
tagElem.TagOrientation = orientation;
tagElem.HasLeader = addLeader;
tagElem.TagHeadPosition = point;
}
InternalSetTag(tagElem);
TransactionManager.Instance.TransactionTaskDone();
if (tagElem != null)
{
ElementBinder.CleanupAndSetElementForTrace(document, this.InternalElement);
}
else
{
ElementBinder.SetElementForTrace(this.InternalElement);
}
}
/// <summary>
/// Initialize an AdaptiveComponent element
/// </summary>
/// <param name="uvParams">Parameters to use as reference</param>
/// <param name="f">Face to use as reference</param>
/// <param name="ft">familyType to place</param>
private void InitAdaptiveComponent(double[][] uvParams, ElementFaceReference f, FamilyType ft)
{
// if the family instance is present in trace...
var oldFam =
ElementBinder.GetElementFromTrace <Autodesk.Revit.DB.FamilyInstance>(Document);
// just mutate it...
if (oldFam != null)
{
InternalSetFamilyInstance(oldFam);
if (ft.InternalFamilySymbol.Id != oldFam.Symbol.Id)
{
InternalSetFamilySymbol(ft);
}
InternalSetUvsAndFace(uvParams.ToUvs(), f.InternalReference);
return;
}
// otherwise create a new family instance...
TransactionManager.Instance.EnsureInTransaction(Document);
using (Autodesk.Revit.DB.SubTransaction st = new SubTransaction(Document))
{
try
{
st.Start();
var fam = AdaptiveComponentInstanceUtils.CreateAdaptiveComponentInstance(Element.Document, ft.InternalFamilySymbol);
InternalSetFamilyInstance(fam);
InternalSetUvsAndFace(uvParams.ToUvs(), f.InternalReference);
st.Commit();
}
catch (Exception ex)
{
st.RollBack();
throw new ArgumentException(Revit.Properties.Resources.Adaptive_Component_Creation_Failed + ex.Message);
}
}
TransactionManager.Instance.TransactionTaskDone();
ElementBinder.SetElementForTrace(InternalElement);
}
private void InitRebarContainer(List <Revit.Elements.Rebar> rebars)
{
if (rebars.Count > 0)
{
Autodesk.Revit.DB.Document document = DocumentManager.Instance.CurrentDBDocument;
TransactionManager.Instance.EnsureInTransaction(document);
var rebarElem = ElementBinder.GetElementFromTrace <Autodesk.Revit.DB.Structure.RebarContainer>(document);
if (rebarElem == null)
{
ElementId stdC = Autodesk.Revit.DB.Structure.RebarContainerType.CreateDefaultRebarContainerType(DocumentManager.Instance.CurrentDBDocument);
Autodesk.Revit.DB.Element host = DocumentManager.Instance.CurrentDBDocument.GetElement(rebars[0].InternalRebar.GetHostId());
rebarElem = Autodesk.Revit.DB.Structure.RebarContainer.Create(DocumentManager.Instance.CurrentDBDocument, host, stdC);
}
else
{
rebarElem.ClearItems();
}
foreach (Revit.Elements.Rebar rebar in rebars)
{
rebarElem.AppendItemFromRebar(rebar.InternalRebar);
}
InternalSetRebarContainer(rebarElem);
TransactionManager.Instance.TransactionTaskDone();
if (rebarElem != null)
{
ElementBinder.CleanupAndSetElementForTrace(document, this.InternalElement);
}
else
{
ElementBinder.SetElementForTrace(this.InternalElement);
}
}
}
/// <summary>
/// Init Filled Region by Curves
/// </summary>
/// <param name="view"></param>
/// <param name="typeId"></param>
/// <param name="boundary"></param>
private void Init(View view, ElementId typeId, IEnumerable <CurveLoop> boundary)
{
// Get document and start transaction
Autodesk.Revit.DB.Document document = DocumentManager.Instance.CurrentDBDocument;
TransactionManager.Instance.EnsureInTransaction(document);
// Get existing element
var region = ElementBinder.GetElementFromTrace <Autodesk.Revit.DB.FilledRegion>(document);
if (null != region)
{
DocumentManager.Instance.DeleteElement(new ElementUUID(region.UniqueId));
}
region = Autodesk.Revit.DB.FilledRegion.Create(document, typeId, view.Id, boundary.ToList());
InternalSetElement(region);
TransactionManager.Instance.TransactionTaskDone();
ElementBinder.SetElementForTrace(this.InternalElement);
}
/// <summary>
/// Initialize a GroupType element from a set of objects ids and a name
/// </summary>
/// <param name="ids"></param>
/// <param name="name"></param>
private void InitGroupType(ICollection <DB.ElementId> ids, string name)
{
DB.Document document = DocumentManager.Instance.CurrentDBDocument;
//Find all groupType name in the document
DB.FilteredElementCollector collector = new DB.FilteredElementCollector(document);
List <string> groupTypeNames = collector.OfClass(typeof(DB.GroupType)).ToElements().Select(element => element.Name).ToList();
// This creates a new wall and deletes the old one
TransactionManager.Instance.EnsureInTransaction(document);
//Phase 1 - Check to see if the object exists and should be rebound
var GroupTypeElem = ElementBinder.GetElementFromTrace <DB.GroupType>(document);
if (GroupTypeElem == null)
{
GroupTypeElem = document.Create.NewGroup(ids).GroupType;
if (!groupTypeNames.Contains(name))
{
GroupTypeElem.Name = name;
}
else
{
GetNextFilename(name + " {0}", groupTypeNames);
}
}
InternalSetGroupType(GroupTypeElem);
TransactionManager.Instance.TransactionTaskDone();
if (GroupTypeElem != null)
{
ElementBinder.CleanupAndSetElementForTrace(document, this.InternalElement);
}
else
{
ElementBinder.SetElementForTrace(this.InternalElement);
}
}
/// <summary>
/// Make a SketchPlane from a plane
/// </summary>
/// <param name="p"></param>
private SketchPlane(Autodesk.Revit.DB.Plane p)
{
//Phase 1 - Check to see if the object exists and should be rebound
var oldEle =
ElementBinder.GetElementFromTrace <Autodesk.Revit.DB.SketchPlane>(Document);
//There was an element, bind & mutate
if (oldEle != null)
{
InternalSetSketchPlane(oldEle);
if (InternalSetPlane(p))
{
return;
}
// if setting the plane fails, we delete the old Element
// in order to create a new one
DocumentManager.Instance.DeleteElement(oldEle.Id);
}
//Phase 2- There was no existing element, create new
TransactionManager.Instance.EnsureInTransaction(Document);
Autodesk.Revit.DB.SketchPlane sp;
if (Document.IsFamilyDocument)
{
sp = Document.FamilyCreate.NewSketchPlane(p);
}
else
{
sp = Document.Create.NewSketchPlane(p);
}
InternalSetSketchPlane(sp);
TransactionManager.Instance.TransactionTaskDone();
ElementBinder.SetElementForTrace(this.InternalElement);
}
/// <summary>
/// Create new RevisionCloud from Curves
/// </summary>
/// <param name="view"></param>
/// <param name="curves"></param>
/// <param name="id"></param>
private void Init(Autodesk.Revit.DB.View view, IEnumerable <Autodesk.Revit.DB.Curve> curves, Autodesk.Revit.DB.ElementId id)
{
// get document and open transaction
Autodesk.Revit.DB.Document document = DocumentManager.Instance.CurrentDBDocument;
TransactionManager.Instance.EnsureInTransaction(document);
// get existing element if possible
var element = ElementBinder.GetElementFromTrace <Autodesk.Revit.DB.RevisionCloud>(document);
if (null != element)
{
DocumentManager.Instance.DeleteElement(new ElementUUID(element.UniqueId));
}
element = Autodesk.Revit.DB.RevisionCloud.Create(document, view, id, curves.ToList());
InternalSetElement(element);
// commit transaction and set element for trace
TransactionManager.Instance.TransactionTaskDone();
ElementBinder.SetElementForTrace(this.InternalElement);
}
/// <summary>
/// Init ParameterFilterElement by rules
/// </summary>
/// <param name="name"></param>
/// <param name="ids"></param>
/// <param name="rules"></param>
private void Init(string name, IEnumerable <ElementId> ids, IEnumerable <Autodesk.Revit.DB.FilterRule> rules)
{
Autodesk.Revit.DB.Document document = DocumentManager.Instance.CurrentDBDocument;
TransactionManager.Instance.EnsureInTransaction(document);
var elem = ElementBinder.GetElementFromTrace <Autodesk.Revit.DB.ParameterFilterElement>(document);
if (elem == null)
{
elem = Autodesk.Revit.DB.ParameterFilterElement.Create(document, name, ids.ToList(), rules.ToList());
}
else
{
elem.Name = name;
elem.SetCategories(ids.ToList());
elem.SetRules(rules.ToList());
}
InternalSetElement(elem);
TransactionManager.Instance.TransactionTaskDone();
ElementBinder.SetElementForTrace(this.InternalElement);
}
private void InitImageInstance(Autodesk.Revit.DB.View view, Autodesk.Revit.DB.ElementId typeId, Autodesk.Revit.DB.ImagePlacementOptions options)
{
//Phase 1 - Check to see if the object exists and should be rebound
var oldEle = ElementBinder.GetElementFromTrace <Autodesk.Revit.DB.ImageInstance>(DocumentManager.Instance.CurrentDBDocument);
// Rebind to Element
if (oldEle != null)
{
InternalSetImageInstance(oldEle);
return;
}
//Phase 2 - There was no existing Element, create new one
TransactionManager.Instance.EnsureInTransaction(DocumentManager.Instance.CurrentDBDocument);
var ii = Autodesk.Revit.DB.ImageInstance.Create(DocumentManager.Instance.CurrentDBDocument, view, typeId, options);
InternalSetImageInstance(ii);
TransactionManager.Instance.TransactionTaskDone();
ElementBinder.SetElementForTrace(InternalElement);
}
/// <summary>
/// Initialize a ReferencePoint element
/// </summary>
/// <param name="xyz"></param>
private void InitReferencePoint(XYZ xyz)
{
//Phase 1 - Check to see if the object exists and should be rebound
var oldRefPt =
ElementBinder.GetElementFromTrace <Autodesk.Revit.DB.ReferencePoint>(Document);
//There was a point, rebind to that, and adjust its position
if (oldRefPt != null)
{
InternalSetReferencePoint(oldRefPt);
InternalSetPosition(xyz);
return;
}
//Phase 2- There was no existing point, create one
TransactionManager.Instance.EnsureInTransaction(Document);
InternalSetReferencePoint(Document.FamilyCreate.NewReferencePoint(xyz));
TransactionManager.Instance.TransactionTaskDone();
ElementBinder.SetElementForTrace(InternalElement);
}
private void InitDimension(Autodesk.Revit.DB.View view, Autodesk.Revit.DB.Line line, Autodesk.Revit.DB.ReferenceArray arr, Autodesk.Revit.DB.DimensionType type)
{
//Phase 1 - Check to see if the object exists and should be rebound
var oldEle = ElementBinder.GetElementFromTrace <Autodesk.Revit.DB.Dimension>(DocumentManager.Instance.CurrentDBDocument);
// Rebind to Element
if (oldEle != null)
{
InternalSetDimension(oldEle);
return;
}
//Phase 2 - There was no existing Element, create new one
TransactionManager.Instance.EnsureInTransaction(DocumentManager.Instance.CurrentDBDocument);
var ii = DocumentManager.Instance.CurrentDBDocument.Create.NewDimension(view, line, arr, type);
InternalSetDimension(ii);
TransactionManager.Instance.TransactionTaskDone();
ElementBinder.SetElementForTrace(InternalElement);
}
/// <summary>
/// Initialize a ModelText element
/// </summary>
/// <param name="text"></param>
/// <param name="sketchPlane"></param>
/// <param name="xCoordinateInPlane"></param>
/// <param name="yCoordinateInPlane"></param>
/// <param name="textDepth"></param>
/// <param name="modelTextType"></param>
private void InitModelText(string text, Autodesk.Revit.DB.SketchPlane sketchPlane,
double xCoordinateInPlane, double yCoordinateInPlane, double textDepth,
Autodesk.Revit.DB.ModelTextType modelTextType)
{
//Phase 1 - Check to see if the object exists and should be rebound
var oldEle =
ElementBinder.GetElementFromTrace <Autodesk.Revit.DB.ModelText>(Document);
// Note: not sure if there's a way to mutate the sketchPlane for a ModelText, so we need
// to insure the Element hasn't changed position, otherwise, we destroy and rebuild the Element
if (oldEle != null && PositionUnchanged(oldEle, sketchPlane, xCoordinateInPlane, yCoordinateInPlane))
{
// There was an element and it's position hasn't changed
InternalSetModelText(oldEle);
InternalSetText(text);
InternalSetDepth(textDepth);
InternalSetModelTextType(modelTextType);
return;
}
TransactionManager.Instance.EnsureInTransaction(Document);
// We have to clean up the old ModelText b/c we can't mutate it's position
if (oldEle != null)
{
DocumentManager.Instance.DeleteElement(new ElementUUID(oldEle.UniqueId));
}
var mt = CreateModelText(text, sketchPlane, xCoordinateInPlane, yCoordinateInPlane, textDepth, modelTextType);
InternalSetModelText(mt);
TransactionManager.Instance.TransactionTaskDone();
ElementBinder.SetElementForTrace(this.InternalElement);
}
/// <summary>
/// Initialize an ImportInstance element
/// </summary>
/// <param name="satPath"></param>
/// <param name="translation"></param>
/// <param name="view"></param>
private void InitImportInstance(string satPath, Revit.Elements.Views.View view, XYZ translation = null)
{
var instance = ElementBinder.GetElementFromTrace <Autodesk.Revit.DB.ImportInstance>(Document);
if (null != instance)
{
DocumentManager.Instance.DeleteElement(new ElementUUID(instance.UniqueId));
}
translation = translation ?? XYZ.Zero;
TransactionManager.Instance.EnsureInTransaction(Document);
var options = new SATImportOptions()
{
Unit = ImportUnit.Foot
};
var id = null != view?Document.Import(satPath, options, view.InternalView) : Document.Import(satPath, options, Document.ActiveView);
var element = Document.GetElement(id);
var importInstance = element as Autodesk.Revit.DB.ImportInstance;
if (importInstance == null)
{
throw new Exception(Properties.Resources.InstanceImportFailure);
}
InternalSetImportInstance(importInstance);
InternalUnpinAndTranslateImportInstance(translation);
this.Path = satPath;
TransactionManager.Instance.TransactionTaskDone();
ElementBinder.SetElementForTrace(importInstance);
}
/// <summary>
/// Init ParameterFilterElement by rules
/// </summary>
/// <param name="name"></param>
/// <param name="ids"></param>
/// <param name="rules"></param>
private void Init(string name, IEnumerable <ElementId> ids, IEnumerable <Autodesk.Revit.DB.FilterRule> rules)
{
Autodesk.Revit.DB.Document document = DocumentManager.Instance.CurrentDBDocument;
TransactionManager.Instance.EnsureInTransaction(document);
var elemFilters = new List <ElementFilter>();
foreach (var rule in rules)
{
var elemParamFilter = new ElementParameterFilter(rule);
elemFilters.Add(elemParamFilter);
}
Autodesk.Revit.DB.ElementFilter eleFilter = new LogicalOrFilter(elemFilters);
var elem = ElementBinder.GetElementFromTrace <Autodesk.Revit.DB.ParameterFilterElement>(document);
if (elem == null)
{
// ParameterFilterElement..::..Create Method (Document, String, ICollection<ElementId>, IList<FilterRule>) is deprecated in Revit 2019 and will be removed in the next version of Revit.
//We suggest you instead use a Create method that takes an ElementFilter as input.
elem = Autodesk.Revit.DB.ParameterFilterElement.Create(document, name, ids.ToList(), eleFilter);
}
else
{
elem.Name = name;
elem.SetCategories(ids.ToList());
//ParameterFilterElement..::..SetRules Method is deprecated in Revit 2019 and will be removed in the next version of Revit.
//We suggest you instead use SetElementFilter instead.
elem.SetElementFilter(eleFilter);
}
InternalSetElement(elem);
TransactionManager.Instance.TransactionTaskDone();
ElementBinder.SetElementForTrace(this.InternalElement);
}
/// <summary>
/// Internal constructor for the AdaptiveComponent wrapper
/// </summary>
/// <param name="pts">Points to use as reference</param>
/// <param name="fs">FamilySymbol to place</param>
private AdaptiveComponent(Point[] pts, FamilySymbol fs)
{
// if the family instance is present in trace...
var oldFam =
ElementBinder.GetElementFromTrace <Autodesk.Revit.DB.FamilyInstance>(Document);
// just mutate it...
if (oldFam != null)
{
InternalSetFamilyInstance(oldFam);
if (fs.InternalFamilySymbol.Id != oldFam.Symbol.Id)
{
InternalSetFamilySymbol(fs);
}
InternalSetPositions(pts.ToXyzs());
return;
}
// otherwise create a new family instance...
TransactionManager.Instance.EnsureInTransaction(Document);
var fam = AdaptiveComponentInstanceUtils.CreateAdaptiveComponentInstance(Element.Document, fs.InternalFamilySymbol);
if (fam == null)
{
throw new Exception("An adaptive component could not be found or created.");
}
InternalSetFamilyInstance(fam);
InternalSetPositions(pts.ToXyzs());
TransactionManager.Instance.TransactionTaskDone();
// remember this value
ElementBinder.SetElementForTrace(this.InternalElement);
}
/// <summary>
/// Initialize a Pipe element
/// </summary>
/// <param name="pipeType">Type of the pipe.</param>
/// <param name="pipingSystemType">Type of the piping system.</param>
/// <param name="start">The start.</param>
/// <param name="end">The end.</param>
/// <param name="level">The level.</param>
private void InitObject(Autodesk.Revit.DB.Plumbing.PipeType pipeType, Autodesk.Revit.DB.Plumbing.PipingSystemType pipingSystemType, XYZ start, XYZ end,
Autodesk.Revit.DB.Level level)
{
//Phase 1 - Check to see if the object exists and should be rebound
var oldFam =
ElementBinder.GetElementFromTrace <Autodesk.Revit.DB.MEPCurve>(DocumentManager.Instance.CurrentDBDocument);
//There was a point, rebind to that, and adjust its position
if (oldFam != null)
{
InternalSetMEPCurve(oldFam);
InternalSetMEPCurveType(pipeType);
InternalSetPosition(start, end);
return;
}
//Phase 2- There was no existing point, create one
TransactionManager.Instance.EnsureInTransaction(DocumentManager.Instance.CurrentDBDocument);
Autodesk.Revit.DB.MEPCurve fi;
if (DocumentManager.Instance.CurrentDBDocument.IsFamilyDocument)
{
fi = null;
}
else
{
fi = Autodesk.Revit.DB.Plumbing.Pipe.Create(DocumentManager.Instance.CurrentDBDocument, pipingSystemType.Id, pipeType.Id, level.Id, start, end);
}
InternalSetMEPCurve(fi);
TransactionManager.Instance.TransactionTaskDone();
ElementBinder.SetElementForTrace(InternalElement);
}
private void InitViewPlan(Autodesk.Revit.DB.Level level, Autodesk.Revit.DB.ViewFamilyType viewFamilyType)
{
// Phase 1 - Check to see if the object exists and should be rebound
var doc = DocumentManager.Instance.CurrentDBDocument;
var oldEle = ElementBinder.GetElementFromTrace <Autodesk.Revit.DB.ViewPlan>(doc);
// Rebind to Element
if (oldEle != null)
{
InternalSetViewPlan(oldEle);
return;
}
// Phase 2 - There was no existing Element, create new one
TransactionManager.Instance.EnsureInTransaction(doc);
var view = Autodesk.Revit.DB.ViewPlan.Create(doc, viewFamilyType.Id, level.Id);
InternalSetViewPlan(view);
TransactionManager.Instance.TransactionTaskDone();
ElementBinder.SetElementForTrace(InternalElement);
}
/// <summary>
/// Private constructor for Level
/// </summary>
/// <param name="elevation"></param>
/// <param name="name"></param>
private Level(double elevation, string name)
{
//Phase 1 - Check to see if the object exists and should be rebound
var oldEle =
ElementBinder.GetElementFromTrace <Autodesk.Revit.DB.Level>(Document);
//There was an element, bind & mutate
if (oldEle != null)
{
InternalSetLevel(oldEle);
InternalSetElevation(elevation);
InternalSetName(name);
return;
}
//Phase 2- There was no existing element, create new
TransactionManager.Instance.EnsureInTransaction(Document);
Autodesk.Revit.DB.Level level;
if (Document.IsFamilyDocument)
{
level = Document.FamilyCreate.NewLevel(elevation);
}
else
{
level = Document.Create.NewLevel(elevation);
}
InternalSetLevel(level);
InternalSetName(name);
TransactionManager.Instance.TransactionTaskDone();
ElementBinder.SetElementForTrace(this.InternalElement);
}
/// <summary>
/// Init element by location
/// </summary>
/// <param name="view"></param>
/// <param name="origin"></param>
/// <param name="alignment"></param>
/// <param name="text"></param>
/// <param name="keepRotatedTextreadable"></param>
/// <param name="rotation">in degrees</param>
/// <param name="typeId"></param>
private void Init(RVT.View view, RVT.XYZ origin, RVT.HorizontalTextAlignment alignment, string text, bool keepRotatedTextreadable, double rotation, ElementId typeId)
{
Autodesk.Revit.DB.Document document = DocumentManager.Instance.CurrentDBDocument;
TransactionManager.Instance.EnsureInTransaction(document);
var element = ElementBinder.GetElementFromTrace <RVT.TextNote>(document);
RVT.TextNoteOptions options = new TextNoteOptions()
{
HorizontalAlignment = alignment,
KeepRotatedTextReadable = keepRotatedTextreadable,
Rotation = rotation.ToRadians(),
TypeId = typeId
};
if (element == null)
{
element = RVT.TextNote.Create(document, view.Id, origin, text, options);
}
else
{
if (element.HorizontalAlignment != alignment)
{
element.HorizontalAlignment = alignment;
}
if (element.KeepRotatedTextReadable != keepRotatedTextreadable)
{
element.KeepRotatedTextReadable = keepRotatedTextreadable;
}
if (element.Text != text)
{
element.Text = text;
}
// if the element location is null, try to use the Coord property
// Coord holds a point only without rotation.
if (element.Location == null)
{
if (!element.Coord.IsAlmostEqualTo(origin))
{
element.Coord = origin;
}
}
else
{
// If a location point is set we can use this and extract
// its location and rotation
if (element.Location is LocationPoint)
{
LocationPoint point = (LocationPoint)element.Location;
if (!point.Point.IsAlmostEqualTo(origin))
{
point.Point = origin;
}
if (Math.Abs(point.Rotation - rotation.ToRadians()) <= System.Double.Epsilon)
{
point.Rotate(Line.CreateUnbound(XYZ.Zero, XYZ.BasisZ), rotation.ToRadians());
}
}
}
}
RVT.TextNoteType type = (RVT.TextNoteType)document.GetElement(typeId);
InternalSetType(text, type, origin, alignment, rotation);
InternalSetElement(element);
TransactionManager.Instance.TransactionTaskDone();
ElementBinder.SetElementForTrace(this.InternalElement);
}
// PB: This implementation borrows the somewhat risky notions from the original Dynamo
// implementation. In short, it has the ability to infer a sketch plane,
// which might also mean deleting the original one.
/// <summary>
/// Initialize a ModelCurve element
/// </summary>
/// <param name="crv"></param>
/// <param name="makeReferenceCurve"></param>
private void InitModelCurve(Autodesk.Revit.DB.Curve crv, bool makeReferenceCurve)
{
//Phase 1 - Check to see if the object exists and should be rebound
var mc =
ElementBinder.GetElementFromTrace <Autodesk.Revit.DB.ModelCurve>(Document);
//There was a modelcurve, try and set sketch plane
// if you can't, rebuild
if (mc != null)
{
InternalSetCurveElement(mc);
if (!InternalSetSketchPlaneFromCurve(crv))
{
InternalSetCurve(crv);
return;
}
}
ElementId oldId = (mc != null) ? mc.Id : ElementId.InvalidElementId;
string oldUniqueId = (mc != null) ? mc.UniqueId : string.Empty;
TransactionManager.Instance.EnsureInTransaction(Document);
// (sic erat scriptum)
var sp = GetSketchPlaneFromCurve(crv);
var plane = sp.GetPlane();
if (CurveUtils.GetPlaneFromCurve(crv, true) == null)
{
var flattenCurve = Flatten3dCurveOnPlane(crv, plane);
mc = Document.IsFamilyDocument
? Document.FamilyCreate.NewModelCurve(flattenCurve, sp)
: Document.Create.NewModelCurve(flattenCurve, sp);
setCurveMethod(mc, crv);
}
else
{
mc = Document.IsFamilyDocument
? Document.FamilyCreate.NewModelCurve(crv, sp)
: Document.Create.NewModelCurve(crv, sp);
}
if (mc.SketchPlane.Id != sp.Id)
{
//THIS BIZARRE as Revit could use different existing SP, so if Revit had found better plane this sketch plane has no use
DocumentManager.Instance.DeleteElement(new ElementUUID(sp.UniqueId));
}
InternalSetCurveElement(mc);
if (oldId != mc.Id && oldId != ElementId.InvalidElementId)
{
DocumentManager.Instance.DeleteElement(new ElementUUID(oldUniqueId));
}
if (makeReferenceCurve)
{
mc.ChangeToReferenceLine();
}
TransactionManager.Instance.TransactionTaskDone();
ElementBinder.SetElementForTrace(this.InternalElement);
}
/// <summary>
///
/// </summary>
/// <param name="curve"></param>
/// <param name="barType"></param>
/// <param name="barStyle"></param>
/// <param name="host"></param>
/// <param name="startHook"></param>
/// <param name="endHook"></param>
/// <param name="startHookOrientation"></param>
/// <param name="endHookOrientation"></param>
/// <param name="normal"></param>
/// <param name="useExistingShape"></param>
/// <param name="createNewShape"></param>
private void InitRebarContainer(System.Collections.Generic.List <object> curves,
Autodesk.Revit.DB.Structure.RebarBarType barType,
Autodesk.Revit.DB.Structure.RebarStyle barStyle,
Autodesk.Revit.DB.Element host,
Autodesk.Revit.DB.Structure.RebarHookType startHook,
Autodesk.Revit.DB.Structure.RebarHookType endHook,
Autodesk.Revit.DB.Structure.RebarHookOrientation startHookOrientation,
Autodesk.Revit.DB.Structure.RebarHookOrientation endHookOrientation,
System.Collections.Generic.List <Autodesk.Revit.DB.XYZ> normals,
bool useExistingShape,
bool createNewShape)
{
Autodesk.Revit.DB.Document document = DocumentManager.Instance.CurrentDBDocument;
TransactionManager.Instance.EnsureInTransaction(document);
var rebarElem = ElementBinder.GetElementFromTrace <Autodesk.Revit.DB.Structure.RebarContainer>(document);
// Parse Geometry
List <List <Curve> > curvature = new List <List <Curve> >();
foreach (object curve in curves)
{
List <Curve> geometry = new List <Curve>();
if (curve.GetType() == typeof(DynamoRebar.RevitPolyCurve))
{
DynamoRebar.RevitPolyCurve polycurve = (DynamoRebar.RevitPolyCurve)curve;
geometry = polycurve.Curves;
}
else
{
geometry.Add((Curve)curve);
}
curvature.Add(geometry);
}
if (rebarElem == null)
{
ElementId stdC = Autodesk.Revit.DB.Structure.RebarContainerType.CreateDefaultRebarContainerType(DocumentManager.Instance.CurrentDBDocument);
rebarElem = Autodesk.Revit.DB.Structure.RebarContainer.Create(DocumentManager.Instance.CurrentDBDocument, host, stdC);
}
else
{
//rebarElem.ClearItems();
rebarElem.SetHostId(document, host.Id);
}
int counter = rebarElem.ItemsCount;
for (int i = 0; i < counter; i++)
{
Autodesk.Revit.DB.Structure.RebarContainerItem item = rebarElem.GetItem(i);
int index = GeometryMatches(item.ComputeDrivingCurves(), curvature);
if (index == -1)
{
rebarElem.RemoveItem(item);
}
else
{
item.SetHookOrientation(0, startHookOrientation);
item.SetHookOrientation(1, endHookOrientation);
item.SetHookTypeId(0, startHook.Id);
item.SetHookTypeId(1, endHook.Id);
curvature.RemoveAt(index);
if (normals.Count > 1)
{
normals.RemoveAt(index);
}
}
}
for (int i = 0; i < curvature.Count; i++)
{
// If there is only one normal in the list use this one for all curves
XYZ normal = (normals.Count == 1) ? normals[0] : normals[i];
List <Curve> geometry = curvature[i];
rebarElem.AppendItemFromCurves(barStyle, barType, startHook, endHook, normal, geometry, startHookOrientation, endHookOrientation, useExistingShape, createNewShape);
}
// Update Quantity Parameter
Autodesk.Revit.DB.Parameter quantityParameter = rebarElem.get_Parameter(BuiltInParameter.REBAR_ELEM_QUANTITY_OF_BARS);
Autodesk.Revit.DB.Structure.RebarContainerParameterManager containerParameters = rebarElem.GetParametersManager();
containerParameters.AddOverride(quantityParameter.Id, curves.Count);
InternalSetRebarContainer(rebarElem);
TransactionManager.Instance.TransactionTaskDone();
if (rebarElem != null)
{
ElementBinder.CleanupAndSetElementForTrace(document, this.InternalElement);
}
else
{
ElementBinder.SetElementForTrace(this.InternalElement);
}
}
/// <summary>
/// Initialize a StructuralFraming element
/// </summary>
private void InitStructuralFraming(Autodesk.Revit.DB.Curve curve, Autodesk.Revit.DB.Level level, Autodesk.Revit.DB.Structure.StructuralType structuralType, Autodesk.Revit.DB.FamilySymbol symbol)
{
//Phase 1 - Check to see if the object exists and should be rebound
var oldFam =
ElementBinder.GetElementFromTrace <Autodesk.Revit.DB.FamilyInstance>(Document);
//There's an existing structural framing element, rebind to that, and adjust its position
if (oldFam != null)
{
InternalSetFamilyInstance(oldFam);
InternalSetFamilySymbol(symbol);
InternalSetCurve(curve);
return;
}
//Phase 2- There was no existing structural framing element, create one
TransactionManager.Instance.EnsureInTransaction(Document);
var creationData = GetCreationData(curve, level, structuralType, symbol);
Autodesk.Revit.DB.FamilyInstance fi;
if (Document.IsFamilyDocument)
{
var elementIds =
Document.FamilyCreate.NewFamilyInstances2(
new List <FamilyInstanceCreationData>()
{
creationData
});
if (elementIds.Count == 0)
{
throw new Exception(Properties.Resources.FamilyInstanceCreationFailure);
}
fi = (Autodesk.Revit.DB.FamilyInstance)Document.GetElement(elementIds.First());
}
else
{
var elementIds =
Document.Create.NewFamilyInstances2(
new List <FamilyInstanceCreationData>()
{
creationData
});
if (elementIds.Count == 0)
{
throw new Exception(Properties.Resources.FamilyInstanceCreationFailure);
}
fi = (Autodesk.Revit.DB.FamilyInstance)Document.GetElement(elementIds.First());
}
InternalSetFamilyInstance(fi);
TransactionManager.Instance.TransactionTaskDone();
ElementBinder.SetElementForTrace(this.InternalElement);
}
/// <summary>
///
/// </summary>
/// <param name="curve"></param>
/// <param name="barType"></param>
/// <param name="barStyle"></param>
/// <param name="host"></param>
/// <param name="startHook"></param>
/// <param name="endHook"></param>
/// <param name="startHookOrientation"></param>
/// <param name="endHookOrientation"></param>
/// <param name="normal"></param>
/// <param name="useExistingShape"></param>
/// <param name="createNewShape"></param>
private void InitRebarContainer(System.Collections.Generic.List <object> curves,
Autodesk.Revit.DB.Structure.RebarBarType barType,
Autodesk.Revit.DB.Structure.RebarStyle barStyle,
Autodesk.Revit.DB.Element host,
Autodesk.Revit.DB.Structure.RebarHookType startHook,
Autodesk.Revit.DB.Structure.RebarHookType endHook,
Autodesk.Revit.DB.Structure.RebarHookOrientation startHookOrientation,
Autodesk.Revit.DB.Structure.RebarHookOrientation endHookOrientation,
System.Collections.Generic.List <Autodesk.Revit.DB.XYZ> normals,
bool useExistingShape,
bool createNewShape)
{
Autodesk.Revit.DB.Document document = DocumentManager.Instance.CurrentDBDocument;
TransactionManager.Instance.EnsureInTransaction(document);
var rebarElem = ElementBinder.GetElementFromTrace <Autodesk.Revit.DB.Structure.RebarContainer>(document);
if (rebarElem == null)
{
ElementId stdC = Autodesk.Revit.DB.Structure.RebarContainerType.CreateDefaultRebarContainerType(DocumentManager.Instance.CurrentDBDocument);
rebarElem = Autodesk.Revit.DB.Structure.RebarContainer.Create(DocumentManager.Instance.CurrentDBDocument, host, stdC);
}
else
{
rebarElem.ClearItems();
}
for (int i = 0; i < curves.Count; i++)
{
// If there is only one normal in the list use this one for all curves
XYZ normal = (normals.Count == 1) ? normals[0] : normals[i];
// geometry wrapper for polycurves
List <Curve> geometry = new List <Curve>();
if (curves[i].GetType() == typeof(DynamoRebar.RevitPolyCurve))
{
DynamoRebar.RevitPolyCurve polycurve = (DynamoRebar.RevitPolyCurve)curves[i];
geometry = polycurve.Curves;
}
else
{
geometry.Add((Curve)curves[i]);
}
rebarElem.AppendItemFromCurves(barStyle, barType, startHook, endHook, normal, geometry, startHookOrientation, endHookOrientation, useExistingShape, createNewShape);
}
InternalSetRebarContainer(rebarElem);
TransactionManager.Instance.TransactionTaskDone();
if (rebarElem != null)
{
ElementBinder.CleanupAndSetElementForTrace(document, this.InternalElement);
}
else
{
ElementBinder.SetElementForTrace(this.InternalElement);
}
}
