This code implements a specialized collection called `ShopFloorCanvasElements`, which inherits...

April 3, 2025 at 03:15 PM

public partial class ShopFloorCanvasElements : ObservableCollection<CanvasElement>
{
    /// <summary>
    /// Maps <c>VisibilityManager</c>'s attribute names to view models, which visibilities should be
    /// synchronized with the corresponding attribute.
    /// </summary>
    private static readonly ImmutableDictionary<string, Type> NAME_TO_TYPE = new Dictionary<string, Type>()
    {
        { nameof(VisibilityManager.AreRobotsVisible), typeof(RobotViewModel) },
        { nameof(VisibilityManager.AreNodesVisible), typeof(NodeViewModel) },
        { nameof(VisibilityManager.AreEdgesVisible), typeof(EdgeViewModel) },
        { nameof(VisibilityManager.AreNodeBoundingBoxesVisible), typeof(NodeBoundingBoxViewModel) },
        { nameof(VisibilityManager.AreEdgeBoundingBoxesVisible), typeof(EdgeBoundingBoxViewModel) },
    }.ToImmutableDictionary();

    /// <summary>
    /// Reverse of <c>NAME_TO_TYPE</c>.
    /// </summary>
    private static readonly ImmutableDictionary<Type, string> TYPE_TO_NAME = NAME_TO_TYPE
        .ToDictionary(e => e.Value, e => e.Key)
        .ToImmutableDictionary();

    public ShopFloorCanvasElements()
    {
        Visibility.PropertyChanged += VisibilityChanged;
    }

    public VisibilityManager Visibility { get; } = new();

    protected override void OnCollectionChanged(NotifyCollectionChangedEventArgs e)
    {
        base.OnCollectionChanged(e);

        IEnumerable<CanvasElement>? updateItems = null;

        switch (e.Action)
        {
            case NotifyCollectionChangedAction.Add:
            case NotifyCollectionChangedAction.Replace:
                updateItems = e.NewItems!.Cast<CanvasElement>();
                break;

            case NotifyCollectionChangedAction.Reset:
                updateItems = this;
                break;
        }

        if (updateItems is null)
            return;

        foreach (var item in updateItems)
        {
            if (TYPE_TO_NAME.TryGetValue(item.GetType(), out var prop))
                item.SetCategoryVisibility(Visibility[prop]);

            if (item is NodeViewModel node)
                node.ShowLabel = Visibility.AreNodeLabelsVisible;
            else if (item is EdgeViewModel edge)
                edge.ShowDirection = Visibility.AreEdgeDirectionsVisible;
        }
    }

    private void VisibilityChanged(object? sender, PropertyChangedEventArgs e)
    {
        if (e.PropertyName is null || e.PropertyName == nameof(VisibilityManager.IsEverythingVisible))
            return;

        var value = Visibility[e.PropertyName];

        // this property is directly mapped to a viewmodel type, update all objects of this type
        if (NAME_TO_TYPE.TryGetValue(e.PropertyName, out var type))
        {
            foreach (var elem in this)
            {
                if (elem.GetType() == type)
                    elem.SetCategoryVisibility(value);
            }

            return;
        }

        // more special cases
        switch (e.PropertyName)
        {
            case nameof(VisibilityManager.AreNodeLabelsVisible):
                foreach (var elem in this)
                {
                    if (elem is NodeViewModel node)
                        node.ShowLabel = value;
                }

                break;

            case nameof(VisibilityManager.AreEdgeDirectionsVisible):
                foreach (var elem in this)
                {
                    if (elem is EdgeViewModel edge)
                        edge.ShowDirection = value;
                }

                break;

            case nameof(VisibilityManager.IsCoordinateGridVisible):
                break;

            default:
                throw new NotImplementedException();
        }
    }

This code implements a specialized collection called ShopFloorCanvasElements, which inherits from ObservableCollection<CanvasElement>. It provides mechanisms to manage UI elements (or models) whose visibility is dynamically synchronized and updated based on changes in a VisibilityManager object.

Here's a breakdown of what the code does:

Static Fields:
- NAME_TO_TYPE: A mapping between attribute names in the VisibilityManager class (e.g., AreRobotsVisible) to their corresponding ViewModel types (like RobotViewModel, NodeViewModel, etc.).
- TYPE_TO_NAME: A reverse mapping of NAME_TO_TYPE, which maps ViewModel types back to the corresponding VisibilityManager attributes.

Constructor:
- The constructor initializes a VisibilityManager instance (exposed as a property Visibility) and binds the PropertyChanged event of the VisibilityManager to the VisibilityChanged method so that when visibility-related properties change, elements in the collection are updated accordingly.

OnCollectionChanged:
- This override reacts whenever elements in the collection are added, replaced, or reset (via methods such as Add, Clear, or Replace):
  - It determines the items being added, replaced, or updated in the collection (updateItems).
  - For each affected item, it checks if the corresponding visibility rule (TYPE_TO_NAME) exists for the item's type. If yes, it updates the visibility state (SetCategoryVisibility) for that item based on the Visibility object.
  - Special cases are handled: e.g., NodeViewModel instances are updated to show or hide their labels (ShowLabel), and EdgeViewModel instances are updated to show or hide their direction (ShowDirection).

VisibilityChanged:
- This method responds when a property in VisibilityManager changes:
  - If the property change corresponds to an entry in NAME_TO_TYPE, all elements of the associated ViewModel type are updated to match the new visibility value.
  - Special cases are handled:
    - If AreNodeLabelsVisible changes, update all NodeViewModel elements' ShowLabel property.
    - If AreEdgeDirectionsVisible changes, update all EdgeViewModel elements' ShowDirection property.
    - For unsupported properties, a NotImplementedException is thrown.

What this code achieves:

Dynamic Visibility Synchronization:
- The visibility of CanvasElement objects in the collection is managed dynamically based on the state of the VisibilityManager.
Efficient Propagation of UI Changes:
- Any changes in the visibility-related properties of the VisibilityManager automatically propagate to the relevant items in the collection.
- Only affected items are updated.
Custom Behavior for Specialized ViewModels:
- Custom behaviors are applied for specific ViewModel types:
  - NodeViewModel handles node labels.
  - EdgeViewModel handles edge directions.
- These behaviors can be extended with additional cases.
Centralized Mapping of Visibility Rules:
- The mappings in NAME_TO_TYPE and TYPE_TO_NAME centralize the correspondence between VisibilityManager fields and ViewModel types for maintainability and scalability.

In summary:

The ShopFloorCanvasElements class acts as a dynamically updating collection of UI elements or "canvas elements," where the visibility of these elements is synchronized with the state of a VisibilityManager. It is designed to work efficiently with observable collections and specialized view models that react to changes in visibility properties.

Generate your own explanations

Download our vscode extension

Read other generated explanations

Built by @thebuilderjr