/// <summary> /// The main entry point into the .NET IFC import code /// </summary> /// <param name="importer">The internal ImporterIFC class that contains information necessary for the import process.</param> public void ImportIFC(ImporterIFC importer) { TheImporter = this; IDictionary <String, String> options = importer.GetOptions(); TheOptions = m_ImportOptions = IFCImportOptions.Create(options); // An early check, based on the options set - if we are allowed to use an up-to-date existing file on disk, use it. try { string fullIFCFileName = importer.FullFileName; if (!TheOptions.ForceImport && !NeedsReload(importer.Document, fullIFCFileName)) { return; } // Clear the category mapping table, to force reload of options. IFCCategoryUtil.Clear(); if (TheOptions.Intent != IFCImportIntent.Reference) { IFCImportFile.Import(importer); } else { ReferenceIFC(importer.Document, fullIFCFileName, options); } } catch (Exception ex) { if (Importer.TheLog != null) { Importer.TheLog.LogError(-1, ex.Message, false); } // The following message can sometimes occur when reloading some IFC files // from external resources. In this case, we should silently fail, and not // throw. if (!ex.Message.Contains("Starting a new transaction is not permitted")) { throw; } } finally { if (Importer.TheLog != null) { Importer.TheLog.Close(); } if (IFCImportFile.TheFile != null) { IFCImportFile.TheFile.Close(); } } }
/// <summary> /// Quick reject based on IFC file info and existence of Revit file. /// </summary> /// <param name="doc">The parent document.</param> /// <param name="originalIFCFileName">The IFC file name.</param> /// <returns>True if we need a reload; false if nothing has changed.</returns> private bool NeedsReload(Document doc, string originalIFCFileName) { string ifcFileName = ImporterIFCUtils.GetLocalFileName(doc, originalIFCFileName); if (ifcFileName == null) { return(true); } string revitFileName = IFCImportFile.GetRevitFileName(ifcFileName); // If the RVT file doesn't exist, we'll reload. Otherwise, look at saved file size and timestamp. if (!File.Exists(revitFileName)) { return(true); } FileInfo infoIFC = null; try { infoIFC = new FileInfo(ifcFileName); } catch { return(true); } long ifcFileLength = infoIFC.Length; if ((TheOptions.OriginalFileSize != 0) && (ifcFileLength != TheOptions.OriginalFileSize)) { return(true); } // If we got a local IFC file name that is different from the original file name, that may have resulted in a load // operation that would update the timestamp. In this case, ignore that check. // Unfortunately, this means that it is possible that an updated IFC file with the same file size but different contents // would register as unchanged when it was. The alternative, though, is to reload the IFC file on every file open, // which is unacceptable. bool checkFileTimestamp = (ifcFileName == originalIFCFileName); if (checkFileTimestamp) { // Ignore ticks - only needs to be accurate to the second, or 10,000,000 ticks. Int64 diffTicks = infoIFC.LastWriteTimeUtc.Ticks - TheOptions.OriginalTimeStamp.Ticks; if (diffTicks < 0 || diffTicks >= 10000000) { return(true); } } return(false); }
/// <summary> /// The main entry point into the .NET IFC import code /// </summary> /// <param name="importer">The internal ImporterIFC class that contains information necessary for the import process.</param> public void ImportIFC(ImporterIFC importer) { TheImporter = this; IDictionary <String, String> options = importer.GetOptions(); TheOptions = m_ImportOptions = IFCImportOptions.Create(options); // An early check, based on the options set - if we are allowed to use an up-to-date existing file on disk, use it. try { string fullFileName = importer.FullFileName; string revitFileName = IFCImportFile.GetRevitFileName(fullFileName); if (!TheOptions.ForceImport && !NeedsReload(fullFileName, revitFileName)) { return; } // Clear the category mapping table, to force reload of options. IFCCategoryUtil.Clear(); if (TheOptions.Intent != IFCImportIntent.Reference) { IFCImportFile.Import(importer); } else { ReferenceIFC(importer.Document, fullFileName, options); } } catch (Exception ex) { if (Importer.TheLog != null) { Importer.TheLog.LogError(-1, ex.Message, false); } } finally { if (Importer.TheLog != null) { Importer.TheLog.Close(); } if (IFCImportFile.TheFile != null) { IFCImportFile.TheFile.Close(); } } }
/// <summary> /// Import an IFC file into a given document for Reference only. /// </summary> /// <param name="document">The host document for the import.</param> /// <param name="origFullFileName">The full file name of the document.</param> /// <param name="options">The list of configurable options for this import.</param> public void ReferenceIFC(Document document, string origFullFileName, IDictionary <String, String> options) { // We need to generate a local file name for all of the intermediate files (the log file, the cache file, and the shared parameters file). string localFileName = ImporterIFCUtils.GetLocalFileName(document, origFullFileName); if (localFileName == null) { throw new InvalidOperationException("Could not generate local file name for: " + origFullFileName); } // An early check, based on the options set - if we are allowed to use an up-to-date existing file on disk, use it. // It is possible that the log file may have been created in CreateImporter above, // if it is used by an external developer. if (TheLog == null) { m_ImportLog = IFCImportLog.CreateLog(localFileName, "log.html", !m_ImportOptions.DisableLogging); } Document originalDocument = document; Document ifcDocument = null; if (TheOptions.Action == IFCImportAction.Link) { string linkedFileName = IFCImportFile.GetRevitFileName(localFileName); ifcDocument = LoadOrCreateLinkDocument(originalDocument, linkedFileName); } else { ifcDocument = originalDocument; } bool useCachedRevitFile = DocumentUpToDate(ifcDocument, localFileName); // In the case where the document is already opened as a link, but it has been updated on disk, // give the user a warning and use the cached value. if (!useCachedRevitFile && ifcDocument.IsLinked) { useCachedRevitFile = true; Importer.AddDelayedLinkError(BuiltInFailures.ImportFailures.IFCCantUpdateLinkedFile); } if (!useCachedRevitFile) { m_ImportCache = IFCImportCache.Create(ifcDocument, localFileName); // Limit creating the cache to Link, but may either remove limiting or make it more restrict (reload only) later. if (TheOptions.Action == IFCImportAction.Link) { TheCache.CreateExistingElementMaps(ifcDocument); } // TheFile will contain the same value as the return value for this function. IFCImportFile.Create(localFileName, m_ImportOptions, ifcDocument); } if (useCachedRevitFile || IFCImportFile.TheFile != null) { IFCImportFile theFile = IFCImportFile.TheFile; if (theFile != null) { if (theFile.IFCProject != null) { IFCObjectDefinition.CreateElement(ifcDocument, theFile.IFCProject); } // Also process any other entities to create. foreach (IFCObjectDefinition objDef in IFCImportFile.TheFile.OtherEntitiesToCreate) { IFCObjectDefinition.CreateElement(ifcDocument, objDef); } theFile.EndImport(ifcDocument, localFileName); } if (TheOptions.Action == IFCImportAction.Link) { // If we have an original Revit link file name, don't create a new RevitLinkType - // we will use the existing one. bool useExistingType = (TheOptions.RevitLinkFileName != null); ElementId revitLinkTypeId = IFCImportFile.LinkInFile(origFullFileName, localFileName, ifcDocument, originalDocument, useExistingType, !useCachedRevitFile); } } if (m_ImportCache != null) { m_ImportCache.Reset(ifcDocument); } }
/// <summary> /// Import an IFC file into a given document for Reference only. /// </summary> /// <param name="document">The host document for the import.</param> /// <param name="fullFileName">The full file name of the document.</param> /// <param name="options">The list of configurable options for this import.</param> public void ReferenceIFC(Document document, string fullFileName, IDictionary <String, String> options) { // An early check, based on the options set - if we are allowed to use an up-to-date existing file on disk, use it. m_ImportLog = IFCImportLog.CreateLog(fullFileName, "log.html"); Document originalDocument = document; Document ifcDocument = null; if (TheOptions.Action == IFCImportAction.Link) { string linkedFileName = IFCImportFile.GetRevitFileName(fullFileName); ifcDocument = LoadOrCreateLinkDocument(originalDocument, linkedFileName); if (ifcDocument == null) { return; } } else { ifcDocument = originalDocument; } bool useCachedRevitFile = DocumentUpToDate(ifcDocument, fullFileName); // In the case where the document is already opened as a link, but it has been updated on disk, // give the user a warning and use the cached value. if (!useCachedRevitFile && ifcDocument.IsLinked) { useCachedRevitFile = true; Importer.AddDelayedLinkError(BuiltInFailures.ImportFailures.IFCCantUpdateLinkedFile); } if (!useCachedRevitFile) { m_ImportCache = IFCImportCache.Create(ifcDocument, fullFileName); // Limit creating the cache to Link, but may either remove limiting or make it more restrict (reload only) later. if (TheOptions.Action == IFCImportAction.Link) { TheCache.CreateExistingElementMaps(ifcDocument); } // TheFile will contain the same value as the return value for this function. IFCImportFile.Create(fullFileName, m_ImportOptions, ifcDocument); } if (useCachedRevitFile || IFCImportFile.TheFile != null) { IFCImportFile theFile = IFCImportFile.TheFile; if (theFile != null) { if (theFile.IFCProject != null) { IFCObjectDefinition.CreateElement(ifcDocument, theFile.IFCProject); } // Also process any other entities to create. foreach (IFCObjectDefinition objDef in IFCImportFile.TheFile.OtherEntitiesToCreate) { IFCObjectDefinition.CreateElement(ifcDocument, objDef); } theFile.EndImport(ifcDocument, fullFileName); } if (TheOptions.Action == IFCImportAction.Link) { // If we have an original Revit link file name, don't create a new RevitLinkType - // we will use the existing one. bool useExistingType = (TheOptions.RevitLinkFileName != null); ElementId revitLinkTypeId = IFCImportFile.LinkInFile(fullFileName, ifcDocument, originalDocument, useExistingType, !useCachedRevitFile); } } if (m_ImportCache != null) { m_ImportCache.Reset(ifcDocument); } }
public void ImportIFC(ImporterIFC importer) { TheImporter = this; IDictionary <String, String> options = importer.GetOptions(); TheOptions = m_ImportOptions = IFCImportOptions.Create(options); // An early check, based on the options set - if we are allowed to use an up-to-date existing file on disk, use it. try { string revitFileName = IFCImportFile.GetRevitFileName(importer.FullFileName); if (!TheOptions.ForceImport && !NeedsReload(importer.FullFileName, revitFileName)) { return; } // Clear the category mapping table, to force reload of options. IFCCategoryUtil.Clear(); if (TheOptions.Intent != IFCImportIntent.Reference) { IFCImportFile.Import(importer); } else { Document originalDocument = importer.Document; Document ifcDocument = null; if (TheOptions.Action == IFCImportAction.Link) { string linkedFileName = IFCImportFile.GetRevitFileName(importer.FullFileName); ifcDocument = LoadOrCreateLinkDocument(originalDocument, linkedFileName); if (ifcDocument == null) { return; } } else { ifcDocument = originalDocument; } bool useCachedRevitFile = DocumentUpToDate(ifcDocument, importer.FullFileName); // In the case where the document is already opened as a link, but it has been updated on disk, // give the user a warning and use the cached value. if (!useCachedRevitFile && ifcDocument.IsLinked) { useCachedRevitFile = true; Importer.AddDelayedLinkError(BuiltInFailures.ImportFailures.IFCCantUpdateLinkedFile); } if (!useCachedRevitFile) { m_ImportCache = IFCImportCache.Create(ifcDocument, importer.FullFileName); // Limit creating the cache to Link, but may either remove limiting or make it more restrict (reload only) later. if (TheOptions.Action == IFCImportAction.Link) { TheCache.CreateExistingElementMaps(ifcDocument); } // TheFile will contain the same value as the return value for this function. IFCImportFile.Create(importer.FullFileName, m_ImportOptions, ifcDocument); } if (useCachedRevitFile || IFCImportFile.TheFile != null) { if (IFCImportFile.TheFile != null) { if (IFCImportFile.TheFile.IFCProject != null) { IFCObjectDefinition.CreateElement(ifcDocument, IFCImportFile.TheFile.IFCProject); } IFCImportFile.TheFile.EndImport(ifcDocument, importer.FullFileName); } if (TheOptions.Action == IFCImportAction.Link) { // If we have an original Revit link file name, don't create a new RvtLinkSymbol - // we will use the existing one. bool useExistingType = (TheOptions.RevitLinkFileName != null); IFCImportFile.LinkInFile(importer.FullFileName, ifcDocument, originalDocument, useExistingType, !useCachedRevitFile); } } m_ImportCache.Reset(ifcDocument); } } catch (Exception ex) { if (IFCImportFile.TheFile != null) { IFCImportFile.TheFile.Log.LogError(-1, ex.Message, false); } } finally { if (IFCImportFile.TheFile != null) { IFCImportFile.TheFile.Close(); } } }