RevitNetAddinWizard & NavisworksNetAddinWizard

Parameter of Revit API – 34: Extensions to BindingMap

Keen readers may have noticed that in the previous post some code methods are not really in the BindingMap class. Sorry for that. They are some extensions to the BindingMap class.

Revit Parameter Organizer can organize various Revit parameters such as Shared Parameters, Family Parameters, Project Parameters and Built-in Parameter in many good ways.

Here they are, along with some more extension methods not used yet:

public static bool IsInstance(this Binding binding)
{
    return (binding as InstanceBinding) != null;
}

public static CategorySet GetCategories(this Binding binding)
{
    if (binding.IsInstance())
        return (binding as InstanceBinding).Categories;
    else
        return (binding as TypeBinding).Categories;
}

public static Autodesk.Revit.DB.Definition GetDefiniton(this BindingMap map, string name)
{
    DefinitionBindingMapIterator it = map.ForwardIterator();
    it.Reset();
    while (it.MoveNext())
    {
        if (it.Key.Name == name)
        {
            return it.Key;
        }
    }

    return null;
}

public static Autodesk.Revit.DB.Binding GetBinding(this BindingMap map, string name)
{
    DefinitionBindingMapIterator it = map.ForwardIterator();
    it.Reset();
    while (it.MoveNext())
    {
        if (it.Key.Name == name)
        {
            return it.Current as Autodesk.Revit.DB.Binding;
        }
    }

    return null;
}

public static KeyValuePair<Autodesk.Revit.DB.Definition, Autodesk.Revit.DB.Binding> GetDefinitonBindingPair(this BindingMap map, string name)
{
    DefinitionBindingMapIterator it = map.ForwardIterator();
    it.Reset();
    while (it.MoveNext())
    {
        if (it.Key.Name == name)
        {
            return new KeyValuePair<Definition, Binding>(it.Key, it.Current as Autodesk.Revit.DB.Binding);
        }
    }

    return new KeyValuePair<Definition,Binding>(null, null);
}

public static void TruelyClear(this BindingMap map)
{
    DefinitionBindingMapIterator it = map.ForwardIterator();
    it.Reset();
    while (it.MoveNext())
    {
        map.Remove(it.Key);
    }
}

Just a kind reminder in case: please put these extension methods into a public static class and import its namespace into the source that you’d like to use them. Enjoy!

ProjectParameter Extensioner of Revit Addin Coder will create them automatically into where we want them to be in no time.

Parameter of Revit API – 33: Redefine Project Parameter

Many times we’d like to redefine, rebind, or replace some exisitng project parameters. In this post, we will talk about what can be done, how to achieve it with the Revit API, and what can not be done.

Revit Parameter Organizer can organize various Revit parameters such as Shared Parameters, Family Parameters, Project Parameters and Built-in Parameter in many good ways.

Can we redefine an project parameter which is defined from a shared parameter?
Yes, supposing the shared parameter definition is still there in the DefinitionGroup and in turn in the DefinitionFile:

        public static void RawReplaceProjectParameterWithExistingSharedParameter(RvtApplication app, string name, CategorySet cats, BuiltInParameterGroup group, bool inst)
        {
            DefinitionFile defFile = app.OpenSharedParameterFile();
            if (defFile == null) throw new Exception("No SharedParameter File!");

            var v = (from DefinitionGroup dg in defFile.Groups
                     from ExternalDefinition d in dg.Definitions
                     where d.Name == name
                     select d);
            if (v == null || v.Count() < 1) throw new Exception("Invalid Name Input!");

            ExternalDefinition def = v.First();

            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.ReInsert(def, binding, group);
        }

Can we update the categories only of an existing project parameter regardless of where it is defined from (project or shared parameter)?

No. The following code tries its best but without any luck:

        public static void RawRecategorizeProjectParameter(RvtDocument doc, string name, CategorySet cats)
        {
            BindingMap map = doc.ParameterBindings;
            Definition def = map.GetDefiniton(name);
            Autodesk.Revit.DB.Binding binding = map.GetBinding(name);
            if (def == null || binding == null) return;

            CategorySet oriCats = null;
            if ((binding as InstanceBinding) != null)
                oriCats = (binding as InstanceBinding).Categories;
            else
                oriCats = (binding as TypeBinding).Categories;

            oriCats.Clear();
            foreach (Category cat in cats)
                oriCats.Insert(cat);

            map.ReInsert(def, binding);
        }

