/// <summary>
/// Create a new ClassificationCache.
/// </summary>
/// <param name="doc">The document.</param>
public ClassificationCache(Document doc)
{
// The UI currently supports only one, but future UIs may support a list.
IList <IFCClassification> classifications;
if (IFCClassificationMgr.GetSavedClassifications(doc, null, out classifications))
{
foreach (IFCClassification classification in classifications)
{
bool classificationHasName = !string.IsNullOrWhiteSpace(classification.ClassificationName);
if (classificationHasName)
{
ClassificationsByName[classification.ClassificationName] = classification;
}
if (!string.IsNullOrWhiteSpace(classification.ClassificationFieldName))
{
string[] splitResult = classification.ClassificationFieldName.Split(new Char[] { ',', ';', '\t', '\n' }, StringSplitOptions.RemoveEmptyEntries);
for (int i = 0; i < splitResult.Length; i++)
{
// found [<Classification Field Names>]
string classificationFieldName = splitResult[i].Trim();
CustomClassificationCodeNames.Add(classificationFieldName);
if (classificationHasName)
{
FieldNameToClassificationNames[classificationFieldName] = classification.ClassificationName;
}
}
}
}
}
}
/// <summary>
/// Event when OK button is pressed
/// </summary>
/// <param name="sender"></param>
/// <param name="args"></param>
private void buttonOK_Click(object sender, RoutedEventArgs args)
{
// Update Classification if it has changed or the mandatory fields are filled. If mandatory fields are not filled we will ignore the classification.
if (!m_newClassification.IsUnchanged(m_savedClassification))
{
if (!m_newClassification.AreMandatoryFieldsFilled())
{
fillMandatoryFields(m_newClassification);
}
IFCClassificationMgr.UpdateClassification(IFCCommandOverrideApplication.TheDocument, m_newClassification);
}
Close();
}
/// <summary>
/// Initialization of the Classification Tab when there is saved item
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void ClassificationTab_Initialized(object sender, EventArgs e)
{
bool hasSavedItem = IFCClassificationMgr.GetSavedClassifications(IFCCommandOverrideApplication.TheDocument, null, out m_newClassificationList);
m_newClassification = m_newClassificationList[0]; // Set the default first Classification item to the first member of the List
if (hasSavedItem == true)
{
m_savedClassification = m_newClassification.Clone();
}
if (m_newClassification.ClassificationEditionDate <= DateTime.MinValue || m_newClassification.ClassificationEditionDate >= DateTime.MaxValue)
{
DateTime today = DateTime.Now;
m_newClassification.ClassificationEditionDate = today;
}
}
/// <summary>
/// Event when OK button is pressed
/// </summary>
/// <param name="sender"></param>
/// <param name="args"></param>
private void buttonOK_Click(object sender, RoutedEventArgs args)
{
// Saved changes to both Address Tab items and File Header Tab items if they have changed
if (m_newAddressItem.isUnchanged(m_savedAddressItem) == false)
{
m_newAddress.UpdateAddress(IFCCommandOverrideApplication.TheDocument, m_newAddressItem);
}
if (m_newFileHeaderItem.isUnchanged(m_savedFileHeaderItem) == false)
{
m_newFileHeader.UpdateFileHeader(IFCCommandOverrideApplication.TheDocument, m_newFileHeaderItem);
}
if (m_newAddressItem.UpdateProjectInformation == true)
{
// Format IFC address and update it into Project Information: Project Address
String address = null;
String geographicMapLocation = null;
bool addNewLine = false;
if (String.IsNullOrEmpty(m_newAddressItem.AddressLine1) == false)
{
address += string.Format("{0}\r\n", m_newAddressItem.AddressLine1);
}
if (String.IsNullOrEmpty(m_newAddressItem.AddressLine2) == false)
{
address += string.Format("{0}\r\n", m_newAddressItem.AddressLine2);
}
if (String.IsNullOrEmpty(m_newAddressItem.POBox) == false)
{
address += string.Format("{0}\r\n", m_newAddressItem.POBox);
}
if (String.IsNullOrEmpty(m_newAddressItem.TownOrCity) == false)
{
address += string.Format("{0}", m_newAddressItem.TownOrCity);
addNewLine = true;
}
if (String.IsNullOrEmpty(m_newAddressItem.RegionOrState) == false)
{
address += string.Format(", {0}", m_newAddressItem.RegionOrState);
addNewLine = true;
}
if (String.IsNullOrEmpty(m_newAddressItem.PostalCode) == false)
{
address += string.Format(" {0}", m_newAddressItem.PostalCode);
addNewLine = true;
}
if (addNewLine == true)
{
address += string.Format("\r\n");
addNewLine = false;
}
if (String.IsNullOrEmpty(m_newAddressItem.Country) == false)
{
address += string.Format("{0}\r\n", m_newAddressItem.Country);
}
if (String.IsNullOrEmpty(m_newAddressItem.InternalLocation) == false)
{
address += string.Format("\r\n{0}: {1}\r\n",
Properties.Resources.InternalAddress, m_newAddressItem.InternalLocation);
}
if (String.IsNullOrEmpty(m_newAddressItem.TownOrCity) == false)
{
geographicMapLocation = m_newAddressItem.TownOrCity;
}
if (String.IsNullOrEmpty(m_newAddressItem.RegionOrState) == false)
{
if (String.IsNullOrEmpty(geographicMapLocation) == false)
{
geographicMapLocation = geographicMapLocation + ", " + m_newAddressItem.RegionOrState;
}
else
{
geographicMapLocation = m_newAddressItem.RegionOrState;
}
}
if (String.IsNullOrEmpty(m_newAddressItem.Country) == false)
{
if (String.IsNullOrEmpty(geographicMapLocation) == false)
{
geographicMapLocation = geographicMapLocation + ", " + m_newAddressItem.Country;
}
else
{
geographicMapLocation = m_newAddressItem.Country;
}
}
;
Transaction transaction = new Transaction(IFCCommandOverrideApplication.TheDocument, Properties.Resources.UpdateProjectAddress);
transaction.Start();
ProjectInfo projectInfo = IFCCommandOverrideApplication.TheDocument.ProjectInformation;
projectInfo.Address = address; // set project address information using the IFC Address Information when requested
if (String.IsNullOrEmpty(geographicMapLocation) == false)
{
IFCCommandOverrideApplication.TheDocument.ActiveProjectLocation.SiteLocation.PlaceName = geographicMapLocation; // Update also Revit Site location on the Map using City, State and Country when they are not null
}
transaction.Commit();
}
// Update Classification if it has changed or the mandatory fields are filled. If mandatory fields are not filled we will ignore the classification.
if (!m_newClassification.IsUnchanged(m_savedClassification))
{
if (m_newClassification.AreMandatoryFieldsFilled())
{
IFCClassificationMgr.UpdateClassification(IFCCommandOverrideApplication.TheDocument, m_newClassification);
}
else if (!m_newClassification.IsClassificationEmpty())
{
m_newClassification.ClassificationTabMsg = Properties.Resources.ManditoryFieldsNotEmpty;
return;
}
}
m_newClassification.ClassificationTabMsg = null;
Close();
}
/// <summary>
/// Implementation of the command binding event for the IFC export command.
/// </summary>
/// <param name="sender">The event sender (Revit UIApplication).</param>
/// <param name="args">The arguments (command binding).</param>
public void OnIFCExport(object sender, CommandEventArgs args)
{
try
{
// Prepare basic objects
UIApplication uiApp = sender as UIApplication;
UIDocument uiDoc = uiApp.ActiveUIDocument;
Document doc = uiDoc.Document;
TheDocument = doc;
IFCExportConfigurationsMap configurationsMap = new IFCExportConfigurationsMap();
configurationsMap.Add(IFCExportConfiguration.GetInSession());
configurationsMap.AddBuiltInConfigurations();
configurationsMap.AddSavedConfigurations();
String mruSelection = null;
if (m_mruConfiguration != null && configurationsMap.HasName(m_mruConfiguration))
{
mruSelection = m_mruConfiguration;
}
PotentiallyUpdatedConfigurations = false;
IFCExport mainWindow = new IFCExport(doc, configurationsMap, mruSelection);
mainWindow.ShowDialog();
// If user chose to continue
if (mainWindow.Result == IFCExportResult.ExportAndSaveSettings)
{
// change options
IFCExportConfiguration selectedConfig = mainWindow.GetSelectedConfiguration();
// Prepare the export options
IFCExportOptions exportOptions = new IFCExportOptions();
selectedConfig.UpdateOptions(exportOptions, uiDoc.ActiveView.Id);
// prompt for the file name
SaveFileDialog fileDialog = new SaveFileDialog();
fileDialog.AddExtension = true;
String defaultDirectory = m_mruExportPath != null ? m_mruExportPath : null;
if (defaultDirectory == null)
{
String revitFilePath = doc.PathName;
if (!String.IsNullOrEmpty(revitFilePath))
{
defaultDirectory = Path.GetDirectoryName(revitFilePath);
}
}
if (defaultDirectory == null)
{
defaultDirectory = Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments);
}
String defaultFileName = doc.Title;
if (String.IsNullOrEmpty(defaultFileName))
{
defaultFileName = "Project";
}
else
{
defaultFileName = Path.GetFileNameWithoutExtension(defaultFileName);
}
String defaultExtension = mainWindow.GetFileExtension();
fileDialog.FileName = defaultFileName;
fileDialog.DefaultExt = defaultExtension;
fileDialog.Filter = mainWindow.GetFileFilter();
fileDialog.InitialDirectory = defaultDirectory;
bool?fileDialogResult = fileDialog.ShowDialog();
// If user chose to continue
if (fileDialogResult.HasValue && fileDialogResult.Value)
{
// Prompt the user for the file location and path
String fullName = fileDialog.FileName;
String path = Path.GetDirectoryName(fullName);
String fileName = Path.GetFileName(fullName);
// Call this before the Export IFC transaction starts, as it has its own transaction.
IFCClassificationMgr.DeleteObsoleteSchemas(doc);
// IFC export requires an open transaction, although no changes should be made
Transaction transaction = new Transaction(doc, "Export IFC");
transaction.Start();
FailureHandlingOptions failureOptions = transaction.GetFailureHandlingOptions();
failureOptions.SetClearAfterRollback(false);
transaction.SetFailureHandlingOptions(failureOptions);
// There is no UI option for this, but these two options can be useful for debugging/investigating
// issues in specific file export. The first one supports export of only one element
//exportOptions.AddOption("SingleElement", "174245");
// The second one supports export only of a list of elements
//exportOptions.AddOption("ElementsForExport", "174245;205427");
bool result = doc.Export(path, fileName, exportOptions); // pass in the options here
if (!result)
{
using (TaskDialog taskDialog = new TaskDialog(Properties.Resources.IFCExport))
{
taskDialog.MainInstruction = Properties.Resources.IFCExportProcessError;
taskDialog.MainIcon = TaskDialogIcon.TaskDialogIconWarning;
TaskDialogResult taskDialogResult = taskDialog.Show();
}
}
// 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");
bool use2009BuildingStoreyGUIDs = (use2009GUID != null && use2009GUID == "1");
// Cache for links guids
Dictionary <ElementId, string> linksGUIDsCache = new Dictionary <ElementId, string>();
if (selectedConfig.ExportLinkedFiles == true)
{
Autodesk.Revit.DB.FilteredElementCollector collector = new FilteredElementCollector(doc);
collector.WhereElementIsNotElementType().OfCategory(BuiltInCategory.OST_RvtLinks);
System.Collections.Generic.ICollection <ElementId> rvtLinkInstanceIds = collector.ToElementIds();
foreach (ElementId linkId in rvtLinkInstanceIds)
{
Element linkInstance = doc.GetElement(linkId);
if (linkInstance == null)
{
continue;
}
Parameter parameter = linkInstance.get_Parameter(BuiltInParameter.IFC_GUID);
if (parameter != null && parameter.HasValue && parameter.StorageType == StorageType.String)
{
String sGUID = parameter.AsString(), sGUIDlower = sGUID.ToLower();
foreach (KeyValuePair <ElementId, string> value in linksGUIDsCache)
{
if (value.Value.ToLower().IndexOf(sGUIDlower) == 0)
{
sGUID += "-";
}
}
linksGUIDsCache.Add(linkInstance.Id, sGUID);
}
}
}
// Roll back the transaction started earlier, unless certain options are set.
if (use2009BuildingStoreyGUIDs || selectedConfig.StoreIFCGUID)
{
transaction.Commit();
}
else
{
transaction.RollBack();
}
// Export links
if (selectedConfig.ExportLinkedFiles == true)
{
exportOptions.AddOption("ExportingLinks", true.ToString());
ExportLinkedDocuments(doc, fullName, linksGUIDsCache, exportOptions);
exportOptions.AddOption("ExportingLinks", false.ToString());
}
// Remember last successful export location
m_mruExportPath = path;
}
}
// The cancel button should cancel the export, not any "OK"ed setup changes.
if (mainWindow.Result == IFCExportResult.ExportAndSaveSettings || mainWindow.Result == IFCExportResult.Cancel)
{
if (PotentiallyUpdatedConfigurations)
{
configurationsMap = mainWindow.GetModifiedConfigurations();
configurationsMap.UpdateSavedConfigurations();
}
// Remember last selected configuration
m_mruConfiguration = mainWindow.GetSelectedConfiguration().Name;
}
}
catch (Exception e)
{
using (TaskDialog taskDialog = new TaskDialog(Properties.Resources.IFCExport))
{
taskDialog.MainInstruction = Properties.Resources.IFCExportProcessError;
taskDialog.MainIcon = TaskDialogIcon.TaskDialogIconWarning;
taskDialog.ExpandedContent = e.ToString();
TaskDialogResult result = taskDialog.Show();
}
}
}
/// <summary>
/// initialization of IFCAssignemt class
/// </summary>
/// <param name="document"></param>
public IFCAssignment()
{
m_newClassificationMgr = new IFCClassificationMgr(IFCCommandOverrideApplication.TheDocument);
InitializeComponent();
}
/// <summary>
/// Implementation of the command binding event for the IFC export command.
/// </summary>
/// <param name="sender">The event sender (Revit UIApplication).</param>
/// <param name="args">The arguments (command binding).</param>
public void OnIFCExport(object sender, CommandEventArgs args)
{
try
{
// Prepare basic objects
UIApplication uiApp = sender as UIApplication;
UIDocument uiDoc = uiApp.ActiveUIDocument;
Document activeDoc = uiDoc.Document;
TheDocument = activeDoc;
// Note that when exporting multiple documents, we are still going to use the configurations from the
// active document.
IFCExportConfigurationsMap configurationsMap = new IFCExportConfigurationsMap();
configurationsMap.Add(IFCExportConfiguration.GetInSession());
configurationsMap.AddBuiltInConfigurations();
configurationsMap.AddSavedConfigurations();
String mruSelection = null;
if (m_mruConfiguration != null && configurationsMap.HasName(m_mruConfiguration))
{
mruSelection = m_mruConfiguration;
}
PotentiallyUpdatedConfigurations = false;
IFCExport mainWindow = new IFCExport(uiApp, configurationsMap, mruSelection);
mainWindow.ShowDialog();
// If user chose to continue
if (mainWindow.Result == IFCExportResult.ExportAndSaveSettings)
{
int docsToExport = mainWindow.DocumentsToExport.Count;
// This shouldn't happen, but just to be safe.
if (docsToExport == 0)
{
return;
}
bool multipleFiles = docsToExport > 1;
// If user chooses to continue
// change options
IFCExportConfiguration selectedConfig = mainWindow.GetSelectedConfiguration();
// Prompt the user for the file location and path
string defaultExt = mainWindow.DefaultExt;
String fullName = mainWindow.ExportFilePathName;
String path = Path.GetDirectoryName(fullName);
String fileName = multipleFiles ? Properties.Resources.MultipleFiles : Path.GetFileName(fullName);
// 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");
bool use2009BuildingStoreyGUIDs = (use2009GUID != null && use2009GUID == "1");
string unsuccesfulExports = string.Empty;
// In rare occasions, there may be two projects loaded into Revit with the same name. This isn't supposed to be allowed, but can happen if,
// e.g., a user creates a new project, exports it to IFC, and then calls Open IFC. In this case, if we export both projects, we will overwrite
// one of the exports. Prevent that by keeping track of the exported file names.
ISet <string> exportedFileNames = new HashSet <string>();
foreach (Document document in mainWindow.DocumentsToExport)
{
TheDocument = document;
// Call this before the Export IFC transaction starts, as it has its own transaction.
IFCClassificationMgr.DeleteObsoleteSchemas(document);
Transaction transaction = new Transaction(document, "Export IFC");
transaction.Start();
FailureHandlingOptions failureOptions = transaction.GetFailureHandlingOptions();
failureOptions.SetClearAfterRollback(false);
transaction.SetFailureHandlingOptions(failureOptions);
// Normally the transaction will be rolled back, but there are cases where we do update the document.
// There is no UI option for this, but these two options can be useful for debugging/investigating
// issues in specific file export. The first one supports export of only one element
//exportOptions.AddOption("SingleElement", "174245");
// The second one supports export only of a list of elements
//exportOptions.AddOption("ElementsForExport", "174245;205427");
if (multipleFiles)
{
fileName = IFCUISettings.GenerateFileNameFromDocument(document, exportedFileNames) + "." + defaultExt;
fullName = path + "\\" + fileName;
}
// Prepare the export options
IFCExportOptions exportOptions = new IFCExportOptions();
ElementId activeViewId = GenerateActiveViewIdFromDocument(document);
selectedConfig.ActiveViewId = selectedConfig.UseActiveViewGeometry ? activeViewId.IntegerValue : -1;
selectedConfig.UpdateOptions(exportOptions, activeViewId);
bool result = document.Export(path, fileName, exportOptions);
Dictionary <ElementId, string> linksGUIDsCache = new Dictionary <ElementId, string>();
if (result)
{
// Cache for links guids
if (selectedConfig.ExportLinkedFiles == true)
{
Autodesk.Revit.DB.FilteredElementCollector collector = new FilteredElementCollector(document);
collector.WhereElementIsNotElementType().OfCategory(BuiltInCategory.OST_RvtLinks);
System.Collections.Generic.ICollection <ElementId> rvtLinkInstanceIds = collector.ToElementIds();
foreach (ElementId linkId in rvtLinkInstanceIds)
{
Element linkInstance = document.GetElement(linkId);
if (linkInstance == null)
{
continue;
}
Parameter parameter = linkInstance.get_Parameter(BuiltInParameter.IFC_GUID);
if (parameter != null && parameter.HasValue && parameter.StorageType == StorageType.String)
{
String sGUID = parameter.AsString(), sGUIDlower = sGUID.ToLower();
foreach (KeyValuePair <ElementId, string> value in linksGUIDsCache)
{
if (value.Value.ToLower().IndexOf(sGUIDlower) == 0)
{
sGUID += "-";
}
}
linksGUIDsCache.Add(linkInstance.Id, sGUID);
}
}
}
}
else
{
unsuccesfulExports += fullName + "\n";
}
// Roll back the transaction started earlier, unless certain options are set.
if (result && (use2009BuildingStoreyGUIDs || selectedConfig.StoreIFCGUID))
{
transaction.Commit();
}
else
{
transaction.RollBack();
}
// Export links
if (selectedConfig.ExportLinkedFiles == true)
{
exportOptions.AddOption("ExportingLinks", true.ToString());
ExportLinkedDocuments(document, fullName, linksGUIDsCache, exportOptions);
exportOptions.AddOption("ExportingLinks", false.ToString());
}
}
if (!string.IsNullOrWhiteSpace(unsuccesfulExports))
{
using (TaskDialog taskDialog = new TaskDialog(Properties.Resources.IFCExport))
{
taskDialog.MainInstruction = string.Format(Properties.Resources.IFCExportProcessError, unsuccesfulExports);
taskDialog.MainIcon = TaskDialogIcon.TaskDialogIconWarning;
TaskDialogResult taskDialogResult = taskDialog.Show();
}
}
// Remember last successful export location
m_mruExportPath = path;
}
// The cancel button should cancel the export, not any "OK"ed setup changes.
if (mainWindow.Result == IFCExportResult.ExportAndSaveSettings || mainWindow.Result == IFCExportResult.Cancel)
{
if (PotentiallyUpdatedConfigurations)
{
configurationsMap = mainWindow.GetModifiedConfigurations();
configurationsMap.UpdateSavedConfigurations();
}
// Remember last selected configuration
m_mruConfiguration = mainWindow.GetSelectedConfiguration().Name;
}
}
catch (Exception e)
{
using (TaskDialog taskDialog = new TaskDialog(Properties.Resources.IFCExport))
{
taskDialog.MainInstruction = Properties.Resources.IFCExportProcessGenericError;
taskDialog.MainIcon = TaskDialogIcon.TaskDialogIconWarning;
taskDialog.ExpandedContent = e.ToString();
TaskDialogResult result = taskDialog.Show();
}
}
}
