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); } }