Can we change the binding only of an existing project parameter?
No. The following code does not seem to have anything wrong but it just can not make the job done:

        public static void RawRebindProjectParameter(RvtDocument doc, string name, CategorySet cats, BuiltInParameterGroup group, bool inst)
        {
            BindingMap map = doc.ParameterBindings;
            Definition def = map.GetDefiniton(name);
          
            Autodesk.Revit.DB.Binding binding = doc.Application.Create.NewTypeBinding(cats);
            if (inst) binding = doc.Application.Create.NewInstanceBinding(cats);

            map.ReInsert(def, binding, group);
        }

If the original shared parameter definition file is lost, can we redefining a shared project parameter? 

No. The following code, which uses the technique of temporary shared parameter definition and external file that we introduced before, can not replace the existing shared project parameter:

        public static void RawReplaceProjectParameterWithTempSharedParameter(RvtApplication 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;

            ExternalDefinition def = app.OpenSharedParameterFile().Groups.Create("TemporaryDefintionGroup").Definitions.Create(name, type, visible) 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.ReInsert(def, binding, group);
        }

The following code can test these methods:

…
//Please create the project parameter 'PrjParameter' first.
RawRecategorizeProjectParameter(CachedDoc, "PrjParameter", cats1);

//Please create the project parameter "Volume42' first.
RawRebindProjectParameter(CachedDoc, "Volume42", cats1, BuiltInParameterGroup.PG_STRUCTURAL, false);

//RawCreateProjectParameterFromExistingSharedParameter(CachedApp, "ExistingParameter1", cats1, BuiltInParameterGroup.PG_DATA, false);
RawReplaceProjectParameterWithExistingSharedParameter(CachedApp, "ExistingParameter1", cats1, BuiltInParameterGroup.PG_IFC, true);

//RawCreateProjectParameter(CachedApp, "TemporarySharedParameter", ParameterType.Text, true, cats1, BuiltInParameterGroup.PG_DATA, true);
RawReplaceProjectParameterWithTempSharedParameter(CachedApp, "TemporarySharedParameter", ParameterType.Text, true, cats1, BuiltInParameterGroup.PG_DISPLAY, false);
…

So except for the first scenario, it seems the only way is to erase the existing project parameter regardless of its origin and create a new one from a shared parameter. This time, the shared parameter can be from a real in use external definition file or a temporary one.

ProjectParameter Reshaper of Revit Addin Coder will take care of these for us.

Parameter of Revit API – 32: Erase Project Parameter

We talked about getting information of project parameters and creating them with various ways before, now let’s look at how to erase project parameters in this post.

Revit Parameter Organizer can organize various Revit parameters such as Shared Parameters, Family Parameters, Project Parameters and Built-in Parameter in many good ways.

Let’s see how to erase a specific project parameter first. In fact, we provided the method before but it’s mainly to show some misconceptions there. Here is the updated version which can specifically address a project parameter in a Revit Document of interest:

public static bool RawEraseProjectParameter(RvtDocument doc, string name, ParameterType type)
{
    BindingMap map = doc.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)
    {
        map.Remove(def);

        return true;        
    }

    return false;
}

The following test code can exercise it:
…

RawEraseProjectParameter(CachedDoc, "Volume41", ParameterType.Volume);
…

Next, is there a strightfoward API way to remove all project prameters from a Revit Document?
The BindingMap.Clear() seems to do so:

public static void RawEraseAllProjectParameters(RvtDocument doc)
{
    BindingMap map = doc.ParameterBindings;
    map.Clear();
}

The following code tests it:

…
RawEraseAllProjectParameters(CachedDoc);
…

but the following exception would occur:

Autodesk.Revit.Exceptions.InvalidOperationException
   at Autodesk.Revit.DB.BindingMap.Clear()

Q: Why?
A: No idea!

How could it be done programmatically then? People may wonder. Obviously, we have to iterate through the BindingMap of interest and remove its Bindings one by one:

public static void RawTruelyEraseAllProjectParameters(RvtDocument doc)
{
    BindingMap map = doc.ParameterBindings;
    map.TruelyClear();
}

