/// <summary> /// Helper to get shared params definition. /// </summary> public static Definition GetOrCreateSharedParamsDefinition( DefinitionGroup defGroup, ParameterType defType, string defName, bool visible) { Definition definition = defGroup.Definitions.get_Item( defName); if (null == definition) { try { //definition = defGroup.Definitions.Create( defName, defType, visible ); // 2014 ExternalDefinitionCreationOptions opt = new ExternalDefinitionCreationOptions( defName, defType); // 2015 opt.Visible = visible; definition = defGroup.Definitions.Create(opt); // 2015 } catch (Exception) { definition = null; } } return(definition); }
// 定義參數與綁定類型的Function private bool setNewParameterToTypeWall(UIApplication app, DefinitionFile myDefinitionFile) { // 共用參數文檔中包含了Group,代表參數所屬的群組, // 而Group內又包含了Definition,也就是你想增加的參數, // 欲新增Definition首先必須新增一個Group DefinitionGroups myGroups = myDefinitionFile.Groups; DefinitionGroup myGroup = myGroups.Create("參數群組"); // 創建Definition的定義以及其儲存類型 ExternalDefinitionCreationOptions options = new ExternalDefinitionCreationOptions("聯絡人", ParameterType.Text); Definition myDefinition = myGroup.Definitions.Create(options); // 創建品類集並插入牆品類到裡面 CategorySet myCategories = app.Application.Create.NewCategorySet(); // 使用BuiltInCategory來取得牆品類 Category myCategory = app.ActiveUIDocument.Document.Settings.Categories.get_Item(BuiltInCategory.OST_Walls); myCategories.Insert(myCategory); // 根據品類創建類型綁定的物件 TypeBinding typeBinding = app.Application.Create.NewTypeBinding(myCategories); // 取得當前文件中所有的類型綁定 BindingMap bindingMap = app.ActiveUIDocument.Document.ParameterBindings; // 將客製化的參數定義綁定到文件中 bool typeBindOK = bindingMap.Insert(myDefinition, typeBinding, BuiltInParameterGroup.PG_TEXT); return(typeBindOK); }
/// <summary> ///This method is provided by the official website, here is the link ///https://www.revitapidocs.com/2019/f5066ef5-fa12-4cd2-ad0c-ca72ab21e479.htm /// </summary> /// <param name="app"></param> /// <param name="myDefinitionFile"></param> /// <returns></returns> public bool SetNewParameterToTypeWall(UIApplication app, DefinitionFile myDefinitionFile) { // Create a new group in the shared parameters file DefinitionGroups myGroups = myDefinitionFile.Groups; DefinitionGroup myGroup = myGroups.Create("Revit API Course"); // Create a type definition ExternalDefinitionCreationOptions option = new ExternalDefinitionCreationOptions("Note", ParameterType.Text); Definition myDefinition_CompanyName = myGroup.Definitions.Create(option); // Create a category set and insert category of wall to it CategorySet myCategories = app.Application.Create.NewCategorySet(); // Use BuiltInCategory to get category of wall Category myCategory = Category.GetCategory(app.ActiveUIDocument.Document, BuiltInCategory.OST_Walls); myCategories.Insert(myCategory);//add wall into the group. Of course, you can add multiple categories //Create an object of InstanceBinding according to the Categories, //The next line: I also provide the TypeBinding example here, but hide the code by comments //TypeBinding typeBinding = app.Application.Create.NewTypeBinding(myCategories); InstanceBinding instanceBinding = app.Application.Create.NewInstanceBinding(myCategories); // Get the BingdingMap of current document. BindingMap bindingMap = app.ActiveUIDocument.Document.ParameterBindings; //Bind the definitions to the document bool typeBindOK = bindingMap.Insert(myDefinition_CompanyName, instanceBinding, BuiltInParameterGroup.PG_TEXT); //The next two lines: I also provide the TypeBinding example here, but hide the code by comments //bool typeBindOK=bindingMap.Insert(myDefinition_CompanyName, typeBinding, //BuiltInParameterGroup.PG_TEXT); return(typeBindOK); }
public static Definition sharedParameterYarat(RevitApplication app, string name, string group, ParameterType type, bool visible, Guid myGuid) { DefinitionFile defFile = myApp.OpenSharedParameterFile(); if (defFile == null) { throw new Exception("No SharedParameter File!"); } DefinitionGroup dg = RawConvertSetToList <DefinitionGroup>(defFile.Groups).FirstOrDefault(g => g.Name == group); if (dg == null) { dg = defFile.Groups.Create(group); } Definition def = RawConvertSetToList <Definition>(dg.Definitions).FirstOrDefault(d => d.Name == name); if (def != null) { return(def); } //Guid myGuid = new Guid("A0AD7058-9A98-47AC-89B1-0E1CBD5FCDCB"); ExternalDefinitionCreationOptions edco = new ExternalDefinitionCreationOptions(name, type); edco.GUID = myGuid; edco.Visible = true; def = dg.Definitions.Create(edco); return(def); }
public void AddParameterToGroup(string parameterName) { // add our parameter to the group ExternalDefinitionCreationOptions option = new ExternalDefinitionCreationOptions(parameterName, ParameterType.Text); Definition def = SharedParameterDefinitionGroup.Definitions.Create(option); }
private void addParameterToAreas() { try { CategorySet set = new CategorySet(); Category area = CurrentDoc.Settings.Categories.get_Item(BuiltInCategory.OST_Areas); set.Insert(area); var binding = CurrentDoc.Application.Create.NewInstanceBinding(set); if (String.IsNullOrEmpty(CurrentDoc.Application.SharedParametersFilename) || (System.IO.File.Exists(CurrentDoc.Application.SharedParametersFilename) == false)) { // make our own file. string file = System.IO.Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments), "RevitSharedParameters.txt"); CurrentDoc.Application.SharedParametersFilename = file; System.IO.File.WriteAllText(file, ""); } DefinitionFile defFile = CurrentDoc.Application.OpenSharedParameterFile(); var group = defFile.Groups.get_Item("AreaRoomTypes"); if (group == null) { group = defFile.Groups.Create("AreaRoomTypes"); } ExternalDefinitionCreationOptions opts = new ExternalDefinitionCreationOptions(TypeParam, ParameterType.Text); Definition def = group.Definitions.Create(opts); CurrentDoc.ParameterBindings.Insert(def, binding); } catch (Exception ex) { log("Tried to add the " + TypeParam + " parameter to Areas, but failed! " + ex.GetType().Name + ": " + ex.Message); } }
} //end fun //這個方法也是被公開在官網上的,我只是小小修改並且翻譯了註解,參考以下網址 //http://www.revitapidocs.com/2017/f5066ef5-fa12-4cd2-ad0c-ca72ab21e479.htm private void AddNewParametersToCategories(UIApplication app, DefinitionFile myDefinitionFile, BuiltInCategory category, List <string> newParameters) { //在共用參數檔案當中先建立一個新的參數群組 DefinitionGroups myGroups = myDefinitionFile.Groups; DefinitionGroup myGroup = myGroups.Create("使用者定義參數群組"); // 創立參數定義,含參數名稱及參數型別 foreach (string paraName in newParameters) { ExternalDefinitionCreationOptions option = new ExternalDefinitionCreationOptions(paraName, ParameterType.Text); Definition myDefinition = myGroup.Definitions.Create(option); // 創建一個類別群組,將來在這個類別群組裡的所有類別都會被新增指定的參數 CategorySet myCategories = app.Application.Create.NewCategorySet(); // 創建一個類別.以牆為例 Category myCategory = Category.GetCategory(app.ActiveUIDocument.Document, category); myCategories.Insert(myCategory);//把牆類別插入類別群組,當然你可以插入不只一個類別 //以下兩者是亮點,「類別綁定」與「實體綁定」的結果不同,以本例而言我們需要的其實是實體綁定 //TypeBinding typeBinding = app.Application.Create.NewTypeBinding(myCategories); InstanceBinding instanceBinding = app.Application.Create.NewInstanceBinding(myCategories); //取得一個叫作BingdingMap的物件,以進行後續新增參數 BindingMap bindingMap = app.ActiveUIDocument.Document.ParameterBindings; // 最後將新增參數加到群組上頭,並且指定了instanceBiding的方法(也可替換為typeBinding) bool typeBindOK = bindingMap.Insert(myDefinition, instanceBinding, BuiltInParameterGroup.PG_TEXT); } }
public static Definition GetOrCreateSharedParamsDefinition( DefinitionGroup defGroup, ForgeTypeId forgeTypeId, string defName, bool visible) { Definition definition = defGroup.Definitions.get_Item(defName); if (null == definition) { try { //definition = defGroup.Definitions.Create(defName, defType, visible); // 'Autodesk.Revit.DB.Definitions.Create(string, Autodesk.Revit.DB.ParameterType, bool)' is obsolete: // 'This method is deprecated in Revit 2015. Use Create(Autodesk.Revit.DB.ExternalDefinitonCreationOptions) instead' // Modified code for Revit 2015 // and fixed typo in class name in Revit 2016 ExternalDefinitionCreationOptions opt = new ExternalDefinitionCreationOptions( defName, forgeTypeId); opt.Visible = true; definition = defGroup.Definitions.Create(opt); } catch (Exception) { definition = null; } } return(definition); }
/// <summary> /// Helper to get shared params definition. /// </summary> public static Definition GetOrCreateSharedParamsDefinition( DefinitionGroup defGroup, ParameterType defType, string defName, string tooltip, bool visible) { Definition definition = defGroup.Definitions.get_Item( defName); if (null == definition) { try { //definition = defGroup.Definitions.Create( defName, defType, visible ); // 2014 ExternalDefinitionCreationOptions opt = new ExternalDefinitionCreationOptions( defName, defType); // 2015 opt.Visible = visible; opt.Description = tooltip; definition = defGroup.Definitions.Create(opt); // 2015 } catch (Exception) { TaskDialog.Show("Parameter exists.", "Parameter already exist. No action taken."); definition = null; } } return(definition); }
public Definition Create(string group, ExternalDefinitionCreationOptions externalDefinitionCreationOptions) { if (definitionFile == null) { return(null); } DefinitionGroup definitionGroup = null; foreach (DefinitionGroup definitionGroup_Temp in definitionFile.Groups) { if (definitionGroup_Temp.Name == group) { definitionGroup = definitionGroup_Temp; break; } } if (definitionGroup == null) { definitionGroup = definitionFile.Groups.Create(group); } Definition definition = definitionGroup.Definitions.Create(externalDefinitionCreationOptions); return(definition); }
public static void ExportParameters(Document doc, string path) { DefinitionFile existingDefFile = doc.Application.OpenSharedParameterFile(); // doc.Application.SharedParametersFilename = path; DefinitionFile tempDefFile = doc.Application.OpenSharedParameterFile(); // Manager the Exported group DefinitionGroup exported = null; var query = from dg in tempDefFile.Groups where dg.Name.Equals(doc.PathName + "-Exported") select dg; if (query.Count() == 0) { exported = tempDefFile.Groups.Create(doc.PathName + "-Exported"); } else { exported = query.First(); } // Iterate over the shared parameters in the document BindingMap bindingMap = doc.ParameterBindings; DefinitionBindingMapIterator it = bindingMap.ForwardIterator(); it.Reset(); while (it.MoveNext()) { InternalDefinition definition = it.Key as InternalDefinition; Autodesk.Revit.DB.Binding currBinding = bindingMap.get_Item(definition); // Corroborate that the current parameter has not been exported previously Definition existingDef = exported.Definitions .Where(d => (d.Name.Equals(definition.Name))).FirstOrDefault(); if (existingDef != null) { continue; } // unearth and assign the parameter's GUID SharedParameterElement sharedParamElem = doc.GetElement(definition.Id) as SharedParameterElement; if (sharedParamElem == null) { continue; } ExternalDefinitionCreationOptions options = new ExternalDefinitionCreationOptions(definition.Name, definition.ParameterType); options.GUID = sharedParamElem.GuidValue; Definition createdDefinition = exported.Definitions.Create(options); } }
/// <summary> /// Gets definition by sharing parameter file path. /// </summary> /// <param name="group"></param> /// <param name="paramName"></param> /// <param name="canEdit"></param> /// <returns></returns> public static Definition GetDefinition(this DefinitionGroup group, string paramName, bool canEdit = false) { if (group == null) { throw new ArgumentNullException(nameof(group)); } if (paramName == null) { throw new ArgumentNullException(nameof(paramName)); } var definition = group.Definitions.get_Item(paramName); if (definition != null) { return(definition); } var opt = new ExternalDefinitionCreationOptions(paramName, ParameterType.Text) { UserModifiable = canEdit }; return(group.Definitions.Create(opt)); }
/// <summary> /// Create a project parameter /// </summary> /// <param name="app"></param> /// <param name="name"></param> /// <param name="type"></param> /// <param name="visible"></param> /// <param name="cats"></param> /// <param name="group"></param> /// <param name="inst"></param> public static void RawCreateProjectParameter(Autodesk.Revit.ApplicationServices.Application app, string name, ParameterType type, bool visible, CategorySet cats, BuiltInParameterGroup group, bool inst) { string oriFile = app.SharedParametersFilename; string tempFile = Path.GetTempFileName() + ".txt"; using (File.Create(tempFile)) { } app.SharedParametersFilename = tempFile; ExternalDefinitionCreationOptions externalDefinitionCreationOptions = new ExternalDefinitionCreationOptions(name, type); ExternalDefinition def = app.OpenSharedParameterFile().Groups.Create("TemporaryDefintionGroup").Definitions.Create(externalDefinitionCreationOptions) as ExternalDefinition; app.SharedParametersFilename = oriFile; File.Delete(tempFile); Autodesk.Revit.DB.Binding binding = app.Create.NewTypeBinding(cats); if (inst) { binding = app.Create.NewInstanceBinding(cats); } BindingMap map = (new UIApplication(app)).ActiveUIDocument.Document.ParameterBindings; map.Insert(def, binding, group); }
public static ExternalDefinitionCreationOptions CreateOptions(this Param param) { ExternalDefinitionCreationOptions options = new ExternalDefinitionCreationOptions(param.Name, ParameterType.Text); switch (param.Type) { default: case ParamType.Text: options.Type = ParameterType.Text; break; case ParamType.Length: options.Type = ParameterType.Length; break; case ParamType.Bool: options.Type = ParameterType.YesNo; break; case ParamType.Int: options.Type = ParameterType.Integer; break; case ParamType.Material: options.Type = ParameterType.Material; break; case ParamType.Area: options.Type = ParameterType.Area; break; } options.GUID = param.Guid; options.UserModifiable = param.UserModifiable; return(options); }
//這個方法也是被公開在官網上的,我只是小小修改並且翻譯了註解,參考以下網址 //http://www.revitapidocs.com/2017/f5066ef5-fa12-4cd2-ad0c-ca72ab21e479.htm public bool SetNewParameterToTypeWall(UIApplication app, DefinitionFile myDefinitionFile) { //在共用參數檔案當中先建立一個新的參數群組 DefinitionGroups myGroups = myDefinitionFile.Groups; DefinitionGroup myGroup = myGroups.Create("新參數群組"); // 創立參數定義,含參數名稱及參數型別 ExternalDefinitionCreationOptions option = new ExternalDefinitionCreationOptions("牆上塗鴉", ParameterType.Text); Definition myDefinition_CompanyName = myGroup.Definitions.Create(option); // 創建一個類別群組,將來在這個類別群組裡的所有類別都會被新增指定的參數 CategorySet myCategories = app.Application.Create.NewCategorySet(); // 創建一個類別.以牆為例 Category myCategory = Category.GetCategory(app.ActiveUIDocument.Document, BuiltInCategory.OST_Walls); myCategories.Insert(myCategory);//把牆類別插入類別群組,當然你可以插入不只一個類別 //以下兩者是亮點,「類別綁定」與「實體綁定」的結果不同,以本例而言我們需要的其實是實體綁定 //TypeBinding typeBinding = app.Application.Create.NewTypeBinding(myCategories); InstanceBinding instanceBinding = app.Application.Create.NewInstanceBinding(myCategories); //取得一個叫作BingdingMap的物件,以進行後續新增參數 BindingMap bindingMap = app.ActiveUIDocument.Document.ParameterBindings; // 最後將新增參數加到群組上頭,並且指定了instanceBiding的方法(也可替換為typeBinding) bool typeBindOK = bindingMap.Insert(myDefinition_CompanyName, instanceBinding, BuiltInParameterGroup.PG_TEXT); //bool typeBindOK=bindingMap.Insert(myDefinition_CompanyName, typeBinding, //BuiltInParameterGroup.PG_TEXT); return(typeBindOK); }
void ProblemAddingParameterBindingForCategory( Document doc) { Application app = doc.Application; if (null == _spellingErrorCorrector) { _spellingErrorCorrector = new Util.SpellingErrorCorrector(app); } DefinitionFile sharedParametersFile = app.OpenSharedParameterFile(); DefinitionGroup group = sharedParametersFile .Groups.Create("Reinforcement"); //Definition def = group.Definitions.Create( // 2014 // "ReinforcementParameter", ParameterType.Text ); ExternalDefinitionCreationOptions opt = new ExternalDefinitionCreationOptions( "ReinforcementParameter", ParameterType.Text); Definition def = group.Definitions.Create(opt); // 2015 // To handle both ExternalDefinitonCreationOptions // and ExternalDefinitionCreationOptions: def = _spellingErrorCorrector.NewDefinition( group.Definitions, "ReinforcementParameter", ParameterType.Text); List <BuiltInCategory> bics = new List <BuiltInCategory>(); //bics.Add(BuiltInCategory.OST_AreaRein); //bics.Add(BuiltInCategory.OST_FabricAreas); //bics.Add(BuiltInCategory.OST_FabricReinforcement); //bics.Add(BuiltInCategory.OST_PathRein); //bics.Add(BuiltInCategory.OST_Rebar); bics.Add(BuiltInCategory .OST_IOSRebarSystemSpanSymbolCtrl); CategorySet catset = new CategorySet(); foreach (BuiltInCategory bic in bics) { catset.Insert( doc.Settings.Categories.get_Item(bic)); } InstanceBinding binding = app.Create.NewInstanceBinding(catset); doc.ParameterBindings.Insert(def, binding, BuiltInParameterGroup.PG_CONSTRUCTION); }
public ExternalDefinitionCreationOptions GetCreationOptions() { ExternalDefinitionCreationOptions options = new ExternalDefinitionCreationOptions(Name, Type); options.UserModifiable = UserModifiable; options.Description = Description; return(options); }
/// <summary> /// Create shared parameter for Rooms category /// </summary> /// <returns>True, shared parameter exists; false, doesn't exist</returns> private bool CreateMyRoomSharedParameter() { // Create Room Shared Parameter Routine: --> // 1: Check whether the Room shared parameter("External Room ID") has been defined. // 2: Share parameter file locates under sample directory of this .dll module. // 3: Add a group named "SDKSampleRoomScheduleGroup". // 4: Add a shared parameter named "External Room ID" to "Rooms" category, which is visible. // The "External Room ID" parameter will be used to map to spreadsheet based room ID(which is unique) try { // check whether shared parameter exists if (ShareParameterExists(RoomsData.SharedParam)) { return(true); } // create shared parameter file String modulePath = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location); String paramFile = modulePath + "\\RoomScheduleSharedParameters.txt"; if (File.Exists(paramFile)) { File.Delete(paramFile); } FileStream fs = File.Create(paramFile); fs.Close(); // cache application handle Autodesk.Revit.ApplicationServices.Application revitApp = m_commandData.Application.Application; // prepare shared parameter file m_commandData.Application.Application.SharedParametersFilename = paramFile; // open shared parameter file DefinitionFile parafile = revitApp.OpenSharedParameterFile(); // create a group DefinitionGroup apiGroup = parafile.Groups.Create("SDKSampleRoomScheduleGroup"); // create a visible "External Room ID" of text type. ExternalDefinitionCreationOptions ExternalDefinitionCreationOptions = new ExternalDefinitionCreationOptions(RoomsData.SharedParam, ParameterType.Text); Definition roomSharedParamDef = apiGroup.Definitions.Create(ExternalDefinitionCreationOptions); // get Rooms category Category roomCat = m_commandData.Application.ActiveUIDocument.Document.Settings.Categories.get_Item(BuiltInCategory.OST_Rooms); CategorySet categories = revitApp.Create.NewCategorySet(); categories.Insert(roomCat); // insert the new parameter InstanceBinding binding = revitApp.Create.NewInstanceBinding(categories); m_commandData.Application.ActiveUIDocument.Document.ParameterBindings.Insert(roomSharedParamDef, binding); return(false); } catch (Exception ex) { throw new Exception("Failed to create shared parameter: " + ex.Message); } }
public Definition RegisterParameter(Application application, ISharedParameter parameter) { if (application == null) { throw new ArgumentNullException(nameof(application)); } if (parameter == null) { throw new ArgumentNullException(nameof(parameter)); } Definition result; //TODO: Move to config file string path = Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData) + "\\JPP Consulting\\Cedar\\SharedParameters.txt"; string directory = Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData) + "\\JPP Consulting\\Cedar"; if (!File.Exists(path)) { Directory.CreateDirectory(directory); FileStream fs = File.Create(path); fs.Close(); } string currentPath = application.SharedParametersFilename; application.SharedParametersFilename = path; //Why does disposing the file throw an invalid exception?!?!?!?!?!? /*using (DefinitionFile defFile = _application.OpenSharedParameterFile()) * {*/ DefinitionFile defFile = application.OpenSharedParameterFile(); DefinitionGroup pilingGroup = defFile.Groups.get_Item(parameter.GroupName); if (pilingGroup == null) { pilingGroup = defFile.Groups.Create(parameter.GroupName); } result = pilingGroup.Definitions.get_Item(parameter.Name); if (result == null) { ExternalDefinitionCreationOptions newDefinition = new ExternalDefinitionCreationOptions(parameter.Name, parameter.Type); newDefinition.UserModifiable = parameter.Editable; newDefinition.Description = parameter.Description; newDefinition.GUID = parameter.Id; result = pilingGroup.Definitions.Create(newDefinition); } application.SharedParametersFilename = currentPath; return(result); //} }
private Definition CreateDefinition(DefinitionGroup defGroup, ExternalDefinitionCreationOptions options) { Definition definition = defGroup.Definitions.FirstOrDefault(d => d.Name == options.Name); if (definition == null) { definition = defGroup.Definitions.Create(options); } return(definition); }
public void AddParameterToSPF(DefinitionGroup defG, string name, ParameterType type, bool visible) { ExternalDefinitionCreationOptions opt = new ExternalDefinitionCreationOptions(name, type) { Visible = visible }; defG.Definitions.Create(opt); //Add parameter name to list ParametersAdded.Add(name); }
private bool AddSharedTestParameter(ExternalCommandData commandData, string paramName, ParameterType paramType, bool userModifiable) { try { // check whether shared parameter exists if (ShareParameterExists(commandData.Application.ActiveUIDocument.Document, paramName)) { return(true); } // create shared parameter file String modulePath = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location); String paramFile = modulePath + "\\RebarTestParameters.txt"; if (File.Exists(paramFile)) { File.Delete(paramFile); } FileStream fs = File.Create(paramFile); fs.Close(); // cache application handle Autodesk.Revit.ApplicationServices.Application revitApp = commandData.Application.Application; // prepare shared parameter file commandData.Application.Application.SharedParametersFilename = paramFile; // open shared parameter file DefinitionFile parafile = revitApp.OpenSharedParameterFile(); // create a group DefinitionGroup apiGroup = parafile.Groups.Create("RebarTestParamGroup"); // create a visible param ExternalDefinitionCreationOptions ExtDefinitionCreationOptions = new ExternalDefinitionCreationOptions(paramName, paramType); ExtDefinitionCreationOptions.HideWhenNoValue = true; //used this to show the parameter only in some rebar instances that will use it ExtDefinitionCreationOptions.UserModifiable = userModifiable; // set if users need to modify this Definition rebarSharedParamDef = apiGroup.Definitions.Create(ExtDefinitionCreationOptions); // get rebar category Category rebarCat = commandData.Application.ActiveUIDocument.Document.Settings.Categories.get_Item(BuiltInCategory.OST_Rebar); CategorySet categories = revitApp.Create.NewCategorySet(); categories.Insert(rebarCat); // insert the new parameter InstanceBinding binding = revitApp.Create.NewInstanceBinding(categories); commandData.Application.ActiveUIDocument.Document.ParameterBindings.Insert(rebarSharedParamDef, binding); return(true); } catch (Exception ex) { throw new Exception("Failed to create shared parameter: " + ex.Message); } }
private void bttnCreate_Click(object sender, EventArgs e) { Definition definition = null; using (Transaction trans = new Transaction(m_doc)) { trans.Start("Create Shared Parameter"); try { defDictionary.Clear(); DefinitionGroups dGroups = definitionFile.Groups; DefinitionGroup dGroup = dGroups.get_Item("HOK Mass Parameters"); if (null == dGroup) { dGroup = dGroups.Create("HOK Mass Parameters"); } Definitions definitions = dGroup.Definitions; foreach (ListViewItem item in listViewMassParameter.Items) { definition = definitions.get_Item("Mass_" + item.Text); Parameter parameter = item.Tag as Parameter; if (null == definition && null != parameter) { ParameterType paramType = parameter.Definition.ParameterType; #if RELEASE2013 || RELEASE2014 definition = definitions.Create("Mass_" + parameter.Definition.Name, paramType); #elif RELEASE2015 ExternalDefinitonCreationOptions options = new ExternalDefinitonCreationOptions("Mass_" + parameter.Definition.Name, paramType); definition = definitions.Create(options); #elif RELEASE2016 ExternalDefinitionCreationOptions options = new ExternalDefinitionCreationOptions("Mass_" + parameter.Definition.Name, paramType); definition = definitions.Create(options); #endif } if (!defDictionary.ContainsKey(parameter.Definition.Name)) { defDictionary.Add(parameter.Definition.Name, definition); } } trans.Commit(); this.DialogResult = DialogResult.OK; } catch (Exception ex) { MessageBox.Show("Failed to set shared parameters.\n" + ex.Message, "Form_Parameters:CreateButtonClick", MessageBoxButtons.OK, MessageBoxIcon.Warning); trans.RollBack(); } } }
public void CreateStreetParameters(Document doc) { // Categories CategorySet catSet = new CategorySet(); Category cat = Category.GetCategory(doc, BuiltInCategory.OST_Roads); catSet.Insert(cat); Binding binding = new InstanceBinding(catSet); var app = doc.Application; app.SharedParametersFilename = ParamFile; DefinitionFile defFile = app.OpenSharedParameterFile(); DefinitionGroup defGroup = defFile.Groups.FirstOrDefault(d => d.Name == defGroupName); if (defGroup == null) { defGroup = defFile.Groups.Create(defGroupName); } var options = new ExternalDefinitionCreationOptions(nameParamName, ParameterType.Text); options.GUID = new Guid(NameParamGUID); options.Description = nameParamDescription; CreateParam(doc, binding, defGroup, options); options = new ExternalDefinitionCreationOptions(streetUsageParamName, ParameterType.Text); options.GUID = new Guid(StreetUsageParamGUID); options.Description = streetUsageDescription; CreateParam(doc, binding, defGroup, options); options = new ExternalDefinitionCreationOptions(streetTypeParamName, ParameterType.Text); options.GUID = new Guid(StreetTypeParamGUID); options.Description = streetTypeDescription; CreateParam(doc, binding, defGroup, options); options = new ExternalDefinitionCreationOptions(streetLanesParam, ParameterType.Integer); options.GUID = new Guid(StreetLanesParamGUID); options.Description = streetLanesDescription; CreateParam(doc, binding, defGroup, options); options = new ExternalDefinitionCreationOptions(streetMaxSpeedParam, ParameterType.Integer); options.GUID = new Guid(StreetMaxSpeedParamGUID); options.Description = streetMaxSpeedDescription; CreateParam(doc, binding, defGroup, options); options = new ExternalDefinitionCreationOptions(streetSurfaceParam, ParameterType.Text); options.GUID = new Guid(StreetSurfaceParamGUID); options.Description = streetSurfaceParamDescription; CreateParam(doc, binding, defGroup, options); }
/// <summary> /// Add a new parameter, "Unique ID", to the beams and slabs /// The following process should be followed: /// Open the shared parameters file, via the Document.OpenSharedParameterFile method. /// Access an existing group or create a new group, via the DefinitionFile.Groups property. /// Access an existing or create a new external parameter definition, /// via the DefinitionGroup.Definitions property. /// Create a new Binding with the categories to which the parameter will be bound /// using an InstanceBinding or a TypeBinding. /// Finally add the binding and definition to the document /// using the Document.ParameterBindings object. /// </summary> /// <returns>bool type, a value that signifies if add parameter was successful</returns> public bool SetNewParameterToBeamsAndSlabs() { //Open the shared parameters file // via the private method AccessOrCreateExternalSharedParameterFile DefinitionFile informationFile = AccessOrCreateExternalSharedParameterFile(); if (null == informationFile) { return(false); } // Access an existing or create a new group in the shared parameters file DefinitionGroups informationCollections = informationFile.Groups; DefinitionGroup informationCollection = null; informationCollection = informationCollections.get_Item("MyParameters"); if (null == informationCollection) { informationCollections.Create("MyParameters"); informationCollection = informationCollections.get_Item("MyParameters"); } // Access an existing or create a new external parameter definition // belongs to a specific group Definition information = informationCollection.Definitions.get_Item("Unique ID"); if (null == information) { ExternalDefinitionCreationOptions ExternalDefinitionCreationOptions = new ExternalDefinitionCreationOptions("Unique ID", Autodesk.Revit.DB.SpecTypeId.String.Text); informationCollection.Definitions.Create(ExternalDefinitionCreationOptions); information = informationCollection.Definitions.get_Item("Unique ID"); } // Create a new Binding object with the categories to which the parameter will be bound CategorySet categories = m_revit.Application.Create.NewCategorySet(); Category structuralFramingCategorie = null; Category floorsClassification = null; // use category in instead of the string name to get category structuralFramingCategorie = m_revit.ActiveUIDocument.Document.Settings.Categories.get_Item(BuiltInCategory.OST_StructuralFraming); floorsClassification = m_revit.ActiveUIDocument.Document.Settings.Categories.get_Item(BuiltInCategory.OST_Floors); categories.Insert(structuralFramingCategorie); categories.Insert(floorsClassification); InstanceBinding caseTying = m_revit.Application.Create.NewInstanceBinding(categories); // Add the binding and definition to the document bool boundResult = m_revit.ActiveUIDocument.Document.ParameterBindings.Insert(information, caseTying); return(boundResult); }
public Definition GetDefinition(DefinitionGroup group) { ExternalDefinitionCreationOptions externalDefinitionCreationOptions = new ExternalDefinitionCreationOptions(this.Name, this.DataType); externalDefinitionCreationOptions.Visible = true; Definition definition = group.Definitions.get_Item(this.Name); if (definition == null) { definition = group.Definitions.Create(externalDefinitionCreationOptions); } return(definition); }
/// <summary> /// Get a external definition if there exists one, otherwise create a new one. /// </summary> /// <param name="group">Definition group</param> /// <returns>External definition</returns> protected ExternalDefinition GetOrCreateDef(DefinitionGroup group) { ExternalDefinition Bdef = group.Definitions.get_Item(m_name) as ExternalDefinition; if (Bdef == null) { ExternalDefinitionCreationOptions ExternalDefinitionCreationOptions = new ExternalDefinitionCreationOptions(m_name, SpecTypeId.ReinforcementLength); Bdef = group. Definitions.Create(ExternalDefinitionCreationOptions) as ExternalDefinition; } return(Bdef); }
public bool CreateUserDefinedParameter(ParameterInfo parameterInfo) { if (parameterInfo.ParameterIsProject) { return(false); } this.StartTransaction(); try { DefinitionGroup sharedGroup = this.GetSharedGroup(); Definition definition = sharedGroup.Definitions.get_Item(parameterInfo.ParameterName); if (definition == null) { ExternalDefinitionCreationOptions externalDefinitionCreationOptions = new ExternalDefinitionCreationOptions(parameterInfo.ParameterName, parameterInfo.ParameterType); definition = sharedGroup.Definitions.Create(externalDefinitionCreationOptions); Log.WriteLine("Create shared parameter: " + parameterInfo.ParameterName); } ElementBinding elementBinding; if (parameterInfo.ParameterForType) { elementBinding = this.m_revitApp.Create.NewTypeBinding(parameterInfo.Categories); Log.WriteLine("Binding with types"); } else { elementBinding = this.m_revitApp.Create.NewInstanceBinding(parameterInfo.Categories); Log.WriteLine("Binding with instances"); } bool flag = this.m_revitDoc.ParameterBindings.Insert(definition, elementBinding, parameterInfo.ParameterGroup); Log.WriteLine("Submit binding"); bool result; if (!flag) { this.RollbackTransaction(); result = false; return(result); } this.CommitTransaction(); result = true; return(result); } catch (System.Exception ex) { Log.WriteLine("Create shared parameter failed"); Log.WriteLine(ex.ToString()); this.RollbackTransaction(); } return(false); }
AddSharedParamsToFile() { // open the file DefinitionFile sharedParametersFile = null; try { sharedParametersFile = OpenSharedParamFile(); } catch (Exception ex) { MessageBox.Show(string.Format("Can't open Shared Parameters file. (Exception: {0})", ex.Message)); return; } // get or create our group DefinitionGroup sharedParameterGroup = sharedParametersFile.Groups.get_Item(m_paramGroupName); if (sharedParameterGroup == null) { sharedParameterGroup = sharedParametersFile.Groups.Create(m_paramGroupName); } // get or create the parameter Definition sharedParameterDefinition = sharedParameterGroup.Definitions.get_Item(m_paramName); if (sharedParameterDefinition == null) { //sharedParameterDefinition = sharedParameterGroup.Definitions.Create( m_paramName, ParameterType.Text, true ); // 2015, jeremy: 'Autodesk.Revit.DB.Definitions.Create(string, Autodesk.Revit.DB.ParameterType, bool)' is obsolete: 'This method is deprecated in Revit 2015. Use Create(Autodesk.Revit.DB.ExternalDefinitonCreationOptions) instead' ExternalDefinitionCreationOptions opt = new ExternalDefinitionCreationOptions(m_paramName, ParameterType.Text); opt.UserModifiable = true; opt.Visible = true; sharedParameterDefinition = sharedParameterGroup.Definitions.Create(opt); // 2016, jeremy } // create a category set with the wall category in it CategorySet categories = m_app.Application.Create.NewCategorySet(); Category wallCategory = m_app.ActiveUIDocument.Document.Settings.Categories.get_Item("Walls"); categories.Insert(wallCategory); // create a new instance binding for the wall categories InstanceBinding instanceBinding = m_app.Application.Create.NewInstanceBinding(categories); // add the binding m_app.ActiveUIDocument.Document.ParameterBindings.Insert(sharedParameterDefinition, instanceBinding); MessageBox.Show(string.Format("Added a shared parameter \"{0}\" that applies to Category \"Walls\".", m_paramName)); }
private bool CreateSharedParameter(string paramName, ParameterType paramType, BuiltInParameterGroup pramGroup) { var created = false; using (var trans = new Transaction(m_doc)) { try { var definitionFile = m_app.Application.OpenSharedParameterFile(); if (null != definitionFile) { trans.Start("Create a shared parameter"); var groups = definitionFile.Groups; var group = groups.get_Item("HOK Tools"); if (null == group) { group = groups.Create("HOK Tools"); } var definition = group.Definitions.get_Item(paramName); if (definition == null) { #if RELEASE2015 definition = group.Definitions.Create(paramName, paramType); #else var options = new ExternalDefinitionCreationOptions(paramName, paramType); definition = group.Definitions.Create(options); #endif } var categorySet = m_app.Application.Create.NewCategorySet(); var roomCategory = m_doc.Settings.Categories.get_Item(BuiltInCategory.OST_Rooms); categorySet.Insert(roomCategory); var instanceBinding = m_app.Application.Create.NewInstanceBinding(categorySet); var bindingMap = m_doc.ParameterBindings; var instanceBindOK = bindingMap.Insert(definition, instanceBinding, pramGroup); trans.Commit(); created = true; } } catch (Exception ex) { MessageBox.Show("Could not create the Ceiling Height parametert." + paramName + "\n" + ex.Message, "CeilingHeightUtil : CreateSharedParameter", MessageBoxButtons.OK, MessageBoxIcon.Warning); trans.RollBack(); created = false; } } return(created); }
AddSharedParamsToFile() { // open the file DefinitionFile sharedParametersFile = null; try { sharedParametersFile = OpenSharedParamFile(); } catch (Exception ex) { MessageBox.Show(string.Format("Can't open Shared Parameters file. (Exception: {0})", ex.Message)); return; } // get or create our group DefinitionGroup sharedParameterGroup = sharedParametersFile.Groups.get_Item(m_paramGroupName); if (sharedParameterGroup == null) { sharedParameterGroup = sharedParametersFile.Groups.Create(m_paramGroupName); } // get or create the parameter Definition sharedParameterDefinition = sharedParameterGroup.Definitions.get_Item(m_paramName); if (sharedParameterDefinition == null) { //sharedParameterDefinition = sharedParameterGroup.Definitions.Create( m_paramName, ParameterType.Text, true ); // 2015, jeremy: 'Autodesk.Revit.DB.Definitions.Create(string, Autodesk.Revit.DB.ParameterType, bool)' is obsolete: 'This method is deprecated in Revit 2015. Use Create(Autodesk.Revit.DB.ExternalDefinitonCreationOptions) instead' ExternalDefinitionCreationOptions opt = new ExternalDefinitionCreationOptions( m_paramName, ParameterType.Text ); opt.Visible = true; sharedParameterDefinition = sharedParameterGroup.Definitions.Create( opt ); // 2016, jeremy } // create a category set with the wall category in it CategorySet categories = m_app.Application.Create.NewCategorySet(); Category wallCategory = m_app.ActiveUIDocument.Document.Settings.Categories.get_Item("Walls"); categories.Insert(wallCategory); // create a new instance binding for the wall categories InstanceBinding instanceBinding = m_app.Application.Create.NewInstanceBinding(categories); // add the binding m_app.ActiveUIDocument.Document.ParameterBindings.Insert(sharedParameterDefinition, instanceBinding); MessageBox.Show(string.Format("Added a shared parameter \"{0}\" that applies to Category \"Walls\".", m_paramName)); }
// Previous tests: // // We also test using BuiltInCategory.OST_Walls to // demonstrate that the same technique works with system // families just as well as with standard ones. // // To test attaching shared parameters to inserted // DWG files, which generate their own category on // the fly, we also identify the category by // category name. // // The last test is for attaching shared parameters // to model groups. // //static public BuiltInCategory Target = BuiltInCategory.OST_Walls; //static public string Target = "Drawing1.dwg"; //static public BuiltInCategory Target = BuiltInCategory.OST_IOSModelGroups; // doc.Settings.Categories.get_Item returns null //static public string Target = "Model Groups"; // doc.Settings.Categories.get_Item throws an exception SystemInvalidOperationException "Operation is not valid due to the current state of the object." //static public BuiltInCategory Target = BuiltInCategory.OST_Lines; // model lines //static public BuiltInCategory Target = BuiltInCategory.OST_SWallRectOpening; // Rectangular Straight Wall Openings, case 1260656 [Add Parameters Wall Opening] public Result Execute( ExternalCommandData commandData, ref string message, ElementSet elements) { UIApplication uiapp = commandData.Application; Application app = uiapp.Application; Document doc = uiapp.ActiveUIDocument.Document; Category cat = null; // The category to define the parameter for. #region Determine model group category #if DETERMINE_MODEL_GROUP_CATEGORY List<Element> modelGroups = new List<Element>(); //Filter fType = app.Create.Filter.NewTypeFilter( typeof( Group ) ); // "Binding the parameter to the category Model Groups is not allowed" Filter fType = app.Create.Filter.NewTypeFilter( typeof( GroupType ) ); // same result "Binding the parameter to the category Model Groups is not allowed" Filter fCategory = app.Create.Filter.NewCategoryFilter( BuiltInCategory.OST_IOSModelGroups ); Filter f = app.Create.Filter.NewLogicAndFilter( fType, fCategory ); if ( 0 < doc.get_Elements( f, modelGroups ) ) { cat = modelGroups[0].Category; } #endif // DETERMINE_MODEL_GROUP_CATEGORY #endregion // Determine model group category if( null == cat ) { cat = doc.Settings.Categories.get_Item( Target ); } // Retrieve shared parameter definition file. DefinitionFile sharedParamsFile = Util .GetSharedParamsFile( app ); if( null == sharedParamsFile ) { message = "Error getting the shared params file."; return Result.Failed; } // Get or create the shared parameter group. DefinitionGroup sharedParamsGroup = sharedParamsFile.Groups.get_Item( Util.SharedParameterGroupName ); if( null == sharedParamsGroup ) { sharedParamsGroup = sharedParamsFile.Groups .Create( Util.SharedParameterGroupName ); } // Visibility of the new parameter: the // Category.AllowsBoundParameters property // determines whether a category is allowed to // have user-visible shared or project parameters. // If it is false, it may not be bound to visible // shared parameters using the BindingMap. Note // that non-user-visible parameters can still be // bound to these categories. In our case, we // make the shared parameter user visible, if // the category allows it. bool visible = cat.AllowsBoundParameters; // Get or create the shared parameter definition. Definition def = sharedParamsGroup.Definitions .get_Item( Util.SharedParameterName ); if( null == def ) { ExternalDefinitionCreationOptions opt = new ExternalDefinitionCreationOptions( Util.SharedParameterName, ParameterType.Number ); opt.Visible = visible; def = sharedParamsGroup.Definitions.Create( opt ); } if( null == def ) { message = "Error creating shared parameter."; return Result.Failed; } // Create the category set for binding and // add the category of interest to it. CategorySet catSet = app.Create.NewCategorySet(); catSet.Insert( cat ); // Bind the parameter. using( Transaction t = new Transaction( doc ) ) { t.Start( "Bind FireRating Shared Parameter" ); Binding binding = app.Create.NewInstanceBinding( catSet ); // We could check if it is already bound; if so, // Insert will apparently just ignore it. doc.ParameterBindings.Insert( def, binding ); // You can also specify the parameter group here: //doc.ParameterBindings.Insert( def, binding, // BuiltInParameterGroup.PG_GEOMETRY ); t.Commit(); } return Result.Succeeded; }
/// <summary> /// Create a new shared parameter /// </summary> /// <param name="doc">Document</param> /// <param name="cat">Category to bind the parameter definition</param> /// <param name="nameSuffix">Parameter name suffix</param> /// <param name="typeParameter">Create a type parameter? If not, it is an instance parameter.</param> /// <returns></returns> bool CreateSharedParameter( Document doc, Category cat, int nameSuffix, bool typeParameter) { Application app = doc.Application; Autodesk.Revit.Creation.Application ca = app.Create; // get or set the current shared params filename: string filename = app.SharedParametersFilename; if( 0 == filename.Length ) { string path = _filename; StreamWriter stream; stream = new StreamWriter( path ); stream.Close(); app.SharedParametersFilename = path; filename = app.SharedParametersFilename; } // get the current shared params file object: DefinitionFile file = app.OpenSharedParameterFile(); if( null == file ) { Util.ErrorMsg( "Error getting the shared params file." ); return false; } // get or create the shared params group: DefinitionGroup group = file.Groups.get_Item( _groupname ); if( null == group ) { group = file.Groups.Create( _groupname ); } if( null == group ) { Util.ErrorMsg( "Error getting the shared params group." ); return false; } // set visibility of the new parameter: // Category.AllowsBoundParameters property // indicates if a category can have user-visible // shared or project parameters. If it is false, // it may not be bound to visible shared params // using the BindingMap. Please note that // non-user-visible parameters can still be // bound to these categories. bool visible = cat.AllowsBoundParameters; // get or create the shared params definition: string defname = _defname + nameSuffix.ToString(); Definition definition = group.Definitions.get_Item( defname ); if( null == definition ) { //definition = group.Definitions.Create( defname, _deftype, visible ); // 2014 ExternalDefinitionCreationOptions opt = new ExternalDefinitionCreationOptions( defname, _deftype ); opt.Visible = visible; definition = group.Definitions.Create( opt ); // 2015 } if( null == definition ) { Util.ErrorMsg( "Error creating shared parameter." ); return false; } // create the category set containing our category for binding: CategorySet catSet = ca.NewCategorySet(); catSet.Insert( cat ); // bind the param: try { Binding binding = typeParameter ? ca.NewTypeBinding( catSet ) as Binding : ca.NewInstanceBinding( catSet ) as Binding; // we could check if it is already bound, // but it looks like insert will just ignore // it in that case: doc.ParameterBindings.Insert( definition, binding ); // we can also specify the parameter group here: //doc.ParameterBindings.Insert( definition, binding, // BuiltInParameterGroup.PG_GEOMETRY ); Debug.Print( "Created a shared {0} parameter '{1}' for the {2} category.", ( typeParameter ? "type" : "instance" ), defname, cat.Name ); } catch( Exception ex ) { Util.ErrorMsg( string.Format( "Error binding shared parameter to category {0}: {1}", cat.Name, ex.Message ) ); return false; } return true; }
public static Definition GetOrCreateSharedParamsDefinition( DefinitionGroup defGroup, ParameterType defType, string defName, bool visible) { Definition definition = defGroup.Definitions.get_Item(defName); if (null == definition) { try { //definition = defGroup.Definitions.Create(defName, defType, visible); // 'Autodesk.Revit.DB.Definitions.Create(string, Autodesk.Revit.DB.ParameterType, bool)' is obsolete: // 'This method is deprecated in Revit 2015. Use Create(Autodesk.Revit.DB.ExternalDefinitonCreationOptions) instead' // Modified code for Revit 2015 // and fixed typo in class name in Revit 2016 ExternalDefinitionCreationOptions opt = new ExternalDefinitionCreationOptions( defName, defType); opt.Visible = true; definition = defGroup.Definitions.Create(opt); } catch (Exception) { definition = null; } } return definition; }
/// <summary> /// create project parameter /// source :http://spiderinnet.typepad.com/blog/2011/05/parameter-of-revit-api-31-create-project-parameter.html /// </summary> /// <param name="app">revit application</param> /// <param name="name">revit ui application</param> /// <param name="type">parameter type</param> /// <param name="cats">category set</param> /// <param name="group">parameter group</param> /// <param name="inst">is instance variable</param> public void CreateProjectParameter(Application app, string name, ParameterType type, CategorySet cats, BuiltInParameterGroup group, bool instance) { string oriFile = app.SharedParametersFilename; string tempFile = Path.GetTempFileName() + ".txt"; using (File.Create(tempFile)) { } app.SharedParametersFilename = tempFile; ExternalDefinitionCreationOptions edc=new ExternalDefinitionCreationOptions(name, type); ExternalDefinition def = app.OpenSharedParameterFile().Groups.Create("TemporaryDefintionGroup").Definitions.Create(edc) as ExternalDefinition; app.SharedParametersFilename = oriFile; File.Delete(tempFile); Autodesk.Revit.DB.Binding binding = app.Create.NewTypeBinding(cats); if (instance) binding = app.Create.NewInstanceBinding(cats); BindingMap map = (new UIApplication(app)).ActiveUIDocument.Document.ParameterBindings; map.Insert(def, binding, group); }
/// <summary> /// Helper to get shared params definition. /// </summary> public static Definition GetOrCreateSharedParamsDefinition( DefinitionGroup defGroup, ParameterType defType, string defName, bool visible) { Definition definition = defGroup.Definitions.get_Item( defName ); if( null == definition ) { try { //definition = defGroup.Definitions.Create( defName, defType, visible ); // 2014 ExternalDefinitionCreationOptions opt = new ExternalDefinitionCreationOptions( defName, defType ); // 2015 opt.Visible = visible; definition = defGroup.Definitions.Create( opt ); // 2015 } catch( Exception ) { definition = null; } } return definition; }
private static Parameter AddParameterBase(Document doc, Element element, string parameterName, int parameterSetId, ParameterType parameterType) { Category category = element.Category; if (category == null) { Importer.TheLog.LogWarning(parameterSetId, "Can't add parameters for element with no category.", true); return null; } else if (IsDisallowedCategory(category)) { Importer.TheLog.LogWarning(parameterSetId, "Can't add parameters for category: " + category.Name, true); return null; } Guid guid; bool isElementType = (element is ElementType); DefinitionGroup definitionGroup = isElementType ? Importer.TheCache.DefinitionTypeGroup : Importer.TheCache.DefinitionInstanceGroup; KeyValuePair<string, bool> parameterKey = new KeyValuePair<string, bool>(parameterName, isElementType); bool newlyCreated = false; Definition definition = definitionGroup.Definitions.get_Item(parameterName); if (definition == null) { ExternalDefinitionCreationOptions option = new ExternalDefinitionCreationOptions(parameterName, parameterType); definition = definitionGroup.Definitions.Create(option); newlyCreated = true; } guid = (definition as ExternalDefinition).GUID; Parameter parameter = null; if (definition != null) { ElementBinding binding = null; bool reinsert = false; bool changed = false; if (!newlyCreated) { binding = doc.ParameterBindings.get_Item(definition) as ElementBinding; reinsert = (binding != null); } if (binding == null) { if (isElementType) binding = new TypeBinding(); else binding = new InstanceBinding(); } if (category != null) { if (category.Parent != null) category = category.Parent; if (!reinsert || !binding.Categories.Contains(category)) { changed = true; binding.Categories.Insert(category); } // The binding can fail if we haven't identified a "bad" category above. Use try/catch as a safety net. try { if (changed) { if (reinsert) doc.ParameterBindings.ReInsert(definition, binding, BuiltInParameterGroup.PG_IFC); else doc.ParameterBindings.Insert(definition, binding, BuiltInParameterGroup.PG_IFC); } parameter = element.get_Parameter(guid); } catch { } } } if (parameter == null) Importer.TheLog.LogError(parameterSetId, "Couldn't create parameter: " + parameterName, false); return parameter; }
void ProblemAddingParameterBindingForCategory( Document doc) { Application app = doc.Application; if( null == _spellingErrorCorrector ) { _spellingErrorCorrector = new Util.SpellingErrorCorrector( app ); } DefinitionFile sharedParametersFile = app.OpenSharedParameterFile(); DefinitionGroup group = sharedParametersFile .Groups.Create( "Reinforcement" ); //Definition def = group.Definitions.Create( // 2014 // "ReinforcementParameter", ParameterType.Text ); ExternalDefinitionCreationOptions opt = new ExternalDefinitionCreationOptions( "ReinforcementParameter", ParameterType.Text ); Definition def = group.Definitions.Create( opt ); // 2015 // To handle both ExternalDefinitonCreationOptions // and ExternalDefinitionCreationOptions: def = _spellingErrorCorrector.NewDefinition( group.Definitions, "ReinforcementParameter", ParameterType.Text ); List<BuiltInCategory> bics = new List<BuiltInCategory>(); //bics.Add(BuiltInCategory.OST_AreaRein); //bics.Add(BuiltInCategory.OST_FabricAreas); //bics.Add(BuiltInCategory.OST_FabricReinforcement); //bics.Add(BuiltInCategory.OST_PathRein); //bics.Add(BuiltInCategory.OST_Rebar); bics.Add( BuiltInCategory .OST_IOSRebarSystemSpanSymbolCtrl ); CategorySet catset = new CategorySet(); foreach( BuiltInCategory bic in bics ) { catset.Insert( doc.Settings.Categories.get_Item( bic ) ); } InstanceBinding binding = app.Create.NewInstanceBinding( catset ); doc.ParameterBindings.Insert( def, binding, BuiltInParameterGroup.PG_CONSTRUCTION ); }