/// <summary> /// Creates a shape representation and register it to shape representation layer. /// </summary> /// <param name="exporterIFC">The ExporterIFC object.</param> /// <param name="categoryId">The category id.</param> /// <param name="contextOfItems">The context for which the different subtypes of representation are valid.</param> /// <param name="identifier">The identifier for the representation.</param> /// <param name="representationType">The type handle for the representation.</param> /// <param name="items">Collection of geometric representation items that are defined for this representation.</param> /// <returns>The handle.</returns> public static IFCAnyHandle CreateShapeRepresentation(ExporterIFC exporterIFC, Element element, ElementId categoryId, IFCAnyHandle contextOfItems, string identifier, string representationType, ISet<IFCAnyHandle> items) { IFCAnyHandle newShapeRepresentation = CreateBaseShapeRepresentation(exporterIFC, contextOfItems, identifier, representationType, items); if (IFCAnyHandleUtil.IsNullOrHasNoValue(newShapeRepresentation)) return newShapeRepresentation; // Search for old "IFCCadLayer" or new "IfcPresentationLayer". string ifcCADLayer = null; if ((ParameterUtil.GetStringValueFromElementOrSymbol(element, "IFCCadLayer", out ifcCADLayer) == null) || string.IsNullOrWhiteSpace(ifcCADLayer)) { if ((ParameterUtil.GetStringValueFromElementOrSymbol(element, "IfcPresentationLayer", out ifcCADLayer) == null) || string.IsNullOrWhiteSpace(ifcCADLayer)) { ifcCADLayer = ExporterStateManager.GetCurrentCADLayerOverride(); } } // We are using the DWG export layer table to correctly map category to DWG layer for the // IfcPresentationLayerAsssignment, if it is not overridden. if (!string.IsNullOrWhiteSpace(ifcCADLayer)) ExporterCacheManager.PresentationLayerSetCache.AddRepresentationToLayer(ifcCADLayer, newShapeRepresentation); else exporterIFC.RegisterShapeForPresentationLayer(element, categoryId, newShapeRepresentation); return newShapeRepresentation; }
/// <summary> /// Checks if element should be exported using a variety of different checks. /// </summary> /// <param name="exporterIFC">The ExporterIFC object.</param> /// <param name="element">The element.</param> /// <param name="allowSeparateOpeningExport">True if IfcOpeningElement is allowed to be exported.</param> /// <returns>True if the element should be exported, false otherwise.</returns> /// <remarks>There are some inefficiencies here, as we later check IfcExportAs in other contexts. We should attempt to get the value only once.</remarks> public static bool ShouldElementBeExported(ExporterIFC exporterIFC, Element element, bool allowSeparateOpeningExport) { // Allow the ExporterStateManager to say that an element should be exported regardless of settings. if (ExporterStateManager.CanExportElementOverride()) { return(true); } // Check to see if the category should be exported. This overrides the IfcExportAs parameter. if (!ShouldCategoryBeExported(exporterIFC, element, allowSeparateOpeningExport)) { return(false); } string elementClassName; if (IsIFCExportAsSetToDontExport(element, out elementClassName)) { return(false); } // Check whether the intended Entity type is inside the export exclusion set IFCEntityType elementClassTypeEnum; return (!Enum.TryParse(elementClassName, out elementClassTypeEnum) || !ExporterCacheManager.ExportOptionsCache.IsElementInExcludeList(elementClassTypeEnum)); }
/// <summary> /// The constructor that sets the current CAD layer override string. Will do nothing if the string in invalid or null. /// </summary> /// <param name="overrideString">The value.</param> public CADLayerOverrideSetter(string overrideString) { if (!string.IsNullOrWhiteSpace(overrideString)) { ExporterStateManager.PushCADLayerOverride(overrideString); m_ValidString = true; } }
/// <summary> /// Checks if element should be exported using a variety of different checks. /// </summary> /// <param name="exporterIFC">The ExporterIFC object.</param> /// <param name="element">The element.</param> /// <param name="allowSeparateOpeningExport">True if IfcOpeningElement is allowed to be exported.</param> /// <returns>True if the element should be exported, false otherwise.</returns> /// <remarks>There are some inefficiencies here, as we later check IfcExportAs in other contexts. We should attempt to get the value only once.</remarks> public static bool ShouldElementBeExported(ExporterIFC exporterIFC, Element element, bool allowSeparateOpeningExport) { // Allow the ExporterStateManager to say that an element should be exported regardless of settings. if (ExporterStateManager.CanExportElementOverride()) { return(true); } // Check to see if the category should be exported. This overrides the IfcExportAs parameter. if (!ShouldCategoryBeExported(exporterIFC, element, allowSeparateOpeningExport)) { return(false); } string exportAsEntity = "IFCExportAs"; string elementClassName; if (ParameterUtil.GetStringValueFromElementOrSymbol(element, exportAsEntity, out elementClassName) != null) { string enumTypeValue = string.Empty; ExporterUtil.ExportEntityAndPredefinedType(elementClassName, out elementClassName, out enumTypeValue); if (CompareAlphaOnly(elementClassName, "DONTEXPORT")) { return(false); } // Check whether the intended Entity type is inside the export exclusion set Common.Enums.IFCEntityType elementClassTypeEnum; if (Enum.TryParse <Common.Enums.IFCEntityType>(elementClassName, out elementClassTypeEnum)) { if (ExporterCacheManager.ExportOptionsCache.IsElementInExcludeList(elementClassTypeEnum)) { return(false); } } } return(true); }
/// <summary> /// Checks if element should be exported using a variety of different checks. /// </summary> /// <param name="exporterIFC">The ExporterIFC object.</param> /// <param name="element">The element.</param> /// <param name="allowSeparateOpeningExport">True if IfcOpeningElement is allowed to be exported.</param> /// <returns>True if the element should be exported, false otherwise.</returns> /// <remarks>There are some inefficiencies here, as we call GetExportInfoFromParameters /// in other contexts. We should attempt to get the value only once.</remarks> public static bool ShouldElementBeExported(ExporterIFC exporterIFC, Element element, bool allowSeparateOpeningExport) { // Allow the ExporterStateManager to say that an element should be exported regardless of settings. if (ExporterStateManager.CanExportElementOverride()) return true; // First, check if the element is set explicitly to be exported or not exported. This // overrides category settings. Element elementType = element.Document.GetElement(element.GetTypeId()); IFCExportElement? exportElementState = GetExportElementState(element, elementType); if (exportElementState.HasValue) return exportElementState.Value == IFCExportElement.Yes; // Check to see if the category should be exported if parameters aren't set. // Note that in previous versions, the category override the parameter settings. This is // no longer true. if (!ShouldCategoryBeExported(exporterIFC, element, allowSeparateOpeningExport)) return false; // Check whether the intended Entity type is inside the export exclusion set IFCExportInfoPair exportInfo = ExporterUtil.GetIFCExportElementParameterInfo(element, IFCEntityType.IfcRoot); return !ExporterCacheManager.ExportOptionsCache.IsElementInExcludeList(exportInfo.ExportInstance); }