public static void TruelyClear(this BindingMap map)
{
    DefinitionBindingMapIterator it = map.ForwardIterator();
    it.Reset();
    while (it.MoveNext())
    {
        map.Remove(it.Key);
    }
}

The following code can test the method:

…
RawTruelyEraseAllProjectParameters(CachedDoc);
…

And it works well.

ProjectParameter Eraser of RevitAddinWizard can generate the code automatically in no time.

Parameter of Revit API – 31: Create Project Parameter

Revit project parameters are different from built-in parameters (BuiltInParameter), family parameters (FamilyParameter), and shared parameters. Project parameters may relate to shared parameters in some way as talked about previously.

Revit Parameter Organizer can organize various Revit parameters such as Shared Parameters, Family Parameters, Project Parameters and Built-in Parameter in many good ways.

As can be seen from the Project Parameters dialog in Revit, project parameters can be defined from both ‘project parameters’ themselves and shared parameters.

The former is not achievable programmatically due to the fact that InternalDefinition or native Parameter cannot be created with the Revit API. Though there is an InternalDefinitions.Create() method in the API and it looks like being supposed to fulfill the task but the point is that nowhere and no way to get an instance of InternalDefinitions.

The latter is doable programmatically through different ways, from existing shared parameters, from newly created shared parameters, or from temporary shared parameters in some temporary external definition files. In fact, in the post of Parameter of Revit API – 25: Attach Shared Parameter, we have already introduced the first approach, creating a project parameter from an existing shared parameter or attaching a shared parameter to some categories (indirectly to elements).

Revit Parameter Organizer can organize various Revit parameters such as Shared Parameters, Family Parameters, Project Parameters and Built-in Parameter in many good ways.

In this post, let’s append that method again here along with the two more methods to make the story complete.

public static void RawCreateProjectParameterFromExistingSharedParameter(RvtApplication app, string name, CategorySet cats, BuiltInParameterGroup group, bool inst)
{
    DefinitionFile defFile = app.OpenSharedParameterFile();
    if (defFile == null) throw new Exception("No SharedParameter File!");

    var v = (from DefinitionGroup dg in defFile.Groups
             from ExternalDefinition d in dg.Definitions
             where d.Name == name
             select d);
    if (v == null || v.Count() < 1) throw new Exception("Invalid Name Input!");

    ExternalDefinition def = v.First();

    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 void RawCreateProjectParameterFromNewSharedParameter(RvtApplication app, string defGroup, string name, ParameterType type, bool visible, CategorySet cats, BuiltInParameterGroup paramGroup, bool inst)
{
    DefinitionFile defFile = app.OpenSharedParameterFile();
    if (defFile == null) throw new Exception("No SharedParameter File!");

    ExternalDefinition def = app.OpenSharedParameterFile().Groups.Create(defGroup).Definitions.Create(name, type, visible) as ExternalDefinition;

    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, paramGroup);
}

public static void RawCreateProjectParameter(RvtApplication app, string name, ParameterType type, bool visible, CategorySet cats, BuiltInParameterGroup group, bool inst)
{
    //InternalDefinition def = new InternalDefinition();
    //Definition def = new Definition();

    string oriFile = app.SharedParametersFilename;
    string tempFile = Path.GetTempFileName() + ".txt";
    using (File.Create(tempFile)) { }
    app.SharedParametersFilename = tempFile;

    ExternalDefinition def = app.OpenSharedParameterFile().Groups.Create("TemporaryDefintionGroup").Definitions.Create(name, type, visible) 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);
}

It may be worth of a few more words about the third method. It creates a temporary shared parameter file and switch the current shared parameter file over regardless of what it is, creates the named shared parameter in a temporary DefinitionGroup, creates a type binding or instance binding accordingly for the shared parameter, adds the Binding to the BindingMap got from the ParameterBindings property of the Revit Document of concern, and finally switches back to the original shared parameter file.

The following test code can be used to exercise the help methods:

…
Category wall = CachedDoc.Settings.Categories.get_Item(BuiltInCategory.OST_Walls);
Category door = CachedDoc.Settings.Categories.get_Item(BuiltInCategory.OST_Doors);
CategorySet cats1 = CachedApp.Create.NewCategorySet();
cats1.Insert(wall);
cats1.Insert(door);

