public GetResponse Get(ByteSequence key, GetOption option)
{
Etcdserverpb.RangeRequest request = new Etcdserverpb.RangeRequest();
request.Key = key.GetByteString();
request.KeysOnly = option.IsCountOnly();
request.Limit = option.GetLimit();
request.Revision = option.GetRevision();
request.KeysOnly = option.IsKeysOnly();
request.Serializable = option.isSerializable();
request.SortOrder = OptionsUtil.ToRangeRequestSortOrder(option.GetSortOrder());
request.SortTarget = OptionsUtil.ToRangeRequestSortTarget(option.GetSortField());
if (option.GetEndKey() != null)
{
request.RangeEnd = option.GetEndKey().GetByteString();
}
var rsp = kVClient.Range(request);
GetResponse response = new GetResponse(rsp);
return(response);
//return Util.ToCompletableFutureWithRetry(
// stub.Range(request),
// new FunctionResponse<Etcdserverpb.RangeRequest, GetResponse>(),
// Util.IsRetriable
//);
}
/// <summary>
/// Creates a new property set options cache from the data in the ExporterIFC passed from Revit.
/// </summary>
/// <param name="exporterIFC">The ExporterIFC handle passed during export.</param>
/// <returns>The new cache.</returns>
/// <remarks>Please initialize this after all other code, as it relies on a consistent cache otherwise.</remarks>
public static PropertySetOptions Create(ExporterIFC exporterIFC, ExportOptionsCache cache)
{
IDictionary <String, String> options = exporterIFC.GetOptions();
PropertySetOptions propertySetOptions = new PropertySetOptions();
propertySetOptions.m_ExportInternalRevit = (!(cache.ExportAs2x3CoordinationView2 || cache.ExportAs2x3COBIE24DesignDeliverable));
// "Revit property sets" override
propertySetOptions.ExportInternalRevitOverride = OptionsUtil.GetNamedBooleanOption(options, "ExportInternalRevitPropertySets");
// "ExportIFCCommonPropertySets" override
propertySetOptions.ExportIFCCommonOverride = OptionsUtil.GetNamedBooleanOption(options, "ExportIFCCommonPropertySets");
// "ExportSchedulesAsPsets" override
propertySetOptions.ExportSchedulesAsPsetsOverride = OptionsUtil.GetNamedBooleanOption(options, "ExportSchedulesAsPsets");
// "ExportUserDefinedPsets" override
propertySetOptions.ExportUserDefinedPsetsOverride = OptionsUtil.GetNamedBooleanOption(options, "ExportUserDefinedPsets");
// "ExportUserDefinedPsetsFileName" override
propertySetOptions.ExportUserDefinedPsetsFileName = OptionsUtil.GetNamedStringOption(options, "ExportUserDefinedPsetsFileName");
// "ExportSpecificSchedules" overrid
propertySetOptions.ExportSpecificSchedulesOverride = OptionsUtil.GetNamedBooleanOption(options, "ExportSpecificSchedules");
return(propertySetOptions);
}
RequestOp toRequestOp()
{
RangeRequest range = new RangeRequest()
{
Key = this.key, CountOnly = this.option.IsCountOnly(),
Limit = this.option.GetLimit(), Revision = this.option.GetRevision(),
KeysOnly = this.option.IsKeysOnly(), Serializable = this.option.isSerializable(),
SortOrder = OptionsUtil.ToRangeRequestSortOrder(this.option.GetSortOrder()),
SortTarget = OptionsUtil.ToRangeRequestSortTarget(this.option.GetSortField())
};
range.RangeEnd = ByteString.CopyFrom(this.option.GetEndKey().getBytes());
RequestOp op = new RequestOp();
op.RequestRange = range;
return(op);
}
/// <summary>
/// Creates a new export options cache from the data in the ExporterIFC passed from Revit.
/// </summary>
/// <param name="exporterIFC">The ExporterIFC handle passed during export.</param>
/// <returns>The new cache.</returns>
public static ExportOptionsCache Create(ExporterIFC exporterIFC, Document document, Autodesk.Revit.DB.View filterView)
{
IDictionary <String, String> options = exporterIFC.GetOptions();
ExportOptionsCache cache = new ExportOptionsCache();
cache.FileVersion = exporterIFC.FileVersion;
cache.FileName = exporterIFC.FileName;
cache.ExportBaseQuantities = exporterIFC.ExportBaseQuantities;
cache.WallAndColumnSplitting = exporterIFC.WallAndColumnSplitting;
cache.SpaceBoundaryLevel = exporterIFC.SpaceBoundaryLevel;
// Export Part element only if 'Current View Only' is checked and 'Show Parts' is selected. Or if it is exported as IFC4RV
cache.ExportParts = (filterView != null && filterView.PartsVisibility == PartsVisibility.ShowPartsOnly);
cache.ExportPartsAsBuildingElementsOverride = null;
cache.ExportAnnotationsOverride = null;
// We are going to default to "true" for IncludeSteelElements to allow the default API
// export to match the default UI.
bool?includeSteelElements = OptionsUtil.GetNamedBooleanOption(options, "IncludeSteelElements");
cache.IncludeSteelElements = includeSteelElements.HasValue && includeSteelElements.Value;
// There is a bug in the native code that doesn't allow us to cast the filterView to any sub-type of View. Work around this by re-getting the element pointer.
if (filterView != null)
{
cache.FilterViewForExport = filterView.Document.GetElement(filterView.Id) as View;
}
else
{
cache.FilterViewForExport = null;
}
cache.ExportBoundingBoxOverride = null;
cache.IncludeSiteElevation = false;
cache.PropertySetOptions = PropertySetOptions.Create(exporterIFC, cache);
String use2DRoomBoundary = Environment.GetEnvironmentVariable("Use2DRoomBoundaryForRoomVolumeCalculationOnIFCExport");
bool? use2DRoomBoundaryOption = OptionsUtil.GetNamedBooleanOption(options, "Use2DRoomBoundaryForVolume");
cache.Use2DRoomBoundaryForRoomVolumeCreation =
((use2DRoomBoundary != null && use2DRoomBoundary == "1") ||
cache.ExportAs2x2 ||
(use2DRoomBoundaryOption != null && use2DRoomBoundaryOption.GetValueOrDefault()));
bool?exportAdvancedSweptSolids = OptionsUtil.GetNamedBooleanOption(options, "ExportAdvancedSweptSolids");
cache.ExportAdvancedSweptSolids = (exportAdvancedSweptSolids.HasValue) ? exportAdvancedSweptSolids.Value : false;
// Set GUIDOptions here.
{
// This option should be rarely used, and is only for consistency with old files. As such, it is set by environment variable only.
String use2009GUID = Environment.GetEnvironmentVariable("Assign2009GUIDToBuildingStoriesOnIFCExport");
cache.GUIDOptions.Use2009BuildingStoreyGUIDs = (use2009GUID != null && use2009GUID == "1");
bool?allowGUIDParameterOverride = OptionsUtil.GetNamedBooleanOption(options, "AllowGUIDParameterOverride");
if (allowGUIDParameterOverride != null)
{
cache.GUIDOptions.AllowGUIDParameterOverride = allowGUIDParameterOverride.Value;
}
bool?storeIFCGUID = OptionsUtil.GetNamedBooleanOption(options, "StoreIFCGUID");
if (storeIFCGUID != null)
{
cache.GUIDOptions.StoreIFCGUID = storeIFCGUID.Value;
}
}
// Set NamingOptions here.
cache.NamingOptions = new NamingOptions();
{
bool?useFamilyAndTypeNameForReference = OptionsUtil.GetNamedBooleanOption(options, "UseFamilyAndTypeNameForReference");
cache.NamingOptions.UseFamilyAndTypeNameForReference =
(useFamilyAndTypeNameForReference != null) && useFamilyAndTypeNameForReference.GetValueOrDefault();
bool?useVisibleRevitNameAsEntityName = OptionsUtil.GetNamedBooleanOption(options, "UseVisibleRevitNameAsEntityName");
cache.NamingOptions.UseVisibleRevitNameAsEntityName =
(useVisibleRevitNameAsEntityName != null) && useVisibleRevitNameAsEntityName.GetValueOrDefault();
bool?useOnlyTypeNameForIfcType = OptionsUtil.GetNamedBooleanOption(options, "UseTypeNameOnlyForIfcType");
cache.NamingOptions.UseTypeNameOnlyForIfcType =
(useOnlyTypeNameForIfcType != null) && useOnlyTypeNameForIfcType.GetValueOrDefault();
}
// "SingleElement" export option - useful for debugging - only one input element will be processed for export
String singleElementValue;
String elementsToExportValue;
if (options.TryGetValue("SingleElement", out singleElementValue))
{
ElementId elementId = ParseElementId(singleElementValue);
List <ElementId> ids = new List <ElementId>();
ids.Add(elementId);
cache.ElementsForExport = ids;
}
else if (options.TryGetValue("ElementsForExport", out elementsToExportValue))
{
IList <ElementId> ids = ParseElementIds(elementsToExportValue);
cache.ElementsForExport = ids;
}
else
{
cache.ElementsForExport = new List <ElementId>();
}
// "ExportAnnotations" override
cache.ExportAnnotationsOverride = OptionsUtil.GetNamedBooleanOption(options, "ExportAnnotations");
// "ExportSeparateParts" override
cache.ExportPartsAsBuildingElementsOverride = OptionsUtil.GetNamedBooleanOption(options, "ExportPartsAsBuildingElements");
// "ExportBoundingBox" override
cache.ExportBoundingBoxOverride = OptionsUtil.GetNamedBooleanOption(options, "ExportBoundingBox");
bool?exportRoomsInView = OptionsUtil.GetNamedBooleanOption(options, "ExportRoomsInView");
cache.ExportRoomsInView = exportRoomsInView != null ? exportRoomsInView.Value : false;
// Using the alternate UI or not.
cache.AlternateUIVersionOverride = OptionsUtil.GetNamedStringOption(options, "AlternateUIVersion");
// Include IFCSITE elevation in the site local placement origin
bool?includeIfcSiteElevation = OptionsUtil.GetNamedBooleanOption(options, "IncludeSiteElevation");
cache.IncludeSiteElevation = includeIfcSiteElevation != null ? includeIfcSiteElevation.Value : false;
string siteTransformation = OptionsUtil.GetNamedStringOption(options, "SitePlacement");
if (!string.IsNullOrEmpty(siteTransformation))
{
SiteTransformBasis trfBasis = SiteTransformBasis.Shared;
if (Enum.TryParse(siteTransformation, out trfBasis))
{
cache.SiteTransformation = trfBasis;
}
}
// We have two ways to get information about level of detail:
// 1. The old Boolean "UseCoarseTessellation".
// 2. The new double "TessellationLevelOfDetail".
// We will combine these both into a LevelOfDetail integer that can be used by different elements differently.
// The scale is from 1 (Extra Low) to 4 (High), where :
// UseCoarseTessellation = true -> 1, UseCoarseTessellation = false -> 4
// TessellationLevelOfDetail * 4 = LevelOfDetail
// TessellationLevelOfDetail takes precedence over UseCoarseTessellation.
cache.LevelOfDetail = ExportTessellationLevel.Low;
bool?useCoarseTessellation = OptionsUtil.GetNamedBooleanOption(options, "UseCoarseTessellation");
if (useCoarseTessellation.HasValue)
{
cache.LevelOfDetail = useCoarseTessellation.Value ? ExportTessellationLevel.ExtraLow : ExportTessellationLevel.High;
}
double?tessellationLOD = OptionsUtil.GetNamedDoubleOption(options, "TessellationLevelOfDetail");
if (tessellationLOD.HasValue)
{
int levelOfDetail = (int)(tessellationLOD.Value * 4.0 + 0.5);
// Ensure LOD is between 1 to 4, inclusive.
levelOfDetail = Math.Min(Math.Max(levelOfDetail, 1), 4);
cache.LevelOfDetail = (ExportTessellationLevel)levelOfDetail;
}
bool?useOnlyTriangulation = OptionsUtil.GetNamedBooleanOption(options, "UseOnlyTriangulation");
cache.UseOnlyTriangulation = useOnlyTriangulation.HasValue ? useOnlyTriangulation.Value : false;
/// Allow exporting a mix of extrusions and BReps as a solid model, if possible.
bool?canExportSolidModelRep = OptionsUtil.GetNamedBooleanOption(options, "ExportSolidModelRep");
cache.CanExportSolidModelRep = canExportSolidModelRep != null ? canExportSolidModelRep.Value : false;
// Set the phase we are exporting
cache.ActivePhaseId = ElementId.InvalidElementId;
String activePhaseElementValue;
if (options.TryGetValue("ActivePhase", out activePhaseElementValue))
{
cache.ActivePhaseId = ParseElementId(activePhaseElementValue);
}
if ((cache.ActivePhaseId == ElementId.InvalidElementId) && (cache.FilterViewForExport != null))
{
Parameter currPhase = cache.FilterViewForExport.get_Parameter(BuiltInParameter.VIEW_PHASE);
if (currPhase != null)
{
cache.ActivePhaseId = currPhase.AsElementId();
}
}
if (cache.ActivePhaseId == ElementId.InvalidElementId)
{
PhaseArray phaseArray = document.Phases;
Phase lastPhase = phaseArray.get_Item(phaseArray.Size - 1);
cache.ActivePhaseId = lastPhase.Id;
cache.ActivePhaseElement = lastPhase;
}
else
{
cache.ActivePhaseElement = document.GetElement(cache.ActivePhaseId) as Phase;
}
bool?useActiveViewGeometry = OptionsUtil.GetNamedBooleanOption(options, "UseActiveViewGeometry");
cache.UseActiveViewGeometry = useActiveViewGeometry.HasValue ? useActiveViewGeometry.Value : false;
if (cache.UseActiveViewGeometry)
{
int? viewId = OptionsUtil.GetNamedIntOption(options, "ActiveViewId");
int activeViewId = viewId.HasValue ? viewId.Value : -1;
View activeView = null;
try
{
activeView = document.GetElement(new ElementId(activeViewId)) as View;
}
catch
{
}
cache.ActiveView = activeView;
}
// "FileType" - note - setting is not respected yet
ParseFileType(options, cache);
string erName = OptionsUtil.GetNamedStringOption(options, "ExchangeRequirement");
Enum.TryParse(erName, out cache.m_exchangeRequirement);
// Get stored File Header information from the UI and use it for export
IFCFileHeaderItem fileHeaderItem = new IFCFileHeaderItem();
new IFCFileHeader().GetSavedFileHeader(document, out fileHeaderItem);
if (cache.m_exchangeRequirement != KnownERNames.NotDefined)
{
// It override existing value (if present) in the saved FileHeader, to use the selected ER from the UI
fileHeaderItem.FileDescription = "ExchangeRequirement [" + erName + "]";
}
cache.FileHeaderItem = fileHeaderItem;
cache.SelectedConfigName = OptionsUtil.GetNamedStringOption(options, "ConfigName");
cache.SelectedParametermappingTableName = OptionsUtil.GetNamedStringOption(options, "ExportUserDefinedParameterMappingFileName");
bool?bExportLinks = OptionsUtil.GetNamedBooleanOption(options, "ExportingLinks");
cache.ExportingLink = (bExportLinks.HasValue && bExportLinks.Value == true);
if (cache.ExportingLink)
{
int?numInstances = OptionsUtil.GetNamedIntOption(options, "NumberOfExportedLinkInstances");
for (int ii = 0; ii < numInstances; ii++)
{
string optionName = (ii == 0) ? "ExportLinkInstanceTransform" : "ExportLinkInstanceTransform" + (ii + 1).ToString();
String aLinkInstanceTransform = OptionsUtil.GetNamedStringOption(options, optionName);
Transform currTransform = null;
if (!String.IsNullOrEmpty(aLinkInstanceTransform))
{
//reconstruct transform
Transform tr = ParseTransform(aLinkInstanceTransform);
//set to cache
if (tr != null)
{
currTransform = tr;
}
}
string fileName = null;
if (ii > 0)
{
optionName = "ExportLinkInstanceFileName" + (ii + 1).ToString();
fileName = OptionsUtil.GetNamedStringOption(options, optionName);
}
if (currTransform == null)
{
cache.m_LinkInstanceInfos.Add(new Tuple <string, Transform>(fileName, Transform.Identity));
}
else
{
cache.m_LinkInstanceInfos.Add(new Tuple <string, Transform>(fileName, currTransform));
}
}
}
cache.ExcludeFilter = OptionsUtil.GetNamedStringOption(options, "ExcludeFilter");
// Geo Reference info
cache.GeoRefCRSName = OptionsUtil.GetNamedStringOption(options, "GeoRefCRSName");
cache.GeoRefCRSDesc = OptionsUtil.GetNamedStringOption(options, "GeoRefCRSDesc");
cache.GeoRefEPSGCode = OptionsUtil.GetNamedStringOption(options, "GeoRefEPSGCode");
cache.GeoRefGeodeticDatum = OptionsUtil.GetNamedStringOption(options, "GeoRefGeodeticDatum");
cache.GeoRefMapUnit = OptionsUtil.GetNamedStringOption(options, "GeoRefMapUnit");
return(cache);
}
protected IFCImportOptions(IDictionary <String, String> options)
{
// "Intent": covers what the import operation is intended to create.
// The two options are:
// "Reference": create lightweight objects intended to be used for reference only.
// This is the option supported by Link IFC.
// "Parametric": attempt to create intelligent objects that can be maximally flexible.
// This option is still supported only by internal Open IFC code.
string intent = OptionsUtil.GetNamedStringOption(options, "Intent");
if (!string.IsNullOrWhiteSpace(intent))
{
IFCImportIntent intentTemp;
if (!Enum.TryParse <IFCImportIntent>(intent, out intentTemp))
{
intentTemp = IFCImportIntent.Reference;
}
Intent = intentTemp;
}
// "Action": covers how the data is intended to be stored.
// Options:
// "Open": Create a new file with the data in it.
// "Link": Create a new file with the data in it, and then link that into an existing document.
string action = OptionsUtil.GetNamedStringOption(options, "Action");
if (!string.IsNullOrWhiteSpace(action))
{
IFCImportAction actionTemp;
if (!Enum.TryParse <IFCImportAction>(action, out actionTemp))
{
actionTemp = IFCImportAction.Open;
}
Action = actionTemp;
}
// We have two Boolean options that control how we process bounding box geometry. They work together as follows:
// 1. AlwaysProcessBoundingBoxGeometry set to true: always import the bounding box geometry.
// 2. If AlwaysProcessBoundingBoxGeometry is not set, or set to false:
// 2a. If ProcessBoundingBoxGeometry is not set or set to true, import the bounding box geometry if there is no other representation available.
// 2b. If ProcessBoundingBoxGeometry is set to false, completely ignore the bounding box geometry.
bool?processBoundingBoxGeometry = OptionsUtil.GetNamedBooleanOption(options, "ProcessBoundingBoxGeometry");
bool?alwaysProcessBoundingBoxGeometry = OptionsUtil.GetNamedBooleanOption(options, "AlwaysProcessBoundingBoxGeometry");
if (alwaysProcessBoundingBoxGeometry.HasValue && alwaysProcessBoundingBoxGeometry.Value)
{
ProcessBoundingBoxGeometry = IFCProcessBBoxOptions.Always;
}
else if (processBoundingBoxGeometry.HasValue)
{
ProcessBoundingBoxGeometry = processBoundingBoxGeometry.Value ? IFCProcessBBoxOptions.NoOtherGeometry : IFCProcessBBoxOptions.Never;
}
else
{
ProcessBoundingBoxGeometry = IFCProcessBBoxOptions.NoOtherGeometry;
}
// The following 2 options control whether containers will get a copy of the geometry of its contained parts. We have two options,
// one for Zones, and one for generic containers. These are currently API-only options.
bool?createDuplicateZoneGeometry = OptionsUtil.GetNamedBooleanOption(options, "CreateDuplicateZoneGeometry");
if (createDuplicateZoneGeometry.HasValue)
{
CreateDuplicateZoneGeometry = createDuplicateZoneGeometry.Value;
}
bool?createDuplicateContainerGeometry = OptionsUtil.GetNamedBooleanOption(options, "CreateDuplicateContainerGeometry");
if (createDuplicateContainerGeometry.HasValue)
{
CreateDuplicateContainerGeometry = createDuplicateContainerGeometry.Value;
}
bool?useStreamlinedOptions = OptionsUtil.GetNamedBooleanOption(options, "UseStreamlinedOptions");
if (useStreamlinedOptions.HasValue)
{
UseStreamlinedOptions = useStreamlinedOptions.Value;
}
bool?disableLogging = OptionsUtil.GetNamedBooleanOption(options, "DisableLogging");
if (disableLogging.HasValue)
{
DisableLogging = disableLogging.Value;
}
bool?verboseLogging = OptionsUtil.GetNamedBooleanOption(options, "VerboseLogging");
if (verboseLogging.HasValue)
{
VerboseLogging = verboseLogging.Value;
}
bool?forceImport = OptionsUtil.GetNamedBooleanOption(options, "ForceImport");
if (forceImport.HasValue)
{
ForceImport = forceImport.Value;
}
bool?createLinkInstanceOnly = OptionsUtil.GetNamedBooleanOption(options, "CreateLinkInstanceOnly");
if (createLinkInstanceOnly.HasValue)
{
CreateLinkInstanceOnly = createLinkInstanceOnly.Value;
}
string revitLinkFileName = OptionsUtil.GetNamedStringOption(options, "RevitLinkFileName");
if (!string.IsNullOrWhiteSpace(revitLinkFileName))
{
RevitLinkFileName = revitLinkFileName;
}
Int64?fileSize = OptionsUtil.GetNamedInt64Option(options, "FileSize", false);
if (fileSize.HasValue)
{
OriginalFileSize = fileSize.Value;
}
Int64?timestamp = OptionsUtil.GetNamedInt64Option(options, "FileModifiedTime", true);
if (timestamp.HasValue)
{
OriginalTimeStamp = OriginalTimeStamp.AddSeconds(timestamp.Value);
}
}
/// <summary>
/// Exports as an IFC file on clicking OK.
/// </summary>
/// <param name="sender">The source of the event.</param>
/// <param name="args">Event arguments that contains the event data.</param>
private void buttonNext_Click(object sender, RoutedEventArgs args)
{
string fileNameWithoutExtension = Path.GetFileNameWithoutExtension(textBoxSetupFileName.Text);
string filePath = Path.GetDirectoryName(textBoxSetupFileName.Text);
// Show Path is invalid message if the path is blank or invalid.
if (!string.IsNullOrWhiteSpace(filePath) && !Directory.Exists(filePath))
{
TaskDialog.Show("Error", Properties.Resources.ValidPathExists);
}
else
{
// Create a default .ifc file if the file name is blank
if (String.IsNullOrWhiteSpace(filePath))
{
updateFileName();
}
// Check for a valid IFC File format, if it does not exists, append the default IFC file format to export to the file
if (Path.GetExtension(textBoxSetupFileName.Text).IndexOf(Properties.Resources.IFC, StringComparison.CurrentCultureIgnoreCase) == -1)
{
textBoxSetupFileName.Text = textBoxSetupFileName.Text.ToString() + "." + m_defaultExt;
}
// Prompt for overwriting the file if it is already present in the directory.
if (File.Exists(textBoxSetupFileName.Text))
{
TaskDialogResult msgBoxResult = TaskDialog.Show(Properties.Resources.IFCExport, String.Format(Properties.Resources.FileExists, textBoxSetupFileName.Text), TaskDialogCommonButtons.Yes | TaskDialogCommonButtons.No);
if (msgBoxResult == TaskDialogResult.No)
{
return;
}
}
if (Win32API.RtlIsDosDeviceName_U(textBoxSetupFileName.Text) != 0)
{
TaskDialog.Show(Properties.Resources.IFCExport, String.Format(Properties.Resources.ReservedDeviceName, textBoxSetupFileName.Text));
return;
}
IFCExportConfiguration selectedConfig = GetSelectedConfiguration();
if (!EditConfigVisited && LastSelectedConfig.ContainsKey(selectedConfig.Name))
{
selectedConfig = LastSelectedConfig[selectedConfig.Name];
}
// This check will be done only for IFC4 and above as this only affects IfcMapConversion use that starts in IFC4 onward
if (!OptionsUtil.ExportAsOlderThanIFC4(selectedConfig.IFCVersion))
{
// Check whether the resulting offset (to wcs) will be too large due to geo-reference information, raise warning
BasePoint surveyPoint = BasePoint.GetSurveyPoint(TheDocument);
BasePoint projectBasePoint = BasePoint.GetProjectBasePoint(TheDocument);
{
XYZ deltaOffset = XYZ.Zero;
switch (selectedConfig.SitePlacement)
{
case SiteTransformBasis.Internal:
deltaOffset = projectBasePoint.Position;
break;
case SiteTransformBasis.Project:
// Offset from Project point is Zero, unchanged from the initial value
break;
case SiteTransformBasis.Site:
deltaOffset = projectBasePoint.Position - surveyPoint.Position;
break;
case SiteTransformBasis.Shared:
deltaOffset = projectBasePoint.SharedPosition;
break;
default:
break;
}
if (!XYZ.IsWithinLengthLimits(deltaOffset))
{
TaskDialogResult msgBoxResult = TaskDialog.Show(Properties.Resources.IFCExport, Properties.Resources.OffsetDistanceTooLarge,
TaskDialogCommonButtons.Ok | TaskDialogCommonButtons.Cancel);
if (msgBoxResult == TaskDialogResult.Cancel)
{
return;
}
}
}
}
Result = IFCExportResult.ExportAndSaveSettings;
Close();
// Set IFC File header with the selected exchange requirement
if (selectedConfig.ExchangeRequirement != KnownERNames.NotDefined)
{
IFCFileHeader ifcFileHeader = new IFCFileHeader();
IFCFileHeaderItem fileHeaderItem;
if (!ifcFileHeader.GetSavedFileHeader(IFCCommandOverrideApplication.TheDocument, out fileHeaderItem))
{
// Do minimum initialization if the header item is not initialized
fileHeaderItem = new IFCFileHeaderItem(IFCCommandOverrideApplication.TheDocument);
}
string erName = selectedConfig.ExchangeRequirement.ToString();
fileHeaderItem.FileDescription = "ExchangeRequirement [" + erName + "]";
ifcFileHeader.UpdateFileHeader(IFCCommandOverrideApplication.TheDocument, fileHeaderItem);
}
LastSelectedConfig[selectedConfig.Name] = selectedConfig;
TheDocument.Application.WriteJournalComment("Dialog Closed", true);
}
}
