public virtual object Clone() { SharedParameterDef clonePar = new SharedParameterDef(); clonePar.Param = this.Param; clonePar.ParamGuid = this.ParamGuid; clonePar.Name = this.Name; clonePar.ParamType = this.ParamType; clonePar.DataCategory = this.DataCategory; clonePar.GroupId = this.GroupId; clonePar.Visibility = this.Visibility; clonePar.Description = this.Description; clonePar.UserModifiable = this.UserModifiable; return(clonePar); }
private void button_Go_Click(object sender, RoutedEventArgs e) { #if DEBUG string tempFolder = System.IO.Path.GetTempPath(); logF = new StreamWriter(Path.Combine(tempFolder, "GeneratePsetDefWin.log")); #endif textBox_OutputMsg.Clear(); string parFileNameOut = Path.Combine(Path.GetDirectoryName(SharedParFileName), Path.GetFileNameWithoutExtension(SharedParFileName) + "_out.txt"); stSharedPar = File.CreateText(parFileNameOut); ProcessPsetDefinition.processExistingParFile(SharedParFileName, false, ref stSharedPar); if (File.Exists(SharedParFileNameType)) { string typeParFileNameOut = Path.Combine(Path.GetDirectoryName(SharedParFileNameType), Path.GetFileNameWithoutExtension(SharedParFileNameType) + "_out.txt"); stSharedParType = File.CreateText(typeParFileNameOut); ProcessPsetDefinition.processExistingParFile(SharedParFileNameType, true, ref stSharedParType); } else { stSharedParType = File.CreateText(SharedParFileNameType); } ProcessPsetDefinition procPsetDef = new ProcessPsetDefinition(logF); if (string.IsNullOrEmpty(textBox_PSDSourceDir.Text) || string.IsNullOrEmpty(textBox_OutputFile.Text)) { return; } var psdFolders = new DirectoryInfo(textBox_PSDSourceDir.Text).GetDirectories("psd", SearchOption.AllDirectories); string dirName = Path.GetDirectoryName(textBox_OutputFile.Text); string penumFileName = Path.GetFileNameWithoutExtension(textBox_OutputFile.Text); if (File.Exists(textBox_OutputFile.Text)) { File.Delete(textBox_OutputFile.Text); } StreamWriter outF = new StreamWriter(textBox_OutputFile.Text); outF.WriteLine("/********************************************************************************************************************************"); outF.WriteLine("** NOTE: This code is generated from IFC psd files automatically by RevitIFCTools. **"); outF.WriteLine("** DO NOT change it manually as it will be overwritten the next time this file is re-generated!! **"); outF.WriteLine("********************************************************************************************************************************/"); outF.WriteLine(); outF.WriteLine("using System;"); outF.WriteLine("using System.Collections.Generic;"); outF.WriteLine("using System.Linq;"); outF.WriteLine("using System.Text;"); outF.WriteLine("using System.Threading.Tasks;"); outF.WriteLine("using Autodesk.Revit;"); outF.WriteLine("using Autodesk.Revit.DB;"); outF.WriteLine("using Autodesk.Revit.DB.IFC;"); outF.WriteLine("using Autodesk.Revit.ApplicationServices;"); outF.WriteLine("using Revit.IFC.Export.Exporter.PropertySet;"); outF.WriteLine("using Revit.IFC.Export.Exporter.PropertySet.Calculators;"); outF.WriteLine("using Revit.IFC.Export.Utility;"); outF.WriteLine("using Revit.IFC.Export.Toolkit;"); outF.WriteLine("using Revit.IFC.Common.Enums;"); outF.WriteLine(""); outF.WriteLine("namespace Revit.IFC.Export.Exporter"); outF.WriteLine("{"); outF.WriteLine("\tpartial class ExporterInitializer"); outF.WriteLine("\t{"); // Collect all Pset definition for psd folders foreach (DirectoryInfo psd in psdFolders) { string schemaFolder = psd.FullName.Remove(0, textBox_PSDSourceDir.Text.Length + 1).Split('\\')[0]; #if DEBUG logF.WriteLine("\n*** Processing " + schemaFolder); #endif foreach (DirectoryInfo subDir in psd.GetDirectories()) { procPsetDef.ProcessSchemaPsetDef(schemaFolder, subDir); } procPsetDef.ProcessSchemaPsetDef(schemaFolder, psd); } // For testing purpose: Dump all the propertyset definition in a text file if (checkBox_Dump.IsChecked.HasValue && checkBox_Dump.IsChecked.Value) { string pSetDump = ""; foreach (KeyValuePair <string, IList <VersionSpecificPropertyDef> > psetDefEntry in procPsetDef.allPDefDict) { pSetDump += "**** Property Set Name: " + psetDefEntry.Key; foreach (VersionSpecificPropertyDef vPdef in psetDefEntry.Value) { pSetDump += "\n ===> IfcVersion: " + vPdef.IfcVersion; pSetDump += "\n" + vPdef.PropertySetDef.ToString() + "\n"; } pSetDump += "\n\n"; } string dumpDir = Path.GetDirectoryName(textBox_OutputFile.Text); string dumpFile = Path.GetFileNameWithoutExtension(textBox_OutputFile.Text) + ".txt"; string dumpFilePath = Path.Combine(dumpDir, dumpFile); if (File.Exists(dumpFilePath)) { File.Delete(dumpFilePath); } StreamWriter tx = new StreamWriter(dumpFilePath); tx.Write(pSetDump); tx.Close(); } // Method to initialize all the propertysets outF.WriteLine("\t\tpublic static void InitCommonPropertySets(IList<IList<PropertySetDescription>> propertySets)"); outF.WriteLine("\t\t{"); outF.WriteLine("\t\t\tIList<PropertySetDescription> commonPropertySets = new List<PropertySetDescription>();"); foreach (KeyValuePair <string, IList <VersionSpecificPropertyDef> > psetDefEntry in procPsetDef.allPDefDict) { outF.WriteLine("\t\t\tInit" + psetDefEntry.Key + "(commonPropertySets);"); } outF.WriteLine("\n\t\t\tpropertySets.Add(commonPropertySets);"); outF.WriteLine("\t\t}"); outF.WriteLine(""); // For generated codes and shared parameters foreach (KeyValuePair <string, IList <VersionSpecificPropertyDef> > psetDefEntry in procPsetDef.allPDefDict) { string psetName = psetDefEntry.Key; outF.WriteLine("\t\tprivate static void Init" + psetName + "(IList<PropertySetDescription> commonPropertySets)"); outF.WriteLine("\t\t{"); string varName = psetDefEntry.Key.Replace("Pset_", "propertySet"); outF.WriteLine("\t\t\tPropertySetDescription {0} = new PropertySetDescription();", varName); string psetEnumStr = psetName.Replace("PSet_", "PSet"); try { Revit.IFC.Export.Toolkit.IFCCommonPSets psetEnum = (Revit.IFC.Export.Toolkit.IFCCommonPSets)Enum.Parse(typeof(Revit.IFC.Export.Toolkit.IFCCommonPSets), psetEnumStr); outF.WriteLine("\t\t\t{0}.SubElementIndex = (int)IFCCommonPSets.{1};", varName, psetName.Replace("PSet_", "PSet")); } catch (ArgumentException) { #if DEBUG logF.WriteLine("\t%Info: " + psetEnumStr + " is not defined in Revit.IFC.Export.Toolkit.IFCCommonPSets."); #endif } outF.WriteLine("\t\t\t{0}.Name = \"{1}\";", varName, psetName); outF.WriteLine("\t\t\tPropertySetEntry ifcPSE = null;"); outF.WriteLine("\t\t\tType calcType = null;"); foreach (VersionSpecificPropertyDef vspecPDef in psetDefEntry.Value) { PsetDefinition pDef = vspecPDef.PropertySetDef; if (vspecPDef.IfcVersion.Equals("IFC2X2", StringComparison.CurrentCultureIgnoreCase)) { outF.WriteLine("\t\t\tif (ExporterCacheManager.ExportOptionsCache.ExportAs2x2 && certifiedEntityAndPsetList.AllowPsetToBeCreated(ExporterCacheManager.ExportOptionsCache.FileVersion.ToString().ToUpper(), \"" + psetName + "\"))"); outF.WriteLine("\t\t\t{"); foreach (string applEnt in vspecPDef.PropertySetDef.ApplicableClasses) { string applEnt2 = applEnt; if (string.IsNullOrEmpty(applEnt)) { applEnt2 = "IfcBuildingElementProxy"; // Default if somehow the data is empty } outF.WriteLine("\t\t\t\t{0}.EntityTypes.Add(IFCEntityType.{1});", varName, applEnt2); } if (!string.IsNullOrEmpty(vspecPDef.PropertySetDef.ApplicableType)) { outF.WriteLine("\t\t\t\t{0}.ObjectType = \"{1}\";", varName, vspecPDef.PropertySetDef.ApplicableType); } if (!string.IsNullOrEmpty(vspecPDef.PropertySetDef.PredefinedType)) { outF.WriteLine("\t\t\t\t{0}.PredefinedType = \"{1}\";", varName, vspecPDef.PropertySetDef.PredefinedType); } } else if (vspecPDef.IfcVersion.Equals("IFC2X3TC1", StringComparison.CurrentCultureIgnoreCase) || vspecPDef.IfcVersion.Equals("IFC2X3_TC1", StringComparison.CurrentCultureIgnoreCase)) { outF.WriteLine("\t\t\tif (ExporterCacheManager.ExportOptionsCache.ExportAs2x3 && certifiedEntityAndPsetList.AllowPsetToBeCreated(ExporterCacheManager.ExportOptionsCache.FileVersion.ToString().ToUpper(), \"" + psetName + "\"))"); outF.WriteLine("\t\t\t{"); foreach (string applEnt in vspecPDef.PropertySetDef.ApplicableClasses) { string applEnt2 = applEnt; if (string.IsNullOrEmpty(applEnt)) { applEnt2 = "IfcBuildingElementProxy"; // Default if somehow the data is empty } outF.WriteLine("\t\t\t\t{0}.EntityTypes.Add(IFCEntityType.{1});", varName, applEnt2); } if (!string.IsNullOrEmpty(vspecPDef.PropertySetDef.ApplicableType)) { outF.WriteLine("\t\t\t\t{0}.ObjectType = \"{1}\";", varName, vspecPDef.PropertySetDef.ApplicableType); } if (!string.IsNullOrEmpty(vspecPDef.PropertySetDef.PredefinedType)) { outF.WriteLine("\t\t\t\t{0}.PredefinedType = \"{1}\";", varName, vspecPDef.PropertySetDef.PredefinedType); } } //else if (vspecPDef.IfcVersion.Equals("IFC4_ADD1")) //{ else if (vspecPDef.SchemaFileVersion.Equals("IFC4_ADD1", StringComparison.CurrentCultureIgnoreCase)) { outF.WriteLine("\t\t\tif (ExporterCacheManager.ExportOptionsCache.ExportAs4_ADD1 && certifiedEntityAndPsetList.AllowPsetToBeCreated(ExporterCacheManager.ExportOptionsCache.FileVersion.ToString().ToUpper(), \"" + psetName + "\"))"); outF.WriteLine("\t\t\t{"); foreach (string applEnt in vspecPDef.PropertySetDef.ApplicableClasses) { string applEnt2 = applEnt; if (string.IsNullOrEmpty(applEnt)) { applEnt2 = "IfcBuildingElementProxy"; // Default if somehow the data is empty } outF.WriteLine("\t\t\t\t{0}.EntityTypes.Add(IFCEntityType.{1});", varName, applEnt2); } if (!string.IsNullOrEmpty(vspecPDef.PropertySetDef.ApplicableType)) { outF.WriteLine("\t\t\t\t{0}.ObjectType = \"{1}\";", varName, vspecPDef.PropertySetDef.ApplicableType); } if (!string.IsNullOrEmpty(vspecPDef.PropertySetDef.PredefinedType)) { outF.WriteLine("\t\t\t\t{0}.PredefinedType = \"{1}\";", varName, vspecPDef.PropertySetDef.PredefinedType); } } else if (vspecPDef.SchemaFileVersion.Equals("IFC4_ADD2", StringComparison.CurrentCultureIgnoreCase)) { outF.WriteLine("\t\t\tif (ExporterCacheManager.ExportOptionsCache.ExportAs4_ADD2 && certifiedEntityAndPsetList.AllowPsetToBeCreated(ExporterCacheManager.ExportOptionsCache.FileVersion.ToString().ToUpper(), \"" + psetName + "\"))"); outF.WriteLine("\t\t\t{"); foreach (string applEnt in vspecPDef.PropertySetDef.ApplicableClasses) { string applEnt2 = applEnt; if (string.IsNullOrEmpty(applEnt)) { applEnt2 = "IfcBuildingElementProxy"; // Default if somehow the data is empty } outF.WriteLine("\t\t\t\t{0}.EntityTypes.Add(IFCEntityType.{1});", varName, applEnt2); } if (!string.IsNullOrEmpty(vspecPDef.PropertySetDef.ApplicableType)) { outF.WriteLine("\t\t\t\t{0}.ObjectType = \"{1}\";", varName, vspecPDef.PropertySetDef.ApplicableType); } if (!string.IsNullOrEmpty(vspecPDef.PropertySetDef.PredefinedType)) { outF.WriteLine("\t\t\t\t{0}.PredefinedType = \"{1}\";", varName, vspecPDef.PropertySetDef.PredefinedType); } } else if (vspecPDef.SchemaFileVersion.Equals("IFC4", StringComparison.CurrentCultureIgnoreCase)) { outF.WriteLine("\t\t\tif (ExporterCacheManager.ExportOptionsCache.ExportAs4 && certifiedEntityAndPsetList.AllowPsetToBeCreated(ExporterCacheManager.ExportOptionsCache.FileVersion.ToString().ToUpper(), \"" + psetName + "\"))"); outF.WriteLine("\t\t\t{"); foreach (string applEnt in vspecPDef.PropertySetDef.ApplicableClasses) { string applEnt2 = applEnt; if (string.IsNullOrEmpty(applEnt)) { applEnt2 = "IfcBuildingElementProxy"; // Default if somehow the data is empty } outF.WriteLine("\t\t\t\t{0}.EntityTypes.Add(IFCEntityType.{1});", varName, applEnt2); } if (!string.IsNullOrEmpty(vspecPDef.PropertySetDef.ApplicableType)) { outF.WriteLine("\t\t\t\t{0}.ObjectType = \"{1}\";", varName, vspecPDef.PropertySetDef.ApplicableType); } if (!string.IsNullOrEmpty(vspecPDef.PropertySetDef.PredefinedType)) { outF.WriteLine("\t\t\t\t{0}.PredefinedType = \"{1}\";", varName, vspecPDef.PropertySetDef.PredefinedType); } } else { #if DEBUG logF.WriteLine("%Error - Unrecognized schema version : " + vspecPDef.SchemaFileVersion); #endif } //} // Process each property foreach (PsetProperty prop in pDef.properties) { // Handle only one level deep of complex property !!!! if (prop.PropertyType is ComplexProperty) { ComplexProperty complexProp = prop.PropertyType as ComplexProperty; // For complex property the properties will be flattened by using <Pset>.<Property>.<SubProperty> foreach (PsetProperty propCx in complexProp.Properties) { string prefixName = pDef.Name + "." + prop.Name; procPsetDef.processSimpleProperty(outF, propCx, prefixName, pDef.IfcVersion, vspecPDef.SchemaFileVersion, varName, vspecPDef, penumFileName); } } else { procPsetDef.processSimpleProperty(outF, prop, pDef.Name, pDef.IfcVersion, vspecPDef.SchemaFileVersion, varName, vspecPDef, penumFileName); } } outF.WriteLine("\t\t\t}"); } outF.WriteLine("\t\t\tif (ifcPSE != null)"); outF.WriteLine("\t\t\t{"); //outF.WriteLine("\t\t\t\t{0}.Name = \"{1}\";", varName, psetName); outF.WriteLine("\t\t\t\tcommonPropertySets.Add({0});", varName); outF.WriteLine("\t\t\t}"); outF.WriteLine("\t\t}"); outF.WriteLine("\n"); } outF.WriteLine("\t}"); outF.WriteLine("}"); outF.Close(); procPsetDef.endWriteEnumFile(); // Now write shared parameter definitions from the Dict to destination file stSharedPar.WriteLine("# This is a Revit shared parameter file."); stSharedPar.WriteLine("# Do not edit manually."); stSharedPar.WriteLine("*META VERSION MINVERSION"); stSharedPar.WriteLine("META 2 1"); stSharedPar.WriteLine("*GROUP ID NAME"); stSharedPar.WriteLine("GROUP 2 IFC Properties"); stSharedPar.WriteLine("*PARAM GUID NAME DATATYPE DATACATEGORY GROUP VISIBLE DESCRIPTION USERMODIFIABLE"); stSharedPar.WriteLine("#"); foreach (KeyValuePair <string, SharedParameterDef> parDef in ProcessPsetDefinition.SharedParamFileDict) { SharedParameterDef newPar = parDef.Value; string vis = newPar.Visibility ? "1" : "0"; string usrMod = newPar.UserModifiable ? "1" : "0"; string parEntry = newPar.Param + "\t" + newPar.ParamGuid.ToString() + "\t" + newPar.Name + "\t" + newPar.ParamType + "\t" + newPar.DataCategory + "\t" + newPar.GroupId.ToString() + "\t" + vis + "\t" + newPar.Description + "\t" + usrMod; stSharedPar.WriteLine(parEntry); } stSharedParType.WriteLine("# This is a Revit shared parameter file."); stSharedParType.WriteLine("# Do not edit manually."); stSharedParType.WriteLine("*META VERSION MINVERSION"); stSharedParType.WriteLine("META 2 1"); stSharedParType.WriteLine("*GROUP ID NAME"); stSharedParType.WriteLine("GROUP 2 IFC Properties"); stSharedParType.WriteLine("*PARAM GUID NAME DATATYPE DATACATEGORY GROUP VISIBLE DESCRIPTION USERMODIFIABLE"); stSharedParType.WriteLine("#"); foreach (KeyValuePair <string, SharedParameterDef> parDef in ProcessPsetDefinition.SharedParamFileTypeDict) { SharedParameterDef newPar = parDef.Value; string parName4Type; if (newPar.Name.EndsWith("[Type]")) { parName4Type = newPar.Name; } else { parName4Type = newPar.Name + "[Type]"; } string vis = newPar.Visibility ? "1" : "0"; string usrMod = newPar.UserModifiable ? "1" : "0"; string parEntry = newPar.Param + "\t" + newPar.ParamGuid.ToString() + "\t" + parName4Type + "\t" + newPar.ParamType + "\t" + newPar.DataCategory + "\t" + newPar.GroupId.ToString() + "\t" + vis + "\t" + newPar.Description + "\t" + usrMod; stSharedParType.WriteLine(parEntry); } stSharedPar.Close(); stSharedParType.Close(); #if DEBUG logF.Close(); #endif }
void WriteRevitSharedParam(StreamWriter stSharedPar, IDictionary <string, SharedParameterDef> existingParDict, IDictionary <string, int> groupParamDict, bool isType, out IList <string> deferredParList) { // Now write shared parameter definitions from the Dict to destination file stSharedPar.WriteLine("# This is a Revit shared parameter file."); stSharedPar.WriteLine("# Do not edit manually."); stSharedPar.WriteLine("*META VERSION MINVERSION"); stSharedPar.WriteLine("META 2 1"); stSharedPar.WriteLine("*GROUP ID NAME"); int groupID = groupParamDict["Revit IFCExporter Parameters"]; // Keep the list of Parameters that do not belong to any Pset to be written all together in one group at the end deferredParList = new List <string>(); deferredParList.Add(string.Format("#")); deferredParList.Add(string.Format("GROUP {0} Revit IFCExporter Parameters", groupID)); deferredParList.Add(string.Format("*PARAM GUID NAME DATATYPE DATACATEGORY GROUP VISIBLE DESCRIPTION USERMODIFIABLE")); deferredParList.Add(string.Format("#")); string prevPsetName = "Revit IFCExporter Parameters"; int defaultGroupID = groupParamDict[prevPsetName]; SortedDictionary <string, SharedParameterDef> SharedParDict = null; if (!isType) { SharedParDict = ProcessPsetDefinition.SharedParamFileDict; } else { SharedParDict = ProcessPsetDefinition.SharedParamFileTypeDict; } foreach (KeyValuePair <string, SharedParameterDef> parDef in ProcessPsetDefinition.SharedParamFileDict) { SharedParameterDef newPar = parDef.Value; bool toBeDeferred = false; if (!prevPsetName.Equals(newPar.OwningPset, StringComparison.InvariantCultureIgnoreCase)) { if (!string.IsNullOrEmpty(newPar.OwningPset)) { prevPsetName = newPar.OwningPset; groupID = groupParamDict[newPar.OwningPset]; stSharedPar.WriteLine("#"); stSharedPar.WriteLine("GROUP {0} {1}", groupID, newPar.OwningPset); stSharedPar.WriteLine("*PARAM GUID NAME DATATYPE DATACATEGORY GROUP VISIBLE DESCRIPTION USERMODIFIABLE"); stSharedPar.WriteLine("#"); } else { toBeDeferred = true; } } string parName = newPar.Name; if (isType) { if (newPar.Name.EndsWith("[Type]")) { parName = newPar.Name; } else { parName = newPar.Name + "[Type]"; } } string vis = newPar.Visibility ? "1" : "0"; string usrMod = newPar.UserModifiable ? "1" : "0"; // Retain the same GUID if the existing file contains the same parameter name already. This is to keep consistent GUID, even for non-IfdGUID if (existingParDict.ContainsKey(parName)) { var existingPar = existingParDict[parName]; newPar.ParamGuid = existingPar.ParamGuid; } else if (isType) { newPar.ParamGuid = Guid.NewGuid(); // assign new GUID for [Type] parameter if not existing } if (toBeDeferred) { string parEntry = newPar.Param + "\t" + newPar.ParamGuid.ToString() + "\t" + parName + "\t" + newPar.ParamType + "\t" + newPar.DataCategory + "\t" + defaultGroupID.ToString() + "\t" + vis + "\t" + newPar.Description + "\t" + usrMod; deferredParList.Add(parEntry); } else { string parEntry = newPar.Param + "\t" + newPar.ParamGuid.ToString() + "\t" + parName + "\t" + newPar.ParamType + "\t" + newPar.DataCategory + "\t" + groupID.ToString() + "\t" + vis + "\t" + newPar.Description + "\t" + usrMod; stSharedPar.WriteLine(parEntry); } } // Add items in the existing parameter dict that are not found in SharedParamFileDict, into the deferred list var disjunctPars = existingParDict.Where(x => !SharedParDict.ContainsKey(x.Key)); foreach (KeyValuePair <string, SharedParameterDef> parDef in disjunctPars) { SharedParameterDef newPar = parDef.Value; string parName = newPar.Name; if (isType) { if (newPar.Name.EndsWith("[Type]")) { parName = newPar.Name; } else { parName = newPar.Name + "[Type]"; } } string vis = newPar.Visibility ? "1" : "0"; string usrMod = newPar.UserModifiable ? "1" : "0"; string parEntry = newPar.Param + "\t" + newPar.ParamGuid.ToString() + "\t" + parName + "\t" + newPar.ParamType + "\t" + newPar.DataCategory + "\t" + defaultGroupID.ToString() + "\t" + vis + "\t" + newPar.Description + "\t" + usrMod; deferredParList.Add(parEntry); } }
PsetDefinition Process(string schemaVersion, FileInfo PSDfileName) { PsetDefinition pset = new PsetDefinition(); XDocument doc = XDocument.Load(PSDfileName.FullName); // Older versions of psd uses namespace! var nsInfo = doc.Root.Attributes("xmlns").FirstOrDefault(); XNamespace ns = ""; if (nsInfo != null) { ns = nsInfo.Value; } pset.Name = doc.Elements(ns + "PropertySetDef").Elements(ns + "Name").FirstOrDefault().Value; pset.IfcVersion = doc.Elements(ns + "PropertySetDef").Elements(ns + "IfcVersion").FirstOrDefault().Attribute("version").Value.Replace(" ", ""); if (pset.IfcVersion.StartsWith("2")) { if (pset.IfcVersion.Equals("2X", StringComparison.CurrentCultureIgnoreCase)) { pset.IfcVersion = "IFC" + pset.IfcVersion.ToUpper() + "2"; // BUG in the documentation. It ony contains "2x" instead of "2x2" } else { pset.IfcVersion = "IFC" + pset.IfcVersion.ToUpper(); // Namespace cannot start with a number. e.g. make sure 2x3 -> IFC2x3 } } else if (pset.IfcVersion.StartsWith("IFC4")) { pset.IfcVersion = schemaVersion.ToUpper(); } if (doc.Element(ns + "PropertySetDef").Attribute("ifdguid") != null) { pset.IfdGuid = doc.Element(ns + "PropertySetDef").Attribute("ifdguid").Value; } // Get applicable classes IEnumerable <XElement> applicableClasses = from el in doc.Descendants(ns + "ClassName") select el; IList <string> applClassesList = new List <string>(); foreach (XElement applClass in applicableClasses) { string className = ProcessPsetDefinition.removeInvalidNName(applClass.Value); if (!string.IsNullOrEmpty(className)) { applClassesList.Add(className); } } pset.ApplicableClasses = applClassesList; XElement applType = doc.Elements(ns + "PropertySetDef").Elements(ns + "ApplicableTypeValue").FirstOrDefault(); if (applType != null) { string applicableType = applType.Value; if (!string.IsNullOrEmpty(applicableType) && !applicableType.Equals("N/A", StringComparison.InvariantCultureIgnoreCase)) { // Remove "SELF\" in the applicable type if (applicableType.Contains("SELF\\")) { applicableType = applicableType.Replace("SELF\\", ""); } string[] applTypeStr = applicableType.Split('/', '.', '='); pset.ApplicableType = applTypeStr[0]; if (applTypeStr.Count() > 1) { pset.PredefinedType = applTypeStr[applTypeStr.Count() - 1].Replace("\"", ""); } // If the applicable type contains more than 1 entry, add them into the applicable classes string[] addClasses = pset.ApplicableType.Split(','); if (addClasses.Count() > 1) { foreach (string addClass in addClasses) { string addClassTr = addClass.TrimStart().TrimEnd(); if (!pset.ApplicableClasses.Contains(addClassTr)) { pset.ApplicableClasses.Add(addClassTr); } } } } } IList <PsetProperty> propList = new List <PsetProperty>(); var pDefs = from p in doc.Descendants(ns + "PropertyDef") select p; foreach (XElement pDef in pDefs) { PsetProperty prop = getPropertyDef(ns, pDef); SharedParameterDef shPar = new SharedParameterDef(); if (prop == null) { #if DEBUG logF.WriteLine("%Error: Mising PropertyType data for {0}.{1}", pset.Name, pDef.Element(ns + "Name").Value); #endif } else { propList.Add(prop); } } pset.properties = propList; return(pset); }
public static string processExistingParFile(string parFileName, bool isType, ref StreamWriter destFile) { IDictionary <string, SharedParameterDef> dictToFill; if (isType) { dictToFill = SharedParamFileTypeDict; } else { dictToFill = SharedParamFileDict; } string messageText = null; // Keep original data (for maintaining the GUID) in a dictionary using (StreamReader stSharedParam = File.OpenText(parFileName)) { string line; while ((line = stSharedParam.ReadLine()) != null && !string.IsNullOrEmpty(line)) { // Copy content to the destination file //destFile.WriteLine(line); string[] token = line.Split('\t'); if (token == null || token.Count() == 0) { continue; } if (!token[0].Equals("PARAM")) { continue; } SharedParameterDef parDef = new SharedParameterDef(); parDef.Param = token[0]; try { parDef.ParamGuid = Guid.Parse(token[1]); } catch { // Shouldn't be here continue; } if (string.IsNullOrEmpty(token[2])) { // Shouldn't be here continue; } parDef.Name = token[2]; if (token[3] == null) { continue; } parDef.ParamType = token[3]; parDef.DataCategory = token[4]; int grp; if (int.TryParse(token[5], out grp)) { parDef.GroupId = grp; } else { continue; } parDef.Visibility = false; if (!string.IsNullOrEmpty(token[6])) { int vis; if (int.TryParse(token[6], out vis)) { if (vis == 1) { parDef.Visibility = true; } } } if (!string.IsNullOrEmpty(token[7])) { parDef.Description = token[7]; } parDef.UserModifiable = false; if (!string.IsNullOrEmpty(token[8])) { int mod; if (int.TryParse(token[8], out mod)) { if (mod == 1) { parDef.UserModifiable = true; } } } try { dictToFill.Add(parDef.Name, parDef); } catch (ArgumentException exp) { messageText += "\n" + parDef.Name + ": " + exp.Message; } } } return(messageText); }
public void processSimpleProperty(StreamWriter outF, PsetProperty prop, string propNamePrefix, string IfcVersion, string schemaVersion, string varName, VersionSpecificPropertyDef vSpecPDef, string outputFile) { outF.WriteLine("\t\t\t\tifcPSE = new PropertySetEntry(\"{0}\");", prop.Name); outF.WriteLine("\t\t\t\tifcPSE.PropertyName = \"{0}\";", prop.Name); if (prop.PropertyType != null) { if (prop.PropertyType is PropertyEnumeratedValue) { PropertyEnumeratedValue propEnum = prop.PropertyType as PropertyEnumeratedValue; outF.WriteLine("\t\t\t\tifcPSE.PropertyType = PropertyType.Label;"); outF.WriteLine("\t\t\t\tifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;"); outF.WriteLine("\t\t\t\tifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet." + IfcVersion + "." + propEnum.Name + ");"); IList <string> enumItems = new List <string>(); foreach (PropertyEnumItem enumItem in propEnum.EnumDef) { string item = HandleInvalidCharacter(enumItem.EnumItem); enumItems.Add(item); } writeEnumFile(IfcVersion, schemaVersion, propEnum.Name, enumItems, outputFile); } else if (prop.PropertyType is PropertyReferenceValue) { PropertyReferenceValue propRef = prop.PropertyType as PropertyReferenceValue; outF.WriteLine("\t\t\t\tifcPSE.PropertyType = PropertyType.{0};", propRef.RefEntity.Trim()); outF.WriteLine("\t\t\t\tifcPSE.PropertyValueType = PropertyValueType.ReferenceValue;"); } else if (prop.PropertyType is PropertyListValue) { PropertyListValue propList = prop.PropertyType as PropertyListValue; if (propList.DataType != null && !propList.DataType.Equals("IfcValue", StringComparison.InvariantCultureIgnoreCase)) { outF.WriteLine("\t\t\t\tifcPSE.PropertyType = PropertyType.{0};", propList.DataType.ToString().Replace("Ifc", "").Replace("Measure", "").Trim()); } else { outF.WriteLine("\t\t\t\tifcPSE.PropertyType = PropertyType.Label;"); // default to Label if not defined } outF.WriteLine("\t\t\t\tifcPSE.PropertyValueType = PropertyValueType.ListValue;"); } else if (prop.PropertyType is PropertyTableValue) { PropertyTableValue propTab = prop.PropertyType as PropertyTableValue; // TableValue has 2 types: DefiningValue and DefinedValue. This is not fully implemented yet if (propTab.DefinedValueType != null) { outF.WriteLine("\t\t\t\tifcPSE.PropertyType = PropertyType.{0};", propTab.DefinedValueType.ToString().Replace("Ifc", "").Replace("Measure", "").Trim()); } else { outF.WriteLine("\t\t\t\tifcPSE.PropertyType = PropertyType.Label;"); // default to Label if missing } outF.WriteLine("\t\t\t\tifcPSE.PropertyValueType = PropertyValueType.TableValue;"); } else { outF.WriteLine("\t\t\t\tifcPSE.PropertyType = PropertyType.{0};", prop.PropertyType.ToString().Replace("Ifc", "").Replace("Measure", "").Trim()); } } else { prop.PropertyType = new PropertySingleValue(); // Handle bad cases where datatype is somehow missing in the PSD if (prop.Name.ToLowerInvariant().Contains("ratio") || prop.Name.ToLowerInvariant().Contains("length") || prop.Name.ToLowerInvariant().Contains("width") || prop.Name.ToLowerInvariant().Contains("thickness") || prop.Name.ToLowerInvariant().Contains("angle") || prop.Name.ToLowerInvariant().Contains("transmittance") || prop.Name.ToLowerInvariant().Contains("fraction") || prop.Name.ToLowerInvariant().Contains("rate") || prop.Name.ToLowerInvariant().Contains("velocity") || prop.Name.ToLowerInvariant().Contains("speed") || prop.Name.ToLowerInvariant().Contains("capacity") || prop.Name.ToLowerInvariant().Contains("pressure") || prop.Name.ToLowerInvariant().Contains("temperature") || prop.Name.ToLowerInvariant().Contains("power") || prop.Name.ToLowerInvariant().Contains("heatgain") || prop.Name.ToLowerInvariant().Contains("efficiency") || prop.Name.ToLowerInvariant().Contains("resistance") || prop.Name.ToLowerInvariant().Contains("coefficient") || prop.Name.ToLowerInvariant().Contains("measure")) { (prop.PropertyType as PropertySingleValue).DataType = "IfcReal"; } else if (prop.Name.ToLowerInvariant().Contains("loadbearing")) { (prop.PropertyType as PropertySingleValue).DataType = "IfcBoolean"; } else { (prop.PropertyType as PropertySingleValue).DataType = "IfcLabel"; } #if DEBUG logF.WriteLine("%Warning: " + prop.Name + " from " + vSpecPDef.PropertySetDef.Name + "(" + vSpecPDef.SchemaFileVersion + ") is missing PropertyType/datatype. Set to default " + (prop.PropertyType as PropertySingleValue).DataType); #endif } // Append new definition to the Shared parameter file SharedParameterDef newPar = new SharedParameterDef(); newPar.Name = prop.Name; // Use IfdGuid for the GUID if defined Guid pGuid = Guid.Empty; bool hasIfdGuid = false; if (!string.IsNullOrEmpty(prop.IfdGuid)) { if (Guid.TryParse(prop.IfdGuid, out pGuid)) { hasIfdGuid = true; } } if (pGuid == Guid.Empty) { pGuid = Guid.NewGuid(); } newPar.ParamGuid = pGuid; if (prop.PropertyType != null) { newPar.Description = prop.PropertyType.ToString().Split(' ', '\t')[0].Trim(); // Put the original IFC datatype in the description } else { #if DEBUG logF.WriteLine("%Warning: " + prop.Name + " from " + vSpecPDef.PropertySetDef.Name + "(" + vSpecPDef.SchemaFileVersion + ") is missing PropertyType/datatype."); #endif } if (prop.PropertyType is PropertyEnumeratedValue) { newPar.ParamType = "TEXT"; // Support only a single enum value (which is most if not all cases known) } else if (prop.PropertyType is PropertyReferenceValue || prop.PropertyType is PropertyBoundedValue || prop.PropertyType is PropertyListValue || prop.PropertyType is PropertyTableValue) { // For all the non-simple value, a TEXT parameter will be created that will contain formatted string newPar.ParamType = "MULTILINETEXT"; if (prop.PropertyType is PropertyBoundedValue) { newPar.Description = "PropertyBoundedValue"; // override the default to the type of property datatype } else if (prop.PropertyType is PropertyListValue) { newPar.Description = "PropertyListValue"; // override the default to the type of property datatype } else if (prop.PropertyType is PropertyTableValue) { newPar.Description = "PropertyTableValue"; // override the default to the type of property datatype } } else if (prop.PropertyType is PropertySingleValue) { PropertySingleValue propSingle = prop.PropertyType as PropertySingleValue; newPar.Description = propSingle.DataType; // Put the original IFC datatype in the description if (propSingle.DataType.Equals("IfcPositivePlaneAngleMeasure", StringComparison.InvariantCultureIgnoreCase) || propSingle.DataType.Equals("IfcSolidAngleMeasure", StringComparison.InvariantCultureIgnoreCase)) { newPar.ParamType = "ANGLE"; } else if (propSingle.DataType.Equals("IfcAreaMeasure", StringComparison.InvariantCultureIgnoreCase)) { newPar.ParamType = "AREA"; } else if (propSingle.DataType.Equals("IfcMonetaryMeasure", StringComparison.InvariantCultureIgnoreCase)) { newPar.ParamType = "CURRENCY"; } else if (propSingle.DataType.Equals("IfcPositivePlaneAngleMeasure", StringComparison.InvariantCultureIgnoreCase) || propSingle.DataType.Equals("IfcCardinalPointReference", StringComparison.InvariantCultureIgnoreCase) || propSingle.DataType.Equals("IfcCountMeasure", StringComparison.InvariantCultureIgnoreCase) || propSingle.DataType.Equals("IfcDayInMonthNumber", StringComparison.InvariantCultureIgnoreCase) || propSingle.DataType.Equals("IfcDayInWeekNumber", StringComparison.InvariantCultureIgnoreCase) || propSingle.DataType.Equals("IfcDimensionCount", StringComparison.InvariantCultureIgnoreCase) || propSingle.DataType.Equals("IfcInteger", StringComparison.InvariantCultureIgnoreCase) || propSingle.DataType.Equals("IfcIntegerCountRateMeasure", StringComparison.InvariantCultureIgnoreCase) || propSingle.DataType.Equals("IfcMonthInYearNumber", StringComparison.InvariantCultureIgnoreCase) || propSingle.DataType.Equals("IfcTimeStamp", StringComparison.InvariantCultureIgnoreCase)) { newPar.ParamType = "INTEGER"; } else if (propSingle.DataType.Equals("IfcLengthMeasure", StringComparison.InvariantCultureIgnoreCase) || propSingle.DataType.Equals("IfcNonNegativeLengthMeasure", StringComparison.InvariantCultureIgnoreCase) || propSingle.DataType.Equals("IfcPositiveLengthMeasure", StringComparison.InvariantCultureIgnoreCase)) { newPar.ParamType = "LENGTH"; } else if (propSingle.DataType.Equals("IfcMassDensityMeasure", StringComparison.InvariantCultureIgnoreCase)) { newPar.ParamType = "MASS_DENSITY"; } else if (propSingle.DataType.Equals("IfcArcIndex", StringComparison.InvariantCultureIgnoreCase) || propSingle.DataType.Equals("IfcComplexNumber", StringComparison.InvariantCultureIgnoreCase) || propSingle.DataType.Equals("IfcCompoundPlaneAngleMeasure", StringComparison.InvariantCultureIgnoreCase) || propSingle.DataType.Equals("IfcLineIndex", StringComparison.InvariantCultureIgnoreCase) || propSingle.DataType.Equals("IfcPropertySetDefinitionSet", StringComparison.InvariantCultureIgnoreCase)) { newPar.ParamType = "MULTILINETEXT"; } else if (propSingle.DataType.Equals("IfcBinary", StringComparison.InvariantCultureIgnoreCase) || propSingle.DataType.Equals("IfcBoxAlignment", StringComparison.InvariantCultureIgnoreCase) || propSingle.DataType.Equals("IfcDate", StringComparison.InvariantCultureIgnoreCase) || propSingle.DataType.Equals("IfcDateTime", StringComparison.InvariantCultureIgnoreCase) || propSingle.DataType.Equals("IfcDescriptiveMeasure", StringComparison.InvariantCultureIgnoreCase) || propSingle.DataType.Equals("IfcDuration", StringComparison.InvariantCultureIgnoreCase) || propSingle.DataType.Equals("IfcFontStyle", StringComparison.InvariantCultureIgnoreCase) || propSingle.DataType.Equals("IfcFontVariant", StringComparison.InvariantCultureIgnoreCase) || propSingle.DataType.Equals("IfcFontWeight", StringComparison.InvariantCultureIgnoreCase) || propSingle.DataType.Equals("IfcGloballyUniqueId", StringComparison.InvariantCultureIgnoreCase) || propSingle.DataType.Equals("IfcIdentifier", StringComparison.InvariantCultureIgnoreCase) || propSingle.DataType.Equals("IfcLabel", StringComparison.InvariantCultureIgnoreCase) || propSingle.DataType.Equals("IfcLanguageId", StringComparison.InvariantCultureIgnoreCase) || propSingle.DataType.Equals("IfcPresentableText", StringComparison.InvariantCultureIgnoreCase) || propSingle.DataType.Equals("IfcText", StringComparison.InvariantCultureIgnoreCase) || propSingle.DataType.Equals("IfcTextAlignment", StringComparison.InvariantCultureIgnoreCase) || propSingle.DataType.Equals("IfcTextDecoration", StringComparison.InvariantCultureIgnoreCase) || propSingle.DataType.Equals("IfcTextFontName", StringComparison.InvariantCultureIgnoreCase) || propSingle.DataType.Equals("IfcTextTransformation", StringComparison.InvariantCultureIgnoreCase) || propSingle.DataType.Equals("IfcTime", StringComparison.InvariantCultureIgnoreCase)) { newPar.ParamType = "TEXT"; } else if (propSingle.DataType.Equals("IfcURIReference", StringComparison.InvariantCultureIgnoreCase)) { newPar.ParamType = "URL"; } else if (propSingle.DataType.Equals("IfcVolumeMeasure", StringComparison.InvariantCultureIgnoreCase)) { newPar.ParamType = "VOLUME"; } else if (propSingle.DataType.Equals("IfcBoolean", StringComparison.InvariantCultureIgnoreCase) || propSingle.DataType.Equals("IfcLogical", StringComparison.InvariantCultureIgnoreCase)) { newPar.ParamType = "YESNO"; } else { newPar.ParamType = "NUMBER"; } } if (!SharedParamFileDict.ContainsKey(newPar.Name)) { SharedParamFileDict.Add(newPar.Name, newPar); } else // Keep the GUID, but override the details { // If this Property has IfcGuid, use the IfdGuid set in the newPar, otherwise keep the original one if (!hasIfdGuid) { newPar.ParamGuid = SharedParamFileDict[newPar.Name].ParamGuid; } SharedParamFileDict[newPar.Name] = newPar; // override the Dict } SharedParameterDef newParType = (SharedParameterDef)newPar.Clone(); newParType.Name = newParType.Name + "[Type]"; if (!SharedParamFileTypeDict.ContainsKey(newParType.Name)) { SharedParamFileTypeDict.Add(newParType.Name, newParType); } else // Keep the GUID, but override the details { newParType.ParamGuid = SharedParamFileTypeDict[newParType.Name].ParamGuid; SharedParamFileTypeDict[newParType.Name] = newParType; // override the Dict } if (prop.NameAliases != null) { foreach (NameAlias alias in prop.NameAliases) { LanguageType lang = checkAliasLanguage(alias.lang); outF.WriteLine("\t\t\t\tifcPSE.AddLocalizedParameterName(LanguageType.{0}, \"{1}\");", lang, alias.Alias); } } string calcName = "Revit.IFC.Export.Exporter.PropertySet.Calculators." + prop.Name + "Calculator"; outF.WriteLine("\t\t\t\tcalcType = System.Reflection.Assembly.GetExecutingAssembly().GetType(\"" + calcName + "\");"); outF.WriteLine("\t\t\t\tif (calcType != null)"); outF.WriteLine("\t\t\t\t\tifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});"); outF.WriteLine("\t\t\t\t{0}.AddEntry(ifcPSE);", varName); outF.WriteLine(""); }