RawCreateProjectParameterFromExistingSharedParameter(CachedApp, "ExistingParameter1", cats1, BuiltInParameterGroup.PG_DATA, false);
RawCreateProjectParameterFromNewSharedParameter(CachedApp, "NewDefinitionGroup1", "NewParameter1", ParameterType.Text, true, cats1, BuiltInParameterGroup.PG_DATA, false);
RawCreateProjectParameter(CachedApp, "TemporarySharedParameter", ParameterType.Text, true, cats1, BuiltInParameterGroup.PG_DATA, true);
…

ProjectParameter Creator of Revit .NET Addin Wizard can help create the code automatically in a configurable and flexible way in a second. 
 

Shopping
Support
Query
More

Parameter of Revit API – 30: Project Parameter Information

Project parameters refer to those parameters that have been associated with some categories in a particular project model. They are ready to use by the Revit elements tied in with those categories. From user perspective, they will show up in the Element Properties dialog if the parameters are designed to be visible; from programmer perspective, they can be accessed from the Parameters collection of the elements of interest.

Revit Parameter Organizer can organize various Revit parameters such as Shared Parameters, Family Parameters, Project Parameters and Built-in Parameter in many good ways.

Project parameters really confuse people sometimes. A few questions may come in mind, for example:

1. Does each of them map to a BuiltInParameter?
2. Are they Shared Parameters?
3. Any tie between Project Parameters and Shared Parameters?
4. Do they have anything to do with FamilyParameter?
5. How are they associated with categories or elements?
6. Is there really a Project Parameter thing?

A1: No. Project parameter has nothing to do with BuiltInParameter. Rather we can think them as non-built-in parameters. They share some common characters though, the most important of which is both of them have been associated with certain elements of certain project models through categories.

A2: They could be if seen from some point of view. As can be seen from the Project Parameters user interface in Revit, Shared Parameters can be bound to the current project model to become Project Parameters. But from the accuracy point  of view, the answer is NO. Project Parameter does not equal to Shared Parameter. Shared Parameters are like a ware house or a repository for building up some other parameters, I would say. Another example: FamilyParameter can also be defined from Shared Parameter but we should not mistake one with another either in this case.

A3: If a Project Parameter is defined from a Shared Parameter as mentioned above, some ties such as GUID and Visibility should be still somewhere but it will test our patience and intelligence to seek them. We will elaborate what this exactly means with the assistance of some code examples and use cases later.

A4: No, not at all. I would say they are counterparts though, one of which addresses Project Model and the other Family Model.

A5: Through the BindingMap, ElementBinding, InstanceBinding and TypeBinding. We will demonstrate these in detail with code later.

A6. It depends. From user perspective, YES. As mentioned a bit earlier, there is a Project Parameters interface in Revit. However, it’s also confusing. If the Add sub dialog is opened, two options will be found, one of which is the Project Parameter itself (No recursive/cross reference issues at all?!), and the other is Shared Parameter. From programmer perspective, NO. There is not a ProjectParameter class in the API, not like FamilyParameter or Parameter. But we do have a way to find them as mentioned in the A5 and demonstrated in the following code.

public class RawProjectParameterInfo
{
    public static string FileName { get; set; }

    public string Name { get; set; }
    public BuiltInParameterGroup Group { get; set; }
    public ParameterType Type { get; set; }
    public bool ReadOnly { get; set; }
    public bool BoundToInstance { get; set; }
    public string[] BoundCategories { get; set; }

    public bool FromShared { get; set; }
    public string GUID { get; set; }
    public string Owner { get; set; }
    public bool Visible { get; set; }
}

public static List<T> RawConvertSetToList<T>(IEnumerable set)
{
    List<T> list = (from T p in set select p).ToList<T>();
    return list;
}

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 = def.IsReadOnly,
                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;
}

And the following code will convert the informative object List into a single string:

