/// <summary>
/// Construct a new Revit PathOfTravel in a floor plan view between the specified start point and end point
/// </summary>
/// <param name="rvtView"></param>
/// <param name="startPoints"></param>
/// <param name="endPoints"></param>
/// <returns></returns>
private static PathOfTravel[] InternalByViewEndPoints(Rvt.View rvtView, IEnumerable <XYZ> startPoints, IEnumerable <XYZ> endPoints)
{
List <PathOfTravel> pathsOfTravel = new List <PathOfTravel>();
TransactionManager.Instance.EnsureInTransaction(Document);
try
{
// get previously created elements
IEnumerable <RvtAnalysis.PathOfTravel> existingRvtElements = ElementBinder.GetElementsFromTrace <RvtAnalysis.PathOfTravel>(Document);
// update elements that can be reused
IList <PathOfTravel> updatedPathsOfTravel = UpdateReusedElements(existingRvtElements, startPoints, endPoints);
pathsOfTravel.AddRange(updatedPathsOfTravel);
// delete elements that are not needed anymore
DeleteExtraElements(existingRvtElements, startPoints, endPoints);
// create additional elements
IList <PathOfTravel> newPathsOfTravel = CreateAdditionalElements(rvtView, existingRvtElements, startPoints, endPoints);
pathsOfTravel.AddRange(newPathsOfTravel);
ElementBinder.SetElementsForTrace(pathsOfTravel.Where(x => x != null).Select(x => x.InternalElement));
}
catch (Exception e)
{
// unregister the elements from the element life cycle manager and delete the elements
var elementManager = ElementIDLifecycleManager <int> .GetInstance();
if (pathsOfTravel != null)
{
foreach (var path in pathsOfTravel)
{
if (path != null)
{
elementManager.UnRegisterAssociation(path.InternalElementId.IntegerValue, path);
Document.Delete(path.InternalElementId);
}
}
}
throw e;
}
finally
{
TransactionManager.Instance.TransactionTaskDone();
}
return(pathsOfTravel.ToArray());
}
/// <summary>
///
/// </summary>
/// <param name="sheetName"></param>
/// <param name="sheetNumber"></param>
/// <param name="titleBlockFamilySymbol"></param>
/// <param name="views"></param>
/// <param name="locations"></param>
private void InitSheet(string sheetName, string sheetNumber, Autodesk.Revit.DB.FamilySymbol titleBlockFamilySymbol, IEnumerable <Autodesk.Revit.DB.View> views, IEnumerable <XYZ> locations)
{
//Phase 1 - Check to see if the object exists
var oldEles =
ElementBinder.GetElementsFromTrace <Autodesk.Revit.DB.ViewSheet>(Document);
List <Autodesk.Revit.DB.Element> TraceElements = new List <Autodesk.Revit.DB.Element>();
List <Autodesk.Revit.DB.Viewport> BindingViewports = new List <Autodesk.Revit.DB.Viewport>();
if (ElementBinder.GetElementsFromTrace <Autodesk.Revit.DB.Viewport>(Document) != null)
{
BindingViewports.AddRange(ElementBinder.GetElementsFromTrace <Autodesk.Revit.DB.Viewport>(Document).ToList());
}
// Rebind to Element
if (oldEles != null && oldEles.Any())
{
var oldEle = oldEles.First();
InternalSetViewSheet(oldEle);
InternalSetSheetName(sheetName);
InternalSetSheetNumber(sheetNumber);
InternalSetTitleBlock(titleBlockFamilySymbol.Id);
TraceElements.Add(oldEle);
TraceElements.AddRange(InternalSetViewsToSheetView(views, locations, BindingViewports));
ElementBinder.SetElementsForTrace(TraceElements);
return;
}
//Phase 2 - There was no existing Element, create new one
TransactionManager.Instance.EnsureInTransaction(Document);
// create sheet with title block ID
var sheet = Autodesk.Revit.DB.ViewSheet.Create(Document, titleBlockFamilySymbol.Id);
InternalSetViewSheet(sheet);
InternalSetSheetName(sheetName);
InternalSetSheetNumber(sheetNumber);
TraceElements.Add(this.InternalElement);
TraceElements.AddRange(InternalSetViewsToSheetView(views, locations, BindingViewports));
TransactionManager.Instance.TransactionTaskDone();
ElementBinder.SetElementsForTrace(TraceElements);
}
/// <summary>
/// Create a list of adaptive components from two-dimensional array of points
/// </summary>
/// <param name="points">a two-dimensional array of points</param>
/// <param name="familyType">a family type to use to create the adaptive components</param>
/// <returns></returns>
private static AdaptiveComponent[] InternalByPoints(Point[][] points, FamilyType familyType)
{
var oldInstances = ElementBinder.GetElementsFromTrace <Autodesk.Revit.DB.FamilyInstance>(Document);
int countToBeCreated = points.Count();
int countOfOldInstances = 0;
if (oldInstances != null)
{
countOfOldInstances = oldInstances.Count();
}
int reusableCount = Math.Min(countToBeCreated, countOfOldInstances);
TransactionManager.Instance.EnsureInTransaction(Document);
List <Autodesk.Revit.DB.FamilyInstance> instances = new List <Autodesk.Revit.DB.FamilyInstance>();
List <AdaptiveComponent> components = new List <AdaptiveComponent>();
try
{
// Reuse the adaptive components that can be reused if possible
for (int i = 0; i < reusableCount; i++)
{
var fi = oldInstances.ElementAt(i);
var comp = new AdaptiveComponent(fi);
components.Add(comp);
//Update the family symbol
if (familyType.InternalFamilySymbol.Id != fi.Symbol.Id)
{
fi.Symbol = familyType.InternalFamilySymbol;
}
UpdatePlacementPoints(fi, points[i].ToXyzs());
instances.Add(fi);
}
// Delete the redundant adaptive components if any
for (int i = reusableCount; i < countOfOldInstances; i++)
{
var fi = oldInstances.ElementAt(i);
Document.Delete(fi.Id);
}
// Create new adaptive components
if (countToBeCreated > countOfOldInstances)
{
var remainingPoints = points.Skip(reusableCount).ToArray();
// Prepare the creation data for batch processing
int numOfComponents = remainingPoints.Count();
List <FamilyInstanceCreationData> creationDatas = new List <FamilyInstanceCreationData>(numOfComponents);
for (int i = 0; i < numOfComponents; ++i)
{
int numOfPoints = remainingPoints[i].Length;
var aPoints = remainingPoints[i].ToXyzs();
var creationData = DocumentManager.Instance.CurrentUIApplication.Application.Create.
NewFamilyInstanceCreationData(familyType.InternalFamilySymbol, aPoints);
if (creationData != null)
{
creationDatas.Add(creationData);
}
}
// Create elements based on the creation data in a batch
ICollection <ElementId> elements;
if (creationDatas.Count > 0)
{
if (Document.IsFamilyDocument)
{
elements = DocumentManager.Instance.CurrentDBDocument.FamilyCreate.NewFamilyInstances2(creationDatas);
}
else
{
elements = DocumentManager.Instance.CurrentDBDocument.Create.NewFamilyInstances2(creationDatas);
}
foreach (var id in elements)
{
Autodesk.Revit.DB.FamilyInstance instance;
if (ElementUtils.TryGetElement <Autodesk.Revit.DB.FamilyInstance>(
DocumentManager.Instance.CurrentDBDocument, id, out instance))
{
instances.Add(instance);
components.Add(new AdaptiveComponent(instance));
}
}
}
}
ElementBinder.SetElementsForTrace(instances);
}
catch (Exception e)
{
// Unregister the elements from the element life cycle manager and delete the elements
var elementManager = ElementIDLifecycleManager <int> .GetInstance();
foreach (var component in components)
{
elementManager.UnRegisterAssociation(component.InternalElementId.IntegerValue, component);
}
foreach (var instance in instances)
{
Document.Delete(instance.Id);
}
if (e is Autodesk.Revit.Exceptions.ArgumentException)
{
throw new ArgumentException("The arguments have issues", e);
}
else
{
throw e;
}
}
finally
{
TransactionManager.Instance.TransactionTaskDone();
}
return(components.ToArray());
}
/// <summary>
/// Duplicates A Sheet.
/// </summary>
/// <param name="sheet">The Sheet to be Duplicated.</param>
/// <param name="duplicateWithContents">Set to true that Duplicate sheet with contents</param>
/// <param name="duplicateWithView">Set to true that Duplicate sheet with views.</param>
/// <param name="viewDuplicateOption">Enter View Duplicate Option: 0 = Duplicate. 1 = AsDependent. 2 = WithDetailing.</param>
/// <param name="prefix"></param>
/// <param name="suffix">When prefix and suffix are both empty, suffix will set a default value - " - Copy".</param>
/// <returns></returns>
public static Sheet DuplicateSheet(Sheet sheet, bool duplicateWithContents = false, bool duplicateWithView = false, int viewDuplicateOption = 0, string prefix = "", string suffix = "")
{
if (sheet == null)
{
throw new ArgumentNullException(nameof(sheet));
}
ViewDuplicateOption Option = 0;
switch (viewDuplicateOption)
{
case 0:
Option = ViewDuplicateOption.Duplicate;
break;
case 1:
Option = ViewDuplicateOption.AsDependent;
break;
case 2:
Option = ViewDuplicateOption.WithDetailing;
break;
default:
throw new ArgumentException(Properties.Resources.ViewDuplicateOptionOutofRange);
}
if (String.IsNullOrEmpty(prefix) && String.IsNullOrEmpty(suffix))
{
suffix = " - Copy";
}
Sheet newSheet = null;
try
{
RevitServices.Transactions.TransactionManager.Instance.EnsureInTransaction(Application.Document.Current.InternalDocument);
var oldElements = ElementBinder.GetElementsFromTrace <Autodesk.Revit.DB.Element>(Document);
List <ElementId> elementIds = new List <ElementId>();
var newSheetNumber = prefix + sheet.SheetNumber + suffix;
var newSheetName = sheet.SheetName;
List <Autodesk.Revit.DB.Element> TraceElements = new List <Autodesk.Revit.DB.Element>();
if (oldElements != null)
{
foreach (var element in oldElements)
{
elementIds.Add(element.Id);
if (element is ViewSheet)
{
var oldSheet = (element as ViewSheet).ToDSType(false) as Sheet;
if (oldSheet.SheetNumber.Equals(newSheetNumber))
{
if ((duplicateWithView && oldElements.Count() > 1) || (!duplicateWithView && oldElements.Count() == 1))
{
newSheet = oldSheet;
TraceElements.AddRange(oldElements);
}
if (newSheet != null)
{
if (duplicateWithContents)
{
DuplicateSheetAnnotations(sheet, newSheet);
}
else
{
DeleteSheetAnnotations(newSheet);
}
}
}
}
}
if (newSheet == null)
{
Autodesk.Revit.UI.UIDocument uIDocument = new Autodesk.Revit.UI.UIDocument(Document);
var openedViews = uIDocument.GetOpenUIViews().ToList();
var shouldClosedViews = openedViews.FindAll(x => elementIds.Contains(x.ViewId));
if (shouldClosedViews.Count > 0)
{
foreach (var v in shouldClosedViews)
{
if (uIDocument.GetOpenUIViews().ToList().Count() > 1)
{
v.Close();
}
else
{
throw new InvalidOperationException(string.Format(Properties.Resources.CantCloseLastOpenView, v.ToString()));
}
}
}
Document.Delete(elementIds);
}
}
if (newSheet == null && TraceElements.Count == 0)
{
// Create a new Sheet with different SheetNumber
var titleBlockElement = sheet.TitleBlock.First() as FamilyInstance;
FamilySymbol TitleBlock = titleBlockElement.InternalFamilyInstance.Symbol;
FamilyType titleBlockFamilyType = ElementWrapper.Wrap(TitleBlock, true);
if (!CheckUniqueSheetNumber(newSheetNumber))
{
throw new ArgumentException(String.Format(Properties.Resources.SheetNumberExists, newSheetNumber));
}
var viewSheet = Autodesk.Revit.DB.ViewSheet.Create(Document, TitleBlock.Id);
newSheet = new Sheet(viewSheet);
newSheet.InternalSetSheetName(newSheetName);
newSheet.InternalSetSheetNumber(newSheetNumber);
TraceElements.Add(newSheet.InternalElement);
// Copy Annotation Elements from sheet to new sheet by ElementTransformUtils.CopyElements
if (duplicateWithContents)
{
DuplicateSheetAnnotations(sheet, newSheet);
}
if (duplicateWithView)
{
// Copy ScheduleSheetInstance except RevisionSchedule from sheet to new sheet by ElementTransformUtils.CopyElements
DuplicateScheduleSheetInstance(sheet, newSheet);
// Duplicate Viewport in sheet and place on new sheet
TraceElements.AddRange(DuplicateViewport(sheet, newSheet, Option, prefix, suffix));
}
}
ElementBinder.SetElementsForTrace(TraceElements);
RevitServices.Transactions.TransactionManager.Instance.TransactionTaskDone();
}
catch (Exception e)
{
if (newSheet != null)
{
newSheet.Dispose();
}
throw e;
}
return(newSheet);
}
/// <summary>
/// [INTERNAL]: Calculates the longest Path of Travel of all shortest paths from rooms in the floor plan to given exit points.
/// </summary>
/// <param name="rvtView">Floor plan view for which rooms will be used to retrieve longest paths to the given exit points.</param>
/// <param name="endPoints">List of end (exit) points.</param>
/// <returns>List of Path of Travel elements corresponding to the longest of shortest exit paths from rooms.</returns>
///
private static PathOfTravel[] InternalLongestOfShortestExitPaths(Rvt.View rvtView, IEnumerable <XYZ> endPoints)
{
List <PathOfTravel> pathsOfTravel = new List <PathOfTravel>();
TransactionManager.Instance.EnsureInTransaction(Document);
try
{
IList <XYZ> startsOfLongestPathsFromRooms = RvtAnalysis.PathOfTravel.FindStartsOfLongestPathsFromRooms(
rvtView,
endPoints.ToList());
if (startsOfLongestPathsFromRooms.Count() != 0)
{
IList <XYZ> endsOfShortestPaths = RvtAnalysis.PathOfTravel.FindEndsOfShortestPaths(
rvtView,
endPoints.ToList(),
startsOfLongestPathsFromRooms);
IList <RvtAnalysis.PathOfTravel> newRvtPathOfTravels = RvtAnalysis.PathOfTravel.CreateMultiple(
rvtView,
startsOfLongestPathsFromRooms.ToList(),
endsOfShortestPaths.ToList());
foreach (RvtAnalysis.PathOfTravel rvtPathOfTravel in newRvtPathOfTravels)
{
if (rvtPathOfTravel != null)
{
pathsOfTravel.Add(new PathOfTravel(rvtPathOfTravel));
}
}
ElementBinder.SetElementsForTrace(pathsOfTravel.Where(x => x != null).Select(x => x.InternalElement));
}
}
catch (Exception e)
{
//unregister the elements from the element life cycle manager and delete the elements
var elementManager = ElementIDLifecycleManager <int> .GetInstance();
if (pathsOfTravel != null)
{
foreach (var path in pathsOfTravel)
{
if (path != null)
{
elementManager.UnRegisterAssociation(path.InternalElementId.IntegerValue, path);
Document.Delete(path.InternalElementId);
}
}
}
throw e;
}
finally
{
TransactionManager.Instance.TransactionTaskDone();
}
return(pathsOfTravel.ToArray());
}
