//Method deletes parameters
public void RemoveSharedParameterBinding(Application app, string name, ParameterType type)
{
BindingMap map = (new UIApplication(app)).ActiveUIDocument.Document.ParameterBindings;
DefinitionBindingMapIterator it = map.ForwardIterator();
it.Reset();
Definition def = null;
while (it.MoveNext())
{
if (it.Key != null && it.Key.Name == name && type == it.Key.ParameterType)
{
def = it.Key;
break;
}
}
if (def == null)
{
sbFeedback.Append("Parameter " + name + " does not exist.\n");
}
else
{
map.Remove(def);
if (map.Contains(def))
{
sbFeedback.Append("Failed to delete parameter " + name + " for some reason.\n");
}
else
{
sbFeedback.Append("Parameter " + name + " deleted.\n");
}
}
}
/// <summary>
/// Returns a list of the objects containing
/// references to the project parameter definitions
/// </summary>
/// <param name="doc">The project document being quereied</param>
/// <returns></returns>
static List <ProjectParameterData> GetProjectParameterData(Document doc)
{
// Following good SOA practices, first validate incoming parameters
if (doc == null)
{
throw new ArgumentNullException("doc");
}
if (doc.IsFamilyDocument)
{
throw new Exception("doc can not be a family document.");
}
List <ProjectParameterData> result = new List <ProjectParameterData>();
BindingMap map = doc.ParameterBindings;
DefinitionBindingMapIterator it
= map.ForwardIterator();
it.Reset();
while (it.MoveNext())
{
ProjectParameterData newProjectParameterData = new ProjectParameterData();
newProjectParameterData.Definition = it.Key;
newProjectParameterData.Name = it.Key.Name;
newProjectParameterData.Binding = it.Current
as ElementBinding;
result.Add(newProjectParameterData);
}
return(result);
}
public static IList <SharedParameter> GetSharedParameters(Document doc)
{
IList <SharedParameter> extSharedParams = new List <SharedParameter>();
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);
// unearth the parameter's GUID
SharedParameterElement sharedParamElem =
doc.GetElement(definition.Id) as SharedParameterElement;
if (sharedParamElem == null)
{
continue;
}
SharedParameter sharedParam =
new SharedParameter(definition.Name, definition.ParameterType,
sharedParamElem.GuidValue, currBinding, definition.ParameterGroup);
extSharedParams.Add(sharedParam);
}
return(extSharedParams);
}
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>
/// Test if the Room binds a specified shared parameter
/// </summary>
/// <param name="paramName">Parameter name to be checked</param>
/// <returns>true, the definition exists, false, doesn't exist.</returns>
private bool ShareParameterExists(String paramName)
{
BindingMap bindingMap = m_document.ParameterBindings;
DefinitionBindingMapIterator iter = bindingMap.ForwardIterator();
iter.Reset();
while (iter.MoveNext())
{
Definition tempDefinition = iter.Key;
// find the definition of which the name is the appointed one
if (String.Compare(tempDefinition.Name, paramName) != 0)
{
continue;
}
// get the category which is bound
ElementBinding binding = bindingMap.get_Item(tempDefinition) as ElementBinding;
CategorySet bindCategories = binding.Categories;
foreach (Category category in bindCategories)
{
if (category.Name
== m_document.Settings.Categories.get_Item(BuiltInCategory.OST_Rooms).Name)
{
// the definition with appointed name was bound to Rooms, return true
return(true);
}
}
}
//
// return false if shared parameter doesn't exist
return(false);
}
/// <summary>
/// Checks if a parameter exists based of a name
/// </summary>
/// <param name="doc"></param>
/// <param name="paramName"></param>
/// <returns></returns>
private bool ShareParameterExists(Document doc, String paramName)
{
BindingMap bindingMap = doc.ParameterBindings;
DefinitionBindingMapIterator iter = bindingMap.ForwardIterator();
iter.Reset();
while (iter.MoveNext())
{
Definition tempDefinition = iter.Key;
// find the definition of which the name is the appointed one
if (String.Compare(tempDefinition.Name, paramName) != 0)
{
continue;
}
// get the category which is bound
ElementBinding binding = bindingMap.get_Item(tempDefinition) as ElementBinding;
CategorySet bindCategories = binding.Categories;
foreach (Category category in bindCategories)
{
if (category.Name
== doc.Settings.Categories.get_Item(BuiltInCategory.OST_Rebar).Name)
{
return(true);
}
}
}
return(false);
}
static public bool IsParameterInProject(Document doc, string parameterName, BuiltInCategory cat)
{
Category category = doc.Settings.Categories.get_Item(cat);
BindingMap map = doc.ParameterBindings;
DefinitionBindingMapIterator it = map.ForwardIterator();
bool result = false;
it.Reset();
while (it.MoveNext())
{
result = result || (it.Key.Name == parameterName && (it.Current as ElementBinding).Categories.Contains(category));
}
return(result);
}
//Shared Parameters
//-----------------
public static bool CheckCreateProjectParameter(Document doc, string param, BuiltInCategory bicCheck)
{
try
{
BindingMap map = doc.ParameterBindings;
DefinitionBindingMapIterator it = map.ForwardIterator();
it.Reset();
Category cat = Category.GetCategory(doc, bicCheck);
CategorySet catSet = new CategorySet();
catSet.Insert(Category.GetCategory(doc, bicCheck));
ElementBinding eb = null;
while (it.MoveNext())
{
if (param == it.Key.Name)
{
eb = it.Current as ElementBinding;
if (eb.Categories.Contains(cat))
{
return(true);
}
}
}
Transaction trans = new Transaction(doc);
try
{
trans.Start("Project Parameters");
CreateSharedProjectParameters(doc, param, catSet);
trans.Commit();
return(true);
}
catch (Exception ex)
{
trans.RollBack();
throw new Exception("Exception in Create Shared Parameters" + ex.Message);
}
}
catch (Exception ex)
{
throw new Exception("Exception in Check Project Parameter.\n" + ex);
}
}
static private ElementBinding GetParameterBinding(Document doc, string parameterName)
{
BindingMap map = doc.ParameterBindings;
DefinitionBindingMapIterator it = map.ForwardIterator();
it.Reset();
while (it.MoveNext())
{
if (it.Key.Name == parameterName)
{
return(it.Current as ElementBinding);
}
}
return(null);
}
protected internal static Definition GetParameterDefinition(Document doc, string name)
{
BindingMap val = doc.get_ParameterBindings();
DefinitionBindingMapIterator val2 = val.ForwardIterator();
val2.Reset();
while (val2.MoveNext())
{
InternalDefinition val3 = val2.get_Key();
if (val3.get_Name().Equals(name))
{
return(val3);
}
}
return(null);
}
static List <RoomProjectParametersData> GetRoomProjectParametersData(Document doc)
{
// Following good SOA practices, first validate incoming parameters
if (doc == null)
{
throw new ArgumentNullException("doc");
}
if (doc.IsFamilyDocument)
{
throw new Exception("This plugin cannot be run on a family document.");
}
List <RoomProjectParametersData> result
= new List <RoomProjectParametersData>();
BindingMap map = doc.ParameterBindings;
DefinitionBindingMapIterator it
= map.ForwardIterator();
it.Reset();
while (it.MoveNext())
{
RoomProjectParametersData newProjectParameterData
= new RoomProjectParametersData();
newProjectParameterData.Binding = it.Current
as ElementBinding;
Category roomCategory = Category.GetCategory(doc, BuiltInCategory.OST_Rooms);
IEnumerable <Category> catSet = newProjectParameterData.Binding.Categories.Cast <Category>();
if (catSet.Any(c => c.Id.Equals(roomCategory.Id)) && it.Key.ParameterType == ParameterType.Text)
{
newProjectParameterData.category = roomCategory;
newProjectParameterData.Definition = it.Key;
newProjectParameterData.Name = it.Key.Name;
newProjectParameterData.type = it.Key.ParameterType;
result.Add(newProjectParameterData);
}
}
return(result);
}
public ParameterListForm(UIApplication revitUiApp, DataSet dataSet) : this()
{
this.m_revitUiApp = revitUiApp;
this.m_revitApp = revitUiApp.Application;
this.m_tableInfoSet = Command.TableInfoSet;
this.m_parameterCreation = new ParameterCreation(revitUiApp);
this.m_dataSet = dataSet;
this.parameterListBox.DisplayMember = "ParameterName";
this.parameterListBox.Sorted = true;
DefinitionBindingMapIterator definitionBindingMapIterator = this.m_revitUiApp.ActiveUIDocument.Document.ParameterBindings.ForwardIterator();
definitionBindingMapIterator.Reset();
while (definitionBindingMapIterator.MoveNext())
{
Definition key = definitionBindingMapIterator.Key;
string name = key.Name;
if (!this.ParameterExists(name))
{
this.parameterListBox.Items.Add(name);
}
}
}
public static List <RawProjectParameterInfo> RawGetProjectParametersInfo(Document doc)
{
RawProjectParameterInfo.FileName = doc.Title;
List <RawProjectParameterInfo> paramList = new List <RawProjectParameterInfo>();
BindingMap map = doc.ParameterBindings;
DefinitionBindingMapIterator it = map.ForwardIterator();
it.Reset();
while (it.MoveNext())
{
ElementBinding eleBinding = it.Current as ElementBinding;
InstanceBinding insBinding = eleBinding as InstanceBinding;
Definition def = it.Key;
if (def != null)
{
ExternalDefinition extDef = def as ExternalDefinition;
bool shared = extDef != null;
RawProjectParameterInfo param = new RawProjectParameterInfo
{
Name = def.Name,
Group = def.ParameterGroup,
Type = def.ParameterType,
ReadOnly = true, // def.IsReadOnly, def.IsReadOnly NOT working in either 2015 or 2014 but working in 2013
BoundToInstance = insBinding != null,
BoundCategories = RawConvertSetToList <Category>(eleBinding.Categories).Select(c => c.Name).ToArray(),
FromShared = shared,
GUID = shared ? extDef.GUID.ToString() : string.Empty,
Owner = shared ? extDef.OwnerGroup.Name : string.Empty,
Visible = shared ? extDef.Visible : true,
};
paramList.Add(param);
}
}
return(paramList);
}
/// <summary>
/// Method to retrieve filtered project parameters ID by category
/// </summary>
/// <param name="doc"></param>
/// <param name="category"></param>
/// <returns></returns>
public static string[] ProjectParameters(Document doc, string categoryName)
{
List <string> parametersID = new List <string>();
BindingMap map = doc.ParameterBindings;
DefinitionBindingMapIterator it = map.ForwardIterator();
it.Reset();
while (it.MoveNext())
{
ElementBinding eleBinding = it.Current as ElementBinding;
InstanceBinding insBinding = eleBinding as InstanceBinding;
if (insBinding != null && IsInstBindingOfCategory(insBinding, categoryName))
{
Definition def = it.Key;
if (def != null)
{
ExternalDefinition extDef = def as ExternalDefinition;
if (extDef != null)
{
string GUID = extDef.GUID.ToString();
parametersID.Add(GUID);
}
else
{
InternalDefinition intDef = def as InternalDefinition;
string ID = intDef.Id.ToString();
parametersID.Add(ID);
}
}
}
}
return(parametersID.ToArray());
}
private void AddSharedParameters(Application app, Document doc, CategorySet myCategorySet)
{
//Save the previous shared param file path
string previousSharedParam = app.SharedParametersFilename;
//Extract shared param to a txt file
string tempPath = System.IO.Path.GetTempPath();
string SPPath = Path.Combine(tempPath, "FileProperties.txt");
if (!File.Exists(SPPath))
{
//extract the familly
List <string> files = new List <string>();
files.Add("FileProperties.txt");
Tools.ExtractEmbeddedResource(tempPath, "TimeStamp.Resources", files);
}
//set the shared param file
app.SharedParametersFilename = SPPath;
//Retrive shared parameters
DefinitionFile myDefinitionFile = app.OpenSharedParameterFile();
DefinitionGroup definitionGroup = myDefinitionFile.Groups.get_Item("FileProperties");
foreach (Definition paramDef in definitionGroup.Definitions)
{
// Get the BingdingMap of current document.
BindingMap bindingMap = doc.ParameterBindings;
//the parameter does not exist
if (!bindingMap.Contains(paramDef))
{
//Create an instance of InstanceBinding
InstanceBinding instanceBinding = app.Create.NewInstanceBinding(myCategorySet);
bindingMap.Insert(paramDef, instanceBinding, BuiltInParameterGroup.PG_IDENTITY_DATA);
}
//the parameter is not added to the correct categories
else if (bindingMap.Contains(paramDef))
{
InstanceBinding currentBinding = bindingMap.get_Item(paramDef) as InstanceBinding;
currentBinding.Categories = myCategorySet;
bindingMap.ReInsert(paramDef, currentBinding, BuiltInParameterGroup.PG_IDENTITY_DATA);
}
}
//SetAllowVaryBetweenGroups for these parameters
string[] parameterNames = { "BIM42_Date", "BIM42_Version", "BIM42_File", "BIM42_Discipline" };
DefinitionBindingMapIterator definitionBindingMapIterator = doc.ParameterBindings.ForwardIterator();
definitionBindingMapIterator.Reset();
while (definitionBindingMapIterator.MoveNext())
{
InternalDefinition paramDef = definitionBindingMapIterator.Key as InternalDefinition;
if (paramDef != null)
{
if (parameterNames.Contains(paramDef.Name))
{
paramDef.SetAllowVaryBetweenGroups(doc, true);
}
}
}
//Reset to the previous shared parameters text file
app.SharedParametersFilename = previousSharedParam;
File.Delete(SPPath);
}
//private ParameterElement projectleider { get; set; }
public Result Execute(
ExternalCommandData commandData,
ref string message,
ElementSet elements)
{
NewProjects newProjects = new NewProjects();
ProjectInformation information = new ProjectInformation(); // ProjectInformation Dialog
information.OK += delegate
{
var templateFileName = @"C:\Users\Appie\Desktop\TestTemplate.rte";
var file = $"{information.FilePath}\\{information.FileName}";
var app = commandData?.Application?.Application;
var activeDoc = app.NewProjectDocument(templateFileName);
ActiveDocument = activeDoc;
var date = DateTime.Now.ToString("dd/MM/yyyy");
using (new TransactionManager.TransactionManager(activeDoc))
{
activeDoc.ProjectInformation.Name = information.ProjectName;
activeDoc.ProjectInformation.Number = information.TotalProjectNumber;
activeDoc.ProjectInformation.BuildingName = information.BuildingName;
activeDoc.ProjectInformation.Author = Environment.UserName;
activeDoc.ProjectInformation.IssueDate = date;
activeDoc.ProjectInformation.ClientName = information.ClientName;
activeDoc.ProjectInformation.Address = information.Project_adress;
activeDoc.ProjectInformation.Status = "Concept";
activeDoc.ProjectInformation.OrganizationName = information.OrganizationName;
activeDoc.ProjectInformation.OrganizationDescription = information.OrganizationDesc;
// activeDoc.GetElement("").GetParameters("")[0].SetValueString("");
if (activeDoc == null)
{
throw new ArgumentNullException("doc");
}
if (activeDoc.IsFamilyDocument)
{
throw new Exception("doc can not be a family document.");
}
List <ProjectParameterData> result = new List <ProjectParameterData>();
BindingMap map = activeDoc.ParameterBindings;
DefinitionBindingMapIterator it
= map.ForwardIterator();
it.Reset();
while (it.MoveNext())
{
ProjectParameterData newProjectParameterData = new ProjectParameterData();
newProjectParameterData.Definition = it.Key;
newProjectParameterData.Name = it.Key.Name;
newProjectParameterData.Binding = it.Current
as ElementBinding;
result.Add(newProjectParameterData);
}
}
activeDoc.SaveAs(file);
commandData.Application.OpenAndActivateDocument(file);
};
newProjects.ProjectInformation = information;
newProjects.ShowDialog();
return(Result.Succeeded);
}
public ElementBinding Add(Document document, string name, IEnumerable <BuiltInCategory> builtInCategories, BuiltInParameterGroup builtInParameterGroup, bool instance)
{
if (document == null || document.ParameterBindings == null || string.IsNullOrWhiteSpace(name) || builtInCategories == null || builtInCategories.Count() == 0)
{
return(null);
}
ElementBinding result = null;
DefinitionBindingMapIterator definitionBindingMapIterator = document?.ParameterBindings?.ForwardIterator();
if (definitionBindingMapIterator != null)
{
definitionBindingMapIterator.Reset();
while (definitionBindingMapIterator.MoveNext())
{
Definition definition_Temp = definitionBindingMapIterator.Key as Definition;
if (definition_Temp == null)
{
continue;
}
//if (aExternalDefinition.GUID.Equals(pExternalDefinition.GUID))
if (definition_Temp.Name.Equals(name))
{
result = (ElementBinding)definitionBindingMapIterator.Current;
break;
}
}
}
if (result != null)
{
return(result);
}
Definition definition = Find(name);
if (definition == null)
{
return(null);
}
CategorySet categorySet = Revit.Create.CategorySet(document, builtInCategories);
if (categorySet == null || categorySet.Size == 0)
{
return(null);
}
if (result != null)
{
}
else
{
if (instance)
{
result = document.Application.Create.NewInstanceBinding(categorySet);
}
else
{
result = document.Application.Create.NewTypeBinding(categorySet);
}
document.ParameterBindings.Insert(definition, result, builtInParameterGroup);
}
return(result);
}