public static string RawParametersInfoToCSVString(List<RawProjectParameterInfo> infoList, ref string title)
{

    StringBuilder sb = new StringBuilder();
    PropertyInfo[] propInfoArray = typeof(RawProjectParameterInfo).GetProperties();
    foreach (PropertyInfo pi in propInfoArray)
    {
        title += pi.Name + ",";
    }
    title = title.Remove(title.Length - 1);

    foreach (RawProjectParameterInfo info in infoList)
    {
        foreach (PropertyInfo pi in propInfoArray)
        {
            object obj = info.GetType().InvokeMember(pi.Name, BindingFlags.GetProperty, null, info, null);
            IList list = obj as IList;
            if (list != null)
            {
                string str = string.Empty;
                foreach (object e in list)
                {
                    str += e.ToString() + ";";
                }
                str = str.Remove(str.Length - 1);

                sb.Append(str + ",");
            }
            else
            {
                sb.Append((obj == null ? string.Empty : obj.ToString()) + ",");
            }
        }
        sb.Remove(sb.Length - 1, 1).Append(Environment.NewLine);
    }

    return sb.ToString();
}

Then we can write all the project parameter information of a Revit Document to a CSV file.

…
List<RawProjectParameterInfo> paramsInfo = RawGetProjectParametersInfo(CachedDoc);
using (StreamWriter sw = new StreamWriter(@"c:\temp\ProjectParametersInfo.csv"))
{
    string title = string.Empty;
    string rows = RawParametersInfoToCSVString(paramsInfo, ref title);
    sw.WriteLine(title);
    sw.Write(rows);
}
…

Finally the CSV file can be read into a spreadsheet of Excel.

 
By the way, here is what the Project Parameters window looks like in Revit regarding the particular project model:

 

 
Some keen observers may notice that the Project Parameters window misses one parameter, the ‘Volume42’ one. Good catch! It is because the Project Parameter is defined from an invisible Shared Parameter from the same sample external DefinitionFile that we demonstrated a few times before.

Again, some logical readers will ask why the FromShared column are all False then as obviously some other Project Parameters are defined from Shared Parameters too besides the ‘Volume42’ such as the ‘Area11’ and the ‘Volume41’. Good catch again! It is because once Shared Parameters are bound to categories, their ExternalDefintion objects cannot be cast back anymore! As mentioned earlier, the Shared Parameter related information should be still somewhere as verified by the fact that the parameter Volume42 is hidden in the dialog!

ProjectParameter Infoer of RevitAddinWizard can help do all of these in a configurable and flexible way in no time. 

Parameter of Revit API – 17: Generically Convert Set To List

In fact some code about this technique was already shown in an article, Parameter of Revit API – 15: Set FamilyParameter, which was posted a bit earlier. Some readers may have noticed it. 

 And this can be an addition to the three approaches of converting Set to List as introduced in another article, Parameter of Revit API – 3: Convert ParameterSet to List of Parameter, and I would vote this approach as the best so far.

Here is the generic way to do the conversion:

public static List<T> RawConvertSetToList<T>(IEnumerable set)
{
    List<T> list = (from T p in set select p).ToList<T>();
    return list;
}

The method works with any enumerable Set or Collection instances regardless they are from Revit API. The generic type T represents the data type of the members of the Set or Collection, for example, Parameter for the ParameterSet which can be retrieved from the Element.Parameters property, and FamilyParameter for the FamilyParameterSet from the FamilyManager.Parameters.

The following is a typical usage of the method:

…
    List<Parameter> list = RawConvertSetToList<Parameter>(element.Parameters);
…

We have to specify the same Parameter type twice, but that is the way the generic method, its return type, and the generic type List<T> work. Anyway it’s more concise, self explanatory and readable. We do not need to worry about the LINQ grammars anymore.

Here are some more usage examples:

…
    FamilyParameter fp = RawConvertSetToList<FamilyParameter>(fm.Parameters).
        FirstOrDefault(e => e.Definition.Name.Equals(parameterName, StringComparison.CurrentCultureIgnoreCase));
…

…
    FamilyType famType = RawConvertSetToList<FamilyType>(fm.Types).
        FirstOrDefault(e => e.Name.Equals(familyTypeName, StringComparison.CurrentCultureIgnoreCase));
…

Besides these examples, the technique actually can be applied to all Set or Collection classes. In terms of Revit API ones, a few more are listed below:

ElementSet
CitySet
CategorySet
ConnectorSet
DimensionTypeSet
ViewSet
WallTypeSet

RevitAddinWizard uses this technique in its various Parameter related coders.