How to create Tags / Markups using the API

[igor.barcelosC54YD]

I need to create tags using the API, something similar to this : 

I could do this in NavisWorks using RenderPlugin, is there something similar in Revit ? 

How can I add click events to these tags ? 

[jeremy_tammik]

You can create tags in Revit. I suggest researching that from the manual end user point of view first, before think about implementing anything programmatically. Clickable tags are not supported out of the box in Revit, afaik, but you can implement a workable solution for that using the API in case of interest. Please let us know how you wish to proceed. Thank you and good luck.

[igor.barcelosC54YD]

Hi Jeremy, thanks for your return. 

I've taken a look at the manual end user at  'Annotation Elements'. This seems promissing : https://help.autodesk.com/view/RVT/2022/ENU/?guid=Revit_API_Revit_API_Developers_Guide_Revit_Geometr...

Can you provide me some guidance towards a flexible solution ? In the near future I will also need to capture click events at those tags.

Not looking for some ready-to-use piece of code, just some directions. 

Thank you

[jeremy_tammik]

I don't know whether this will help, but it might at least provide some ideas... this is the reply from Gemini on how to implement a click event on a tag:

Alright, let's tackle the challenge of implementing a click event on a Revit BIM tag element. This is a common request, and while Revit doesn't directly expose a "click" event for tags, we can achieve the desired functionality through a combination of techniques involving IExternalEventHandler, view filters, and some clever geometry manipulation.

The Core Concept:

We'll simulate a click by detecting when the user selects a tag. We then use the selected tag's location to trigger an action. Because direct tag selection for event triggering is limited, we'll use a temporary view filter to isolate the tag and make it easily selectable. This selection will then trigger our external event.

Step-by-Step Implementation:

1. Create an External Command: This command will initiate the process. It will create a temporary view filter and subscribe to the SelectionChanged event.

C#

[Transaction(TransactionMode.Manual)]
public class TagClickCommand : IExternalCommand
{
    public Result Execute(ExternalCommandData commandData, ref string message, ElementSet elements)
    {
        UIApplication uiapp = commandData.Application;
        UIDocument uidoc = uiapp.ActiveUIDocument;
        Document doc = uidoc.Document;

        // 1. Create a temporary view filter to isolate tags.
        ViewFilter filter = CreateTagViewFilter(doc);

        // 2. Subscribe to the SelectionChanged event.
        uiapp.SelectionChanged += OnSelectionChanged;

        // 3. Store the filter ID for later deletion.
        // (Important: Store this somewhere accessible, e.g., in a class member)
        _filterId = filter.Id;  // Assuming _filterId is a class-level variable.

        TaskDialog.TaskDialog.Show("Select a Tag", "Now select a tag. The action will be triggered upon selection.");

        return Result.Succeeded;
    }

    private ElementId _filterId; // Store filter ID for later deletion

    // ... (Rest of the code below)
}

2. Create a View Filter: This filter will isolate the tags in the active view, making them easy to select.

C#

private ViewFilter CreateTagViewFilter(Document doc)
{
    // Create a new view filter
    ViewFilter filter = ViewFilter.Create(doc, "Temporary Tag Filter");

    // Define filter criteria (Category = Tags)
    FilterElementCollector collector = new FilterElementCollector(doc);
    collector.OfClass(typeof(IndependentTag)); // Or whatever tag class is relevant

    // Apply the filter to the active view.
    View activeView = doc.ActiveView;
    activeView.AddFilter(filter.Id);
    activeView.SetFilterVisibility(filter.Id, true); // Make the filter active.

    return filter;
}

3. Handle the SelectionChanged Event: This is where the magic happens. When a tag is selected, we check if it's one of our filtered tags, trigger the desired action, and clean up.

C#

private void OnSelectionChanged(object sender, SelectionChangedEventArgs e)
{
    UIApplication uiapp = sender as UIApplication;
    UIDocument uidoc = uiapp.ActiveUIDocument;
    Document doc = uidoc.Document;

    // 1. Get the selected elements.
    ICollection<ElementId> selectedIds = uidoc.Selection.GetElementIds();

    // 2. Check if any selected element is a tag and is affected by our filter
    foreach (ElementId id in selectedIds)
    {
        Element element = doc.GetElement(id);
        if (element is IndependentTag tag && IsElementInFilter(doc, element.Id, _filterId)) // Check against our filter
        {
            // 3. Unsubscribe from the event to avoid multiple triggers. (Important!)
            uiapp.SelectionChanged -= OnSelectionChanged;

            // 4. Delete the temporary filter. (Important!)
            View activeView = doc.ActiveView;
            activeView.RemoveFilter(_filterId);

            // 5. Perform your desired action here.
            // Example: Get the tagged element and do something with it.
            Element taggedElement = doc.GetElement(tag.TaggedElementId);
            TaskDialog.TaskDialog.Show("Tag Clicked!", $"Tag on {taggedElement.Name} was clicked!");

            break; // Exit loop after handling the event.
        }
    }
}

//Helper function to check if an element is affected by a filter
private bool IsElementInFilter(Document doc, ElementId elementId, ElementId filterId)
{
    FilteredElementCollector collector = new FilteredElementCollector(doc);
    collector.OfClass(typeof(IndependentTag));
    collector.WhereElementIsElementType(false); // Exclude element types
    collector.AddViewFilter(filterId);
    return collector.Contains(elementId);
}

Key Improvements and Explanations:

• Temporary View Filter: This is crucial. It ensures that only the tags are easily selectable, avoiding unintended triggers from selecting other elements.
• SelectionChanged Event: This event is used to detect the tag selection.
• Unsubscribing from the Event: Absolutely vital! Failing to unsubscribe will lead to the event handler being called multiple times, causing unexpected behavior.
• Deleting the Filter: Clean up is essential. Remove the temporary filter after the event is handled to restore the view to its original state.
• IsElementInFilter Helper Function: This function ensures that the selected tag is actually one that is affected by the temporary view filter. This helps avoid triggering the event handler for tags that might be present in the view but are not intended to be part of the "clickable" set.
• Clearer Code Structure: The code is organized into methods for better readability and maintainability.
• Example Action: The code demonstrates how to retrieve the element that the tag is associated with. You can replace this with your desired logic.

Further Refinements:

• Error Handling: Add robust error handling (try-catch blocks) to handle potential issues.
• User Feedback: Provide visual feedback to the user, such as highlighting the tag when it's selected.
• Tag Type Filtering: You can refine the view filter to target specific tag types if needed.

This approach provides a robust and practical solution to simulate click events on Revit tags. Remember to thoroughly test your implementation and adapt it to your specific requirements. Let me know if you have any further questions!