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
ExternalDefinitonCreationOptions extDefCrOptns = new ExternalDefinitonCreationOptions(defName, defType);
extDefCrOptns.Visible = true;
definition = defGroup.Definitions.Create(extDefCrOptns);
}
catch (Exception)
{
definition = null;
}
}
return(definition);
}
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();
}
}
}
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'
ExternalDefinitonCreationOptions opt = new ExternalDefinitonCreationOptions(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));
}
private Autodesk.Revit.DB.Definition OpenDefinition(Autodesk.Revit.DB.DefinitionGroup defGroup, string param, ParameterType paramType)
{
ExternalDefinitonCreationOptions defOptions = new ExternalDefinitonCreationOptions(param, (ParameterType)paramType);
defOptions.Name = param;
defOptions.Type = paramType;
Definition def = null;
if (def == null)
{
def = defGroup.Definitions.Create(defOptions);
}
return(def);
}
void ProblemAddingParameterBindingForCategory(
Document doc)
{
Application app = doc.Application;
DefinitionFile sharedParametersFile
= app.OpenSharedParameterFile();
DefinitionGroup group = sharedParametersFile
.Groups.Create("Reinforcement");
//Definition def = group.Definitions.Create( // 2014
// "ReinforcementParameter", ParameterType.Text );
ExternalDefinitonCreationOptions opt
= new ExternalDefinitonCreationOptions(
"ReinforcementParameter", ParameterType.Text);
Definition def = group.Definitions.Create(opt); // 2015
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);
}
private ExternalDefinition CreateProjectParameterDefinition(string name, ParameterType type)
{
var origSharedParamFilePath = app.SharedParametersFilename;
var tempFilePath = $"{Path.GetTempFileName()}.txt";
using (File.Create(tempFilePath)) { }
this.app.SharedParametersFilename = tempFilePath;
#if (REVIT2015)
ExternalDefinitonCreationOptions opts = new ExternalDefinitonCreationOptions(name, type);
#else
var opts = new ExternalDefinitionCreationOptions(name, type);
#endif
opts.Visible = true;
var def = app.OpenSharedParameterFile().Groups.Create("Temp Parameters").Definitions.Create(opts) as ExternalDefinition;
app.SharedParametersFilename = origSharedParamFilePath;
File.Delete(tempFilePath);
return(def);
}
public static Definition GetOrCreateSharedParamsDefinition(DefinitionGroup defGroup, ParameterType defType, string defName, bool visible)
{
ExternalDefinitonCreationOptions options = new ExternalDefinitonCreationOptions(defName, defType);
options.Visible = visible;
Definition def = defGroup.Definitions.get_Item(defName);
if (null == def)
{
try
{
def = defGroup.Definitions.Create(options);
}
catch (Exception)
{
def = null;
}
}
return def;
}
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)
{
ExternalDefinitonCreationOptions option = new ExternalDefinitonCreationOptions(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);
}
private static Parameter AddParameterBase(Document doc, Element element, string parameterName, int parameterSetId, ParameterType parameterType)
{
Category category = element.Category;
if (category == null)
{
IFCImportFile.TheLog.LogWarning(parameterSetId, "Can't add parameters for element with no category.", true);
return null;
}
else if (IsDisallowedCategory(category))
{
IFCImportFile.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)
{
ExternalDefinitonCreationOptions option = new ExternalDefinitonCreationOptions(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)
IFCImportFile.TheLog.LogError(parameterSetId, "Couldn't create parameter: " + parameterName, false);
return parameter;
}
private bool AddParameter(Element element)
{
bool instanceBindOK = false;
try
{
DefinitionFile definitionFile = m_app.Application.OpenSharedParameterFile();
DefinitionGroup defGroup = definitionFile.Groups.get_Item("HOK BCF");
if (null == defGroup)
{
defGroup = definitionFile.Groups.Create("HOK BCF");
}
foreach (string defName in bcfParameters)
{
#if RELEASE2015
Parameter parameter = element.LookupParameter(defName);
#else
Parameter parameter = element.get_Parameter(defName);
#endif
if (null != parameter)
{
continue;
}
Definition definition = defGroup.Definitions.get_Item(defName);
if (null == definition)
{
#if RELEASE2015
ExternalDefinitonCreationOptions option = new ExternalDefinitonCreationOptions(defName, ParameterType.Text);
definition = defGroup.Definitions.Create(option);
#else
definition = defGroup.Definitions.Create(defName, ParameterType.Text);
#endif
}
BindingMap bindingMap = m_app.ActiveUIDocument.Document.ParameterBindings;
InstanceBinding instanceBinding = bindingMap.get_Item(definition) as InstanceBinding;
if (null != instanceBinding)
{
instanceBinding.Categories.Insert(element.Category);
instanceBindOK = bindingMap.ReInsert(definition, instanceBinding);
}
else
{
CategorySet categories = m_app.Application.Create.NewCategorySet();
categories.Insert(element.Category);
instanceBinding = m_app.Application.Create.NewInstanceBinding(categories);
instanceBindOK = bindingMap.Insert(definition, instanceBinding, BuiltInParameterGroup.PG_TEXT);
}
if (!instanceBindOK)
{
break;
}
}
}
catch (Exception ex)
{
MessageBox.Show("Failed to add project parameters for element " + element.Name + "\n" + ex.Message, "CommandForm:AddParameter", MessageBoxButtons.OK, MessageBoxIcon.Warning);
instanceBindOK = false;
}
return(instanceBindOK);
}
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
ExternalDefinitonCreationOptions extDefCrOptns = new ExternalDefinitonCreationOptions(defName, defType);
extDefCrOptns.Visible = true;
definition = defGroup.Definitions.Create(extDefCrOptns);
}
catch (Exception)
{
definition = null;
}
}
return definition;
}
private void StoreSharedParams()
{
using (Transaction trans = new Transaction(doc))
{
trans.Start("Store Shared Parameters");
try
{
string currentAssembly = System.Reflection.Assembly.GetAssembly(this.GetType()).Location;
string definitionPath = Path.GetDirectoryName(currentAssembly) + "/Resources/Mass Shared Parameters.txt";
m_app.SharedParametersFilename = definitionPath;
definitionFile = m_app.OpenSharedParameterFile();
FilteredElementCollector collector = new FilteredElementCollector(doc);
Element element = null;
List <string> activeSharedParams = new List <string>();
switch (massCategory)
{
case MassCategory.Rooms:
element = collector.OfCategory(BuiltInCategory.OST_Rooms).WhereElementIsNotElementType().ToElements().First();
activeSharedParams = roomSharedParameters;
break;
case MassCategory.Areas:
element = collector.OfCategory(BuiltInCategory.OST_Areas).WhereElementIsNotElementType().ToElements().First();
activeSharedParams = areaSharedParameters;
break;
case MassCategory.Floors:
element = collector.OfCategory(BuiltInCategory.OST_Floors).WhereElementIsNotElementType().ToElements().First();
activeSharedParams = floorSharedParameters;
break;
}
if (null != definitionFile)
{
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;
Definition definition;
foreach (string paramName in activeSharedParams)
{
definition = definitions.get_Item("Mass_" + paramName);
if (null == definition)
{
#if RELEASE2013 || RELEASE2014
Parameter param = element.get_Parameter(paramName);
definition = definitions.Create("Mass_" + param.Definition.Name, param.Definition.ParameterType);
#elif RELEASE2015
Parameter param = element.LookupParameter(paramName);
ExternalDefinitonCreationOptions options = new ExternalDefinitonCreationOptions("Mass_" + param.Definition.Name, param.Definition.ParameterType);
definition = definitions.Create(options);
#elif RELEASE2016
Parameter param = element.LookupParameter(paramName);
ExternalDefinitionCreationOptions options = new ExternalDefinitionCreationOptions("Mass_" + param.Definition.Name, param.Definition.ParameterType);
definition = definitions.Create(options);
#endif
}
if (null != definition && !defDictionary.ContainsKey(paramName))
{
defDictionary.Add(paramName, definition);
}
}
}
trans.Commit();
}
catch (Exception ex)
{
MessageBox.Show("Failed to store shared parameters.\n" + ex.Message, "Form_RoomMass:StoreSharedParams", MessageBoxButtons.OK, MessageBoxIcon.Warning);
trans.RollBack();
}
}
}
/// <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
ExternalDefinitonCreationOptions opt
= new ExternalDefinitonCreationOptions(
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 bool SetSharedPropertiesBinding(this Document document, ParameterType paramType, CategorySet categoriesForParam, string parameterName, BuiltInParameterGroup group, bool type)
#endif
{
if (categoriesForParam == null)
{
return(false);
}
if (categoriesForParam.Size == 0)
{
return(false);
}
foreach (Category cat in categoriesForParam)
{
if (cat == null)
{
return(false);
}
if (!cat.AllowsBoundParameters)
{
return(false);
}
}
var application = document.Application;
if (_definitionFile == null)
{
//ask for the location of the shared parameters file
var dialog = new OpenFileDialog();
dialog.CheckFileExists = false;
dialog.Title = "Set shared parameter file...";
dialog.ShowDialog();
string shrFilePath = dialog.FileName;
if (!String.IsNullOrEmpty(shrFilePath))
{
document.SetDefinitionFile(shrFilePath);
}
}
if (_definitionFile == null)
{
throw new Exception("Definition file must be set before creation of the new parameters.");
}
var myDefinitionFile = _definitionFile;
// Get parameter or create new one
var myGroups = myDefinitionFile.Groups;
Definition myDefinition = null;
var found = false;
foreach (var gr in myGroups)
{
foreach (var def in gr.Definitions)
{
if (def.Name != parameterName || def.ParameterType != paramType || def.ParameterGroup != @group)
{
continue;
}
myDefinition = def;
found = true;
break;
}
if (found)
{
break;
}
}
//if there is not such a parameter new one is created in default group
if (myDefinition == null)
{
var myGroup = myGroups.get_Item(DefaultGroupName) ?? myGroups.Create(DefaultGroupName);
// Create a type definition
myDefinition = myGroup.Definitions.get_Item(parameterName);
if (myDefinition == null)
{
#if Revit2015 || Revit2016
var options = new ExternalDefinitonCreationOptions(parameterName, paramType)
{
UserModifiable = editable,
Visible = visible,
GUID = id
};
myDefinition = myGroup.Definitions.Create(options);
#elif Revit2014
myDefinition = myGroup.Definitions.Create(parameterName, paramType, visible, ref id);
#else
myDefinition = myGroup.Definitions.Create(parameterName, paramType);
#endif
}
}
//Create an object of TypeBinding or InstanceBinding according to the Categories and "typeBinding" variable
// Get the BingdingMap of current document.
var bindingMap = document.ParameterBindings;
var binding = bindingMap.get_Item(myDefinition);
bool bindOk;
if (type)
{
if (binding != null)
{
TypeBinding typeBinding = binding as TypeBinding;
if (typeBinding == null)
{
throw new Exception("Parameter with this definition already exists and is bound to instances. It cannot be bound to the type at the same time");
}
foreach (Category cat in categoriesForParam)
{
typeBinding.Categories.Insert(cat);
}
bindOk = bindingMap.ReInsert(myDefinition, binding, group);
return(bindOk);
}
else
{
binding = application.Create.NewTypeBinding(categoriesForParam);
}
}
else
{
if (binding != null)
{
var instBinding = binding as InstanceBinding;
if (instBinding == null)
{
throw new Exception("Parameter with this definition already exists and is bound to types. It cannot be bound to the instance at the same time");
}
foreach (Category cat in categoriesForParam)
{
instBinding.Categories.Insert(cat);
}
bindOk = bindingMap.ReInsert(myDefinition, binding, group);
return(bindOk);
}
binding = application.Create.NewInstanceBinding(categoriesForParam);
}
// Bind the definitions to the document
bindOk = bindingMap.Insert(myDefinition, binding, group);
return(bindOk);
}
